Re: [PATCH] selftests/cgroup: memory controller self-tests

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On 05/09/2018 01:20 PM, Roman Gushchin wrote:
> Cgroups are used for controlling the physical resource distribution
> (memory, CPU, io, etc) and often are used as basic building blocks
> for large distributed computing systems. Even small differences
> in the actual behavior may lead to significant incidents.
> 
> The codebase is under the active development, which will unlikely
> stop at any time soon. Also it's scattered over different
> kernel subsystems, which makes regressions more probable.
> 
> Given that, the lack of any tests is crying.
> 
> This patch implements some basic tests for the memory controller,
> as well as a minimal required framework.
> It doesn't pretend for a very good coverage, but pretends
> to be a starting point.
> 
> Hopefully, any following significant changes will
> include corresponding tests.
> 
> Tests for CPU and io controllers, as well as cgroup core
> are next in the todo list.
> 

Thanks you for the patch.


> Signed-off-by: Roman Gushchin <guro@xxxxxx>
> Cc: Tejun Heo <tj@xxxxxxxxxx>
> Cc: Shuah Khan <shuah@xxxxxxxxxx>
> Cc: Johannes Weiner <hannes@xxxxxxxxxxx>
> Cc: Michal Hocko <mhocko@xxxxxxxx>
> Cc: Mike Rapoport <rppt@xxxxxxxxxxxxxxxxxx>
> Cc: kernel-team@xxxxxx
> Cc: linux-kselftest@xxxxxxxxxxxxxxx
> Cc: linux-kernel@xxxxxxxxxxxxxxx
> ---
>  tools/testing/selftests/Makefile                 |   1 +
>  tools/testing/selftests/cgroup/Makefile          |  10 +
>  tools/testing/selftests/cgroup/cgroup_util.c     | 317 ++++++++++
>  tools/testing/selftests/cgroup/cgroup_util.h     |  40 ++
>  tools/testing/selftests/cgroup/test_memcontrol.c | 742 +++++++++++++++++++++++
>  5 files changed, 1110 insertions(+)
>  create mode 100644 tools/testing/selftests/cgroup/Makefile
>  create mode 100644 tools/testing/selftests/cgroup/cgroup_util.c
>  create mode 100644 tools/testing/selftests/cgroup/cgroup_util.h
>  create mode 100644 tools/testing/selftests/cgroup/test_memcontrol.c
> 
> diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
> index 32aafa92074c..24d0331d6c11 100644
> --- a/tools/testing/selftests/Makefile
> +++ b/tools/testing/selftests/Makefile
> @@ -3,6 +3,7 @@ TARGETS = android
>  TARGETS += bpf
>  TARGETS += breakpoints
>  TARGETS += capabilities
> +TARGETS += cgroup
>  TARGETS += cpufreq
>  TARGETS += cpu-hotplug
>  TARGETS += efivarfs
> diff --git a/tools/testing/selftests/cgroup/Makefile b/tools/testing/selftests/cgroup/Makefile
> new file mode 100644
> index 000000000000..f7a31392eb2f
> --- /dev/null
> +++ b/tools/testing/selftests/cgroup/Makefile
> @@ -0,0 +1,10 @@
> +# SPDX-License-Identifier: GPL-2.0
> +CFLAGS += -Wall
> +
> +all:
> +
> +TEST_GEN_PROGS = test_memcontrol
> +
> +include ../lib.mk
> +
> +$(OUTPUT)/test_memcontrol: cgroup_util.c
> diff --git a/tools/testing/selftests/cgroup/cgroup_util.c b/tools/testing/selftests/cgroup/cgroup_util.c
> new file mode 100644
> index 000000000000..a938b6c8b55a
> --- /dev/null
> +++ b/tools/testing/selftests/cgroup/cgroup_util.c
> @@ -0,0 +1,317 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +
> +#define _GNU_SOURCE
> +
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <linux/limits.h>
> +#include <signal.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <sys/types.h>
> +#include <sys/wait.h>
> +#include <unistd.h>
> +
> +#include "cgroup_util.h"
> +
> +static ssize_t read_text(const char *path, char *buf, size_t max_len)
> +{
> +	ssize_t len;
> +	int fd;
> +
> +	fd = open(path, O_RDONLY);
> +	if (fd < 0)
> +		return fd;
> +
> +	len = read(fd, buf, max_len - 1);
> +	if (len < 0)
> +		goto out;
> +
> +	buf[len] = 0;
> +out:
> +	close(fd);
> +	return len;
> +}
> +
> +static ssize_t write_text(const char *path, char *buf, size_t len)
> +{
> +	int fd;
> +
> +	fd = open(path, O_WRONLY | O_APPEND);
> +	if (fd < 0)
> +		return fd;
> +
> +	len = write(fd, buf, len);
> +	if (len < 0) {
> +		close(fd);
> +		return len;
> +	}
> +
> +	close(fd);
> +
> +	return len;
> +}
> +
> +char *cg_name(const char *root, const char *name)
> +{
> +	size_t len = strlen(root) + strlen(name) + 2;
> +	char *ret = malloc(len);
> +
> +	if (name)
> +		snprintf(ret, len, "%s/%s", root, name);
> +
> +	return ret;
> +}
> +
> +char *cg_name_indexed(const char *root, const char *name, int index)
> +{
> +	size_t len = strlen(root) + strlen(name) + 10;
> +	char *ret = malloc(len);
> +
> +	if (name)
> +		snprintf(ret, len, "%s/%s_%d", root, name, index);
> +
> +	return ret;
> +}
> +
> +int cg_read(const char *cgroup, const char *control, char *buf, size_t len)
> +{
> +	char path[PATH_MAX];
> +
> +	snprintf(path, sizeof(path), "%s/%s", cgroup, control);
> +
> +	if (read_text(path, buf, len) >= 0)
> +		return 0;
> +
> +	return -1;
> +}
> +
> +int cg_read_strcmp(const char *cgroup, const char *control,
> +		   const char *expected)
> +{
> +	size_t size = strlen(expected) + 1;
> +	char *buf;
> +
> +	buf = malloc(size);
> +	if (!buf)
> +		return -1;
> +
> +	if (cg_read(cgroup, control, buf, size))
> +		return -1;
> +
> +	return strcmp(expected, buf);
> +}
> +
> +int cg_read_strstr(const char *cgroup, const char *control, const char *needle)
> +{
> +	char buf[PAGE_SIZE];
> +
> +	if (cg_read(cgroup, control, buf, sizeof(buf)))
> +		return -1;
> +
> +	return strstr(buf, needle) ? 0 : -1;
> +}
> +
> +long cg_read_long(const char *cgroup, const char *control)
> +{
> +	char buf[128];
> +
> +	if (cg_read(cgroup, control, buf, sizeof(buf)))
> +		return -1;
> +
> +	return atol(buf);
> +}
> +
> +long cg_read_key_long(const char *cgroup, const char *control, const char *key)
> +{
> +	char buf[PAGE_SIZE];
> +	char *ptr;
> +
> +	if (cg_read(cgroup, control, buf, sizeof(buf)))
> +		return -1;
> +
> +	ptr = strstr(buf, key);
> +	if (!ptr)
> +		return -1;
> +
> +	return atol(ptr + strlen(key));
> +}
> +
> +int cg_write(const char *cgroup, const char *control, char *buf)
> +{
> +	char path[PATH_MAX];
> +	size_t len = strlen(buf);
> +
> +	snprintf(path, sizeof(path), "%s/%s", cgroup, control);
> +
> +	if (write_text(path, buf, len) == len)
> +		return 0;
> +
> +	return -1;
> +}
> +
> +int cg_find_unified_root(char *root, size_t len)
> +{
> +	char buf[10 * PAGE_SIZE];
> +	char *fs, *mount, *type;
> +	const char delim[] = "\n\t ";
> +
> +	if (read_text("/proc/self/mounts", buf, sizeof(buf)) <= 0)
> +		return -1;
> +
> +	/*
> +	 * Example:
> +	 * cgroup /sys/fs/cgroup cgroup2 rw,seclabel,noexec,relatime 0 0
> +	 */
> +	for (fs = strtok(buf, delim); fs; fs = strtok(NULL, delim)) {
> +		mount = strtok(NULL, delim);
> +		type = strtok(NULL, delim);
> +		strtok(NULL, delim);
> +		strtok(NULL, delim);
> +		strtok(NULL, delim);
> +
> +		if (strcmp(fs, "cgroup") == 0 &&
> +		    strcmp(type, "cgroup2") == 0) {
> +			strncpy(root, mount, len);
> +			return 0;
> +		}
> +	}
> +
> +	return -1;
> +}
> +
> +int cg_create(const char *cgroup)
> +{
> +	return mkdir(cgroup, 0644);
> +}
> +
> +static int cg_killall(const char *cgroup)
> +{
> +	char buf[PAGE_SIZE];
> +	char *ptr = buf;
> +
> +	if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf)))
> +		return -1;
> +
> +	while (ptr < buf + sizeof(buf)) {
> +		int pid = strtol(ptr, &ptr, 10);
> +
> +		if (pid == 0)
> +			break;
> +		if (*ptr)
> +			ptr++;
> +		else
> +			break;
> +		if (kill(pid, SIGKILL))
> +			return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +int cg_destroy(const char *cgroup)
> +{
> +	int ret;
> +
> +retry:
> +	ret = rmdir(cgroup);
> +	if (ret && errno == EBUSY) {
> +		ret = cg_killall(cgroup);
> +		if (ret)
> +			return ret;
> +		usleep(100);
> +		goto retry;
> +	}
> +
> +	if (ret && errno == ENOENT)
> +		ret = 0;
> +
> +	return ret;
> +}
> +
> +int cg_run(const char *cgroup,
> +	   int (*fn)(const char *cgroup, void *arg),
> +	   void *arg)
> +{
> +	int pid, retcode;
> +
> +	pid = fork();
> +	if (pid < 0) {
> +		return pid;
> +	} else if (pid == 0) {
> +		char buf[64];
> +
> +		snprintf(buf, sizeof(buf), "%d", getpid());
> +		if (cg_write(cgroup, "cgroup.procs", buf))
> +			exit(EXIT_FAILURE);
> +		exit(fn(cgroup, arg));
> +	} else {
> +		waitpid(pid, &retcode, 0);
> +		if (WIFEXITED(retcode))
> +			return WEXITSTATUS(retcode);
> +		else
> +			return -1;
> +	}
> +}
> +
> +int cg_run_nowait(const char *cgroup,
> +		  int (*fn)(const char *cgroup, void *arg),
> +		  void *arg)
> +{
> +	int pid;
> +
> +	pid = fork();
> +	if (pid == 0) {
> +		char buf[64];
> +
> +		snprintf(buf, sizeof(buf), "%d", getpid());
> +		if (cg_write(cgroup, "cgroup.procs", buf))
> +			exit(EXIT_FAILURE);
> +		exit(fn(cgroup, arg));
> +	}
> +
> +	return pid;
> +}
> +
> +int get_temp_fd(void)
> +{
> +	return open(".", O_TMPFILE | O_RDWR | O_EXCL);
> +}
> +
> +int alloc_pagecache(int fd, size_t size)
> +{
> +	char buf[PAGE_SIZE];
> +	struct stat st;
> +	int i;
> +
> +	if (fstat(fd, &st))
> +		goto cleanup;
> +
> +	size += st.st_size;
> +
> +	if (ftruncate(fd, size))
> +		goto cleanup;
> +
> +	for (i = 0; i < size; i += sizeof(buf))
> +		read(fd, buf, sizeof(buf));
> +
> +	return 0;
> +
> +cleanup:
> +	return -1;
> +}
> +
> +int alloc_anon(const char *cgroup, void *arg)
> +{
> +	size_t size = (unsigned long)arg;
> +	char *buf, *ptr;
> +
> +	buf = malloc(size);
> +	for (ptr = buf; ptr < buf + size; ptr += PAGE_SIZE)
> +		*ptr = 0;
> +
> +	free(buf);
> +	return 0;
> +}
> diff --git a/tools/testing/selftests/cgroup/cgroup_util.h b/tools/testing/selftests/cgroup/cgroup_util.h
> new file mode 100644
> index 000000000000..000de075d3d8
> --- /dev/null
> +++ b/tools/testing/selftests/cgroup/cgroup_util.h
> @@ -0,0 +1,40 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +#include <stdlib.h>
> +
> +#define PAGE_SIZE 4096
> +
> +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
> +
> +#define MB(x) (x << 20)
> +
> +/*
> + * Checks if two given values differ by less than err% of their sum.
> + */
> +static inline int values_close(long a, long b, int err)
> +{
> +	return abs(a - b) <= (a + b) / 100 * err;
> +}
> +
> +extern int cg_find_unified_root(char *root, size_t len);
> +extern char *cg_name(const char *root, const char *name);
> +extern char *cg_name_indexed(const char *root, const char *name, int index);
> +extern int cg_create(const char *cgroup);
> +extern int cg_destroy(const char *cgroup);
> +extern int cg_read(const char *cgroup, const char *control,
> +		   char *buf, size_t len);
> +extern int cg_read_strcmp(const char *cgroup, const char *control,
> +			  const char *expected);
> +extern int cg_read_strstr(const char *cgroup, const char *control,
> +			  const char *needle);
> +extern long cg_read_long(const char *cgroup, const char *control);
> +long cg_read_key_long(const char *cgroup, const char *control, const char *key);
> +extern int cg_write(const char *cgroup, const char *control, char *buf);
> +extern int cg_run(const char *cgroup,
> +		  int (*fn)(const char *cgroup, void *arg),
> +		  void *arg);
> +extern int cg_run_nowait(const char *cgroup,
> +			 int (*fn)(const char *cgroup, void *arg),
> +			 void *arg);
> +extern int get_temp_fd(void);
> +extern int alloc_pagecache(int fd, size_t size);
> +extern int alloc_anon(const char *cgroup, void *arg);
> diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testing/selftests/cgroup/test_memcontrol.c
> new file mode 100644
> index 000000000000..7bf2a30e857c
> --- /dev/null
> +++ b/tools/testing/selftests/cgroup/test_memcontrol.c
> @@ -0,0 +1,742 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +#define _GNU_SOURCE
> +
> +#include <linux/limits.h>
> +#include <fcntl.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <sys/types.h>
> +#include <unistd.h>
> +
> +#include "cgroup_util.h"
> +
> +enum test_result {
> +	TEST_SKIP,
> +	TEST_FAIL,
> +	TEST_PASS,
> +};
> +
> +const char *test_result_texts[] = {
> +	[TEST_SKIP] = "SKIP",
> +	[TEST_FAIL] = "FAIL",
> +	[TEST_PASS] = "PASS",
> +};
> +

Please use kselftest.h instead of defining these strings.
You can simply call ksft_* routines to print appropriate
SKIPO/FAIL/PASS messages.

> +/*
> + * This test creates two nested cgroups with and without enabling
> + * the memory controller.
> + */
> +static int test_memcg_subtree_control(const char *root)
> +{
> +	char *parent, *child, *parent2, *child2;
> +	int ret = TEST_FAIL;
> +	char buf[PAGE_SIZE];
> +
> +	/* Create two nested cgroups with the memory controller enabled */
> +	parent = cg_name(root, "memcg_test_0");
> +	child = cg_name(root, "memcg_test_0/memcg_test_1");
> +	if (!parent || !child)
> +		goto cleanup;
> +
> +	if (cg_create(parent))
> +		goto cleanup;
> +
> +	if (cg_write(parent, "cgroup.subtree_control", "+memory"))
> +		goto cleanup;
> +
> +	if (cg_create(child))
> +		goto cleanup;
> +
> +	if (cg_read_strstr(child, "cgroup.controllers", "memory"))
> +		goto cleanup;
> +
> +	/* Create two nested cgroups without enabling memory controller */
> +	parent2 = cg_name(root, "memcg_test_1");
> +	child2 = cg_name(root, "memcg_test_1/memcg_test_1");
> +	if (!parent2 || !child2)
> +		goto cleanup;
> +
> +	if (cg_create(parent2))
> +		goto cleanup;
> +
> +	if (cg_create(child2))
> +		goto cleanup;
> +
> +	if (cg_read(child2, "cgroup.controllers", buf, sizeof(buf)))
> +		goto cleanup;
> +
> +	if (!cg_read_strstr(child2, "cgroup.controllers", "memory"))
> +		goto cleanup;
> +
> +	ret = TEST_PASS;
> +
> +cleanup:
> +	cg_destroy(child);
> +	cg_destroy(parent);
> +	free(parent);
> +	free(child);
> +
> +	cg_destroy(child2);
> +	cg_destroy(parent2);
> +	free(parent2);
> +	free(child2);
> +
> +	return ret;
> +}
> +
> +static int alloc_anon_50M_check(const char *cgroup, void *arg)
> +{
> +	size_t size = MB(50);
> +	char *buf, *ptr;
> +	long anon, current;
> +	int ret = -1;
> +
> +	buf = malloc(size);
> +	for (ptr = buf; ptr < buf + size; ptr += PAGE_SIZE)
> +		*ptr = 0;
> +
> +	current = cg_read_long(cgroup, "memory.current");
> +	if (current < size)
> +		goto cleanup;
> +
> +	if (!values_close(size, current, 3))
> +		goto cleanup;
> +
> +	anon = cg_read_key_long(cgroup, "memory.stat", "anon ");
> +	if (anon < 0)
> +		goto cleanup;
> +
> +	if (!values_close(anon, current, 3))
> +		goto cleanup;
> +
> +	ret = 0;
> +cleanup:
> +	free(buf);
> +	return ret;
> +}
> +
> +static int alloc_pagecache_50M_check(const char *cgroup, void *arg)
> +{
> +	size_t size = MB(50);
> +	int ret = -1;
> +	long current, file;
> +	int fd;
> +
> +	fd = get_temp_fd();
> +	if (fd < 0)
> +		return -1;
> +
> +	if (alloc_pagecache(fd, size))
> +		goto cleanup;
> +
> +	current = cg_read_long(cgroup, "memory.current");
> +	if (current < size)
> +		goto cleanup;
> +
> +	file = cg_read_key_long(cgroup, "memory.stat", "file ");
> +	if (file < 0)
> +		goto cleanup;
> +
> +	if (!values_close(file, current, 10))
> +		goto cleanup;
> +
> +	ret = 0;
> +
> +cleanup:
> +	close(fd);
> +	return ret;
> +}
> +
> +/*
> + * This test create a memory cgroup, allocates
> + * some anonymous memory and some pagecache
> + * and check memory.current and some memory.stat values.
> + */
> +static int test_memcg_current(const char *root)
> +{
> +	int ret = TEST_FAIL;
> +	long current;
> +	char *memcg;
> +
> +	memcg = cg_name(root, "memcg_test");
> +	if (!memcg)
> +		goto cleanup;
> +
> +	if (cg_create(memcg))
> +		goto cleanup;
> +
> +	current = cg_read_long(memcg, "memory.current");
> +	if (current != 0)
> +		goto cleanup;
> +
> +	if (cg_run(memcg, alloc_anon_50M_check, NULL))
> +		goto cleanup;
> +
> +	if (cg_run(memcg, alloc_pagecache_50M_check, NULL))
> +		goto cleanup;
> +
> +	ret = TEST_PASS;
> +
> +cleanup:
> +	cg_destroy(memcg);
> +	free(memcg);
> +
> +	return ret;
> +}
> +
> +static int alloc_pagecache_50M(const char *cgroup, void *arg)
> +{
> +	int fd = (long)arg;
> +
> +	return alloc_pagecache(fd, MB(50));
> +}
> +
> +static int alloc_pagecache_50M_noexit(const char *cgroup, void *arg)
> +{
> +	int fd = (long)arg;
> +	int ppid = getppid();
> +
> +	if (alloc_pagecache(fd, MB(50)))
> +		return -1;
> +
> +	while (getppid() == ppid)
> +		sleep(1);
> +
> +	return 0;
> +}
> +
> +/*
> + * First, this test creates the following hierarchy:
> + * A       memory.min = 50M,  memory.max = 200M
> + * A/B     memory.min = 50M,  memory.current = 50M
> + * A/B/C   memory.min = 75M,  memory.current = 50M
> + * A/B/D   memory.min = 25M,  memory.current = 50M
> + * A/B/E   memory.min = 500M, memory.current = 0
> + * A/B/F   memory.min = 0,    memory.current = 50M
> + *
> + * Usages are pagecache, but the test keeps a running
> + * process in every leaf cgroup.
> + * Then it creates A/G and creates a significant
> + * memory pressure in it.
> + *
> + * A/B    memory.current ~= 50M
> + * A/B/C  memory.current ~= 33M
> + * A/B/D  memory.current ~= 17M
> + * A/B/E  memory.current ~= 0
> + *
> + * After that it tries to allocate more than there is
> + * unprotected memory in A available, and checks
> + * checks that memory.min protects pagecache even
> + * in this case.
> + */
> +static int test_memcg_min(const char *root)
> +{
> +	int ret = TEST_FAIL;
> +	char *parent[3] = {NULL};
> +	char *children[4] = {NULL};
> +	long c[4];
> +	int i, attempts;
> +	int fd;
> +
> +	fd = get_temp_fd();
> +	if (fd < 0)
> +		goto cleanup;
> +
> +	parent[0] = cg_name(root, "memcg_test_0");
> +	if (!parent[0])
> +		goto cleanup;
> +
> +	parent[1] = cg_name(parent[0], "memcg_test_1");
> +	if (!parent[1])
> +		goto cleanup;
> +
> +	parent[2] = cg_name(parent[0], "memcg_test_2");
> +	if (!parent[2])
> +		goto cleanup;
> +
> +	if (cg_create(parent[0]))
> +		goto cleanup;
> +
> +	if (cg_read_long(parent[0], "memory.min")) {
> +		ret = TEST_SKIP;
> +		goto cleanup;
> +	}
> +
> +	if (cg_write(parent[0], "cgroup.subtree_control", "+memory"))
> +		goto cleanup;
> +
> +	if (cg_write(parent[0], "memory.max", "200M"))
> +		goto cleanup;
> +
> +	if (cg_write(parent[0], "memory.swap.max", "0"))
> +		goto cleanup;
> +
> +	if (cg_create(parent[1]))
> +		goto cleanup;
> +
> +	if (cg_write(parent[1], "cgroup.subtree_control", "+memory"))
> +		goto cleanup;
> +
> +	if (cg_create(parent[2]))
> +		goto cleanup;
> +
> +	for (i = 0; i < ARRAY_SIZE(children); i++) {
> +		children[i] = cg_name_indexed(parent[1], "child_memcg", i);
> +		if (!children[i])
> +			goto cleanup;
> +
> +		if (cg_create(children[i]))
> +			goto cleanup;
> +
> +		if (i == 2)
> +			continue;
> +
> +		cg_run_nowait(children[i], alloc_pagecache_50M_noexit,
> +			      (void *)(long)fd);
> +	}
> +
> +	if (cg_write(parent[0], "memory.min", "50M"))
> +		goto cleanup;
> +	if (cg_write(parent[1], "memory.min", "50M"))
> +		goto cleanup;
> +	if (cg_write(children[0], "memory.min", "75M"))
> +		goto cleanup;
> +	if (cg_write(children[1], "memory.min", "25M"))
> +		goto cleanup;
> +	if (cg_write(children[2], "memory.min", "500M"))
> +		goto cleanup;
> +	if (cg_write(children[3], "memory.min", "0"))
> +		goto cleanup;
> +
> +	attempts = 0;
> +	while (!values_close(cg_read_long(parent[1], "memory.current"),
> +			     MB(150), 3)) {
> +		if (attempts++ > 5)
> +			break;
> +		sleep(1);
> +	}
> +
> +	if (cg_run(parent[2], alloc_anon, (void *)MB(148)))
> +		goto cleanup;
> +
> +	if (!values_close(cg_read_long(parent[1], "memory.current"), MB(50), 3))
> +		goto cleanup;
> +
> +	for (i = 0; i < ARRAY_SIZE(children); i++)
> +		c[i] = cg_read_long(children[i], "memory.current");
> +
> +	if (!values_close(c[0], MB(33), 10))
> +		goto cleanup;
> +
> +	if (!values_close(c[1], MB(17), 10))
> +		goto cleanup;
> +
> +	if (!values_close(c[2], 0, 1))
> +		goto cleanup;
> +
> +	if (!cg_run(parent[2], alloc_anon, (void *)MB(170)))
> +		goto cleanup;
> +
> +	if (!values_close(cg_read_long(parent[1], "memory.current"), MB(50), 3))
> +		goto cleanup;
> +
> +	ret = TEST_PASS;
> +
> +cleanup:
> +	for (i = ARRAY_SIZE(children) - 1; i >= 0; i--) {
> +		if (!children[i])
> +			continue;
> +
> +		cg_destroy(children[i]);
> +		free(children[i]);
> +	}
> +
> +	for (i = ARRAY_SIZE(parent) - 1; i >= 0; i--) {
> +		if (!parent[i])
> +			continue;
> +
> +		cg_destroy(parent[i]);
> +		free(parent[i]);
> +	}
> +	close(fd);
> +	return ret;
> +}
> +
> +/*
> + * First, this test creates the following hierarchy:
> + * A       memory.low = 50M,  memory.max = 200M
> + * A/B     memory.low = 50M,  memory.current = 50M
> + * A/B/C   memory.low = 75M,  memory.current = 50M
> + * A/B/D   memory.low = 25M,  memory.current = 50M
> + * A/B/E   memory.low = 500M, memory.current = 0
> + * A/B/F   memory.low = 0,    memory.current = 50M
> + *
> + * Usages are pagecache.
> + * Then it creates A/G an creates a significant
> + * memory pressure in it.
> + *
> + * Then it checks actual memory usages and expects that:
> + * A/B    memory.current ~= 50M
> + * A/B/   memory.current ~= 33M
> + * A/B/D  memory.current ~= 17M
> + * A/B/E  memory.current ~= 0
> + *
> + * After that it tries to allocate more than there is
> + * unprotected memory in A available,
> + * and checks low and oom events in memory.events.
> + */
> +static int test_memcg_low(const char *root)
> +{
> +	int ret = TEST_FAIL;
> +	char *parent[3] = {NULL};
> +	char *children[4] = {NULL};
> +	long low, oom;
> +	long c[4];
> +	int i;
> +	int fd;
> +
> +	fd = get_temp_fd();
> +	if (fd < 0)
> +		goto cleanup;
> +
> +	parent[0] = cg_name(root, "memcg_test_0");
> +	if (!parent[0])
> +		goto cleanup;
> +
> +	parent[1] = cg_name(parent[0], "memcg_test_1");
> +	if (!parent[1])
> +		goto cleanup;
> +
> +	parent[2] = cg_name(parent[0], "memcg_test_2");
> +	if (!parent[2])
> +		goto cleanup;
> +
> +	if (cg_create(parent[0]))
> +		goto cleanup;
> +
> +	if (cg_read_long(parent[0], "memory.low"))
> +		goto cleanup;
> +
> +	if (cg_write(parent[0], "cgroup.subtree_control", "+memory"))
> +		goto cleanup;
> +
> +	if (cg_write(parent[0], "memory.max", "200M"))
> +		goto cleanup;
> +
> +	if (cg_write(parent[0], "memory.swap.max", "0"))
> +		goto cleanup;
> +
> +	if (cg_create(parent[1]))
> +		goto cleanup;
> +
> +	if (cg_write(parent[1], "cgroup.subtree_control", "+memory"))
> +		goto cleanup;
> +
> +	if (cg_create(parent[2]))
> +		goto cleanup;
> +
> +	for (i = 0; i < ARRAY_SIZE(children); i++) {
> +		children[i] = cg_name_indexed(parent[1], "child_memcg", i);
> +		if (!children[i])
> +			goto cleanup;
> +
> +		if (cg_create(children[i]))
> +			goto cleanup;
> +
> +		if (i == 2)
> +			continue;
> +
> +		if (cg_run(children[i], alloc_pagecache_50M, (void *)(long)fd))
> +			goto cleanup;
> +	}
> +
> +	if (cg_write(parent[0], "memory.low", "50M"))
> +		goto cleanup;
> +	if (cg_write(parent[1], "memory.low", "50M"))
> +		goto cleanup;
> +	if (cg_write(children[0], "memory.low", "75M"))
> +		goto cleanup;
> +	if (cg_write(children[1], "memory.low", "25M"))
> +		goto cleanup;
> +	if (cg_write(children[2], "memory.low", "500M"))
> +		goto cleanup;
> +	if (cg_write(children[3], "memory.low", "0"))
> +		goto cleanup;
> +
> +	if (cg_run(parent[2], alloc_anon, (void *)MB(148)))
> +		goto cleanup;
> +
> +	if (!values_close(cg_read_long(parent[1], "memory.current"), MB(50), 3))
> +		goto cleanup;
> +
> +	for (i = 0; i < ARRAY_SIZE(children); i++)
> +		c[i] = cg_read_long(children[i], "memory.current");
> +
> +	if (!values_close(c[0], MB(33), 10))
> +		goto cleanup;
> +
> +	if (!values_close(c[1], MB(17), 10))
> +		goto cleanup;
> +
> +	if (!values_close(c[2], 0, 1))
> +		goto cleanup;
> +
> +	if (cg_run(parent[2], alloc_anon, (void *)MB(166))) {
> +		fprintf(stderr,
> +			"memory.low prevents from allocating anon memory\n");
> +		goto cleanup;
> +	}
> +
> +	for (i = 0; i < ARRAY_SIZE(children); i++) {
> +		oom = cg_read_key_long(children[i], "memory.events", "oom ");
> +		low = cg_read_key_long(children[i], "memory.events", "low ");
> +
> +		if (oom)
> +			goto cleanup;
> +		if (i < 2 && low <= 0)
> +			goto cleanup;
> +		if (i >= 2 && low)
> +			goto cleanup;
> +	}
> +
> +	ret = TEST_PASS;
> +
> +cleanup:
> +	for (i = ARRAY_SIZE(children) - 1; i >= 0; i--) {
> +		if (!children[i])
> +			continue;
> +
> +		cg_destroy(children[i]);
> +		free(children[i]);
> +	}
> +
> +	for (i = ARRAY_SIZE(parent) - 1; i >= 0; i--) {
> +		if (!parent[i])
> +			continue;
> +
> +		cg_destroy(parent[i]);
> +		free(parent[i]);
> +	}
> +	close(fd);
> +	return ret;
> +}
> +
> +static int alloc_pagecache_max_30M(const char *cgroup, void *arg)
> +{
> +	size_t size = MB(50);
> +	int ret = -1;
> +	long current;
> +	int fd;
> +
> +	fd = get_temp_fd();
> +	if (fd < 0)
> +		return -1;
> +
> +	if (alloc_pagecache(fd, size))
> +		goto cleanup;
> +
> +	current = cg_read_long(cgroup, "memory.current");
> +	if (current <= MB(29) || current > MB(30))
> +		goto cleanup;
> +
> +	ret = 0;
> +
> +cleanup:
> +	close(fd);
> +	return ret;
> +
> +}
> +
> +/*
> + * This test checks that memory.high limits the amount of
> + * memory which can be consumed by either anonymous memory
> + * or pagecache.
> + */
> +static int test_memcg_high(const char *root)
> +{
> +	int ret = TEST_FAIL;
> +	char *memcg;
> +	long high;
> +
> +	memcg = cg_name(root, "memcg_test");
> +	if (!memcg)
> +		goto cleanup;
> +
> +	if (cg_create(memcg))
> +		goto cleanup;
> +
> +	if (cg_read_strcmp(memcg, "memory.high", "max\n"))
> +		goto cleanup;
> +
> +	if (cg_write(memcg, "memory.swap.max", "0"))
> +		goto cleanup;
> +
> +	if (cg_write(memcg, "memory.high", "30M"))
> +		goto cleanup;
> +
> +	if (cg_run(memcg, alloc_anon, (void *)MB(100)))
> +		goto cleanup;
> +
> +	if (!cg_run(memcg, alloc_pagecache_50M_check, NULL))
> +		goto cleanup;
> +
> +	if (cg_run(memcg, alloc_pagecache_max_30M, NULL))
> +		goto cleanup;
> +
> +	high = cg_read_key_long(memcg, "memory.events", "high ");
> +	if (high <= 0)
> +		goto cleanup;
> +
> +	ret = TEST_PASS;
> +
> +cleanup:
> +	cg_destroy(memcg);
> +	free(memcg);
> +
> +	return ret;
> +}
> +
> +/*
> + * This test checks that memory.max limits the amount of
> + * memory which can be consumed by either anonymous memory
> + * or pagecache.
> + */
> +static int test_memcg_max(const char *root)
> +{
> +	int ret = TEST_FAIL;
> +	char *memcg;
> +	long current, max;
> +
> +	memcg = cg_name(root, "memcg_test");
> +	if (!memcg)
> +		goto cleanup;
> +
> +	if (cg_create(memcg))
> +		goto cleanup;
> +
> +	if (cg_read_strcmp(memcg, "memory.max", "max\n"))
> +		goto cleanup;
> +
> +	if (cg_write(memcg, "memory.swap.max", "0"))
> +		goto cleanup;
> +
> +	if (cg_write(memcg, "memory.max", "30M"))
> +		goto cleanup;
> +
> +	/* Should be killed by OOM killer */
> +	if (!cg_run(memcg, alloc_anon, (void *)MB(100)))
> +		goto cleanup;
> +
> +	if (cg_run(memcg, alloc_pagecache_max_30M, NULL))
> +		goto cleanup;
> +
> +	current = cg_read_long(memcg, "memory.current");
> +	if (current > MB(30) || !current)
> +		goto cleanup;
> +
> +	max = cg_read_key_long(memcg, "memory.events", "max ");
> +	if (max <= 0)
> +		goto cleanup;
> +
> +	ret = TEST_PASS;
> +
> +cleanup:
> +	cg_destroy(memcg);
> +	free(memcg);
> +
> +	return ret;
> +}
> +
> +/*
> + * This test disables swapping and tries to allocate anonymous memory
> + * up to OOM. Then it checks for oom and oom_kill events in
> + * memory.events.
> + */
> +static int test_memcg_oom_events(const char *root)
> +{
> +	int ret = TEST_FAIL;
> +	char *memcg;
> +
> +	memcg = cg_name(root, "memcg_test");
> +	if (!memcg)
> +		goto cleanup;
> +
> +	if (cg_create(memcg))
> +		goto cleanup;
> +
> +	if (cg_write(memcg, "memory.max", "30M"))
> +		goto cleanup;
> +
> +	if (cg_write(memcg, "memory.swap.max", "0"))
> +		goto cleanup;
> +
> +	if (!cg_run(memcg, alloc_anon, (void *)MB(100)))
> +		goto cleanup;
> +
> +	if (cg_read_strcmp(memcg, "cgroup.procs", ""))
> +		goto cleanup;
> +
> +	if (cg_read_key_long(memcg, "memory.events", "oom ") != 1)
> +		goto cleanup;
> +
> +	if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 1)
> +		goto cleanup;
> +
> +	ret = TEST_PASS;
> +
> +cleanup:
> +	cg_destroy(memcg);
> +	free(memcg);
> +
> +	return ret;
> +}
> +
> +#define T(x) { x, #x }
> +struct memcg_test {
> +	int (*fn)(const char *root);
> +	const char *name;
> +} tests[] = {
> +	T(test_memcg_subtree_control),
> +	T(test_memcg_current),
> +	T(test_memcg_min),
> +	T(test_memcg_low),
> +	T(test_memcg_high),
> +	T(test_memcg_max),
> +	T(test_memcg_oom_events),
> +};
> +#undef T
> +
> +int main(int argc, char **argv)
> +{
> +	char root[PATH_MAX];
> +	int i, ret = EXIT_SUCCESS;
> +
> +	if (cg_find_unified_root(root, sizeof(root))) {
> +		printf("test_memcontrol:SKIP (cgroup v2 isn't mounted)\n");
> +		return ret;
> +	}
> +

Please call ksft_exit_skip() here so lib.mk can count this as a skipped
test.

> +	/*
> +	 * Check that memory controller is available:
> +	 * memory is listed in cgroup.controllers
> +	 */
> +	if (cg_read_strstr(root, "cgroup.controllers", "memory")) {
> +		printf("test_memcontrol:SKIP "
> +		       "(memory controller is not available)\n");
> +		return ret;
> +	}
> +

Please call ksft_exit_skip() here so lib.mk can count this as a skipped
test.

> +
> +	for (i = 0; i < ARRAY_SIZE(tests); i++) {
> +		int r = tests[i].fn(root);
> +
> +		printf("%s:%s\n", tests[i].name, test_result_texts[r]);
> +
> +		if (r == TEST_FAIL)
> +			ret = EXIT_FAILURE;
> +	}
> +
> +	return ret;
> +}
> 

thanks,
-- Shuah
--
To unsubscribe from this list: send the line "unsubscribe linux-kselftest" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html



[Index of Archives]     [Linux Wireless]     [Linux Kernel]     [ATH6KL]     [Linux Bluetooth]     [Linux Netdev]     [Kernel Newbies]     [Share Photos]     [IDE]     [Security]     [Git]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux RAID]     [Linux ATA RAID]     [Samba]     [Device Mapper]

  Powered by Linux