f2fs: sysfs: introduce critical_task_priority

This patch introduces /sys/fs/f2fs/<disk>/critical_task_priority, w/
this new sysfs interface, we can tune priority of f2fs_ckpt thread and
f2fs_gc thread.

Signed-off-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 ea6474db8a319d2b07ae618fa5bb155d3a0174cd..c1d2b3fd9c65d1f5309070796128162c619971ca 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -987,3 +987,11 @@ Contact:   "Chao Yu" <chao@kernel.org>
 Description:   f2fs can tune priority of thread which has entered into critical region covered by
                f2fs rwsemphore lock. This sysfs entry can be used to control priority value, the
                range is [100,139], by default the value is 120.
+
+What:          /sys/fs/f2fs/<disk>/critical_task_priority
+Date:          February 2026
+Contact:       "Chao Yu" <chao@kernel.org>
+Description:   It can be used to tune priority of f2fs critical task, e.g. f2fs_ckpt, f2fs_gc
+               threads, limitation as below:
+               - it requires user has CAP_SYS_NICE capability.
+               - the range is [100, 139], by default the value is 100.

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 4afa5d9a19fc3c2898ea2b006d8c40879c910cf2..6dd39b7de11a454b30098858e79cc5dac91ac09e 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -2158,6 +2158,8 @@ int f2fs_start_ckpt_thread(struct f2fs_sb_info *sbi)
        }
 
        set_task_ioprio(cprc->f2fs_issue_ckpt, cprc->ckpt_thread_ioprio);
+       set_user_nice(cprc->f2fs_issue_ckpt,
+                       PRIO_TO_NICE(sbi->critical_task_priority));
 
        return 0;
 }

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index a6e7368fc40ae9220082f606d6f616ffc421e988..aa0bca9f851df31943f8e71257934b772227a776 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1593,6 +1593,7 @@ enum node_type {
 #define MAX_LOCK_ELAPSED_TIME          500
 
 #define F2FS_DEFAULT_TASK_PRIORITY             (DEFAULT_PRIO)
+#define F2FS_CRITICAL_TASK_PRIORITY            NICE_TO_PRIO(0)
 
 static inline int f2fs_test_bit(unsigned int nr, char *addr);
 static inline void f2fs_set_bit(unsigned int nr, char *addr);
@@ -2010,6 +2011,9 @@ struct f2fs_sb_info {
        /* adjust priority for task which is in critical region covered by lock */
        unsigned int lock_duration_priority;
 
+       /* priority for critical task, e.g. f2fs_ckpt, f2fs_gc threads */
+       long critical_task_priority;
+
 #ifdef CONFIG_F2FS_FS_COMPRESSION
        struct kmem_cache *page_array_slab;     /* page array entry */
        unsigned int page_array_slab_size;      /* default page array slab size */

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 60378614bc54758247c2ce15a18e5f6be160bbdd..f46b2673d31f5a334bac543947e713cfe85dc68a 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -234,6 +234,8 @@ int f2fs_start_gc_thread(struct f2fs_sb_info *sbi)
                return err;
        }
 
+       set_user_nice(gc_th->f2fs_gc_task,
+                       PRIO_TO_NICE(sbi->critical_task_priority));
        return 0;
 }
 

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index d5cf7265e5d3c0e52aad5ba3f87a73fc603ea97c..1a755997aff55cacce519c932d66e13ebe1d9d9b 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -4340,6 +4340,7 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
        sbi->max_lock_elapsed_time = MAX_LOCK_ELAPSED_TIME;
        sbi->adjust_lock_priority = 0;
        sbi->lock_duration_priority = F2FS_DEFAULT_TASK_PRIORITY;
+       sbi->critical_task_priority = F2FS_CRITICAL_TASK_PRIORITY;
 
        sbi->sum_blocksize = f2fs_sb_has_packed_ssa(sbi) ?
                4096 : sbi->blocksize;

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index 3a272e7edf23413be227f1b7dd71eca56e9c74b8..5fbfdc96e502d60c800f9ed8632a7c11b2e7e9e3 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -969,6 +969,21 @@ out:
                return count;
        }
 
+       if (!strcmp(a->attr.name, "critical_task_priority")) {
+               if (t < NICE_TO_PRIO(MIN_NICE) || t > NICE_TO_PRIO(MAX_NICE))
+                       return -EINVAL;
+               if (!capable(CAP_SYS_NICE))
+                       return -EPERM;
+               sbi->critical_task_priority = t;
+               if (sbi->cprc_info.f2fs_issue_ckpt)
+                       set_user_nice(sbi->cprc_info.f2fs_issue_ckpt,
+                                       PRIO_TO_NICE(sbi->critical_task_priority));
+               if (sbi->gc_thread && sbi->gc_thread->f2fs_gc_task)
+                       set_user_nice(sbi->gc_thread->f2fs_gc_task,
+                                       PRIO_TO_NICE(sbi->critical_task_priority));
+               return count;
+       }
+
        __sbi_store_value(a, sbi, ptr + a->offset, t);
 
        return count;
@@ -1288,6 +1303,7 @@ F2FS_SBI_GENERAL_RW_ATTR(bggc_io_aware);
 F2FS_SBI_GENERAL_RW_ATTR(max_lock_elapsed_time);
 F2FS_SBI_GENERAL_RW_ATTR(lock_duration_priority);
 F2FS_SBI_GENERAL_RW_ATTR(adjust_lock_priority);
+F2FS_SBI_GENERAL_RW_ATTR(critical_task_priority);
 
 /* STAT_INFO ATTR */
 #ifdef CONFIG_F2FS_STAT_FS
@@ -1496,6 +1512,7 @@ static struct attribute *f2fs_attrs[] = {
        ATTR_LIST(max_lock_elapsed_time),
        ATTR_LIST(lock_duration_priority),
        ATTR_LIST(adjust_lock_priority),
+       ATTR_LIST(critical_task_priority),
        NULL,
 };
 ATTRIBUTE_GROUPS(f2fs);