f2fs: introduce gc_urgent_mid mode

We need a mid level of gc urgent mode to do GC forcibly in a period
of given gc_urgent_sleep_time, but not like using greedy GC approach
and switching to SSR mode such as gc urgent high mode. This can be
used for more aggressive periodic storage clean up.

Signed-off-by: Daeho Jeong <daehojeong@google.com>
Reviewed-by: Chao Yu <chao@kernel.org>
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 5a5f3c5..9b583dd 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -297,11 +297,16 @@ Description:      Shows current reserved blocks in system, it may be temporarily
 What:          /sys/fs/f2fs/<disk>/gc_urgent
 Date:          August 2017
 Contact:       "Jaegeuk Kim" <jaegeuk@kernel.org>
-Description:   Do background GC aggressively when set. When gc_urgent = 1,
-               background thread starts to do GC by given gc_urgent_sleep_time
-               interval. When gc_urgent = 2, F2FS will lower the bar of
-               checking idle in order to process outstanding discard commands
-               and GC a little bit aggressively. It is set to 0 by default.
+Description:   Do background GC aggressively when set. Set to 0 by default.
+               gc urgent high(1): does GC forcibly in a period of given
+               gc_urgent_sleep_time and ignores I/O idling check. uses greedy
+               GC approach and turns SSR mode on.
+               gc urgent low(2): lowers the bar of checking I/O idling in
+               order to process outstanding discard commands and GC a
+               little bit aggressively. uses cost benefit GC approach.
+               gc urgent mid(3): does GC forcibly in a period of given
+               gc_urgent_sleep_time and executes a mid level of I/O idling check.
+               uses cost benefit GC approach.
 
 What:          /sys/fs/f2fs/<disk>/gc_urgent_sleep_time
 Date:          August 2017
@@ -532,7 +537,7 @@ Date:               July 2021
 Contact:       "Daeho Jeong" <daehojeong@google.com>
 Description:   Show how many segments have been reclaimed by GC during a specific
                GC mode (0: GC normal, 1: GC idle CB, 2: GC idle greedy,
-               3: GC idle AT, 4: GC urgent high, 5: GC urgent low)
+               3: GC idle AT, 4: GC urgent high, 5: GC urgent low 6: GC urgent mid)
                You can re-initialize this value to "0".
 
 What:          /sys/fs/f2fs/<disk>/gc_segment_mode

diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index 6d26872..fcdf253 100644 (file)
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -476,12 +476,14 @@ static int stat_show(struct seq_file *s, void *v)
                                si->node_segs, si->bg_node_segs);
                seq_printf(s, "  - Reclaimed segs : Normal (%d), Idle CB (%d), "
                                "Idle Greedy (%d), Idle AT (%d), "
-                               "Urgent High (%d), Urgent Low (%d)\n",
+                               "Urgent High (%d), Urgent Mid (%d), "
+                               "Urgent Low (%d)\n",
                                si->sbi->gc_reclaimed_segs[GC_NORMAL],
                                si->sbi->gc_reclaimed_segs[GC_IDLE_CB],
                                si->sbi->gc_reclaimed_segs[GC_IDLE_GREEDY],
                                si->sbi->gc_reclaimed_segs[GC_IDLE_AT],
                                si->sbi->gc_reclaimed_segs[GC_URGENT_HIGH],
+                               si->sbi->gc_reclaimed_segs[GC_URGENT_MID],
                                si->sbi->gc_reclaimed_segs[GC_URGENT_LOW]);
                seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks,
                                si->bg_data_blks + si->bg_node_blks);

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index da729f5..3016b63 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1313,6 +1313,7 @@ enum {
        GC_IDLE_AT,
        GC_URGENT_HIGH,
        GC_URGENT_LOW,
+       GC_URGENT_MID,
        MAX_GC_MODE,
 };
 
@@ -2784,6 +2785,9 @@ static inline bool is_idle(struct f2fs_sb_info *sbi, int type)
        if (is_inflight_io(sbi, type))
                return false;
 
+       if (sbi->gc_mode == GC_URGENT_MID)
+               return true;
+
        if (sbi->gc_mode == GC_URGENT_LOW &&
                        (type == DISCARD_TIME || type == GC_TIME))
                return true;

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 2d53ef1..ea5b93b 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -103,7 +103,10 @@ static int gc_thread_func(void *data)
                                sbi->gc_urgent_high_remaining--;
                        }
                        spin_unlock(&sbi->gc_urgent_high_lock);
+               }
 
+               if (sbi->gc_mode == GC_URGENT_HIGH ||
+                               sbi->gc_mode == GC_URGENT_MID) {
                        wait_ms = gc_th->urgent_sleep_time;
                        f2fs_down_write(&sbi->gc_lock);
                        goto do_gc;

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index 47efcf2..fe29bcb 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -468,6 +468,13 @@ out:
                        }
                } else if (t == 2) {
                        sbi->gc_mode = GC_URGENT_LOW;
+               } else if (t == 3) {
+                       sbi->gc_mode = GC_URGENT_MID;
+                       if (sbi->gc_thread) {
+                               sbi->gc_thread->gc_wake = 1;
+                               wake_up_interruptible_all(
+                                       &sbi->gc_thread->gc_wait_queue_head);
+                       }
                } else {
                        return -EINVAL;
                }