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 a6a6026..24e7cb7 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 662b27c..04ef4cc 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 15f5685..6466db7 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 e6365f0..a43d8a4 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 af23ed6..032c03e 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),