1 /* SPDX-License-Identifier: GPL-2.0 */
2 
3 #include <linux/limits.h>
4 #include <sys/types.h>
5 #include <unistd.h>
6 #include <stdio.h>
7 #include <errno.h>
8 
9 #include "../kselftest.h"
10 #include "cgroup_util.h"
11 
12 /*
13  * A(0) - B(0) - C(1)
14  *        \ D(0)
15  *
16  * A, B and C's "populated" fields would be 1 while D's 0.
17  * test that after the one process in C is moved to root,
18  * A,B and C's "populated" fields would flip to "0" and file
19  * modified events will be generated on the
20  * "cgroup.events" files of both cgroups.
21  */
22 static int test_cgcore_populated(const char *root)
23 {
24 	int ret = KSFT_FAIL;
25 	char *cg_test_a = NULL, *cg_test_b = NULL;
26 	char *cg_test_c = NULL, *cg_test_d = NULL;
27 
28 	cg_test_a = cg_name(root, "cg_test_a");
29 	cg_test_b = cg_name(root, "cg_test_a/cg_test_b");
30 	cg_test_c = cg_name(root, "cg_test_a/cg_test_b/cg_test_c");
31 	cg_test_d = cg_name(root, "cg_test_a/cg_test_b/cg_test_d");
32 
33 	if (!cg_test_a || !cg_test_b || !cg_test_c || !cg_test_d)
34 		goto cleanup;
35 
36 	if (cg_create(cg_test_a))
37 		goto cleanup;
38 
39 	if (cg_create(cg_test_b))
40 		goto cleanup;
41 
42 	if (cg_create(cg_test_c))
43 		goto cleanup;
44 
45 	if (cg_create(cg_test_d))
46 		goto cleanup;
47 
48 	if (cg_enter_current(cg_test_c))
49 		goto cleanup;
50 
51 	if (cg_read_strcmp(cg_test_a, "cgroup.events", "populated 1\n"))
52 		goto cleanup;
53 
54 	if (cg_read_strcmp(cg_test_b, "cgroup.events", "populated 1\n"))
55 		goto cleanup;
56 
57 	if (cg_read_strcmp(cg_test_c, "cgroup.events", "populated 1\n"))
58 		goto cleanup;
59 
60 	if (cg_read_strcmp(cg_test_d, "cgroup.events", "populated 0\n"))
61 		goto cleanup;
62 
63 	if (cg_enter_current(root))
64 		goto cleanup;
65 
66 	if (cg_read_strcmp(cg_test_a, "cgroup.events", "populated 0\n"))
67 		goto cleanup;
68 
69 	if (cg_read_strcmp(cg_test_b, "cgroup.events", "populated 0\n"))
70 		goto cleanup;
71 
72 	if (cg_read_strcmp(cg_test_c, "cgroup.events", "populated 0\n"))
73 		goto cleanup;
74 
75 	if (cg_read_strcmp(cg_test_d, "cgroup.events", "populated 0\n"))
76 		goto cleanup;
77 
78 	ret = KSFT_PASS;
79 
80 cleanup:
81 	if (cg_test_d)
82 		cg_destroy(cg_test_d);
83 	if (cg_test_c)
84 		cg_destroy(cg_test_c);
85 	if (cg_test_b)
86 		cg_destroy(cg_test_b);
87 	if (cg_test_a)
88 		cg_destroy(cg_test_a);
89 	free(cg_test_d);
90 	free(cg_test_c);
91 	free(cg_test_b);
92 	free(cg_test_a);
93 	return ret;
94 }
95 
96 /*
97  * A (domain threaded) - B (threaded) - C (domain)
98  *
99  * test that C can't be used until it is turned into a
100  * threaded cgroup.  "cgroup.type" file will report "domain (invalid)" in
101  * these cases. Operations which fail due to invalid topology use
102  * EOPNOTSUPP as the errno.
103  */
104 static int test_cgcore_invalid_domain(const char *root)
105 {
106 	int ret = KSFT_FAIL;
107 	char *grandparent = NULL, *parent = NULL, *child = NULL;
108 
109 	grandparent = cg_name(root, "cg_test_grandparent");
110 	parent = cg_name(root, "cg_test_grandparent/cg_test_parent");
111 	child = cg_name(root, "cg_test_grandparent/cg_test_parent/cg_test_child");
112 	if (!parent || !child || !grandparent)
113 		goto cleanup;
114 
115 	if (cg_create(grandparent))
116 		goto cleanup;
117 
118 	if (cg_create(parent))
119 		goto cleanup;
120 
121 	if (cg_create(child))
122 		goto cleanup;
123 
124 	if (cg_write(parent, "cgroup.type", "threaded"))
125 		goto cleanup;
126 
127 	if (cg_read_strcmp(child, "cgroup.type", "domain invalid\n"))
128 		goto cleanup;
129 
130 	if (!cg_enter_current(child))
131 		goto cleanup;
132 
133 	if (errno != EOPNOTSUPP)
134 		goto cleanup;
135 
136 	ret = KSFT_PASS;
137 
138 cleanup:
139 	cg_enter_current(root);
140 	if (child)
141 		cg_destroy(child);
142 	if (parent)
143 		cg_destroy(parent);
144 	if (grandparent)
145 		cg_destroy(grandparent);
146 	free(child);
147 	free(parent);
148 	free(grandparent);
149 	return ret;
150 }
151 
152 /*
153  * Test that when a child becomes threaded
154  * the parent type becomes domain threaded.
155  */
156 static int test_cgcore_parent_becomes_threaded(const char *root)
157 {
158 	int ret = KSFT_FAIL;
159 	char *parent = NULL, *child = NULL;
160 
161 	parent = cg_name(root, "cg_test_parent");
162 	child = cg_name(root, "cg_test_parent/cg_test_child");
163 	if (!parent || !child)
164 		goto cleanup;
165 
166 	if (cg_create(parent))
167 		goto cleanup;
168 
169 	if (cg_create(child))
170 		goto cleanup;
171 
172 	if (cg_write(child, "cgroup.type", "threaded"))
173 		goto cleanup;
174 
175 	if (cg_read_strcmp(parent, "cgroup.type", "domain threaded\n"))
176 		goto cleanup;
177 
178 	ret = KSFT_PASS;
179 
180 cleanup:
181 	if (child)
182 		cg_destroy(child);
183 	if (parent)
184 		cg_destroy(parent);
185 	free(child);
186 	free(parent);
187 	return ret;
188 
189 }
190 
191 /*
192  * Test that there's no internal process constrain on threaded cgroups.
193  * You can add threads/processes on a parent with a controller enabled.
194  */
195 static int test_cgcore_no_internal_process_constraint_on_threads(const char *root)
196 {
197 	int ret = KSFT_FAIL;
198 	char *parent = NULL, *child = NULL;
199 
200 	if (cg_read_strstr(root, "cgroup.controllers", "cpu") ||
201 	    cg_write(root, "cgroup.subtree_control", "+cpu")) {
202 		ret = KSFT_SKIP;
203 		goto cleanup;
204 	}
205 
206 	parent = cg_name(root, "cg_test_parent");
207 	child = cg_name(root, "cg_test_parent/cg_test_child");
208 	if (!parent || !child)
209 		goto cleanup;
210 
211 	if (cg_create(parent))
212 		goto cleanup;
213 
214 	if (cg_create(child))
215 		goto cleanup;
216 
217 	if (cg_write(parent, "cgroup.type", "threaded"))
218 		goto cleanup;
219 
220 	if (cg_write(child, "cgroup.type", "threaded"))
221 		goto cleanup;
222 
223 	if (cg_write(parent, "cgroup.subtree_control", "+cpu"))
224 		goto cleanup;
225 
226 	if (cg_enter_current(parent))
227 		goto cleanup;
228 
229 	ret = KSFT_PASS;
230 
231 cleanup:
232 	cg_enter_current(root);
233 	cg_enter_current(root);
234 	if (child)
235 		cg_destroy(child);
236 	if (parent)
237 		cg_destroy(parent);
238 	free(child);
239 	free(parent);
240 	return ret;
241 }
242 
243 /*
244  * Test that you can't enable a controller on a child if it's not enabled
245  * on the parent.
246  */
247 static int test_cgcore_top_down_constraint_enable(const char *root)
248 {
249 	int ret = KSFT_FAIL;
250 	char *parent = NULL, *child = NULL;
251 
252 	parent = cg_name(root, "cg_test_parent");
253 	child = cg_name(root, "cg_test_parent/cg_test_child");
254 	if (!parent || !child)
255 		goto cleanup;
256 
257 	if (cg_create(parent))
258 		goto cleanup;
259 
260 	if (cg_create(child))
261 		goto cleanup;
262 
263 	if (!cg_write(child, "cgroup.subtree_control", "+memory"))
264 		goto cleanup;
265 
266 	ret = KSFT_PASS;
267 
268 cleanup:
269 	if (child)
270 		cg_destroy(child);
271 	if (parent)
272 		cg_destroy(parent);
273 	free(child);
274 	free(parent);
275 	return ret;
276 }
277 
278 /*
279  * Test that you can't disable a controller on a parent
280  * if it's enabled in a child.
281  */
282 static int test_cgcore_top_down_constraint_disable(const char *root)
283 {
284 	int ret = KSFT_FAIL;
285 	char *parent = NULL, *child = NULL;
286 
287 	parent = cg_name(root, "cg_test_parent");
288 	child = cg_name(root, "cg_test_parent/cg_test_child");
289 	if (!parent || !child)
290 		goto cleanup;
291 
292 	if (cg_create(parent))
293 		goto cleanup;
294 
295 	if (cg_create(child))
296 		goto cleanup;
297 
298 	if (cg_write(parent, "cgroup.subtree_control", "+memory"))
299 		goto cleanup;
300 
301 	if (cg_write(child, "cgroup.subtree_control", "+memory"))
302 		goto cleanup;
303 
304 	if (!cg_write(parent, "cgroup.subtree_control", "-memory"))
305 		goto cleanup;
306 
307 	ret = KSFT_PASS;
308 
309 cleanup:
310 	if (child)
311 		cg_destroy(child);
312 	if (parent)
313 		cg_destroy(parent);
314 	free(child);
315 	free(parent);
316 	return ret;
317 }
318 
319 /*
320  * Test internal process constraint.
321  * You can't add a pid to a domain parent if a controller is enabled.
322  */
323 static int test_cgcore_internal_process_constraint(const char *root)
324 {
325 	int ret = KSFT_FAIL;
326 	char *parent = NULL, *child = NULL;
327 
328 	parent = cg_name(root, "cg_test_parent");
329 	child = cg_name(root, "cg_test_parent/cg_test_child");
330 	if (!parent || !child)
331 		goto cleanup;
332 
333 	if (cg_create(parent))
334 		goto cleanup;
335 
336 	if (cg_create(child))
337 		goto cleanup;
338 
339 	if (cg_write(parent, "cgroup.subtree_control", "+memory"))
340 		goto cleanup;
341 
342 	if (!cg_enter_current(parent))
343 		goto cleanup;
344 
345 	ret = KSFT_PASS;
346 
347 cleanup:
348 	if (child)
349 		cg_destroy(child);
350 	if (parent)
351 		cg_destroy(parent);
352 	free(child);
353 	free(parent);
354 	return ret;
355 }
356 
357 #define T(x) { x, #x }
358 struct corecg_test {
359 	int (*fn)(const char *root);
360 	const char *name;
361 } tests[] = {
362 	T(test_cgcore_internal_process_constraint),
363 	T(test_cgcore_top_down_constraint_enable),
364 	T(test_cgcore_top_down_constraint_disable),
365 	T(test_cgcore_no_internal_process_constraint_on_threads),
366 	T(test_cgcore_parent_becomes_threaded),
367 	T(test_cgcore_invalid_domain),
368 	T(test_cgcore_populated),
369 };
370 #undef T
371 
372 int main(int argc, char *argv[])
373 {
374 	char root[PATH_MAX];
375 	int i, ret = EXIT_SUCCESS;
376 
377 	if (cg_find_unified_root(root, sizeof(root)))
378 		ksft_exit_skip("cgroup v2 isn't mounted\n");
379 
380 	if (cg_read_strstr(root, "cgroup.subtree_control", "memory"))
381 		if (cg_write(root, "cgroup.subtree_control", "+memory"))
382 			ksft_exit_skip("Failed to set memory controller\n");
383 
384 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
385 		switch (tests[i].fn(root)) {
386 		case KSFT_PASS:
387 			ksft_test_result_pass("%s\n", tests[i].name);
388 			break;
389 		case KSFT_SKIP:
390 			ksft_test_result_skip("%s\n", tests[i].name);
391 			break;
392 		default:
393 			ret = EXIT_FAILURE;
394 			ksft_test_result_fail("%s\n", tests[i].name);
395 			break;
396 		}
397 	}
398 
399 	return ret;
400 }
401