From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 701D344C4EE for ; Tue, 25 Aug 2026 13:01:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787662913; cv=none; b=XHAXbmlxtVOhdByDbo/dBJkqGUdI3Ns1CzQSPYgyETdB0IMUwUZfSAygaufB6ITip1GAICx3UnMeIX0MA4a5LzChkcI7XgpgmO40/faPqOc7X4uEE7jAeZ/Wy92Xh2nD4/ZVPxbuwIY89PUP1OdDBsnV+zBcCbvdNsFXcUH5Sbc= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787662913; c=relaxed/simple; bh=oVmZpYM1zAW7t7ESGOghohzqkxxN9yIWivTng0tKQr4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=KLIywyrx6VcR1Kr9wRslO6yFy9v/KeLg3h6NAuHi9Q9BV2gDFzjYc7rMI9D5IkgeQpY+85tG7E+CuDCaP0a6FwqnmjHIIWaemQmGqZtAGPC6/wMYgQSB3jrhrIC15F1Ig/kRqfUXxCHZt79HLXcdXRQ2K76b4Dwri4j1u0uM9hQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KgcJOYPi; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="KgcJOYPi" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3B0111F00AC4; Tue, 25 Aug 2026 13:01:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1787662911; bh=9XYLRoOsDsXkWtt1U8k+UspNw7f3nYtHyEkYLmQ4148=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=KgcJOYPiTkJpPR4Ao+QTw8ZDE37RzMmnTQVvlQPSazDwA7lvOwBl3Op7dxD941QYa t4mxMmmpyqV7jrjHUR7cmPk8mTtRIrMufn3alw6p8s+fpDet9+AWUXWLCT8e7ol+AT zegGTJQjHIszMwIS7Mu1Rm6TiWMEKn4JPVc/syD1A9iSjn7/9DGWpZItzVEIY6cSWv ZKutpPp2j5haKIpiVa6NKV7vNuSfJtZ9DiX4WORiT0FTSuc6miY0RbFzHVh12efeMR b/lH+fjITyJ3cr8HlPxpfTZ0NUWGIACs6g1MhhSbk22Qz2fWVZD+t4Br3LYBiXr8/n 2fRXS/7Gav2dQ== From: Chao Yu To: jaegeuk@kernel.org Cc: linux-f2fs-devel@lists.sourceforge.net, linux-kernel@vger.kernel.org, Chao Yu Subject: [PATCH v3 03/12] f2fs: cache: introduce shrinker Date: Tue, 25 Aug 2026 21:01:17 +0800 Message-ID: <20260825130126.2078627-4-chao@kernel.org> X-Mailer: git-send-email 2.55.0.887.g758fc8c411-goog In-Reply-To: <20260825130126.2078627-1-chao@kernel.org> References: <20260825130126.2078627-1-chao@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit 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 --- 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) + 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); + 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