12 files changed, 248 insertions, 242 deletions

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 93fd57d491ac..be6aa2eef894 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -543,54 +543,39 @@ retry:
  */
 static void block_operations(struct f2fs_sb_info *sbi)
 {
-        int t;
         struct writeback_control wbc = {
                 .sync_mode = WB_SYNC_ALL,
                 .nr_to_write = LONG_MAX,
                 .for_reclaim = 0,
         };
+retry_flush_dents:
+        mutex_lock_all(sbi);
 
-        /* Stop renaming operation */
-        mutex_lock_op(sbi, RENAME);
-        mutex_lock_op(sbi, DENTRY_OPS);
-
-retry_dents:
         /* write all the dirty dentry pages */
-        sync_dirty_dir_inodes(sbi);
-
-        mutex_lock_op(sbi, DATA_WRITE);
         if (get_pages(sbi, F2FS_DIRTY_DENTS)) {
-                mutex_unlock_op(sbi, DATA_WRITE);
-                goto retry_dents;
+                mutex_unlock_all(sbi);
+                sync_dirty_dir_inodes(sbi);
+                goto retry_flush_dents;
         }
 
-        /* block all the operations */
-        for (t = DATA_NEW; t <= NODE_TRUNC; t++)
-                mutex_lock_op(sbi, t);
-
-        mutex_lock(&sbi->write_inode);
-
         /*
          * POR: we should ensure that there is no dirty node pages
          * until finishing nat/sit flush.
          */
-retry:
-        sync_node_pages(sbi, 0, &wbc);
-
-        mutex_lock_op(sbi, NODE_WRITE);
+retry_flush_nodes:
+        mutex_lock(&sbi->node_write);
 
         if (get_pages(sbi, F2FS_DIRTY_NODES)) {
-                mutex_unlock_op(sbi, NODE_WRITE);
-                goto retry;
+                mutex_unlock(&sbi->node_write);
+                sync_node_pages(sbi, 0, &wbc);
+                goto retry_flush_nodes;
         }
-        mutex_unlock(&sbi->write_inode);
 }
 
 static void unblock_operations(struct f2fs_sb_info *sbi)
 {
-        int t;
-        for (t = NODE_WRITE; t >= RENAME; t--)
-                mutex_unlock_op(sbi, t);
+        mutex_unlock(&sbi->node_write);
+        mutex_unlock_all(sbi);
 }
 
 static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index cf9ff5f76134..72a1b30f720a 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -260,6 +260,9 @@ struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
 /*
  * Caller ensures that this data page is never allocated.
  * A new zero-filled data page is allocated in the page cache.
+ *
+ * Also, caller should grab and release a mutex by calling mutex_lock_op() and
+ * mutex_unlock_op().
  */
 struct page *get_new_data_page(struct inode *inode, pgoff_t index,
                                                 bool new_i_size)
@@ -479,10 +482,11 @@ static int f2fs_write_data_page(struct page *page,
         const pgoff_t end_index = ((unsigned long long) i_size)
                                                         >> PAGE_CACHE_SHIFT;
         unsigned offset;
+        bool need_balance_fs = false;
         int err = 0;
 
         if (page->index < end_index)
-                goto out;
+                goto write;
 
         /*
          * If the offset is out-of-range of file size,
@@ -494,50 +498,46 @@ static int f2fs_write_data_page(struct page *page,
                         dec_page_count(sbi, F2FS_DIRTY_DENTS);
                         inode_dec_dirty_dents(inode);
                 }
-                goto unlock_out;
+                goto out;
         }
 
         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
-out:
-        if (sbi->por_doing)
-                goto redirty_out;
-
-        if (wbc->for_reclaim && !S_ISDIR(inode->i_mode) && !is_cold_data(page))
+write:
+        if (sbi->por_doing) {
+                err = AOP_WRITEPAGE_ACTIVATE;
                 goto redirty_out;
+        }
 
-        mutex_lock_op(sbi, DATA_WRITE);
+        /* Dentry blocks are controlled by checkpoint */
         if (S_ISDIR(inode->i_mode)) {
                 dec_page_count(sbi, F2FS_DIRTY_DENTS);
                 inode_dec_dirty_dents(inode);
+                err = do_write_data_page(page);
+        } else {
+                int ilock = mutex_lock_op(sbi);
+                err = do_write_data_page(page);
+                mutex_unlock_op(sbi, ilock);
+                need_balance_fs = true;
         }
-        err = do_write_data_page(page);
-        if (err && err != -ENOENT) {
-                wbc->pages_skipped++;
-                set_page_dirty(page);
-        }
-        mutex_unlock_op(sbi, DATA_WRITE);
+        if (err == -ENOENT)
+                goto out;
+        else if (err)
+                goto redirty_out;
 
         if (wbc->for_reclaim)
                 f2fs_submit_bio(sbi, DATA, true);
 
-        if (err == -ENOENT)
-                goto unlock_out;
-
         clear_cold_data(page);
+out:
         unlock_page(page);
-
-        if (!wbc->for_reclaim && !S_ISDIR(inode->i_mode))
+        if (need_balance_fs)
                 f2fs_balance_fs(sbi);
         return 0;
 
-unlock_out:
-        unlock_page(page);
-        return (err == -ENOENT) ? 0 : err;
-
 redirty_out:
         wbc->pages_skipped++;
         set_page_dirty(page);
-        return AOP_WRITEPAGE_ACTIVATE;
+        return err;
 }
 
 #define MAX_DESIRED_PAGES_WP    4096
@@ -592,6 +592,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
         pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
         struct dnode_of_data dn;
         int err = 0;
+        int ilock;
 
         /* for nobh_write_end */
         *fsdata = NULL;
@@ -603,28 +604,21 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
                 return -ENOMEM;
         *pagep = page;
 
-        mutex_lock_op(sbi, DATA_NEW);
+        ilock = mutex_lock_op(sbi);
 
         set_new_dnode(&dn, inode, NULL, NULL, 0);
         err = get_dnode_of_data(&dn, index, ALLOC_NODE);
-        if (err) {
-                mutex_unlock_op(sbi, DATA_NEW);
-                f2fs_put_page(page, 1);
-                return err;
-        }
+        if (err)
+                goto err;
 
-        if (dn.data_blkaddr == NULL_ADDR) {
+        if (dn.data_blkaddr == NULL_ADDR)
                 err = reserve_new_block(&dn);
-                if (err) {
-                        f2fs_put_dnode(&dn);
-                        mutex_unlock_op(sbi, DATA_NEW);
-                        f2fs_put_page(page, 1);
-                        return err;
-                }
-        }
+
         f2fs_put_dnode(&dn);
+        if (err)
+                goto err;
 
-        mutex_unlock_op(sbi, DATA_NEW);
+        mutex_unlock_op(sbi, ilock);
 
         if ((len == PAGE_CACHE_SIZE) || PageUptodate(page))
                 return 0;
@@ -654,6 +648,11 @@ out:
         SetPageUptodate(page);
         clear_cold_data(page);
         return 0;
+
+err:
+        mutex_unlock_op(sbi, ilock);
+        f2fs_put_page(page, 1);
+        return err;
 }
 
 static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 2851ae6948a1..cd3342d4a3a7 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -249,9 +249,6 @@ ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr)
 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
                 struct page *page, struct inode *inode)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
-
-        mutex_lock_op(sbi, DENTRY_OPS);
         lock_page(page);
         wait_on_page_writeback(page);
         de->ino = cpu_to_le32(inode->i_ino);
@@ -265,7 +262,6 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
         F2FS_I(inode)->i_pino = dir->i_ino;
 
         f2fs_put_page(page, 1);
-        mutex_unlock_op(sbi, DENTRY_OPS);
 }
 
 void init_dent_inode(const struct qstr *name, struct page *ipage)
@@ -284,6 +280,43 @@ void init_dent_inode(const struct qstr *name, struct page *ipage)
         set_page_dirty(ipage);
 }
 
+static int make_empty_dir(struct inode *inode, struct inode *parent)
+{
+        struct page *dentry_page;
+        struct f2fs_dentry_block *dentry_blk;
+        struct f2fs_dir_entry *de;
+        void *kaddr;
+
+        dentry_page = get_new_data_page(inode, 0, true);
+        if (IS_ERR(dentry_page))
+                return PTR_ERR(dentry_page);
+
+        kaddr = kmap_atomic(dentry_page);
+        dentry_blk = (struct f2fs_dentry_block *)kaddr;
+
+        de = &dentry_blk->dentry[0];
+        de->name_len = cpu_to_le16(1);
+        de->hash_code = 0;
+        de->ino = cpu_to_le32(inode->i_ino);
+        memcpy(dentry_blk->filename[0], ".", 1);
+        set_de_type(de, inode);
+
+        de = &dentry_blk->dentry[1];
+        de->hash_code = 0;
+        de->name_len = cpu_to_le16(2);
+        de->ino = cpu_to_le32(parent->i_ino);
+        memcpy(dentry_blk->filename[1], "..", 2);
+        set_de_type(de, inode);
+
+        test_and_set_bit_le(0, &dentry_blk->dentry_bitmap);
+        test_and_set_bit_le(1, &dentry_blk->dentry_bitmap);
+        kunmap_atomic(kaddr);
+
+        set_page_dirty(dentry_page);
+        f2fs_put_page(dentry_page, 1);
+        return 0;
+}
+
 static int init_inode_metadata(struct inode *inode,
                 struct inode *dir, const struct qstr *name)
 {
@@ -294,7 +327,7 @@ static int init_inode_metadata(struct inode *inode,
                         return err;
 
                 if (S_ISDIR(inode->i_mode)) {
-                        err = f2fs_make_empty(inode, dir);
+                        err = make_empty_dir(inode, dir);
                         if (err) {
                                 remove_inode_page(inode);
                                 return err;
@@ -317,7 +350,7 @@ static int init_inode_metadata(struct inode *inode,
         }
         if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) {
                 inc_nlink(inode);
-                f2fs_write_inode(inode, NULL);
+                update_inode_page(inode);
         }
         return 0;
 }
@@ -341,7 +374,7 @@ static void update_parent_metadata(struct inode *dir, struct inode *inode,
         }
 
         if (need_dir_update)
-                f2fs_write_inode(dir, NULL);
+                update_inode_page(dir);
         else
                 mark_inode_dirty(dir);
 
@@ -373,6 +406,10 @@ next:
         goto next;
 }
 
+/*
+ * Caller should grab and release a mutex by calling mutex_lock_op() and
+ * mutex_unlock_op().
+ */
 int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode)
 {
         unsigned int bit_pos;
@@ -382,7 +419,6 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *in
         f2fs_hash_t dentry_hash;
         struct f2fs_dir_entry *de;
         unsigned int nbucket, nblock;
-        struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
         size_t namelen = name->len;
         struct page *dentry_page = NULL;
         struct f2fs_dentry_block *dentry_blk = NULL;
@@ -412,12 +448,9 @@ start:
         bidx = dir_block_index(level, (le32_to_cpu(dentry_hash) % nbucket));
 
         for (block = bidx; block <= (bidx + nblock - 1); block++) {
-                mutex_lock_op(sbi, DENTRY_OPS);
                 dentry_page = get_new_data_page(dir, block, true);
-                if (IS_ERR(dentry_page)) {
-                        mutex_unlock_op(sbi, DENTRY_OPS);
+                if (IS_ERR(dentry_page))
                         return PTR_ERR(dentry_page);
-                }
 
                 dentry_blk = kmap(dentry_page);
                 bit_pos = room_for_filename(dentry_blk, slots);
@@ -426,7 +459,6 @@ start:
 
                 kunmap(dentry_page);
                 f2fs_put_page(dentry_page, 1);
-                mutex_unlock_op(sbi, DENTRY_OPS);
         }
 
         /* Move to next level to find the empty slot for new dentry */
@@ -456,7 +488,6 @@ add_dentry:
 fail:
         kunmap(dentry_page);
         f2fs_put_page(dentry_page, 1);
-        mutex_unlock_op(sbi, DENTRY_OPS);
         return err;
 }
 
@@ -476,8 +507,6 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
         void *kaddr = page_address(page);
         int i;
 
-        mutex_lock_op(sbi, DENTRY_OPS);
-
         lock_page(page);
         wait_on_page_writeback(page);
 
@@ -497,7 +526,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
 
         if (inode && S_ISDIR(inode->i_mode)) {
                 drop_nlink(dir);
-                f2fs_write_inode(dir, NULL);
+                update_inode_page(dir);
         } else {
                 mark_inode_dirty(dir);
         }
@@ -509,7 +538,8 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
                         drop_nlink(inode);
                         i_size_write(inode, 0);
                 }
-                f2fs_write_inode(inode, NULL);
+                update_inode_page(inode);
+
                 if (inode->i_nlink == 0)
                         add_orphan_inode(sbi, inode->i_ino);
         }
@@ -522,45 +552,6 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
                 inode_dec_dirty_dents(dir);
         }
         f2fs_put_page(page, 1);
-
-        mutex_unlock_op(sbi, DENTRY_OPS);
-}
-
-int f2fs_make_empty(struct inode *inode, struct inode *parent)
-{
-        struct page *dentry_page;
-        struct f2fs_dentry_block *dentry_blk;
-        struct f2fs_dir_entry *de;
-        void *kaddr;
-
-        dentry_page = get_new_data_page(inode, 0, true);
-        if (IS_ERR(dentry_page))
-                return PTR_ERR(dentry_page);
-
-        kaddr = kmap_atomic(dentry_page);
-        dentry_blk = (struct f2fs_dentry_block *)kaddr;
-
-        de = &dentry_blk->dentry[0];
-        de->name_len = cpu_to_le16(1);
-        de->hash_code = f2fs_dentry_hash(".", 1);
-        de->ino = cpu_to_le32(inode->i_ino);
-        memcpy(dentry_blk->filename[0], ".", 1);
-        set_de_type(de, inode);
-
-        de = &dentry_blk->dentry[1];
-        de->hash_code = f2fs_dentry_hash("..", 2);
-        de->name_len = cpu_to_le16(2);
-        de->ino = cpu_to_le32(parent->i_ino);
-        memcpy(dentry_blk->filename[1], "..", 2);
-        set_de_type(de, inode);
-
-        test_and_set_bit_le(0, &dentry_blk->dentry_bitmap);
-        test_and_set_bit_le(1, &dentry_blk->dentry_bitmap);
-        kunmap_atomic(kaddr);
-
-        set_page_dirty(dentry_page);
-        f2fs_put_page(dentry_page, 1);
-        return 0;
 }
 
 bool f2fs_empty_dir(struct inode *dir)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 71eacd373916..06cc75c66c88 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -309,23 +309,12 @@ enum count_type {
 };
 
 /*
- * FS_LOCK nesting subclasses for the lock validator:
- *
- * The locking order between these classes is
- * RENAME -> DENTRY_OPS -> DATA_WRITE -> DATA_NEW
- *    -> DATA_TRUNC -> NODE_WRITE -> NODE_NEW -> NODE_TRUNC
+ * Uses as sbi->fs_lock[NR_GLOBAL_LOCKS].
+ * The checkpoint procedure blocks all the locks in this fs_lock array.
+ * Some FS operations grab free locks, and if there is no free lock,
+ * then wait to grab a lock in a round-robin manner.
  */
-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,
-};
+#define NR_GLOBAL_LOCKS 8
 
 /*
  * The below are the page types of bios used in submti_bio().
@@ -365,10 +354,11 @@ struct f2fs_sb_info {
         /* for checkpoint */
         struct f2fs_checkpoint *ckpt;           /* raw checkpoint pointer */
         struct inode *meta_inode;               /* cache meta blocks */
-        struct mutex cp_mutex;                  /* for checkpoint procedure */
-        struct mutex fs_lock[NR_LOCK_TYPE];     /* for blocking FS operations */
-        struct mutex write_inode;               /* mutex for write inode */
+        struct mutex cp_mutex;                  /* checkpoint procedure lock */
+        struct mutex fs_lock[NR_GLOBAL_LOCKS];  /* blocking FS operations */
+        struct mutex node_write;                /* locking node writes */
         struct mutex writepages;                /* mutex for writepages() */
+        unsigned char next_lock_num;            /* round-robin global locks */
         int por_doing;                          /* recovery is doing or not */
 
         /* for orphan inode management */
@@ -503,14 +493,40 @@ static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
         cp->ckpt_flags = cpu_to_le32(ckpt_flags);
 }
 
-static inline void mutex_lock_op(struct f2fs_sb_info *sbi, enum lock_type t)
+static inline void mutex_lock_all(struct f2fs_sb_info *sbi)
+{
+        int i = 0;
+        for (; i < NR_GLOBAL_LOCKS; i++)
+                mutex_lock(&sbi->fs_lock[i]);
+}
+
+static inline void mutex_unlock_all(struct f2fs_sb_info *sbi)
 {
-        mutex_lock_nested(&sbi->fs_lock[t], t);
+        int i = 0;
+        for (; i < NR_GLOBAL_LOCKS; i++)
+                mutex_unlock(&sbi->fs_lock[i]);
 }
 
-static inline void mutex_unlock_op(struct f2fs_sb_info *sbi, enum lock_type t)
+static inline int mutex_lock_op(struct f2fs_sb_info *sbi)
 {
-        mutex_unlock(&sbi->fs_lock[t]);
+        unsigned char next_lock = sbi->next_lock_num % NR_GLOBAL_LOCKS;
+        int i = 0;
+
+        for (; i < NR_GLOBAL_LOCKS; i++)
+                if (mutex_trylock(&sbi->fs_lock[i]))
+                        return i;
+
+        mutex_lock(&sbi->fs_lock[next_lock]);
+        sbi->next_lock_num++;
+        return next_lock;
+}
+
+static inline void mutex_unlock_op(struct f2fs_sb_info *sbi, int ilock)
+{
+        if (ilock < 0)
+                return;
+        BUG_ON(ilock >= NR_GLOBAL_LOCKS);
+        mutex_unlock(&sbi->fs_lock[ilock]);
 }
 
 /*
@@ -879,6 +895,7 @@ long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
 void f2fs_set_inode_flags(struct inode *);
 struct inode *f2fs_iget(struct super_block *, unsigned long);
 void update_inode(struct inode *, struct page *);
+int update_inode_page(struct inode *);
 int f2fs_write_inode(struct inode *, struct writeback_control *);
 void f2fs_evict_inode(struct inode *);
 
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 155b362dad63..07be88ddb9f8 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -34,19 +34,18 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         block_t old_blk_addr;
         struct dnode_of_data dn;
-        int err;
+        int err, ilock;
 
         f2fs_balance_fs(sbi);
 
         sb_start_pagefault(inode->i_sb);
 
-        mutex_lock_op(sbi, DATA_NEW);
-
         /* block allocation */
+        ilock = mutex_lock_op(sbi);
         set_new_dnode(&dn, inode, NULL, NULL, 0);
         err = get_dnode_of_data(&dn, page->index, ALLOC_NODE);
         if (err) {
-                mutex_unlock_op(sbi, DATA_NEW);
+                mutex_unlock_op(sbi, ilock);
                 goto out;
         }
 
@@ -56,13 +55,12 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
                 err = reserve_new_block(&dn);
                 if (err) {
                         f2fs_put_dnode(&dn);
-                        mutex_unlock_op(sbi, DATA_NEW);
+                        mutex_unlock_op(sbi, ilock);
                         goto out;
                 }
         }
         f2fs_put_dnode(&dn);
-
-        mutex_unlock_op(sbi, DATA_NEW);
+        mutex_unlock_op(sbi, ilock);
 
         lock_page(page);
         if (page->mapping != inode->i_mapping ||
@@ -223,20 +221,19 @@ static int truncate_blocks(struct inode *inode, u64 from)
         unsigned int blocksize = inode->i_sb->s_blocksize;
         struct dnode_of_data dn;
         pgoff_t free_from;
-        int count = 0;
+        int count = 0, ilock = -1;
         int err;
 
         free_from = (pgoff_t)
                         ((from + blocksize - 1) >> (sbi->log_blocksize));
 
-        mutex_lock_op(sbi, DATA_TRUNC);
-
+        ilock = mutex_lock_op(sbi);
         set_new_dnode(&dn, inode, NULL, NULL, 0);
         err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE);
         if (err) {
                 if (err == -ENOENT)
                         goto free_next;
-                mutex_unlock_op(sbi, DATA_TRUNC);
+                mutex_unlock_op(sbi, ilock);
                 return err;
         }
 
@@ -247,6 +244,7 @@ static int truncate_blocks(struct inode *inode, u64 from)
 
         count -= dn.ofs_in_node;
         BUG_ON(count < 0);
+
         if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
                 truncate_data_blocks_range(&dn, count);
                 free_from += count;
@@ -255,7 +253,7 @@ static int truncate_blocks(struct inode *inode, u64 from)
         f2fs_put_dnode(&dn);
 free_next:
         err = truncate_inode_blocks(inode, free_from);
-        mutex_unlock_op(sbi, DATA_TRUNC);
+        mutex_unlock_op(sbi, ilock);
 
         /* lastly zero out the first data page */
         truncate_partial_data_page(inode, from);
@@ -363,15 +361,16 @@ static void fill_zero(struct inode *inode, pgoff_t index,
 {
         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         struct page *page;
+        int ilock;
 
         if (!len)
                 return;
 
         f2fs_balance_fs(sbi);
 
-        mutex_lock_op(sbi, DATA_NEW);
+        ilock = mutex_lock_op(sbi);
         page = get_new_data_page(inode, index, false);
-        mutex_unlock_op(sbi, DATA_NEW);
+        mutex_unlock_op(sbi, ilock);
 
         if (!IS_ERR(page)) {
                 wait_on_page_writeback(page);
@@ -388,13 +387,10 @@ int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
 
         for (index = pg_start; index < pg_end; index++) {
                 struct dnode_of_data dn;
-                struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
 
-                mutex_lock_op(sbi, DATA_TRUNC);
                 set_new_dnode(&dn, inode, NULL, NULL, 0);
                 err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
                 if (err) {
-                        mutex_unlock_op(sbi, DATA_TRUNC);
                         if (err == -ENOENT)
                                 continue;
                         return err;
@@ -403,7 +399,6 @@ int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
                 if (dn.data_blkaddr != NULL_ADDR)
                         truncate_data_blocks_range(&dn, 1);
                 f2fs_put_dnode(&dn);
-                mutex_unlock_op(sbi, DATA_TRUNC);
         }
         return 0;
 }
@@ -434,6 +429,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len, int mode)
                         struct address_space *mapping = inode->i_mapping;
                         loff_t blk_start, blk_end;
                         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+                        int ilock;
 
                         f2fs_balance_fs(sbi);
 
@@ -441,7 +437,10 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len, int mode)
                         blk_end = pg_end << PAGE_CACHE_SHIFT;
                         truncate_inode_pages_range(mapping, blk_start,
                                         blk_end - 1);
+
+                        ilock = mutex_lock_op(sbi);
                         ret = truncate_hole(inode, pg_start, pg_end);
+                        mutex_unlock_op(sbi, ilock);
                 }
         }
 
@@ -475,13 +474,13 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
 
         for (index = pg_start; index <= pg_end; index++) {
                 struct dnode_of_data dn;
+                int ilock;
 
-                mutex_lock_op(sbi, DATA_NEW);
-
+                ilock = mutex_lock_op(sbi);
                 set_new_dnode(&dn, inode, NULL, NULL, 0);
                 ret = get_dnode_of_data(&dn, index, ALLOC_NODE);
                 if (ret) {
-                        mutex_unlock_op(sbi, DATA_NEW);
+                        mutex_unlock_op(sbi, ilock);
                         break;
                 }
 
@@ -489,13 +488,12 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
                         ret = reserve_new_block(&dn);
                         if (ret) {
                                 f2fs_put_dnode(&dn);
-                                mutex_unlock_op(sbi, DATA_NEW);
+                                mutex_unlock_op(sbi, ilock);
                                 break;
                         }
                 }
                 f2fs_put_dnode(&dn);
-
-                mutex_unlock_op(sbi, DATA_NEW);
+                mutex_unlock_op(sbi, ilock);
 
                 if (pg_start == pg_end)
                         new_size = offset + len;
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index e97f30157aa6..83cec8f868c6 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -510,7 +510,6 @@ static void move_data_page(struct inode *inode, struct page *page, int gc_type)
                         wait_on_page_writeback(page);
                 }
 
-                mutex_lock_op(sbi, DATA_WRITE);
                 if (clear_page_dirty_for_io(page) &&
                         S_ISDIR(inode->i_mode)) {
                         dec_page_count(sbi, F2FS_DIRTY_DENTS);
@@ -518,7 +517,6 @@ static void move_data_page(struct inode *inode, struct page *page, int gc_type)
                 }
                 set_cold_data(page);
                 do_write_data_page(page);
-                mutex_unlock_op(sbi, DATA_WRITE);
                 clear_cold_data(page);
         }
 out:
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index f798ddf2c8a8..60105b710958 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -195,46 +195,49 @@ void update_inode(struct inode *inode, struct page *node_page)
         set_page_dirty(node_page);
 }
 
-int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
+int update_inode_page(struct inode *inode)
 {
         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         struct page *node_page;
-        bool need_lock = false;
-
-        if (inode->i_ino == F2FS_NODE_INO(sbi) ||
-                        inode->i_ino == F2FS_META_INO(sbi))
-                return 0;
-
-        if (wbc)
-                f2fs_balance_fs(sbi);
 
         node_page = get_node_page(sbi, inode->i_ino);
         if (IS_ERR(node_page))
                 return PTR_ERR(node_page);
 
-        if (!PageDirty(node_page)) {
-                need_lock = true;
-                f2fs_put_page(node_page, 1);
-                mutex_lock(&sbi->write_inode);
-                node_page = get_node_page(sbi, inode->i_ino);
-                if (IS_ERR(node_page)) {
-                        mutex_unlock(&sbi->write_inode);
-                        return PTR_ERR(node_page);
-                }
-        }
         update_inode(inode, node_page);
         f2fs_put_page(node_page, 1);
-        if (need_lock)
-                mutex_unlock(&sbi->write_inode);
         return 0;
 }
 
+int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
+{
+        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+        int ret, ilock;
+
+        if (inode->i_ino == F2FS_NODE_INO(sbi) ||
+                        inode->i_ino == F2FS_META_INO(sbi))
+                return 0;
+
+        if (wbc)
+                f2fs_balance_fs(sbi);
+
+        /*
+         * We need to lock here to prevent from producing dirty node pages
+         * during the urgent cleaning time when runing out of free sections.
+         */
+        ilock = mutex_lock_op(sbi);
+        ret = update_inode_page(inode);
+        mutex_unlock_op(sbi, ilock);
+        return ret;
+}
+
 /*
  * Called at the last iput() if i_nlink is zero
  */
 void f2fs_evict_inode(struct inode *inode)
 {
         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+        int ilock;
 
         truncate_inode_pages(&inode->i_data, 0);
 
@@ -255,7 +258,10 @@ void f2fs_evict_inode(struct inode *inode)
         if (F2FS_HAS_BLOCKS(inode))
                 f2fs_truncate(inode);
 
+        ilock = mutex_lock_op(sbi);
         remove_inode_page(inode);
+        mutex_unlock_op(sbi, ilock);
+
         sb_end_intwrite(inode->i_sb);
 no_delete:
         clear_inode(inode);
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);
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index ad3adbee842a..5a7edf90ca45 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -385,6 +385,9 @@ got:
 
 /*
  * Caller should call f2fs_put_dnode(dn).
+ * Also, it should grab and release a mutex by calling mutex_lock_op() and
+ * mutex_unlock_op() only if ro is not set RDONLY_NODE.
+ * In the case of RDONLY_NODE, we don't need to care about mutex.
  */
 int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode)
 {
@@ -415,11 +418,8 @@ int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode)
                 bool done = false;
 
                 if (!nids[i] && mode == ALLOC_NODE) {
-                        mutex_lock_op(sbi, NODE_NEW);
-
                         /* alloc new node */
                         if (!alloc_nid(sbi, &(nids[i]))) {
-                                mutex_unlock_op(sbi, NODE_NEW);
                                 err = -ENOSPC;
                                 goto release_pages;
                         }
@@ -428,14 +428,12 @@ int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode)
                         npage[i] = new_node_page(dn, noffset[i]);
                         if (IS_ERR(npage[i])) {
                                 alloc_nid_failed(sbi, nids[i]);
-                                mutex_unlock_op(sbi, NODE_NEW);
                                 err = PTR_ERR(npage[i]);
                                 goto release_pages;
                         }
 
                         set_nid(parent, offset[i - 1], nids[i], i == 1);
                         alloc_nid_done(sbi, nids[i]);
-                        mutex_unlock_op(sbi, NODE_NEW);
                         done = true;
                 } else if (mode == LOOKUP_NODE_RA && i == level && level > 1) {
                         npage[i] = get_node_page_ra(parent, offset[i - 1]);
@@ -745,6 +743,10 @@ fail:
         return err > 0 ? 0 : err;
 }
 
+/*
+ * Caller should grab and release a mutex by calling mutex_lock_op() and
+ * mutex_unlock_op().
+ */
 int remove_inode_page(struct inode *inode)
 {
         struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
@@ -752,21 +754,16 @@ int remove_inode_page(struct inode *inode)
         nid_t ino = inode->i_ino;
         struct dnode_of_data dn;
 
-        mutex_lock_op(sbi, NODE_TRUNC);
         page = get_node_page(sbi, ino);
-        if (IS_ERR(page)) {
-                mutex_unlock_op(sbi, NODE_TRUNC);
+        if (IS_ERR(page))
                 return PTR_ERR(page);
-        }
 
         if (F2FS_I(inode)->i_xattr_nid) {
                 nid_t nid = F2FS_I(inode)->i_xattr_nid;
                 struct page *npage = get_node_page(sbi, nid);
 
-                if (IS_ERR(npage)) {
-                        mutex_unlock_op(sbi, NODE_TRUNC);
+                if (IS_ERR(npage))
                         return PTR_ERR(npage);
-                }
 
                 F2FS_I(inode)->i_xattr_nid = 0;
                 set_new_dnode(&dn, inode, page, npage, nid);
@@ -778,23 +775,18 @@ int remove_inode_page(struct inode *inode)
         BUG_ON(inode->i_blocks != 0 && inode->i_blocks != 1);
         set_new_dnode(&dn, inode, page, page, ino);
         truncate_node(&dn);
-
-        mutex_unlock_op(sbi, NODE_TRUNC);
         return 0;
 }
 
 int new_inode_page(struct inode *inode, const struct qstr *name)
 {
-        struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
         struct page *page;
         struct dnode_of_data dn;
 
         /* allocate inode page for new inode */
         set_new_dnode(&dn, inode, NULL, NULL, inode->i_ino);
-        mutex_lock_op(sbi, NODE_NEW);
         page = new_node_page(&dn, 0);
         init_dent_inode(name, page);
-        mutex_unlock_op(sbi, NODE_NEW);
         if (IS_ERR(page))
                 return PTR_ERR(page);
         f2fs_put_page(page, 1);
@@ -985,7 +977,7 @@ void sync_inode_page(struct dnode_of_data *dn)
                 if (!dn->inode_page_locked)
                         unlock_page(dn->inode_page);
         } else {
-                f2fs_write_inode(dn->inode, NULL);
+                update_inode_page(dn->inode);
         }
 }
 
@@ -1102,8 +1094,6 @@ static int f2fs_write_node_page(struct page *page,
 
         wait_on_page_writeback(page);
 
-        mutex_lock_op(sbi, NODE_WRITE);
-
         /* get old block addr of this node page */
         nid = nid_of_node(page);
         BUG_ON(page->index != nid);
@@ -1111,25 +1101,25 @@ static int f2fs_write_node_page(struct page *page,
         get_node_info(sbi, nid, &ni);
 
         /* This page is already truncated */
-        if (ni.blk_addr == NULL_ADDR)
-                goto out;
+        if (ni.blk_addr == NULL_ADDR) {
+                dec_page_count(sbi, F2FS_DIRTY_NODES);
+                unlock_page(page);
+                return 0;
+        }
 
         if (wbc->for_reclaim) {
                 dec_page_count(sbi, F2FS_DIRTY_NODES);
                 wbc->pages_skipped++;
                 set_page_dirty(page);
-                mutex_unlock_op(sbi, NODE_WRITE);
                 return AOP_WRITEPAGE_ACTIVATE;
         }
 
+        mutex_lock(&sbi->node_write);
         set_page_writeback(page);
-
-        /* insert node offset */
         write_node_page(sbi, page, nid, ni.blk_addr, &new_addr);
         set_node_addr(sbi, &ni, new_addr);
-out:
         dec_page_count(sbi, F2FS_DIRTY_NODES);
-        mutex_unlock_op(sbi, NODE_WRITE);
+        mutex_unlock(&sbi->node_write);
         unlock_page(page);
         return 0;
 }
diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 61bdaa755906..f16d12df8e99 100644
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -242,6 +242,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
         struct f2fs_summary sum;
         struct node_info ni;
         int err = 0;
+        int ilock;
 
         start = start_bidx_of_node(ofs_of_node(page));
         if (IS_INODE(page))
@@ -249,10 +250,14 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
         else
                 end = start + ADDRS_PER_BLOCK;
 
+        ilock = mutex_lock_op(sbi);
         set_new_dnode(&dn, inode, NULL, NULL, 0);
+
         err = get_dnode_of_data(&dn, start, ALLOC_NODE);
-        if (err)
+        if (err) {
+                mutex_unlock_op(sbi, ilock);
                 return err;
+        }
 
         wait_on_page_writeback(dn.node_page);
 
@@ -297,6 +302,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
 
         recover_node_page(sbi, dn.node_page, &sum, &ni, blkaddr);
         f2fs_put_dnode(&dn);
+        mutex_unlock_op(sbi, ilock);
         return 0;
 }
 
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index ca5413346653..2643c49c38a5 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -556,11 +556,11 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
         sbi->raw_super = raw_super;
         sbi->raw_super_buf = raw_super_buf;
         mutex_init(&sbi->gc_mutex);
-        mutex_init(&sbi->write_inode);
         mutex_init(&sbi->writepages);
         mutex_init(&sbi->cp_mutex);
-        for (i = 0; i < NR_LOCK_TYPE; i++)
+        for (i = 0; i < NR_GLOBAL_LOCKS; i++)
                 mutex_init(&sbi->fs_lock[i]);
+        mutex_init(&sbi->node_write);
         sbi->por_doing = 0;
         spin_lock_init(&sbi->stat_lock);
         init_rwsem(&sbi->bio_sem);
diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index 3bfea80610ff..0b02dce31356 100644
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -307,6 +307,7 @@ int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
         int error, found, free, newsize;
         size_t name_len;
         char *pval;
+        int ilock;
 
         if (name == NULL)
                 return -EINVAL;
@@ -321,7 +322,8 @@ int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
 
         f2fs_balance_fs(sbi);
 
-        mutex_lock_op(sbi, NODE_NEW);
+        ilock = mutex_lock_op(sbi);
+
         if (!fi->i_xattr_nid) {
                 /* Allocate new attribute block */
                 struct dnode_of_data dn;
@@ -433,13 +435,13 @@ int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
                 inode->i_ctime = CURRENT_TIME;
                 clear_inode_flag(fi, FI_ACL_MODE);
         }
-        f2fs_write_inode(inode, NULL);
-        mutex_unlock_op(sbi, NODE_NEW);
+        update_inode_page(inode);
+        mutex_unlock_op(sbi, ilock);
 
         return 0;
 cleanup:
         f2fs_put_page(page, 1);
 exit:
-        mutex_unlock_op(sbi, NODE_NEW);
+        mutex_unlock_op(sbi, ilock);
         return error;
 }