f2fs: introduce a new global lock scheme

In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.

Reference the following lock types in f2fs.h.
enum lock_type {
	RENAME,		/* for renaming operations */
	DENTRY_OPS,	/* for directory operations */
	DATA_WRITE,	/* for data write */
	DATA_NEW,	/* for data allocation */
	DATA_TRUNC,	/* for data truncate */
	NODE_NEW,	/* for node allocation */
	NODE_TRUNC,	/* for node truncate */
	NODE_WRITE,	/* for node write */
	NR_LOCK_TYPE,
};

In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.

In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.

For this, I propose a new global lock scheme as follows.

0. Data structure
 - f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
 - f2fs_sb_info -> node_write

1. mutex_lock_op(sbi)
 - try to get an avaiable lock from the array.
 - returns the index of the gottern lock variable.

2. mutex_unlock_op(sbi, index of the lock)
 - unlock the given index of the lock.

3. mutex_lock_all(sbi)
 - grab all the locks in the array before the checkpoint.

4. mutex_unlock_all(sbi)
 - release all the locks in the array after checkpoint.

5. block_operations()
 - call mutex_lock_all()
 - sync_dirty_dir_inodes()
 - grab node_write
 - sync_node_pages()

Note that,
 the pairs of mutex_lock_op()/mutex_unlock_op() and
 mutex_lock_all()/mutex_unlock_all() should be used together.

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

1 files changed, 29 insertions, 15 deletions

diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 7c6e219a479c..841f6b486bd6 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -26,19 +26,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;
+        int err, ilock;
 
         inode = new_inode(sb);
         if (!inode)
                 return ERR_PTR(-ENOMEM);
 
-        mutex_lock_op(sbi, NODE_NEW);
+        ilock = mutex_lock_op(sbi);
         if (!alloc_nid(sbi, &ino)) {
-                mutex_unlock_op(sbi, NODE_NEW);
+                mutex_unlock_op(sbi, ilock);
                 err = -ENOSPC;
                 goto fail;
         }
-        mutex_unlock_op(sbi, NODE_NEW);
+        mutex_unlock_op(sbi, ilock);
 
         inode->i_uid = current_fsuid();
 
@@ -122,7 +122,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;
+        int err, ilock;
 
         f2fs_balance_fs(sbi);
 
@@ -138,7 +138,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);
         err = f2fs_add_link(dentry, inode);
+        mutex_unlock_op(sbi, ilock);
         if (err)
                 goto out;
 
@@ -162,7 +164,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;
+        int err, ilock;
 
         f2fs_balance_fs(sbi);
 
@@ -170,7 +172,9 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
         atomic_inc(&inode->i_count);
 
         set_inode_flag(F2FS_I(inode), FI_INC_LINK);
+        ilock = mutex_lock_op(sbi);
         err = f2fs_add_link(dentry, inode);
+        mutex_unlock_op(sbi, ilock);
         if (err)
                 goto out;
 
@@ -229,6 +233,7 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
         struct f2fs_dir_entry *de;
         struct page *page;
         int err = -ENOENT;
+        int ilock;
 
         f2fs_balance_fs(sbi);
 
@@ -243,7 +248,9 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
                 goto fail;
         }
 
+        ilock = mutex_lock_op(sbi);
         f2fs_delete_entry(de, page, inode);
+        mutex_unlock_op(sbi, ilock);
 
         /* In order to evict this inode,  we set it dirty */
         mark_inode_dirty(inode);
@@ -258,7 +265,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;
+        int err, ilock;
 
         f2fs_balance_fs(sbi);
 
@@ -269,7 +276,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);
         err = f2fs_add_link(dentry, inode);
+        mutex_unlock_op(sbi, ilock);
         if (err)
                 goto out;
 
@@ -291,7 +300,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;
+        int err, ilock;
 
         f2fs_balance_fs(sbi);
 
@@ -305,7 +314,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);
         err = f2fs_add_link(dentry, inode);
+        mutex_unlock_op(sbi, ilock);
         if (err)
                 goto out_fail;
 
@@ -340,6 +351,7 @@ 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;
@@ -353,7 +365,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);
         err = f2fs_add_link(dentry, inode);
+        mutex_unlock_op(sbi, ilock);
         if (err)
                 goto out;
 
@@ -381,7 +395,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;
+        int err = -ENOENT, ilock = -1;
 
         f2fs_balance_fs(sbi);
 
@@ -396,7 +410,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         goto out_old;
         }
 
-        mutex_lock_op(sbi, RENAME);
+        ilock = mutex_lock_op(sbi);
 
         if (new_inode) {
                 struct page *new_page;
@@ -419,7 +433,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 drop_nlink(new_inode);
                 if (!new_inode->i_nlink)
                         add_orphan_inode(sbi, new_inode->i_ino);
-                f2fs_write_inode(new_inode, NULL);
+                update_inode_page(new_inode);
         } else {
                 err = f2fs_add_link(new_dentry, old_inode);
                 if (err)
@@ -427,7 +441,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
                 if (old_dir_entry) {
                         inc_nlink(new_dir);
-                        f2fs_write_inode(new_dir, NULL);
+                        update_inode_page(new_dir);
                 }
         }
 
@@ -445,10 +459,10 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         f2fs_put_page(old_dir_page, 0);
                 }
                 drop_nlink(old_dir);
-                f2fs_write_inode(old_dir, NULL);
+                update_inode_page(old_dir);
         }
 
-        mutex_unlock_op(sbi, RENAME);
+        mutex_unlock_op(sbi, ilock);
         return 0;
 
 out_dir:
@@ -456,7 +470,7 @@ out_dir:
                 kunmap(old_dir_page);
                 f2fs_put_page(old_dir_page, 0);
         }
-        mutex_unlock_op(sbi, RENAME);
+        mutex_unlock_op(sbi, ilock);
 out_old:
         kunmap(old_page);
         f2fs_put_page(old_page, 0);