1 /* SPDX-License-Identifier: GPL-2.0 */
2 #include <stdbool.h>
3 #include <linux/limits.h>
4 #include <sys/ptrace.h>
5 #include <sys/types.h>
6 #include <sys/mman.h>
7 #include <unistd.h>
8 #include <stdio.h>
9 #include <errno.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <sys/wait.h>
13 
14 #include "../kselftest.h"
15 #include "cgroup_util.h"
16 
17 #define DEBUG
18 #ifdef DEBUG
19 #define debug(args...) fprintf(stderr, args)
20 #else
21 #define debug(args...)
22 #endif
23 
24 /*
25  * Check if the cgroup is frozen by looking at the cgroup.events::frozen value.
26  */
cg_check_frozen(const char * cgroup,bool frozen)27 static int cg_check_frozen(const char *cgroup, bool frozen)
28 {
29 	if (frozen) {
30 		if (cg_read_strstr(cgroup, "cgroup.events", "frozen 1") != 0) {
31 			debug("Cgroup %s isn't frozen\n", cgroup);
32 			return -1;
33 		}
34 	} else {
35 		/*
36 		 * Check the cgroup.events::frozen value.
37 		 */
38 		if (cg_read_strstr(cgroup, "cgroup.events", "frozen 0") != 0) {
39 			debug("Cgroup %s is frozen\n", cgroup);
40 			return -1;
41 		}
42 	}
43 
44 	return 0;
45 }
46 
47 /*
48  * Freeze the given cgroup.
49  */
cg_freeze_nowait(const char * cgroup,bool freeze)50 static int cg_freeze_nowait(const char *cgroup, bool freeze)
51 {
52 	return cg_write(cgroup, "cgroup.freeze", freeze ? "1" : "0");
53 }
54 
55 /*
56  * Attach a task to the given cgroup and wait for a cgroup frozen event.
57  * All transient events (e.g. populated) are ignored.
58  */
cg_enter_and_wait_for_frozen(const char * cgroup,int pid,bool frozen)59 static int cg_enter_and_wait_for_frozen(const char *cgroup, int pid,
60 					bool frozen)
61 {
62 	int fd, ret = -1;
63 	int attempts;
64 
65 	fd = cg_prepare_for_wait(cgroup);
66 	if (fd < 0)
67 		return fd;
68 
69 	ret = cg_enter(cgroup, pid);
70 	if (ret)
71 		goto out;
72 
73 	for (attempts = 0; attempts < 10; attempts++) {
74 		ret = cg_wait_for(fd);
75 		if (ret)
76 			break;
77 
78 		ret = cg_check_frozen(cgroup, frozen);
79 		if (ret)
80 			continue;
81 	}
82 
83 out:
84 	close(fd);
85 	return ret;
86 }
87 
88 /*
89  * Freeze the given cgroup and wait for the inotify signal.
90  * If there are no events in 10 seconds, treat this as an error.
91  * Then check that the cgroup is in the desired state.
92  */
cg_freeze_wait(const char * cgroup,bool freeze)93 static int cg_freeze_wait(const char *cgroup, bool freeze)
94 {
95 	int fd, ret = -1;
96 
97 	fd = cg_prepare_for_wait(cgroup);
98 	if (fd < 0)
99 		return fd;
100 
101 	ret = cg_freeze_nowait(cgroup, freeze);
102 	if (ret) {
103 		debug("Error: cg_freeze_nowait() failed\n");
104 		goto out;
105 	}
106 
107 	ret = cg_wait_for(fd);
108 	if (ret)
109 		goto out;
110 
111 	ret = cg_check_frozen(cgroup, freeze);
112 out:
113 	close(fd);
114 	return ret;
115 }
116 
117 /*
118  * A simple process running in a sleep loop until being
119  * re-parented.
120  */
child_fn(const char * cgroup,void * arg)121 static int child_fn(const char *cgroup, void *arg)
122 {
123 	int ppid = getppid();
124 
125 	while (getppid() == ppid)
126 		usleep(1000);
127 
128 	return getppid() == ppid;
129 }
130 
131 /*
132  * A simple test for the cgroup freezer: populated the cgroup with 100
133  * running processes and freeze it. Then unfreeze it. Then it kills all
134  * processes and destroys the cgroup.
135  */
test_cgfreezer_simple(const char * root)136 static int test_cgfreezer_simple(const char *root)
137 {
138 	int ret = KSFT_FAIL;
139 	char *cgroup = NULL;
140 	int i;
141 
142 	cgroup = cg_name(root, "cg_test_simple");
143 	if (!cgroup)
144 		goto cleanup;
145 
146 	if (cg_create(cgroup))
147 		goto cleanup;
148 
149 	for (i = 0; i < 100; i++)
150 		cg_run_nowait(cgroup, child_fn, NULL);
151 
152 	if (cg_wait_for_proc_count(cgroup, 100))
153 		goto cleanup;
154 
155 	if (cg_check_frozen(cgroup, false))
156 		goto cleanup;
157 
158 	if (cg_freeze_wait(cgroup, true))
159 		goto cleanup;
160 
161 	if (cg_freeze_wait(cgroup, false))
162 		goto cleanup;
163 
164 	ret = KSFT_PASS;
165 
166 cleanup:
167 	if (cgroup)
168 		cg_destroy(cgroup);
169 	free(cgroup);
170 	return ret;
171 }
172 
173 /*
174  * The test creates the following hierarchy:
175  *       A
176  *    / / \ \
177  *   B  E  I K
178  *  /\  |
179  * C  D F
180  *      |
181  *      G
182  *      |
183  *      H
184  *
185  * with a process in C, H and 3 processes in K.
186  * Then it tries to freeze and unfreeze the whole tree.
187  */
test_cgfreezer_tree(const char * root)188 static int test_cgfreezer_tree(const char *root)
189 {
190 	char *cgroup[10] = {0};
191 	int ret = KSFT_FAIL;
192 	int i;
193 
194 	cgroup[0] = cg_name(root, "cg_test_tree_A");
195 	if (!cgroup[0])
196 		goto cleanup;
197 
198 	cgroup[1] = cg_name(cgroup[0], "B");
199 	if (!cgroup[1])
200 		goto cleanup;
201 
202 	cgroup[2] = cg_name(cgroup[1], "C");
203 	if (!cgroup[2])
204 		goto cleanup;
205 
206 	cgroup[3] = cg_name(cgroup[1], "D");
207 	if (!cgroup[3])
208 		goto cleanup;
209 
210 	cgroup[4] = cg_name(cgroup[0], "E");
211 	if (!cgroup[4])
212 		goto cleanup;
213 
214 	cgroup[5] = cg_name(cgroup[4], "F");
215 	if (!cgroup[5])
216 		goto cleanup;
217 
218 	cgroup[6] = cg_name(cgroup[5], "G");
219 	if (!cgroup[6])
220 		goto cleanup;
221 
222 	cgroup[7] = cg_name(cgroup[6], "H");
223 	if (!cgroup[7])
224 		goto cleanup;
225 
226 	cgroup[8] = cg_name(cgroup[0], "I");
227 	if (!cgroup[8])
228 		goto cleanup;
229 
230 	cgroup[9] = cg_name(cgroup[0], "K");
231 	if (!cgroup[9])
232 		goto cleanup;
233 
234 	for (i = 0; i < 10; i++)
235 		if (cg_create(cgroup[i]))
236 			goto cleanup;
237 
238 	cg_run_nowait(cgroup[2], child_fn, NULL);
239 	cg_run_nowait(cgroup[7], child_fn, NULL);
240 	cg_run_nowait(cgroup[9], child_fn, NULL);
241 	cg_run_nowait(cgroup[9], child_fn, NULL);
242 	cg_run_nowait(cgroup[9], child_fn, NULL);
243 
244 	/*
245 	 * Wait until all child processes will enter
246 	 * corresponding cgroups.
247 	 */
248 
249 	if (cg_wait_for_proc_count(cgroup[2], 1) ||
250 	    cg_wait_for_proc_count(cgroup[7], 1) ||
251 	    cg_wait_for_proc_count(cgroup[9], 3))
252 		goto cleanup;
253 
254 	/*
255 	 * Freeze B.
256 	 */
257 	if (cg_freeze_wait(cgroup[1], true))
258 		goto cleanup;
259 
260 	/*
261 	 * Freeze F.
262 	 */
263 	if (cg_freeze_wait(cgroup[5], true))
264 		goto cleanup;
265 
266 	/*
267 	 * Freeze G.
268 	 */
269 	if (cg_freeze_wait(cgroup[6], true))
270 		goto cleanup;
271 
272 	/*
273 	 * Check that A and E are not frozen.
274 	 */
275 	if (cg_check_frozen(cgroup[0], false))
276 		goto cleanup;
277 
278 	if (cg_check_frozen(cgroup[4], false))
279 		goto cleanup;
280 
281 	/*
282 	 * Freeze A. Check that A, B and E are frozen.
283 	 */
284 	if (cg_freeze_wait(cgroup[0], true))
285 		goto cleanup;
286 
287 	if (cg_check_frozen(cgroup[1], true))
288 		goto cleanup;
289 
290 	if (cg_check_frozen(cgroup[4], true))
291 		goto cleanup;
292 
293 	/*
294 	 * Unfreeze B, F and G
295 	 */
296 	if (cg_freeze_nowait(cgroup[1], false))
297 		goto cleanup;
298 
299 	if (cg_freeze_nowait(cgroup[5], false))
300 		goto cleanup;
301 
302 	if (cg_freeze_nowait(cgroup[6], false))
303 		goto cleanup;
304 
305 	/*
306 	 * Check that C and H are still frozen.
307 	 */
308 	if (cg_check_frozen(cgroup[2], true))
309 		goto cleanup;
310 
311 	if (cg_check_frozen(cgroup[7], true))
312 		goto cleanup;
313 
314 	/*
315 	 * Unfreeze A. Check that A, C and K are not frozen.
316 	 */
317 	if (cg_freeze_wait(cgroup[0], false))
318 		goto cleanup;
319 
320 	if (cg_check_frozen(cgroup[2], false))
321 		goto cleanup;
322 
323 	if (cg_check_frozen(cgroup[9], false))
324 		goto cleanup;
325 
326 	ret = KSFT_PASS;
327 
328 cleanup:
329 	for (i = 9; i >= 0 && cgroup[i]; i--) {
330 		cg_destroy(cgroup[i]);
331 		free(cgroup[i]);
332 	}
333 
334 	return ret;
335 }
336 
337 /*
338  * A fork bomb emulator.
339  */
forkbomb_fn(const char * cgroup,void * arg)340 static int forkbomb_fn(const char *cgroup, void *arg)
341 {
342 	int ppid;
343 
344 	fork();
345 	fork();
346 
347 	ppid = getppid();
348 
349 	while (getppid() == ppid)
350 		usleep(1000);
351 
352 	return getppid() == ppid;
353 }
354 
355 /*
356  * The test runs a fork bomb in a cgroup and tries to freeze it.
357  * Then it kills all processes and checks that cgroup isn't populated
358  * anymore.
359  */
test_cgfreezer_forkbomb(const char * root)360 static int test_cgfreezer_forkbomb(const char *root)
361 {
362 	int ret = KSFT_FAIL;
363 	char *cgroup = NULL;
364 
365 	cgroup = cg_name(root, "cg_forkbomb_test");
366 	if (!cgroup)
367 		goto cleanup;
368 
369 	if (cg_create(cgroup))
370 		goto cleanup;
371 
372 	cg_run_nowait(cgroup, forkbomb_fn, NULL);
373 
374 	usleep(100000);
375 
376 	if (cg_freeze_wait(cgroup, true))
377 		goto cleanup;
378 
379 	if (cg_killall(cgroup))
380 		goto cleanup;
381 
382 	if (cg_wait_for_proc_count(cgroup, 0))
383 		goto cleanup;
384 
385 	ret = KSFT_PASS;
386 
387 cleanup:
388 	if (cgroup)
389 		cg_destroy(cgroup);
390 	free(cgroup);
391 	return ret;
392 }
393 
394 /*
395  * The test creates a cgroups and freezes it. Then it creates a child cgroup
396  * and populates it with a task. After that it checks that the child cgroup
397  * is frozen and the parent cgroup remains frozen too.
398  */
test_cgfreezer_mkdir(const char * root)399 static int test_cgfreezer_mkdir(const char *root)
400 {
401 	int ret = KSFT_FAIL;
402 	char *parent, *child = NULL;
403 	int pid;
404 
405 	parent = cg_name(root, "cg_test_mkdir_A");
406 	if (!parent)
407 		goto cleanup;
408 
409 	child = cg_name(parent, "cg_test_mkdir_B");
410 	if (!child)
411 		goto cleanup;
412 
413 	if (cg_create(parent))
414 		goto cleanup;
415 
416 	if (cg_freeze_wait(parent, true))
417 		goto cleanup;
418 
419 	if (cg_create(child))
420 		goto cleanup;
421 
422 	pid = cg_run_nowait(child, child_fn, NULL);
423 	if (pid < 0)
424 		goto cleanup;
425 
426 	if (cg_wait_for_proc_count(child, 1))
427 		goto cleanup;
428 
429 	if (cg_check_frozen(child, true))
430 		goto cleanup;
431 
432 	if (cg_check_frozen(parent, true))
433 		goto cleanup;
434 
435 	ret = KSFT_PASS;
436 
437 cleanup:
438 	if (child)
439 		cg_destroy(child);
440 	free(child);
441 	if (parent)
442 		cg_destroy(parent);
443 	free(parent);
444 	return ret;
445 }
446 
447 /*
448  * The test creates two nested cgroups, freezes the parent
449  * and removes the child. Then it checks that the parent cgroup
450  * remains frozen and it's possible to create a new child
451  * without unfreezing. The new child is frozen too.
452  */
test_cgfreezer_rmdir(const char * root)453 static int test_cgfreezer_rmdir(const char *root)
454 {
455 	int ret = KSFT_FAIL;
456 	char *parent, *child = NULL;
457 
458 	parent = cg_name(root, "cg_test_rmdir_A");
459 	if (!parent)
460 		goto cleanup;
461 
462 	child = cg_name(parent, "cg_test_rmdir_B");
463 	if (!child)
464 		goto cleanup;
465 
466 	if (cg_create(parent))
467 		goto cleanup;
468 
469 	if (cg_create(child))
470 		goto cleanup;
471 
472 	if (cg_freeze_wait(parent, true))
473 		goto cleanup;
474 
475 	if (cg_destroy(child))
476 		goto cleanup;
477 
478 	if (cg_check_frozen(parent, true))
479 		goto cleanup;
480 
481 	if (cg_create(child))
482 		goto cleanup;
483 
484 	if (cg_check_frozen(child, true))
485 		goto cleanup;
486 
487 	ret = KSFT_PASS;
488 
489 cleanup:
490 	if (child)
491 		cg_destroy(child);
492 	free(child);
493 	if (parent)
494 		cg_destroy(parent);
495 	free(parent);
496 	return ret;
497 }
498 
499 /*
500  * The test creates two cgroups: A and B, runs a process in A
501  * and performs several migrations:
502  * 1) A (running) -> B (frozen)
503  * 2) B (frozen) -> A (running)
504  * 3) A (frozen) -> B (frozen)
505  *
506  * On each step it checks the actual state of both cgroups.
507  */
test_cgfreezer_migrate(const char * root)508 static int test_cgfreezer_migrate(const char *root)
509 {
510 	int ret = KSFT_FAIL;
511 	char *cgroup[2] = {0};
512 	int pid;
513 
514 	cgroup[0] = cg_name(root, "cg_test_migrate_A");
515 	if (!cgroup[0])
516 		goto cleanup;
517 
518 	cgroup[1] = cg_name(root, "cg_test_migrate_B");
519 	if (!cgroup[1])
520 		goto cleanup;
521 
522 	if (cg_create(cgroup[0]))
523 		goto cleanup;
524 
525 	if (cg_create(cgroup[1]))
526 		goto cleanup;
527 
528 	pid = cg_run_nowait(cgroup[0], child_fn, NULL);
529 	if (pid < 0)
530 		goto cleanup;
531 
532 	if (cg_wait_for_proc_count(cgroup[0], 1))
533 		goto cleanup;
534 
535 	/*
536 	 * Migrate from A (running) to B (frozen)
537 	 */
538 	if (cg_freeze_wait(cgroup[1], true))
539 		goto cleanup;
540 
541 	if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
542 		goto cleanup;
543 
544 	if (cg_check_frozen(cgroup[0], false))
545 		goto cleanup;
546 
547 	/*
548 	 * Migrate from B (frozen) to A (running)
549 	 */
550 	if (cg_enter_and_wait_for_frozen(cgroup[0], pid, false))
551 		goto cleanup;
552 
553 	if (cg_check_frozen(cgroup[1], true))
554 		goto cleanup;
555 
556 	/*
557 	 * Migrate from A (frozen) to B (frozen)
558 	 */
559 	if (cg_freeze_wait(cgroup[0], true))
560 		goto cleanup;
561 
562 	if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
563 		goto cleanup;
564 
565 	if (cg_check_frozen(cgroup[0], true))
566 		goto cleanup;
567 
568 	ret = KSFT_PASS;
569 
570 cleanup:
571 	if (cgroup[0])
572 		cg_destroy(cgroup[0]);
573 	free(cgroup[0]);
574 	if (cgroup[1])
575 		cg_destroy(cgroup[1]);
576 	free(cgroup[1]);
577 	return ret;
578 }
579 
580 /*
581  * The test checks that ptrace works with a tracing process in a frozen cgroup.
582  */
test_cgfreezer_ptrace(const char * root)583 static int test_cgfreezer_ptrace(const char *root)
584 {
585 	int ret = KSFT_FAIL;
586 	char *cgroup = NULL;
587 	siginfo_t siginfo;
588 	int pid;
589 
590 	cgroup = cg_name(root, "cg_test_ptrace");
591 	if (!cgroup)
592 		goto cleanup;
593 
594 	if (cg_create(cgroup))
595 		goto cleanup;
596 
597 	pid = cg_run_nowait(cgroup, child_fn, NULL);
598 	if (pid < 0)
599 		goto cleanup;
600 
601 	if (cg_wait_for_proc_count(cgroup, 1))
602 		goto cleanup;
603 
604 	if (cg_freeze_wait(cgroup, true))
605 		goto cleanup;
606 
607 	if (ptrace(PTRACE_SEIZE, pid, NULL, NULL))
608 		goto cleanup;
609 
610 	if (ptrace(PTRACE_INTERRUPT, pid, NULL, NULL))
611 		goto cleanup;
612 
613 	waitpid(pid, NULL, 0);
614 
615 	/*
616 	 * Cgroup has to remain frozen, however the test task
617 	 * is in traced state.
618 	 */
619 	if (cg_check_frozen(cgroup, true))
620 		goto cleanup;
621 
622 	if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo))
623 		goto cleanup;
624 
625 	if (ptrace(PTRACE_DETACH, pid, NULL, NULL))
626 		goto cleanup;
627 
628 	if (cg_check_frozen(cgroup, true))
629 		goto cleanup;
630 
631 	ret = KSFT_PASS;
632 
633 cleanup:
634 	if (cgroup)
635 		cg_destroy(cgroup);
636 	free(cgroup);
637 	return ret;
638 }
639 
640 /*
641  * Check if the process is stopped.
642  */
proc_check_stopped(int pid)643 static int proc_check_stopped(int pid)
644 {
645 	char buf[PAGE_SIZE];
646 	int len;
647 
648 	len = proc_read_text(pid, 0, "stat", buf, sizeof(buf));
649 	if (len == -1) {
650 		debug("Can't get %d stat\n", pid);
651 		return -1;
652 	}
653 
654 	if (strstr(buf, "(test_freezer) T ") == NULL) {
655 		debug("Process %d in the unexpected state: %s\n", pid, buf);
656 		return -1;
657 	}
658 
659 	return 0;
660 }
661 
662 /*
663  * Test that it's possible to freeze a cgroup with a stopped process.
664  */
test_cgfreezer_stopped(const char * root)665 static int test_cgfreezer_stopped(const char *root)
666 {
667 	int pid, ret = KSFT_FAIL;
668 	char *cgroup = NULL;
669 
670 	cgroup = cg_name(root, "cg_test_stopped");
671 	if (!cgroup)
672 		goto cleanup;
673 
674 	if (cg_create(cgroup))
675 		goto cleanup;
676 
677 	pid = cg_run_nowait(cgroup, child_fn, NULL);
678 
679 	if (cg_wait_for_proc_count(cgroup, 1))
680 		goto cleanup;
681 
682 	if (kill(pid, SIGSTOP))
683 		goto cleanup;
684 
685 	if (cg_check_frozen(cgroup, false))
686 		goto cleanup;
687 
688 	if (cg_freeze_wait(cgroup, true))
689 		goto cleanup;
690 
691 	if (cg_freeze_wait(cgroup, false))
692 		goto cleanup;
693 
694 	if (proc_check_stopped(pid))
695 		goto cleanup;
696 
697 	ret = KSFT_PASS;
698 
699 cleanup:
700 	if (cgroup)
701 		cg_destroy(cgroup);
702 	free(cgroup);
703 	return ret;
704 }
705 
706 /*
707  * Test that it's possible to freeze a cgroup with a ptraced process.
708  */
test_cgfreezer_ptraced(const char * root)709 static int test_cgfreezer_ptraced(const char *root)
710 {
711 	int pid, ret = KSFT_FAIL;
712 	char *cgroup = NULL;
713 	siginfo_t siginfo;
714 
715 	cgroup = cg_name(root, "cg_test_ptraced");
716 	if (!cgroup)
717 		goto cleanup;
718 
719 	if (cg_create(cgroup))
720 		goto cleanup;
721 
722 	pid = cg_run_nowait(cgroup, child_fn, NULL);
723 
724 	if (cg_wait_for_proc_count(cgroup, 1))
725 		goto cleanup;
726 
727 	if (ptrace(PTRACE_SEIZE, pid, NULL, NULL))
728 		goto cleanup;
729 
730 	if (ptrace(PTRACE_INTERRUPT, pid, NULL, NULL))
731 		goto cleanup;
732 
733 	waitpid(pid, NULL, 0);
734 
735 	if (cg_check_frozen(cgroup, false))
736 		goto cleanup;
737 
738 	if (cg_freeze_wait(cgroup, true))
739 		goto cleanup;
740 
741 	/*
742 	 * cg_check_frozen(cgroup, true) will fail here,
743 	 * because the task in in the TRACEd state.
744 	 */
745 	if (cg_freeze_wait(cgroup, false))
746 		goto cleanup;
747 
748 	if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo))
749 		goto cleanup;
750 
751 	if (ptrace(PTRACE_DETACH, pid, NULL, NULL))
752 		goto cleanup;
753 
754 	ret = KSFT_PASS;
755 
756 cleanup:
757 	if (cgroup)
758 		cg_destroy(cgroup);
759 	free(cgroup);
760 	return ret;
761 }
762 
vfork_fn(const char * cgroup,void * arg)763 static int vfork_fn(const char *cgroup, void *arg)
764 {
765 	int pid = vfork();
766 
767 	if (pid == 0)
768 		while (true)
769 			sleep(1);
770 
771 	return pid;
772 }
773 
774 /*
775  * Test that it's possible to freeze a cgroup with a process,
776  * which called vfork() and is waiting for a child.
777  */
test_cgfreezer_vfork(const char * root)778 static int test_cgfreezer_vfork(const char *root)
779 {
780 	int ret = KSFT_FAIL;
781 	char *cgroup = NULL;
782 
783 	cgroup = cg_name(root, "cg_test_vfork");
784 	if (!cgroup)
785 		goto cleanup;
786 
787 	if (cg_create(cgroup))
788 		goto cleanup;
789 
790 	cg_run_nowait(cgroup, vfork_fn, NULL);
791 
792 	if (cg_wait_for_proc_count(cgroup, 2))
793 		goto cleanup;
794 
795 	if (cg_freeze_wait(cgroup, true))
796 		goto cleanup;
797 
798 	ret = KSFT_PASS;
799 
800 cleanup:
801 	if (cgroup)
802 		cg_destroy(cgroup);
803 	free(cgroup);
804 	return ret;
805 }
806 
807 #define T(x) { x, #x }
808 struct cgfreezer_test {
809 	int (*fn)(const char *root);
810 	const char *name;
811 } tests[] = {
812 	T(test_cgfreezer_simple),
813 	T(test_cgfreezer_tree),
814 	T(test_cgfreezer_forkbomb),
815 	T(test_cgfreezer_mkdir),
816 	T(test_cgfreezer_rmdir),
817 	T(test_cgfreezer_migrate),
818 	T(test_cgfreezer_ptrace),
819 	T(test_cgfreezer_stopped),
820 	T(test_cgfreezer_ptraced),
821 	T(test_cgfreezer_vfork),
822 };
823 #undef T
824 
main(int argc,char * argv[])825 int main(int argc, char *argv[])
826 {
827 	char root[PATH_MAX];
828 	int i, ret = EXIT_SUCCESS;
829 
830 	if (cg_find_unified_root(root, sizeof(root), NULL))
831 		ksft_exit_skip("cgroup v2 isn't mounted\n");
832 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
833 		switch (tests[i].fn(root)) {
834 		case KSFT_PASS:
835 			ksft_test_result_pass("%s\n", tests[i].name);
836 			break;
837 		case KSFT_SKIP:
838 			ksft_test_result_skip("%s\n", tests[i].name);
839 			break;
840 		default:
841 			ret = EXIT_FAILURE;
842 			ksft_test_result_fail("%s\n", tests[i].name);
843 			break;
844 		}
845 	}
846 
847 	return ret;
848 }
849