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 int cg_write(const char *cgroup, const char *control, char *buf) 162 { 163 char path[PATH_MAX]; 164 ssize_t len = strlen(buf); 165 166 snprintf(path, sizeof(path), "%s/%s", cgroup, control); 167 168 if (write_text(path, buf, len) == len) 169 return 0; 170 171 return -1; 172 } 173 174 int cg_find_unified_root(char *root, size_t len) 175 { 176 char buf[10 * PAGE_SIZE]; 177 char *fs, *mount, *type; 178 const char delim[] = "\n\t "; 179 180 if (read_text("/proc/self/mounts", buf, sizeof(buf)) <= 0) 181 return -1; 182 183 /* 184 * Example: 185 * cgroup /sys/fs/cgroup cgroup2 rw,seclabel,noexec,relatime 0 0 186 */ 187 for (fs = strtok(buf, delim); fs; fs = strtok(NULL, delim)) { 188 mount = strtok(NULL, delim); 189 type = strtok(NULL, delim); 190 strtok(NULL, delim); 191 strtok(NULL, delim); 192 strtok(NULL, delim); 193 194 if (strcmp(type, "cgroup2") == 0) { 195 strncpy(root, mount, len); 196 return 0; 197 } 198 } 199 200 return -1; 201 } 202 203 int cg_create(const char *cgroup) 204 { 205 return mkdir(cgroup, 0644); 206 } 207 208 int cg_wait_for_proc_count(const char *cgroup, int count) 209 { 210 char buf[10 * PAGE_SIZE] = {0}; 211 int attempts; 212 char *ptr; 213 214 for (attempts = 10; attempts >= 0; attempts--) { 215 int nr = 0; 216 217 if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf))) 218 break; 219 220 for (ptr = buf; *ptr; ptr++) 221 if (*ptr == '\n') 222 nr++; 223 224 if (nr >= count) 225 return 0; 226 227 usleep(100000); 228 } 229 230 return -1; 231 } 232 233 int cg_killall(const char *cgroup) 234 { 235 char buf[PAGE_SIZE]; 236 char *ptr = buf; 237 238 if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf))) 239 return -1; 240 241 while (ptr < buf + sizeof(buf)) { 242 int pid = strtol(ptr, &ptr, 10); 243 244 if (pid == 0) 245 break; 246 if (*ptr) 247 ptr++; 248 else 249 break; 250 if (kill(pid, SIGKILL)) 251 return -1; 252 } 253 254 return 0; 255 } 256 257 int cg_destroy(const char *cgroup) 258 { 259 int ret; 260 261 retry: 262 ret = rmdir(cgroup); 263 if (ret && errno == EBUSY) { 264 cg_killall(cgroup); 265 usleep(100); 266 goto retry; 267 } 268 269 if (ret && errno == ENOENT) 270 ret = 0; 271 272 return ret; 273 } 274 275 int cg_enter(const char *cgroup, int pid) 276 { 277 char pidbuf[64]; 278 279 snprintf(pidbuf, sizeof(pidbuf), "%d", pid); 280 return cg_write(cgroup, "cgroup.procs", pidbuf); 281 } 282 283 int cg_enter_current(const char *cgroup) 284 { 285 return cg_write(cgroup, "cgroup.procs", "0"); 286 } 287 288 int cg_enter_current_thread(const char *cgroup) 289 { 290 return cg_write(cgroup, "cgroup.threads", "0"); 291 } 292 293 int cg_run(const char *cgroup, 294 int (*fn)(const char *cgroup, void *arg), 295 void *arg) 296 { 297 int pid, retcode; 298 299 pid = fork(); 300 if (pid < 0) { 301 return pid; 302 } else if (pid == 0) { 303 char buf[64]; 304 305 snprintf(buf, sizeof(buf), "%d", getpid()); 306 if (cg_write(cgroup, "cgroup.procs", buf)) 307 exit(EXIT_FAILURE); 308 exit(fn(cgroup, arg)); 309 } else { 310 waitpid(pid, &retcode, 0); 311 if (WIFEXITED(retcode)) 312 return WEXITSTATUS(retcode); 313 else 314 return -1; 315 } 316 } 317 318 int cg_run_nowait(const char *cgroup, 319 int (*fn)(const char *cgroup, void *arg), 320 void *arg) 321 { 322 int pid; 323 324 pid = fork(); 325 if (pid == 0) { 326 char buf[64]; 327 328 snprintf(buf, sizeof(buf), "%d", getpid()); 329 if (cg_write(cgroup, "cgroup.procs", buf)) 330 exit(EXIT_FAILURE); 331 exit(fn(cgroup, arg)); 332 } 333 334 return pid; 335 } 336 337 int get_temp_fd(void) 338 { 339 return open(".", O_TMPFILE | O_RDWR | O_EXCL); 340 } 341 342 int alloc_pagecache(int fd, size_t size) 343 { 344 char buf[PAGE_SIZE]; 345 struct stat st; 346 int i; 347 348 if (fstat(fd, &st)) 349 goto cleanup; 350 351 size += st.st_size; 352 353 if (ftruncate(fd, size)) 354 goto cleanup; 355 356 for (i = 0; i < size; i += sizeof(buf)) 357 read(fd, buf, sizeof(buf)); 358 359 return 0; 360 361 cleanup: 362 return -1; 363 } 364 365 int alloc_anon(const char *cgroup, void *arg) 366 { 367 size_t size = (unsigned long)arg; 368 char *buf, *ptr; 369 370 buf = malloc(size); 371 for (ptr = buf; ptr < buf + size; ptr += PAGE_SIZE) 372 *ptr = 0; 373 374 free(buf); 375 return 0; 376 } 377 378 int is_swap_enabled(void) 379 { 380 char buf[PAGE_SIZE]; 381 const char delim[] = "\n"; 382 int cnt = 0; 383 char *line; 384 385 if (read_text("/proc/swaps", buf, sizeof(buf)) <= 0) 386 return -1; 387 388 for (line = strtok(buf, delim); line; line = strtok(NULL, delim)) 389 cnt++; 390 391 return cnt > 1; 392 } 393 394 int set_oom_adj_score(int pid, int score) 395 { 396 char path[PATH_MAX]; 397 int fd, len; 398 399 sprintf(path, "/proc/%d/oom_score_adj", pid); 400 401 fd = open(path, O_WRONLY | O_APPEND); 402 if (fd < 0) 403 return fd; 404 405 len = dprintf(fd, "%d", score); 406 if (len < 0) { 407 close(fd); 408 return len; 409 } 410 411 close(fd); 412 return 0; 413 } 414 415 ssize_t proc_read_text(int pid, bool thread, const char *item, char *buf, size_t size) 416 { 417 char path[PATH_MAX]; 418 419 if (!pid) 420 snprintf(path, sizeof(path), "/proc/%s/%s", 421 thread ? "thread-self" : "self", item); 422 else 423 snprintf(path, sizeof(path), "/proc/%d/%s", pid, item); 424 425 return read_text(path, buf, size); 426 } 427