tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

selftests: cgroup: make test_memcg_sock robust against delayed sock stats

test_memcg_sock() currently requires that memory.stat's "sock " counter
is exactly zero immediately after the TCP server exits. On a busy system
this assumption is too strict:

- Socket memory may be freed with a small delay (e.g. RCU callbacks).
- memcg statistics are updated asynchronously via the rstat flushing
worker, so the "sock " value in memory.stat can stay non-zero for a
short period of time even after all socket memory has been uncharged.

As a result, test_memcg_sock() can intermittently fail even though socket
memory accounting is working correctly.

Make the test more robust by polling memory.stat for the "sock "
counter and allowing it some time to drop to zero instead of checking
it only once. The timeout is set to 3 seconds to cover the periodic
rstat flush interval (FLUSH_TIME = 2*HZ by default) plus some
scheduling slack. If the counter does not become zero within the
timeout, the test still fails as before.

On my test system, running test_memcontrol 50 times produced:

- Before this patch: 6/50 runs passed.
- After this patch: 50/50 runs passed.

Signed-off-by: Guopeng Zhang <zhangguopeng@kylinos.cn>
Suggested-by: Lance Yang <lance.yang@linux.dev>
Reviewed-by: Shakeel Butt <shakeel.butt@linux.dev>
Acked-by: Michal Koutný <mkoutny@suse.com>
Signed-off-by: Tejun Heo <tj@kernel.org>

authored by

Guopeng Zhang and committed by
Tejun Heo 6360d444 311ead1b

+19 -1
+19 -1
tools/testing/selftests/cgroup/test_memcontrol.c
··· 21 21 #include "kselftest.h" 22 22 #include "cgroup_util.h" 23 23 24 + #define MEMCG_SOCKSTAT_WAIT_RETRIES 30 25 + 24 26 static bool has_localevents; 25 27 static bool has_recursiveprot; 26 28 ··· 1386 1384 int bind_retries = 5, ret = KSFT_FAIL, pid, err; 1387 1385 unsigned short port; 1388 1386 char *memcg; 1387 + long sock_post = -1; 1389 1388 1390 1389 memcg = cg_name(root, "memcg_test"); 1391 1390 if (!memcg) ··· 1435 1432 if (cg_read_long(memcg, "memory.current") < 0) 1436 1433 goto cleanup; 1437 1434 1438 - if (cg_read_key_long(memcg, "memory.stat", "sock ")) 1435 + /* 1436 + * memory.stat is updated asynchronously via the memcg rstat 1437 + * flushing worker, which runs periodically (every 2 seconds, 1438 + * see FLUSH_TIME). On a busy system, the "sock " counter may 1439 + * stay non-zero for a short period of time after the TCP 1440 + * connection is closed and all socket memory has been 1441 + * uncharged. 1442 + * 1443 + * Poll memory.stat for up to 3 seconds (~FLUSH_TIME plus some 1444 + * scheduling slack) and require that the "sock " counter 1445 + * eventually drops to zero. 1446 + */ 1447 + sock_post = cg_read_key_long_poll(memcg, "memory.stat", "sock ", 0, 1448 + MEMCG_SOCKSTAT_WAIT_RETRIES, 1449 + DEFAULT_WAIT_INTERVAL_US); 1450 + if (sock_post) 1439 1451 goto cleanup; 1440 1452 1441 1453 ret = KSFT_PASS;