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>

diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testing/selftests/cgroup/test_memcontrol.c
index 4e1647568c5bb93463f69b8d96832ad018b3bef3..2fb096a2a9f9232b1edf5cf4b8d2e9aa672b7bd2 100644 (file)
--- a/tools/testing/selftests/cgroup/test_memcontrol.c
+++ b/tools/testing/selftests/cgroup/test_memcontrol.c
@@ -21,6 +21,8 @@
 #include "kselftest.h"
 #include "cgroup_util.h"
 
+#define MEMCG_SOCKSTAT_WAIT_RETRIES        30
+
 static bool has_localevents;
 static bool has_recursiveprot;
 
@@ -1384,6 +1386,7 @@ static int test_memcg_sock(const char *root)
        int bind_retries = 5, ret = KSFT_FAIL, pid, err;
        unsigned short port;
        char *memcg;
+       long sock_post = -1;
 
        memcg = cg_name(root, "memcg_test");
        if (!memcg)
@@ -1432,7 +1435,22 @@ static int test_memcg_sock(const char *root)
        if (cg_read_long(memcg, "memory.current") < 0)
                goto cleanup;
 
-       if (cg_read_key_long(memcg, "memory.stat", "sock "))
+       /*
+        * memory.stat is updated asynchronously via the memcg rstat
+        * flushing worker, which runs periodically (every 2 seconds,
+        * see FLUSH_TIME). On a busy system, the "sock " counter may
+        * stay non-zero for a short period of time after the TCP
+        * connection is closed and all socket memory has been
+        * uncharged.
+        *
+        * Poll memory.stat for up to 3 seconds (~FLUSH_TIME plus some
+        * scheduling slack) and require that the "sock " counter
+        * eventually drops to zero.
+        */
+       sock_post = cg_read_key_long_poll(memcg, "memory.stat", "sock ", 0,
+                                        MEMCG_SOCKSTAT_WAIT_RETRIES,
+                                        DEFAULT_WAIT_INTERVAL_US);
+       if (sock_post)
                goto cleanup;
 
        ret = KSFT_PASS;