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