1/* SPDX-License-Identifier: GPL-2.0 */
2
3#include <errno.h>
4#include <linux/limits.h>
5#include <stdbool.h>
6#include <stdio.h>
7#include <stdlib.h>
8#include <string.h>
9#include <sys/types.h>
10#include <unistd.h>
11
12#include "../kselftest.h"
13#include "../pidfd/pidfd.h"
14#include "cgroup_util.h"
15
16/*
17 * Kill the given cgroup and wait for the inotify signal.
18 * If there are no events in 10 seconds, treat this as an error.
19 * Then check that the cgroup is in the desired state.
20 */
21static int cg_kill_wait(const char *cgroup)
22{
23	int fd, ret = -1;
24
25	fd = cg_prepare_for_wait(cgroup);
26	if (fd < 0)
27		return fd;
28
29	ret = cg_write(cgroup, "cgroup.kill", "1");
30	if (ret)
31		goto out;
32
33	ret = cg_wait_for(fd);
34	if (ret)
35		goto out;
36
37out:
38	close(fd);
39	return ret;
40}
41
42/*
43 * A simple process running in a sleep loop until being
44 * re-parented.
45 */
46static int child_fn(const char *cgroup, void *arg)
47{
48	int ppid = getppid();
49
50	while (getppid() == ppid)
51		usleep(1000);
52
53	return getppid() == ppid;
54}
55
56static int test_cgkill_simple(const char *root)
57{
58	pid_t pids[100];
59	int ret = KSFT_FAIL;
60	char *cgroup = NULL;
61	int i;
62
63	cgroup = cg_name(root, "cg_test_simple");
64	if (!cgroup)
65		goto cleanup;
66
67	if (cg_create(cgroup))
68		goto cleanup;
69
70	for (i = 0; i < 100; i++)
71		pids[i] = cg_run_nowait(cgroup, child_fn, NULL);
72
73	if (cg_wait_for_proc_count(cgroup, 100))
74		goto cleanup;
75
76	if (cg_read_strcmp(cgroup, "cgroup.events", "populated 1\n"))
77		goto cleanup;
78
79	if (cg_kill_wait(cgroup))
80		goto cleanup;
81
82	ret = KSFT_PASS;
83
84cleanup:
85	for (i = 0; i < 100; i++)
86		wait_for_pid(pids[i]);
87
88	if (ret == KSFT_PASS &&
89	    cg_read_strcmp(cgroup, "cgroup.events", "populated 0\n"))
90		ret = KSFT_FAIL;
91
92	if (cgroup)
93		cg_destroy(cgroup);
94	free(cgroup);
95	return ret;
96}
97
98/*
99 * The test creates the following hierarchy:
100 *       A
101 *    / / \ \
102 *   B  E  I K
103 *  /\  |
104 * C  D F
105 *      |
106 *      G
107 *      |
108 *      H
109 *
110 * with a process in C, H and 3 processes in K.
111 * Then it tries to kill the whole tree.
112 */
113static int test_cgkill_tree(const char *root)
114{
115	pid_t pids[5];
116	char *cgroup[10] = {0};
117	int ret = KSFT_FAIL;
118	int i;
119
120	cgroup[0] = cg_name(root, "cg_test_tree_A");
121	if (!cgroup[0])
122		goto cleanup;
123
124	cgroup[1] = cg_name(cgroup[0], "B");
125	if (!cgroup[1])
126		goto cleanup;
127
128	cgroup[2] = cg_name(cgroup[1], "C");
129	if (!cgroup[2])
130		goto cleanup;
131
132	cgroup[3] = cg_name(cgroup[1], "D");
133	if (!cgroup[3])
134		goto cleanup;
135
136	cgroup[4] = cg_name(cgroup[0], "E");
137	if (!cgroup[4])
138		goto cleanup;
139
140	cgroup[5] = cg_name(cgroup[4], "F");
141	if (!cgroup[5])
142		goto cleanup;
143
144	cgroup[6] = cg_name(cgroup[5], "G");
145	if (!cgroup[6])
146		goto cleanup;
147
148	cgroup[7] = cg_name(cgroup[6], "H");
149	if (!cgroup[7])
150		goto cleanup;
151
152	cgroup[8] = cg_name(cgroup[0], "I");
153	if (!cgroup[8])
154		goto cleanup;
155
156	cgroup[9] = cg_name(cgroup[0], "K");
157	if (!cgroup[9])
158		goto cleanup;
159
160	for (i = 0; i < 10; i++)
161		if (cg_create(cgroup[i]))
162			goto cleanup;
163
164	pids[0] = cg_run_nowait(cgroup[2], child_fn, NULL);
165	pids[1] = cg_run_nowait(cgroup[7], child_fn, NULL);
166	pids[2] = cg_run_nowait(cgroup[9], child_fn, NULL);
167	pids[3] = cg_run_nowait(cgroup[9], child_fn, NULL);
168	pids[4] = cg_run_nowait(cgroup[9], child_fn, NULL);
169
170	/*
171	 * Wait until all child processes will enter
172	 * corresponding cgroups.
173	 */
174
175	if (cg_wait_for_proc_count(cgroup[2], 1) ||
176	    cg_wait_for_proc_count(cgroup[7], 1) ||
177	    cg_wait_for_proc_count(cgroup[9], 3))
178		goto cleanup;
179
180	/*
181	 * Kill A and check that we get an empty notification.
182	 */
183	if (cg_kill_wait(cgroup[0]))
184		goto cleanup;
185
186	ret = KSFT_PASS;
187
188cleanup:
189	for (i = 0; i < 5; i++)
190		wait_for_pid(pids[i]);
191
192	if (ret == KSFT_PASS &&
193	    cg_read_strcmp(cgroup[0], "cgroup.events", "populated 0\n"))
194		ret = KSFT_FAIL;
195
196	for (i = 9; i >= 0 && cgroup[i]; i--) {
197		cg_destroy(cgroup[i]);
198		free(cgroup[i]);
199	}
200
201	return ret;
202}
203
204static int forkbomb_fn(const char *cgroup, void *arg)
205{
206	int ppid;
207
208	fork();
209	fork();
210
211	ppid = getppid();
212
213	while (getppid() == ppid)
214		usleep(1000);
215
216	return getppid() == ppid;
217}
218
219/*
220 * The test runs a fork bomb in a cgroup and tries to kill it.
221 */
222static int test_cgkill_forkbomb(const char *root)
223{
224	int ret = KSFT_FAIL;
225	char *cgroup = NULL;
226	pid_t pid = -ESRCH;
227
228	cgroup = cg_name(root, "cg_forkbomb_test");
229	if (!cgroup)
230		goto cleanup;
231
232	if (cg_create(cgroup))
233		goto cleanup;
234
235	pid = cg_run_nowait(cgroup, forkbomb_fn, NULL);
236	if (pid < 0)
237		goto cleanup;
238
239	usleep(100000);
240
241	if (cg_kill_wait(cgroup))
242		goto cleanup;
243
244	if (cg_wait_for_proc_count(cgroup, 0))
245		goto cleanup;
246
247	ret = KSFT_PASS;
248
249cleanup:
250	if (pid > 0)
251		wait_for_pid(pid);
252
253	if (ret == KSFT_PASS &&
254	    cg_read_strcmp(cgroup, "cgroup.events", "populated 0\n"))
255		ret = KSFT_FAIL;
256
257	if (cgroup)
258		cg_destroy(cgroup);
259	free(cgroup);
260	return ret;
261}
262
263#define T(x) { x, #x }
264struct cgkill_test {
265	int (*fn)(const char *root);
266	const char *name;
267} tests[] = {
268	T(test_cgkill_simple),
269	T(test_cgkill_tree),
270	T(test_cgkill_forkbomb),
271};
272#undef T
273
274int main(int argc, char *argv[])
275{
276	char root[PATH_MAX];
277	int i, ret = EXIT_SUCCESS;
278
279	if (cg_find_unified_root(root, sizeof(root)))
280		ksft_exit_skip("cgroup v2 isn't mounted\n");
281	for (i = 0; i < ARRAY_SIZE(tests); i++) {
282		switch (tests[i].fn(root)) {
283		case KSFT_PASS:
284			ksft_test_result_pass("%s\n", tests[i].name);
285			break;
286		case KSFT_SKIP:
287			ksft_test_result_skip("%s\n", tests[i].name);
288			break;
289		default:
290			ret = EXIT_FAILURE;
291			ksft_test_result_fail("%s\n", tests[i].name);
292			break;
293		}
294	}
295
296	return ret;
297}
298