Lines Matching defs:cgroup
25 * Check if the cgroup is frozen by looking at the cgroup.events::frozen value.
27 static int cg_check_frozen(const char *cgroup, bool frozen)
30 if (cg_read_strstr(cgroup, "cgroup.events", "frozen 1") != 0) {
31 debug("Cgroup %s isn't frozen\n", cgroup);
36 * Check the cgroup.events::frozen value.
38 if (cg_read_strstr(cgroup, "cgroup.events", "frozen 0") != 0) {
39 debug("Cgroup %s is frozen\n", cgroup);
48 * Freeze the given cgroup.
50 static int cg_freeze_nowait(const char *cgroup, bool freeze)
52 return cg_write(cgroup, "cgroup.freeze", freeze ? "1" : "0");
56 * Attach a task to the given cgroup and wait for a cgroup frozen event.
59 static int cg_enter_and_wait_for_frozen(const char *cgroup, int pid,
65 fd = cg_prepare_for_wait(cgroup);
69 ret = cg_enter(cgroup, pid);
78 ret = cg_check_frozen(cgroup, frozen);
89 * Freeze the given cgroup and wait for the inotify signal.
91 * Then check that the cgroup is in the desired state.
93 static int cg_freeze_wait(const char *cgroup, bool freeze)
97 fd = cg_prepare_for_wait(cgroup);
101 ret = cg_freeze_nowait(cgroup, freeze);
111 ret = cg_check_frozen(cgroup, freeze);
121 static int child_fn(const char *cgroup, void *arg)
132 * A simple test for the cgroup freezer: populated the cgroup with 100
134 * processes and destroys the cgroup.
139 char *cgroup = NULL;
142 cgroup = cg_name(root, "cg_test_simple");
143 if (!cgroup)
146 if (cg_create(cgroup))
150 cg_run_nowait(cgroup, child_fn, NULL);
152 if (cg_wait_for_proc_count(cgroup, 100))
155 if (cg_check_frozen(cgroup, false))
158 if (cg_freeze_wait(cgroup, true))
161 if (cg_freeze_wait(cgroup, false))
167 if (cgroup)
168 cg_destroy(cgroup);
169 free(cgroup);
190 char *cgroup[10] = {0};
194 cgroup[0] = cg_name(root, "cg_test_tree_A");
195 if (!cgroup[0])
198 cgroup[1] = cg_name(cgroup[0], "B");
199 if (!cgroup[1])
202 cgroup[2] = cg_name(cgroup[1], "C");
203 if (!cgroup[2])
206 cgroup[3] = cg_name(cgroup[1], "D");
207 if (!cgroup[3])
210 cgroup[4] = cg_name(cgroup[0], "E");
211 if (!cgroup[4])
214 cgroup[5] = cg_name(cgroup[4], "F");
215 if (!cgroup[5])
218 cgroup[6] = cg_name(cgroup[5], "G");
219 if (!cgroup[6])
222 cgroup[7] = cg_name(cgroup[6], "H");
223 if (!cgroup[7])
226 cgroup[8] = cg_name(cgroup[0], "I");
227 if (!cgroup[8])
230 cgroup[9] = cg_name(cgroup[0], "K");
231 if (!cgroup[9])
235 if (cg_create(cgroup[i]))
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);
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))
257 if (cg_freeze_wait(cgroup[1], true))
263 if (cg_freeze_wait(cgroup[5], true))
269 if (cg_freeze_wait(cgroup[6], true))
275 if (cg_check_frozen(cgroup[0], false))
278 if (cg_check_frozen(cgroup[4], false))
284 if (cg_freeze_wait(cgroup[0], true))
287 if (cg_check_frozen(cgroup[1], true))
290 if (cg_check_frozen(cgroup[4], true))
296 if (cg_freeze_nowait(cgroup[1], false))
299 if (cg_freeze_nowait(cgroup[5], false))
302 if (cg_freeze_nowait(cgroup[6], false))
308 if (cg_check_frozen(cgroup[2], true))
311 if (cg_check_frozen(cgroup[7], true))
317 if (cg_freeze_wait(cgroup[0], false))
320 if (cg_check_frozen(cgroup[2], false))
323 if (cg_check_frozen(cgroup[9], false))
329 for (i = 9; i >= 0 && cgroup[i]; i--) {
330 cg_destroy(cgroup[i]);
331 free(cgroup[i]);
340 static int forkbomb_fn(const char *cgroup, void *arg)
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
363 char *cgroup = NULL;
365 cgroup = cg_name(root, "cg_forkbomb_test");
366 if (!cgroup)
369 if (cg_create(cgroup))
372 cg_run_nowait(cgroup, forkbomb_fn, NULL);
376 if (cg_freeze_wait(cgroup, true))
379 if (cg_killall(cgroup))
382 if (cg_wait_for_proc_count(cgroup, 0))
388 if (cgroup)
389 cg_destroy(cgroup);
390 free(cgroup);
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.
449 * and removes the child. Then it checks that the parent cgroup
511 char *cgroup[2] = {0};
514 cgroup[0] = cg_name(root, "cg_test_migrate_A");
515 if (!cgroup[0])
518 cgroup[1] = cg_name(root, "cg_test_migrate_B");
519 if (!cgroup[1])
522 if (cg_create(cgroup[0]))
525 if (cg_create(cgroup[1]))
528 pid = cg_run_nowait(cgroup[0], child_fn, NULL);
532 if (cg_wait_for_proc_count(cgroup[0], 1))
538 if (cg_freeze_wait(cgroup[1], true))
541 if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
544 if (cg_check_frozen(cgroup[0], false))
550 if (cg_enter_and_wait_for_frozen(cgroup[0], pid, false))
553 if (cg_check_frozen(cgroup[1], true))
559 if (cg_freeze_wait(cgroup[0], true))
562 if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
565 if (cg_check_frozen(cgroup[0], true))
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]);
581 * The test checks that ptrace works with a tracing process in a frozen cgroup.
586 char *cgroup = NULL;
590 cgroup = cg_name(root, "cg_test_ptrace");
591 if (!cgroup)
594 if (cg_create(cgroup))
597 pid = cg_run_nowait(cgroup, child_fn, NULL);
601 if (cg_wait_for_proc_count(cgroup, 1))
604 if (cg_freeze_wait(cgroup, true))
619 if (cg_check_frozen(cgroup, true))
628 if (cg_check_frozen(cgroup, true))
634 if (cgroup)
635 cg_destroy(cgroup);
636 free(cgroup);
663 * Test that it's possible to freeze a cgroup with a stopped process.
668 char *cgroup = NULL;
670 cgroup = cg_name(root, "cg_test_stopped");
671 if (!cgroup)
674 if (cg_create(cgroup))
677 pid = cg_run_nowait(cgroup, child_fn, NULL);
679 if (cg_wait_for_proc_count(cgroup, 1))
685 if (cg_check_frozen(cgroup, false))
688 if (cg_freeze_wait(cgroup, true))
691 if (cg_freeze_wait(cgroup, false))
700 if (cgroup)
701 cg_destroy(cgroup);
702 free(cgroup);
707 * Test that it's possible to freeze a cgroup with a ptraced process.
712 char *cgroup = NULL;
715 cgroup = cg_name(root, "cg_test_ptraced");
716 if (!cgroup)
719 if (cg_create(cgroup))
722 pid = cg_run_nowait(cgroup, child_fn, NULL);
724 if (cg_wait_for_proc_count(cgroup, 1))
735 if (cg_check_frozen(cgroup, false))
738 if (cg_freeze_wait(cgroup, true))
742 * cg_check_frozen(cgroup, true) will fail here,
745 if (cg_freeze_wait(cgroup, false))
757 if (cgroup)
758 cg_destroy(cgroup);
759 free(cgroup);
763 static int vfork_fn(const char *cgroup, void *arg)
775 * Test that it's possible to freeze a cgroup with a process,
781 char *cgroup = NULL;
783 cgroup = cg_name(root, "cg_test_vfork");
784 if (!cgroup)
787 if (cg_create(cgroup))
790 cg_run_nowait(cgroup, vfork_fn, NULL);
792 if (cg_wait_for_proc_count(cgroup, 2))
795 if (cg_freeze_wait(cgroup, true))
801 if (cgroup)
802 cg_destroy(cgroup);
803 free(cgroup);
831 ksft_exit_skip("cgroup v2 isn't mounted\n");