f2fs: replace gc_urgent_high_remaining with gc_remaining_trials

The user can set the trial count limit for GC urgent and
idle mode with replaced gc_remaining_trials.. If GC thread gets
to the limit, the mode will turn back to GC normal mode finally.

It was applied only to GC_URGENT, while this patch expands it for
GC_IDLE.

Signed-off-by: Yangtao Li <frank.li@vivo.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
index a6a60268dcc5a0bd13ad7d213b6bfe5e6f28107f..24e7cb77f265b77e5b2379440e7a03e3d78f8b7a 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -598,10 +598,10 @@ Description:      With "mode=fragment:block" mount options, we can scatter block allo
                in the length of 1..<max_fragment_hole> by turns. This value can be set
                between 1..512 and the default value is 4.
 
-What:          /sys/fs/f2fs/<disk>/gc_urgent_high_remaining
-Date:          December 2021
-Contact:       "Daeho Jeong" <daehojeong@google.com>
-Description:   You can set the trial count limit for GC urgent high mode with this value.
+What:          /sys/fs/f2fs/<disk>/gc_remaining_trials
+Date:          October 2022
+Contact:       "Yangtao Li" <frank.li@vivo.com>
+Description:   You can set the trial count limit for GC urgent and idle mode with this value.
                If GC thread gets to the limit, the mode will turn back to GC normal mode.
                By default, the value is zero, which means there is no limit like before.
 

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 662b27c19de10bf1993a1610a0d560d17300386c..04ef4cce3d7f4c30b8bdc0fafa8b6b955cd73258 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1736,8 +1736,9 @@ struct f2fs_sb_info {
        unsigned int cur_victim_sec;            /* current victim section num */
        unsigned int gc_mode;                   /* current GC state */
        unsigned int next_victim_seg[2];        /* next segment in victim section */
-       spinlock_t gc_urgent_high_lock;
-       unsigned int gc_urgent_high_remaining;  /* remaining trial count for GC_URGENT_HIGH */
+       spinlock_t gc_remaining_trials_lock;
+       /* remaining trial count for GC_URGENT_* and GC_IDLE_* */
+       unsigned int gc_remaining_trials;
 
        /* for skip statistic */
        unsigned long long skipped_gc_rwsem;            /* FG_GC only */

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 15f56859966ccb9d252571c33f146e517f45f291..6466db75af5d28935ff41186417c4a88ebf0e8b0 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -152,14 +152,14 @@ do_gc:
                /* balancing f2fs's metadata periodically */
                f2fs_balance_fs_bg(sbi, true);
 next:
-               if (sbi->gc_mode == GC_URGENT_HIGH) {
-                       spin_lock(&sbi->gc_urgent_high_lock);
-                       if (sbi->gc_urgent_high_remaining) {
-                               sbi->gc_urgent_high_remaining--;
-                               if (!sbi->gc_urgent_high_remaining)
+               if (sbi->gc_mode != GC_NORMAL) {
+                       spin_lock(&sbi->gc_remaining_trials_lock);
+                       if (sbi->gc_remaining_trials) {
+                               sbi->gc_remaining_trials--;
+                               if (!sbi->gc_remaining_trials)
                                        sbi->gc_mode = GC_NORMAL;
                        }
-                       spin_unlock(&sbi->gc_urgent_high_lock);
+                       spin_unlock(&sbi->gc_remaining_trials_lock);
                }
                sb_end_write(sbi->sb);
 

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index e6365f040171ed34d38035f7575efebf18b799da..a43d8a46a6e567c9881e49827253df8264ff06d7 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -3624,7 +3624,7 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
        sbi->seq_file_ra_mul = MIN_RA_MUL;
        sbi->max_fragment_chunk = DEF_FRAGMENT_SIZE;
        sbi->max_fragment_hole = DEF_FRAGMENT_SIZE;
-       spin_lock_init(&sbi->gc_urgent_high_lock);
+       spin_lock_init(&sbi->gc_remaining_trials_lock);
        atomic64_set(&sbi->current_atomic_write, 0);
 
        sbi->dir_level = DEF_DIR_LEVEL;

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index af23ed6121b00c3f95af888a1e2bc0cbafe72c46..032c03e09580d6d94d412a5d3785545c52612308 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -538,10 +538,10 @@ out:
                return count;
        }
 
-       if (!strcmp(a->attr.name, "gc_urgent_high_remaining")) {
-               spin_lock(&sbi->gc_urgent_high_lock);
-               sbi->gc_urgent_high_remaining = t;
-               spin_unlock(&sbi->gc_urgent_high_lock);
+       if (!strcmp(a->attr.name, "gc_remaining_trials")) {
+               spin_lock(&sbi->gc_remaining_trials_lock);
+               sbi->gc_remaining_trials = t;
+               spin_unlock(&sbi->gc_remaining_trials_lock);
 
                return count;
        }
@@ -832,7 +832,7 @@ F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type);
 #endif
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, data_io_flag, data_io_flag);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, node_io_flag, node_io_flag);
-F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_urgent_high_remaining, gc_urgent_high_remaining);
+F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_remaining_trials, gc_remaining_trials);
 F2FS_RW_ATTR(CPRC_INFO, ckpt_req_control, ckpt_thread_ioprio, ckpt_thread_ioprio);
 F2FS_GENERAL_RO_ATTR(dirty_segments);
 F2FS_GENERAL_RO_ATTR(free_segments);
@@ -961,7 +961,7 @@ static struct attribute *f2fs_attrs[] = {
 #endif
        ATTR_LIST(data_io_flag),
        ATTR_LIST(node_io_flag),
-       ATTR_LIST(gc_urgent_high_remaining),
+       ATTR_LIST(gc_remaining_trials),
        ATTR_LIST(ckpt_thread_ioprio),
        ATTR_LIST(dirty_segments),
        ATTR_LIST(free_segments),