tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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>

authored by

Chao Yu and committed by
Jaegeuk Kim 66e9e0d5 e4b75621

+173 -126
+28
fs/f2fs/checkpoint.c
··· 127 127 trace_lock_elapsed_time_end(sem, lc, true); 128 128 } 129 129 130 + void f2fs_lock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc) 131 + { 132 + f2fs_down_read_trace(&sbi->cp_rwsem, lc); 133 + } 134 + 135 + int f2fs_trylock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc) 136 + { 137 + if (time_to_inject(sbi, FAULT_LOCK_OP)) 138 + return 0; 139 + 140 + return f2fs_down_read_trylock_trace(&sbi->cp_rwsem, lc); 141 + } 142 + 143 + void f2fs_unlock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc) 144 + { 145 + f2fs_up_read_trace(&sbi->cp_rwsem, lc); 146 + } 147 + 148 + static inline void f2fs_lock_all(struct f2fs_sb_info *sbi) 149 + { 150 + f2fs_down_write(&sbi->cp_rwsem); 151 + } 152 + 153 + static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi) 154 + { 155 + f2fs_up_write(&sbi->cp_rwsem); 156 + } 157 + 130 158 #define DEFAULT_CHECKPOINT_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_RT, 3)) 131 159 132 160 static struct kmem_cache *ino_entry_slab;
+7 -5
fs/f2fs/compress.c
··· 1290 1290 struct dnode_of_data dn; 1291 1291 struct node_info ni; 1292 1292 struct compress_io_ctx *cic; 1293 + struct f2fs_lock_context lc; 1293 1294 pgoff_t start_idx = start_idx_of_cluster(cc); 1294 1295 unsigned int last_index = cc->cluster_size - 1; 1295 1296 loff_t psize; ··· 1310 1309 * the below discard race condition. 1311 1310 */ 1312 1311 f2fs_down_read(&sbi->node_write); 1313 - } else if (!f2fs_trylock_op(sbi)) { 1312 + } else if (!f2fs_trylock_op(sbi, &lc)) { 1314 1313 goto out_free; 1315 1314 } 1316 1315 ··· 1436 1435 if (quota_inode) 1437 1436 f2fs_up_read(&sbi->node_write); 1438 1437 else 1439 - f2fs_unlock_op(sbi); 1438 + f2fs_unlock_op(sbi, &lc); 1440 1439 1441 1440 spin_lock(&fi->i_size_lock); 1442 1441 if (fi->last_disk_size < psize) ··· 1465 1464 if (quota_inode) 1466 1465 f2fs_up_read(&sbi->node_write); 1467 1466 else 1468 - f2fs_unlock_op(sbi); 1467 + f2fs_unlock_op(sbi, &lc); 1469 1468 out_free: 1470 1469 for (i = 0; i < cc->valid_nr_cpages; i++) { 1471 1470 f2fs_compress_free_page(cc->cpages[i]); ··· 1512 1511 { 1513 1512 struct address_space *mapping = cc->inode->i_mapping; 1514 1513 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping); 1514 + struct f2fs_lock_context lc; 1515 1515 int submitted, compr_blocks, i; 1516 1516 int ret = 0; 1517 1517 ··· 1531 1529 1532 1530 /* overwrite compressed cluster w/ normal cluster */ 1533 1531 if (compr_blocks > 0) 1534 - f2fs_lock_op(sbi); 1532 + f2fs_lock_op(sbi, &lc); 1535 1533 1536 1534 for (i = 0; i < cc->cluster_size; i++) { 1537 1535 struct folio *folio; ··· 1587 1585 1588 1586 out: 1589 1587 if (compr_blocks > 0) 1590 - f2fs_unlock_op(sbi); 1588 + f2fs_unlock_op(sbi, &lc); 1591 1589 1592 1590 f2fs_balance_fs(sbi, true); 1593 1591 return ret;
+28 -19
fs/f2fs/data.c
··· 1466 1466 return 0; 1467 1467 } 1468 1468 1469 - static void f2fs_map_lock(struct f2fs_sb_info *sbi, int flag) 1469 + static void f2fs_map_lock(struct f2fs_sb_info *sbi, 1470 + struct f2fs_lock_context *lc, 1471 + int flag) 1470 1472 { 1471 1473 f2fs_down_read(&sbi->cp_enable_rwsem); 1472 1474 if (flag == F2FS_GET_BLOCK_PRE_AIO) 1473 1475 f2fs_down_read(&sbi->node_change); 1474 1476 else 1475 - f2fs_lock_op(sbi); 1477 + f2fs_lock_op(sbi, lc); 1476 1478 } 1477 1479 1478 - static void f2fs_map_unlock(struct f2fs_sb_info *sbi, int flag) 1480 + static void f2fs_map_unlock(struct f2fs_sb_info *sbi, 1481 + struct f2fs_lock_context *lc, 1482 + int flag) 1479 1483 { 1480 1484 if (flag == F2FS_GET_BLOCK_PRE_AIO) 1481 1485 f2fs_up_read(&sbi->node_change); 1482 1486 else 1483 - f2fs_unlock_op(sbi); 1487 + f2fs_unlock_op(sbi, lc); 1484 1488 f2fs_up_read(&sbi->cp_enable_rwsem); 1485 1489 } 1486 1490 1487 1491 int f2fs_get_block_locked(struct dnode_of_data *dn, pgoff_t index) 1488 1492 { 1489 1493 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); 1494 + struct f2fs_lock_context lc; 1490 1495 int err = 0; 1491 1496 1492 - f2fs_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO); 1497 + f2fs_map_lock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO); 1493 1498 if (!f2fs_lookup_read_extent_cache_block(dn->inode, index, 1494 1499 &dn->data_blkaddr)) 1495 1500 err = f2fs_reserve_block(dn, index); 1496 - f2fs_map_unlock(sbi, F2FS_GET_BLOCK_PRE_AIO); 1501 + f2fs_map_unlock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO); 1497 1502 1498 1503 return err; 1499 1504 } ··· 1589 1584 unsigned int maxblocks = map->m_len; 1590 1585 struct dnode_of_data dn; 1591 1586 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1587 + struct f2fs_lock_context lc; 1592 1588 int mode = map->m_may_create ? ALLOC_NODE : LOOKUP_NODE; 1593 1589 pgoff_t pgofs, end_offset, end; 1594 1590 int err = 0, ofs = 1; ··· 1628 1622 if (map->m_may_create) { 1629 1623 if (f2fs_lfs_mode(sbi)) 1630 1624 f2fs_balance_fs(sbi, true); 1631 - f2fs_map_lock(sbi, flag); 1625 + f2fs_map_lock(sbi, &lc, flag); 1632 1626 } 1633 1627 1634 1628 /* When reading holes, we need its node page */ ··· 1794 1788 f2fs_put_dnode(&dn); 1795 1789 1796 1790 if (map->m_may_create) { 1797 - f2fs_map_unlock(sbi, flag); 1791 + f2fs_map_unlock(sbi, &lc, flag); 1798 1792 f2fs_balance_fs(sbi, dn.node_changed); 1799 1793 } 1800 1794 goto next_dnode; ··· 1841 1835 f2fs_put_dnode(&dn); 1842 1836 unlock_out: 1843 1837 if (map->m_may_create) { 1844 - f2fs_map_unlock(sbi, flag); 1838 + f2fs_map_unlock(sbi, &lc, flag); 1845 1839 f2fs_balance_fs(sbi, dn.node_changed); 1846 1840 } 1847 1841 out: ··· 2871 2865 struct inode *inode = folio->mapping->host; 2872 2866 struct dnode_of_data dn; 2873 2867 struct node_info ni; 2868 + struct f2fs_lock_context lc; 2874 2869 bool ipu_force = false; 2875 2870 bool atomic_commit; 2876 2871 int err = 0; ··· 2897 2890 } 2898 2891 2899 2892 /* Deadlock due to between page->lock and f2fs_lock_op */ 2900 - if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi)) 2893 + if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc)) 2901 2894 return -EAGAIN; 2902 2895 2903 2896 err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE); ··· 2938 2931 folio_start_writeback(folio); 2939 2932 f2fs_put_dnode(&dn); 2940 2933 if (fio->need_lock == LOCK_REQ) 2941 - f2fs_unlock_op(fio->sbi); 2934 + f2fs_unlock_op(fio->sbi, &lc); 2942 2935 err = f2fs_inplace_write_data(fio); 2943 2936 if (err) { 2944 2937 if (fscrypt_inode_uses_fs_layer_crypto(inode)) ··· 2952 2945 } 2953 2946 2954 2947 if (fio->need_lock == LOCK_RETRY) { 2955 - if (!f2fs_trylock_op(fio->sbi)) { 2948 + if (!f2fs_trylock_op(fio->sbi, &lc)) { 2956 2949 err = -EAGAIN; 2957 2950 goto out_writepage; 2958 2951 } ··· 2984 2977 f2fs_put_dnode(&dn); 2985 2978 out: 2986 2979 if (fio->need_lock == LOCK_REQ) 2987 - f2fs_unlock_op(fio->sbi); 2980 + f2fs_unlock_op(fio->sbi, &lc); 2988 2981 return err; 2989 2982 } 2990 2983 ··· 3577 3570 struct inode *inode = folio->mapping->host; 3578 3571 pgoff_t index = folio->index; 3579 3572 struct dnode_of_data dn; 3573 + struct f2fs_lock_context lc; 3580 3574 struct folio *ifolio; 3581 3575 bool locked = false; 3582 3576 int flag = F2FS_GET_BLOCK_PRE_AIO; ··· 3594 3586 if (f2fs_has_inline_data(inode)) { 3595 3587 if (pos + len > MAX_INLINE_DATA(inode)) 3596 3588 flag = F2FS_GET_BLOCK_DEFAULT; 3597 - f2fs_map_lock(sbi, flag); 3589 + f2fs_map_lock(sbi, &lc, flag); 3598 3590 locked = true; 3599 3591 } else if ((pos & PAGE_MASK) >= i_size_read(inode)) { 3600 - f2fs_map_lock(sbi, flag); 3592 + f2fs_map_lock(sbi, &lc, flag); 3601 3593 locked = true; 3602 3594 } 3603 3595 ··· 3641 3633 if (!err && dn.data_blkaddr != NULL_ADDR) 3642 3634 goto out; 3643 3635 f2fs_put_dnode(&dn); 3644 - f2fs_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO); 3636 + f2fs_map_lock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO); 3645 3637 WARN_ON(flag != F2FS_GET_BLOCK_PRE_AIO); 3646 3638 locked = true; 3647 3639 goto restart; ··· 3655 3647 f2fs_put_dnode(&dn); 3656 3648 unlock_out: 3657 3649 if (locked) 3658 - f2fs_map_unlock(sbi, flag); 3650 + f2fs_map_unlock(sbi, &lc, flag); 3659 3651 return err; 3660 3652 } 3661 3653 ··· 3691 3683 { 3692 3684 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 3693 3685 struct dnode_of_data dn; 3686 + struct f2fs_lock_context lc; 3694 3687 struct folio *ifolio; 3695 3688 int err = 0; 3696 3689 3697 - f2fs_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO); 3690 + f2fs_map_lock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO); 3698 3691 3699 3692 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); 3700 3693 if (IS_ERR(ifolio)) { ··· 3713 3704 f2fs_put_dnode(&dn); 3714 3705 3715 3706 unlock_out: 3716 - f2fs_map_unlock(sbi, F2FS_GET_BLOCK_PRE_AIO); 3707 + f2fs_map_unlock(sbi, &lc, F2FS_GET_BLOCK_PRE_AIO); 3717 3708 return err; 3718 3709 } 3719 3710
+5 -28
fs/f2fs/f2fs.h
··· 175 175 176 176 enum f2fs_lock_name { 177 177 LOCK_NAME_NONE, 178 + LOCK_NAME_CP_RWSEM, 178 179 }; 179 180 180 181 /* ··· 2418 2417 return (cpc) ? (cpc->reason & CP_UMOUNT) && set : set; 2419 2418 } 2420 2419 2421 - static inline void f2fs_lock_op(struct f2fs_sb_info *sbi) 2422 - { 2423 - f2fs_down_read(&sbi->cp_rwsem); 2424 - } 2425 - 2426 - static inline int f2fs_trylock_op(struct f2fs_sb_info *sbi) 2427 - { 2428 - if (time_to_inject(sbi, FAULT_LOCK_OP)) 2429 - return 0; 2430 - return f2fs_down_read_trylock(&sbi->cp_rwsem); 2431 - } 2432 - 2433 - static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi) 2434 - { 2435 - f2fs_up_read(&sbi->cp_rwsem); 2436 - } 2437 - 2438 - static inline void f2fs_lock_all(struct f2fs_sb_info *sbi) 2439 - { 2440 - f2fs_down_write(&sbi->cp_rwsem); 2441 - } 2442 - 2443 - static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi) 2444 - { 2445 - f2fs_up_write(&sbi->cp_rwsem); 2446 - } 2447 - 2448 2420 static inline int __get_cp_reason(struct f2fs_sb_info *sbi) 2449 2421 { 2450 2422 int reason = CP_SYNC; ··· 3744 3770 int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc); 3745 3771 void f2fs_remove_donate_inode(struct inode *inode); 3746 3772 void f2fs_evict_inode(struct inode *inode); 3747 - void f2fs_handle_failed_inode(struct inode *inode); 3773 + void f2fs_handle_failed_inode(struct inode *inode, struct f2fs_lock_context *lc); 3748 3774 3749 3775 /* 3750 3776 * namei.c ··· 4011 4037 /* 4012 4038 * checkpoint.c 4013 4039 */ 4040 + void f2fs_lock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc); 4041 + int f2fs_trylock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc); 4042 + void f2fs_unlock_op(struct f2fs_sb_info *sbi, struct f2fs_lock_context *lc); 4014 4043 void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io, 4015 4044 unsigned char reason); 4016 4045 void f2fs_flush_ckpt_thread(struct f2fs_sb_info *sbi);
+39 -26
fs/f2fs/file.c
··· 774 774 { 775 775 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 776 776 struct dnode_of_data dn; 777 + struct f2fs_lock_context lc; 777 778 pgoff_t free_from; 778 779 int count = 0, err = 0; 779 780 struct folio *ifolio; ··· 793 792 goto free_partial; 794 793 795 794 if (lock) 796 - f2fs_lock_op(sbi); 795 + f2fs_lock_op(sbi, &lc); 797 796 798 797 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); 799 798 if (IS_ERR(ifolio)) { ··· 844 843 err = f2fs_truncate_inode_blocks(inode, free_from); 845 844 out: 846 845 if (lock) 847 - f2fs_unlock_op(sbi); 846 + f2fs_unlock_op(sbi, &lc); 848 847 free_partial: 849 848 /* lastly zero out the first data page */ 850 849 if (!err) ··· 1119 1118 } 1120 1119 if (i_uid_needs_update(idmap, attr, inode) || 1121 1120 i_gid_needs_update(idmap, attr, inode)) { 1122 - f2fs_lock_op(sbi); 1121 + struct f2fs_lock_context lc; 1122 + 1123 + f2fs_lock_op(sbi, &lc); 1123 1124 err = dquot_transfer(idmap, inode, attr); 1124 1125 if (err) { 1125 1126 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR); 1126 - f2fs_unlock_op(sbi); 1127 + f2fs_unlock_op(sbi, &lc); 1127 1128 return err; 1128 1129 } 1129 1130 /* ··· 1135 1132 i_uid_update(idmap, attr, inode); 1136 1133 i_gid_update(idmap, attr, inode); 1137 1134 f2fs_mark_inode_dirty_sync(inode, true); 1138 - f2fs_unlock_op(sbi); 1135 + f2fs_unlock_op(sbi, &lc); 1139 1136 } 1140 1137 1141 1138 if (attr->ia_valid & ATTR_SIZE) { ··· 1219 1216 { 1220 1217 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1221 1218 struct folio *folio; 1219 + struct f2fs_lock_context lc; 1222 1220 1223 1221 if (!len) 1224 1222 return 0; 1225 1223 1226 1224 f2fs_balance_fs(sbi, true); 1227 1225 1228 - f2fs_lock_op(sbi); 1226 + f2fs_lock_op(sbi, &lc); 1229 1227 folio = f2fs_get_new_data_folio(inode, NULL, index, false); 1230 - f2fs_unlock_op(sbi); 1228 + f2fs_unlock_op(sbi, &lc); 1231 1229 1232 1230 if (IS_ERR(folio)) 1233 1231 return PTR_ERR(folio); ··· 1311 1307 if (pg_start < pg_end) { 1312 1308 loff_t blk_start, blk_end; 1313 1309 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1310 + struct f2fs_lock_context lc; 1314 1311 1315 1312 f2fs_balance_fs(sbi, true); 1316 1313 ··· 1323 1318 1324 1319 truncate_pagecache_range(inode, blk_start, blk_end - 1); 1325 1320 1326 - f2fs_lock_op(sbi); 1321 + f2fs_lock_op(sbi, &lc); 1327 1322 ret = f2fs_truncate_hole(inode, pg_start, pg_end); 1328 - f2fs_unlock_op(sbi); 1323 + f2fs_unlock_op(sbi, &lc); 1329 1324 1330 1325 filemap_invalidate_unlock(inode->i_mapping); 1331 1326 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); ··· 1557 1552 static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len) 1558 1553 { 1559 1554 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1555 + struct f2fs_lock_context lc; 1560 1556 pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE); 1561 1557 pgoff_t start = offset >> PAGE_SHIFT; 1562 1558 pgoff_t end = (offset + len) >> PAGE_SHIFT; ··· 1571 1565 1572 1566 f2fs_zero_post_eof_page(inode, offset + len, false); 1573 1567 1574 - f2fs_lock_op(sbi); 1568 + f2fs_lock_op(sbi, &lc); 1575 1569 f2fs_drop_extent_tree(inode); 1576 1570 truncate_pagecache(inode, offset); 1577 1571 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true); 1578 - f2fs_unlock_op(sbi); 1572 + f2fs_unlock_op(sbi, &lc); 1579 1573 1580 1574 filemap_invalidate_unlock(inode->i_mapping); 1581 1575 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); ··· 1723 1717 1724 1718 for (index = pg_start; index < pg_end;) { 1725 1719 struct dnode_of_data dn; 1720 + struct f2fs_lock_context lc; 1726 1721 unsigned int end_offset; 1727 1722 pgoff_t end; 1728 1723 ··· 1734 1727 (loff_t)index << PAGE_SHIFT, 1735 1728 ((loff_t)pg_end << PAGE_SHIFT) - 1); 1736 1729 1737 - f2fs_lock_op(sbi); 1730 + f2fs_lock_op(sbi, &lc); 1738 1731 1739 1732 set_new_dnode(&dn, inode, NULL, NULL, 0); 1740 1733 ret = f2fs_get_dnode_of_data(&dn, index, ALLOC_NODE); 1741 1734 if (ret) { 1742 - f2fs_unlock_op(sbi); 1735 + f2fs_unlock_op(sbi, &lc); 1743 1736 filemap_invalidate_unlock(mapping); 1744 1737 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); 1745 1738 goto out; ··· 1751 1744 ret = f2fs_do_zero_range(&dn, index, end); 1752 1745 f2fs_put_dnode(&dn); 1753 1746 1754 - f2fs_unlock_op(sbi); 1747 + f2fs_unlock_op(sbi, &lc); 1755 1748 filemap_invalidate_unlock(mapping); 1756 1749 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); 1757 1750 ··· 1834 1827 truncate_pagecache(inode, offset); 1835 1828 1836 1829 while (!ret && idx > pg_start) { 1830 + struct f2fs_lock_context lc; 1831 + 1837 1832 nr = idx - pg_start; 1838 1833 if (nr > delta) 1839 1834 nr = delta; 1840 1835 idx -= nr; 1841 1836 1842 - f2fs_lock_op(sbi); 1837 + f2fs_lock_op(sbi, &lc); 1843 1838 f2fs_drop_extent_tree(inode); 1844 1839 1845 1840 ret = __exchange_data_block(inode, inode, idx, 1846 1841 idx + delta, nr, false); 1847 - f2fs_unlock_op(sbi); 1842 + f2fs_unlock_op(sbi, &lc); 1848 1843 } 1849 1844 filemap_invalidate_unlock(mapping); 1850 1845 f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]); ··· 3102 3093 struct inode *src = file_inode(file_in); 3103 3094 struct inode *dst = file_inode(file_out); 3104 3095 struct f2fs_sb_info *sbi = F2FS_I_SB(src); 3096 + struct f2fs_lock_context lc; 3105 3097 size_t olen = len, dst_max_i_size = 0; 3106 3098 size_t dst_osize; 3107 3099 int ret; ··· 3198 3188 goto out_src; 3199 3189 } 3200 3190 3201 - f2fs_lock_op(sbi); 3191 + f2fs_lock_op(sbi, &lc); 3202 3192 ret = __exchange_data_block(src, dst, F2FS_BYTES_TO_BLK(pos_in), 3203 3193 F2FS_BYTES_TO_BLK(pos_out), 3204 3194 F2FS_BYTES_TO_BLK(len), false); ··· 3209 3199 else if (dst_osize != dst->i_size) 3210 3200 f2fs_i_size_write(dst, dst_osize); 3211 3201 } 3212 - f2fs_unlock_op(sbi); 3202 + f2fs_unlock_op(sbi, &lc); 3213 3203 3214 3204 if (src != dst) 3215 3205 f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]); ··· 3377 3367 struct f2fs_inode_info *fi = F2FS_I(inode); 3378 3368 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 3379 3369 struct f2fs_inode *ri = NULL; 3370 + struct f2fs_lock_context lc; 3380 3371 kprojid_t kprojid; 3381 3372 int err; 3382 3373 ··· 3408 3397 if (err) 3409 3398 return err; 3410 3399 3411 - f2fs_lock_op(sbi); 3400 + f2fs_lock_op(sbi, &lc); 3412 3401 err = f2fs_transfer_project_quota(inode, kprojid); 3413 3402 if (err) 3414 3403 goto out_unlock; ··· 3417 3406 inode_set_ctime_current(inode); 3418 3407 f2fs_mark_inode_dirty_sync(inode, true); 3419 3408 out_unlock: 3420 - f2fs_unlock_op(sbi); 3409 + f2fs_unlock_op(sbi, &lc); 3421 3410 return err; 3422 3411 } 3423 3412 #else ··· 3850 3839 struct inode *inode = file_inode(filp); 3851 3840 struct f2fs_inode_info *fi = F2FS_I(inode); 3852 3841 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 3842 + struct f2fs_lock_context lc; 3853 3843 pgoff_t page_idx = 0, last_idx; 3854 3844 unsigned int released_blocks = 0; 3855 3845 int ret; ··· 3905 3893 struct dnode_of_data dn; 3906 3894 pgoff_t end_offset, count; 3907 3895 3908 - f2fs_lock_op(sbi); 3896 + f2fs_lock_op(sbi, &lc); 3909 3897 3910 3898 set_new_dnode(&dn, inode, NULL, NULL, 0); 3911 3899 ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE); 3912 3900 if (ret) { 3913 - f2fs_unlock_op(sbi); 3901 + f2fs_unlock_op(sbi, &lc); 3914 3902 if (ret == -ENOENT) { 3915 3903 page_idx = f2fs_get_next_page_offset(&dn, 3916 3904 page_idx); ··· 3928 3916 3929 3917 f2fs_put_dnode(&dn); 3930 3918 3931 - f2fs_unlock_op(sbi); 3919 + f2fs_unlock_op(sbi, &lc); 3932 3920 3933 3921 if (ret < 0) 3934 3922 break; ··· 4081 4069 4082 4070 while (page_idx < last_idx) { 4083 4071 struct dnode_of_data dn; 4072 + struct f2fs_lock_context lc; 4084 4073 pgoff_t end_offset, count; 4085 4074 4086 - f2fs_lock_op(sbi); 4075 + f2fs_lock_op(sbi, &lc); 4087 4076 4088 4077 set_new_dnode(&dn, inode, NULL, NULL, 0); 4089 4078 ret = f2fs_get_dnode_of_data(&dn, page_idx, LOOKUP_NODE); 4090 4079 if (ret) { 4091 - f2fs_unlock_op(sbi); 4080 + f2fs_unlock_op(sbi, &lc); 4092 4081 if (ret == -ENOENT) { 4093 4082 page_idx = f2fs_get_next_page_offset(&dn, 4094 4083 page_idx); ··· 4107 4094 4108 4095 f2fs_put_dnode(&dn); 4109 4096 4110 - f2fs_unlock_op(sbi); 4097 + f2fs_unlock_op(sbi, &lc); 4111 4098 4112 4099 if (ret < 0) 4113 4100 break;
+3 -2
fs/f2fs/gc.c
··· 2263 2263 struct f2fs_sb_info *sbi = F2FS_I_SB(file_inode(filp)); 2264 2264 __u64 old_block_count, shrunk_blocks; 2265 2265 struct cp_control cpc = { CP_RESIZE, 0, 0, 0 }; 2266 + struct f2fs_lock_context lc; 2266 2267 unsigned int secs; 2267 2268 int err = 0; 2268 2269 __u32 rem; ··· 2313 2312 } 2314 2313 2315 2314 /* stop CP to protect MAIN_SEC in free_segment_range */ 2316 - f2fs_lock_op(sbi); 2315 + f2fs_lock_op(sbi, &lc); 2317 2316 2318 2317 spin_lock(&sbi->stat_lock); 2319 2318 if (shrunk_blocks + valid_user_blocks(sbi) + ··· 2328 2327 err = free_segment_range(sbi, secs, true); 2329 2328 2330 2329 out_unlock: 2331 - f2fs_unlock_op(sbi); 2330 + f2fs_unlock_op(sbi, &lc); 2332 2331 f2fs_up_write(&sbi->gc_lock); 2333 2332 out_drop_write: 2334 2333 mnt_drop_write_file(filp);
+6 -4
fs/f2fs/inline.c
··· 218 218 { 219 219 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 220 220 struct dnode_of_data dn; 221 + struct f2fs_lock_context lc; 221 222 struct folio *ifolio, *folio; 222 223 int err = 0; 223 224 ··· 236 235 if (IS_ERR(folio)) 237 236 return PTR_ERR(folio); 238 237 239 - f2fs_lock_op(sbi); 238 + f2fs_lock_op(sbi, &lc); 240 239 241 240 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); 242 241 if (IS_ERR(ifolio)) { ··· 251 250 252 251 f2fs_put_dnode(&dn); 253 252 out: 254 - f2fs_unlock_op(sbi); 253 + f2fs_unlock_op(sbi, &lc); 255 254 256 255 f2fs_folio_put(folio, true); 257 256 ··· 598 597 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 599 598 struct folio *ifolio; 600 599 struct f2fs_filename fname; 600 + struct f2fs_lock_context lc; 601 601 void *inline_dentry = NULL; 602 602 int err = 0; 603 603 604 604 if (!f2fs_has_inline_dentry(dir)) 605 605 return 0; 606 606 607 - f2fs_lock_op(sbi); 607 + f2fs_lock_op(sbi, &lc); 608 608 609 609 err = f2fs_setup_filename(dir, &dentry->d_name, 0, &fname); 610 610 if (err) ··· 630 628 out_fname: 631 629 f2fs_free_filename(&fname); 632 630 out: 633 - f2fs_unlock_op(sbi); 631 + f2fs_unlock_op(sbi, &lc); 634 632 return err; 635 633 } 636 634
+6 -4
fs/f2fs/inode.c
··· 910 910 err = -EIO; 911 911 912 912 if (!err) { 913 - f2fs_lock_op(sbi); 913 + struct f2fs_lock_context lc; 914 + 915 + f2fs_lock_op(sbi, &lc); 914 916 err = f2fs_remove_inode_page(inode); 915 - f2fs_unlock_op(sbi); 917 + f2fs_unlock_op(sbi, &lc); 916 918 if (err == -ENOENT) { 917 919 err = 0; 918 920 ··· 1011 1009 } 1012 1010 1013 1011 /* caller should call f2fs_lock_op() */ 1014 - void f2fs_handle_failed_inode(struct inode *inode) 1012 + void f2fs_handle_failed_inode(struct inode *inode, struct f2fs_lock_context *lc) 1015 1013 { 1016 1014 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1017 1015 struct node_info ni; ··· 1060 1058 } 1061 1059 1062 1060 out: 1063 - f2fs_unlock_op(sbi); 1061 + f2fs_unlock_op(sbi, lc); 1064 1062 1065 1063 /* iput will drop the inode object */ 1066 1064 iput(inode);
+37 -28
fs/f2fs/namei.c
··· 354 354 struct dentry *dentry, umode_t mode, bool excl) 355 355 { 356 356 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 357 + struct f2fs_lock_context lc; 357 358 struct inode *inode; 358 359 nid_t ino = 0; 359 360 int err; ··· 377 376 inode->i_mapping->a_ops = &f2fs_dblock_aops; 378 377 ino = inode->i_ino; 379 378 380 - f2fs_lock_op(sbi); 379 + f2fs_lock_op(sbi, &lc); 381 380 err = f2fs_add_link(dentry, inode); 382 381 if (err) 383 382 goto out; 384 - f2fs_unlock_op(sbi); 383 + f2fs_unlock_op(sbi, &lc); 385 384 386 385 f2fs_alloc_nid_done(sbi, ino); 387 386 ··· 393 392 f2fs_balance_fs(sbi, true); 394 393 return 0; 395 394 out: 396 - f2fs_handle_failed_inode(inode); 395 + f2fs_handle_failed_inode(inode, &lc); 397 396 return err; 398 397 } 399 398 ··· 402 401 { 403 402 struct inode *inode = d_inode(old_dentry); 404 403 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 404 + struct f2fs_lock_context lc; 405 405 int err; 406 406 407 407 if (unlikely(f2fs_cp_error(sbi))) ··· 429 427 ihold(inode); 430 428 431 429 set_inode_flag(inode, FI_INC_LINK); 432 - f2fs_lock_op(sbi); 430 + f2fs_lock_op(sbi, &lc); 433 431 err = f2fs_add_link(dentry, inode); 434 432 if (err) 435 433 goto out; 436 - f2fs_unlock_op(sbi); 434 + f2fs_unlock_op(sbi, &lc); 437 435 438 436 d_instantiate(dentry, inode); 439 437 ··· 443 441 out: 444 442 clear_inode_flag(inode, FI_INC_LINK); 445 443 iput(inode); 446 - f2fs_unlock_op(sbi); 444 + f2fs_unlock_op(sbi, &lc); 447 445 return err; 448 446 } 449 447 ··· 547 545 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 548 546 struct inode *inode = d_inode(dentry); 549 547 struct f2fs_dir_entry *de; 548 + struct f2fs_lock_context lc; 550 549 struct folio *folio; 551 550 int err; 552 551 ··· 584 581 585 582 f2fs_balance_fs(sbi, true); 586 583 587 - f2fs_lock_op(sbi); 584 + f2fs_lock_op(sbi, &lc); 588 585 err = f2fs_acquire_orphan_inode(sbi); 589 586 if (err) { 590 - f2fs_unlock_op(sbi); 587 + f2fs_unlock_op(sbi, &lc); 591 588 f2fs_folio_put(folio, false); 592 589 goto out; 593 590 } 594 591 f2fs_delete_entry(de, folio, dir, inode); 595 - f2fs_unlock_op(sbi); 592 + f2fs_unlock_op(sbi, &lc); 596 593 597 594 /* VFS negative dentries are incompatible with Encoding and 598 595 * Case-insensitiveness. Eventually we'll want avoid ··· 635 632 struct dentry *dentry, const char *symname) 636 633 { 637 634 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 635 + struct f2fs_lock_context lc; 638 636 struct inode *inode; 639 637 size_t len = strlen(symname); 640 638 struct fscrypt_str disk_link; ··· 666 662 inode_nohighmem(inode); 667 663 inode->i_mapping->a_ops = &f2fs_dblock_aops; 668 664 669 - f2fs_lock_op(sbi); 665 + f2fs_lock_op(sbi, &lc); 670 666 err = f2fs_add_link(dentry, inode); 671 667 if (err) 672 668 goto out_f2fs_handle_failed_inode; 673 - f2fs_unlock_op(sbi); 669 + f2fs_unlock_op(sbi, &lc); 674 670 f2fs_alloc_nid_done(sbi, inode->i_ino); 675 671 676 672 err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link); ··· 705 701 goto out_free_encrypted_link; 706 702 707 703 out_f2fs_handle_failed_inode: 708 - f2fs_handle_failed_inode(inode); 704 + f2fs_handle_failed_inode(inode, &lc); 709 705 out_free_encrypted_link: 710 706 if (disk_link.name != (unsigned char *)symname) 711 707 kfree(disk_link.name); ··· 716 712 struct dentry *dentry, umode_t mode) 717 713 { 718 714 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 715 + struct f2fs_lock_context lc; 719 716 struct inode *inode; 720 717 int err; 721 718 ··· 737 732 mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS); 738 733 739 734 set_inode_flag(inode, FI_INC_LINK); 740 - f2fs_lock_op(sbi); 735 + f2fs_lock_op(sbi, &lc); 741 736 err = f2fs_add_link(dentry, inode); 742 737 if (err) 743 738 goto out_fail; 744 - f2fs_unlock_op(sbi); 739 + f2fs_unlock_op(sbi, &lc); 745 740 746 741 f2fs_alloc_nid_done(sbi, inode->i_ino); 747 742 ··· 755 750 756 751 out_fail: 757 752 clear_inode_flag(inode, FI_INC_LINK); 758 - f2fs_handle_failed_inode(inode); 753 + f2fs_handle_failed_inode(inode, &lc); 759 754 return ERR_PTR(err); 760 755 } 761 756 ··· 772 767 struct dentry *dentry, umode_t mode, dev_t rdev) 773 768 { 774 769 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 770 + struct f2fs_lock_context lc; 775 771 struct inode *inode; 776 772 int err = 0; 777 773 ··· 792 786 init_special_inode(inode, inode->i_mode, rdev); 793 787 inode->i_op = &f2fs_special_inode_operations; 794 788 795 - f2fs_lock_op(sbi); 789 + f2fs_lock_op(sbi, &lc); 796 790 err = f2fs_add_link(dentry, inode); 797 791 if (err) 798 792 goto out; 799 - f2fs_unlock_op(sbi); 793 + f2fs_unlock_op(sbi, &lc); 800 794 801 795 f2fs_alloc_nid_done(sbi, inode->i_ino); 802 796 ··· 808 802 f2fs_balance_fs(sbi, true); 809 803 return 0; 810 804 out: 811 - f2fs_handle_failed_inode(inode); 805 + f2fs_handle_failed_inode(inode, &lc); 812 806 return err; 813 807 } 814 808 ··· 817 811 struct inode **new_inode, struct f2fs_filename *fname) 818 812 { 819 813 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 814 + struct f2fs_lock_context lc; 820 815 struct inode *inode; 821 816 int err; 822 817 ··· 838 831 inode->i_mapping->a_ops = &f2fs_dblock_aops; 839 832 } 840 833 841 - f2fs_lock_op(sbi); 834 + f2fs_lock_op(sbi, &lc); 842 835 err = f2fs_acquire_orphan_inode(sbi); 843 836 if (err) 844 837 goto out; ··· 867 860 f2fs_i_links_write(inode, false); 868 861 } 869 862 /* link_count was changed by d_tmpfile as well. */ 870 - f2fs_unlock_op(sbi); 863 + f2fs_unlock_op(sbi, &lc); 871 864 unlock_new_inode(inode); 872 865 873 866 if (new_inode) ··· 879 872 release_out: 880 873 f2fs_release_orphan_inode(sbi); 881 874 out: 882 - f2fs_handle_failed_inode(inode); 875 + f2fs_handle_failed_inode(inode, &lc); 883 876 return err; 884 877 } 885 878 ··· 927 920 struct f2fs_dir_entry *old_dir_entry = NULL; 928 921 struct f2fs_dir_entry *old_entry; 929 922 struct f2fs_dir_entry *new_entry; 923 + struct f2fs_lock_context lc; 930 924 bool old_is_dir = S_ISDIR(old_inode->i_mode); 931 925 int err; 932 926 ··· 1016 1008 1017 1009 f2fs_balance_fs(sbi, true); 1018 1010 1019 - f2fs_lock_op(sbi); 1011 + f2fs_lock_op(sbi, &lc); 1020 1012 1021 1013 err = f2fs_acquire_orphan_inode(sbi); 1022 1014 if (err) ··· 1039 1031 } else { 1040 1032 f2fs_balance_fs(sbi, true); 1041 1033 1042 - f2fs_lock_op(sbi); 1034 + f2fs_lock_op(sbi, &lc); 1043 1035 1044 1036 err = f2fs_add_link(new_dentry, old_inode); 1045 1037 if (err) { 1046 - f2fs_unlock_op(sbi); 1038 + f2fs_unlock_op(sbi, &lc); 1047 1039 goto out_dir; 1048 1040 } 1049 1041 ··· 1092 1084 TRANS_DIR_INO); 1093 1085 } 1094 1086 1095 - f2fs_unlock_op(sbi); 1087 + f2fs_unlock_op(sbi, &lc); 1096 1088 1097 1089 if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir)) 1098 1090 f2fs_sync_fs(sbi->sb, 1); ··· 1101 1093 return 0; 1102 1094 1103 1095 put_out_dir: 1104 - f2fs_unlock_op(sbi); 1096 + f2fs_unlock_op(sbi, &lc); 1105 1097 f2fs_folio_put(new_folio, false); 1106 1098 out_dir: 1107 1099 if (old_dir_entry) ··· 1123 1115 struct folio *old_folio, *new_folio; 1124 1116 struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL; 1125 1117 struct f2fs_dir_entry *old_entry, *new_entry; 1118 + struct f2fs_lock_context lc; 1126 1119 int old_nlink = 0, new_nlink = 0; 1127 1120 int err; 1128 1121 ··· 1203 1194 1204 1195 f2fs_balance_fs(sbi, true); 1205 1196 1206 - f2fs_lock_op(sbi); 1197 + f2fs_lock_op(sbi, &lc); 1207 1198 1208 1199 /* update ".." directory entry info of old dentry */ 1209 1200 if (old_dir_entry) ··· 1256 1247 f2fs_add_ino_entry(sbi, new_dir->i_ino, TRANS_DIR_INO); 1257 1248 } 1258 1249 1259 - f2fs_unlock_op(sbi); 1250 + f2fs_unlock_op(sbi, &lc); 1260 1251 1261 1252 if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir)) 1262 1253 f2fs_sync_fs(sbi->sb, 1);
+6 -4
fs/f2fs/segment.c
··· 400 400 { 401 401 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 402 402 struct f2fs_inode_info *fi = F2FS_I(inode); 403 + struct f2fs_lock_context lc; 403 404 int err; 404 405 405 406 err = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); ··· 408 407 return err; 409 408 410 409 f2fs_down_write(&fi->i_gc_rwsem[WRITE]); 411 - f2fs_lock_op(sbi); 410 + f2fs_lock_op(sbi, &lc); 412 411 413 412 err = __f2fs_commit_atomic_write(inode); 414 413 415 - f2fs_unlock_op(sbi); 414 + f2fs_unlock_op(sbi, &lc); 416 415 f2fs_up_write(&fi->i_gc_rwsem[WRITE]); 417 416 418 417 return err; ··· 3363 3362 3364 3363 int f2fs_allocate_pinning_section(struct f2fs_sb_info *sbi) 3365 3364 { 3365 + struct f2fs_lock_context lc; 3366 3366 int err; 3367 3367 bool gc_required = true; 3368 3368 3369 3369 retry: 3370 - f2fs_lock_op(sbi); 3370 + f2fs_lock_op(sbi, &lc); 3371 3371 err = f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false); 3372 - f2fs_unlock_op(sbi); 3372 + f2fs_unlock_op(sbi, &lc); 3373 3373 3374 3374 if (f2fs_sb_has_blkzoned(sbi) && err == -EAGAIN && gc_required) { 3375 3375 f2fs_down_write(&sbi->gc_lock);
+4 -3
fs/f2fs/super.c
··· 3325 3325 * that userspace sees the changes. 3326 3326 */ 3327 3327 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 3328 + struct f2fs_lock_context lc; 3328 3329 3329 3330 if (type != -1 && cnt != type) 3330 3331 continue; ··· 3345 3344 * block_operation 3346 3345 * f2fs_down_read(quota_sem) 3347 3346 */ 3348 - f2fs_lock_op(sbi); 3347 + f2fs_lock_op(sbi, &lc); 3349 3348 f2fs_down_read(&sbi->quota_sem); 3350 3349 3351 3350 ret = f2fs_quota_sync_file(sbi, cnt); 3352 3351 3353 3352 f2fs_up_read(&sbi->quota_sem); 3354 - f2fs_unlock_op(sbi); 3353 + f2fs_unlock_op(sbi, &lc); 3355 3354 3356 3355 if (!f2fs_sb_has_quota_ino(sbi)) 3357 3356 inode_unlock(dqopt->files[cnt]); ··· 4899 4898 init_f2fs_rwsem(&sbi->node_write); 4900 4899 init_f2fs_rwsem(&sbi->node_change); 4901 4900 spin_lock_init(&sbi->stat_lock); 4902 - init_f2fs_rwsem(&sbi->cp_rwsem); 4901 + init_f2fs_rwsem_trace(&sbi->cp_rwsem, sbi, LOCK_NAME_CP_RWSEM); 4903 4902 init_f2fs_rwsem(&sbi->cp_enable_rwsem); 4904 4903 init_f2fs_rwsem(&sbi->quota_sem); 4905 4904 init_waitqueue_head(&sbi->cp_wait);
+3 -2
fs/f2fs/xattr.c
··· 804 804 struct folio *ifolio, int flags) 805 805 { 806 806 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 807 + struct f2fs_lock_context lc; 807 808 int err; 808 809 809 810 if (unlikely(f2fs_cp_error(sbi))) ··· 822 821 size, ifolio, flags); 823 822 f2fs_balance_fs(sbi, true); 824 823 825 - f2fs_lock_op(sbi); 824 + f2fs_lock_op(sbi, &lc); 826 825 f2fs_down_write(&F2FS_I(inode)->i_xattr_sem); 827 826 err = __f2fs_setxattr(inode, index, name, value, size, NULL, flags); 828 827 f2fs_up_write(&F2FS_I(inode)->i_xattr_sem); 829 - f2fs_unlock_op(sbi); 828 + f2fs_unlock_op(sbi, &lc); 830 829 831 830 f2fs_update_time(sbi, REQ_TIME); 832 831 return err;
+1 -1
include/trace/events/f2fs.h
··· 186 186 187 187 #define show_lock_name(lock) \ 188 188 __print_symbolic(lock, \ 189 - { LOCK_NAME_NONE, "none" }) 189 + { LOCK_NAME_CP_RWSEM, "cp_rwsem" }) 190 190 191 191 struct f2fs_sb_info; 192 192 struct f2fs_io_info;