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;
  93         char *buf;
  94         int ret;
  95
  96         /* Handle the case of comparing against empty string */
  97         if (!expected)
  98                 size = 32;
  99         else
 100                 size = strlen(expected) + 1;
 101
 102         buf = malloc(size);
 103         if (!buf)
 104                 return -1;
 105
 106         if (cg_read(cgroup, control, buf, size)) {
 107                 free(buf);
 108                 return -1;
 109         }
 110
 111         ret = strcmp(expected, buf);
 112         free(buf);
 113         return ret;
 114 }
 115
 116 int cg_read_strstr(const char *cgroup, const char *control, const char *needle)
 117 {
 118         char buf[PAGE_SIZE];
 119
 120         if (cg_read(cgroup, control, buf, sizeof(buf)))
 121                 return -1;
 122
 123         return strstr(buf, needle) ? 0 : -1;
 124 }
 125
 126 long cg_read_long(const char *cgroup, const char *control)
 127 {
 128         char buf[128];
 129
 130         if (cg_read(cgroup, control, buf, sizeof(buf)))
 131                 return -1;
 132
 133         return atol(buf);
 134 }
 135
 136 long cg_read_key_long(const char *cgroup, const char *control, const char *key)
 137 {
 138         char buf[PAGE_SIZE];
 139         char *ptr;
 140
 141         if (cg_read(cgroup, control, buf, sizeof(buf)))
 142                 return -1;
 143
 144         ptr = strstr(buf, key);
 145         if (!ptr)
 146                 return -1;
 147
 148         return atol(ptr + strlen(key));
 149 }
 150
 151 int cg_write(const char *cgroup, const char *control, char *buf)
 152 {
 153         char path[PATH_MAX];
 154         ssize_t len = strlen(buf);
 155
 156         snprintf(path, sizeof(path), "%s/%s", cgroup, control);
 157
 158         if (write_text(path, buf, len) == len)
 159                 return 0;
 160
 161         return -1;
 162 }
 163
 164 int cg_find_unified_root(char *root, size_t len)
 165 {
 166         char buf[10 * PAGE_SIZE];
 167         char *fs, *mount, *type;
 168         const char delim[] = "\n\t ";
 169
 170         if (read_text("/proc/self/mounts", buf, sizeof(buf)) <= 0)
 171                 return -1;
 172
 173         /*
 174          * Example:
 175          * cgroup /sys/fs/cgroup cgroup2 rw,seclabel,noexec,relatime 0 0
 176          */
 177         for (fs = strtok(buf, delim); fs; fs = strtok(NULL, delim)) {
 178                 mount = strtok(NULL, delim);
 179                 type = strtok(NULL, delim);
 180                 strtok(NULL, delim);
 181                 strtok(NULL, delim);
 182                 strtok(NULL, delim);
 183
 184                 if (strcmp(type, "cgroup2") == 0) {
 185                         strncpy(root, mount, len);
 186                         return 0;
 187                 }
 188         }
 189
 190         return -1;
 191 }
 192
 193 int cg_create(const char *cgroup)
 194 {
 195         return mkdir(cgroup, 0644);
 196 }
 197
 198 static int cg_killall(const char *cgroup)
 199 {
 200         char buf[PAGE_SIZE];
 201         char *ptr = buf;
 202
 203         if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf)))
 204                 return -1;
 205
 206         while (ptr < buf + sizeof(buf)) {
 207                 int pid = strtol(ptr, &ptr, 10);
 208
 209                 if (pid == 0)
 210                         break;
 211                 if (*ptr)
 212                         ptr++;
 213                 else
 214                         break;
 215                 if (kill(pid, SIGKILL))
 216                         return -1;
 217         }
 218
 219         return 0;
 220 }
 221
 222 int cg_destroy(const char *cgroup)
 223 {
 224         int ret;
 225
 226 retry:
 227         ret = rmdir(cgroup);
 228         if (ret && errno == EBUSY) {
 229                 ret = cg_killall(cgroup);
 230                 if (ret)
 231                         return ret;
 232                 usleep(100);
 233                 goto retry;
 234         }
 235
 236         if (ret && errno == ENOENT)
 237                 ret = 0;
 238
 239         return ret;
 240 }
 241
 242 int cg_enter_current(const char *cgroup)
 243 {
 244         char pidbuf[64];
 245
 246         snprintf(pidbuf, sizeof(pidbuf), "%d", getpid());
 247         return cg_write(cgroup, "cgroup.procs", pidbuf);
 248 }
 249
 250 int cg_run(const char *cgroup,
 251            int (*fn)(const char *cgroup, void *arg),
 252            void *arg)
 253 {
 254         int pid, retcode;
 255
 256         pid = fork();
 257         if (pid < 0) {
 258                 return pid;
 259         } else if (pid == 0) {
 260                 char buf[64];
 261
 262                 snprintf(buf, sizeof(buf), "%d", getpid());
 263                 if (cg_write(cgroup, "cgroup.procs", buf))
 264                         exit(EXIT_FAILURE);
 265                 exit(fn(cgroup, arg));
 266         } else {
 267                 waitpid(pid, &retcode, 0);
 268                 if (WIFEXITED(retcode))
 269                         return WEXITSTATUS(retcode);
 270                 else
 271                         return -1;
 272         }
 273 }
 274
 275 int cg_run_nowait(const char *cgroup,
 276                   int (*fn)(const char *cgroup, void *arg),
 277                   void *arg)
 278 {
 279         int pid;
 280
 281         pid = fork();
 282         if (pid == 0) {
 283                 char buf[64];
 284
 285                 snprintf(buf, sizeof(buf), "%d", getpid());
 286                 if (cg_write(cgroup, "cgroup.procs", buf))
 287                         exit(EXIT_FAILURE);
 288                 exit(fn(cgroup, arg));
 289         }
 290
 291         return pid;
 292 }
 293
 294 int get_temp_fd(void)
 295 {
 296         return open(".", O_TMPFILE | O_RDWR | O_EXCL);
 297 }
 298
 299 int alloc_pagecache(int fd, size_t size)
 300 {
 301         char buf[PAGE_SIZE];
 302         struct stat st;
 303         int i;
 304
 305         if (fstat(fd, &st))
 306                 goto cleanup;
 307
 308         size += st.st_size;
 309
 310         if (ftruncate(fd, size))
 311                 goto cleanup;
 312
 313         for (i = 0; i < size; i += sizeof(buf))
 314                 read(fd, buf, sizeof(buf));
 315
 316         return 0;
 317
 318 cleanup:
 319         return -1;
 320 }
 321
 322 int alloc_anon(const char *cgroup, void *arg)
 323 {
 324         size_t size = (unsigned long)arg;
 325         char *buf, *ptr;
 326
 327         buf = malloc(size);
 328         for (ptr = buf; ptr < buf + size; ptr += PAGE_SIZE)
 329                 *ptr = 0;
 330
 331         free(buf);
 332         return 0;
 333 }
 334
 335 int is_swap_enabled(void)
 336 {
 337         char buf[PAGE_SIZE];
 338         const char delim[] = "\n";
 339         int cnt = 0;
 340         char *line;
 341
 342         if (read_text("/proc/swaps", buf, sizeof(buf)) <= 0)
 343                 return -1;
 344
 345         for (line = strtok(buf, delim); line; line = strtok(NULL, delim))
 346                 cnt++;
 347
 348         return cnt > 1;
 349 }
 350
 351 int set_oom_adj_score(int pid, int score)
 352 {
 353         char path[PATH_MAX];
 354         int fd, len;
 355
 356         sprintf(path, "/proc/%d/oom_score_adj", pid);
 357
 358         fd = open(path, O_WRONLY | O_APPEND);
 359         if (fd < 0)
 360                 return fd;
 361
 362         len = dprintf(fd, "%d", score);
 363         if (len < 0) {
 364                 close(fd);
 365                 return len;
 366         }
 367
 368         close(fd);
 369         return 0;
 370 }