1 /* SPDX-License-Identifier: GPL-2.0 */ 2 3 #include <errno.h> 4 #include <linux/limits.h> 5 #include <stdbool.h> 6 #include <stdio.h> 7 #include <stdlib.h> 8 #include <string.h> 9 #include <sys/types.h> 10 #include <unistd.h> 11 12 #include "../kselftest.h" 13 #include "../pidfd/pidfd.h" 14 #include "cgroup_util.h" 15 16 /* 17 * Kill the given cgroup and wait for the inotify signal. 18 * If there are no events in 10 seconds, treat this as an error. 19 * Then check that the cgroup is in the desired state. 20 */ 21 static int cg_kill_wait(const char *cgroup) 22 { 23 int fd, ret = -1; 24 25 fd = cg_prepare_for_wait(cgroup); 26 if (fd < 0) 27 return fd; 28 29 ret = cg_write(cgroup, "cgroup.kill", "1"); 30 if (ret) 31 goto out; 32 33 ret = cg_wait_for(fd); 34 if (ret) 35 goto out; 36 37 out: 38 close(fd); 39 return ret; 40 } 41 42 /* 43 * A simple process running in a sleep loop until being 44 * re-parented. 45 */ 46 static int child_fn(const char *cgroup, void *arg) 47 { 48 int ppid = getppid(); 49 50 while (getppid() == ppid) 51 usleep(1000); 52 53 return getppid() == ppid; 54 } 55 56 static int test_cgkill_simple(const char *root) 57 { 58 pid_t pids[100]; 59 int ret = KSFT_FAIL; 60 char *cgroup = NULL; 61 int i; 62 63 cgroup = cg_name(root, "cg_test_simple"); 64 if (!cgroup) 65 goto cleanup; 66 67 if (cg_create(cgroup)) 68 goto cleanup; 69 70 for (i = 0; i < 100; i++) 71 pids[i] = cg_run_nowait(cgroup, child_fn, NULL); 72 73 if (cg_wait_for_proc_count(cgroup, 100)) 74 goto cleanup; 75 76 if (cg_read_strcmp(cgroup, "cgroup.events", "populated 1\n")) 77 goto cleanup; 78 79 if (cg_kill_wait(cgroup)) 80 goto cleanup; 81 82 ret = KSFT_PASS; 83 84 cleanup: 85 for (i = 0; i < 100; i++) 86 wait_for_pid(pids[i]); 87 88 if (ret == KSFT_PASS && 89 cg_read_strcmp(cgroup, "cgroup.events", "populated 0\n")) 90 ret = KSFT_FAIL; 91 92 if (cgroup) 93 cg_destroy(cgroup); 94 free(cgroup); 95 return ret; 96 } 97 98 /* 99 * The test creates the following hierarchy: 100 * A 101 * / / \ \ 102 * B E I K 103 * /\ | 104 * C D F 105 * | 106 * G 107 * | 108 * H 109 * 110 * with a process in C, H and 3 processes in K. 111 * Then it tries to kill the whole tree. 112 */ 113 static int test_cgkill_tree(const char *root) 114 { 115 pid_t pids[5]; 116 char *cgroup[10] = {0}; 117 int ret = KSFT_FAIL; 118 int i; 119 120 cgroup[0] = cg_name(root, "cg_test_tree_A"); 121 if (!cgroup[0]) 122 goto cleanup; 123 124 cgroup[1] = cg_name(cgroup[0], "B"); 125 if (!cgroup[1]) 126 goto cleanup; 127 128 cgroup[2] = cg_name(cgroup[1], "C"); 129 if (!cgroup[2]) 130 goto cleanup; 131 132 cgroup[3] = cg_name(cgroup[1], "D"); 133 if (!cgroup[3]) 134 goto cleanup; 135 136 cgroup[4] = cg_name(cgroup[0], "E"); 137 if (!cgroup[4]) 138 goto cleanup; 139 140 cgroup[5] = cg_name(cgroup[4], "F"); 141 if (!cgroup[5]) 142 goto cleanup; 143 144 cgroup[6] = cg_name(cgroup[5], "G"); 145 if (!cgroup[6]) 146 goto cleanup; 147 148 cgroup[7] = cg_name(cgroup[6], "H"); 149 if (!cgroup[7]) 150 goto cleanup; 151 152 cgroup[8] = cg_name(cgroup[0], "I"); 153 if (!cgroup[8]) 154 goto cleanup; 155 156 cgroup[9] = cg_name(cgroup[0], "K"); 157 if (!cgroup[9]) 158 goto cleanup; 159 160 for (i = 0; i < 10; i++) 161 if (cg_create(cgroup[i])) 162 goto cleanup; 163 164 pids[0] = cg_run_nowait(cgroup[2], child_fn, NULL); 165 pids[1] = cg_run_nowait(cgroup[7], child_fn, NULL); 166 pids[2] = cg_run_nowait(cgroup[9], child_fn, NULL); 167 pids[3] = cg_run_nowait(cgroup[9], child_fn, NULL); 168 pids[4] = cg_run_nowait(cgroup[9], child_fn, NULL); 169 170 /* 171 * Wait until all child processes will enter 172 * corresponding cgroups. 173 */ 174 175 if (cg_wait_for_proc_count(cgroup[2], 1) || 176 cg_wait_for_proc_count(cgroup[7], 1) || 177 cg_wait_for_proc_count(cgroup[9], 3)) 178 goto cleanup; 179 180 /* 181 * Kill A and check that we get an empty notification. 182 */ 183 if (cg_kill_wait(cgroup[0])) 184 goto cleanup; 185 186 ret = KSFT_PASS; 187 188 cleanup: 189 for (i = 0; i < 5; i++) 190 wait_for_pid(pids[i]); 191 192 if (ret == KSFT_PASS && 193 cg_read_strcmp(cgroup[0], "cgroup.events", "populated 0\n")) 194 ret = KSFT_FAIL; 195 196 for (i = 9; i >= 0 && cgroup[i]; i--) { 197 cg_destroy(cgroup[i]); 198 free(cgroup[i]); 199 } 200 201 return ret; 202 } 203 204 static int forkbomb_fn(const char *cgroup, void *arg) 205 { 206 int ppid; 207 208 fork(); 209 fork(); 210 211 ppid = getppid(); 212 213 while (getppid() == ppid) 214 usleep(1000); 215 216 return getppid() == ppid; 217 } 218 219 /* 220 * The test runs a fork bomb in a cgroup and tries to kill it. 221 */ 222 static int test_cgkill_forkbomb(const char *root) 223 { 224 int ret = KSFT_FAIL; 225 char *cgroup = NULL; 226 pid_t pid = -ESRCH; 227 228 cgroup = cg_name(root, "cg_forkbomb_test"); 229 if (!cgroup) 230 goto cleanup; 231 232 if (cg_create(cgroup)) 233 goto cleanup; 234 235 pid = cg_run_nowait(cgroup, forkbomb_fn, NULL); 236 if (pid < 0) 237 goto cleanup; 238 239 usleep(100000); 240 241 if (cg_kill_wait(cgroup)) 242 goto cleanup; 243 244 if (cg_wait_for_proc_count(cgroup, 0)) 245 goto cleanup; 246 247 ret = KSFT_PASS; 248 249 cleanup: 250 if (pid > 0) 251 wait_for_pid(pid); 252 253 if (ret == KSFT_PASS && 254 cg_read_strcmp(cgroup, "cgroup.events", "populated 0\n")) 255 ret = KSFT_FAIL; 256 257 if (cgroup) 258 cg_destroy(cgroup); 259 free(cgroup); 260 return ret; 261 } 262 263 #define T(x) { x, #x } 264 struct cgkill_test { 265 int (*fn)(const char *root); 266 const char *name; 267 } tests[] = { 268 T(test_cgkill_simple), 269 T(test_cgkill_tree), 270 T(test_cgkill_forkbomb), 271 }; 272 #undef T 273 274 int main(int argc, char *argv[]) 275 { 276 char root[PATH_MAX]; 277 int i, ret = EXIT_SUCCESS; 278 279 if (cg_find_unified_root(root, sizeof(root), NULL)) 280 ksft_exit_skip("cgroup v2 isn't mounted\n"); 281 for (i = 0; i < ARRAY_SIZE(tests); i++) { 282 switch (tests[i].fn(root)) { 283 case KSFT_PASS: 284 ksft_test_result_pass("%s\n", tests[i].name); 285 break; 286 case KSFT_SKIP: 287 ksft_test_result_skip("%s\n", tests[i].name); 288 break; 289 default: 290 ret = EXIT_FAILURE; 291 ksft_test_result_fail("%s\n", tests[i].name); 292 break; 293 } 294 } 295 296 return ret; 297 } 298