[PATCH v3] mm: add source selector to memory.reclaim

From: Li Zhe

Date: Mon Nov 16 2026 - 06:08:41 EST


memory.reclaim can apply proactive reclaim to a memcg, but it cannot
target source nodes the way global node reclaim can. Proactive memcg
reclaim follows a fast-to-slow fallback order, which attempts demotion
before reclaiming from slower tiers.

As a result, a memcg controller cannot decide whether reclaim should
start from DRAM or from a slower tier. For a cgroup that is close to OOM
and needs charge reduction, or for a controller trying to shape a
workload's DRAM/CXL resident distribution, the default policy may spend
reclaim effort on the wrong source tier.

Add source=nodes:<nodelist> to memory.reclaim. The selector only chooses
the resident source nodes where the existing memcg reclaim path applies
pressure. It does not select demotion targets, force demotion, force
eviction, promote pages, or change completion accounting. Leaving source
unspecified preserves existing behavior.

With this, userspace can build the policy it needs on top of existing
kernel reclaim behavior:

1. start reclaim from lower-tier nodes to reduce the cgroup's memory
usage more directly;
2. steer reclaim toward over-represented nodes to shape a workload's
DRAM/CXL resident distribution; and
3. reclaim from lower-tier nodes first so later top-tier reclaim has
room for demotion.

Example: nodes 0-2=DRAM, node3=CXL

echo 1G > memory.reclaim # progress from nodes 0-3
echo "1G source=nodes:3" > memory.reclaim # reclaim from CXL
echo "1G source=nodes:0-2" > memory.reclaim # usually demote to CXL

The typed source= form also leaves room for future source selectors
without changing the ABI introduced here.

Tested in a CXL setup with nodes 0-2 as DRAM and node 3 as CXL. A
userspace controller steered eight cgroups toward a 50:50 DRAM:CXL
resident ratio while a background workload created reclaim and demotion
pressure. With source=nodes, all eight cgroups ended with 45%-55% of
their memory on DRAM. Under the same pressure, the plain memory.reclaim
baseline left the worst cgroup far away from the target range.

Signed-off-by: Li Zhe <lizhe.67@xxxxxxxxxxxxx>
---
v2: https://lore.kernel.org/all/20261102070440.16262-1-lizhe.67@xxxxxxxxxxxxx/#t
v1: https://lore.kernel.org/all/20261019141401.11927-1-lizhe.67@xxxxxxxxxxxxx/

Changes since v2:
- Dropped the separate cover letter and shortened/refocused the commit
message, as suggested by Joshua Hahn and Gregory Price.
- Added an eight-cgroup CXL test summary under background
reclaim/demotion pressure, as suggested by Joshua Hahn.

---
Documentation/admin-guide/cgroup-v2.rst | 11 ++++++
mm/bpf_memcontrol.c | 3 +-
mm/internal.h | 3 +-
mm/memcontrol-v1.c | 6 ++-
mm/memcontrol.c | 11 ++++--
mm/vmscan.c | 49 +++++++++++++++++++++++--
6 files changed, 72 insertions(+), 11 deletions(-)

diff --git a/Documentation/admin-guide/cgroup-v2.rst b/Documentation/admin-guide/cgroup-v2.rst
index 9e3c67b02ae2..992f9bdc46a1 100644
--- a/Documentation/admin-guide/cgroup-v2.rst
+++ b/Documentation/admin-guide/cgroup-v2.rst
@@ -1458,6 +1458,7 @@ The following nested keys are defined.

========== ================================
swappiness Swappiness value to reclaim with
+ source Source to apply reclaim pressure to
========== ================================

Specifying a swappiness value instructs the kernel to perform
@@ -1468,6 +1469,16 @@ The following nested keys are defined.
The valid range for swappiness is [0-200, max], setting
swappiness=max exclusively reclaims anonymous memory.

+ Specifying a source value constrains where proactive reclaim applies
+ pressure. Currently only source=nodes:<nodelist> is supported. For
+ example::
+
+ echo "1G source=nodes:0-1" > memory.reclaim
+
+ This applies proactive reclaim pressure to memory of the target cgroup
+ resident on nodes 0-1. It does not constrain demotion targets and does
+ not change memory.reclaim completion accounting.
+
memory.peak
A read-write single value file which exists on non-root cgroups.

diff --git a/mm/bpf_memcontrol.c b/mm/bpf_memcontrol.c
index d8f579c28560..7d98f55a044f 100644
--- a/mm/bpf_memcontrol.c
+++ b/mm/bpf_memcontrol.c
@@ -201,7 +201,8 @@ __bpf_kfunc long bpf_proactive_reclaim(struct mem_cgroup *memcg,
nr_reclaimed = try_to_free_mem_cgroup_pages(memcg, nr_pages, GFP_KERNEL,
MEMCG_RECLAIM_MAY_SWAP |
MEMCG_RECLAIM_PROACTIVE,
- swappiness == -1 ? NULL : &swappiness);
+ swappiness == -1 ? NULL : &swappiness,
+ NULL);

return nr_reclaimed * PAGE_SIZE;
}
diff --git a/mm/internal.h b/mm/internal.h
index e3f92883bf23..ff24a58d47e8 100644
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -83,7 +83,8 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
unsigned long nr_pages,
gfp_t gfp_mask,
unsigned int reclaim_options,
- int *swappiness);
+ int *swappiness,
+ const nodemask_t *source_nodes);

#ifdef CONFIG_NUMA
extern int sysctl_min_unmapped_ratio;
diff --git a/mm/memcontrol-v1.c b/mm/memcontrol-v1.c
index b7f286888507..74aa06fee76a 100644
--- a/mm/memcontrol-v1.c
+++ b/mm/memcontrol-v1.c
@@ -1464,7 +1464,8 @@ static int mem_cgroup_resize_max(struct mem_cgroup *memcg,
}

if (!try_to_free_mem_cgroup_pages(memcg, 1, GFP_KERNEL,
- memsw ? 0 : MEMCG_RECLAIM_MAY_SWAP, NULL)) {
+ memsw ? 0 : MEMCG_RECLAIM_MAY_SWAP,
+ NULL, NULL)) {
ret = -EBUSY;
break;
}
@@ -1500,7 +1501,8 @@ static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
break;

if (!try_to_free_mem_cgroup_pages(memcg, 1, GFP_KERNEL,
- MEMCG_RECLAIM_MAY_SWAP, NULL))
+ MEMCG_RECLAIM_MAY_SWAP,
+ NULL, NULL))
nr_retries--;
}

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 84f4a8fd4d16..116c6853c9ba 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -2444,7 +2444,7 @@ static unsigned long reclaim_high(struct mem_cgroup *memcg,
nr_reclaimed += try_to_free_mem_cgroup_pages(memcg, nr_pages,
gfp_mask,
MEMCG_RECLAIM_MAY_SWAP,
- NULL);
+ NULL, NULL);
psi_memstall_leave(&pflags);
} while ((memcg = parent_mem_cgroup(memcg)) &&
!mem_cgroup_is_root(memcg));
@@ -2774,7 +2774,8 @@ static int try_charge_memcg(struct mem_cgroup *memcg, gfp_t gfp_mask,

psi_memstall_enter(&pflags);
nr_reclaimed = try_to_free_mem_cgroup_pages(mem_over_limit, nr_pages,
- gfp_mask, reclaim_options, NULL);
+ gfp_mask, reclaim_options,
+ NULL, NULL);
psi_memstall_leave(&pflags);

if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
@@ -5001,7 +5002,8 @@ static ssize_t memory_high_write(struct kernfs_open_file *of,
}

reclaimed = try_to_free_mem_cgroup_pages(memcg, nr_pages - high,
- GFP_KERNEL, MEMCG_RECLAIM_MAY_SWAP, NULL);
+ GFP_KERNEL, MEMCG_RECLAIM_MAY_SWAP,
+ NULL, NULL);

if (!reclaimed && !nr_retries--)
break;
@@ -5060,7 +5062,8 @@ static ssize_t memory_max_write(struct kernfs_open_file *of,

if (nr_reclaims) {
if (!try_to_free_mem_cgroup_pages(memcg, nr_pages - max,
- GFP_KERNEL, MEMCG_RECLAIM_MAY_SWAP, NULL))
+ GFP_KERNEL, MEMCG_RECLAIM_MAY_SWAP,
+ NULL, NULL))
nr_reclaims--;
continue;
}
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 6a1af9b92349..15e2e5710468 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -7013,12 +7013,14 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
unsigned long nr_pages,
gfp_t gfp_mask,
unsigned int reclaim_options,
- int *swappiness)
+ int *swappiness,
+ const nodemask_t *source_nodes)
{
unsigned long nr_reclaimed;
unsigned int noreclaim_flag;
struct scan_control sc = {
.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
+ .nodemask = source_nodes,
.proactive_swappiness = swappiness,
.gfp_mask = (current_gfp_context(gfp_mask) & GFP_RECLAIM_MASK) |
(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
@@ -7054,7 +7056,8 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
unsigned long nr_pages,
gfp_t gfp_mask,
unsigned int reclaim_options,
- int *swappiness)
+ int *swappiness,
+ const nodemask_t *source_nodes)
{
return 0;
}
@@ -8098,20 +8101,51 @@ static unsigned long __node_reclaim(struct pglist_data *pgdat,
enum {
MEMORY_RECLAIM_SWAPPINESS = 0,
MEMORY_RECLAIM_SWAPPINESS_MAX,
+ MEMORY_RECLAIM_SOURCE,
MEMORY_RECLAIM_NULL,
};
static const match_table_t tokens = {
{ MEMORY_RECLAIM_SWAPPINESS, "swappiness=%d"},
{ MEMORY_RECLAIM_SWAPPINESS_MAX, "swappiness=max"},
+ { MEMORY_RECLAIM_SOURCE, "source=%s"},
{ MEMORY_RECLAIM_NULL, NULL },
};

+#define MEMORY_RECLAIM_SOURCE_NODES "nodes:"
+#define MEMORY_RECLAIM_SOURCE_NODES_LEN (sizeof(MEMORY_RECLAIM_SOURCE_NODES) - 1)
+
+static int parse_memory_reclaim_source(const char *source,
+ nodemask_t *source_nodes)
+{
+ const char *nodes;
+
+ if (strncmp(source, MEMORY_RECLAIM_SOURCE_NODES,
+ MEMORY_RECLAIM_SOURCE_NODES_LEN))
+ return -EINVAL;
+
+ nodes = source + MEMORY_RECLAIM_SOURCE_NODES_LEN;
+ if (!*nodes)
+ return -EINVAL;
+
+ nodes_clear(*source_nodes);
+ if (nodelist_parse(nodes, *source_nodes))
+ return -EINVAL;
+
+ nodes_and(*source_nodes, *source_nodes, node_states[N_MEMORY]);
+ if (nodes_empty(*source_nodes))
+ return -EINVAL;
+
+ return 0;
+}
+
int user_proactive_reclaim(char *buf,
struct mem_cgroup *memcg, pg_data_t *pgdat)
{
unsigned int nr_retries = MAX_RECLAIM_RETRIES;
unsigned long nr_to_reclaim, nr_reclaimed = 0;
int swappiness = -1;
+ nodemask_t source_nodes;
+ const nodemask_t *source_nodemask = NULL;
char *old_buf, *start;
substring_t args[MAX_OPT_ARGS];
gfp_t gfp_mask = GFP_KERNEL;
@@ -8142,6 +8176,14 @@ int user_proactive_reclaim(char *buf,
case MEMORY_RECLAIM_SWAPPINESS_MAX:
swappiness = SWAPPINESS_ANON_ONLY;
break;
+ case MEMORY_RECLAIM_SOURCE:
+ if (!memcg || source_nodemask)
+ return -EINVAL;
+ if (parse_memory_reclaim_source(args[0].from,
+ &source_nodes))
+ return -EINVAL;
+ source_nodemask = &source_nodes;
+ break;
default:
return -EINVAL;
}
@@ -8181,7 +8223,8 @@ int user_proactive_reclaim(char *buf,
reclaimed = try_to_free_mem_cgroup_pages(memcg,
batch_size, gfp_mask,
reclaim_options,
- swappiness == -1 ? NULL : &swappiness);
+ swappiness == -1 ? NULL : &swappiness,
+ source_nodemask);
} else {
struct scan_control sc = {
.gfp_mask = current_gfp_context(gfp_mask),
--
2.20.1