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

[Zhiguo Niu]

Zhiguo Niu <niuzhiguo84@xxxxxxxxx> 于2026年9月15日周二 10:34写道：
>
> Chao Yu via Linux-f2fs-devel <linux-f2fs-devel@xxxxxxxxxxxxxxxxxxxxx>
> 于2026年9月12日周六 07:28写道：
> >
> > From: Chao Yu <chao@xxxxxxxxxx>
> >
> > 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>
> Reviewed-by: Zhiguo Niu <zhiguo.niu@xxxxxxxxxx>
Hi Chao,
sorry, pls ignore the attachment in the last email. its Operational
error by myself.
thanks!
> thanks!
> > ---
> >  fs/f2fs/cache.c    | 89 ++++++++++++++++++++++++++++++++++++++++++++++
> >  fs/f2fs/cache.h    |  3 ++
> >  fs/f2fs/shrinker.c | 12 +++++++
> >  3 files changed, 104 insertions(+)
> >
> > diff --git a/fs/f2fs/cache.c b/fs/f2fs/cache.c
> > index fb0ab77d3b49..563615761d11 100644
> > --- a/fs/f2fs/cache.c
> > +++ b/fs/f2fs/cache.c
> > @@ -537,3 +537,92 @@ 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 scanned = 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 (scanned >= cache->num_entries)
> > +                       break;
> > +               if (scanned++ >= nr_to_scan)
> > +                       break;
> > +
> > +               /* If accessed, give it a second chance to rotate to tail */
> > +               if (f2fs_cache_test_and_clear_referenced(entry)) {
> > +                       list_move_tail(&entry->list, &cache->lru_list);
> > +                       continue;
> > +               }
> > +
> > +               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);
> > +               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 d5ee51691fac..5728e2225465 100644
> > --- a/fs/f2fs/cache.h
> > +++ b/fs/f2fs/cache.h
> > @@ -206,4 +206,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 e3e0a7e89406..baa09bc63585 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 META_CACHE(sbi)->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