[RFC PATCH 7/7] selftests/cgroup: make test_memcg_high_sync check that throttling holds
From: Shakeel Butt
Date: Sat Nov 21 2026 - 21:48:36 EST
test_memcg_high_sync mlock()s 200M with memory.high=30M and
memory.max=140M, and expects memory.high to throttle the call before it
reaches memory.max. But it checked memory.events right after the first
high event, so it passed as soon as the handler ran once, even if the
rest of the call was not throttled.
That hid a real gap: with THP=always and the default defrag=madvise,
THP charges skipped the synchronous handler, and only a few page table
charges ran it. In a VM, usage reached 85M within 115ms and memory.max
about 2s later.
After the first event, check for 5 seconds that no max event shows up
and the child is still running, then that memory.current went up.
Counting high events isn't enough: one handler call can log many while
it retries reclaim. Also kill and reap the child, which may still be
throttled.
Signed-off-by: Shakeel Butt <shakeel.butt@xxxxxxxxx>
---
.../selftests/cgroup/test_memcontrol.c | 39 +++++++++++++++----
1 file changed, 32 insertions(+), 7 deletions(-)
diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testing/selftests/cgroup/test_memcontrol.c
index bb673012dcf0..1af984761a02 100644
--- a/tools/testing/selftests/cgroup/test_memcontrol.c
+++ b/tools/testing/selftests/cgroup/test_memcontrol.c
@@ -771,14 +771,16 @@ static int alloc_anon_mlock(const char *cgroup, void *arg)
/*
* This test checks that memory.high is able to throttle big single shot
- * allocation i.e. large allocation within one kernel entry.
+ * allocation i.e. large allocation within one kernel entry. The name is
+ * from when this was done synchronously in the charge path.
*/
static int test_memcg_high_sync(const char *root)
{
- int ret = KSFT_FAIL, pid, fd = -1;
+ int ret = KSFT_FAIL, pid = -1, fd = -1, i;
char *memcg;
long pre_high, pre_max;
- long post_high, post_max;
+ long first_high, first_current;
+ long post_max, post_current;
memcg = cg_name(root, "memcg_test");
if (!memcg)
@@ -811,17 +813,40 @@ static int test_memcg_high_sync(const char *root)
cg_wait_for(fd);
- post_high = cg_read_key_long(memcg, "memory.events", "high ");
- post_max = cg_read_key_long(memcg, "memory.events", "max ");
- if (post_high < 0 || post_max < 0)
+ /*
+ * The first event only shows that throttling started. For 5 seconds,
+ * check that the child is still running and doesn't reach memory.max,
+ * then that memory.current went up, so it is throttled, not stuck.
+ * High events don't show progress: one handler call can log many.
+ */
+ first_high = cg_read_key_long(memcg, "memory.events", "high ");
+ first_current = cg_read_long(memcg, "memory.current");
+ if (first_high < 0 || first_high == pre_high || first_current < 0)
goto cleanup;
- if (pre_high == post_high || pre_max != post_max)
+ for (i = 0; i < 50; i++) {
+ usleep(100000);
+ post_max = cg_read_key_long(memcg, "memory.events", "max ");
+ if (post_max < 0 || post_max != pre_max)
+ goto cleanup;
+ if (waitpid(pid, NULL, WNOHANG) == pid) {
+ pid = -1;
+ goto cleanup;
+ }
+ }
+
+ post_current = cg_read_long(memcg, "memory.current");
+ if (post_current <= first_current)
goto cleanup;
ret = KSFT_PASS;
cleanup:
+ if (pid > 0) {
+ kill(pid, SIGKILL);
+ while (waitpid(pid, NULL, 0) < 0 && errno == EINTR)
+ ;
+ }
if (fd >= 0)
close(fd);
cg_destroy(memcg);
--
2.53.1-Meta