f2fs: use rw_sem instead of fs_lock(locks mutex)

The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.

V2:
  -fix the potential starvation problem.
  -use more suitable func name suggested by Xu Jin.

Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>

1 files changed, 24 insertions, 26 deletions

diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 2a5359c990fc..29f73fdf958e 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -27,19 +27,19 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
         nid_t ino;
         struct inode *inode;
         bool nid_free = false;
-        int err, ilock;
+        int err;
 
         inode = new_inode(sb);
         if (!inode)
                 return ERR_PTR(-ENOMEM);
 
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
         if (!alloc_nid(sbi, &ino)) {
-                mutex_unlock_op(sbi, ilock);
+                f2fs_unlock_op(sbi);
                 err = -ENOSPC;
                 goto fail;
         }
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
 
         inode->i_uid = current_fsuid();
 
@@ -115,7 +115,7 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
         struct f2fs_sb_info *sbi = F2FS_SB(sb);
         struct inode *inode;
         nid_t ino = 0;
-        int err, ilock;
+        int err;
 
         f2fs_balance_fs(sbi);
 
@@ -131,9 +131,9 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
         inode->i_mapping->a_ops = &f2fs_dblock_aops;
         ino = inode->i_ino;
 
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
         err = f2fs_add_link(dentry, inode);
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
         if (err)
                 goto out;
 
@@ -157,7 +157,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
         struct inode *inode = old_dentry->d_inode;
         struct super_block *sb = dir->i_sb;
         struct f2fs_sb_info *sbi = F2FS_SB(sb);
-        int err, ilock;
+        int err;
 
         f2fs_balance_fs(sbi);
 
@@ -165,9 +165,9 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
         ihold(inode);
 
         set_inode_flag(F2FS_I(inode), FI_INC_LINK);
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
         err = f2fs_add_link(dentry, inode);
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
         if (err)
                 goto out;
 
@@ -220,7 +220,6 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
         struct f2fs_dir_entry *de;
         struct page *page;
         int err = -ENOENT;
-        int ilock;
 
         trace_f2fs_unlink_enter(dir, dentry);
         f2fs_balance_fs(sbi);
@@ -236,9 +235,9 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
                 goto fail;
         }
 
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
         f2fs_delete_entry(de, page, inode);
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
 
         /* In order to evict this inode,  we set it dirty */
         mark_inode_dirty(inode);
@@ -254,7 +253,7 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
         struct f2fs_sb_info *sbi = F2FS_SB(sb);
         struct inode *inode;
         size_t symlen = strlen(symname) + 1;
-        int err, ilock;
+        int err;
 
         f2fs_balance_fs(sbi);
 
@@ -265,9 +264,9 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
         inode->i_op = &f2fs_symlink_inode_operations;
         inode->i_mapping->a_ops = &f2fs_dblock_aops;
 
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
         err = f2fs_add_link(dentry, inode);
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
         if (err)
                 goto out;
 
@@ -290,7 +289,7 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
         struct inode *inode;
-        int err, ilock;
+        int err;
 
         f2fs_balance_fs(sbi);
 
@@ -304,9 +303,9 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
 
         set_inode_flag(F2FS_I(inode), FI_INC_LINK);
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
         err = f2fs_add_link(dentry, inode);
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
         if (err)
                 goto out_fail;
 
@@ -342,7 +341,6 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
         struct f2fs_sb_info *sbi = F2FS_SB(sb);
         struct inode *inode;
         int err = 0;
-        int ilock;
 
         if (!new_valid_dev(rdev))
                 return -EINVAL;
@@ -356,9 +354,9 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
         init_special_inode(inode, inode->i_mode, rdev);
         inode->i_op = &f2fs_special_inode_operations;
 
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
         err = f2fs_add_link(dentry, inode);
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
         if (err)
                 goto out;
 
@@ -387,7 +385,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct f2fs_dir_entry *old_dir_entry = NULL;
         struct f2fs_dir_entry *old_entry;
         struct f2fs_dir_entry *new_entry;
-        int err = -ENOENT, ilock = -1;
+        int err = -ENOENT;
 
         f2fs_balance_fs(sbi);
 
@@ -402,7 +400,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         goto out_old;
         }
 
-        ilock = mutex_lock_op(sbi);
+        f2fs_lock_op(sbi);
 
         if (new_inode) {
 
@@ -467,7 +465,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 update_inode_page(old_dir);
         }
 
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
         return 0;
 
 put_out_dir:
@@ -477,7 +475,7 @@ out_dir:
                 kunmap(old_dir_page);
                 f2fs_put_page(old_dir_page, 0);
         }
-        mutex_unlock_op(sbi, ilock);
+        f2fs_unlock_op(sbi);
 out_old:
         kunmap(old_page);
         f2fs_put_page(old_page, 0);