tools/testing/selftests/bpf/cgroup_helpers.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #define _GNU_SOURCE
   3 #include <sched.h>
   4 #include <sys/mount.h>
   5 #include <sys/stat.h>
   6 #include <sys/types.h>
   7 #include <linux/limits.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <linux/sched.h>
  11 #include <fcntl.h>
  12 #include <unistd.h>
  13 #include <ftw.h>
  14
  15
  16 #include "cgroup_helpers.h"
  17
  18 /*
  19  * To avoid relying on the system setup, when setup_cgroup_env is called
  20  * we create a new mount namespace, and cgroup namespace. The cgroup2
  21  * root is mounted at CGROUP_MOUNT_PATH
  22  *
  23  * Unfortunately, most people don't have cgroupv2 enabled at this point in time.
  24  * It's easier to create our own mount namespace and manage it ourselves.
  25  *
  26  * We assume /mnt exists.
  27  */
  28
  29 #define WALK_FD_LIMIT                   16
  30 #define CGROUP_MOUNT_PATH               "/mnt"
  31 #define CGROUP_WORK_DIR                 "/cgroup-test-work-dir"
  32 #define format_cgroup_path(buf, path) \
  33         snprintf(buf, sizeof(buf), "%s%s%s", CGROUP_MOUNT_PATH, \
  34                  CGROUP_WORK_DIR, path)
  35
  36 /**
  37  * setup_cgroup_environment() - Setup the cgroup environment
  38  *
  39  * After calling this function, cleanup_cgroup_environment should be called
  40  * once testing is complete.
  41  *
  42  * This function will print an error to stderr and return 1 if it is unable
  43  * to setup the cgroup environment. If setup is successful, 0 is returned.
  44  */
  45 int setup_cgroup_environment(void)
  46 {
  47         char cgroup_workdir[PATH_MAX + 1];
  48
  49         format_cgroup_path(cgroup_workdir, "");
  50
  51         if (unshare(CLONE_NEWNS)) {
  52                 log_err("unshare");
  53                 return 1;
  54         }
  55
  56         if (mount("none", "/", NULL, MS_REC | MS_PRIVATE, NULL)) {
  57                 log_err("mount fakeroot");
  58                 return 1;
  59         }
  60
  61         if (mount("none", CGROUP_MOUNT_PATH, "cgroup2", 0, NULL) && errno != EBUSY) {
  62                 log_err("mount cgroup2");
  63                 return 1;
  64         }
  65
  66         /* Cleanup existing failed runs, now that the environment is setup */
  67         cleanup_cgroup_environment();
  68
  69         if (mkdir(cgroup_workdir, 0777) && errno != EEXIST) {
  70                 log_err("mkdir cgroup work dir");
  71                 return 1;
  72         }
  73
  74         return 0;
  75 }
  76
  77 static int nftwfunc(const char *filename, const struct stat *statptr,
  78                     int fileflags, struct FTW *pfwt)
  79 {
  80         if ((fileflags & FTW_D) && rmdir(filename))
  81                 log_err("Removing cgroup: %s", filename);
  82         return 0;
  83 }
  84
  85
  86 static int join_cgroup_from_top(char *cgroup_path)
  87 {
  88         char cgroup_procs_path[PATH_MAX + 1];
  89         pid_t pid = getpid();
  90         int fd, rc = 0;
  91
  92         snprintf(cgroup_procs_path, sizeof(cgroup_procs_path),
  93                  "%s/cgroup.procs", cgroup_path);
  94
  95         fd = open(cgroup_procs_path, O_WRONLY);
  96         if (fd < 0) {
  97                 log_err("Opening Cgroup Procs: %s", cgroup_procs_path);
  98                 return 1;
  99         }
 100
 101         if (dprintf(fd, "%d\n", pid) < 0) {
 102                 log_err("Joining Cgroup");
 103                 rc = 1;
 104         }
 105
 106         close(fd);
 107         return rc;
 108 }
 109
 110 /**
 111  * join_cgroup() - Join a cgroup
 112  * @path: The cgroup path, relative to the workdir, to join
 113  *
 114  * This function expects a cgroup to already be created, relative to the cgroup
 115  * work dir, and it joins it. For example, passing "/my-cgroup" as the path
 116  * would actually put the calling process into the cgroup
 117  * "/cgroup-test-work-dir/my-cgroup"
 118  *
 119  * On success, it returns 0, otherwise on failure it returns 1.
 120  */
 121 int join_cgroup(const char *path)
 122 {
 123         char cgroup_path[PATH_MAX + 1];
 124
 125         format_cgroup_path(cgroup_path, path);
 126         return join_cgroup_from_top(cgroup_path);
 127 }
 128
 129 /**
 130  * cleanup_cgroup_environment() - Cleanup Cgroup Testing Environment
 131  *
 132  * This is an idempotent function to delete all temporary cgroups that
 133  * have been created during the test, including the cgroup testing work
 134  * directory.
 135  *
 136  * At call time, it moves the calling process to the root cgroup, and then
 137  * runs the deletion process. It is idempotent, and should not fail, unless
 138  * a process is lingering.
 139  *
 140  * On failure, it will print an error to stderr, and try to continue.
 141  */
 142 void cleanup_cgroup_environment(void)
 143 {
 144         char cgroup_workdir[PATH_MAX + 1];
 145
 146         format_cgroup_path(cgroup_workdir, "");
 147         join_cgroup_from_top(CGROUP_MOUNT_PATH);
 148         nftw(cgroup_workdir, nftwfunc, WALK_FD_LIMIT, FTW_DEPTH | FTW_MOUNT);
 149 }
 150
 151 /**
 152  * create_and_get_cgroup() - Create a cgroup, relative to workdir, and get the FD
 153  * @path: The cgroup path, relative to the workdir, to join
 154  *
 155  * This function creates a cgroup under the top level workdir and returns the
 156  * file descriptor. It is idempotent.
 157  *
 158  * On success, it returns the file descriptor. On failure it returns 0.
 159  * If there is a failure, it prints the error to stderr.
 160  */
 161 int create_and_get_cgroup(const char *path)
 162 {
 163         char cgroup_path[PATH_MAX + 1];
 164         int fd;
 165
 166         format_cgroup_path(cgroup_path, path);
 167         if (mkdir(cgroup_path, 0777) && errno != EEXIST) {
 168                 log_err("mkdiring cgroup %s .. %s", path, cgroup_path);
 169                 return 0;
 170         }
 171
 172         fd = open(cgroup_path, O_RDONLY);
 173         if (fd < 0) {
 174                 log_err("Opening Cgroup");
 175                 return 0;
 176         }
 177
 178         return fd;
 179 }
 180
 181 /**
 182  * get_cgroup_id() - Get cgroup id for a particular cgroup path
 183  * @path: The cgroup path, relative to the workdir, to join
 184  *
 185  * On success, it returns the cgroup id. On failure it returns 0,
 186  * which is an invalid cgroup id.
 187  * If there is a failure, it prints the error to stderr.
 188  */
 189 unsigned long long get_cgroup_id(const char *path)
 190 {
 191         int dirfd, err, flags, mount_id, fhsize;
 192         union {
 193                 unsigned long long cgid;
 194                 unsigned char raw_bytes[8];
 195         } id;
 196         char cgroup_workdir[PATH_MAX + 1];
 197         struct file_handle *fhp, *fhp2;
 198         unsigned long long ret = 0;
 199
 200         format_cgroup_path(cgroup_workdir, path);
 201
 202         dirfd = AT_FDCWD;
 203         flags = 0;
 204         fhsize = sizeof(*fhp);
 205         fhp = calloc(1, fhsize);
 206         if (!fhp) {
 207                 log_err("calloc");
 208                 return 0;
 209         }
 210         err = name_to_handle_at(dirfd, cgroup_workdir, fhp, &mount_id, flags);
 211         if (err >= 0 || fhp->handle_bytes != 8) {
 212                 log_err("name_to_handle_at");
 213                 goto free_mem;
 214         }
 215
 216         fhsize = sizeof(struct file_handle) + fhp->handle_bytes;
 217         fhp2 = realloc(fhp, fhsize);
 218         if (!fhp2) {
 219                 log_err("realloc");
 220                 goto free_mem;
 221         }
 222         err = name_to_handle_at(dirfd, cgroup_workdir, fhp2, &mount_id, flags);
 223         fhp = fhp2;
 224         if (err < 0) {
 225                 log_err("name_to_handle_at");
 226                 goto free_mem;
 227         }
 228
 229         memcpy(id.raw_bytes, fhp->f_handle, 8);
 230         ret = id.cgid;
 231
 232 free_mem:
 233         free(fhp);
 234         return ret;
 235 }