f2fs: trace elapsed time for cp_rwsem lock

Use f2fs_{down,up}_read_trace for cp_rwsem to trace lock elapsed time.

Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 61bcf227d8ca915f780422bab1eef52da92cafda..dfd54cba1b3593622fb58767c492d810e8b05d59 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -127,6 +127,34 @@ void f2fs_up_write_trace(struct f2fs_rwsem *sem, struct f2fs_lock_context *lc)
        trace_lock_elapsed_time_end(sem, lc, true);
 }
 
+void f2fs_lock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc)
+{
+       f2fs_down_read_trace(&sbi->cp_rwsem, lc);
+}
+
+int f2fs_trylock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc)
+{
+       if (time_to_inject(sbi, FAULT_LOCK_OP))
+               return 0;
+
+       return f2fs_down_read_trylock_trace(&sbi->cp_rwsem, lc);
+}
+
+void f2fs_unlock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc)
+{
+       f2fs_up_read_trace(&sbi->cp_rwsem, lc);
+}
+
+static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
+{
+       f2fs_down_write(&sbi->cp_rwsem);
+}
+
+static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
+{
+       f2fs_up_write(&sbi->cp_rwsem);
+}
+
 #define DEFAULT_CHECKPOINT_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_RT, 3))
 
 static struct kmem_cache *ino_entry_slab;

diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index 7b68bf22989d9bcc236990747808687bca891060..3155d30b24488639d78e7ae750fd89efb5ab1b14 100644 (file)
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1290,6 +1290,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
        struct dnode_of_data dn;
        struct node_info ni;
        struct compress_io_ctx *cic;
+       struct f2fs_lock_context lc;
        pgoff_t start_idx = start_idx_of_cluster(cc);
        unsigned int last_index = cc->cluster_size - 1;
        loff_t psize;
@@ -1309,7 +1310,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
                 * the below discard race condition.
                 */
                f2fs_down_read(&sbi->node_write);
-       } else if (!f2fs_trylock_op(sbi)) {
+       } else if (!f2fs_trylock_op(sbi, &lc)) {
                goto out_free;
        }
 
@@ -1435,7 +1436,7 @@ unlock_continue:
        if (quota_inode)
                f2fs_up_read(&sbi->node_write);
        else
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
 
        spin_lock(&fi->i_size_lock);
        if (fi->last_disk_size < psize)
@@ -1464,7 +1465,7 @@ out_unlock_op:
        if (quota_inode)
                f2fs_up_read(&sbi->node_write);
        else
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
 out_free:
        for (i = 0; i < cc->valid_nr_cpages; i++) {
                f2fs_compress_free_page(cc->cpages[i]);
@@ -1511,6 +1512,7 @@ static int f2fs_write_raw_pages(struct compress_ctx *cc,
 {
        struct address_space *mapping = cc->inode->i_mapping;
        struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
+       struct f2fs_lock_context lc;
        int submitted, compr_blocks, i;
        int ret = 0;
 
@@ -1529,7 +1531,7 @@ static int f2fs_write_raw_pages(struct compress_ctx *cc,
 
        /* overwrite compressed cluster w/ normal cluster */
        if (compr_blocks > 0)
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
 
        for (i = 0; i < cc->cluster_size; i++) {
                struct folio *folio;
@@ -1585,7 +1587,7 @@ continue_unlock:
 
 out:
        if (compr_blocks > 0)
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
 
        f2fs_balance_fs(sbi, true);
        return ret;

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 471e52c6c1e03e462e5d2b1aa097fb0944be71c2..73fcafbc819128651d385d082b272c4e4244f805 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1466,34 +1466,39 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)
        return 0;
 }
 
-static void f2fs_map_lock(struct f2fs_sb_info *sbi, int flag)
+static void f2fs_map_lock(struct f2fs_sb_info *sbi,
+                               struct f2fs_lock_context *lc,
+                               int flag)
 {
        f2fs_down_read(&sbi->cp_enable_rwsem);
        if (flag == F2FS_GET_BLOCK_PRE_AIO)
                f2fs_down_read(&sbi->node_change);
        else
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, lc);
 }
 
-static void f2fs_map_unlock(struct f2fs_sb_info *sbi, int flag)
+static void f2fs_map_unlock(struct f2fs_sb_info *sbi,
+                               struct f2fs_lock_context *lc,
+                               int flag)
 {
        if (flag == F2FS_GET_BLOCK_PRE_AIO)
                f2fs_up_read(&sbi->node_change);
        else
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, lc);
        f2fs_up_read(&sbi->cp_enable_rwsem);
 }
 
 int f2fs_get_block_locked(struct dnode_of_data *dn, pgoff_t index)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
+       struct f2fs_lock_context lc;
        int err = 0;
 
-       f2fs_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO);
+       f2fs_map_lock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO);
        if (!f2fs_lookup_read_extent_cache_block(dn->inode, index,
                                                &dn->data_blkaddr))
                err = f2fs_reserve_block(dn, index);
-       f2fs_map_unlock(sbi, F2FS_GET_BLOCK_PRE_AIO);
+       f2fs_map_unlock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO);
 
        return err;
 }
@@ -1584,6 +1589,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, int flag)
        unsigned int maxblocks = map->m_len;
        struct dnode_of_data dn;
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_lock_context lc;
        int mode = map->m_may_create ? ALLOC_NODE : LOOKUP_NODE;
        pgoff_t pgofs, end_offset, end;
        int err = 0, ofs = 1;
@@ -1622,7 +1628,7 @@ next_dnode:
        if (map->m_may_create) {
                if (f2fs_lfs_mode(sbi))
                        f2fs_balance_fs(sbi, true);
-               f2fs_map_lock(sbi, flag);
+               f2fs_map_lock(sbi, &lc, flag);
        }
 
        /* When reading holes, we need its node page */
@@ -1788,7 +1794,7 @@ skip:
        f2fs_put_dnode(&dn);
 
        if (map->m_may_create) {
-               f2fs_map_unlock(sbi, flag);
+               f2fs_map_unlock(sbi, &lc, flag);
                f2fs_balance_fs(sbi, dn.node_changed);
        }
        goto next_dnode;
@@ -1835,7 +1841,7 @@ sync_out:
        f2fs_put_dnode(&dn);
 unlock_out:
        if (map->m_may_create) {
-               f2fs_map_unlock(sbi, flag);
+               f2fs_map_unlock(sbi, &lc, flag);
                f2fs_balance_fs(sbi, dn.node_changed);
        }
 out:
@@ -2865,6 +2871,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
        struct inode *inode = folio->mapping->host;
        struct dnode_of_data dn;
        struct node_info ni;
+       struct f2fs_lock_context lc;
        bool ipu_force = false;
        bool atomic_commit;
        int err = 0;
@@ -2890,7 +2897,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
        }
 
        /* Deadlock due to between page->lock and f2fs_lock_op */
-       if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi))
+       if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc))
                return -EAGAIN;
 
        err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);
@@ -2931,7 +2938,7 @@ got_it:
                folio_start_writeback(folio);
                f2fs_put_dnode(&dn);
                if (fio->need_lock == LOCK_REQ)
-                       f2fs_unlock_op(fio->sbi);
+                       f2fs_unlock_op(fio->sbi, &lc);
                err = f2fs_inplace_write_data(fio);
                if (err) {
                        if (fscrypt_inode_uses_fs_layer_crypto(inode))
@@ -2945,7 +2952,7 @@ got_it:
        }
 
        if (fio->need_lock == LOCK_RETRY) {
-               if (!f2fs_trylock_op(fio->sbi)) {
+               if (!f2fs_trylock_op(fio->sbi, &lc)) {
                        err = -EAGAIN;
                        goto out_writepage;
                }
@@ -2977,7 +2984,7 @@ out_writepage:
        f2fs_put_dnode(&dn);
 out:
        if (fio->need_lock == LOCK_REQ)
-               f2fs_unlock_op(fio->sbi);
+               f2fs_unlock_op(fio->sbi, &lc);
        return err;
 }
 
@@ -3570,6 +3577,7 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
        struct inode *inode = folio->mapping->host;
        pgoff_t index = folio->index;
        struct dnode_of_data dn;
+       struct f2fs_lock_context lc;
        struct folio *ifolio;
        bool locked = false;
        int flag = F2FS_GET_BLOCK_PRE_AIO;
@@ -3586,10 +3594,10 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
        if (f2fs_has_inline_data(inode)) {
                if (pos + len > MAX_INLINE_DATA(inode))
                        flag = F2FS_GET_BLOCK_DEFAULT;
-               f2fs_map_lock(sbi, flag);
+               f2fs_map_lock(sbi, &lc, flag);
                locked = true;
        } else if ((pos & PAGE_MASK) >= i_size_read(inode)) {
-               f2fs_map_lock(sbi, flag);
+               f2fs_map_lock(sbi, &lc, flag);
                locked = true;
        }
 
@@ -3633,7 +3641,7 @@ restart:
                if (!err && dn.data_blkaddr != NULL_ADDR)
                        goto out;
                f2fs_put_dnode(&dn);
-               f2fs_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO);
+               f2fs_map_lock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO);
                WARN_ON(flag != F2FS_GET_BLOCK_PRE_AIO);
                locked = true;
                goto restart;
@@ -3647,7 +3655,7 @@ out:
        f2fs_put_dnode(&dn);
 unlock_out:
        if (locked)
-               f2fs_map_unlock(sbi, flag);
+               f2fs_map_unlock(sbi, &lc, flag);
        return err;
 }
 
@@ -3683,10 +3691,11 @@ static int __reserve_data_block(struct inode *inode, pgoff_t index,
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct dnode_of_data dn;
+       struct f2fs_lock_context lc;
        struct folio *ifolio;
        int err = 0;
 
-       f2fs_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO);
+       f2fs_map_lock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO);
 
        ifolio = f2fs_get_inode_folio(sbi, inode->i_ino);
        if (IS_ERR(ifolio)) {
@@ -3704,7 +3713,7 @@ static int __reserve_data_block(struct inode *inode, pgoff_t index,
        f2fs_put_dnode(&dn);
 
 unlock_out:
-       f2fs_map_unlock(sbi, F2FS_GET_BLOCK_PRE_AIO);
+       f2fs_map_unlock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO);
        return err;
 }
 

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 7f2675ed7f8609179c3b72b51d65506f79773b3b..58244bb87fef51d51ad85475125152aa3cc235c8 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -175,6 +175,7 @@ enum device_allocation_policy {
 
 enum f2fs_lock_name {
        LOCK_NAME_NONE,
+       LOCK_NAME_CP_RWSEM,
 };
 
 /*
@@ -2417,33 +2418,6 @@ static inline bool enabled_nat_bits(struct f2fs_sb_info *sbi,
        return (cpc) ? (cpc->reason & CP_UMOUNT) && set : set;
 }
 
-static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
-{
-       f2fs_down_read(&sbi->cp_rwsem);
-}
-
-static inline int f2fs_trylock_op(struct f2fs_sb_info *sbi)
-{
-       if (time_to_inject(sbi, FAULT_LOCK_OP))
-               return 0;
-       return f2fs_down_read_trylock(&sbi->cp_rwsem);
-}
-
-static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
-{
-       f2fs_up_read(&sbi->cp_rwsem);
-}
-
-static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
-{
-       f2fs_down_write(&sbi->cp_rwsem);
-}
-
-static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
-{
-       f2fs_up_write(&sbi->cp_rwsem);
-}
-
 static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
 {
        int reason = CP_SYNC;
@@ -3770,7 +3744,7 @@ void f2fs_update_inode_page(struct inode *inode);
 int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);
 void f2fs_remove_donate_inode(struct inode *inode);
 void f2fs_evict_inode(struct inode *inode);
-void f2fs_handle_failed_inode(struct inode *inode);
+void f2fs_handle_failed_inode(struct inode *inode, struct f2fs_lock_context *lc);
 
 /*
  * namei.c
@@ -4037,6 +4011,9 @@ static inline bool f2fs_need_rand_seg(struct f2fs_sb_info *sbi)
 /*
  * checkpoint.c
  */
+void f2fs_lock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc);
+int f2fs_trylock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc);
+void f2fs_unlock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc);
 void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io,
                                                        unsigned char reason);
 void f2fs_flush_ckpt_thread(struct f2fs_sb_info *sbi);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index e75e61ac50d72acd6a1bd9714bc19e15f18032d8..1cdbbc2e1005df8e4a85088677e400e637ded7b2 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -774,6 +774,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct dnode_of_data dn;
+       struct f2fs_lock_context lc;
        pgoff_t free_from;
        int count = 0, err = 0;
        struct folio *ifolio;
@@ -792,7 +793,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
                goto free_partial;
 
        if (lock)
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
 
        ifolio = f2fs_get_inode_folio(sbi, inode->i_ino);
        if (IS_ERR(ifolio)) {
@@ -843,7 +844,7 @@ free_next:
        err = f2fs_truncate_inode_blocks(inode, free_from);
 out:
        if (lock)
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
 free_partial:
        /* lastly zero out the first data page */
        if (!err)
@@ -1118,11 +1119,13 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
        }
        if (i_uid_needs_update(idmap, attr, inode) ||
            i_gid_needs_update(idmap, attr, inode)) {
-               f2fs_lock_op(sbi);
+               struct f2fs_lock_context lc;
+
+               f2fs_lock_op(sbi, &lc);
                err = dquot_transfer(idmap, inode, attr);
                if (err) {
                        set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
-                       f2fs_unlock_op(sbi);
+                       f2fs_unlock_op(sbi, &lc);
                        return err;
                }
                /*
@@ -1132,7 +1135,7 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
                i_uid_update(idmap, attr, inode);
                i_gid_update(idmap, attr, inode);
                f2fs_mark_inode_dirty_sync(inode, true);
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
        }
 
        if (attr->ia_valid & ATTR_SIZE) {
@@ -1216,15 +1219,16 @@ static int fill_zero(struct inode *inode, pgoff_t index,
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct folio *folio;
+       struct f2fs_lock_context lc;
 
        if (!len)
                return 0;
 
        f2fs_balance_fs(sbi, true);
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        folio = f2fs_get_new_data_folio(inode, NULL, index, false);
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        if (IS_ERR(folio))
                return PTR_ERR(folio);
@@ -1307,6 +1311,7 @@ static int f2fs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
                if (pg_start < pg_end) {
                        loff_t blk_start, blk_end;
                        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+                       struct f2fs_lock_context lc;
 
                        f2fs_balance_fs(sbi, true);
 
@@ -1318,9 +1323,9 @@ static int f2fs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
 
                        truncate_pagecache_range(inode, blk_start, blk_end - 1);
 
-                       f2fs_lock_op(sbi);
+                       f2fs_lock_op(sbi, &lc);
                        ret = f2fs_truncate_hole(inode, pg_start, pg_end);
-                       f2fs_unlock_op(sbi);
+                       f2fs_unlock_op(sbi, &lc);
 
                        filemap_invalidate_unlock(inode->i_mapping);
                        f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
@@ -1552,6 +1557,7 @@ roll_back:
 static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_lock_context lc;
        pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
        pgoff_t start = offset >> PAGE_SHIFT;
        pgoff_t end = (offset + len) >> PAGE_SHIFT;
@@ -1565,11 +1571,11 @@ static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
 
        f2fs_zero_post_eof_page(inode, offset + len, false);
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        f2fs_drop_extent_tree(inode);
        truncate_pagecache(inode, offset);
        ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        filemap_invalidate_unlock(inode->i_mapping);
        f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
@@ -1717,6 +1723,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
 
                for (index = pg_start; index < pg_end;) {
                        struct dnode_of_data dn;
+                       struct f2fs_lock_context lc;
                        unsigned int end_offset;
                        pgoff_t end;
 
@@ -1727,12 +1734,12 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
                                (loff_t)index << PAGE_SHIFT,
                                ((loff_t)pg_end << PAGE_SHIFT) - 1);
 
-                       f2fs_lock_op(sbi);
+                       f2fs_lock_op(sbi, &lc);
 
                        set_new_dnode(&dn, inode, NULL, NULL, 0);
                        ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE);
                        if (ret) {
-                               f2fs_unlock_op(sbi);
+                               f2fs_unlock_op(sbi, &lc);
                                filemap_invalidate_unlock(mapping);
                                f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                                goto out;
@@ -1744,7 +1751,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
                        ret = f2fs_do_zero_range(&dn, index, end);
                        f2fs_put_dnode(&dn);
 
-                       f2fs_unlock_op(sbi);
+                       f2fs_unlock_op(sbi, &lc);
                        filemap_invalidate_unlock(mapping);
                        f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 
@@ -1827,17 +1834,19 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
        truncate_pagecache(inode, offset);
 
        while (!ret && idx > pg_start) {
+               struct f2fs_lock_context lc;
+
                nr = idx - pg_start;
                if (nr > delta)
                        nr = delta;
                idx -= nr;
 
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
                f2fs_drop_extent_tree(inode);
 
                ret = __exchange_data_block(inode, inode, idx,
                                        idx + delta, nr, false);
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
        }
        filemap_invalidate_unlock(mapping);
        f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
@@ -3093,6 +3102,7 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
        struct inode *src = file_inode(file_in);
        struct inode *dst = file_inode(file_out);
        struct f2fs_sb_info *sbi = F2FS_I_SB(src);
+       struct f2fs_lock_context lc;
        size_t olen = len, dst_max_i_size = 0;
        size_t dst_osize;
        int ret;
@@ -3188,7 +3198,7 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
                        goto out_src;
        }
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        ret = __exchange_data_block(src, dst, F2FS_BYTES_TO_BLK(pos_in),
                                F2FS_BYTES_TO_BLK(pos_out),
                                F2FS_BYTES_TO_BLK(len), false);
@@ -3199,7 +3209,7 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
                else if (dst_osize != dst->i_size)
                        f2fs_i_size_write(dst, dst_osize);
        }
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        if (src != dst)
                f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
@@ -3367,6 +3377,7 @@ static int f2fs_ioc_setproject(struct inode *inode, __u32 projid)
        struct f2fs_inode_info *fi = F2FS_I(inode);
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct f2fs_inode *ri = NULL;
+       struct f2fs_lock_context lc;
        kprojid_t kprojid;
        int err;
 
@@ -3397,7 +3408,7 @@ static int f2fs_ioc_setproject(struct inode *inode, __u32 projid)
        if (err)
                return err;
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_transfer_project_quota(inode, kprojid);
        if (err)
                goto out_unlock;
@@ -3406,7 +3417,7 @@ static int f2fs_ioc_setproject(struct inode *inode, __u32 projid)
        inode_set_ctime_current(inode);
        f2fs_mark_inode_dirty_sync(inode, true);
 out_unlock:
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        return err;
 }
 #else
@@ -3839,6 +3850,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
        struct inode *inode = file_inode(filp);
        struct f2fs_inode_info *fi = F2FS_I(inode);
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_lock_context lc;
        pgoff_t page_idx = 0, last_idx;
        unsigned int released_blocks = 0;
        int ret;
@@ -3893,12 +3905,12 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
                struct dnode_of_data dn;
                pgoff_t end_offset, count;
 
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
 
                set_new_dnode(&dn, inode, NULL, NULL, 0);
                ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE);
                if (ret) {
-                       f2fs_unlock_op(sbi);
+                       f2fs_unlock_op(sbi, &lc);
                        if (ret == -ENOENT) {
                                page_idx = f2fs_get_next_page_offset(&dn,
                                                                page_idx);
@@ -3916,7 +3928,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
 
                f2fs_put_dnode(&dn);
 
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
 
                if (ret < 0)
                        break;
@@ -4069,14 +4081,15 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
 
        while (page_idx < last_idx) {
                struct dnode_of_data dn;
+               struct f2fs_lock_context lc;
                pgoff_t end_offset, count;
 
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
 
                set_new_dnode(&dn, inode, NULL, NULL, 0);
                ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE);
                if (ret) {
-                       f2fs_unlock_op(sbi);
+                       f2fs_unlock_op(sbi, &lc);
                        if (ret == -ENOENT) {
                                page_idx = f2fs_get_next_page_offset(&dn,
                                                                page_idx);
@@ -4094,7 +4107,7 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
 
                f2fs_put_dnode(&dn);
 
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
 
                if (ret < 0)
                        break;

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index ba66d8bc9b5f298ec6d34422d20dbfb89e16718d..8999829a95590c64f40e86be8e9995105e86aa6a 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -2263,6 +2263,7 @@ int f2fs_resize_fs(struct file *filp, __u64 block_count)
        struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp));
        __u64 old_block_count, shrunk_blocks;
        struct cp_control cpc = { CP_RESIZE, 0, 0, 0 };
+       struct f2fs_lock_context lc;
        unsigned int secs;
        int err = 0;
        __u32 rem;
@@ -2312,7 +2313,7 @@ int f2fs_resize_fs(struct file *filp, __u64 block_count)
        }
 
        /* stop CP to protect MAIN_SEC in free_segment_range */
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
 
        spin_lock(&sbi->stat_lock);
        if (shrunk_blocks + valid_user_blocks(sbi) +
@@ -2327,7 +2328,7 @@ int f2fs_resize_fs(struct file *filp, __u64 block_count)
        err = free_segment_range(sbi, secs, true);
 
 out_unlock:
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        f2fs_up_write(&sbi->gc_lock);
 out_drop_write:
        mnt_drop_write_file(filp);

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index e5c6a08b7e4f3fb995212750722e106cd227c768..0a1052d5ee624e68ba27200b100a567a5d216f2a 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -218,6 +218,7 @@ int f2fs_convert_inline_inode(struct inode *inode)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct dnode_of_data dn;
+       struct f2fs_lock_context lc;
        struct folio *ifolio, *folio;
        int err = 0;
 
@@ -235,7 +236,7 @@ int f2fs_convert_inline_inode(struct inode *inode)
        if (IS_ERR(folio))
                return PTR_ERR(folio);
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
 
        ifolio = f2fs_get_inode_folio(sbi, inode->i_ino);
        if (IS_ERR(ifolio)) {
@@ -250,7 +251,7 @@ int f2fs_convert_inline_inode(struct inode *inode)
 
        f2fs_put_dnode(&dn);
 out:
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        f2fs_folio_put(folio, true);
 
@@ -597,13 +598,14 @@ int f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry)
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
        struct folio *ifolio;
        struct f2fs_filename fname;
+       struct f2fs_lock_context lc;
        void *inline_dentry = NULL;
        int err = 0;
 
        if (!f2fs_has_inline_dentry(dir))
                return 0;
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
 
        err = f2fs_setup_filename(dir, &dentry->d_name, 0, &fname);
        if (err)
@@ -628,7 +630,7 @@ int f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry)
 out_fname:
        f2fs_free_filename(&fname);
 out:
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        return err;
 }
 

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index d1270b25ad7d7c030f1870e7d161f97073fd0fdb..b8cf1fab63912d1f13f85a3df084db4de9f34c26 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -910,9 +910,11 @@ retry:
                err = -EIO;
 
        if (!err) {
-               f2fs_lock_op(sbi);
+               struct f2fs_lock_context lc;
+
+               f2fs_lock_op(sbi, &lc);
                err = f2fs_remove_inode_page(inode);
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
                if (err == -ENOENT) {
                        err = 0;
 
@@ -1009,7 +1011,7 @@ out_clear:
 }
 
 /* caller should call f2fs_lock_op() */
-void f2fs_handle_failed_inode(struct inode *inode)
+void f2fs_handle_failed_inode(struct inode *inode, struct f2fs_lock_context *lc)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct node_info ni;
@@ -1058,7 +1060,7 @@ void f2fs_handle_failed_inode(struct inode *inode)
        }
 
 out:
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, lc);
 
        /* iput will drop the inode object */
        iput(inode);

diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 043d20516a21c1d6897721bd62ae1d04aacb50d2..e360f08a9586ab5b75d6e1e1748219c3190a7580 100644 (file)
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -354,6 +354,7 @@ static int f2fs_create(struct mnt_idmap *idmap, struct inode *dir,
                       struct dentry *dentry, umode_t mode, bool excl)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+       struct f2fs_lock_context lc;
        struct inode *inode;
        nid_t ino = 0;
        int err;
@@ -376,11 +377,11 @@ static int f2fs_create(struct mnt_idmap *idmap, struct inode *dir,
        inode->i_mapping->a_ops = &f2fs_dblock_aops;
        ino = inode->i_ino;
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_add_link(dentry, inode);
        if (err)
                goto out;
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        f2fs_alloc_nid_done(sbi, ino);
 
@@ -392,7 +393,7 @@ static int f2fs_create(struct mnt_idmap *idmap, struct inode *dir,
        f2fs_balance_fs(sbi, true);
        return 0;
 out:
-       f2fs_handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode, &lc);
        return err;
 }
 
@@ -401,6 +402,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
 {
        struct inode *inode = d_inode(old_dentry);
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+       struct f2fs_lock_context lc;
        int err;
 
        if (unlikely(f2fs_cp_error(sbi)))
@@ -427,11 +429,11 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
        ihold(inode);
 
        set_inode_flag(inode, FI_INC_LINK);
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_add_link(dentry, inode);
        if (err)
                goto out;
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        d_instantiate(dentry, inode);
 
@@ -441,7 +443,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
 out:
        clear_inode_flag(inode, FI_INC_LINK);
        iput(inode);
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        return err;
 }
 
@@ -545,6 +547,7 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
        struct inode *inode = d_inode(dentry);
        struct f2fs_dir_entry *de;
+       struct f2fs_lock_context lc;
        struct folio *folio;
        int err;
 
@@ -581,15 +584,15 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
 
        f2fs_balance_fs(sbi, true);
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_acquire_orphan_inode(sbi);
        if (err) {
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
                f2fs_folio_put(folio, false);
                goto out;
        }
        f2fs_delete_entry(de, folio, dir, inode);
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        /* VFS negative dentries are incompatible with Encoding and
         * Case-insensitiveness. Eventually we'll want avoid
@@ -632,6 +635,7 @@ static int f2fs_symlink(struct mnt_idmap *idmap, struct inode *dir,
                        struct dentry *dentry, const char *symname)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+       struct f2fs_lock_context lc;
        struct inode *inode;
        size_t len = strlen(symname);
        struct fscrypt_str disk_link;
@@ -662,11 +666,11 @@ static int f2fs_symlink(struct mnt_idmap *idmap, struct inode *dir,
        inode_nohighmem(inode);
        inode->i_mapping->a_ops = &f2fs_dblock_aops;
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_add_link(dentry, inode);
        if (err)
                goto out_f2fs_handle_failed_inode;
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        f2fs_alloc_nid_done(sbi, inode->i_ino);
 
        err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
@@ -701,7 +705,7 @@ err_out:
        goto out_free_encrypted_link;
 
 out_f2fs_handle_failed_inode:
-       f2fs_handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode, &lc);
 out_free_encrypted_link:
        if (disk_link.name != (unsigned char *)symname)
                kfree(disk_link.name);
@@ -712,6 +716,7 @@ static struct dentry *f2fs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
                                 struct dentry *dentry, umode_t mode)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+       struct f2fs_lock_context lc;
        struct inode *inode;
        int err;
 
@@ -732,11 +737,11 @@ static struct dentry *f2fs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
        mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
 
        set_inode_flag(inode, FI_INC_LINK);
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_add_link(dentry, inode);
        if (err)
                goto out_fail;
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        f2fs_alloc_nid_done(sbi, inode->i_ino);
 
@@ -750,7 +755,7 @@ static struct dentry *f2fs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
 
 out_fail:
        clear_inode_flag(inode, FI_INC_LINK);
-       f2fs_handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode, &lc);
        return ERR_PTR(err);
 }
 
@@ -767,6 +772,7 @@ static int f2fs_mknod(struct mnt_idmap *idmap, struct inode *dir,
                      struct dentry *dentry, umode_t mode, dev_t rdev)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+       struct f2fs_lock_context lc;
        struct inode *inode;
        int err = 0;
 
@@ -786,11 +792,11 @@ static int f2fs_mknod(struct mnt_idmap *idmap, struct inode *dir,
        init_special_inode(inode, inode->i_mode, rdev);
        inode->i_op = &f2fs_special_inode_operations;
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_add_link(dentry, inode);
        if (err)
                goto out;
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        f2fs_alloc_nid_done(sbi, inode->i_ino);
 
@@ -802,7 +808,7 @@ static int f2fs_mknod(struct mnt_idmap *idmap, struct inode *dir,
        f2fs_balance_fs(sbi, true);
        return 0;
 out:
-       f2fs_handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode, &lc);
        return err;
 }
 
@@ -811,6 +817,7 @@ static int __f2fs_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
                          struct inode **new_inode, struct f2fs_filename *fname)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
+       struct f2fs_lock_context lc;
        struct inode *inode;
        int err;
 
@@ -831,7 +838,7 @@ static int __f2fs_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
                inode->i_mapping->a_ops = &f2fs_dblock_aops;
        }
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_acquire_orphan_inode(sbi);
        if (err)
                goto out;
@@ -860,7 +867,7 @@ static int __f2fs_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
                        f2fs_i_links_write(inode, false);
        }
        /* link_count was changed by d_tmpfile as well. */
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        unlock_new_inode(inode);
 
        if (new_inode)
@@ -872,7 +879,7 @@ static int __f2fs_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
 release_out:
        f2fs_release_orphan_inode(sbi);
 out:
-       f2fs_handle_failed_inode(inode);
+       f2fs_handle_failed_inode(inode, &lc);
        return err;
 }
 
@@ -920,6 +927,7 @@ static int f2fs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
        struct f2fs_dir_entry *old_dir_entry = NULL;
        struct f2fs_dir_entry *old_entry;
        struct f2fs_dir_entry *new_entry;
+       struct f2fs_lock_context lc;
        bool old_is_dir = S_ISDIR(old_inode->i_mode);
        int err;
 
@@ -1008,7 +1016,7 @@ static int f2fs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
 
                f2fs_balance_fs(sbi, true);
 
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
 
                err = f2fs_acquire_orphan_inode(sbi);
                if (err)
@@ -1031,11 +1039,11 @@ static int f2fs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
        } else {
                f2fs_balance_fs(sbi, true);
 
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
 
                err = f2fs_add_link(new_dentry, old_inode);
                if (err) {
-                       f2fs_unlock_op(sbi);
+                       f2fs_unlock_op(sbi, &lc);
                        goto out_dir;
                }
 
@@ -1084,7 +1092,7 @@ static int f2fs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
                                                        TRANS_DIR_INO);
        }
 
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
                f2fs_sync_fs(sbi->sb, 1);
@@ -1093,7 +1101,7 @@ static int f2fs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
        return 0;
 
 put_out_dir:
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        f2fs_folio_put(new_folio, false);
 out_dir:
        if (old_dir_entry)
@@ -1115,6 +1123,7 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct folio *old_folio, *new_folio;
        struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
        struct f2fs_dir_entry *old_entry, *new_entry;
+       struct f2fs_lock_context lc;
        int old_nlink = 0, new_nlink = 0;
        int err;
 
@@ -1194,7 +1203,7 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
 
        f2fs_balance_fs(sbi, true);
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
 
        /* update ".." directory entry info of old dentry */
        if (old_dir_entry)
@@ -1247,7 +1256,7 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
                f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO);
        }
 
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
                f2fs_sync_fs(sbi->sb, 1);

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index c0c5b7075b04de2042106ab567d87d59a239522b..e4a8daf433a8fe9c980506b37fb2ec35ddddc0ee 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -400,6 +400,7 @@ int f2fs_commit_atomic_write(struct inode *inode)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct f2fs_inode_info *fi = F2FS_I(inode);
+       struct f2fs_lock_context lc;
        int err;
 
        err = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
@@ -407,11 +408,11 @@ int f2fs_commit_atomic_write(struct inode *inode)
                return err;
 
        f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
 
        err = __f2fs_commit_atomic_write(inode);
 
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
        f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
 
        return err;
@@ -3362,13 +3363,14 @@ int f2fs_allocate_new_section(struct f2fs_sb_info *sbi, int type, bool force)
 
 int f2fs_allocate_pinning_section(struct f2fs_sb_info *sbi)
 {
+       struct f2fs_lock_context lc;
        int err;
        bool gc_required = true;
 
 retry:
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        err = f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        if (f2fs_sb_has_blkzoned(sbi) && err == -EAGAIN && gc_required) {
                f2fs_down_write(&sbi->gc_lock);

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 8fe1ac8a609cdcd147c4879900d254c058b668a1..d70567b48d12817307594f2e42996882bd7b687e 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -3325,6 +3325,7 @@ int f2fs_do_quota_sync(struct super_block *sb, int type)
         * that userspace sees the changes.
         */
        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
+               struct f2fs_lock_context lc;
 
                if (type != -1 && cnt != type)
                        continue;
@@ -3344,13 +3345,13 @@ int f2fs_do_quota_sync(struct super_block *sb, int type)
                 *                            block_operation
                 *                            f2fs_down_read(quota_sem)
                 */
-               f2fs_lock_op(sbi);
+               f2fs_lock_op(sbi, &lc);
                f2fs_down_read(&sbi->quota_sem);
 
                ret = f2fs_quota_sync_file(sbi, cnt);
 
                f2fs_up_read(&sbi->quota_sem);
-               f2fs_unlock_op(sbi);
+               f2fs_unlock_op(sbi, &lc);
 
                if (!f2fs_sb_has_quota_ino(sbi))
                        inode_unlock(dqopt->files[cnt]);
@@ -4898,7 +4899,7 @@ try_onemore:
        init_f2fs_rwsem(&sbi->node_write);
        init_f2fs_rwsem(&sbi->node_change);
        spin_lock_init(&sbi->stat_lock);
-       init_f2fs_rwsem(&sbi->cp_rwsem);
+       init_f2fs_rwsem_trace(&sbi->cp_rwsem, sbi, LOCK_NAME_CP_RWSEM);
        init_f2fs_rwsem(&sbi->cp_enable_rwsem);
        init_f2fs_rwsem(&sbi->quota_sem);
        init_waitqueue_head(&sbi->cp_wait);

diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index b4e5c406632f81e839f52951bd4a82a8a5cff48b..941dc62a6d6f7c50c1a661397ef1bbb611e6c304 100644 (file)
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -804,6 +804,7 @@ int f2fs_setxattr(struct inode *inode, int index, const char *name,
                                struct folio *ifolio, int flags)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_lock_context lc;
        int err;
 
        if (unlikely(f2fs_cp_error(sbi)))
@@ -821,11 +822,11 @@ int f2fs_setxattr(struct inode *inode, int index, const char *name,
                                                size, ifolio, flags);
        f2fs_balance_fs(sbi, true);
 
-       f2fs_lock_op(sbi);
+       f2fs_lock_op(sbi, &lc);
        f2fs_down_write(&F2FS_I(inode)->i_xattr_sem);
        err = __f2fs_setxattr(inode, index, name, value, size, NULL, flags);
        f2fs_up_write(&F2FS_I(inode)->i_xattr_sem);
-       f2fs_unlock_op(sbi);
+       f2fs_unlock_op(sbi, &lc);
 
        f2fs_update_time(sbi, REQ_TIME);
        return err;

diff --git a/include/trace/events/f2fs.h b/include/trace/events/f2fs.h
index 9a852a16df9cb6b8e32c6b1111d556c7a43a7dfd..f4f13ddbe1042f67995c214b23798a87ecfba69c 100644 (file)
--- a/include/trace/events/f2fs.h
+++ b/include/trace/events/f2fs.h
@@ -186,7 +186,7 @@ TRACE_DEFINE_ENUM(CP_PHASE_FINISH_CHECKPOINT);
 
 #define show_lock_name(lock)                                           \
        __print_symbolic(lock,                                          \
-               { LOCK_NAME_NONE,               "none" })
+               { LOCK_NAME_CP_RWSEM,           "cp_rwsem" })
 
 struct f2fs_sb_info;
 struct f2fs_io_info;