1 files changed, 39 insertions, 30 deletions

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 76de83e25a89..8e58c4cc2cb9 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -85,7 +85,7 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,
         bio = bio_alloc(GFP_NOIO, npages);
 
         bio->bi_bdev = sbi->sb->s_bdev;
-        bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
+        bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);
         bio->bi_end_io = is_read ? f2fs_read_end_io : f2fs_write_end_io;
         bio->bi_private = sbi;
 
@@ -193,7 +193,7 @@ void f2fs_submit_page_mbio(struct f2fs_sb_info *sbi, struct page *page,
                 __submit_merged_bio(io);
 alloc_new:
         if (io->bio == NULL) {
-                int bio_blocks = MAX_BIO_BLOCKS(max_hw_blocks(sbi));
+                int bio_blocks = MAX_BIO_BLOCKS(sbi);
 
                 io->bio = __bio_alloc(sbi, blk_addr, bio_blocks, is_read);
                 io->fio = *fio;
@@ -236,7 +236,7 @@ static void __set_data_blkaddr(struct dnode_of_data *dn, block_t new_addr)
 
 int reserve_new_block(struct dnode_of_data *dn)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+        struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 
         if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
                 return -EPERM;
@@ -258,7 +258,7 @@ int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
         int err;
 
         /* if inode_page exists, index should be zero */
-        f2fs_bug_on(!need_put && index);
+        f2fs_bug_on(F2FS_I_SB(dn->inode), !need_put && index);
 
         err = get_dnode_of_data(dn, index, ALLOC_NODE);
         if (err)
@@ -321,7 +321,7 @@ void update_extent_cache(block_t blk_addr, struct dnode_of_data *dn)
         block_t start_blkaddr, end_blkaddr;
         int need_update = true;
 
-        f2fs_bug_on(blk_addr == NEW_ADDR);
+        f2fs_bug_on(F2FS_I_SB(dn->inode), blk_addr == NEW_ADDR);
         fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
                                                         dn->ofs_in_node;
 
@@ -396,7 +396,6 @@ end_update:
 
 struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         struct address_space *mapping = inode->i_mapping;
         struct dnode_of_data dn;
         struct page *page;
@@ -429,7 +428,7 @@ struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
                 return page;
         }
 
-        err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr,
+        err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, dn.data_blkaddr,
                                         sync ? READ_SYNC : READA);
         if (err)
                 return ERR_PTR(err);
@@ -451,7 +450,6 @@ struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
  */
 struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         struct address_space *mapping = inode->i_mapping;
         struct dnode_of_data dn;
         struct page *page;
@@ -490,7 +488,8 @@ repeat:
                 return page;
         }
 
-        err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr, READ_SYNC);
+        err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,
+                                        dn.data_blkaddr, READ_SYNC);
         if (err)
                 return ERR_PTR(err);
 
@@ -517,7 +516,6 @@ repeat:
 struct page *get_new_data_page(struct inode *inode,
                 struct page *ipage, pgoff_t index, bool new_i_size)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         struct address_space *mapping = inode->i_mapping;
         struct page *page;
         struct dnode_of_data dn;
@@ -541,8 +539,8 @@ repeat:
                 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
                 SetPageUptodate(page);
         } else {
-                err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr,
-                                                                READ_SYNC);
+                err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,
+                                                dn.data_blkaddr, READ_SYNC);
                 if (err)
                         goto put_err;
 
@@ -573,10 +571,12 @@ put_err:
 
 static int __allocate_data_block(struct dnode_of_data *dn)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+        struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
+        struct f2fs_inode_info *fi = F2FS_I(dn->inode);
         struct f2fs_summary sum;
         block_t new_blkaddr;
         struct node_info ni;
+        pgoff_t fofs;
         int type;
 
         if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
@@ -599,6 +599,12 @@ static int __allocate_data_block(struct dnode_of_data *dn)
         update_extent_cache(new_blkaddr, dn);
         clear_inode_flag(F2FS_I(dn->inode), FI_NO_EXTENT);
 
+        /* update i_size */
+        fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
+                                                        dn->ofs_in_node;
+        if (i_size_read(dn->inode) < ((fofs + 1) << PAGE_CACHE_SHIFT))
+                i_size_write(dn->inode, ((fofs + 1) << PAGE_CACHE_SHIFT));
+
         dn->data_blkaddr = new_blkaddr;
         return 0;
 }
@@ -614,7 +620,6 @@ static int __allocate_data_block(struct dnode_of_data *dn)
 static int __get_data_block(struct inode *inode, sector_t iblock,
                         struct buffer_head *bh_result, int create, bool fiemap)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         unsigned int blkbits = inode->i_sb->s_blocksize_bits;
         unsigned maxblocks = bh_result->b_size >> blkbits;
         struct dnode_of_data dn;
@@ -630,8 +635,8 @@ static int __get_data_block(struct inode *inode, sector_t iblock,
                 goto out;
 
         if (create) {
-                f2fs_balance_fs(sbi);
-                f2fs_lock_op(sbi);
+                f2fs_balance_fs(F2FS_I_SB(inode));
+                f2fs_lock_op(F2FS_I_SB(inode));
         }
 
         /* When reading holes, we need its node page */
@@ -707,7 +712,7 @@ put_out:
         f2fs_put_dnode(&dn);
 unlock_out:
         if (create)
-                f2fs_unlock_op(sbi);
+                f2fs_unlock_op(F2FS_I_SB(inode));
 out:
         trace_f2fs_get_data_block(inode, iblock, bh_result, err);
         return err;
@@ -804,7 +809,7 @@ static int f2fs_write_data_page(struct page *page,
                                         struct writeback_control *wbc)
 {
         struct inode *inode = page->mapping->host;
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
         loff_t i_size = i_size_read(inode);
         const pgoff_t end_index = ((unsigned long long) i_size)
                                                         >> PAGE_CACHE_SHIFT;
@@ -846,7 +851,7 @@ write:
         if (unlikely(f2fs_cp_error(sbi))) {
                 SetPageError(page);
                 unlock_page(page);
-                return 0;
+                goto out;
         }
 
         if (!wbc->for_reclaim)
@@ -866,7 +871,7 @@ done:
 
         clear_cold_data(page);
 out:
-        inode_dec_dirty_dents(inode);
+        inode_dec_dirty_pages(inode);
         unlock_page(page);
         if (need_balance_fs)
                 f2fs_balance_fs(sbi);
@@ -892,7 +897,7 @@ static int f2fs_write_data_pages(struct address_space *mapping,
                             struct writeback_control *wbc)
 {
         struct inode *inode = mapping->host;
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
         bool locked = false;
         int ret;
         long diff;
@@ -904,7 +909,7 @@ static int f2fs_write_data_pages(struct address_space *mapping,
                 return 0;
 
         if (S_ISDIR(inode->i_mode) && wbc->sync_mode == WB_SYNC_NONE &&
-                        get_dirty_dents(inode) < nr_pages_to_skip(sbi, DATA) &&
+                        get_dirty_pages(inode) < nr_pages_to_skip(sbi, DATA) &&
                         available_free_memory(sbi, DIRTY_DENTS))
                 goto skip_write;
 
@@ -926,7 +931,7 @@ static int f2fs_write_data_pages(struct address_space *mapping,
         return ret;
 
 skip_write:
-        wbc->pages_skipped += get_dirty_dents(inode);
+        wbc->pages_skipped += get_dirty_pages(inode);
         return 0;
 }
 
@@ -945,7 +950,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
                 struct page **pagep, void **fsdata)
 {
         struct inode *inode = mapping->host;
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
         struct page *page;
         pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
         struct dnode_of_data dn;
@@ -1047,7 +1052,10 @@ static int f2fs_write_end(struct file *file,
 
         trace_f2fs_write_end(inode, pos, len, copied);
 
-        set_page_dirty(page);
+        if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
+                register_inmem_page(inode, page);
+        else
+                set_page_dirty(page);
 
         if (pos + copied > i_size_read(inode)) {
                 i_size_write(inode, pos + copied);
@@ -1092,9 +1100,6 @@ static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
         if (check_direct_IO(inode, rw, iter, offset))
                 return 0;
 
-        /* clear fsync mark to recover these blocks */
-        fsync_mark_clear(F2FS_SB(inode->i_sb), inode->i_ino);
-
         trace_f2fs_direct_IO_enter(inode, offset, count, rw);
 
         err = blockdev_direct_IO(rw, iocb, inode, iter, offset, get_data_block);
@@ -1110,8 +1115,12 @@ static void f2fs_invalidate_data_page(struct page *page, unsigned int offset,
                                       unsigned int length)
 {
         struct inode *inode = page->mapping->host;
+
+        if (offset % PAGE_CACHE_SIZE || length != PAGE_CACHE_SIZE)
+                return;
+
         if (PageDirty(page))
-                inode_dec_dirty_dents(inode);
+                inode_dec_dirty_pages(inode);
         ClearPagePrivate(page);
 }
 
@@ -1133,7 +1142,7 @@ static int f2fs_set_data_page_dirty(struct page *page)
 
         if (!PageDirty(page)) {
                 __set_page_dirty_nobuffers(page);
-                set_dirty_dir_page(inode, page);
+                update_dirty_page(inode, page);
                 return 1;
         }
         return 0;