f2fs: add new idle interval timing for discard and gc paths

This helps to control the frequency of submission of discard and
GC requests independently, based on the need.

Suggested-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Sahitya Tummala <stummala@codeaurora.org>
Reviewed-by: Chao Yu <yuchao0@huawei.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 94a24aedcdb237cfe07fb9f4fe0c33e953a49bd5..3ac41774ad3cf5730e76d5c5c3595ef1efa8a267 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -121,7 +121,22 @@ What:              /sys/fs/f2fs/<disk>/idle_interval
 Date:          January 2016
 Contact:       "Jaegeuk Kim" <jaegeuk@kernel.org>
 Description:
-                Controls the idle timing.
+                Controls the idle timing for all paths other than
+                discard and gc path.
+
+What:          /sys/fs/f2fs/<disk>/discard_idle_interval
+Date:          September 2018
+Contact:       "Chao Yu" <yuchao0@huawei.com>
+Contact:       "Sahitya Tummala" <stummala@codeaurora.org>
+Description:
+                Controls the idle timing for discard path.
+
+What:          /sys/fs/f2fs/<disk>/gc_idle_interval
+Date:          September 2018
+Contact:       "Chao Yu" <yuchao0@huawei.com>
+Contact:       "Sahitya Tummala" <stummala@codeaurora.org>
+Description:
+                Controls the idle timing for gc path.
 
 What:          /sys/fs/f2fs/<disk>/iostat_enable
 Date:          August 2017

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index b676b82312e001fb8555d4355ed1d23a115e56d5..125f8b79a8c1c227fdf4c286bf15802b83df5ab8 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1093,6 +1093,8 @@ enum {
 enum {
        CP_TIME,
        REQ_TIME,
+       DISCARD_TIME,
+       GC_TIME,
        MAX_TIME,
 };
 
@@ -1344,7 +1346,15 @@ static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
 
 static inline void f2fs_update_time(struct f2fs_sb_info *sbi, int type)
 {
-       sbi->last_time[type] = jiffies;
+       unsigned long now = jiffies;
+
+       sbi->last_time[type] = now;
+
+       /* DISCARD_TIME and GC_TIME are based on REQ_TIME */
+       if (type == REQ_TIME) {
+               sbi->last_time[DISCARD_TIME] = now;
+               sbi->last_time[GC_TIME] = now;
+       }
 }
 
 static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)
@@ -1354,7 +1364,21 @@ static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)
        return time_after(jiffies, sbi->last_time[type] + interval);
 }
 
-static inline bool is_idle(struct f2fs_sb_info *sbi)
+static inline unsigned int f2fs_time_to_wait(struct f2fs_sb_info *sbi,
+                                               int type)
+{
+       unsigned long interval = sbi->interval_time[type] * HZ;
+       unsigned int wait_ms = 0;
+       long delta;
+
+       delta = (sbi->last_time[type] + interval) - jiffies;
+       if (delta > 0)
+               wait_ms = jiffies_to_msecs(delta);
+
+       return wait_ms;
+}
+
+static inline bool is_idle(struct f2fs_sb_info *sbi, int type)
 {
        struct block_device *bdev = sbi->sb->s_bdev;
        struct request_queue *q = bdev_get_queue(bdev);
@@ -1363,7 +1387,7 @@ static inline bool is_idle(struct f2fs_sb_info *sbi)
        if (rl->count[BLK_RW_SYNC] || rl->count[BLK_RW_ASYNC])
                return false;
 
-       return f2fs_time_over(sbi, REQ_TIME);
+       return f2fs_time_over(sbi, type);
 }
 
 /*

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index a4c1a419611d27fa9735dc392406142e3613cff1..77ffa8045a3b4858eebec748b7d8ae8b9195e010 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -80,7 +80,7 @@ static int gc_thread_func(void *data)
                if (!mutex_trylock(&sbi->gc_mutex))
                        goto next;
 
-               if (!is_idle(sbi)) {
+               if (!is_idle(sbi, GC_TIME)) {
                        increase_sleep_time(gc_th, &wait_ms);
                        mutex_unlock(&sbi->gc_mutex);
                        goto next;

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 9a8d7d415a74903e857278bcb23ce632e628e200..97a4fae75651e6444dfd30b582b46e23b66ece48 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -508,7 +508,7 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi)
        else
                f2fs_build_free_nids(sbi, false, false);
 
-       if (!is_idle(sbi) &&
+       if (!is_idle(sbi, REQ_TIME) &&
                (!excess_dirty_nats(sbi) && !excess_dirty_nodes(sbi)))
                return;
 
@@ -1308,7 +1308,7 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
                if (dc->state != D_PREP)
                        goto next;
 
-               if (dpolicy->io_aware && !is_idle(sbi)) {
+               if (dpolicy->io_aware && !is_idle(sbi, DISCARD_TIME)) {
                        io_interrupted = true;
                        break;
                }
@@ -1368,7 +1368,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
                        f2fs_bug_on(sbi, dc->state != D_PREP);
 
                        if (dpolicy->io_aware && i < dpolicy->io_aware_gran &&
-                                                               !is_idle(sbi)) {
+                                               !is_idle(sbi, DISCARD_TIME)) {
                                io_interrupted = true;
                                break;
                        }
@@ -1561,8 +1561,6 @@ static int issue_discard_thread(void *data)
        struct discard_policy dpolicy;
        unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
        int issued;
-       unsigned long interval = sbi->interval_time[REQ_TIME] * HZ;
-       long delta;
 
        set_freezable();
 
@@ -1599,10 +1597,8 @@ static int issue_discard_thread(void *data)
                        __wait_all_discard_cmd(sbi, &dpolicy);
                        wait_ms = dpolicy.min_interval;
                } else if (issued == -1){
-                       delta = (sbi->last_time[REQ_TIME] + interval) - jiffies;
-                       if (delta > 0)
-                               wait_ms = jiffies_to_msecs(delta);
-                       else
+                       wait_ms = f2fs_time_to_wait(sbi, DISCARD_TIME);
+                       if (!wait_ms)
                                wait_ms = dpolicy.mid_interval;
                } else {
                        wait_ms = dpolicy.max_interval;

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 945468968d4efcad9ccde06a48ee121fb2bc1342..c112403b3ca77f1b1905471139420235a59a20d6 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2461,6 +2461,8 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
        sbi->dir_level = DEF_DIR_LEVEL;
        sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
        sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
+       sbi->interval_time[DISCARD_TIME] = DEF_IDLE_INTERVAL;
+       sbi->interval_time[GC_TIME] = DEF_IDLE_INTERVAL;
        clear_sbi_flag(sbi, SBI_NEED_FSCK);
 
        for (i = 0; i < NR_COUNT_TYPE; i++)

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index c8924c02accd35af61e0112ea0039dfefc4468ae..f5a545437b81ce02480d3b67d7ae893f7065e256 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -404,6 +404,9 @@ F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
+F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, discard_idle_interval,
+                                       interval_time[DISCARD_TIME]);
+F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_idle_interval, interval_time[GC_TIME]);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, iostat_enable, iostat_enable);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, readdir_ra, readdir_ra);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, gc_pin_file_thresh, gc_pin_file_threshold);
@@ -457,6 +460,8 @@ static struct attribute *f2fs_attrs[] = {
        ATTR_LIST(dirty_nats_ratio),
        ATTR_LIST(cp_interval),
        ATTR_LIST(idle_interval),
+       ATTR_LIST(discard_idle_interval),
+       ATTR_LIST(gc_idle_interval),
        ATTR_LIST(iostat_enable),
        ATTR_LIST(readdir_ra),
        ATTR_LIST(gc_pin_file_thresh),