f2fs: fix to shrink read extent node in batches

[ Upstream commit 3fc5d5a182f6a1f8bd4dc775feb54c369dd2c343 ]

We use rwlock to protect core structure data of extent tree during
its shrink, however, if there is a huge number of extent nodes in
extent tree, during shrink of extent tree, it may hold rwlock for
a very long time, which may trigger kernel hang issue.

This patch fixes to shrink read extent node in batches, so that,
critical region of the rwlock can be shrunk to avoid its extreme
long time hold.

Reported-by: Xiuhong Wang <xiuhong.wang@unisoc.com>
Closes: https://lore.kernel.org/linux-f2fs-devel/20241112110627.1314632-1-xiuhong.wang@unisoc.com/
Signed-off-by: Xiuhong Wang <xiuhong.wang@unisoc.com>
Signed-off-by: Zhiguo Niu <zhiguo.niu@unisoc.com>
Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
index 62ac440d94168a452512274209fbf3d57cbbf59a..368d9cbdea743cf4f9d2f16b40226775fbbfed63 100644 (file)
--- a/fs/f2fs/extent_cache.c
+++ b/fs/f2fs/extent_cache.c
@@ -346,21 +346,22 @@ static struct extent_tree *__grab_extent_tree(struct inode *inode,
 }
 
 static unsigned int __free_extent_tree(struct f2fs_sb_info *sbi,
-                                       struct extent_tree *et)
+                               struct extent_tree *et, unsigned int nr_shrink)
 {
        struct rb_node *node, *next;
        struct extent_node *en;
-       unsigned int count = atomic_read(&et->node_cnt);
+       unsigned int count;
 
        node = rb_first_cached(&et->root);
-       while (node) {
+
+       for (count = 0; node && count < nr_shrink; count++) {
                next = rb_next(node);
                en = rb_entry(node, struct extent_node, rb_node);
                __release_extent_node(sbi, et, en);
                node = next;
        }
 
-       return count - atomic_read(&et->node_cnt);
+       return count;
 }
 
 static void __drop_largest_extent(struct extent_tree *et,
@@ -579,6 +580,30 @@ do_insert:
        return en;
 }
 
+static unsigned int __destroy_extent_node(struct inode *inode,
+                                       enum extent_type type)
+{
+       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
+       unsigned int nr_shrink = type == EX_READ ?
+                               READ_EXTENT_CACHE_SHRINK_NUMBER :
+                               AGE_EXTENT_CACHE_SHRINK_NUMBER;
+       unsigned int node_cnt = 0;
+
+       if (!et || !atomic_read(&et->node_cnt))
+               return 0;
+
+       while (atomic_read(&et->node_cnt)) {
+               write_lock(&et->lock);
+               node_cnt += __free_extent_tree(sbi, et, nr_shrink);
+               write_unlock(&et->lock);
+       }
+
+       f2fs_bug_on(sbi, atomic_read(&et->node_cnt));
+
+       return node_cnt;
+}
+
 static void __update_extent_tree_range(struct inode *inode,
                        struct extent_info *tei, enum extent_type type)
 {
@@ -717,9 +742,6 @@ static void __update_extent_tree_range(struct inode *inode,
                }
        }
 
-       if (is_inode_flag_set(inode, FI_NO_EXTENT))
-               __free_extent_tree(sbi, et);
-
        if (et->largest_updated) {
                et->largest_updated = false;
                updated = true;
@@ -737,6 +759,9 @@ update_age_extent_cache:
 out_read_extent_cache:
        write_unlock(&et->lock);
 
+       if (is_inode_flag_set(inode, FI_NO_EXTENT))
+               __destroy_extent_node(inode, EX_READ);
+
        if (updated)
                f2fs_mark_inode_dirty_sync(inode, true);
 }
@@ -899,10 +924,14 @@ static unsigned int __shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink
        list_for_each_entry_safe(et, next, &eti->zombie_list, list) {
                if (atomic_read(&et->node_cnt)) {
                        write_lock(&et->lock);
-                       node_cnt += __free_extent_tree(sbi, et);
+                       node_cnt += __free_extent_tree(sbi, et,
+                                       nr_shrink - node_cnt - tree_cnt);
                        write_unlock(&et->lock);
                }
-               f2fs_bug_on(sbi, atomic_read(&et->node_cnt));
+
+               if (atomic_read(&et->node_cnt))
+                       goto unlock_out;
+
                list_del_init(&et->list);
                radix_tree_delete(&eti->extent_tree_root, et->ino);
                kmem_cache_free(extent_tree_slab, et);
@@ -1041,23 +1070,6 @@ unsigned int f2fs_shrink_age_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink
        return __shrink_extent_tree(sbi, nr_shrink, EX_BLOCK_AGE);
 }
 
-static unsigned int __destroy_extent_node(struct inode *inode,
-                                       enum extent_type type)
-{
-       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-       struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
-       unsigned int node_cnt = 0;
-
-       if (!et || !atomic_read(&et->node_cnt))
-               return 0;
-
-       write_lock(&et->lock);
-       node_cnt = __free_extent_tree(sbi, et);
-       write_unlock(&et->lock);
-
-       return node_cnt;
-}
-
 void f2fs_destroy_extent_node(struct inode *inode)
 {
        __destroy_extent_node(inode, EX_READ);
@@ -1066,7 +1078,6 @@ void f2fs_destroy_extent_node(struct inode *inode)
 
 static void __drop_extent_tree(struct inode *inode, enum extent_type type)
 {
-       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
        bool updated = false;
 
@@ -1074,7 +1085,6 @@ static void __drop_extent_tree(struct inode *inode, enum extent_type type)
                return;
 
        write_lock(&et->lock);
-       __free_extent_tree(sbi, et);
        if (type == EX_READ) {
                set_inode_flag(inode, FI_NO_EXTENT);
                if (et->largest.len) {
@@ -1083,6 +1093,9 @@ static void __drop_extent_tree(struct inode *inode, enum extent_type type)
                }
        }
        write_unlock(&et->lock);
+
+       __destroy_extent_node(inode, type);
+
        if (updated)
                f2fs_mark_inode_dirty_sync(inode, true);
 }