tools/testing/selftests/cgroup/test_kill.c

   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 }