f2fs: avoid unnecessary updating inode during fsync

[deliverable/linux.git] / fs / f2fs / file.c

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index f4c0086655c4bf448d76e017d2d6e47e0f2f6de4..23decf050236dbbb46e250872ab285565da47e97 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -171,22 +171,16 @@ static void try_to_fix_pino(struct inode *inode)
        fi->xattr_ver = 0;
        if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
                        get_parent_ino(inode, &pino)) {
-               fi->i_pino = pino;
+               f2fs_i_pino_write(inode, pino);
                file_got_pino(inode);
-               up_write(&fi->i_sem);
-
-               mark_inode_dirty_sync(inode);
-               f2fs_write_inode(inode, NULL);
-       } else {
-               up_write(&fi->i_sem);
        }
+       up_write(&fi->i_sem);
 }
 
 static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
                                                int datasync, bool atomic)
 {
        struct inode *inode = file->f_mapping->host;
-       struct f2fs_inode_info *fi = F2FS_I(inode);
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        nid_t ino = inode->i_ino;
        int ret = 0;
@@ -204,9 +198,9 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
 
        /* if fdatasync is triggered, let's do in-place-update */
        if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
-               set_inode_flag(fi, FI_NEED_IPU);
+               set_inode_flag(inode, FI_NEED_IPU);
        ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
-       clear_inode_flag(fi, FI_NEED_IPU);
+       clear_inode_flag(inode, FI_NEED_IPU);
 
        if (ret) {
                trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
@@ -214,7 +208,7 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
        }
 
        /* if the inode is dirty, let's recover all the time */
-       if (!datasync) {
+       if (!datasync && !f2fs_skip_inode_update(inode)) {
                f2fs_write_inode(inode, NULL);
                goto go_write;
        }
@@ -222,14 +216,14 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
        /*
         * if there is no written data, don't waste time to write recovery info.
         */
-       if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&
+       if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
                        !exist_written_data(sbi, ino, APPEND_INO)) {
 
                /* it may call write_inode just prior to fsync */
                if (need_inode_page_update(sbi, ino))
                        goto go_write;
 
-               if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||
+               if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
                                exist_written_data(sbi, ino, UPDATE_INO))
                        goto flush_out;
                goto out;
@@ -239,9 +233,9 @@ go_write:
         * Both of fdatasync() and fsync() are able to be recovered from
         * sudden-power-off.
         */
-       down_read(&fi->i_sem);
+       down_read(&F2FS_I(inode)->i_sem);
        need_cp = need_do_checkpoint(inode);
-       up_read(&fi->i_sem);
+       up_read(&F2FS_I(inode)->i_sem);
 
        if (need_cp) {
                /* all the dirty node pages should be flushed for POR */
@@ -252,12 +246,12 @@ go_write:
                 * will be used only for fsynced inodes after checkpoint.
                 */
                try_to_fix_pino(inode);
-               clear_inode_flag(fi, FI_APPEND_WRITE);
-               clear_inode_flag(fi, FI_UPDATE_WRITE);
+               clear_inode_flag(inode, FI_APPEND_WRITE);
+               clear_inode_flag(inode, FI_UPDATE_WRITE);
                goto out;
        }
 sync_nodes:
-       ret = fsync_node_pages(sbi, ino, &wbc, atomic);
+       ret = fsync_node_pages(sbi, inode, &wbc, atomic);
        if (ret)
                goto out;
 
@@ -279,10 +273,10 @@ sync_nodes:
 
        /* once recovery info is written, don't need to tack this */
        remove_ino_entry(sbi, ino, APPEND_INO);
-       clear_inode_flag(fi, FI_APPEND_WRITE);
+       clear_inode_flag(inode, FI_APPEND_WRITE);
 flush_out:
        remove_ino_entry(sbi, ino, UPDATE_INO);
-       clear_inode_flag(fi, FI_UPDATE_WRITE);
+       clear_inode_flag(inode, FI_UPDATE_WRITE);
        ret = f2fs_issue_flush(sbi);
        f2fs_update_time(sbi, REQ_TIME);
 out:
@@ -487,8 +481,7 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
                set_data_blkaddr(dn);
                invalidate_blocks(sbi, blkaddr);
                if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
-                       clear_inode_flag(F2FS_I(dn->inode),
-                                               FI_FIRST_BLOCK_WRITTEN);
+                       clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
                nr_free++;
        }
 
@@ -502,7 +495,6 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
                                                        dn->inode) + ofs;
                f2fs_update_extent_cache_range(dn, fofs, 0, len);
                dec_valid_block_count(sbi, dn->inode, nr_free);
-               sync_inode_page(dn);
        }
        dn->ofs_in_node = ofs;
 
@@ -638,7 +630,7 @@ int f2fs_truncate(struct inode *inode, bool lock)
                return err;
 
        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
-       mark_inode_dirty(inode);
+       mark_inode_dirty_sync(inode);
        return 0;
 }
 
@@ -654,7 +646,6 @@ int f2fs_getattr(struct vfsmount *mnt,
 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 {
-       struct f2fs_inode_info *fi = F2FS_I(inode);
        unsigned int ia_valid = attr->ia_valid;
 
        if (ia_valid & ATTR_UID)
@@ -675,7 +666,7 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 
                if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
                        mode &= ~S_ISGID;
-               set_acl_inode(fi, mode);
+               set_acl_inode(inode, mode);
        }
 }
 #else
@@ -685,7 +676,6 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 {
        struct inode *inode = d_inode(dentry);
-       struct f2fs_inode_info *fi = F2FS_I(inode);
        int err;
 
        err = inode_change_ok(inode, attr);
@@ -724,13 +714,13 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 
        if (attr->ia_valid & ATTR_MODE) {
                err = posix_acl_chmod(inode, get_inode_mode(inode));
-               if (err || is_inode_flag_set(fi, FI_ACL_MODE)) {
-                       inode->i_mode = fi->i_acl_mode;
-                       clear_inode_flag(fi, FI_ACL_MODE);
+               if (err || is_inode_flag_set(inode, FI_ACL_MODE)) {
+                       inode->i_mode = F2FS_I(inode)->i_acl_mode;
+                       clear_inode_flag(inode, FI_ACL_MODE);
                }
        }
 
-       mark_inode_dirty(inode);
+       mark_inode_dirty_sync(inode);
        return err;
 }
 
@@ -992,7 +982,7 @@ static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
 
        ret = truncate_blocks(inode, new_size, true);
        if (!ret)
-               i_size_write(inode, new_size);
+               f2fs_i_size_write(inode, new_size);
 
        return ret;
 }
@@ -1128,11 +1118,8 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
        }
 
 out:
-       if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) {
-               i_size_write(inode, new_size);
-               mark_inode_dirty(inode);
-               update_inode_page(inode);
-       }
+       if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
+               f2fs_i_size_write(inode, new_size);
 
        return ret;
 }
@@ -1190,7 +1177,7 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
        truncate_pagecache(inode, offset);
 
        if (!ret)
-               i_size_write(inode, new_size);
+               f2fs_i_size_write(inode, new_size);
        return ret;
 }
 
@@ -1238,11 +1225,8 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
                new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
        }
 
-       if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) {
-               i_size_write(inode, new_size);
-               mark_inode_dirty(inode);
-               update_inode_page(inode);
-       }
+       if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
+               f2fs_i_size_write(inode, new_size);
 
        return ret;
 }
@@ -1285,7 +1269,7 @@ static long f2fs_fallocate(struct file *file, int mode,
 
        if (!ret) {
                inode->i_mtime = inode->i_ctime = CURRENT_TIME;
-               mark_inode_dirty(inode);
+               mark_inode_dirty_sync(inode);
                f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        }
 
@@ -1310,10 +1294,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
        if (f2fs_is_atomic_file(inode))
                drop_inmem_pages(inode);
        if (f2fs_is_volatile_file(inode)) {
-               clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
-               set_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
+               clear_inode_flag(inode, FI_VOLATILE_FILE);
+               set_inode_flag(inode, FI_DROP_CACHE);
                filemap_fdatawrite(inode->i_mapping);
-               clear_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
+               clear_inode_flag(inode, FI_DROP_CACHE);
        }
        return 0;
 }
@@ -1376,9 +1360,8 @@ static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
        fi->i_flags = flags;
        inode_unlock(inode);
 
-       f2fs_set_inode_flags(inode);
        inode->i_ctime = CURRENT_TIME;
-       mark_inode_dirty(inode);
+       f2fs_set_inode_flags(inode);
 out:
        mnt_drop_write_file(filp);
        return ret;
@@ -1412,7 +1395,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
        if (ret)
                goto out;
 
-       set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
+       set_inode_flag(inode, FI_ATOMIC_FILE);
        f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
 
        if (!get_dirty_pages(inode))
@@ -1423,7 +1406,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
                                        inode->i_ino, get_dirty_pages(inode));
        ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
        if (ret)
-               clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
+               clear_inode_flag(inode, FI_ATOMIC_FILE);
 out:
        inode_unlock(inode);
        mnt_drop_write_file(filp);
@@ -1448,10 +1431,10 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
                goto err_out;
 
        if (f2fs_is_atomic_file(inode)) {
-               clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
+               clear_inode_flag(inode, FI_ATOMIC_FILE);
                ret = commit_inmem_pages(inode);
                if (ret) {
-                       set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
+                       set_inode_flag(inode, FI_ATOMIC_FILE);
                        goto err_out;
                }
        }
@@ -1484,7 +1467,7 @@ static int f2fs_ioc_start_volatile_write(struct file *filp)
        if (ret)
                goto out;
 
-       set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
+       set_inode_flag(inode, FI_VOLATILE_FILE);
        f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
 out:
        inode_unlock(inode);
@@ -1538,7 +1521,7 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
        if (f2fs_is_atomic_file(inode))
                drop_inmem_pages(inode);
        if (f2fs_is_volatile_file(inode)) {
-               clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
+               clear_inode_flag(inode, FI_VOLATILE_FILE);
                ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
        }
 
@@ -1871,7 +1854,7 @@ do_map:
                        continue;
                }
 
-               set_inode_flag(F2FS_I(inode), FI_DO_DEFRAG);
+               set_inode_flag(inode, FI_DO_DEFRAG);
 
                idx = map.m_lblk;
                while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) {
@@ -1896,14 +1879,14 @@ do_map:
                if (idx < pg_end && cnt < blk_per_seg)
                        goto do_map;
 
-               clear_inode_flag(F2FS_I(inode), FI_DO_DEFRAG);
+               clear_inode_flag(inode, FI_DO_DEFRAG);
 
                err = filemap_fdatawrite(inode->i_mapping);
                if (err)
                        goto out;
        }
 clear_out:
-       clear_inode_flag(F2FS_I(inode), FI_DO_DEFRAG);
+       clear_inode_flag(inode, FI_DO_DEFRAG);
 out:
        inode_unlock(inode);
        if (!err)