f2fs: introduce migration_window_granularity

[ Upstream commit 8c890c4c60342719526520133fb1b6f69f196ab8 ]

We can control the scanning window granularity for GC migration. For
more frequent scanning and GC on zoned devices, we need a fine grained
control knob for it.

Signed-off-by: Daeho Jeong <daehojeong@google.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Stable-dep-of: 5cc69a27abfa ("f2fs: forcibly migrate to secure space for zoned device file pinning")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
index 3500920ab7ce020687f47bf2e7afe33547cbfc61..d0c1acfcad405e13e0b30674589079a26d9d1f96 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -777,3 +777,11 @@ Description:       The zone UFS we are currently using consists of two parts:
                blkzone_alloc_policy = 1  Only allow writing to sequential zones
                blkzone_alloc_policy = 2  Prioritize writing to conventional zones
                ========================  =========================================
+
+What:          /sys/fs/f2fs/<disk>/migration_window_granularity
+Date:          September 2024
+Contact:       "Daeho Jeong" <daehojeong@google.com>
+Description:   Controls migration window granularity of garbage collection on large
+               section. it can control the scanning window granularity for GC migration
+               in a unit of segment, while migration_granularity controls the number
+               of segments which can be migrated at the same turn.

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 6fd5fc486a703ae6843eaaf1cc78b81d283be870..9796ad64727a6b49f8d1da3d706374847e976596 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1697,6 +1697,8 @@ struct f2fs_sb_info {
        unsigned int max_victim_search;
        /* migration granularity of garbage collection, unit: segment */
        unsigned int migration_granularity;
+       /* migration window granularity of garbage collection, unit: segment */
+       unsigned int migration_window_granularity;
 
        /*
         * for stat information.

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 7f61d6915e76747ed558cc62ff40dbccc68b4479..0605f87d1aca4fd06578651e62d6f2bad0aa0f5a 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1708,24 +1708,34 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
        struct blk_plug plug;
        unsigned int segno = start_segno;
        unsigned int end_segno = start_segno + SEGS_PER_SEC(sbi);
+       unsigned int sec_end_segno;
        int seg_freed = 0, migrated = 0;
        unsigned char type = IS_DATASEG(get_seg_entry(sbi, segno)->type) ?
                                                SUM_TYPE_DATA : SUM_TYPE_NODE;
        unsigned char data_type = (type == SUM_TYPE_DATA) ? DATA : NODE;
        int submitted = 0;
 
-       if (__is_large_section(sbi))
-               end_segno = rounddown(end_segno, SEGS_PER_SEC(sbi));
+       if (__is_large_section(sbi)) {
+               sec_end_segno = rounddown(end_segno, SEGS_PER_SEC(sbi));
 
-       /*
-        * zone-capacity can be less than zone-size in zoned devices,
-        * resulting in less than expected usable segments in the zone,
-        * calculate the end segno in the zone which can be garbage collected
-        */
-       if (f2fs_sb_has_blkzoned(sbi))
-               end_segno -= SEGS_PER_SEC(sbi) -
+               /*
+                * zone-capacity can be less than zone-size in zoned devices,
+                * resulting in less than expected usable segments in the zone,
+                * calculate the end segno in the zone which can be garbage
+                * collected
+                */
+               if (f2fs_sb_has_blkzoned(sbi))
+                       sec_end_segno -= SEGS_PER_SEC(sbi) -
                                        f2fs_usable_segs_in_sec(sbi, segno);
 
+               if (gc_type == BG_GC)
+                       end_segno = start_segno +
+                               sbi->migration_window_granularity;
+
+               if (end_segno > sec_end_segno)
+                       end_segno = sec_end_segno;
+       }
+
        sanity_check_seg_type(sbi, get_seg_entry(sbi, segno)->type);
 
        /* readahead multi ssa blocks those have contiguous address */
@@ -1804,7 +1814,8 @@ freed:
 
                if (__is_large_section(sbi))
                        sbi->next_victim_seg[gc_type] =
-                               (segno + 1 < end_segno) ? segno + 1 : NULL_SEGNO;
+                               (segno + 1 < sec_end_segno) ?
+                                       segno + 1 : NULL_SEGNO;
 skip:
                f2fs_put_page(sum_page, 0);
        }

diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h
index 55c4ba73362ef96d8c1e90e478b5cc62fcec107a..245f93663745a0a5c4ae903b6e7994ab83d52e71 100644 (file)
--- a/fs/f2fs/gc.h
+++ b/fs/f2fs/gc.h
@@ -32,6 +32,7 @@
 
 #define LIMIT_NO_ZONED_GC      60 /* percentage over total user space of no gc for zoned devices */
 #define LIMIT_BOOST_ZONED_GC   25 /* percentage over total user space of boosted gc for zoned devices */
+#define DEF_MIGRATION_WINDOW_GRANULARITY_ZONED 3
 
 #define DEF_GC_FAILED_PINNED_FILES     2048
 #define MAX_GC_FAILED_PINNED_FILES     USHRT_MAX

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 1a1b87c4c803fd625be5524a8c37a460bf2a2041..b0932a4a8e0473f8e536b55a15ca3926a799e96c 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -3801,6 +3801,8 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
        sbi->next_victim_seg[FG_GC] = NULL_SEGNO;
        sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
        sbi->migration_granularity = SEGS_PER_SEC(sbi);
+       sbi->migration_window_granularity = f2fs_sb_has_blkzoned(sbi) ?
+               DEF_MIGRATION_WINDOW_GRANULARITY_ZONED : SEGS_PER_SEC(sbi);
        sbi->seq_file_ra_mul = MIN_RA_MUL;
        sbi->max_fragment_chunk = DEF_FRAGMENT_SIZE;
        sbi->max_fragment_hole = DEF_FRAGMENT_SIZE;

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index 15c8678581afcfb105dd2bed2745047e5e5ab325..bb0dbe7665f9c447cda991deb3e3b5f4c2311f1f 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -561,6 +561,11 @@ out:
                        return -EINVAL;
        }
 
+       if (!strcmp(a->attr.name, "migration_window_granularity")) {
+               if (t == 0 || t > SEGS_PER_SEC(sbi))
+                       return -EINVAL;
+       }
+
        if (!strcmp(a->attr.name, "gc_urgent")) {
                if (t == 0) {
                        sbi->gc_mode = GC_NORMAL;
@@ -1010,6 +1015,7 @@ F2FS_SBI_RW_ATTR(gc_pin_file_thresh, gc_pin_file_threshold);
 F2FS_SBI_RW_ATTR(gc_reclaimed_segments, gc_reclaimed_segs);
 F2FS_SBI_GENERAL_RW_ATTR(max_victim_search);
 F2FS_SBI_GENERAL_RW_ATTR(migration_granularity);
+F2FS_SBI_GENERAL_RW_ATTR(migration_window_granularity);
 F2FS_SBI_GENERAL_RW_ATTR(dir_level);
 #ifdef CONFIG_F2FS_IOSTAT
 F2FS_SBI_GENERAL_RW_ATTR(iostat_enable);
@@ -1150,6 +1156,7 @@ static struct attribute *f2fs_attrs[] = {
        ATTR_LIST(min_ssr_sections),
        ATTR_LIST(max_victim_search),
        ATTR_LIST(migration_granularity),
+       ATTR_LIST(migration_window_granularity),
        ATTR_LIST(dir_level),
        ATTR_LIST(ram_thresh),
        ATTR_LIST(ra_nid_pages),