* [PATCH bpf-next] selftests/bpf: Skip memcg_proactive_reclaim when data lands in shmem
@ 2026-11-13 18:01 Kurt Lin
2026-11-16 3:04 ` Hui Zhu
0 siblings, 1 reply; 3+ messages in thread
From: Kurt Lin @ 2026-11-13 18:01 UTC (permalink / raw)
To: Hui Zhu, Kumar Kartikeya Dwivedi, bpf
Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
Martin KaFai Lau, Eduard Zingerman, Song Liu, Yonghong Song,
Jiri Olsa, Ihor Solodrai, Emil Tsalapatis, Barry Song,
Shuah Khan, linux-kselftest, linux-kernel, Kurt Lin
workload_dir() keeps the data file off tmpfs because shmem cannot be
reclaimed without swap. But statfs() only sees the top of a stacking
filesystem: with /tmp on overlayfs over tmpfs, as in virtme-ng guests,
the check passes and all 32 MiB are still charged as shmem. Whether the
test then passes depends on unrelated page cache in the cgroup; in a
full test_progs run it fails with:
test_memcg_proactive_reclaim:FAIL:reclaimed unexpected reclaimed: actual 0 <= expected 0
Check memory.stat after writing the file and skip when most of the
data was charged as shmem.
An AI coding assistant (Claude) was used to find and analyze the
failure and to draft the fix and this changelog.
Fixes: 0f9b1e9ef584 ("selftests/bpf: Add bpf_proactive_reclaim test")
Signed-off-by: Kurt Lin <lylin1023@gmail.com>
---
Notes:
Tested in a virtme-ng guest without swap: with /tmp on overlayfs over
tmpfs the test now skips; on a disk-backed directory it passes.
After writing 32 MiB, memory.stat shows shmem 32.0 MiB on overlayfs
/tmp and on tmpfs, and 0.0 MiB on a disk-backed filesystem.
.../bpf/prog_tests/memcg_proactive_reclaim.c | 28 +++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c b/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c
index c22dcfabe856..c03550676041 100644
--- a/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c
+++ b/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c
@@ -46,6 +46,28 @@ static const char *workload_dir(void)
return NULL;
}
+/*
+ * statfs() only sees the top of a stacking filesystem. When /tmp is an
+ * overlayfs whose upper layer lives on tmpfs, as in virtme-ng guests, the
+ * check above passes but the written data still ends up as shmem. Ask the
+ * cgroup how the pages were actually charged.
+ */
+static bool charged_as_shmem(void)
+{
+ static char buf[8192];
+ unsigned long long shmem;
+ char *p;
+
+ if (read_cgroup_file(CG_PATH, "memory.stat", buf, sizeof(buf)))
+ return false;
+
+ p = strstr(buf, "\nshmem ");
+ if (!p || sscanf(p, "\nshmem %llu", &shmem) != 1)
+ return false;
+
+ return shmem >= FILE_SIZE / 2;
+}
+
void test_memcg_proactive_reclaim(void)
{
struct memcg_proactive_reclaim *skel = NULL;
@@ -99,6 +121,12 @@ void test_memcg_proactive_reclaim(void)
if (!ASSERT_OK(fsync(data_fd), "fsync"))
goto out;
+ if (charged_as_shmem()) {
+ printf("%s:SKIP: %s is backed by shmem\n", __func__, dir);
+ test__skip();
+ goto out;
+ }
+
args.cgroup_id = cgroup_id;
args.size = FILE_SIZE;
skel->bss->reclaimed = 0;
base-commit: 0021f17128de5dc0b19f1a523f448df2440d8088
--
2.56.0
^ permalink raw reply [flat|nested] 3+ messages in thread* Re: [PATCH bpf-next] selftests/bpf: Skip memcg_proactive_reclaim when data lands in shmem 2026-11-13 18:01 [PATCH bpf-next] selftests/bpf: Skip memcg_proactive_reclaim when data lands in shmem Kurt Lin @ 2026-11-16 3:04 ` Hui Zhu 2026-11-16 17:14 ` Kurt Lin 0 siblings, 1 reply; 3+ messages in thread From: Hui Zhu @ 2026-11-16 3:04 UTC (permalink / raw) To: Kurt Lin, Hui Zhu, Kumar Kartikeya Dwivedi, bpf Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko, Martin KaFai Lau, Eduard Zingerman, Song Liu, Yonghong Song, Jiri Olsa, Ihor Solodrai, Emil Tsalapatis, Barry Song, Shuah Khan, linux-kselftest, linux-kernel Hi Kurt, I have two suggestions below. 2026/11/14 02:01, Kurt Lin: > workload_dir() keeps the data file off tmpfs because shmem cannot be > reclaimed without swap. But statfs() only sees the top of a stacking > filesystem: with /tmp on overlayfs over tmpfs, as in virtme-ng guests, > the check passes and all 32 MiB are still charged as shmem. Whether the > test then passes depends on unrelated page cache in the cgroup; in a > full test_progs run it fails with: > > test_memcg_proactive_reclaim:FAIL:reclaimed unexpected reclaimed: actual 0 <= expected 0 > > Check memory.stat after writing the file and skip when most of the > data was charged as shmem. > > An AI coding assistant (Claude) was used to find and analyze the > failure and to draft the fix and this changelog. > > Fixes: 0f9b1e9ef584 ("selftests/bpf: Add bpf_proactive_reclaim test") > Signed-off-by: Kurt Lin <lylin1023@gmail.com> > --- > > Notes: > Tested in a virtme-ng guest without swap: with /tmp on overlayfs over > tmpfs the test now skips; on a disk-backed directory it passes. > > After writing 32 MiB, memory.stat shows shmem 32.0 MiB on overlayfs > /tmp and on tmpfs, and 0.0 MiB on a disk-backed filesystem. > > .../bpf/prog_tests/memcg_proactive_reclaim.c | 28 +++++++++++++++++++ > 1 file changed, 28 insertions(+) > > diff --git a/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c b/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c > index c22dcfabe856..c03550676041 100644 > --- a/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c > +++ b/tools/testing/selftests/bpf/prog_tests/memcg_proactive_reclaim.c > @@ -46,6 +46,28 @@ static const char *workload_dir(void) > return NULL; > } > > +/* > + * statfs() only sees the top of a stacking filesystem. When /tmp is an > + * overlayfs whose upper layer lives on tmpfs, as in virtme-ng guests, the > + * check above passes but the written data still ends up as shmem. Ask the > + * cgroup how the pages were actually charged. > + */ > +static bool charged_as_shmem(void) > +{ > + static char buf[8192]; > + unsigned long long shmem; > + char *p; > + > + if (read_cgroup_file(CG_PATH, "memory.stat", buf, sizeof(buf))) > + return false; Would it make sense to turn the silent "return false" into an explicit assertion, e.g.: if (!ASSERT_OK(read_cgroup_file(CG_PATH, "memory.stat", buf, sizeof(buf)), "read memory.stat")) return false; My reasoning: memory.stat exists on every cgroup v2 hierarchy and the "shmem" key is emitted unconditionally (not behind any CONFIG), and cgroup_setup_and_join() has already succeeded by the time this runs. So a read/parse failure here likely means something is genuinely broken, rather than an environment limitation. With the silent fallback, a shmem-backed dir falls through to the old confusing "reclaimed: actual 0 <= expected 0" failure and the real cause is never reported. The ASSERT_* macros are statement expressions, so this works inside the bool helper: the failure is recorded with a clear message first, and any subsequent "reclaimed" failure becomes obviously secondary. (Skipping on the error path would be worse still -- a genuine breakage would be counted as a pass, so I'd keep it as a failure either way.) > + > + p = strstr(buf, "\nshmem "); > + if (!p || sscanf(p, "\nshmem %llu", &shmem) != 1) > + return false; > + > + return shmem >= FILE_SIZE / 2; Small nit: a one-line comment on the threshold might help future readers, something like "all-or-nothing: the data file is either fully shmem (stacked tmpfs) or not shmem at all (disk-backed), so half of FILE_SIZE is a safe midpoint". Also, printing the measured shmem value in the SKIP message could be handy when debugging odd environments. Best, Hui > +} > + > void test_memcg_proactive_reclaim(void) > { > struct memcg_proactive_reclaim *skel = NULL; > @@ -99,6 +121,12 @@ void test_memcg_proactive_reclaim(void) > if (!ASSERT_OK(fsync(data_fd), "fsync")) > goto out; > > + if (charged_as_shmem()) { > + printf("%s:SKIP: %s is backed by shmem\n", __func__, dir); > + test__skip(); > + goto out; > + } > + > args.cgroup_id = cgroup_id; > args.size = FILE_SIZE; > skel->bss->reclaimed = 0; > > base-commit: 0021f17128de5dc0b19f1a523f448df2440d8088 ^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH bpf-next] selftests/bpf: Skip memcg_proactive_reclaim when data lands in shmem 2026-11-16 3:04 ` Hui Zhu @ 2026-11-16 17:14 ` Kurt Lin 0 siblings, 0 replies; 3+ messages in thread From: Kurt Lin @ 2026-11-16 17:14 UTC (permalink / raw) To: Hui Zhu Cc: Hui Zhu, Kumar Kartikeya Dwivedi, bpf, Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko, Martin KaFai Lau, Eduard Zingerman, Song Liu, Yonghong Song, Jiri Olsa, Ihor Solodrai, Emil Tsalapatis, Barry Song, Shuah Khan, linux-kselftest, linux-kernel, Kurt Lin Hi Hui, Thanks for the review. On 2026/11/16 11:04, Hui Zhu wrote: > Would it make sense to turn the silent "return false" into an explicit > assertion, e.g.: > > if (!ASSERT_OK(read_cgroup_file(CG_PATH, "memory.stat", buf, > sizeof(buf)), "read memory.stat")) > return false; Agreed, a read or parse failure will fail the test in v2. > Small nit: a one-line comment on the threshold might help future > readers, something like "all-or-nothing: the data file is either fully > shmem (stacked tmpfs) or not shmem at all (disk-backed), so half of > FILE_SIZE is a safe midpoint". Also, printing the measured shmem value > in the SKIP message could be handy when debugging odd environments. Will do both. v2 will also address two points sashiko raised: memory.stat is not force-flushed, so right after the write it can still read 0 on machines with many CPUs, and a shmem-backed /tmp should fall back to "." instead of skipping. I plan to poll memory.stat until the write shows up and to try each candidate directory in a cgroup of its own. Thanks, Kurt ^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2026-11-16 17:15 UTC | newest] Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2026-11-13 18:01 [PATCH bpf-next] selftests/bpf: Skip memcg_proactive_reclaim when data lands in shmem Kurt Lin 2026-11-16 3:04 ` Hui Zhu 2026-11-16 17:14 ` Kurt Lin
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®