fs: push nr_cached_objects memcg gating into individual filesystems
Subsystems (6)
PATCH v2 1/1 fs: push nr_cached_objects memcg gating into individual filesystems
Commit 0baad6f9b997 ("fs/super: skip non-memcg-aware nr_cached_objects in memcg slab shrink") added a check in fs/super.c that skipped every ->nr_cached_objects() hook whenever the shrinker was invoked for a non-root memcg, on the assumption that none of them honour sc->memcg.
That assumption is wrong for XFS, whose inode-reclaim hook is intentionally driven from per-memcg contexts to free memcg-charged slab. Encoding a blanket "never memcg-aware" policy in fs/super.c short-circuits that path.
Push the check down into the callbacks whose counters really are irrelevant to per-memcg reclaim - btrfs_nr_cached_objects() and shmem_unused_huge_count() - and drop the fs/super.c gate. Each filesystem can now lift the restriction independently if its counter later grows memcg awareness, without touching fs/super.c.
Introduce mem_cgroup_shrink_is_root() in <linux/memcontrol.h> so the callbacks don't open-code "sc->memcg is NULL or root".
---
v1 -> v2:
- Do not gate xfs_fs_nr_cached_objects(); XFS's inode reclaim is intentionally driven from per-memcg contexts to free memcg-charged slab (Dave Chinner).
- Add mem_cgroup_shrink_is_root() helper in <linux/memcontrol.h> so the filesystem callbacks don't open-code "sc->memcg is NULL or root". (Dave Chinner)
- Add fixes tag (Dave Chinner)
--- fs/btrfs/super.c | 10 ++++++++++ fs/super.c | 19 ++----------------- include/linux/memcontrol.h | 21 +++++++++++++++++++++ mm/shmem.c | 10 ++++++++++ 4 files changed, 43 insertions(+), 17 deletions(-)
fs/btrfs/super.c +10 -0
@@ -22,6 +22,7 @@#include <linux/namei.h> #include <linux/miscdevice.h> #include <linux/magic.h> +#include <linux/memcontrol.h> #include <linux/slab.h> #include <linux/ratelimit.h> #include <linux/crc32c.h>
@@ -2434,6 +2435,15 @@ static long btrfs_nr_cached_objects(struct super_block *sb, struct shrink_controstruct btrfs_fs_info *fs_info =btrfs_sb (sb);const s64 nr =percpu_counter_read_positive (&fs_info->evictable_extent_maps); +/* +* The evictable extent map counter is filesystem-global and does not +* honour sc->memcg, so it is only meaningful on the global (kswapd or +* root direct reclaim) shrink path. Skip the per-memcg iterations of +* shrink_slab_memcg() to avoid queueing duplicate global work. +*/ +if (!mem_cgroup_shrink_is_root (sc)) +return 0 ; +trace_btrfs_extent_map_shrinker_count (fs_info, nr);return nr;
fs/super.c +2 -17
@@ -24,7 +24,6 @@#include <linux/export.h> #include <linux/slab.h> #include <linux/blkdev.h> -#include <linux/memcontrol.h> #include <linux/mount.h> #include <linux/security.h> #include <linux/writeback.h> /* for the emergency remount stuff */
@@ -170,19 +169,6 @@ static void super_wake(struct super_block *sb, unsigned int flag)wake_up_var (&sb->s_flags); } -/* -* The s_op->nr_cached_objects hooks (used for example by btrfs and xfs) -* operate on filesystem-global state and ignore sc->memcg. Driving them -* from per-memcg shrink_slab_memcg() invocations only burns CPU walking -* per-cpu counters and queueing duplicate work: the actual reclaim happens on -* the global path (kswapd or root direct reclaim) regardless. Restrict them -* to that path. -*/ -static inline bool super_fs_objects_eligible (struct shrink_control *sc) -{ -return !sc->memcg ||mem_cgroup_is_root (sc->memcg); -} -/* * One thing we have to be careful of with a per-sb shrinker is that we don't * drop the last active reference to the superblock from within the shrinker.
@@ -212,7 +198,7 @@ static unsigned long super_cache_scan(struct shrinker *shrink,if (!super_trylock_shared (sb))return SHRINK_STOP ; -if (sb->s_op->nr_cached_objects &&super_fs_objects_eligible (sc)) +if (sb->s_op->nr_cached_objects) fs_objects = sb->s_op->nr_cached_objects (sb, sc); inodes =list_lru_shrink_count (&sb->s_inode_lru, sc);
@@ -273,8 +259,7 @@ static unsigned long super_cache_count(struct shrinker *shrink,return 0 ;smp_rmb (); -if (sb->s_op && sb->s_op->nr_cached_objects && -super_fs_objects_eligible (sc)) +if (sb->s_op && sb->s_op->nr_cached_objects) total_objects = sb->s_op->nr_cached_objects (sb, sc); total_objects +=list_lru_shrink_count (&sb->s_dentry_lru, sc);
include/linux/memcontrol.h +21 -0
@@ -520,6 +520,22 @@ static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)return (memcg == root_mem_cgroup); } +/** +* mem_cgroup_shrink_is_root - is this a global or root-memcg shrink invocation? +* @sc: shrink_control describing the current shrinker call +* +* Returns true when @sc represents a global reclaim shrink (sc->memcg == NULL) +* or a root-memcg shrink, i.e. not a per-memcg iteration of +* shrink_slab_memcg(). Filesystems whose ->nr_cached_objects()/ +* ->free_cached_objects() implementations operate on filesystem-global state +* and do not honour sc->memcg can use this to early-return 0 in per-memcg +* contexts. +*/ +static inline bool mem_cgroup_shrink_is_root (struct shrink_control *sc) +{ +return !sc->memcg ||mem_cgroup_is_root (sc->memcg); +} +static inline bool obj_cgroup_is_root (const struct obj_cgroup *objcg) {return objcg->is_root;
@@ -1071,6 +1087,11 @@ static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)return true; } +static inline bool mem_cgroup_shrink_is_root (struct shrink_control *sc) +{ +return true; +} +static inline bool obj_cgroup_is_root (const struct obj_cgroup *objcg) {return true;
mm/shmem.c +10 -0
@@ -846,6 +846,16 @@ static long shmem_unused_huge_count(struct super_block *sb, struct shrink_control *sc) {struct shmem_sb_info *sbinfo =SHMEM_SB (sb); + +/* +* The per-superblock shrinklist is filesystem-global and does not +* honour sc->memcg, so it is only meaningful on the global (kswapd or +* root direct reclaim) shrink path. Skip the per-memcg iterations of +* shrink_slab_memcg() to avoid queueing duplicate global work. +*/ +if (!mem_cgroup_shrink_is_root (sc)) +return 0 ; +return READ_ONCE (sbinfo->shrinklist_len); }#else /* !CONFIG_TRANSPARENT_HUGEPAGE */
Signature · 1 line
2.53.0-Meta
Quoted 25 lines · Usama Arif
Commit
0baad6f9b997("fs/super: skip non-memcg-awarenr_cached_objectsin memcg slab shrink") added a check infs/super.cthat skipped every ->nr_cached_objects() hook whenever the shrinker was invoked for a non-root memcg, on the assumption that none of them honoursc->memcg.That assumption is wrong for XFS, whose inode-reclaim hook is intentionally driven from per-memcg contexts to free memcg-charged slab. Encoding a blanket "never memcg-aware" policy in
fs/super.cshort-circuits that path.Push the check down into the callbacks whose counters really are irrelevant to per-memcg reclaim -
btrfs_nr_cached_objects()andshmem_unused_huge_count()- and drop thefs/super.cgate. Each filesystem can now lift the restriction independently if its counter later grows memcg awareness, without touchingfs/super.c.Introduce
mem_cgroup_shrink_is_root()in <linux/memcontrol.h> so the callbacks don't open-code "sc->memcgis NULL or root".Fixes 0baad6f9b997 ("fs/super: skip non-memcg-aware nr_cached_objects in memcg slab shrink")Acked-by Qi Zheng <[email protected]>Reviewed-by Jan Kara <[email protected]>Reviewed-by Shakeel Butt <[email protected]>Signed-off-by Usama Arif <[email protected]>---
[snip]
Quoted 50 lines
include/linux/memcontrol.h +21
-0@@ -520,6 +520,22 @@ static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)return (memcg == root_mem_cgroup); } +/** +* mem_cgroup_shrink_is_root - is this a global or root-memcg shrink invocation? +* @sc: shrink_control describing the current shrinker call +* +* Returns true when @sc represents a global reclaim shrink (sc->memcg == NULL) +* or a root-memcg shrink, i.e. not a per-memcg iteration of +* shrink_slab_memcg(). Filesystems whose ->nr_cached_objects()/ +* ->free_cached_objects() implementations operate on filesystem-global state +* and do not honour sc->memcg can use this to early-return 0 in per-memcg +* contexts. +*/ +static inline bool mem_cgroup_shrink_is_root (struct shrink_control *sc) +{ +return !sc->memcg ||mem_cgroup_is_root (sc->memcg); +} +static inline bool obj_cgroup_is_root (const struct obj_cgroup *objcg) {return objcg->is_root;@@ -1071,6 +1087,11 @@ static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)return true; } +static inline bool mem_cgroup_shrink_is_root (struct shrink_control *sc) +{ +return true; +} +static inline bool obj_cgroup_is_root (const struct obj_cgroup *objcg) {return true;mm/shmem.c +3
-0@@ -846,6 +846,16 @@ static long shmem_unused_huge_count(struct super_block *sb, struct shrink_control *sc) {struct shmem_sb_info *sbinfo =SHMEM_SB (sb); + +/* +* The per-superblock shrinklist is filesystem-global and does not
mm/shmem.c static long shmem_unused_huge_count(struct super_block *sb, · line 861
Quoted 10 lines
mm/shmem.c +7
-0+* honour sc->memcg, so it is only meaningful on the global (kswapd or +* root direct reclaim) shrink path. Skip the per-memcg iterations of +* shrink_slab_memcg() to avoid queueing duplicate global work. +*/ +if (!mem_cgroup_shrink_is_root (sc)) +return 0 ; + return READ_ONCE(sbinfo->shrinklist_len); }#else /* !CONFIG_TRANSPARENT_HUGEPAGE */
For shmem part, LGTM.
Quoted 24 lines · Usama Arif
Commit
0baad6f9b997("fs/super: skip non-memcg-awarenr_cached_objectsin memcg slab shrink") added a check infs/super.cthat skipped every ->nr_cached_objects() hook whenever the shrinker was invoked for a non-root memcg, on the assumption that none of them honoursc->memcg.That assumption is wrong for XFS, whose inode-reclaim hook is intentionally driven from per-memcg contexts to free memcg-charged slab. Encoding a blanket "never memcg-aware" policy in
fs/super.cshort-circuits that path.Push the check down into the callbacks whose counters really are irrelevant to per-memcg reclaim -
btrfs_nr_cached_objects()andshmem_unused_huge_count()- and drop thefs/super.cgate. Each filesystem can now lift the restriction independently if its counter later grows memcg awareness, without touchingfs/super.c.Introduce
mem_cgroup_shrink_is_root()in <linux/memcontrol.h> so the callbacks don't open-code "sc->memcgis NULL or root".Fixes 0baad6f9b997 ("fs/super: skip non-memcg-aware nr_cached_objects in memcg slab shrink")Acked-by Qi Zheng <[email protected]>Reviewed-by Jan Kara <[email protected]>Reviewed-by Shakeel Butt <[email protected]>Signed-off-by Usama Arif <[email protected]>
Quoted 10 lines
---
v1 -> v2:
- Do not gatexfs_fs_nr_cached_objects(); XFS's inode reclaim is intentionally driven from per-memcg contexts to free memcg-charged slab (Dave Chinner).
- Addmem_cgroup_shrink_is_root()helper in <linux/memcontrol.h> so the filesystem callbacks don't open-code "sc->memcgis NULL or root". (Dave Chinner)
- Add fixes tag (Dave Chinner)
---
For
Quoted 1 line
fs/btrfs/super.c | 10 ++++++++++
Thanks.
Quoted 1 line · Usama Arif
fs: push
nr_cached_objectsmemcg gating into individual filesystems
Applied to the vfs.fixes branch of the vfs/vfs.git tree. Patches in the vfs.fixes branch should appear in linux-next soon.
Please report any outstanding bugs that were missed during review in a new review to the original patch series allowing us to drop it.
It's encouraged to provide Acked-bys and Reviewed-bys even though the patch has now been applied. If possible patch trailers will be updated.
Note that commit hashes shown below are subject to change due to rebase, trailer updates or similar. If in doubt, please check the listed branch.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git branch: vfs.fixes
[1/1] fs: push nr_cached_objects memcg gating into individual filesystems
https://git.kernel.org/vfs/vfs/c/d5233434ecd5
Quoted 87 lines · Usama Arif
Commit
0baad6f9b997("fs/super: skip non-memcg-awarenr_cached_objectsin memcg slab shrink") added a check infs/super.cthat skipped every ->nr_cached_objects() hook whenever the shrinker was invoked for a non-root memcg, on the assumption that none of them honoursc->memcg.That assumption is wrong for XFS, whose inode-reclaim hook is intentionally driven from per-memcg contexts to free memcg-charged slab. Encoding a blanket "never memcg-aware" policy in
fs/super.cshort-circuits that path.Push the check down into the callbacks whose counters really are irrelevant to per-memcg reclaim -
btrfs_nr_cached_objects()andshmem_unused_huge_count()- and drop thefs/super.cgate. Each filesystem can now lift the restriction independently if its counter later grows memcg awareness, without touchingfs/super.c.Introduce
mem_cgroup_shrink_is_root()in <linux/memcontrol.h> so the callbacks don't open-code "sc->memcgis NULL or root".Fixes 0baad6f9b997 ("fs/super: skip non-memcg-aware nr_cached_objects in memcg slab shrink")Acked-by Qi Zheng <[email protected]>Reviewed-by Jan Kara <[email protected]>Reviewed-by Shakeel Butt <[email protected]>Signed-off-by Usama Arif <[email protected]>---
v1 -> v2:
- Do not gatexfs_fs_nr_cached_objects(); XFS's inode reclaim is intentionally driven from per-memcg contexts to free memcg-charged slab (Dave Chinner).
- Addmem_cgroup_shrink_is_root()helper in <linux/memcontrol.h> so the filesystem callbacks don't open-code "sc->memcgis NULL or root". (Dave Chinner)
- Add fixes tag (Dave Chinner)--- fs/btrfs/super.c | 10 ++++++++++ fs/super.c | 19 ++----------------- include/linux/memcontrol.h | 21 +++++++++++++++++++++ mm/shmem.c | 10 ++++++++++ 4 files changed, 43 insertions(+), 17 deletions(-)fs/btrfs/super.c +10
-0@@ -22,6 +22,7 @@#include <linux/namei.h> #include <linux/miscdevice.h> #include <linux/magic.h> +#include <linux/memcontrol.h> #include <linux/slab.h> #include <linux/ratelimit.h> #include <linux/crc32c.h> @@ -2434,6 +2435,15 @@ static long btrfs_nr_cached_objects(struct super_block *sb, struct shrink_controstruct btrfs_fs_info *fs_info =btrfs_sb (sb);const s64 nr =percpu_counter_read_positive (&fs_info->evictable_extent_maps); +/* +* The evictable extent map counter is filesystem-global and does not +* honour sc->memcg, so it is only meaningful on the global (kswapd or +* root direct reclaim) shrink path. Skip the per-memcg iterations of +* shrink_slab_memcg() to avoid queueing duplicate global work. +*/ +if (!mem_cgroup_shrink_is_root (sc)) +return 0 ; +trace_btrfs_extent_map_shrinker_count (fs_info, nr);return nr;fs/super.c +0
-4@@ -24,7 +24,6 @@#include <linux/export.h> #include <linux/slab.h> #include <linux/blkdev.h> -#include <linux/memcontrol.h> #include <linux/mount.h> #include <linux/security.h> #include <linux/writeback.h> /* for the emergency remount stuff */ @@ -170,19 +169,6 @@ static void super_wake(struct super_block *sb, unsigned int flag)wake_up_var (&sb->s_flags); } -/* -* The s_op->nr_cached_objects hooks (used for example by btrfs and xfs) -* operate on filesystem-global state and ignore sc->memcg. Driving them
fs/super.c static void super_wake(struct super_block *sb, unsigned int flag) · line 185
Quoted 10 lines
fs/super.c +0
-10-* from per-memcg shrink_slab_memcg() invocations only burns CPU walking -* per-cpu counters and queueing duplicate work: the actual reclaim happens on -* the global path (kswapd or root direct reclaim) regardless. Restrict them -* to that path. -*/ -static inline bool super_fs_objects_eligible (struct shrink_control *sc) -{ -return !sc->memcg ||mem_cgroup_is_root (sc->memcg); -} -
Hi Christian, it looks like you missed this when pushing. The commit 0ef8faff490be (next-20260729) doesn't include this part of the code.
Thanks,
Qi
Quoted 110 lines · On Wed, 15 Jul 2026 03:35:16 -0700 Usama Arif <[email protected]> wrote:
Commit
0baad6f9b997("fs/super: skip non-memcg-awarenr_cached_objectsin memcg slab shrink") added a check infs/super.cthat skipped every ->nr_cached_objects() hook whenever the shrinker was invoked for a non-root memcg, on the assumption that none of them honoursc->memcg.That assumption is wrong for XFS, whose inode-reclaim hook is intentionally driven from per-memcg contexts to free memcg-charged slab. Encoding a blanket "never memcg-aware" policy in
fs/super.cshort-circuits that path.Push the check down into the callbacks whose counters really are irrelevant to per-memcg reclaim -
btrfs_nr_cached_objects()andshmem_unused_huge_count()- and drop thefs/super.cgate. Each filesystem can now lift the restriction independently if its counter later grows memcg awareness, without touchingfs/super.c.Introduce
mem_cgroup_shrink_is_root()in <linux/memcontrol.h> so the callbacks don't open-code "sc->memcgis NULL or root".Fixes 0baad6f9b997 ("fs/super: skip non-memcg-aware nr_cached_objects in memcg slab shrink")Acked-by Qi Zheng <[email protected]>Reviewed-by Jan Kara <[email protected]>Reviewed-by Shakeel Butt <[email protected]>Signed-off-by Usama Arif <[email protected]>---
v1 -> v2:
- Do not gatexfs_fs_nr_cached_objects(); XFS's inode reclaim is intentionally driven from per-memcg contexts to free memcg-charged slab (Dave Chinner).
- Addmem_cgroup_shrink_is_root()helper in <linux/memcontrol.h> so the filesystem callbacks don't open-code "sc->memcgis NULL or root". (Dave Chinner)
- Add fixes tag (Dave Chinner)--- fs/btrfs/super.c | 10 ++++++++++ fs/super.c | 19 ++----------------- include/linux/memcontrol.h | 21 +++++++++++++++++++++ mm/shmem.c | 10 ++++++++++ 4 files changed, 43 insertions(+), 17 deletions(-)fs/btrfs/super.c +10
-0@@ -22,6 +22,7 @@#include <linux/namei.h> #include <linux/miscdevice.h> #include <linux/magic.h> +#include <linux/memcontrol.h> #include <linux/slab.h> #include <linux/ratelimit.h> #include <linux/crc32c.h> @@ -2434,6 +2435,15 @@ static long btrfs_nr_cached_objects(struct super_block *sb, struct shrink_controstruct btrfs_fs_info *fs_info =btrfs_sb (sb);const s64 nr =percpu_counter_read_positive (&fs_info->evictable_extent_maps); +/* +* The evictable extent map counter is filesystem-global and does not +* honour sc->memcg, so it is only meaningful on the global (kswapd or +* root direct reclaim) shrink path. Skip the per-memcg iterations of +* shrink_slab_memcg() to avoid queueing duplicate global work. +*/ +if (!mem_cgroup_shrink_is_root (sc)) +return 0 ; +trace_btrfs_extent_map_shrinker_count (fs_info, nr);return nr;fs/super.c +1
-15@@ -24,7 +24,6 @@#include <linux/export.h> #include <linux/slab.h> #include <linux/blkdev.h> -#include <linux/memcontrol.h> #include <linux/mount.h> #include <linux/security.h> #include <linux/writeback.h> /* for the emergency remount stuff */ @@ -170,19 +169,6 @@ static void super_wake(struct super_block *sb, unsigned int flag)wake_up_var (&sb->s_flags); } -/* -* The s_op->nr_cached_objects hooks (used for example by btrfs and xfs) -* operate on filesystem-global state and ignore sc->memcg. Driving them -* from per-memcg shrink_slab_memcg() invocations only burns CPU walking -* per-cpu counters and queueing duplicate work: the actual reclaim happens on -* the global path (kswapd or root direct reclaim) regardless. Restrict them -* to that path. -*/ -static inline bool super_fs_objects_eligible (struct shrink_control *sc) -{ -return !sc->memcg ||mem_cgroup_is_root (sc->memcg); -} -/* * One thing we have to be careful of with a per-sb shrinker is that we don't * drop the last active reference to the superblock from within the shrinker. @@ -212,7 +198,7 @@ static unsigned long super_cache_scan(struct shrinker *shrink,if (!super_trylock_shared (sb))return SHRINK_STOP ; -if (sb->s_op->nr_cached_objects &&super_fs_objects_eligible (sc)) +if (sb->s_op->nr_cached_objects) fs_objects = sb->s_op->nr_cached_objects (sb, sc); inodes =list_lru_shrink_count (&sb->s_inode_lru, sc);
fs/super.c static unsigned long super_cache_count(struct shrinker *shrink, · line 265
Quoted 9 lines
fs/super.c +1
-2@@ -273,8 +259,7 @@ static unsigned long super_cache_count(struct shrinker *shrink,return 0 ;smp_rmb (); -if (sb->s_op && sb->s_op->nr_cached_objects && -super_fs_objects_eligible (sc)) +if (sb->s_op && sb->s_op->nr_cached_objects) total_objects = sb->s_op->nr_cached_objects (sb, sc); total_objects +=list_lru_shrink_count (&sb->s_dentry_lru, sc);
Hi Christian,
It looks like the changes in fs/super.c didnt make it into the patch that was merged in vfs.fixes [1]. Just wanted to check how we could correct this? Should Qi (or I) send a followup patch?
Thanks,
Usama