Merge git://git.kernel.org/pub/scm/linux/kernel/git/cmetcalf/linux-tile

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

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 2e68adab0d645b7df68419829d5e8c4809a8c2a9..9ac5efc15347f4f5bb35460d77cc0a055b529e51 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -18,6 +18,13 @@
 
 #include <trace/events/f2fs.h>
 
+void f2fs_mark_inode_dirty_sync(struct inode *inode)
+{
+       if (f2fs_inode_dirtied(inode))
+               return;
+       mark_inode_dirty_sync(inode);
+}
+
 void f2fs_set_inode_flags(struct inode *inode)
 {
        unsigned int flags = F2FS_I(inode)->i_flags;
@@ -35,6 +42,7 @@ void f2fs_set_inode_flags(struct inode *inode)
                new_fl |= S_DIRSYNC;
        inode_set_flags(inode, new_fl,
                        S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
+       f2fs_mark_inode_dirty_sync(inode);
 }
 
 static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
@@ -85,8 +93,8 @@ static void __recover_inline_status(struct inode *inode, struct page *ipage)
                if (*start++) {
                        f2fs_wait_on_page_writeback(ipage, NODE, true);
 
-                       set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
-                       set_raw_inline(F2FS_I(inode), F2FS_INODE(ipage));
+                       set_inode_flag(inode, FI_DATA_EXIST);
+                       set_raw_inline(inode, F2FS_INODE(ipage));
                        set_page_dirty(ipage);
                        return;
                }
@@ -141,7 +149,7 @@ static int do_read_inode(struct inode *inode)
        if (f2fs_init_extent_tree(inode, &ri->i_ext))
                set_page_dirty(node_page);
 
-       get_inline_info(fi, ri);
+       get_inline_info(inode, ri);
 
        /* check data exist */
        if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
@@ -151,7 +159,10 @@ static int do_read_inode(struct inode *inode)
        __get_inode_rdev(inode, ri);
 
        if (__written_first_block(ri))
-               set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
+               set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
+
+       if (!need_inode_block_update(sbi, inode->i_ino))
+               fi->last_disk_size = inode->i_size;
 
        f2fs_put_page(node_page, 1);
 
@@ -227,6 +238,8 @@ int update_inode(struct inode *inode, struct page *node_page)
 {
        struct f2fs_inode *ri;
 
+       f2fs_inode_synced(inode);
+
        f2fs_wait_on_page_writeback(node_page, NODE, true);
 
        ri = F2FS_INODE(node_page);
@@ -244,7 +257,7 @@ int update_inode(struct inode *inode, struct page *node_page)
                                                        &ri->i_ext);
        else
                memset(&ri->i_ext, 0, sizeof(ri->i_ext));
-       set_raw_inline(F2FS_I(inode), ri);
+       set_raw_inline(inode, ri);
 
        ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
        ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
@@ -261,7 +274,6 @@ int update_inode(struct inode *inode, struct page *node_page)
 
        __set_inode_rdev(inode, ri);
        set_cold_node(inode, node_page);
-       clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
 
        /* deleted inode */
        if (inode->i_nlink == 0)
@@ -285,6 +297,7 @@ retry:
                } else if (err != -ENOENT) {
                        f2fs_stop_checkpoint(sbi, false);
                }
+               f2fs_inode_synced(inode);
                return 0;
        }
        ret = update_inode(inode, node_page);
@@ -300,7 +313,7 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
                        inode->i_ino == F2FS_META_INO(sbi))
                return 0;
 
-       if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE))
+       if (!is_inode_flag_set(inode, FI_DIRTY_INODE))
                return 0;
 
        /*
@@ -318,8 +331,7 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
 void f2fs_evict_inode(struct inode *inode)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-       struct f2fs_inode_info *fi = F2FS_I(inode);
-       nid_t xnid = fi->i_xattr_nid;
+       nid_t xnid = F2FS_I(inode)->i_xattr_nid;
        int err = 0;
 
        /* some remained atomic pages should discarded */
@@ -341,12 +353,17 @@ void f2fs_evict_inode(struct inode *inode)
        if (inode->i_nlink || is_bad_inode(inode))
                goto no_delete;
 
+#ifdef CONFIG_F2FS_FAULT_INJECTION
+       if (time_to_inject(FAULT_EVICT_INODE))
+               goto no_delete;
+#endif
+
        sb_start_intwrite(inode->i_sb);
-       set_inode_flag(fi, FI_NO_ALLOC);
+       set_inode_flag(inode, FI_NO_ALLOC);
        i_size_write(inode, 0);
 retry:
        if (F2FS_HAS_BLOCKS(inode))
-               err = f2fs_truncate(inode, true);
+               err = f2fs_truncate(inode);
 
        if (!err) {
                f2fs_lock_op(sbi);
@@ -360,6 +377,8 @@ retry:
                goto retry;
        }
 
+       if (err)
+               update_inode_page(inode);
        sb_end_intwrite(inode->i_sb);
 no_delete:
        stat_dec_inline_xattr(inode);
@@ -369,13 +388,13 @@ no_delete:
        invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
        if (xnid)
                invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
-       if (is_inode_flag_set(fi, FI_APPEND_WRITE))
+       if (is_inode_flag_set(inode, FI_APPEND_WRITE))
                add_ino_entry(sbi, inode->i_ino, APPEND_INO);
-       if (is_inode_flag_set(fi, FI_UPDATE_WRITE))
+       if (is_inode_flag_set(inode, FI_UPDATE_WRITE))
                add_ino_entry(sbi, inode->i_ino, UPDATE_INO);
-       if (is_inode_flag_set(fi, FI_FREE_NID)) {
+       if (is_inode_flag_set(inode, FI_FREE_NID)) {
                alloc_nid_failed(sbi, inode->i_ino);
-               clear_inode_flag(fi, FI_FREE_NID);
+               clear_inode_flag(inode, FI_FREE_NID);
        }
        f2fs_bug_on(sbi, err &&
                !exist_written_data(sbi, inode->i_ino, ORPHAN_INO));
@@ -407,11 +426,11 @@ void handle_failed_inode(struct inode *inode)
                        f2fs_msg(sbi->sb, KERN_WARNING,
                                "Too many orphan inodes, run fsck to fix.");
                } else {
-                       add_orphan_inode(sbi, inode->i_ino);
+                       add_orphan_inode(inode);
                }
                alloc_nid_done(sbi, inode->i_ino);
        } else {
-               set_inode_flag(F2FS_I(inode), FI_FREE_NID);
+               set_inode_flag(inode, FI_FREE_NID);
        }
 
        f2fs_unlock_op(sbi);