From: Jaegeuk Kim <jaegeuk@kernel.org>
To: Chao Yu <chao@kernel.org>
Cc: linux-kernel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net
Subject: Re: [f2fs-dev] [PATCH v1 04/12] f2fs: cache: introduce writeback thread
Date: Thu, 20 Aug 2026 05:09:31 +0000 [thread overview]
Message-ID: <aoaMC87U4HYLO4Cg@google.com> (raw)
In-Reply-To: <20260820031721.12218-5-chao@kernel.org>
On 08/20, Chao Yu via Linux-f2fs-devel wrote:
> This patch introduces a background writeback kthread (f2fs_writeback-x:y)
> to periodically flush dirty metadata cache entries with a default
> interval of 5 seconds.
>
> It manages thread lifecycle across mount, unmount, and remount (rw/ro)
> transitions, and hooks synchronous flushing into checkpoint commits.
>
> Signed-off-by: Chao Yu <chao@kernel.org>
> ---
> fs/f2fs/cache.c | 54 ++++++++++++++++++++++++++++++++++++++++++++
> fs/f2fs/cache.h | 13 +++++++++++
> fs/f2fs/checkpoint.c | 1 +
> fs/f2fs/f2fs.h | 3 +++
> fs/f2fs/super.c | 31 ++++++++++++++++++++++++-
> 5 files changed, 101 insertions(+), 1 deletion(-)
>
> diff --git a/fs/f2fs/cache.c b/fs/f2fs/cache.c
> index c071364822c4..cb5b26046162 100644
> --- a/fs/f2fs/cache.c
> +++ b/fs/f2fs/cache.c
> @@ -611,3 +611,57 @@ unsigned long f2fs_shrink_cache(struct f2fs_sb_info *sbi,
> {
> return f2fs_do_shrink_cache(META_CACHE(sbi), nr_to_scan);
> }
> +
> +static int f2fs_cache_writeback_kthread(void *data)
> +{
> + struct f2fs_sb_info *sbi = data;
> + struct f2fs_cache_kthread *cache_thread = &sbi->cache_thread;
> + wait_queue_head_t *wq = &cache_thread->cache_wb_wq;
> + unsigned int interval = DEF_DIRTY_CACHE_TIMEOUT;
> +
> + set_freezable();
> +
> + while (!kthread_should_stop()) {
> + wait_event_freezable_timeout(*wq,
> + kthread_should_stop() ||
> + cache_thread->cache_wb_task == NULL,
> + msecs_to_jiffies(interval));
> +
> + if (kthread_should_stop())
> + break;
> + if (f2fs_cp_error(sbi))
> + continue;
> + }
> + return 0;
> +}
> +
> +int f2fs_start_cache_wb_thread(struct f2fs_sb_info *sbi)
> +{
> + struct f2fs_cache_kthread *cache_thread = &sbi->cache_thread;
> + dev_t dev = sbi->sb->s_dev;
> + char name[36];
> +
> + if (cache_thread->cache_wb_task)
> + return 0;
> +
> + init_waitqueue_head(&cache_thread->cache_wb_wq);
> + snprintf(name, sizeof(name), "f2fs_writeback-%u:%u",
> + MAJOR(dev), MINOR(dev));
> +
> + cache_thread->cache_wb_task = kthread_run(f2fs_cache_writeback_kthread,
> + sbi, "%s", name);
> + if (IS_ERR(cache_thread->cache_wb_task))
> + return PTR_ERR(cache_thread->cache_wb_task);
> + return 0;
> +}
> +
> +void f2fs_stop_cache_wb_thread(struct f2fs_sb_info *sbi)
> +{
> + struct f2fs_cache_kthread *cache_thread = &sbi->cache_thread;
> +
> + if (!cache_thread->cache_wb_task)
> + return;
> +
> + kthread_stop(cache_thread->cache_wb_task);
> + cache_thread->cache_wb_task = NULL;
> +}
> diff --git a/fs/f2fs/cache.h b/fs/f2fs/cache.h
> index d92b6f3ed585..5e9fe8c0b15c 100644
> --- a/fs/f2fs/cache.h
> +++ b/fs/f2fs/cache.h
> @@ -191,4 +191,17 @@ void f2fs_stop_cache_wb_thread(struct f2fs_sb_info *sbi);
> unsigned long f2fs_shrink_cache(struct f2fs_sb_info *sbi,
> unsigned long nr_to_scan);
>
> +#define DEF_DIRTY_CACHE_TIMEOUT 5000
> +
> +struct f2fs_cache_kthread {
> + struct task_struct *cache_wb_task;
> + wait_queue_head_t cache_wb_wq;
> + atomic_t cache_wb_trigger;
> + unsigned int cache_wb_interval_ms;
> +};
> +
> +int f2fs_start_cache_wb_thread(struct f2fs_sb_info *sbi);
> +void f2fs_stop_cache_wb_thread(struct f2fs_sb_info *sbi);
> +void f2fs_sync_cache_wb(struct f2fs_sb_info *sbi);
> +
> #endif /* _LINUX_F2FS_CACHE_H */
> diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
> index f81ba8cc861a..729d19680caf 100644
> --- a/fs/f2fs/checkpoint.c
> +++ b/fs/f2fs/checkpoint.c
> @@ -1596,6 +1596,7 @@ static int block_operations(struct f2fs_sb_info *sbi)
> * sbi->node_change is used only for AIO write_begin path which produces
> * dirty node blocks and some checkpoint values by block allocation.
> */
> +
Unnecessary line.
> __prepare_cp_block(sbi);
> f2fs_up_write(&sbi->node_change);
> return err;
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 9b7c60bbb137..6e20b3586f26 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -2108,6 +2108,9 @@ struct f2fs_sb_info {
>
> /* f2fs internal cache */
> struct f2fs_cached_block_list meta_blocks;
> +
> + /* internal cache flush thread */
> + struct f2fs_cache_kthread cache_thread;
> };
>
> /* Definitions to access f2fs_sb_info */
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index bcfb1f97850e..89affe72f4fc 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -1998,6 +1998,7 @@ static void f2fs_put_super(struct super_block *sb)
> * flush all issued checkpoints and stop checkpoint issue thread.
> * after then, all checkpoints should be done by each process context.
> */
> + f2fs_stop_cache_wb_thread(sbi);
> f2fs_stop_ckpt_thread(sbi);
>
> /*
> @@ -2799,6 +2800,7 @@ static int __f2fs_remount(struct fs_context *fc, struct super_block *sb)
> unsigned int flags = fc->sb_flags;
> int err;
> bool need_restart_gc = false, need_stop_gc = false;
> + bool need_restart_wb = false, need_stop_wb = false;
> bool need_restart_flush = false, need_stop_flush = false;
> bool need_restart_discard = false, need_stop_discard = false;
> bool need_enable_checkpoint = false, need_disable_checkpoint = false;
> @@ -2957,6 +2959,18 @@ static int __f2fs_remount(struct fs_context *fc, struct super_block *sb)
> need_stop_gc = true;
> }
>
> + if (flags & SB_RDONLY) {
> + if (sbi->cache_thread.cache_wb_task) {
> + f2fs_stop_cache_wb_thread(sbi);
> + need_restart_wb = true;
> + }
> + } else if (!sbi->cache_thread.cache_wb_task) {
> + err = f2fs_start_cache_wb_thread(sbi);
> + if (err)
> + goto restore_gc;
> + need_stop_wb = true;
> + }
> +
> if (flags & SB_RDONLY) {
> sync_inodes_sb(sb);
>
> @@ -2979,7 +2993,7 @@ static int __f2fs_remount(struct fs_context *fc, struct super_block *sb)
> } else {
> err = f2fs_create_flush_cmd_control(sbi);
> if (err)
> - goto restore_gc;
> + goto restore_wb;
> need_stop_flush = true;
> }
>
> @@ -3075,6 +3089,13 @@ static int __f2fs_remount(struct fs_context *fc, struct super_block *sb)
> clear_opt(sbi, FLUSH_MERGE);
> f2fs_destroy_flush_cmd_control(sbi, false);
> }
> +restore_wb:
> + if (need_restart_wb) {
> + if (f2fs_start_cache_wb_thread(sbi))
> + f2fs_warn(sbi, "background cache writeback thread has stopped");
> + } else if (need_stop_wb) {
> + f2fs_stop_cache_wb_thread(sbi);
> + }
> restore_gc:
> if (need_restart_gc) {
> if (f2fs_start_gc_thread(sbi))
> @@ -5461,6 +5482,12 @@ static int f2fs_fill_super(struct super_block *sb, struct fs_context *fc)
> goto sync_free_meta;
> }
>
> + if (!f2fs_readonly(sb)) {
> + err = f2fs_start_cache_wb_thread(sbi);
> + if (err)
> + goto stop_gc_thread;
> + }
> +
> /* recover broken superblock */
> if (recovery) {
> err = f2fs_commit_super(sbi, true);
> @@ -5483,6 +5510,8 @@ static int f2fs_fill_super(struct super_block *sb, struct fs_context *fc)
> sbi->umount_lock_holder = NULL;
> return 0;
>
> +stop_gc_thread:
> + f2fs_stop_gc_thread(sbi);
> sync_free_meta:
> /* safe to flush all the data */
> sync_filesystem(sbi->sb);
> --
> 2.49.0
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
next prev parent reply other threads:[~2026-08-20 5:09 UTC|newest]
Thread overview: 17+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-08-20 3:17 [PATCH v1 00/12] f2fs: introduce metadata cache Chao Yu
2026-08-20 3:17 ` [PATCH v1 01/12] f2fs: cache: implement " Chao Yu
2026-08-20 5:08 ` [f2fs-dev] " Jaegeuk Kim
2026-08-20 5:13 ` Chao Yu
2026-08-20 3:17 ` [PATCH v1 02/12] f2fs: cache: initialize meta cache Chao Yu
2026-08-20 3:17 ` [PATCH v1 03/12] f2fs: cache: introduce shrinker Chao Yu
2026-08-20 3:17 ` [PATCH v1 04/12] f2fs: cache: introduce writeback thread Chao Yu
2026-08-20 5:09 ` Jaegeuk Kim [this message]
2026-08-20 3:17 ` [PATCH v1 05/12] f2fs: cache: use meta cache Chao Yu
2026-08-20 5:11 ` [f2fs-dev] " Jaegeuk Kim
2026-08-20 3:17 ` [PATCH v1 06/12] f2fs: cache: initialize node cache Chao Yu
2026-08-20 3:17 ` [PATCH v1 07/12] f2fs: cache: use " Chao Yu
2026-08-20 3:17 ` [PATCH v1 08/12] f2fs: cache: initialize compress cache Chao Yu
2026-08-20 3:17 ` [PATCH v1 09/12] f2fs: cache: use " Chao Yu
2026-08-20 3:17 ` [PATCH v1 10/12] f2fs: cache: support fault injection Chao Yu
2026-08-20 3:17 ` [PATCH v1 11/12] f2fs: cache: introduce tracepoints Chao Yu
2026-08-20 3:17 ` [PATCH v1 12/12] f2fs: cache: show per-cache usage in debugfs Chao Yu
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=aoaMC87U4HYLO4Cg@google.com \
--to=jaegeuk@kernel.org \
--cc=chao@kernel.org \
--cc=linux-f2fs-devel@lists.sourceforge.net \
--cc=linux-kernel@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox