f2fs: remove costly dirty_dir_inode operations

This patch removes list opeations in handling dirty dir inodes.
Previously, F2FS traverses whole the list of dirty dir inodes to check whether
there is an existing inode or not, resulting in heavy CPU overheads.

So this patch removes such the traverse operations by adding FI_DIRTY_DIR to
indicate the inode lies on the list or not.
Through this simple flag, we can remove redundant operations gracefully.

Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>

1 files changed, 13 insertions, 39 deletions

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 2902f7d50770..744c68be2e15 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -552,14 +552,13 @@ fail_no_cp:
 static int __add_dirty_inode(struct inode *inode, struct dir_inode_entry *new)
 {
         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
-        struct list_head *head = &sbi->dir_inode_list;
-        struct dir_inode_entry *entry;
 
-        list_for_each_entry(entry, head, list)
-                if (unlikely(entry->inode == inode))
-                        return -EEXIST;
+        if (is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR))
+                return -EEXIST;
 
-        list_add_tail(&new->list, head);
+        set_inode_flag(F2FS_I(inode), FI_DIRTY_DIR);
+        F2FS_I(inode)->dirty_dir = new;
+        list_add_tail(&new->list, &sbi->dir_inode_list);
         stat_inc_dirty_dir(sbi);
         return 0;
 }
@@ -608,31 +607,26 @@ void add_dirty_dir_inode(struct inode *inode)
 void remove_dirty_dir_inode(struct inode *inode)
 {
         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
-        struct list_head *head;
         struct dir_inode_entry *entry;
 
         if (!S_ISDIR(inode->i_mode))
                 return;
 
         spin_lock(&sbi->dir_inode_lock);
-        if (get_dirty_dents(inode)) {
+        if (get_dirty_dents(inode) ||
+                        !is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR)) {
                 spin_unlock(&sbi->dir_inode_lock);
                 return;
         }
 
-        head = &sbi->dir_inode_list;
-        list_for_each_entry(entry, head, list) {
-                if (entry->inode == inode) {
-                        list_del(&entry->list);
-                        stat_dec_dirty_dir(sbi);
-                        spin_unlock(&sbi->dir_inode_lock);
-                        kmem_cache_free(inode_entry_slab, entry);
-                        goto done;
-                }
-        }
+        entry = F2FS_I(inode)->dirty_dir;
+        list_del(&entry->list);
+        F2FS_I(inode)->dirty_dir = NULL;
+        clear_inode_flag(F2FS_I(inode), FI_DIRTY_DIR);
+        stat_dec_dirty_dir(sbi);
         spin_unlock(&sbi->dir_inode_lock);
+        kmem_cache_free(inode_entry_slab, entry);
 
-done:
         /* Only from the recovery routine */
         if (is_inode_flag_set(F2FS_I(inode), FI_DELAY_IPUT)) {
                 clear_inode_flag(F2FS_I(inode), FI_DELAY_IPUT);
@@ -640,26 +634,6 @@ done:
         }
 }
 
-struct inode *check_dirty_dir_inode(struct f2fs_sb_info *sbi, nid_t ino)
-{
-
-        struct list_head *head;
-        struct inode *inode = NULL;
-        struct dir_inode_entry *entry;
-
-        spin_lock(&sbi->dir_inode_lock);
-
-        head = &sbi->dir_inode_list;
-        list_for_each_entry(entry, head, list) {
-                if (entry->inode->i_ino == ino) {
-                        inode = entry->inode;
-                        break;
-                }
-        }
-        spin_unlock(&sbi->dir_inode_lock);
-        return inode;
-}
-
 void sync_dirty_dir_inodes(struct f2fs_sb_info *sbi)
 {
         struct list_head *head;