Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a987785d authored by Jay Kamat's avatar Jay Kamat Committed by Shuah Khan (Samsung OSG)
Browse files

Add tests for memory.oom.group 



Add tests for memory.oom.group for the following cases:
- Killing all processes in a leaf cgroup, but leaving the
  parent untouched
- Killing all processes in a parent and leaf cgroup
- Keeping processes marked by OOM_SCORE_ADJ_MIN alive when considered
  for being killed by the group oom killer.

Signed-off-by: default avatarJay Kamat <jgkamat@fb.com>
Acked-by: default avatarRoman Gushchin <guro@fb.com>
Signed-off-by: default avatarShuah Khan (Samsung OSG) <shuah@kernel.org>
parent 48c2bb0b

tools/testing/selftests/cgroup/cgroup_util.c

+21 −0
Original line number Diff line number Diff line
@@ -348,3 +348,24 @@ int is_swap_enabled(void) 


	return cnt > 1;

}



int set_oom_adj_score(int pid, int score)

{

	char path[PATH_MAX];

	int fd, len;



	sprintf(path, "/proc/%d/oom_score_adj", pid);



	fd = open(path, O_WRONLY | O_APPEND);

	if (fd < 0)

		return fd;



	len = dprintf(fd, "%d", score);

	if (len < 0) {

		close(fd);

		return len;

	}



	close(fd);

	return 0;

}

tools/testing/selftests/cgroup/cgroup_util.h

+1 −0
Original line number Diff line number Diff line
@@ -40,3 +40,4 @@ extern int get_temp_fd(void); 
extern int alloc_pagecache(int fd, size_t size);

extern int alloc_anon(const char *cgroup, void *arg);

extern int is_swap_enabled(void);

extern int set_oom_adj_score(int pid, int score);

tools/testing/selftests/cgroup/test_memcontrol.c

+205 −0
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
#define _GNU_SOURCE



#include <linux/limits.h>

#include <linux/oom.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>
@@ -202,6 +203,36 @@ static int alloc_pagecache_50M_noexit(const char *cgroup, void *arg) 
	return 0;

}



static int alloc_anon_noexit(const char *cgroup, void *arg)

{

	int ppid = getppid();



	if (alloc_anon(cgroup, arg))

		return -1;



	while (getppid() == ppid)

		sleep(1);



	return 0;

}



/*

 * Wait until processes are killed asynchronously by the OOM killer

 * If we exceed a timeout, fail.

 */

static int cg_test_proc_killed(const char *cgroup)

{

	int limit;



	for (limit = 10; limit > 0; limit--) {

		if (cg_read_strcmp(cgroup, "cgroup.procs", "") == 0)

			return 0;



		usleep(100000);

	}

	return -1;

}



/*

 * First, this test creates the following hierarchy:

 * A       memory.min = 50M,  memory.max = 200M
@@ -964,6 +995,177 @@ static int test_memcg_sock(const char *root) 
	return ret;

}



/*

 * This test disables swapping and tries to allocate anonymous memory

 * up to OOM with memory.group.oom set. Then it checks that all

 * processes in the leaf (but not the parent) were killed.

 */

static int test_memcg_oom_group_leaf_events(const char *root)

{

	int ret = KSFT_FAIL;

	char *parent, *child;



	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_create(child))

		goto cleanup;



	if (cg_write(parent, "cgroup.subtree_control", "+memory"))

		goto cleanup;



	if (cg_write(child, "memory.max", "50M"))

		goto cleanup;



	if (cg_write(child, "memory.swap.max", "0"))

		goto cleanup;



	if (cg_write(child, "memory.oom.group", "1"))

		goto cleanup;



	cg_run_nowait(parent, alloc_anon_noexit, (void *) MB(60));

	cg_run_nowait(child, alloc_anon_noexit, (void *) MB(1));

	cg_run_nowait(child, alloc_anon_noexit, (void *) MB(1));

	if (!cg_run(child, alloc_anon, (void *)MB(100)))

		goto cleanup;



	if (cg_test_proc_killed(child))

		goto cleanup;



	if (cg_read_key_long(child, "memory.events", "oom_kill ") <= 0)

		goto cleanup;



	if (cg_read_key_long(parent, "memory.events", "oom_kill ") != 0)

		goto cleanup;



	ret = KSFT_PASS;



cleanup:

	if (child)

		cg_destroy(child);

	if (parent)

		cg_destroy(parent);

	free(child);

	free(parent);



	return ret;

}



/*

 * This test disables swapping and tries to allocate anonymous memory

 * up to OOM with memory.group.oom set. Then it checks that all

 * processes in the parent and leaf were killed.

 */

static int test_memcg_oom_group_parent_events(const char *root)

{

	int ret = KSFT_FAIL;

	char *parent, *child;



	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_create(child))

		goto cleanup;



	if (cg_write(parent, "memory.max", "80M"))

		goto cleanup;



	if (cg_write(parent, "memory.swap.max", "0"))

		goto cleanup;



	if (cg_write(parent, "memory.oom.group", "1"))

		goto cleanup;



	cg_run_nowait(parent, alloc_anon_noexit, (void *) MB(60));

	cg_run_nowait(child, alloc_anon_noexit, (void *) MB(1));

	cg_run_nowait(child, alloc_anon_noexit, (void *) MB(1));



	if (!cg_run(child, alloc_anon, (void *)MB(100)))

		goto cleanup;



	if (cg_test_proc_killed(child))

		goto cleanup;

	if (cg_test_proc_killed(parent))

		goto cleanup;



	ret = KSFT_PASS;



cleanup:

	if (child)

		cg_destroy(child);

	if (parent)

		cg_destroy(parent);

	free(child);

	free(parent);



	return ret;

}



/*

 * This test disables swapping and tries to allocate anonymous memory

 * up to OOM with memory.group.oom set. Then it checks that all

 * processes were killed except those set with OOM_SCORE_ADJ_MIN

 */

static int test_memcg_oom_group_score_events(const char *root)

{

	int ret = KSFT_FAIL;

	char *memcg;

	int safe_pid;



	memcg = cg_name(root, "memcg_test_0");



	if (!memcg)

		goto cleanup;



	if (cg_create(memcg))

		goto cleanup;



	if (cg_write(memcg, "memory.max", "50M"))

		goto cleanup;



	if (cg_write(memcg, "memory.swap.max", "0"))

		goto cleanup;



	if (cg_write(memcg, "memory.oom.group", "1"))

		goto cleanup;



	safe_pid = cg_run_nowait(memcg, alloc_anon_noexit, (void *) MB(1));

	if (set_oom_adj_score(safe_pid, OOM_SCORE_ADJ_MIN))

		goto cleanup;



	cg_run_nowait(memcg, alloc_anon_noexit, (void *) MB(1));

	if (!cg_run(memcg, alloc_anon, (void *)MB(100)))

		goto cleanup;



	if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 3)

		goto cleanup;



	if (kill(safe_pid, SIGKILL))

		goto cleanup;



	ret = KSFT_PASS;



cleanup:

	if (memcg)

		cg_destroy(memcg);

	free(memcg);



	return ret;

}





#define T(x) { x, #x }

struct memcg_test {

	int (*fn)(const char *root);
@@ -978,6 +1180,9 @@ struct memcg_test { 
	T(test_memcg_oom_events),

	T(test_memcg_swap_max),

	T(test_memcg_sock),

	T(test_memcg_oom_group_leaf_events),

	T(test_memcg_oom_group_parent_events),

	T(test_memcg_oom_group_score_events),

};

#undef T