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

[Chao Yu <chao@kernel.org>]

On 8/27/26 03:19, Daeho Jeong wrote:
> On Tue, Aug 25, 2026 at 6:03 AM Chao Yu via Linux-f2fs-devel
> <linux-f2fs-devel@lists.sourceforge.net> 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@kernel.org>
>> ---
>>  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?

Okay, will clean.

> 
>> +                       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?

I think we need to protect the entry from being relocated in f2fs_find_cache()?

Thanks,

> 
> 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@lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel