Merge tag 'sound-3.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai...

[firefly-linux-kernel-4.4.55.git] / fs / f2fs / data.c

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 76de83e25a891d8cf85c4b84d2641dbf414a77e6..8e58c4cc2cb96519359e45d66acd34191972786f 100644 (file)
--- 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;