1 files changed, 357 insertions, 272 deletions

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index b3c243b9afa5..cb1c1ab2720b 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -484,49 +484,6 @@ static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
 }
 
 /*
- * Sets the BH_Da_Mapped bit on the buffer heads corresponding to the given map.
- */
-static void set_buffers_da_mapped(struct inode *inode,
-                                   struct ext4_map_blocks *map)
-{
-        struct address_space *mapping = inode->i_mapping;
-        struct pagevec pvec;
-        int i, nr_pages;
-        pgoff_t index, end;
-
-        index = map->m_lblk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
-        end = (map->m_lblk + map->m_len - 1) >>
-                (PAGE_CACHE_SHIFT - inode->i_blkbits);
-
-        pagevec_init(&pvec, 0);
-        while (index <= end) {
-                nr_pages = pagevec_lookup(&pvec, mapping, index,
-                                          min(end - index + 1,
-                                              (pgoff_t)PAGEVEC_SIZE));
-                if (nr_pages == 0)
-                        break;
-                for (i = 0; i < nr_pages; i++) {
-                        struct page *page = pvec.pages[i];
-                        struct buffer_head *bh, *head;
-
-                        if (unlikely(page->mapping != mapping) ||
-                            !PageDirty(page))
-                                break;
-
-                        if (page_has_buffers(page)) {
-                                bh = head = page_buffers(page);
-                                do {
-                                        set_buffer_da_mapped(bh);
-                                        bh = bh->b_this_page;
-                                } while (bh != head);
-                        }
-                        index++;
-                }
-                pagevec_release(&pvec);
-        }
-}
-
-/*
  * The ext4_map_blocks() function tries to look up the requested blocks,
  * and returns if the blocks are already mapped.
  *
@@ -574,7 +531,16 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
                 up_read((&EXT4_I(inode)->i_data_sem));
 
         if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
-                int ret = check_block_validity(inode, map);
+                int ret;
+                if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
+                        /* delayed alloc may be allocated by fallocate and
+                         * coverted to initialized by directIO.
+                         * we need to handle delayed extent here.
+                         */
+                        down_write((&EXT4_I(inode)->i_data_sem));
+                        goto delayed_mapped;
+                }
+                ret = check_block_validity(inode, map);
                 if (ret != 0)
                         return ret;
         }
@@ -652,12 +618,15 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
         if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
                 ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
 
-                /* If we have successfully mapped the delayed allocated blocks,
-                 * set the BH_Da_Mapped bit on them. Its important to do this
-                 * under the protection of i_data_sem.
-                 */
-                if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
-                        set_buffers_da_mapped(inode, map);
+                if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
+                        int ret;
+delayed_mapped:
+                        /* delayed allocation blocks has been allocated */
+                        ret = ext4_es_remove_extent(inode, map->m_lblk,
+                                                    map->m_len);
+                        if (ret < 0)
+                                retval = ret;
+                }
         }
 
         up_write((&EXT4_I(inode)->i_data_sem));
@@ -680,10 +649,13 @@ static int _ext4_get_block(struct inode *inode, sector_t iblock,
         int ret = 0, started = 0;
         int dio_credits;
 
+        if (ext4_has_inline_data(inode))
+                return -ERANGE;
+
         map.m_lblk = iblock;
         map.m_len = bh->b_size >> inode->i_blkbits;
 
-        if (flags && !handle) {
+        if (flags && !(flags & EXT4_GET_BLOCKS_NO_LOCK) && !handle) {
                 /* Direct IO write... */
                 if (map.m_len > DIO_MAX_BLOCKS)
                         map.m_len = DIO_MAX_BLOCKS;
@@ -798,13 +770,13 @@ struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
         return NULL;
 }
 
-static int walk_page_buffers(handle_t *handle,
-                             struct buffer_head *head,
-                             unsigned from,
-                             unsigned to,
-                             int *partial,
-                             int (*fn)(handle_t *handle,
-                                       struct buffer_head *bh))
+int ext4_walk_page_buffers(handle_t *handle,
+                           struct buffer_head *head,
+                           unsigned from,
+                           unsigned to,
+                           int *partial,
+                           int (*fn)(handle_t *handle,
+                                     struct buffer_head *bh))
 {
         struct buffer_head *bh;
         unsigned block_start, block_end;
@@ -854,8 +826,8 @@ static int walk_page_buffers(handle_t *handle,
  * is elevated.  We'll still have enough credits for the tiny quotafile
  * write.
  */
-static int do_journal_get_write_access(handle_t *handle,
-                                       struct buffer_head *bh)
+int do_journal_get_write_access(handle_t *handle,
+                                struct buffer_head *bh)
 {
         int dirty = buffer_dirty(bh);
         int ret;
@@ -878,7 +850,7 @@ static int do_journal_get_write_access(handle_t *handle,
         return ret;
 }
 
-static int ext4_get_block_write(struct inode *inode, sector_t iblock,
+static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
                    struct buffer_head *bh_result, int create);
 static int ext4_write_begin(struct file *file, struct address_space *mapping,
                             loff_t pos, unsigned len, unsigned flags,
@@ -902,6 +874,17 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
         from = pos & (PAGE_CACHE_SIZE - 1);
         to = from + len;
 
+        if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
+                ret = ext4_try_to_write_inline_data(mapping, inode, pos, len,
+                                                    flags, pagep);
+                if (ret < 0)
+                        goto out;
+                if (ret == 1) {
+                        ret = 0;
+                        goto out;
+                }
+        }
+
 retry:
         handle = ext4_journal_start(inode, needed_blocks);
         if (IS_ERR(handle)) {
@@ -919,6 +902,7 @@ retry:
                 ret = -ENOMEM;
                 goto out;
         }
+
         *pagep = page;
 
         if (ext4_should_dioread_nolock(inode))
@@ -927,8 +911,9 @@ retry:
                 ret = __block_write_begin(page, pos, len, ext4_get_block);
 
         if (!ret && ext4_should_journal_data(inode)) {
-                ret = walk_page_buffers(handle, page_buffers(page),
-                                from, to, NULL, do_journal_get_write_access);
+                ret = ext4_walk_page_buffers(handle, page_buffers(page),
+                                             from, to, NULL,
+                                             do_journal_get_write_access);
         }
 
         if (ret) {
@@ -983,7 +968,12 @@ static int ext4_generic_write_end(struct file *file,
         struct inode *inode = mapping->host;
         handle_t *handle = ext4_journal_current_handle();
 
-        copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
+        if (ext4_has_inline_data(inode))
+                copied = ext4_write_inline_data_end(inode, pos, len,
+                                                    copied, page);
+        else
+                copied = block_write_end(file, mapping, pos,
+                                         len, copied, page, fsdata);
 
         /*
          * No need to use i_size_read() here, the i_size
@@ -1134,16 +1124,21 @@ static int ext4_journalled_write_end(struct file *file,
 
         BUG_ON(!ext4_handle_valid(handle));
 
-        if (copied < len) {
-                if (!PageUptodate(page))
-                        copied = 0;
-                page_zero_new_buffers(page, from+copied, to);
-        }
+        if (ext4_has_inline_data(inode))
+                copied = ext4_write_inline_data_end(inode, pos, len,
+                                                    copied, page);
+        else {
+                if (copied < len) {
+                        if (!PageUptodate(page))
+                                copied = 0;
+                        page_zero_new_buffers(page, from+copied, to);
+                }
 
-        ret = walk_page_buffers(handle, page_buffers(page), from,
-                                to, &partial, write_end_fn);
-        if (!partial)
-                SetPageUptodate(page);
+                ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
+                                             to, &partial, write_end_fn);
+                if (!partial)
+                        SetPageUptodate(page);
+        }
         new_i_size = pos + copied;
         if (new_i_size > inode->i_size)
                 i_size_write(inode, pos+copied);
@@ -1301,6 +1296,7 @@ static void ext4_da_page_release_reservation(struct page *page,
         struct inode *inode = page->mapping->host;
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
         int num_clusters;
+        ext4_fsblk_t lblk;
 
         head = page_buffers(page);
         bh = head;
@@ -1310,20 +1306,23 @@ static void ext4_da_page_release_reservation(struct page *page,
                 if ((offset <= curr_off) && (buffer_delay(bh))) {
                         to_release++;
                         clear_buffer_delay(bh);
-                        clear_buffer_da_mapped(bh);
                 }
                 curr_off = next_off;
         } while ((bh = bh->b_this_page) != head);
 
+        if (to_release) {
+                lblk = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+                ext4_es_remove_extent(inode, lblk, to_release);
+        }
+
         /* If we have released all the blocks belonging to a cluster, then we
          * need to release the reserved space for that cluster. */
         num_clusters = EXT4_NUM_B2C(sbi, to_release);
         while (num_clusters > 0) {
-                ext4_fsblk_t lblk;
                 lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +
                         ((num_clusters - 1) << sbi->s_cluster_bits);
                 if (sbi->s_cluster_ratio == 1 ||
-                    !ext4_find_delalloc_cluster(inode, lblk, 1))
+                    !ext4_find_delalloc_cluster(inode, lblk))
                         ext4_da_release_space(inode, 1);
 
                 num_clusters--;
@@ -1429,8 +1428,6 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd,
                                                 clear_buffer_delay(bh);
                                                 bh->b_blocknr = pblock;
                                         }
-                                        if (buffer_da_mapped(bh))
-                                                clear_buffer_da_mapped(bh);
                                         if (buffer_unwritten(bh) ||
                                             buffer_mapped(bh))
                                                 BUG_ON(bh->b_blocknr != pblock);
@@ -1500,9 +1497,16 @@ static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd)
         struct pagevec pvec;
         struct inode *inode = mpd->inode;
         struct address_space *mapping = inode->i_mapping;
+        ext4_lblk_t start, last;
 
         index = mpd->first_page;
         end   = mpd->next_page - 1;
+
+        start = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+        last = end << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+        ext4_es_remove_extent(inode, start, last - start + 1);
+
+        pagevec_init(&pvec, 0);
         while (index <= end) {
                 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
                 if (nr_pages == 0)
@@ -1656,15 +1660,6 @@ static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
 
                 for (i = 0; i < map.m_len; i++)
                         unmap_underlying_metadata(bdev, map.m_pblk + i);
-
-                if (ext4_should_order_data(mpd->inode)) {
-                        err = ext4_jbd2_file_inode(handle, mpd->inode);
-                        if (err) {
-                                /* Only if the journal is aborted */
-                                mpd->retval = err;
-                                goto submit_io;
-                        }
-                }
         }
 
         /*
@@ -1795,7 +1790,19 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
          * file system block.
          */
         down_read((&EXT4_I(inode)->i_data_sem));
-        if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
+        if (ext4_has_inline_data(inode)) {
+                /*
+                 * We will soon create blocks for this page, and let
+                 * us pretend as if the blocks aren't allocated yet.
+                 * In case of clusters, we have to handle the work
+                 * of mapping from cluster so that the reserved space
+                 * is calculated properly.
+                 */
+                if ((EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) &&
+                    ext4_find_delalloc_cluster(inode, map->m_lblk))
+                        map->m_flags |= EXT4_MAP_FROM_CLUSTER;
+                retval = 0;
+        } else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
                 retval = ext4_ext_map_blocks(NULL, inode, map, 0);
         else
                 retval = ext4_ind_map_blocks(NULL, inode, map, 0);
@@ -1814,6 +1821,10 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
                                 goto out_unlock;
                 }
 
+                retval = ext4_es_insert_extent(inode, map->m_lblk, map->m_len);
+                if (retval)
+                        goto out_unlock;
+
                 /* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
                  * and it should not appear on the bh->b_state.
                  */
@@ -1842,8 +1853,8 @@ out_unlock:
  * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
  * initialized properly.
  */
-static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
-                                  struct buffer_head *bh, int create)
+int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
+                           struct buffer_head *bh, int create)
 {
         struct ext4_map_blocks map;
         int ret = 0;
@@ -1917,15 +1928,29 @@ static int __ext4_journalled_writepage(struct page *page,
 {
         struct address_space *mapping = page->mapping;
         struct inode *inode = mapping->host;
-        struct buffer_head *page_bufs;
+        struct buffer_head *page_bufs = NULL;
         handle_t *handle = NULL;
-        int ret = 0;
-        int err;
+        int ret = 0, err = 0;
+        int inline_data = ext4_has_inline_data(inode);
+        struct buffer_head *inode_bh = NULL;
 
         ClearPageChecked(page);
-        page_bufs = page_buffers(page);
-        BUG_ON(!page_bufs);
-        walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one);
+
+        if (inline_data) {
+                BUG_ON(page->index != 0);
+                BUG_ON(len > ext4_get_max_inline_size(inode));
+                inode_bh = ext4_journalled_write_inline_data(inode, len, page);
+                if (inode_bh == NULL)
+                        goto out;
+        } else {
+                page_bufs = page_buffers(page);
+                if (!page_bufs) {
+                        BUG();
+                        goto out;
+                }
+                ext4_walk_page_buffers(handle, page_bufs, 0, len,
+                                       NULL, bget_one);
+        }
         /* As soon as we unlock the page, it can go away, but we have
          * references to buffers so we are safe */
         unlock_page(page);
@@ -1938,11 +1963,18 @@ static int __ext4_journalled_writepage(struct page *page,
 
         BUG_ON(!ext4_handle_valid(handle));
 
-        ret = walk_page_buffers(handle, page_bufs, 0, len, NULL,
-                                do_journal_get_write_access);
+        if (inline_data) {
+                ret = ext4_journal_get_write_access(handle, inode_bh);
+
+                err = ext4_handle_dirty_metadata(handle, inode, inode_bh);
 
-        err = walk_page_buffers(handle, page_bufs, 0, len, NULL,
-                                write_end_fn);
+        } else {
+                ret = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
+                                             do_journal_get_write_access);
+
+                err = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
+                                             write_end_fn);
+        }
         if (ret == 0)
                 ret = err;
         EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
@@ -1950,9 +1982,12 @@ static int __ext4_journalled_writepage(struct page *page,
         if (!ret)
                 ret = err;
 
-        walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one);
+        if (!ext4_has_inline_data(inode))
+                ext4_walk_page_buffers(handle, page_bufs, 0, len,
+                                       NULL, bput_one);
         ext4_set_inode_state(inode, EXT4_STATE_JDATA);
 out:
+        brelse(inode_bh);
         return ret;
 }
 
@@ -2029,8 +2064,8 @@ static int ext4_writepage(struct page *page,
                 commit_write = 1;
         }
         page_bufs = page_buffers(page);
-        if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
-                              ext4_bh_delay_or_unwritten)) {
+        if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
+                                   ext4_bh_delay_or_unwritten)) {
                 /*
                  * We don't want to do block allocation, so redirty
                  * the page and return.  We may reach here when we do
@@ -2096,7 +2131,8 @@ static int ext4_da_writepages_trans_blocks(struct inode *inode)
  * mpage_da_map_and_submit to map a single contiguous memory region
  * and then write them.
  */
-static int write_cache_pages_da(struct address_space *mapping,
+static int write_cache_pages_da(handle_t *handle,
+                                struct address_space *mapping,
                                 struct writeback_control *wbc,
                                 struct mpage_da_data *mpd,
                                 pgoff_t *done_index)
@@ -2175,6 +2211,17 @@ static int write_cache_pages_da(struct address_space *mapping,
                         wait_on_page_writeback(page);
                         BUG_ON(PageWriteback(page));
 
+                        /*
+                         * If we have inline data and arrive here, it means that
+                         * we will soon create the block for the 1st page, so
+                         * we'd better clear the inline data here.
+                         */
+                        if (ext4_has_inline_data(inode)) {
+                                BUG_ON(ext4_test_inode_state(inode,
+                                                EXT4_STATE_MAY_INLINE_DATA));
+                                ext4_destroy_inline_data(handle, inode);
+                        }
+
                         if (mpd->next_page != page->index)
                                 mpd->first_page = page->index;
                         mpd->next_page = page->index + 1;
@@ -2381,7 +2428,8 @@ retry:
                  * contiguous region of logical blocks that need
                  * blocks to be allocated by ext4 and submit them.
                  */
-                ret = write_cache_pages_da(mapping, wbc, &mpd, &done_index);
+                ret = write_cache_pages_da(handle, mapping,
+                                           wbc, &mpd, &done_index);
                 /*
                  * If we have a contiguous extent of pages and we
                  * haven't done the I/O yet, map the blocks and submit
@@ -2445,7 +2493,6 @@ out_writepages:
         return ret;
 }
 
-#define FALL_BACK_TO_NONDELALLOC 1
 static int ext4_nonda_switch(struct super_block *sb)
 {
         s64 free_blocks, dirty_blocks;
@@ -2502,6 +2549,19 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
         }
         *fsdata = (void *)0;
         trace_ext4_da_write_begin(inode, pos, len, flags);
+
+        if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
+                ret = ext4_da_write_inline_data_begin(mapping, inode,
+                                                      pos, len, flags,
+                                                      pagep, fsdata);
+                if (ret < 0)
+                        goto out;
+                if (ret == 1) {
+                        ret = 0;
+                        goto out;
+                }
+        }
+
 retry:
         /*
          * With delayed allocation, we don't log the i_disksize update
@@ -2603,22 +2663,13 @@ static int ext4_da_write_end(struct file *file,
          * changes.  So let's piggyback the i_disksize mark_inode_dirty
          * into that.
          */
-
         new_i_size = pos + copied;
         if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
-                if (ext4_da_should_update_i_disksize(page, end)) {
+                if (ext4_has_inline_data(inode) ||
+                    ext4_da_should_update_i_disksize(page, end)) {
                         down_write(&EXT4_I(inode)->i_data_sem);
-                        if (new_i_size > EXT4_I(inode)->i_disksize) {
-                                /*
-                                 * Updating i_disksize when extending file
-                                 * without needing block allocation
-                                 */
-                                if (ext4_should_order_data(inode))
-                                        ret = ext4_jbd2_file_inode(handle,
-                                                                   inode);
-
+                        if (new_i_size > EXT4_I(inode)->i_disksize)
                                 EXT4_I(inode)->i_disksize = new_i_size;
-                        }
                         up_write(&EXT4_I(inode)->i_data_sem);
                         /* We need to mark inode dirty even if
                          * new_i_size is less that inode->i_size
@@ -2627,8 +2678,16 @@ static int ext4_da_write_end(struct file *file,
                         ext4_mark_inode_dirty(handle, inode);
                 }
         }
-        ret2 = generic_write_end(file, mapping, pos, len, copied,
+
+        if (write_mode != CONVERT_INLINE_DATA &&
+            ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA) &&
+            ext4_has_inline_data(inode))
+                ret2 = ext4_da_write_inline_data_end(inode, pos, len, copied,
+                                                     page);
+        else
+                ret2 = generic_write_end(file, mapping, pos, len, copied,
                                                         page, fsdata);
+
         copied = ret2;
         if (ret2 < 0)
                 ret = ret2;
@@ -2721,6 +2780,12 @@ static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
         journal_t *journal;
         int err;
 
+        /*
+         * We can get here for an inline file via the FIBMAP ioctl
+         */
+        if (ext4_has_inline_data(inode))
+                return 0;
+
         if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
                         test_opt(inode->i_sb, DELALLOC)) {
                 /*
@@ -2766,14 +2831,30 @@ static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
 
 static int ext4_readpage(struct file *file, struct page *page)
 {
+        int ret = -EAGAIN;
+        struct inode *inode = page->mapping->host;
+
         trace_ext4_readpage(page);
-        return mpage_readpage(page, ext4_get_block);
+
+        if (ext4_has_inline_data(inode))
+                ret = ext4_readpage_inline(inode, page);
+
+        if (ret == -EAGAIN)
+                return mpage_readpage(page, ext4_get_block);
+
+        return ret;
 }
 
 static int
 ext4_readpages(struct file *file, struct address_space *mapping,
                 struct list_head *pages, unsigned nr_pages)
 {
+        struct inode *inode = mapping->host;
+
+        /* If the file has inline data, no need to do readpages. */
+        if (ext4_has_inline_data(inode))
+                return 0;
+
         return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
 }
 
@@ -2840,7 +2921,7 @@ static int ext4_releasepage(struct page *page, gfp_t wait)
  * We allocate an uinitialized extent if blocks haven't been allocated.
  * The extent will be converted to initialized after the IO is complete.
  */
-static int ext4_get_block_write(struct inode *inode, sector_t iblock,
+int ext4_get_block_write(struct inode *inode, sector_t iblock,
                    struct buffer_head *bh_result, int create)
 {
         ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
@@ -2850,29 +2931,12 @@ static int ext4_get_block_write(struct inode *inode, sector_t iblock,
 }
 
 static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
-                   struct buffer_head *bh_result, int flags)
+                   struct buffer_head *bh_result, int create)
 {
-        handle_t *handle = ext4_journal_current_handle();
-        struct ext4_map_blocks map;
-        int ret = 0;
-
-        ext4_debug("ext4_get_block_write_nolock: inode %lu, flag %d\n",
-                   inode->i_ino, flags);
-
-        flags = EXT4_GET_BLOCKS_NO_LOCK;
-
-        map.m_lblk = iblock;
-        map.m_len = bh_result->b_size >> inode->i_blkbits;
-
-        ret = ext4_map_blocks(handle, inode, &map, flags);
-        if (ret > 0) {
-                map_bh(bh_result, inode->i_sb, map.m_pblk);
-                bh_result->b_state = (bh_result->b_state & ~EXT4_MAP_FLAGS) |
-                                        map.m_flags;
-                bh_result->b_size = inode->i_sb->s_blocksize * map.m_len;
-                ret = 0;
-        }
-        return ret;
+        ext4_debug("ext4_get_block_write_nolock: inode %lu, create flag %d\n",
+                   inode->i_ino, create);
+        return _ext4_get_block(inode, iblock, bh_result,
+                               EXT4_GET_BLOCKS_NO_LOCK);
 }
 
 static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
@@ -2978,10 +3042,10 @@ retry:
  * fall back to buffered IO.
  *
  * For holes, we fallocate those blocks, mark them as uninitialized
- * If those blocks were preallocated, we mark sure they are splited, but
+ * If those blocks were preallocated, we mark sure they are split, but
  * still keep the range to write as uninitialized.
  *
- * The unwrritten extents will be converted to written when DIO is completed.
+ * The unwritten extents will be converted to written when DIO is completed.
  * For async direct IO, since the IO may still pending when return, we
  * set up an end_io call back function, which will do the conversion
  * when async direct IO completed.
@@ -2999,125 +3063,120 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
         struct inode *inode = file->f_mapping->host;
         ssize_t ret;
         size_t count = iov_length(iov, nr_segs);
-
+        int overwrite = 0;
+        get_block_t *get_block_func = NULL;
+        int dio_flags = 0;
         loff_t final_size = offset + count;
-        if (rw == WRITE && final_size <= inode->i_size) {
-                int overwrite = 0;
 
-                BUG_ON(iocb->private == NULL);
+        /* Use the old path for reads and writes beyond i_size. */
+        if (rw != WRITE || final_size > inode->i_size)
+                return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
 
-                /* If we do a overwrite dio, i_mutex locking can be released */
-                overwrite = *((int *)iocb->private);
+        BUG_ON(iocb->private == NULL);
 
-                if (overwrite) {
-                        atomic_inc(&inode->i_dio_count);
-                        down_read(&EXT4_I(inode)->i_data_sem);
-                        mutex_unlock(&inode->i_mutex);
-                }
+        /* If we do a overwrite dio, i_mutex locking can be released */
+        overwrite = *((int *)iocb->private);
 
-                /*
-                 * We could direct write to holes and fallocate.
-                 *
-                 * Allocated blocks to fill the hole are marked as uninitialized
-                 * to prevent parallel buffered read to expose the stale data
-                 * before DIO complete the data IO.
-                 *
-                 * As to previously fallocated extents, ext4 get_block
-                 * will just simply mark the buffer mapped but still
-                 * keep the extents uninitialized.
-                 *
-                 * for non AIO case, we will convert those unwritten extents
-                 * to written after return back from blockdev_direct_IO.
-                 *
-                 * for async DIO, the conversion needs to be defered when
-                 * the IO is completed. The ext4 end_io callback function
-                 * will be called to take care of the conversion work.
-                 * Here for async case, we allocate an io_end structure to
-                 * hook to the iocb.
-                 */
-                iocb->private = NULL;
-                ext4_inode_aio_set(inode, NULL);
-                if (!is_sync_kiocb(iocb)) {
-                        ext4_io_end_t *io_end =
-                                ext4_init_io_end(inode, GFP_NOFS);
-                        if (!io_end) {
-                                ret = -ENOMEM;
-                                goto retake_lock;
-                        }
-                        io_end->flag |= EXT4_IO_END_DIRECT;
-                        iocb->private = io_end;
-                        /*
-                         * we save the io structure for current async
-                         * direct IO, so that later ext4_map_blocks()
-                         * could flag the io structure whether there
-                         * is a unwritten extents needs to be converted
-                         * when IO is completed.
-                         */
-                        ext4_inode_aio_set(inode, io_end);
-                }
+        if (overwrite) {
+                atomic_inc(&inode->i_dio_count);
+                down_read(&EXT4_I(inode)->i_data_sem);
+                mutex_unlock(&inode->i_mutex);
+        }
 
-                if (overwrite)
-                        ret = __blockdev_direct_IO(rw, iocb, inode,
-                                                 inode->i_sb->s_bdev, iov,
-                                                 offset, nr_segs,
-                                                 ext4_get_block_write_nolock,
-                                                 ext4_end_io_dio,
-                                                 NULL,
-                                                 0);
-                else
-                        ret = __blockdev_direct_IO(rw, iocb, inode,
-                                                 inode->i_sb->s_bdev, iov,
-                                                 offset, nr_segs,
-                                                 ext4_get_block_write,
-                                                 ext4_end_io_dio,
-                                                 NULL,
-                                                 DIO_LOCKING);
-                if (iocb->private)
-                        ext4_inode_aio_set(inode, NULL);
+        /*
+         * We could direct write to holes and fallocate.
+         *
+         * Allocated blocks to fill the hole are marked as
+         * uninitialized to prevent parallel buffered read to expose
+         * the stale data before DIO complete the data IO.
+         *
+         * As to previously fallocated extents, ext4 get_block will
+         * just simply mark the buffer mapped but still keep the
+         * extents uninitialized.
+         *
+         * For non AIO case, we will convert those unwritten extents
+         * to written after return back from blockdev_direct_IO.
+         *
+         * For async DIO, the conversion needs to be deferred when the
+         * IO is completed. The ext4 end_io callback function will be
+         * called to take care of the conversion work.  Here for async
+         * case, we allocate an io_end structure to hook to the iocb.
+         */
+        iocb->private = NULL;
+        ext4_inode_aio_set(inode, NULL);
+        if (!is_sync_kiocb(iocb)) {
+                ext4_io_end_t *io_end = ext4_init_io_end(inode, GFP_NOFS);
+                if (!io_end) {
+                        ret = -ENOMEM;
+                        goto retake_lock;
+                }
+                io_end->flag |= EXT4_IO_END_DIRECT;
+                iocb->private = io_end;
                 /*
-                 * The io_end structure takes a reference to the inode,
-                 * that structure needs to be destroyed and the
-                 * reference to the inode need to be dropped, when IO is
-                 * complete, even with 0 byte write, or failed.
-                 *
-                 * In the successful AIO DIO case, the io_end structure will be
-                 * desctroyed and the reference to the inode will be dropped
-                 * after the end_io call back function is called.
-                 *
-                 * In the case there is 0 byte write, or error case, since
-                 * VFS direct IO won't invoke the end_io call back function,
-                 * we need to free the end_io structure here.
+                 * we save the io structure for current async direct
+                 * IO, so that later ext4_map_blocks() could flag the
+                 * io structure whether there is a unwritten extents
+                 * needs to be converted when IO is completed.
                  */
-                if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
-                        ext4_free_io_end(iocb->private);
-                        iocb->private = NULL;
-                } else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
-                                                EXT4_STATE_DIO_UNWRITTEN)) {
-                        int err;
-                        /*
-                         * for non AIO case, since the IO is already
-                         * completed, we could do the conversion right here
-                         */
-                        err = ext4_convert_unwritten_extents(inode,
-                                                             offset, ret);
-                        if (err < 0)
-                                ret = err;
-                        ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
-                }
+                ext4_inode_aio_set(inode, io_end);
+        }
 
-        retake_lock:
-                /* take i_mutex locking again if we do a ovewrite dio */
-                if (overwrite) {
-                        inode_dio_done(inode);
-                        up_read(&EXT4_I(inode)->i_data_sem);
-                        mutex_lock(&inode->i_mutex);
-                }
+        if (overwrite) {
+                get_block_func = ext4_get_block_write_nolock;
+        } else {
+                get_block_func = ext4_get_block_write;
+                dio_flags = DIO_LOCKING;
+        }
+        ret = __blockdev_direct_IO(rw, iocb, inode,
+                                   inode->i_sb->s_bdev, iov,
+                                   offset, nr_segs,
+                                   get_block_func,
+                                   ext4_end_io_dio,
+                                   NULL,
+                                   dio_flags);
+
+        if (iocb->private)
+                ext4_inode_aio_set(inode, NULL);
+        /*
+         * The io_end structure takes a reference to the inode, that
+         * structure needs to be destroyed and the reference to the
+         * inode need to be dropped, when IO is complete, even with 0
+         * byte write, or failed.
+         *
+         * In the successful AIO DIO case, the io_end structure will
+         * be destroyed and the reference to the inode will be dropped
+         * after the end_io call back function is called.
+         *
+         * In the case there is 0 byte write, or error case, since VFS
+         * direct IO won't invoke the end_io call back function, we
+         * need to free the end_io structure here.
+         */
+        if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
+                ext4_free_io_end(iocb->private);
+                iocb->private = NULL;
+        } else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
+                                                EXT4_STATE_DIO_UNWRITTEN)) {
+                int err;
+                /*
+                 * for non AIO case, since the IO is already
+                 * completed, we could do the conversion right here
+                 */
+                err = ext4_convert_unwritten_extents(inode,
+                                                     offset, ret);
+                if (err < 0)
+                        ret = err;
+                ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
+        }
 
-                return ret;
+retake_lock:
+        /* take i_mutex locking again if we do a ovewrite dio */
+        if (overwrite) {
+                inode_dio_done(inode);
+                up_read(&EXT4_I(inode)->i_data_sem);
+                mutex_lock(&inode->i_mutex);
         }
 
-        /* for write the the end of file case, we fall back to old way */
-        return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
+        return ret;
 }
 
 static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
@@ -3134,6 +3193,10 @@ static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
         if (ext4_should_journal_data(inode))
                 return 0;
 
+        /* Let buffer I/O handle the inline data case. */
+        if (ext4_has_inline_data(inode))
+                return 0;
+
         trace_ext4_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
         if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
                 ret = ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs);
@@ -3531,6 +3594,14 @@ void ext4_truncate(struct inode *inode)
         if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
                 ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
 
+        if (ext4_has_inline_data(inode)) {
+                int has_inline = 1;
+
+                ext4_inline_data_truncate(inode, &has_inline);
+                if (has_inline)
+                        return;
+        }
+
         if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
                 ext4_ext_truncate(inode);
         else
@@ -3756,6 +3827,19 @@ static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
         }
 }
 
+static inline void ext4_iget_extra_inode(struct inode *inode,
+                                         struct ext4_inode *raw_inode,
+                                         struct ext4_inode_info *ei)
+{
+        __le32 *magic = (void *)raw_inode +
+                        EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize;
+        if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC)) {
+                ext4_set_inode_state(inode, EXT4_STATE_XATTR);
+                ext4_find_inline_data_nolock(inode);
+        } else
+                EXT4_I(inode)->i_inline_off = 0;
+}
+
 struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
 {
         struct ext4_iloc iloc;
@@ -3826,6 +3910,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
         set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
 
         ext4_clear_state_flags(ei);     /* Only relevant on 32-bit archs */
+        ei->i_inline_off = 0;
         ei->i_dir_start_lookup = 0;
         ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
         /* We now have enough fields to check if the inode was active or not.
@@ -3898,11 +3983,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
                         ei->i_extra_isize = sizeof(struct ext4_inode) -
                                             EXT4_GOOD_OLD_INODE_SIZE;
                 } else {
-                        __le32 *magic = (void *)raw_inode +
-                                        EXT4_GOOD_OLD_INODE_SIZE +
-                                        ei->i_extra_isize;
-                        if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
-                                ext4_set_inode_state(inode, EXT4_STATE_XATTR);
+                        ext4_iget_extra_inode(inode, raw_inode, ei);
                 }
         }
 
@@ -3925,17 +4006,19 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
                                  ei->i_file_acl);
                 ret = -EIO;
                 goto bad_inode;
-        } else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
-                if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
-                    (S_ISLNK(inode->i_mode) &&
-                     !ext4_inode_is_fast_symlink(inode)))
-                        /* Validate extent which is part of inode */
-                        ret = ext4_ext_check_inode(inode);
-        } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
-                   (S_ISLNK(inode->i_mode) &&
-                    !ext4_inode_is_fast_symlink(inode))) {
-                /* Validate block references which are part of inode */
-                ret = ext4_ind_check_inode(inode);
+        } else if (!ext4_has_inline_data(inode)) {
+                if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
+                        if ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
+                            (S_ISLNK(inode->i_mode) &&
+                             !ext4_inode_is_fast_symlink(inode))))
+                                /* Validate extent which is part of inode */
+                                ret = ext4_ext_check_inode(inode);
+                } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
+                           (S_ISLNK(inode->i_mode) &&
+                            !ext4_inode_is_fast_symlink(inode))) {
+                        /* Validate block references which are part of inode */
+                        ret = ext4_ind_check_inode(inode);
+                }
         }
         if (ret)
                 goto bad_inode;
@@ -4122,9 +4205,10 @@ static int ext4_do_update_inode(handle_t *handle,
                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
                         raw_inode->i_block[2] = 0;
                 }
-        } else
+        } else if (!ext4_has_inline_data(inode)) {
                 for (block = 0; block < EXT4_N_BLOCKS; block++)
                         raw_inode->i_block[block] = ei->i_data[block];
+        }
 
         raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
         if (ei->i_extra_isize) {
@@ -4811,8 +4895,9 @@ int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
          * journal_start/journal_stop which can block and take a long time
          */
         if (page_has_buffers(page)) {
-                if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
-                                        ext4_bh_unmapped)) {
+                if (!ext4_walk_page_buffers(NULL, page_buffers(page),
+                                            0, len, NULL,
+                                            ext4_bh_unmapped)) {
                         /* Wait so that we don't change page under IO */
                         wait_on_page_writeback(page);
                         ret = VM_FAULT_LOCKED;
@@ -4833,7 +4918,7 @@ retry_alloc:
         }
         ret = __block_page_mkwrite(vma, vmf, get_block);
         if (!ret && ext4_should_journal_data(inode)) {
-                if (walk_page_buffers(handle, page_buffers(page), 0,
+                if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
                           PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
                         unlock_page(page);
                         ret = VM_FAULT_SIGBUS;