Lines Matching defs:cgroup
27 * Check if the cgroup is frozen by looking at the cgroup.events::frozen value.
29 static int cg_check_frozen(const char *cgroup, bool frozen)
32 if (cg_read_strstr(cgroup, "cgroup.events", "frozen 1") != 0) {
33 debug("Cgroup %s isn't frozen\n", cgroup);
38 * Check the cgroup.events::frozen value.
40 if (cg_read_strstr(cgroup, "cgroup.events", "frozen 0") != 0) {
41 debug("Cgroup %s is frozen\n", cgroup);
50 * Freeze the given cgroup.
52 static int cg_freeze_nowait(const char *cgroup, bool freeze)
54 return cg_write(cgroup, "cgroup.freeze", freeze ? "1" : "0");
58 * Prepare for waiting on cgroup.events file.
60 static int cg_prepare_for_wait(const char *cgroup)
70 ret = inotify_add_watch(fd, cg_control(cgroup, "cgroup.events"),
113 * Attach a task to the given cgroup and wait for a cgroup frozen event.
116 static int cg_enter_and_wait_for_frozen(const char *cgroup, int pid,
122 fd = cg_prepare_for_wait(cgroup);
126 ret = cg_enter(cgroup, pid);
135 ret = cg_check_frozen(cgroup, frozen);
146 * Freeze the given cgroup and wait for the inotify signal.
148 * Then check that the cgroup is in the desired state.
150 static int cg_freeze_wait(const char *cgroup, bool freeze)
154 fd = cg_prepare_for_wait(cgroup);
158 ret = cg_freeze_nowait(cgroup, freeze);
168 ret = cg_check_frozen(cgroup, freeze);
178 static int child_fn(const char *cgroup, void *arg)
189 * A simple test for the cgroup freezer: populated the cgroup with 100
191 * processes and destroys the cgroup.
196 char *cgroup = NULL;
199 cgroup = cg_name(root, "cg_test_simple");
200 if (!cgroup)
203 if (cg_create(cgroup))
207 cg_run_nowait(cgroup, child_fn, NULL);
209 if (cg_wait_for_proc_count(cgroup, 100))
212 if (cg_check_frozen(cgroup, false))
215 if (cg_freeze_wait(cgroup, true))
218 if (cg_freeze_wait(cgroup, false))
224 if (cgroup)
225 cg_destroy(cgroup);
226 free(cgroup);
247 char *cgroup[10] = {0};
251 cgroup[0] = cg_name(root, "cg_test_tree_A");
252 if (!cgroup[0])
255 cgroup[1] = cg_name(cgroup[0], "B");
256 if (!cgroup[1])
259 cgroup[2] = cg_name(cgroup[1], "C");
260 if (!cgroup[2])
263 cgroup[3] = cg_name(cgroup[1], "D");
264 if (!cgroup[3])
267 cgroup[4] = cg_name(cgroup[0], "E");
268 if (!cgroup[4])
271 cgroup[5] = cg_name(cgroup[4], "F");
272 if (!cgroup[5])
275 cgroup[6] = cg_name(cgroup[5], "G");
276 if (!cgroup[6])
279 cgroup[7] = cg_name(cgroup[6], "H");
280 if (!cgroup[7])
283 cgroup[8] = cg_name(cgroup[0], "I");
284 if (!cgroup[8])
287 cgroup[9] = cg_name(cgroup[0], "K");
288 if (!cgroup[9])
292 if (cg_create(cgroup[i]))
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);
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))
314 if (cg_freeze_wait(cgroup[1], true))
320 if (cg_freeze_wait(cgroup[5], true))
326 if (cg_freeze_wait(cgroup[6], true))
332 if (cg_check_frozen(cgroup[0], false))
335 if (cg_check_frozen(cgroup[4], false))
341 if (cg_freeze_wait(cgroup[0], true))
344 if (cg_check_frozen(cgroup[1], true))
347 if (cg_check_frozen(cgroup[4], true))
353 if (cg_freeze_nowait(cgroup[1], false))
356 if (cg_freeze_nowait(cgroup[5], false))
359 if (cg_freeze_nowait(cgroup[6], false))
365 if (cg_check_frozen(cgroup[2], true))
368 if (cg_check_frozen(cgroup[7], true))
374 if (cg_freeze_wait(cgroup[0], false))
377 if (cg_check_frozen(cgroup[2], false))
380 if (cg_check_frozen(cgroup[9], false))
386 for (i = 9; i >= 0 && cgroup[i]; i--) {
387 cg_destroy(cgroup[i]);
388 free(cgroup[i]);
397 static int forkbomb_fn(const char *cgroup, void *arg)
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
420 char *cgroup = NULL;
422 cgroup = cg_name(root, "cg_forkbomb_test");
423 if (!cgroup)
426 if (cg_create(cgroup))
429 cg_run_nowait(cgroup, forkbomb_fn, NULL);
433 if (cg_freeze_wait(cgroup, true))
436 if (cg_killall(cgroup))
439 if (cg_wait_for_proc_count(cgroup, 0))
445 if (cgroup)
446 cg_destroy(cgroup);
447 free(cgroup);
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.
506 * and removes the child. Then it checks that the parent cgroup
568 char *cgroup[2] = {0};
571 cgroup[0] = cg_name(root, "cg_test_migrate_A");
572 if (!cgroup[0])
575 cgroup[1] = cg_name(root, "cg_test_migrate_B");
576 if (!cgroup[1])
579 if (cg_create(cgroup[0]))
582 if (cg_create(cgroup[1]))
585 pid = cg_run_nowait(cgroup[0], child_fn, NULL);
589 if (cg_wait_for_proc_count(cgroup[0], 1))
595 if (cg_freeze_wait(cgroup[1], true))
598 if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
601 if (cg_check_frozen(cgroup[0], false))
607 if (cg_enter_and_wait_for_frozen(cgroup[0], pid, false))
610 if (cg_check_frozen(cgroup[1], true))
616 if (cg_freeze_wait(cgroup[0], true))
619 if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
622 if (cg_check_frozen(cgroup[0], true))
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]);
638 * The test checks that ptrace works with a tracing process in a frozen cgroup.
643 char *cgroup = NULL;
647 cgroup = cg_name(root, "cg_test_ptrace");
648 if (!cgroup)
651 if (cg_create(cgroup))
654 pid = cg_run_nowait(cgroup, child_fn, NULL);
658 if (cg_wait_for_proc_count(cgroup, 1))
661 if (cg_freeze_wait(cgroup, true))
676 if (cg_check_frozen(cgroup, true))
685 if (cg_check_frozen(cgroup, true))
691 if (cgroup)
692 cg_destroy(cgroup);
693 free(cgroup);
720 * Test that it's possible to freeze a cgroup with a stopped process.
725 char *cgroup = NULL;
727 cgroup = cg_name(root, "cg_test_stopped");
728 if (!cgroup)
731 if (cg_create(cgroup))
734 pid = cg_run_nowait(cgroup, child_fn, NULL);
736 if (cg_wait_for_proc_count(cgroup, 1))
742 if (cg_check_frozen(cgroup, false))
745 if (cg_freeze_wait(cgroup, true))
748 if (cg_freeze_wait(cgroup, false))
757 if (cgroup)
758 cg_destroy(cgroup);
759 free(cgroup);
764 * Test that it's possible to freeze a cgroup with a ptraced process.
769 char *cgroup = NULL;
772 cgroup = cg_name(root, "cg_test_ptraced");
773 if (!cgroup)
776 if (cg_create(cgroup))
779 pid = cg_run_nowait(cgroup, child_fn, NULL);
781 if (cg_wait_for_proc_count(cgroup, 1))
792 if (cg_check_frozen(cgroup, false))
795 if (cg_freeze_wait(cgroup, true))
799 * cg_check_frozen(cgroup, true) will fail here,
802 if (cg_freeze_wait(cgroup, false))
814 if (cgroup)
815 cg_destroy(cgroup);
816 free(cgroup);
820 static int vfork_fn(const char *cgroup, void *arg)
832 * Test that it's possible to freeze a cgroup with a process,
838 char *cgroup = NULL;
840 cgroup = cg_name(root, "cg_test_vfork");
841 if (!cgroup)
844 if (cg_create(cgroup))
847 cg_run_nowait(cgroup, vfork_fn, NULL);
849 if (cg_wait_for_proc_count(cgroup, 2))
852 if (cg_freeze_wait(cgroup, true))
858 if (cgroup)
859 cg_destroy(cgroup);
860 free(cgroup);
888 ksft_exit_skip("cgroup v2 isn't mounted\n");