Re: [PATCH v3] selftests: cgroup/memcontrol: add basic test for socket accounting

Hi,

Are there any updates on this?

On Tue, May 22, 2018 at 11:06:05PM +0300, Mike Rapoport wrote:

The test verifies that when there is active TCP connection, the memory.stat.sock and memory.current values are close.

Signed-off-by: Mike Rapoport rppt@linux.vnet.ibm.com Acked-by: Roman Gushchin guro@fb.com

---

v3 changes:

• added changelog

v2 changes:

• bumped error percentage for comparing memory.current with memory.stat.sock
• added checks that memory.stat.sock == 0 and memory.current >= 0 after TCP

server exits

• simplified error handling

tools/testing/selftests/cgroup/test_memcontrol.c | 193 +++++++++++++++++++++++ 1 file changed, 193 insertions(+)

diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testing/selftests/cgroup/test_memcontrol.c index beae06c9c899..cf0bddc9d271 100644 --- a/tools/testing/selftests/cgroup/test_memcontrol.c +++ b/tools/testing/selftests/cgroup/test_memcontrol.c @@ -9,6 +9,12 @@ #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> +#include <sys/socket.h> +#include <sys/wait.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include <netdb.h> +#include <errno.h>

#include "../kselftest.h" #include "cgroup_util.h" @@ -772,6 +778,192 @@ static int test_memcg_oom_events(const char *root) return ret; }

+struct tcp_server_args {

• unsigned short port;
• int ctl[2];

+};

+static int tcp_server(const char *cgroup, void *arg) +{

• struct tcp_server_args *srv_args = arg;
• struct sockaddr_in6 saddr = { 0 };
• socklen_t slen = sizeof(saddr);
• int sk, client_sk, ctl_fd, yes = 1, ret = -1;
• close(srv_args->ctl[0]);
• ctl_fd = srv_args->ctl[1];
• saddr.sin6_family = AF_INET6;
• saddr.sin6_addr = in6addr_any;
• saddr.sin6_port = htons(srv_args->port);
• sk = socket(AF_INET6, SOCK_STREAM, 0);
• if (sk < 0)

• return ret;
  

• if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)

• goto cleanup;
  

• if (bind(sk, (struct sockaddr *)&saddr, slen)) {

• write(ctl_fd, &errno, sizeof(errno));
  

• goto cleanup;
  

• }
• if (listen(sk, 1))

• goto cleanup;
  

• ret = 0;
• if (write(ctl_fd, &ret, sizeof(ret)) != sizeof(ret)) {

• ret = -1;
  

• goto cleanup;
  

• }
• client_sk = accept(sk, NULL, NULL);
• if (client_sk < 0)

• goto cleanup;
  

• ret = -1;
• for (;;) {

• uint8_t buf[0x100000];
  

• if (write(client_sk, buf, sizeof(buf)) <= 0) {
  

• 	if (errno == ECONNRESET)
  

• 		ret = 0;
  

• 	break;
  

• }
  

• }
• close(client_sk);

+cleanup:

• close(sk);
• return ret;

+}

+static int tcp_client(const char *cgroup, unsigned short port) +{

• const char server[] = "localhost";
• struct addrinfo *ai;
• char servport[6];
• int retries = 0x10; /* nice round number */
• int sk, ret;
• snprintf(servport, sizeof(servport), "%hd", port);
• ret = getaddrinfo(server, servport, NULL, &ai);
• if (ret)

• return ret;
  

• sk = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
• if (sk < 0)

• goto free_ainfo;
  

• ret = connect(sk, ai->ai_addr, ai->ai_addrlen);
• if (ret < 0)

• goto close_sk;
  

• ret = KSFT_FAIL;
• while (retries--) {

• uint8_t buf[0x100000];
  

• long current, sock;
  

• if (read(sk, buf, sizeof(buf)) <= 0)
  

• 	goto close_sk;
  

• current = cg_read_long(cgroup, "memory.current");
  

• sock = cg_read_key_long(cgroup, "memory.stat", "sock ");
  

• if (current < 0 || sock < 0)
  

• 	goto close_sk;
  

• if (current < sock)
  

• 	goto close_sk;
  

• if (values_close(current, sock, 10)) {
  

• 	ret = KSFT_PASS;
  

• 	break;
  

• }
  

• }

+close_sk:

• close(sk);

+free_ainfo:

• freeaddrinfo(ai);
• return ret;

+}

+/*

• • This test checks socket memory accounting.
• • The test forks a TCP server listens on a random port between 1000
• • and 61000. Once it gets a client connection, it starts writing to
• • its socket.
• • The TCP client interleaves reads from the socket with check whether
• • memory.current and memory.stat.sock are similar.
• */

+static int test_memcg_sock(const char *root) +{

• int bind_retries = 5, ret = KSFT_FAIL, pid, err;
• unsigned short port;
• char *memcg;
• memcg = cg_name(root, "memcg_test");
• if (!memcg)

• goto cleanup;
  

• if (cg_create(memcg))

• goto cleanup;
  

• while (bind_retries--) {

• struct tcp_server_args args;
  

• if (pipe(args.ctl))
  

• 	goto cleanup;
  

• port = args.port = 1000 + rand() % 60000;
  

• pid = cg_run_nowait(memcg, tcp_server, &args);
  

• if (pid < 0)
  

• 	goto cleanup;
  

• close(args.ctl[1]);
  

• if (read(args.ctl[0], &err, sizeof(err)) != sizeof(err))
  

• 	goto cleanup;
  

• close(args.ctl[0]);
  

• if (!err)
  

• 	break;
  

• if (err != EADDRINUSE)
  

• 	goto cleanup;
  

• waitpid(pid, NULL, 0);
  

• }
• if (err == EADDRINUSE) {

• ret = KSFT_SKIP;
  

• goto cleanup;
  

• }
• if (tcp_client(memcg, port) != KSFT_PASS)

• goto cleanup;
  

• waitpid(pid, &err, 0);
• if (WEXITSTATUS(err))

• goto cleanup;
  

• if (cg_read_long(memcg, "memory.current") < 0)

• goto cleanup;
  

• if (cg_read_key_long(memcg, "memory.stat", "sock "))

• goto cleanup;
  

• ret = KSFT_PASS;

+cleanup:

• cg_destroy(memcg);
• free(memcg);
• return ret;

+}

#define T(x) { x, #x } struct memcg_test { int (*fn)(const char *root); @@ -785,6 +977,7 @@ struct memcg_test { T(test_memcg_max), T(test_memcg_oom_events), T(test_memcg_swap_max),

• T(test_memcg_sock),

}; #undef T

-- 2.7.4