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 char *cg_control(const char *cgroup, const char *control)
  78 {
  79         size_t len = strlen(cgroup) + strlen(control) + 2;
  80         char *ret = malloc(len);
  81
  82         snprintf(ret, len, "%s/%s", cgroup, control);
  83
  84         return ret;
  85 }
  86
  87 int cg_read(const char *cgroup, const char *control, char *buf, size_t len)
  88 {
  89         char path[PATH_MAX];
  90
  91         snprintf(path, sizeof(path), "%s/%s", cgroup, control);
  92
  93         if (read_text(path, buf, len) >= 0)
  94                 return 0;
  95
  96         return -1;
  97 }
  98
  99 int cg_read_strcmp(const char *cgroup, const char *control,
 100                    const char *expected)
 101 {
 102         size_t size;
 103         char *buf;
 104         int ret;
 105
 106         /* Handle the case of comparing against empty string */
 107         if (!expected)
 108                 size = 32;
 109         else
 110                 size = strlen(expected) + 1;
 111
 112         buf = malloc(size);
 113         if (!buf)
 114                 return -1;
 115
 116         if (cg_read(cgroup, control, buf, size)) {
 117                 free(buf);
 118                 return -1;
 119         }
 120
 121         ret = strcmp(expected, buf);
 122         free(buf);
 123         return ret;
 124 }
 125
 126 int cg_read_strstr(const char *cgroup, const char *control, const char *needle)
 127 {
 128         char buf[PAGE_SIZE];
 129
 130         if (cg_read(cgroup, control, buf, sizeof(buf)))
 131                 return -1;
 132
 133         return strstr(buf, needle) ? 0 : -1;
 134 }
 135
 136 long cg_read_long(const char *cgroup, const char *control)
 137 {
 138         char buf[128];
 139
 140         if (cg_read(cgroup, control, buf, sizeof(buf)))
 141                 return -1;
 142
 143         return atol(buf);
 144 }
 145
 146 long cg_read_key_long(const char *cgroup, const char *control, const char *key)
 147 {
 148         char buf[PAGE_SIZE];
 149         char *ptr;
 150
 151         if (cg_read(cgroup, control, buf, sizeof(buf)))
 152                 return -1;
 153
 154         ptr = strstr(buf, key);
 155         if (!ptr)
 156                 return -1;
 157
 158         return atol(ptr + strlen(key));
 159 }
 160
 161 long cg_read_lc(const char *cgroup, const char *control)
 162 {
 163         char buf[PAGE_SIZE];
 164         const char delim[] = "\n";
 165         char *line;
 166         long cnt = 0;
 167
 168         if (cg_read(cgroup, control, buf, sizeof(buf)))
 169                 return -1;
 170
 171         for (line = strtok(buf, delim); line; line = strtok(NULL, delim))
 172                 cnt++;
 173
 174         return cnt;
 175 }
 176
 177 int cg_write(const char *cgroup, const char *control, char *buf)
 178 {
 179         char path[PATH_MAX];
 180         ssize_t len = strlen(buf);
 181
 182         snprintf(path, sizeof(path), "%s/%s", cgroup, control);
 183
 184         if (write_text(path, buf, len) == len)
 185                 return 0;
 186
 187         return -1;
 188 }
 189
 190 int cg_find_unified_root(char *root, size_t len)
 191 {
 192         char buf[10 * PAGE_SIZE];
 193         char *fs, *mount, *type;
 194         const char delim[] = "\n\t ";
 195
 196         if (read_text("/proc/self/mounts", buf, sizeof(buf)) <= 0)
 197                 return -1;
 198
 199         /*
 200          * Example:
 201          * cgroup /sys/fs/cgroup cgroup2 rw,seclabel,noexec,relatime 0 0
 202          */
 203         for (fs = strtok(buf, delim); fs; fs = strtok(NULL, delim)) {
 204                 mount = strtok(NULL, delim);
 205                 type = strtok(NULL, delim);
 206                 strtok(NULL, delim);
 207                 strtok(NULL, delim);
 208                 strtok(NULL, delim);
 209
 210                 if (strcmp(type, "cgroup2") == 0) {
 211                         strncpy(root, mount, len);
 212                         return 0;
 213                 }
 214         }
 215
 216         return -1;
 217 }
 218
 219 int cg_create(const char *cgroup)
 220 {
 221         return mkdir(cgroup, 0644);
 222 }
 223
 224 int cg_wait_for_proc_count(const char *cgroup, int count)
 225 {
 226         char buf[10 * PAGE_SIZE] = {0};
 227         int attempts;
 228         char *ptr;
 229
 230         for (attempts = 10; attempts >= 0; attempts--) {
 231                 int nr = 0;
 232
 233                 if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf)))
 234                         break;
 235
 236                 for (ptr = buf; *ptr; ptr++)
 237                         if (*ptr == '\n')
 238                                 nr++;
 239
 240                 if (nr >= count)
 241                         return 0;
 242
 243                 usleep(100000);
 244         }
 245
 246         return -1;
 247 }
 248
 249 int cg_killall(const char *cgroup)
 250 {
 251         char buf[PAGE_SIZE];
 252         char *ptr = buf;
 253
 254         if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf)))
 255                 return -1;
 256
 257         while (ptr < buf + sizeof(buf)) {
 258                 int pid = strtol(ptr, &ptr, 10);
 259
 260                 if (pid == 0)
 261                         break;
 262                 if (*ptr)
 263                         ptr++;
 264                 else
 265                         break;
 266                 if (kill(pid, SIGKILL))
 267                         return -1;
 268         }
 269
 270         return 0;
 271 }
 272
 273 int cg_destroy(const char *cgroup)
 274 {
 275         int ret;
 276
 277 retry:
 278         ret = rmdir(cgroup);
 279         if (ret && errno == EBUSY) {
 280                 cg_killall(cgroup);
 281                 usleep(100);
 282                 goto retry;
 283         }
 284
 285         if (ret && errno == ENOENT)
 286                 ret = 0;
 287
 288         return ret;
 289 }
 290
 291 int cg_enter(const char *cgroup, int pid)
 292 {
 293         char pidbuf[64];
 294
 295         snprintf(pidbuf, sizeof(pidbuf), "%d", pid);
 296         return cg_write(cgroup, "cgroup.procs", pidbuf);
 297 }
 298
 299 int cg_enter_current(const char *cgroup)
 300 {
 301         return cg_write(cgroup, "cgroup.procs", "0");
 302 }
 303
 304 int cg_enter_current_thread(const char *cgroup)
 305 {
 306         return cg_write(cgroup, "cgroup.threads", "0");
 307 }
 308
 309 int cg_run(const char *cgroup,
 310            int (*fn)(const char *cgroup, void *arg),
 311            void *arg)
 312 {
 313         int pid, retcode;
 314
 315         pid = fork();
 316         if (pid < 0) {
 317                 return pid;
 318         } else if (pid == 0) {
 319                 char buf[64];
 320
 321                 snprintf(buf, sizeof(buf), "%d", getpid());
 322                 if (cg_write(cgroup, "cgroup.procs", buf))
 323                         exit(EXIT_FAILURE);
 324                 exit(fn(cgroup, arg));
 325         } else {
 326                 waitpid(pid, &retcode, 0);
 327                 if (WIFEXITED(retcode))
 328                         return WEXITSTATUS(retcode);
 329                 else
 330                         return -1;
 331         }
 332 }
 333
 334 int cg_run_nowait(const char *cgroup,
 335                   int (*fn)(const char *cgroup, void *arg),
 336                   void *arg)
 337 {
 338         int pid;
 339
 340         pid = fork();
 341         if (pid == 0) {
 342                 char buf[64];
 343
 344                 snprintf(buf, sizeof(buf), "%d", getpid());
 345                 if (cg_write(cgroup, "cgroup.procs", buf))
 346                         exit(EXIT_FAILURE);
 347                 exit(fn(cgroup, arg));
 348         }
 349
 350         return pid;
 351 }
 352
 353 int get_temp_fd(void)
 354 {
 355         return open(".", O_TMPFILE | O_RDWR | O_EXCL);
 356 }
 357
 358 int alloc_pagecache(int fd, size_t size)
 359 {
 360         char buf[PAGE_SIZE];
 361         struct stat st;
 362         int i;
 363
 364         if (fstat(fd, &st))
 365                 goto cleanup;
 366
 367         size += st.st_size;
 368
 369         if (ftruncate(fd, size))
 370                 goto cleanup;
 371
 372         for (i = 0; i < size; i += sizeof(buf))
 373                 read(fd, buf, sizeof(buf));
 374
 375         return 0;
 376
 377 cleanup:
 378         return -1;
 379 }
 380
 381 int alloc_anon(const char *cgroup, void *arg)
 382 {
 383         size_t size = (unsigned long)arg;
 384         char *buf, *ptr;
 385
 386         buf = malloc(size);
 387         for (ptr = buf; ptr < buf + size; ptr += PAGE_SIZE)
 388                 *ptr = 0;
 389
 390         free(buf);
 391         return 0;
 392 }
 393
 394 int is_swap_enabled(void)
 395 {
 396         char buf[PAGE_SIZE];
 397         const char delim[] = "\n";
 398         int cnt = 0;
 399         char *line;
 400
 401         if (read_text("/proc/swaps", buf, sizeof(buf)) <= 0)
 402                 return -1;
 403
 404         for (line = strtok(buf, delim); line; line = strtok(NULL, delim))
 405                 cnt++;
 406
 407         return cnt > 1;
 408 }
 409
 410 int set_oom_adj_score(int pid, int score)
 411 {
 412         char path[PATH_MAX];
 413         int fd, len;
 414
 415         sprintf(path, "/proc/%d/oom_score_adj", pid);
 416
 417         fd = open(path, O_WRONLY | O_APPEND);
 418         if (fd < 0)
 419                 return fd;
 420
 421         len = dprintf(fd, "%d", score);
 422         if (len < 0) {
 423                 close(fd);
 424                 return len;
 425         }
 426
 427         close(fd);
 428         return 0;
 429 }
 430
 431 ssize_t proc_read_text(int pid, bool thread, const char *item, char *buf, size_t size)
 432 {
 433         char path[PATH_MAX];
 434
 435         if (!pid)
 436                 snprintf(path, sizeof(path), "/proc/%s/%s",
 437                          thread ? "thread-self" : "self", item);
 438         else
 439                 snprintf(path, sizeof(path), "/proc/%d/%s", pid, item);
 440
 441         return read_text(path, buf, size);
 442 }
 443
 444 int proc_read_strstr(int pid, bool thread, const char *item, const char *needle)
 445 {
 446         char buf[PAGE_SIZE];
 447
 448         if (proc_read_text(pid, thread, item, buf, sizeof(buf)) < 0)
 449                 return -1;
 450
 451         return strstr(buf, needle) ? 0 : -1;
 452 }