tools/testing/selftests/cgroup/cgroup_util.c

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2
   3 #define _GNU_SOURCE
   4
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <linux/limits.h>
   8 #include <signal.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <sys/stat.h>
  13 #include <sys/types.h>
  14 #include <sys/wait.h>
  15 #include <unistd.h>
  16
  17 #include "cgroup_util.h"
  18
  19 static ssize_t read_text(const char *path, char *buf, size_t max_len)
  20 {
  21         ssize_t len;
  22         int fd;
  23
  24         fd = open(path, O_RDONLY);
  25         if (fd < 0)
  26                 return fd;
  27
  28         len = read(fd, buf, max_len - 1);
  29         if (len < 0)
  30                 goto out;
  31
  32         buf[len] = 0;
  33 out:
  34         close(fd);
  35         return len;
  36 }
  37
  38 static ssize_t write_text(const char *path, char *buf, ssize_t len)
  39 {
  40         int fd;
  41
  42         fd = open(path, O_WRONLY | O_APPEND);
  43         if (fd < 0)
  44                 return fd;
  45
  46         len = write(fd, buf, len);
  47         if (len < 0) {
  48                 close(fd);
  49                 return len;
  50         }
  51
  52         close(fd);
  53
  54         return len;
  55 }
  56
  57 char *cg_name(const char *root, const char *name)
  58 {
  59         size_t len = strlen(root) + strlen(name) + 2;
  60         char *ret = malloc(len);
  61
  62         snprintf(ret, len, "%s/%s", root, name);
  63
  64         return ret;
  65 }
  66
  67 char *cg_name_indexed(const char *root, const char *name, int index)
  68 {
  69         size_t len = strlen(root) + strlen(name) + 10;
  70         char *ret = malloc(len);
  71
  72         snprintf(ret, len, "%s/%s_%d", root, name, index);
  73
  74         return ret;
  75 }
  76
  77 int cg_read(const char *cgroup, const char *control, char *buf, size_t len)
  78 {
  79         char path[PATH_MAX];
  80
  81         snprintf(path, sizeof(path), "%s/%s", cgroup, control);
  82
  83         if (read_text(path, buf, len) >= 0)
  84                 return 0;
  85
  86         return -1;
  87 }
  88
  89 int cg_read_strcmp(const char *cgroup, const char *control,
  90                    const char *expected)
  91 {
  92         size_t size = strlen(expected) + 1;
  93         char *buf;
  94
  95         buf = malloc(size);
  96         if (!buf)
  97                 return -1;
  98
  99         if (cg_read(cgroup, control, buf, size))
 100                 return -1;
 101
 102         return strcmp(expected, buf);
 103 }
 104
 105 int cg_read_strstr(const char *cgroup, const char *control, const char *needle)
 106 {
 107         char buf[PAGE_SIZE];
 108
 109         if (cg_read(cgroup, control, buf, sizeof(buf)))
 110                 return -1;
 111
 112         return strstr(buf, needle) ? 0 : -1;
 113 }
 114
 115 long cg_read_long(const char *cgroup, const char *control)
 116 {
 117         char buf[128];
 118
 119         if (cg_read(cgroup, control, buf, sizeof(buf)))
 120                 return -1;
 121
 122         return atol(buf);
 123 }
 124
 125 long cg_read_key_long(const char *cgroup, const char *control, const char *key)
 126 {
 127         char buf[PAGE_SIZE];
 128         char *ptr;
 129
 130         if (cg_read(cgroup, control, buf, sizeof(buf)))
 131                 return -1;
 132
 133         ptr = strstr(buf, key);
 134         if (!ptr)
 135                 return -1;
 136
 137         return atol(ptr + strlen(key));
 138 }
 139
 140 int cg_write(const char *cgroup, const char *control, char *buf)
 141 {
 142         char path[PATH_MAX];
 143         ssize_t len = strlen(buf);
 144
 145         snprintf(path, sizeof(path), "%s/%s", cgroup, control);
 146
 147         if (write_text(path, buf, len) == len)
 148                 return 0;
 149
 150         return -1;
 151 }
 152
 153 int cg_find_unified_root(char *root, size_t len)
 154 {
 155         char buf[10 * PAGE_SIZE];
 156         char *fs, *mount, *type;
 157         const char delim[] = "\n\t ";
 158
 159         if (read_text("/proc/self/mounts", buf, sizeof(buf)) <= 0)
 160                 return -1;
 161
 162         /*
 163          * Example:
 164          * cgroup /sys/fs/cgroup cgroup2 rw,seclabel,noexec,relatime 0 0
 165          */
 166         for (fs = strtok(buf, delim); fs; fs = strtok(NULL, delim)) {
 167                 mount = strtok(NULL, delim);
 168                 type = strtok(NULL, delim);
 169                 strtok(NULL, delim);
 170                 strtok(NULL, delim);
 171                 strtok(NULL, delim);
 172
 173                 if (strcmp(fs, "cgroup") == 0 &&
 174                     strcmp(type, "cgroup2") == 0) {
 175                         strncpy(root, mount, len);
 176                         return 0;
 177                 }
 178         }
 179
 180         return -1;
 181 }
 182
 183 int cg_create(const char *cgroup)
 184 {
 185         return mkdir(cgroup, 0644);
 186 }
 187
 188 static int cg_killall(const char *cgroup)
 189 {
 190         char buf[PAGE_SIZE];
 191         char *ptr = buf;
 192
 193         if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf)))
 194                 return -1;
 195
 196         while (ptr < buf + sizeof(buf)) {
 197                 int pid = strtol(ptr, &ptr, 10);
 198
 199                 if (pid == 0)
 200                         break;
 201                 if (*ptr)
 202                         ptr++;
 203                 else
 204                         break;
 205                 if (kill(pid, SIGKILL))
 206                         return -1;
 207         }
 208
 209         return 0;
 210 }
 211
 212 int cg_destroy(const char *cgroup)
 213 {
 214         int ret;
 215
 216 retry:
 217         ret = rmdir(cgroup);
 218         if (ret && errno == EBUSY) {
 219                 ret = cg_killall(cgroup);
 220                 if (ret)
 221                         return ret;
 222                 usleep(100);
 223                 goto retry;
 224         }
 225
 226         if (ret && errno == ENOENT)
 227                 ret = 0;
 228
 229         return ret;
 230 }
 231
 232 int cg_enter_current(const char *cgroup)
 233 {
 234         char pidbuf[64];
 235
 236         snprintf(pidbuf, sizeof(pidbuf), "%d", getpid());
 237         return cg_write(cgroup, "cgroup.procs", pidbuf);
 238 }
 239
 240 int cg_run(const char *cgroup,
 241            int (*fn)(const char *cgroup, void *arg),
 242            void *arg)
 243 {
 244         int pid, retcode;
 245
 246         pid = fork();
 247         if (pid < 0) {
 248                 return pid;
 249         } else if (pid == 0) {
 250                 char buf[64];
 251
 252                 snprintf(buf, sizeof(buf), "%d", getpid());
 253                 if (cg_write(cgroup, "cgroup.procs", buf))
 254                         exit(EXIT_FAILURE);
 255                 exit(fn(cgroup, arg));
 256         } else {
 257                 waitpid(pid, &retcode, 0);
 258                 if (WIFEXITED(retcode))
 259                         return WEXITSTATUS(retcode);
 260                 else
 261                         return -1;
 262         }
 263 }
 264
 265 int cg_run_nowait(const char *cgroup,
 266                   int (*fn)(const char *cgroup, void *arg),
 267                   void *arg)
 268 {
 269         int pid;
 270
 271         pid = fork();
 272         if (pid == 0) {
 273                 char buf[64];
 274
 275                 snprintf(buf, sizeof(buf), "%d", getpid());
 276                 if (cg_write(cgroup, "cgroup.procs", buf))
 277                         exit(EXIT_FAILURE);
 278                 exit(fn(cgroup, arg));
 279         }
 280
 281         return pid;
 282 }
 283
 284 int get_temp_fd(void)
 285 {
 286         return open(".", O_TMPFILE | O_RDWR | O_EXCL);
 287 }
 288
 289 int alloc_pagecache(int fd, size_t size)
 290 {
 291         char buf[PAGE_SIZE];
 292         struct stat st;
 293         int i;
 294
 295         if (fstat(fd, &st))
 296                 goto cleanup;
 297
 298         size += st.st_size;
 299
 300         if (ftruncate(fd, size))
 301                 goto cleanup;
 302
 303         for (i = 0; i < size; i += sizeof(buf))
 304                 read(fd, buf, sizeof(buf));
 305
 306         return 0;
 307
 308 cleanup:
 309         return -1;
 310 }
 311
 312 int alloc_anon(const char *cgroup, void *arg)
 313 {
 314         size_t size = (unsigned long)arg;
 315         char *buf, *ptr;
 316
 317         buf = malloc(size);
 318         for (ptr = buf; ptr < buf + size; ptr += PAGE_SIZE)
 319                 *ptr = 0;
 320
 321         free(buf);
 322         return 0;
 323 }
 324
 325 int is_swap_enabled(void)
 326 {
 327         char buf[PAGE_SIZE];
 328         const char delim[] = "\n";
 329         int cnt = 0;
 330         char *line;
 331
 332         if (read_text("/proc/swaps", buf, sizeof(buf)) <= 0)
 333                 return -1;
 334
 335         for (line = strtok(buf, delim); line; line = strtok(NULL, delim))
 336                 cnt++;
 337
 338         return cnt > 1;
 339 }