Re: [f2fs-dev] [PATCH v3 03/12] f2fs: cache: introduce shrinker

[Daeho Jeong]

On Tue, Aug 25, 2026 at 6:03 AM Chao Yu via Linux-f2fs-devel
<linux-f2fs-devel@xxxxxxxxxxxxxxxxxxxxx> wrote:
>
> This patch integrates the metadata cache into the F2FS memory shrinker
> subsystem to reclaim clean, unreferenced cached blocks under memory
> pressure.
>
> It implements f2fs_shrink_cache() using a 3-phase cache reclamin method:
> 1. isolate clean entries from lru list
> 2. truncate from radix tree under lock
> 3. splice un-reclaimed entries back
>
> And hooks the new interface into f2fs_shrink_count() and f2fs_shrink_scan().
>
> Signed-off-by: Chao Yu <chao@xxxxxxxxxx>
> ---
>  fs/f2fs/cache.c    | 81 ++++++++++++++++++++++++++++++++++++++++++++++
>  fs/f2fs/cache.h    |  3 ++
>  fs/f2fs/shrinker.c | 12 +++++++
>  3 files changed, 96 insertions(+)
>
> diff --git a/fs/f2fs/cache.c b/fs/f2fs/cache.c
> index 8f09492c402f..3cee33c69880 100644
> --- a/fs/f2fs/cache.c
> +++ b/fs/f2fs/cache.c
> @@ -534,3 +534,84 @@ void f2fs_destroy_cache(struct f2fs_cached_block_list *cache)
>         f2fs_put_cache(entry, true);
>         goto next;
>  }
> +
> +static unsigned long f2fs_do_shrink_cache(struct f2fs_cached_block_list *cache,
> +                                               unsigned long nr_to_scan)
> +{
> +       struct f2fs_cached_block *entry, *next;
> +       LIST_HEAD(dispose_list);
> +       LIST_HEAD(keep_list);
> +       unsigned long freed = 0;
> +       unsigned long isolated = 0;
> +
> +       /* Phase 1: Isolate candidate entries from LRU list into dispose_list */
> +       spin_lock(&cache->list_lock);
> +       list_for_each_entry_safe(entry, next, &cache->lru_list, list) {
> +               if (isolated++ >= nr_to_scan)

scanned?

> +                       break;
> +
> +               if (f2fs_cache_test_dirty(entry) ||
> +                   f2fs_cache_test_writeback(entry) ||
> +                   f2fs_cache_test_locked(entry))
> +                       continue;
> +
> +               if (f2fs_cache_refcount(entry) != 1)
> +                       continue;
> +
> +               list_move_tail(&entry->list, &dispose_list);
> +       }
> +       spin_unlock(&cache->list_lock);
> +
> +       /* Phase 2: Process isolated candidates one by one */
> +       while (1) {
> +               spin_lock(&cache->list_lock);

Why do we need this lock to protect local lists?

Thanks,

> +               entry = list_first_entry_or_null(&dispose_list,
> +                                               struct f2fs_cached_block, list);
> +               if (!entry) {
> +                       spin_unlock(&cache->list_lock);
> +                       break;
> +               }
> +               f2fs_cache_get(entry);
> +               list_move_tail(&entry->list, &keep_list);
> +               spin_unlock(&cache->list_lock);
> +
> +               if (!f2fs_trylock_cache(entry)) {
> +                       f2fs_put_cache(entry, false);
> +                       continue;
> +               }
> +
> +               /* the entry has been truncated */
> +               if (!entry->cache) {
> +                       f2fs_put_cache(entry, true);
> +                       continue;
> +               }
> +               /*
> +                * at least there are shrinker, radix tree and another user
> +                * has referenced the entry.
> +                */
> +               if (f2fs_cache_refcount(entry) >= 3) {
> +                       f2fs_put_cache(entry, true);
> +                       continue;
> +               }
> +
> +               f2fs_do_truncate_cache(entry, false);
> +
> +               if (f2fs_put_cache(entry, true))
> +                       freed++;
> +       }
> +
> +       /* Phase 3: Splice un-reclaimed entries back onto cache->lru_list */
> +       if (!list_empty(&keep_list)) {
> +               spin_lock(&cache->list_lock);
> +               list_splice_tail(&keep_list, &cache->lru_list);
> +               spin_unlock(&cache->list_lock);
> +       }
> +
> +       return freed;
> +}
> +
> +unsigned long f2fs_shrink_cache(struct f2fs_sb_info *sbi,
> +                                       unsigned long nr_to_scan)
> +{
> +       return f2fs_do_shrink_cache(META_CACHE(sbi), nr_to_scan);
> +}
> diff --git a/fs/f2fs/cache.h b/fs/f2fs/cache.h
> index 7ee98d276938..618b377590da 100644
> --- a/fs/f2fs/cache.h
> +++ b/fs/f2fs/cache.h
> @@ -184,4 +184,7 @@ void f2fs_stop_cache_wb_thread(struct f2fs_sb_info *sbi);
>  #define f2fs_truncate_meta_caches(sbi, start, len)     \
>         f2fs_drop_cache_range(META_CACHE(sbi), start, len, true)
>
> +unsigned long f2fs_shrink_cache(struct f2fs_sb_info *sbi,
> +                               unsigned long nr_to_scan);
> +
>  #endif /* _LINUX_F2FS_CACHE_H */
> diff --git a/fs/f2fs/shrinker.c b/fs/f2fs/shrinker.c
> index 4f6bf5926de4..1755c85849e4 100644
> --- a/fs/f2fs/shrinker.c
> +++ b/fs/f2fs/shrinker.c
> @@ -37,6 +37,11 @@ static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi,
>                                 atomic_read(&eti->total_ext_node);
>  }
>
> +static unsigned long __count_cache(struct f2fs_sb_info *sbi)
> +{
> +       return sbi->meta_blocks.num_entries;
> +}
> +
>  unsigned long f2fs_shrink_count(struct shrinker *shrink,
>                                 struct shrink_control *sc)
>  {
> @@ -68,6 +73,9 @@ unsigned long f2fs_shrink_count(struct shrinker *shrink,
>                 /* count free nids cache entries */
>                 count += __count_free_nids(sbi);
>
> +               /* count generic cache entries */
> +               count += __count_cache(sbi);
> +
>                 spin_lock(&f2fs_list_lock);
>                 p = p->next;
>                 mutex_unlock(&sbi->umount_mutex);
> @@ -120,6 +128,10 @@ unsigned long f2fs_shrink_scan(struct shrinker *shrink,
>                 if (freed < nr)
>                         freed += f2fs_try_to_free_nids(sbi, nr - freed);
>
> +               /* shrink generic cache entries */
> +               if (freed < nr)
> +                       freed += f2fs_shrink_cache(sbi, nr - freed);
> +
>                 spin_lock(&f2fs_list_lock);
>                 p = p->next;
>                 list_move_tail(&sbi->s_list, &f2fs_list);
> --
> 2.49.0
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel