?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
udev: String substitutions can be done in ENV, too
[systemd_ALT.git] / src / basic / cgroup-util.c
blob21e2255daed511a040a5189cb493e699332fef19
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <errno.h>
4 #include <limits.h>
5 #include <signal.h>
6 #include <stddef.h>
7 #include <stdlib.h>
8 #include <sys/types.h>
9 #include <sys/utsname.h>
10 #include <sys/xattr.h>
11 #include <unistd.h>
12
13 #include "alloc-util.h"
14 #include "cgroup-util.h"
15 #include "constants.h"
16 #include "dirent-util.h"
17 #include "extract-word.h"
18 #include "fd-util.h"
19 #include "fileio.h"
20 #include "format-util.h"
21 #include "fs-util.h"
22 #include "log.h"
23 #include "login-util.h"
24 #include "macro.h"
25 #include "missing_magic.h"
26 #include "missing_threads.h"
27 #include "mkdir.h"
28 #include "parse-util.h"
29 #include "path-util.h"
30 #include "process-util.h"
31 #include "set.h"
32 #include "special.h"
33 #include "stat-util.h"
34 #include "stdio-util.h"
35 #include "string-table.h"
36 #include "string-util.h"
37 #include "strv.h"
38 #include "unit-name.h"
39 #include "user-util.h"
40 #include "xattr-util.h"
41
42 static int cg_enumerate_items(const char *controller, const char *path, FILE **_f, const char *item) {
43 _cleanup_free_ char *fs = NULL;
44 FILE *f;
45 int r;
46
47 assert(_f);
48
49 r = cg_get_path(controller, path, item, &fs);
50 if (r < 0)
51 return r;
52
53 f = fopen(fs, "re");
54 if (!f)
55 return -errno;
56
57 *_f = f;
58 return 0;
59 }
60
61 int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {
62 return cg_enumerate_items(controller, path, _f, "cgroup.procs");
63 }
64
65 int cg_read_pid(FILE *f, pid_t *_pid) {
66 unsigned long ul;
67
68 /* Note that the cgroup.procs might contain duplicates! See
69 * cgroups.txt for details. */
70
71 assert(f);
72 assert(_pid);
73
74 errno = 0;
75 if (fscanf(f, "%lu", &ul) != 1) {
76
77 if (feof(f))
78 return 0;
79
80 return errno_or_else(EIO);
81 }
82
83 if (ul <= 0)
84 return -EIO;
85
86 *_pid = (pid_t) ul;
87 return 1;
88 }
89
90 int cg_read_event(
91 const char *controller,
92 const char *path,
93 const char *event,
94 char **ret) {
95
96 _cleanup_free_ char *events = NULL, *content = NULL;
97 int r;
98
99 r = cg_get_path(controller, path, "cgroup.events", &events);
100 if (r < 0)
101 return r;
102
103 r = read_full_virtual_file(events, &content, NULL);
104 if (r < 0)
105 return r;
106
107 for (const char *p = content;;) {
108 _cleanup_free_ char *line = NULL, *key = NULL, *val = NULL;
109 const char *q;
110
111 r = extract_first_word(&p, &line, "\n", 0);
112 if (r < 0)
113 return r;
114 if (r == 0)
115 return -ENOENT;
116
117 q = line;
118 r = extract_first_word(&q, &key, " ", 0);
119 if (r < 0)
120 return r;
121 if (r == 0)
122 return -EINVAL;
123
124 if (!streq(key, event))
125 continue;
126
127 val = strdup(q);
128 if (!val)
129 return -ENOMEM;
130
131 *ret = TAKE_PTR(val);
132 return 0;
133 }
134 }
135
136 bool cg_ns_supported(void) {
137 static thread_local int enabled = -1;
138
139 if (enabled >= 0)
140 return enabled;
141
142 if (access("/proc/self/ns/cgroup", F_OK) < 0) {
143 if (errno != ENOENT)
144 log_debug_errno(errno, "Failed to check whether /proc/self/ns/cgroup is available, assuming not: %m");
145 enabled = false;
146 } else
147 enabled = true;
148
149 return enabled;
150 }
151
152 bool cg_freezer_supported(void) {
153 static thread_local int supported = -1;
154
155 if (supported >= 0)
156 return supported;
157
158 supported = cg_all_unified() > 0 && access("/sys/fs/cgroup/init.scope/cgroup.freeze", F_OK) == 0;
159
160 return supported;
161 }
162
163 bool cg_kill_supported(void) {
164 static thread_local int supported = -1;
165
166 if (supported >= 0)
167 return supported;
168
169 if (cg_all_unified() <= 0)
170 supported = false;
171 else if (access("/sys/fs/cgroup/init.scope/cgroup.kill", F_OK) < 0) {
172 if (errno != ENOENT)
173 log_debug_errno(errno, "Failed to check if cgroup.kill is available, assuming not: %m");
174 supported = false;
175 } else
176 supported = true;
177
178 return supported;
179 }
180
181 int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {
182 _cleanup_free_ char *fs = NULL;
183 int r;
184 DIR *d;
185
186 assert(_d);
187
188 /* This is not recursive! */
189
190 r = cg_get_path(controller, path, NULL, &fs);
191 if (r < 0)
192 return r;
193
194 d = opendir(fs);
195 if (!d)
196 return -errno;
197
198 *_d = d;
199 return 0;
200 }
201
202 int cg_read_subgroup(DIR *d, char **fn) {
203 assert(d);
204 assert(fn);
205
206 FOREACH_DIRENT_ALL(de, d, return -errno) {
207 char *b;
208
209 if (de->d_type != DT_DIR)
210 continue;
211
212 if (dot_or_dot_dot(de->d_name))
213 continue;
214
215 b = strdup(de->d_name);
216 if (!b)
217 return -ENOMEM;
218
219 *fn = b;
220 return 1;
221 }
222
223 return 0;
224 }
225
226 int cg_rmdir(const char *controller, const char *path) {
227 _cleanup_free_ char *p = NULL;
228 int r;
229
230 r = cg_get_path(controller, path, NULL, &p);
231 if (r < 0)
232 return r;
233
234 r = rmdir(p);
235 if (r < 0 && errno != ENOENT)
236 return -errno;
237
238 r = cg_hybrid_unified();
239 if (r <= 0)
240 return r;
241
242 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
243 r = cg_rmdir(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path);
244 if (r < 0)
245 log_warning_errno(r, "Failed to remove compat systemd cgroup %s: %m", path);
246 }
247
248 return 0;
249 }
250
251 static int cg_kill_items(
252 const char *controller,
253 const char *path,
254 int sig,
255 CGroupFlags flags,
256 Set *s,
257 cg_kill_log_func_t log_kill,
258 void *userdata,
259 const char *item) {
260
261 _cleanup_set_free_ Set *allocated_set = NULL;
262 bool done = false;
263 int r, ret = 0, ret_log_kill = 0;
264 pid_t my_pid;
265
266 assert(sig >= 0);
267
268 /* Don't send SIGCONT twice. Also, SIGKILL always works even when process is suspended, hence don't send
269 * SIGCONT on SIGKILL. */
270 if (IN_SET(sig, SIGCONT, SIGKILL))
271 flags &= ~CGROUP_SIGCONT;
272
273 /* This goes through the tasks list and kills them all. This
274 * is repeated until no further processes are added to the
275 * tasks list, to properly handle forking processes */
276
277 if (!s) {
278 s = allocated_set = set_new(NULL);
279 if (!s)
280 return -ENOMEM;
281 }
282
283 my_pid = getpid_cached();
284
285 do {
286 _cleanup_fclose_ FILE *f = NULL;
287 pid_t pid = 0;
288 done = true;
289
290 r = cg_enumerate_items(controller, path, &f, item);
291 if (r < 0) {
292 if (ret >= 0 && r != -ENOENT)
293 return r;
294
295 return ret;
296 }
297
298 while ((r = cg_read_pid(f, &pid)) > 0) {
299
300 if ((flags & CGROUP_IGNORE_SELF) && pid == my_pid)
301 continue;
302
303 if (set_get(s, PID_TO_PTR(pid)) == PID_TO_PTR(pid))
304 continue;
305
306 if (log_kill)
307 ret_log_kill = log_kill(pid, sig, userdata);
308
309 /* If we haven't killed this process yet, kill
310 * it */
311 if (kill(pid, sig) < 0) {
312 if (ret >= 0 && errno != ESRCH)
313 ret = -errno;
314 } else {
315 if (flags & CGROUP_SIGCONT)
316 (void) kill(pid, SIGCONT);
317
318 if (ret == 0) {
319 if (log_kill)
320 ret = ret_log_kill;
321 else
322 ret = 1;
323 }
324 }
325
326 done = false;
327
328 r = set_put(s, PID_TO_PTR(pid));
329 if (r < 0) {
330 if (ret >= 0)
331 return r;
332
333 return ret;
334 }
335 }
336
337 if (r < 0) {
338 if (ret >= 0)
339 return r;
340
341 return ret;
342 }
343
344 /* To avoid racing against processes which fork
345 * quicker than we can kill them we repeat this until
346 * no new pids need to be killed. */
347
348 } while (!done);
349
350 return ret;
351 }
352
353 int cg_kill(
354 const char *controller,
355 const char *path,
356 int sig,
357 CGroupFlags flags,
358 Set *s,
359 cg_kill_log_func_t log_kill,
360 void *userdata) {
361
362 int r, ret;
363
364 r = cg_kill_items(controller, path, sig, flags, s, log_kill, userdata, "cgroup.procs");
365 if (r < 0 || sig != SIGKILL)
366 return r;
367
368 ret = r;
369
370 /* Only in case of killing with SIGKILL and when using cgroupsv2, kill remaining threads manually as
371 a workaround for kernel bug. It was fixed in 5.2-rc5 (c03cd7738a83), backported to 4.19.66
372 (4340d175b898) and 4.14.138 (feb6b123b7dd). */
373 r = cg_unified_controller(controller);
374 if (r < 0)
375 return r;
376 if (r == 0)
377 return ret;
378
379 r = cg_kill_items(controller, path, sig, flags, s, log_kill, userdata, "cgroup.threads");
380 if (r < 0)
381 return r;
382
383 return r > 0 || ret > 0;
384 }
385
386 int cg_kill_kernel_sigkill(const char *controller, const char *path) {
387 /* Kills the cgroup at `path` directly by writing to its cgroup.kill file.
388 * This sends SIGKILL to all processes in the cgroup and has the advantage of
389 * being completely atomic, unlike cg_kill_items. */
390 int r;
391 _cleanup_free_ char *killfile = NULL;
392
393 assert(path);
394
395 if (!cg_kill_supported())
396 return -EOPNOTSUPP;
397
398 r = cg_get_path(controller, path, "cgroup.kill", &killfile);
399 if (r < 0)
400 return r;
401
402 r = write_string_file(killfile, "1", WRITE_STRING_FILE_DISABLE_BUFFER);
403 if (r < 0)
404 return r;
405
406 return 0;
407 }
408
409 int cg_kill_recursive(
410 const char *controller,
411 const char *path,
412 int sig,
413 CGroupFlags flags,
414 Set *s,
415 cg_kill_log_func_t log_kill,
416 void *userdata) {
417
418 _cleanup_set_free_ Set *allocated_set = NULL;
419 _cleanup_closedir_ DIR *d = NULL;
420 int r, ret;
421 char *fn;
422
423 assert(path);
424 assert(sig >= 0);
425
426 if (sig == SIGKILL && cg_kill_supported() &&
427 !FLAGS_SET(flags, CGROUP_IGNORE_SELF) && !s && !log_kill) {
428 /* ignore CGROUP_SIGCONT, since this is a no-op alongside SIGKILL */
429 ret = cg_kill_kernel_sigkill(controller, path);
430 if (ret < 0)
431 return ret;
432 } else {
433 if (!s) {
434 s = allocated_set = set_new(NULL);
435 if (!s)
436 return -ENOMEM;
437 }
438
439 ret = cg_kill(controller, path, sig, flags, s, log_kill, userdata);
440
441 r = cg_enumerate_subgroups(controller, path, &d);
442 if (r < 0) {
443 if (ret >= 0 && r != -ENOENT)
444 return r;
445
446 return ret;
447 }
448
449 while ((r = cg_read_subgroup(d, &fn)) > 0) {
450 _cleanup_free_ char *p = NULL;
451
452 p = path_join(empty_to_root(path), fn);
453 free(fn);
454 if (!p)
455 return -ENOMEM;
456
457 r = cg_kill_recursive(controller, p, sig, flags, s, log_kill, userdata);
458 if (r != 0 && ret >= 0)
459 ret = r;
460 }
461 if (ret >= 0 && r < 0)
462 ret = r;
463 }
464
465 if (FLAGS_SET(flags, CGROUP_REMOVE)) {
466 r = cg_rmdir(controller, path);
467 if (r < 0 && ret >= 0 && !IN_SET(r, -ENOENT, -EBUSY))
468 return r;
469 }
470
471 return ret;
472 }
473
474 static const char *controller_to_dirname(const char *controller) {
475 assert(controller);
476
477 /* Converts a controller name to the directory name below /sys/fs/cgroup/ we want to mount it
478 * to. Effectively, this just cuts off the name= prefixed used for named hierarchies, if it is
479 * specified. */
480
481 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
482 if (cg_hybrid_unified() > 0)
483 controller = SYSTEMD_CGROUP_CONTROLLER_HYBRID;
484 else
485 controller = SYSTEMD_CGROUP_CONTROLLER_LEGACY;
486 }
487
488 return startswith(controller, "name=") ?: controller;
489 }
490
491 static int join_path_legacy(const char *controller, const char *path, const char *suffix, char **ret) {
492 const char *dn;
493 char *t = NULL;
494
495 assert(ret);
496 assert(controller);
497
498 dn = controller_to_dirname(controller);
499
500 if (isempty(path) && isempty(suffix))
501 t = path_join("/sys/fs/cgroup", dn);
502 else if (isempty(path))
503 t = path_join("/sys/fs/cgroup", dn, suffix);
504 else if (isempty(suffix))
505 t = path_join("/sys/fs/cgroup", dn, path);
506 else
507 t = path_join("/sys/fs/cgroup", dn, path, suffix);
508 if (!t)
509 return -ENOMEM;
510
511 *ret = t;
512 return 0;
513 }
514
515 static int join_path_unified(const char *path, const char *suffix, char **ret) {
516 char *t;
517
518 assert(ret);
519
520 if (isempty(path) && isempty(suffix))
521 t = strdup("/sys/fs/cgroup");
522 else if (isempty(path))
523 t = path_join("/sys/fs/cgroup", suffix);
524 else if (isempty(suffix))
525 t = path_join("/sys/fs/cgroup", path);
526 else
527 t = path_join("/sys/fs/cgroup", path, suffix);
528 if (!t)
529 return -ENOMEM;
530
531 *ret = t;
532 return 0;
533 }
534
535 int cg_get_path(const char *controller, const char *path, const char *suffix, char **ret) {
536 int r;
537
538 assert(ret);
539
540 if (!controller) {
541 char *t;
542
543 /* If no controller is specified, we return the path *below* the controllers, without any
544 * prefix. */
545
546 if (isempty(path) && isempty(suffix))
547 return -EINVAL;
548
549 if (isempty(suffix))
550 t = strdup(path);
551 else if (isempty(path))
552 t = strdup(suffix);
553 else
554 t = path_join(path, suffix);
555 if (!t)
556 return -ENOMEM;
557
558 *ret = path_simplify(t);
559 return 0;
560 }
561
562 if (!cg_controller_is_valid(controller))
563 return -EINVAL;
564
565 r = cg_all_unified();
566 if (r < 0)
567 return r;
568 if (r > 0)
569 r = join_path_unified(path, suffix, ret);
570 else
571 r = join_path_legacy(controller, path, suffix, ret);
572 if (r < 0)
573 return r;
574
575 path_simplify(*ret);
576 return 0;
577 }
578
579 static int controller_is_v1_accessible(const char *root, const char *controller) {
580 const char *cpath, *dn;
581
582 assert(controller);
583
584 dn = controller_to_dirname(controller);
585
586 /* If root if specified, we check that:
587 * - possible subcgroup is created at root,
588 * - we can modify the hierarchy. */
589
590 cpath = strjoina("/sys/fs/cgroup/", dn, root, root ? "/cgroup.procs" : NULL);
591 return laccess(cpath, root ? W_OK : F_OK);
592 }
593
594 int cg_get_path_and_check(const char *controller, const char *path, const char *suffix, char **fs) {
595 int r;
596
597 assert(controller);
598 assert(fs);
599
600 if (!cg_controller_is_valid(controller))
601 return -EINVAL;
602
603 r = cg_all_unified();
604 if (r < 0)
605 return r;
606 if (r > 0) {
607 /* In the unified hierarchy all controllers are considered accessible,
608 * except for the named hierarchies */
609 if (startswith(controller, "name="))
610 return -EOPNOTSUPP;
611 } else {
612 /* Check if the specified controller is actually accessible */
613 r = controller_is_v1_accessible(NULL, controller);
614 if (r < 0)
615 return r;
616 }
617
618 return cg_get_path(controller, path, suffix, fs);
619 }
620
621 int cg_set_xattr(const char *controller, const char *path, const char *name, const void *value, size_t size, int flags) {
622 _cleanup_free_ char *fs = NULL;
623 int r;
624
625 assert(path);
626 assert(name);
627 assert(value || size <= 0);
628
629 r = cg_get_path(controller, path, NULL, &fs);
630 if (r < 0)
631 return r;
632
633 return RET_NERRNO(setxattr(fs, name, value, size, flags));
634 }
635
636 int cg_get_xattr(const char *controller, const char *path, const char *name, void *value, size_t size) {
637 _cleanup_free_ char *fs = NULL;
638 ssize_t n;
639 int r;
640
641 assert(path);
642 assert(name);
643
644 r = cg_get_path(controller, path, NULL, &fs);
645 if (r < 0)
646 return r;
647
648 n = getxattr(fs, name, value, size);
649 if (n < 0)
650 return -errno;
651
652 return (int) n;
653 }
654
655 int cg_get_xattr_malloc(const char *controller, const char *path, const char *name, char **ret) {
656 _cleanup_free_ char *fs = NULL;
657 int r;
658
659 assert(path);
660 assert(name);
661
662 r = cg_get_path(controller, path, NULL, &fs);
663 if (r < 0)
664 return r;
665
666 r = lgetxattr_malloc(fs, name, ret);
667 if (r < 0)
668 return r;
669
670 return r;
671 }
672
673 int cg_get_xattr_bool(const char *controller, const char *path, const char *name) {
674 _cleanup_free_ char *val = NULL;
675 int r;
676
677 assert(path);
678 assert(name);
679
680 r = cg_get_xattr_malloc(controller, path, name, &val);
681 if (r < 0)
682 return r;
683
684 return parse_boolean(val);
685 }
686
687 int cg_remove_xattr(const char *controller, const char *path, const char *name) {
688 _cleanup_free_ char *fs = NULL;
689 int r;
690
691 assert(path);
692 assert(name);
693
694 r = cg_get_path(controller, path, NULL, &fs);
695 if (r < 0)
696 return r;
697
698 return RET_NERRNO(removexattr(fs, name));
699 }
700
701 int cg_pid_get_path(const char *controller, pid_t pid, char **ret_path) {
702 _cleanup_fclose_ FILE *f = NULL;
703 const char *fs, *controller_str = NULL; /* avoid false maybe-uninitialized warning */
704 int unified, r;
705
706 assert(pid >= 0);
707 assert(ret_path);
708
709 if (controller) {
710 if (!cg_controller_is_valid(controller))
711 return -EINVAL;
712 } else
713 controller = SYSTEMD_CGROUP_CONTROLLER;
714
715 unified = cg_unified_controller(controller);
716 if (unified < 0)
717 return unified;
718 if (unified == 0) {
719 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
720 controller_str = SYSTEMD_CGROUP_CONTROLLER_LEGACY;
721 else
722 controller_str = controller;
723 }
724
725 fs = procfs_file_alloca(pid, "cgroup");
726 r = fopen_unlocked(fs, "re", &f);
727 if (r == -ENOENT)
728 return -ESRCH;
729 if (r < 0)
730 return r;
731
732 for (;;) {
733 _cleanup_free_ char *line = NULL;
734 char *e;
735
736 r = read_line(f, LONG_LINE_MAX, &line);
737 if (r < 0)
738 return r;
739 if (r == 0)
740 return -ENODATA;
741
742 if (unified) {
743 e = startswith(line, "0:");
744 if (!e)
745 continue;
746
747 e = strchr(e, ':');
748 if (!e)
749 continue;
750 } else {
751 char *l;
752
753 l = strchr(line, ':');
754 if (!l)
755 continue;
756
757 l++;
758 e = strchr(l, ':');
759 if (!e)
760 continue;
761 *e = 0;
762
763 assert(controller_str);
764 r = string_contains_word(l, ",", controller_str);
765 if (r < 0)
766 return r;
767 if (r == 0)
768 continue;
769 }
770
771 char *path = strdup(e + 1);
772 if (!path)
773 return -ENOMEM;
774
775 /* Truncate suffix indicating the process is a zombie */
776 e = endswith(path, " (deleted)");
777 if (e)
778 *e = 0;
779
780 *ret_path = path;
781 return 0;
782 }
783 }
784
785 int cg_install_release_agent(const char *controller, const char *agent) {
786 _cleanup_free_ char *fs = NULL, *contents = NULL;
787 const char *sc;
788 int r;
789
790 assert(agent);
791
792 r = cg_unified_controller(controller);
793 if (r < 0)
794 return r;
795 if (r > 0) /* doesn't apply to unified hierarchy */
796 return -EOPNOTSUPP;
797
798 r = cg_get_path(controller, NULL, "release_agent", &fs);
799 if (r < 0)
800 return r;
801
802 r = read_one_line_file(fs, &contents);
803 if (r < 0)
804 return r;
805
806 sc = strstrip(contents);
807 if (isempty(sc)) {
808 r = write_string_file(fs, agent, WRITE_STRING_FILE_DISABLE_BUFFER);
809 if (r < 0)
810 return r;
811 } else if (!path_equal(sc, agent))
812 return -EEXIST;
813
814 fs = mfree(fs);
815 r = cg_get_path(controller, NULL, "notify_on_release", &fs);
816 if (r < 0)
817 return r;
818
819 contents = mfree(contents);
820 r = read_one_line_file(fs, &contents);
821 if (r < 0)
822 return r;
823
824 sc = strstrip(contents);
825 if (streq(sc, "0")) {
826 r = write_string_file(fs, "1", WRITE_STRING_FILE_DISABLE_BUFFER);
827 if (r < 0)
828 return r;
829
830 return 1;
831 }
832
833 if (!streq(sc, "1"))
834 return -EIO;
835
836 return 0;
837 }
838
839 int cg_uninstall_release_agent(const char *controller) {
840 _cleanup_free_ char *fs = NULL;
841 int r;
842
843 r = cg_unified_controller(controller);
844 if (r < 0)
845 return r;
846 if (r > 0) /* Doesn't apply to unified hierarchy */
847 return -EOPNOTSUPP;
848
849 r = cg_get_path(controller, NULL, "notify_on_release", &fs);
850 if (r < 0)
851 return r;
852
853 r = write_string_file(fs, "0", WRITE_STRING_FILE_DISABLE_BUFFER);
854 if (r < 0)
855 return r;
856
857 fs = mfree(fs);
858
859 r = cg_get_path(controller, NULL, "release_agent", &fs);
860 if (r < 0)
861 return r;
862
863 r = write_string_file(fs, "", WRITE_STRING_FILE_DISABLE_BUFFER);
864 if (r < 0)
865 return r;
866
867 return 0;
868 }
869
870 int cg_is_empty(const char *controller, const char *path) {
871 _cleanup_fclose_ FILE *f = NULL;
872 pid_t pid;
873 int r;
874
875 assert(path);
876
877 r = cg_enumerate_processes(controller, path, &f);
878 if (r == -ENOENT)
879 return true;
880 if (r < 0)
881 return r;
882
883 r = cg_read_pid(f, &pid);
884 if (r < 0)
885 return r;
886
887 return r == 0;
888 }
889
890 int cg_is_empty_recursive(const char *controller, const char *path) {
891 int r;
892
893 assert(path);
894
895 /* The root cgroup is always populated */
896 if (controller && empty_or_root(path))
897 return false;
898
899 r = cg_unified_controller(controller);
900 if (r < 0)
901 return r;
902 if (r > 0) {
903 _cleanup_free_ char *t = NULL;
904
905 /* On the unified hierarchy we can check empty state
906 * via the "populated" attribute of "cgroup.events". */
907
908 r = cg_read_event(controller, path, "populated", &t);
909 if (r == -ENOENT)
910 return true;
911 if (r < 0)
912 return r;
913
914 return streq(t, "0");
915 } else {
916 _cleanup_closedir_ DIR *d = NULL;
917 char *fn;
918
919 r = cg_is_empty(controller, path);
920 if (r <= 0)
921 return r;
922
923 r = cg_enumerate_subgroups(controller, path, &d);
924 if (r == -ENOENT)
925 return true;
926 if (r < 0)
927 return r;
928
929 while ((r = cg_read_subgroup(d, &fn)) > 0) {
930 _cleanup_free_ char *p = NULL;
931
932 p = path_join(path, fn);
933 free(fn);
934 if (!p)
935 return -ENOMEM;
936
937 r = cg_is_empty_recursive(controller, p);
938 if (r <= 0)
939 return r;
940 }
941 if (r < 0)
942 return r;
943
944 return true;
945 }
946 }
947
948 int cg_split_spec(const char *spec, char **ret_controller, char **ret_path) {
949 _cleanup_free_ char *controller = NULL, *path = NULL;
950
951 assert(spec);
952
953 if (*spec == '/') {
954 if (!path_is_normalized(spec))
955 return -EINVAL;
956
957 if (ret_path) {
958 path = strdup(spec);
959 if (!path)
960 return -ENOMEM;
961
962 path_simplify(path);
963 }
964
965 } else {
966 const char *e;
967
968 e = strchr(spec, ':');
969 if (e) {
970 controller = strndup(spec, e-spec);
971 if (!controller)
972 return -ENOMEM;
973 if (!cg_controller_is_valid(controller))
974 return -EINVAL;
975
976 if (!isempty(e + 1)) {
977 path = strdup(e+1);
978 if (!path)
979 return -ENOMEM;
980
981 if (!path_is_normalized(path) ||
982 !path_is_absolute(path))
983 return -EINVAL;
984
985 path_simplify(path);
986 }
987
988 } else {
989 if (!cg_controller_is_valid(spec))
990 return -EINVAL;
991
992 if (ret_controller) {
993 controller = strdup(spec);
994 if (!controller)
995 return -ENOMEM;
996 }
997 }
998 }
999
1000 if (ret_controller)
1001 *ret_controller = TAKE_PTR(controller);
1002 if (ret_path)
1003 *ret_path = TAKE_PTR(path);
1004 return 0;
1005 }
1006
1007 int cg_mangle_path(const char *path, char **result) {
1008 _cleanup_free_ char *c = NULL, *p = NULL;
1009 char *t;
1010 int r;
1011
1012 assert(path);
1013 assert(result);
1014
1015 /* First, check if it already is a filesystem path */
1016 if (path_startswith(path, "/sys/fs/cgroup")) {
1017
1018 t = strdup(path);
1019 if (!t)
1020 return -ENOMEM;
1021
1022 *result = path_simplify(t);
1023 return 0;
1024 }
1025
1026 /* Otherwise, treat it as cg spec */
1027 r = cg_split_spec(path, &c, &p);
1028 if (r < 0)
1029 return r;
1030
1031 return cg_get_path(c ?: SYSTEMD_CGROUP_CONTROLLER, p ?: "/", NULL, result);
1032 }
1033
1034 int cg_get_root_path(char **path) {
1035 char *p, *e;
1036 int r;
1037
1038 assert(path);
1039
1040 r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 1, &p);
1041 if (r < 0)
1042 return r;
1043
1044 e = endswith(p, "/" SPECIAL_INIT_SCOPE);
1045 if (!e)
1046 e = endswith(p, "/" SPECIAL_SYSTEM_SLICE); /* legacy */
1047 if (!e)
1048 e = endswith(p, "/system"); /* even more legacy */
1049 if (e)
1050 *e = 0;
1051
1052 *path = p;
1053 return 0;
1054 }
1055
1056 int cg_shift_path(const char *cgroup, const char *root, const char **shifted) {
1057 _cleanup_free_ char *rt = NULL;
1058 char *p;
1059 int r;
1060
1061 assert(cgroup);
1062 assert(shifted);
1063
1064 if (!root) {
1065 /* If the root was specified let's use that, otherwise
1066 * let's determine it from PID 1 */
1067
1068 r = cg_get_root_path(&rt);
1069 if (r < 0)
1070 return r;
1071
1072 root = rt;
1073 }
1074
1075 p = path_startswith(cgroup, root);
1076 if (p && p > cgroup)
1077 *shifted = p - 1;
1078 else
1079 *shifted = cgroup;
1080
1081 return 0;
1082 }
1083
1084 int cg_pid_get_path_shifted(pid_t pid, const char *root, char **cgroup) {
1085 _cleanup_free_ char *raw = NULL;
1086 const char *c;
1087 int r;
1088
1089 assert(pid >= 0);
1090 assert(cgroup);
1091
1092 r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &raw);
1093 if (r < 0)
1094 return r;
1095
1096 r = cg_shift_path(raw, root, &c);
1097 if (r < 0)
1098 return r;
1099
1100 if (c == raw)
1101 *cgroup = TAKE_PTR(raw);
1102 else {
1103 char *n;
1104
1105 n = strdup(c);
1106 if (!n)
1107 return -ENOMEM;
1108
1109 *cgroup = n;
1110 }
1111
1112 return 0;
1113 }
1114
1115 int cg_path_decode_unit(const char *cgroup, char **unit) {
1116 char *c, *s;
1117 size_t n;
1118
1119 assert(cgroup);
1120 assert(unit);
1121
1122 n = strcspn(cgroup, "/");
1123 if (n < 3)
1124 return -ENXIO;
1125
1126 c = strndupa_safe(cgroup, n);
1127 c = cg_unescape(c);
1128
1129 if (!unit_name_is_valid(c, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
1130 return -ENXIO;
1131
1132 s = strdup(c);
1133 if (!s)
1134 return -ENOMEM;
1135
1136 *unit = s;
1137 return 0;
1138 }
1139
1140 static bool valid_slice_name(const char *p, size_t n) {
1141
1142 if (!p)
1143 return false;
1144
1145 if (n < STRLEN("x.slice"))
1146 return false;
1147
1148 if (memcmp(p + n - 6, ".slice", 6) == 0) {
1149 char buf[n+1], *c;
1150
1151 memcpy(buf, p, n);
1152 buf[n] = 0;
1153
1154 c = cg_unescape(buf);
1155
1156 return unit_name_is_valid(c, UNIT_NAME_PLAIN);
1157 }
1158
1159 return false;
1160 }
1161
1162 static const char *skip_slices(const char *p) {
1163 assert(p);
1164
1165 /* Skips over all slice assignments */
1166
1167 for (;;) {
1168 size_t n;
1169
1170 p += strspn(p, "/");
1171
1172 n = strcspn(p, "/");
1173 if (!valid_slice_name(p, n))
1174 return p;
1175
1176 p += n;
1177 }
1178 }
1179
1180 int cg_path_get_unit(const char *path, char **ret) {
1181 _cleanup_free_ char *unit = NULL;
1182 const char *e;
1183 int r;
1184
1185 assert(path);
1186 assert(ret);
1187
1188 e = skip_slices(path);
1189
1190 r = cg_path_decode_unit(e, &unit);
1191 if (r < 0)
1192 return r;
1193
1194 /* We skipped over the slices, don't accept any now */
1195 if (endswith(unit, ".slice"))
1196 return -ENXIO;
1197
1198 *ret = TAKE_PTR(unit);
1199 return 0;
1200 }
1201
1202 int cg_path_get_unit_path(const char *path, char **ret) {
1203 _cleanup_free_ char *path_copy = NULL;
1204 char *unit_name;
1205
1206 assert(path);
1207 assert(ret);
1208
1209 path_copy = strdup(path);
1210 if (!path_copy)
1211 return -ENOMEM;
1212
1213 unit_name = (char *)skip_slices(path_copy);
1214 unit_name[strcspn(unit_name, "/")] = 0;
1215
1216 if (!unit_name_is_valid(cg_unescape(unit_name), UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
1217 return -ENXIO;
1218
1219 *ret = TAKE_PTR(path_copy);
1220
1221 return 0;
1222 }
1223
1224 int cg_pid_get_unit(pid_t pid, char **unit) {
1225 _cleanup_free_ char *cgroup = NULL;
1226 int r;
1227
1228 assert(unit);
1229
1230 r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1231 if (r < 0)
1232 return r;
1233
1234 return cg_path_get_unit(cgroup, unit);
1235 }
1236
1237 /**
1238 * Skip session-*.scope, but require it to be there.
1239 */
1240 static const char *skip_session(const char *p) {
1241 size_t n;
1242
1243 if (isempty(p))
1244 return NULL;
1245
1246 p += strspn(p, "/");
1247
1248 n = strcspn(p, "/");
1249 if (n < STRLEN("session-x.scope"))
1250 return NULL;
1251
1252 if (memcmp(p, "session-", 8) == 0 && memcmp(p + n - 6, ".scope", 6) == 0) {
1253 char buf[n - 8 - 6 + 1];
1254
1255 memcpy(buf, p + 8, n - 8 - 6);
1256 buf[n - 8 - 6] = 0;
1257
1258 /* Note that session scopes never need unescaping,
1259 * since they cannot conflict with the kernel's own
1260 * names, hence we don't need to call cg_unescape()
1261 * here. */
1262
1263 if (!session_id_valid(buf))
1264 return NULL;
1265
1266 p += n;
1267 p += strspn(p, "/");
1268 return p;
1269 }
1270
1271 return NULL;
1272 }
1273
1274 /**
1275 * Skip user@*.service, but require it to be there.
1276 */
1277 static const char *skip_user_manager(const char *p) {
1278 size_t n;
1279
1280 if (isempty(p))
1281 return NULL;
1282
1283 p += strspn(p, "/");
1284
1285 n = strcspn(p, "/");
1286 if (n < STRLEN("user@x.service"))
1287 return NULL;
1288
1289 if (memcmp(p, "user@", 5) == 0 && memcmp(p + n - 8, ".service", 8) == 0) {
1290 char buf[n - 5 - 8 + 1];
1291
1292 memcpy(buf, p + 5, n - 5 - 8);
1293 buf[n - 5 - 8] = 0;
1294
1295 /* Note that user manager services never need unescaping,
1296 * since they cannot conflict with the kernel's own
1297 * names, hence we don't need to call cg_unescape()
1298 * here. */
1299
1300 if (parse_uid(buf, NULL) < 0)
1301 return NULL;
1302
1303 p += n;
1304 p += strspn(p, "/");
1305
1306 return p;
1307 }
1308
1309 return NULL;
1310 }
1311
1312 static const char *skip_user_prefix(const char *path) {
1313 const char *e, *t;
1314
1315 assert(path);
1316
1317 /* Skip slices, if there are any */
1318 e = skip_slices(path);
1319
1320 /* Skip the user manager, if it's in the path now... */
1321 t = skip_user_manager(e);
1322 if (t)
1323 return t;
1324
1325 /* Alternatively skip the user session if it is in the path... */
1326 return skip_session(e);
1327 }
1328
1329 int cg_path_get_user_unit(const char *path, char **ret) {
1330 const char *t;
1331
1332 assert(path);
1333 assert(ret);
1334
1335 t = skip_user_prefix(path);
1336 if (!t)
1337 return -ENXIO;
1338
1339 /* And from here on it looks pretty much the same as for a system unit, hence let's use the same
1340 * parser. */
1341 return cg_path_get_unit(t, ret);
1342 }
1343
1344 int cg_pid_get_user_unit(pid_t pid, char **unit) {
1345 _cleanup_free_ char *cgroup = NULL;
1346 int r;
1347
1348 assert(unit);
1349
1350 r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1351 if (r < 0)
1352 return r;
1353
1354 return cg_path_get_user_unit(cgroup, unit);
1355 }
1356
1357 int cg_path_get_machine_name(const char *path, char **machine) {
1358 _cleanup_free_ char *u = NULL;
1359 const char *sl;
1360 int r;
1361
1362 r = cg_path_get_unit(path, &u);
1363 if (r < 0)
1364 return r;
1365
1366 sl = strjoina("/run/systemd/machines/unit:", u);
1367 return readlink_malloc(sl, machine);
1368 }
1369
1370 int cg_pid_get_machine_name(pid_t pid, char **machine) {
1371 _cleanup_free_ char *cgroup = NULL;
1372 int r;
1373
1374 assert(machine);
1375
1376 r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1377 if (r < 0)
1378 return r;
1379
1380 return cg_path_get_machine_name(cgroup, machine);
1381 }
1382
1383 int cg_path_get_cgroupid(const char *path, uint64_t *ret) {
1384 cg_file_handle fh = CG_FILE_HANDLE_INIT;
1385 int mnt_id = -1;
1386
1387 assert(path);
1388 assert(ret);
1389
1390 /* This is cgroupfs so we know the size of the handle, thus no need to loop around like
1391 * name_to_handle_at_loop() does in mountpoint-util.c */
1392 if (name_to_handle_at(AT_FDCWD, path, &fh.file_handle, &mnt_id, 0) < 0)
1393 return -errno;
1394
1395 *ret = CG_FILE_HANDLE_CGROUPID(fh);
1396 return 0;
1397 }
1398
1399 int cg_path_get_session(const char *path, char **session) {
1400 _cleanup_free_ char *unit = NULL;
1401 char *start, *end;
1402 int r;
1403
1404 assert(path);
1405
1406 r = cg_path_get_unit(path, &unit);
1407 if (r < 0)
1408 return r;
1409
1410 start = startswith(unit, "session-");
1411 if (!start)
1412 return -ENXIO;
1413 end = endswith(start, ".scope");
1414 if (!end)
1415 return -ENXIO;
1416
1417 *end = 0;
1418 if (!session_id_valid(start))
1419 return -ENXIO;
1420
1421 if (session) {
1422 char *rr;
1423
1424 rr = strdup(start);
1425 if (!rr)
1426 return -ENOMEM;
1427
1428 *session = rr;
1429 }
1430
1431 return 0;
1432 }
1433
1434 int cg_pid_get_session(pid_t pid, char **session) {
1435 _cleanup_free_ char *cgroup = NULL;
1436 int r;
1437
1438 r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1439 if (r < 0)
1440 return r;
1441
1442 return cg_path_get_session(cgroup, session);
1443 }
1444
1445 int cg_path_get_owner_uid(const char *path, uid_t *uid) {
1446 _cleanup_free_ char *slice = NULL;
1447 char *start, *end;
1448 int r;
1449
1450 assert(path);
1451
1452 r = cg_path_get_slice(path, &slice);
1453 if (r < 0)
1454 return r;
1455
1456 start = startswith(slice, "user-");
1457 if (!start)
1458 return -ENXIO;
1459 end = endswith(start, ".slice");
1460 if (!end)
1461 return -ENXIO;
1462
1463 *end = 0;
1464 if (parse_uid(start, uid) < 0)
1465 return -ENXIO;
1466
1467 return 0;
1468 }
1469
1470 int cg_pid_get_owner_uid(pid_t pid, uid_t *uid) {
1471 _cleanup_free_ char *cgroup = NULL;
1472 int r;
1473
1474 r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1475 if (r < 0)
1476 return r;
1477
1478 return cg_path_get_owner_uid(cgroup, uid);
1479 }
1480
1481 int cg_path_get_slice(const char *p, char **slice) {
1482 const char *e = NULL;
1483
1484 assert(p);
1485 assert(slice);
1486
1487 /* Finds the right-most slice unit from the beginning, but
1488 * stops before we come to the first non-slice unit. */
1489
1490 for (;;) {
1491 size_t n;
1492
1493 p += strspn(p, "/");
1494
1495 n = strcspn(p, "/");
1496 if (!valid_slice_name(p, n)) {
1497
1498 if (!e) {
1499 char *s;
1500
1501 s = strdup(SPECIAL_ROOT_SLICE);
1502 if (!s)
1503 return -ENOMEM;
1504
1505 *slice = s;
1506 return 0;
1507 }
1508
1509 return cg_path_decode_unit(e, slice);
1510 }
1511
1512 e = p;
1513 p += n;
1514 }
1515 }
1516
1517 int cg_pid_get_slice(pid_t pid, char **slice) {
1518 _cleanup_free_ char *cgroup = NULL;
1519 int r;
1520
1521 assert(slice);
1522
1523 r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1524 if (r < 0)
1525 return r;
1526
1527 return cg_path_get_slice(cgroup, slice);
1528 }
1529
1530 int cg_path_get_user_slice(const char *p, char **slice) {
1531 const char *t;
1532 assert(p);
1533 assert(slice);
1534
1535 t = skip_user_prefix(p);
1536 if (!t)
1537 return -ENXIO;
1538
1539 /* And now it looks pretty much the same as for a system
1540 * slice, so let's just use the same parser from here on. */
1541 return cg_path_get_slice(t, slice);
1542 }
1543
1544 int cg_pid_get_user_slice(pid_t pid, char **slice) {
1545 _cleanup_free_ char *cgroup = NULL;
1546 int r;
1547
1548 assert(slice);
1549
1550 r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1551 if (r < 0)
1552 return r;
1553
1554 return cg_path_get_user_slice(cgroup, slice);
1555 }
1556
1557 bool cg_needs_escape(const char *p) {
1558
1559 /* Checks if the specified path is a valid cgroup name by our rules, or if it must be escaped. Note
1560 * that we consider escaped cgroup names invalid here, as they need to be escaped a second time if
1561 * they shall be used. Also note that various names cannot be made valid by escaping even if we
1562 * return true here (because too long, or contain the forbidden character "/"). */
1563
1564 if (!filename_is_valid(p))
1565 return true;
1566
1567 if (IN_SET(p[0], '_', '.'))
1568 return true;
1569
1570 if (STR_IN_SET(p, "notify_on_release", "release_agent", "tasks"))
1571 return true;
1572
1573 if (startswith(p, "cgroup."))
1574 return true;
1575
1576 for (CGroupController c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1577 const char *q;
1578
1579 q = startswith(p, cgroup_controller_to_string(c));
1580 if (!q)
1581 continue;
1582
1583 if (q[0] == '.')
1584 return true;
1585 }
1586
1587 return false;
1588 }
1589
1590 int cg_escape(const char *p, char **ret) {
1591 _cleanup_free_ char *n = NULL;
1592
1593 /* This implements very minimal escaping for names to be used as file names in the cgroup tree: any
1594 * name which might conflict with a kernel name or is prefixed with '_' is prefixed with a '_'. That
1595 * way, when reading cgroup names it is sufficient to remove a single prefixing underscore if there
1596 * is one. */
1597
1598 /* The return value of this function (unlike cg_unescape()) needs free()! */
1599
1600 if (cg_needs_escape(p)) {
1601 n = strjoin("_", p);
1602 if (!n)
1603 return -ENOMEM;
1604
1605 if (!filename_is_valid(n)) /* became invalid due to the prefixing? Or contained things like a slash that cannot be fixed by prefixing? */
1606 return -EINVAL;
1607 } else {
1608 n = strdup(p);
1609 if (!n)
1610 return -ENOMEM;
1611 }
1612
1613 *ret = TAKE_PTR(n);
1614 return 0;
1615 }
1616
1617 char *cg_unescape(const char *p) {
1618 assert(p);
1619
1620 /* The return value of this function (unlike cg_escape())
1621 * doesn't need free()! */
1622
1623 if (p[0] == '_')
1624 return (char*) p+1;
1625
1626 return (char*) p;
1627 }
1628
1629 #define CONTROLLER_VALID \
1630 DIGITS LETTERS \
1631 "_"
1632
1633 bool cg_controller_is_valid(const char *p) {
1634 const char *t, *s;
1635
1636 if (!p)
1637 return false;
1638
1639 if (streq(p, SYSTEMD_CGROUP_CONTROLLER))
1640 return true;
1641
1642 s = startswith(p, "name=");
1643 if (s)
1644 p = s;
1645
1646 if (IN_SET(*p, 0, '_'))
1647 return false;
1648
1649 for (t = p; *t; t++)
1650 if (!strchr(CONTROLLER_VALID, *t))
1651 return false;
1652
1653 if (t - p > NAME_MAX)
1654 return false;
1655
1656 return true;
1657 }
1658
1659 int cg_slice_to_path(const char *unit, char **ret) {
1660 _cleanup_free_ char *p = NULL, *s = NULL, *e = NULL;
1661 const char *dash;
1662 int r;
1663
1664 assert(unit);
1665 assert(ret);
1666
1667 if (streq(unit, SPECIAL_ROOT_SLICE)) {
1668 char *x;
1669
1670 x = strdup("");
1671 if (!x)
1672 return -ENOMEM;
1673 *ret = x;
1674 return 0;
1675 }
1676
1677 if (!unit_name_is_valid(unit, UNIT_NAME_PLAIN))
1678 return -EINVAL;
1679
1680 if (!endswith(unit, ".slice"))
1681 return -EINVAL;
1682
1683 r = unit_name_to_prefix(unit, &p);
1684 if (r < 0)
1685 return r;
1686
1687 dash = strchr(p, '-');
1688
1689 /* Don't allow initial dashes */
1690 if (dash == p)
1691 return -EINVAL;
1692
1693 while (dash) {
1694 _cleanup_free_ char *escaped = NULL;
1695 char n[dash - p + sizeof(".slice")];
1696
1697 #if HAS_FEATURE_MEMORY_SANITIZER
1698 /* msan doesn't instrument stpncpy, so it thinks
1699 * n is later used uninitialized:
1700 * https://github.com/google/sanitizers/issues/926
1701 */
1702 zero(n);
1703 #endif
1704
1705 /* Don't allow trailing or double dashes */
1706 if (IN_SET(dash[1], 0, '-'))
1707 return -EINVAL;
1708
1709 strcpy(stpncpy(n, p, dash - p), ".slice");
1710 if (!unit_name_is_valid(n, UNIT_NAME_PLAIN))
1711 return -EINVAL;
1712
1713 r = cg_escape(n, &escaped);
1714 if (r < 0)
1715 return r;
1716
1717 if (!strextend(&s, escaped, "/"))
1718 return -ENOMEM;
1719
1720 dash = strchr(dash+1, '-');
1721 }
1722
1723 r = cg_escape(unit, &e);
1724 if (r < 0)
1725 return r;
1726
1727 if (!strextend(&s, e))
1728 return -ENOMEM;
1729
1730 *ret = TAKE_PTR(s);
1731 return 0;
1732 }
1733
1734 int cg_is_threaded(const char *controller, const char *path) {
1735 _cleanup_free_ char *fs = NULL, *contents = NULL;
1736 _cleanup_strv_free_ char **v = NULL;
1737 int r;
1738
1739 r = cg_get_path(controller, path, "cgroup.type", &fs);
1740 if (r < 0)
1741 return r;
1742
1743 r = read_full_virtual_file(fs, &contents, NULL);
1744 if (r == -ENOENT)
1745 return false; /* Assume no. */
1746 if (r < 0)
1747 return r;
1748
1749 v = strv_split(contents, NULL);
1750 if (!v)
1751 return -ENOMEM;
1752
1753 /* If the cgroup is in the threaded mode, it contains "threaded".
1754 * If one of the parents or siblings is in the threaded mode, it may contain "invalid". */
1755 return strv_contains(v, "threaded") || strv_contains(v, "invalid");
1756 }
1757
1758 int cg_set_attribute(const char *controller, const char *path, const char *attribute, const char *value) {
1759 _cleanup_free_ char *p = NULL;
1760 int r;
1761
1762 r = cg_get_path(controller, path, attribute, &p);
1763 if (r < 0)
1764 return r;
1765
1766 return write_string_file(p, value, WRITE_STRING_FILE_DISABLE_BUFFER);
1767 }
1768
1769 int cg_get_attribute(const char *controller, const char *path, const char *attribute, char **ret) {
1770 _cleanup_free_ char *p = NULL;
1771 int r;
1772
1773 r = cg_get_path(controller, path, attribute, &p);
1774 if (r < 0)
1775 return r;
1776
1777 return read_one_line_file(p, ret);
1778 }
1779
1780 int cg_get_attribute_as_uint64(const char *controller, const char *path, const char *attribute, uint64_t *ret) {
1781 _cleanup_free_ char *value = NULL;
1782 uint64_t v;
1783 int r;
1784
1785 assert(ret);
1786
1787 r = cg_get_attribute(controller, path, attribute, &value);
1788 if (r == -ENOENT)
1789 return -ENODATA;
1790 if (r < 0)
1791 return r;
1792
1793 if (streq(value, "max")) {
1794 *ret = CGROUP_LIMIT_MAX;
1795 return 0;
1796 }
1797
1798 r = safe_atou64(value, &v);
1799 if (r < 0)
1800 return r;
1801
1802 *ret = v;
1803 return 0;
1804 }
1805
1806 int cg_get_attribute_as_bool(const char *controller, const char *path, const char *attribute, bool *ret) {
1807 _cleanup_free_ char *value = NULL;
1808 int r;
1809
1810 assert(ret);
1811
1812 r = cg_get_attribute(controller, path, attribute, &value);
1813 if (r == -ENOENT)
1814 return -ENODATA;
1815 if (r < 0)
1816 return r;
1817
1818 r = parse_boolean(value);
1819 if (r < 0)
1820 return r;
1821
1822 *ret = r;
1823 return 0;
1824 }
1825
1826 int cg_get_owner(const char *controller, const char *path, uid_t *ret_uid) {
1827 _cleanup_free_ char *f = NULL;
1828 struct stat stats;
1829 int r;
1830
1831 assert(ret_uid);
1832
1833 r = cg_get_path(controller, path, NULL, &f);
1834 if (r < 0)
1835 return r;
1836
1837 r = stat(f, &stats);
1838 if (r < 0)
1839 return -errno;
1840
1841 *ret_uid = stats.st_uid;
1842 return 0;
1843 }
1844
1845 int cg_get_keyed_attribute_full(
1846 const char *controller,
1847 const char *path,
1848 const char *attribute,
1849 char **keys,
1850 char **ret_values,
1851 CGroupKeyMode mode) {
1852
1853 _cleanup_free_ char *filename = NULL, *contents = NULL;
1854 const char *p;
1855 size_t n, i, n_done = 0;
1856 char **v;
1857 int r;
1858
1859 /* Reads one or more fields of a cgroup v2 keyed attribute file. The 'keys' parameter should be an strv with
1860 * all keys to retrieve. The 'ret_values' parameter should be passed as string size with the same number of
1861 * entries as 'keys'. On success each entry will be set to the value of the matching key.
1862 *
1863 * If the attribute file doesn't exist at all returns ENOENT, if any key is not found returns ENXIO. If mode
1864 * is set to GG_KEY_MODE_GRACEFUL we ignore missing keys and return those that were parsed successfully. */
1865
1866 r = cg_get_path(controller, path, attribute, &filename);
1867 if (r < 0)
1868 return r;
1869
1870 r = read_full_file(filename, &contents, NULL);
1871 if (r < 0)
1872 return r;
1873
1874 n = strv_length(keys);
1875 if (n == 0) /* No keys to retrieve? That's easy, we are done then */
1876 return 0;
1877
1878 /* Let's build this up in a temporary array for now in order not to clobber the return parameter on failure */
1879 v = newa0(char*, n);
1880
1881 for (p = contents; *p;) {
1882 const char *w = NULL;
1883
1884 for (i = 0; i < n; i++)
1885 if (!v[i]) {
1886 w = first_word(p, keys[i]);
1887 if (w)
1888 break;
1889 }
1890
1891 if (w) {
1892 size_t l;
1893
1894 l = strcspn(w, NEWLINE);
1895 v[i] = strndup(w, l);
1896 if (!v[i]) {
1897 r = -ENOMEM;
1898 goto fail;
1899 }
1900
1901 n_done++;
1902 if (n_done >= n)
1903 goto done;
1904
1905 p = w + l;
1906 } else
1907 p += strcspn(p, NEWLINE);
1908
1909 p += strspn(p, NEWLINE);
1910 }
1911
1912 if (mode & CG_KEY_MODE_GRACEFUL)
1913 goto done;
1914
1915 r = -ENXIO;
1916
1917 fail:
1918 for (i = 0; i < n; i++)
1919 free(v[i]);
1920
1921 return r;
1922
1923 done:
1924 memcpy(ret_values, v, sizeof(char*) * n);
1925 if (mode & CG_KEY_MODE_GRACEFUL)
1926 return n_done;
1927
1928 return 0;
1929 }
1930
1931 int cg_mask_to_string(CGroupMask mask, char **ret) {
1932 _cleanup_free_ char *s = NULL;
1933 bool space = false;
1934 CGroupController c;
1935 size_t n = 0;
1936
1937 assert(ret);
1938
1939 if (mask == 0) {
1940 *ret = NULL;
1941 return 0;
1942 }
1943
1944 for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1945 const char *k;
1946 size_t l;
1947
1948 if (!FLAGS_SET(mask, CGROUP_CONTROLLER_TO_MASK(c)))
1949 continue;
1950
1951 k = cgroup_controller_to_string(c);
1952 l = strlen(k);
1953
1954 if (!GREEDY_REALLOC(s, n + space + l + 1))
1955 return -ENOMEM;
1956
1957 if (space)
1958 s[n] = ' ';
1959 memcpy(s + n + space, k, l);
1960 n += space + l;
1961
1962 space = true;
1963 }
1964
1965 assert(s);
1966
1967 s[n] = 0;
1968 *ret = TAKE_PTR(s);
1969
1970 return 0;
1971 }
1972
1973 int cg_mask_from_string(const char *value, CGroupMask *ret) {
1974 CGroupMask m = 0;
1975
1976 assert(ret);
1977 assert(value);
1978
1979 for (;;) {
1980 _cleanup_free_ char *n = NULL;
1981 CGroupController v;
1982 int r;
1983
1984 r = extract_first_word(&value, &n, NULL, 0);
1985 if (r < 0)
1986 return r;
1987 if (r == 0)
1988 break;
1989
1990 v = cgroup_controller_from_string(n);
1991 if (v < 0)
1992 continue;
1993
1994 m |= CGROUP_CONTROLLER_TO_MASK(v);
1995 }
1996
1997 *ret = m;
1998 return 0;
1999 }
2000
2001 int cg_mask_supported_subtree(const char *root, CGroupMask *ret) {
2002 CGroupMask mask;
2003 int r;
2004
2005 /* Determines the mask of supported cgroup controllers. Only includes controllers we can make sense of and that
2006 * are actually accessible. Only covers real controllers, i.e. not the CGROUP_CONTROLLER_BPF_xyz
2007 * pseudo-controllers. */
2008
2009 r = cg_all_unified();
2010 if (r < 0)
2011 return r;
2012 if (r > 0) {
2013 _cleanup_free_ char *controllers = NULL, *path = NULL;
2014
2015 /* In the unified hierarchy we can read the supported and accessible controllers from
2016 * the top-level cgroup attribute */
2017
2018 r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, root, "cgroup.controllers", &path);
2019 if (r < 0)
2020 return r;
2021
2022 r = read_one_line_file(path, &controllers);
2023 if (r < 0)
2024 return r;
2025
2026 r = cg_mask_from_string(controllers, &mask);
2027 if (r < 0)
2028 return r;
2029
2030 /* Mask controllers that are not supported in unified hierarchy. */
2031 mask &= CGROUP_MASK_V2;
2032
2033 } else {
2034 CGroupController c;
2035
2036 /* In the legacy hierarchy, we check which hierarchies are accessible. */
2037
2038 mask = 0;
2039 for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
2040 CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
2041 const char *n;
2042
2043 if (!FLAGS_SET(CGROUP_MASK_V1, bit))
2044 continue;
2045
2046 n = cgroup_controller_to_string(c);
2047 if (controller_is_v1_accessible(root, n) >= 0)
2048 mask |= bit;
2049 }
2050 }
2051
2052 *ret = mask;
2053 return 0;
2054 }
2055
2056 int cg_mask_supported(CGroupMask *ret) {
2057 _cleanup_free_ char *root = NULL;
2058 int r;
2059
2060 r = cg_get_root_path(&root);
2061 if (r < 0)
2062 return r;
2063
2064 return cg_mask_supported_subtree(root, ret);
2065 }
2066
2067 int cg_kernel_controllers(Set **ret) {
2068 _cleanup_set_free_ Set *controllers = NULL;
2069 _cleanup_fclose_ FILE *f = NULL;
2070 int r;
2071
2072 assert(ret);
2073
2074 /* Determines the full list of kernel-known controllers. Might include controllers we don't actually support
2075 * and controllers that aren't currently accessible (because not mounted). This does not include "name="
2076 * pseudo-controllers. */
2077
2078 r = fopen_unlocked("/proc/cgroups", "re", &f);
2079 if (r == -ENOENT) {
2080 *ret = NULL;
2081 return 0;
2082 }
2083 if (r < 0)
2084 return r;
2085
2086 /* Ignore the header line */
2087 (void) read_line(f, SIZE_MAX, NULL);
2088
2089 for (;;) {
2090 _cleanup_free_ char *controller = NULL;
2091 int enabled = 0;
2092
2093 errno = 0;
2094 if (fscanf(f, "%ms %*i %*i %i", &controller, &enabled) != 2) {
2095
2096 if (feof(f))
2097 break;
2098
2099 if (ferror(f))
2100 return errno_or_else(EIO);
2101
2102 return -EBADMSG;
2103 }
2104
2105 if (!enabled)
2106 continue;
2107
2108 if (!cg_controller_is_valid(controller))
2109 return -EBADMSG;
2110
2111 r = set_ensure_consume(&controllers, &string_hash_ops_free, TAKE_PTR(controller));
2112 if (r < 0)
2113 return r;
2114 }
2115
2116 *ret = TAKE_PTR(controllers);
2117
2118 return 0;
2119 }
2120
2121 /* The hybrid mode was initially implemented in v232 and simply mounted cgroup2 on
2122 * /sys/fs/cgroup/systemd. This unfortunately broke other tools (such as docker) which expected the v1
2123 * "name=systemd" hierarchy on /sys/fs/cgroup/systemd. From v233 and on, the hybrid mode mounts v2 on
2124 * /sys/fs/cgroup/unified and maintains "name=systemd" hierarchy on /sys/fs/cgroup/systemd for compatibility
2125 * with other tools.
2126 *
2127 * To keep live upgrade working, we detect and support v232 layout. When v232 layout is detected, to keep
2128 * cgroup v2 process management but disable the compat dual layout, we return true on
2129 * cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER) and false on cg_hybrid_unified().
2130 */
2131 static thread_local bool unified_systemd_v232;
2132
2133 int cg_unified_cached(bool flush) {
2134 static thread_local CGroupUnified unified_cache = CGROUP_UNIFIED_UNKNOWN;
2135
2136 struct statfs fs;
2137
2138 /* Checks if we support the unified hierarchy. Returns an
2139 * error when the cgroup hierarchies aren't mounted yet or we
2140 * have any other trouble determining if the unified hierarchy
2141 * is supported. */
2142
2143 if (flush)
2144 unified_cache = CGROUP_UNIFIED_UNKNOWN;
2145 else if (unified_cache >= CGROUP_UNIFIED_NONE)
2146 return unified_cache;
2147
2148 if (statfs("/sys/fs/cgroup/", &fs) < 0)
2149 return log_debug_errno(errno, "statfs(\"/sys/fs/cgroup/\") failed: %m");
2150
2151 if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
2152 log_debug("Found cgroup2 on /sys/fs/cgroup/, full unified hierarchy");
2153 unified_cache = CGROUP_UNIFIED_ALL;
2154 } else if (F_TYPE_EQUAL(fs.f_type, TMPFS_MAGIC)) {
2155 if (statfs("/sys/fs/cgroup/unified/", &fs) == 0 &&
2156 F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
2157 log_debug("Found cgroup2 on /sys/fs/cgroup/unified, unified hierarchy for systemd controller");
2158 unified_cache = CGROUP_UNIFIED_SYSTEMD;
2159 unified_systemd_v232 = false;
2160 } else {
2161 if (statfs("/sys/fs/cgroup/systemd/", &fs) < 0) {
2162 if (errno == ENOENT) {
2163 /* Some other software may have set up /sys/fs/cgroup in a configuration we do not recognize. */
2164 log_debug_errno(errno, "Unsupported cgroupsv1 setup detected: name=systemd hierarchy not found.");
2165 return -ENOMEDIUM;
2166 }
2167 return log_debug_errno(errno, "statfs(\"/sys/fs/cgroup/systemd\" failed: %m");
2168 }
2169
2170 if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
2171 log_debug("Found cgroup2 on /sys/fs/cgroup/systemd, unified hierarchy for systemd controller (v232 variant)");
2172 unified_cache = CGROUP_UNIFIED_SYSTEMD;
2173 unified_systemd_v232 = true;
2174 } else if (F_TYPE_EQUAL(fs.f_type, CGROUP_SUPER_MAGIC)) {
2175 log_debug("Found cgroup on /sys/fs/cgroup/systemd, legacy hierarchy");
2176 unified_cache = CGROUP_UNIFIED_NONE;
2177 } else {
2178 log_debug("Unexpected filesystem type %llx mounted on /sys/fs/cgroup/systemd, assuming legacy hierarchy",
2179 (unsigned long long) fs.f_type);
2180 unified_cache = CGROUP_UNIFIED_NONE;
2181 }
2182 }
2183 } else if (F_TYPE_EQUAL(fs.f_type, SYSFS_MAGIC)) {
2184 return log_debug_errno(SYNTHETIC_ERRNO(ENOMEDIUM),
2185 "No filesystem is currently mounted on /sys/fs/cgroup.");
2186 } else
2187 return log_debug_errno(SYNTHETIC_ERRNO(ENOMEDIUM),
2188 "Unknown filesystem type %llx mounted on /sys/fs/cgroup.",
2189 (unsigned long long)fs.f_type);
2190
2191 return unified_cache;
2192 }
2193
2194 int cg_unified_controller(const char *controller) {
2195 int r;
2196
2197 r = cg_unified_cached(false);
2198 if (r < 0)
2199 return r;
2200
2201 if (r == CGROUP_UNIFIED_NONE)
2202 return false;
2203
2204 if (r >= CGROUP_UNIFIED_ALL)
2205 return true;
2206
2207 return streq_ptr(controller, SYSTEMD_CGROUP_CONTROLLER);
2208 }
2209
2210 int cg_all_unified(void) {
2211 int r;
2212
2213 r = cg_unified_cached(false);
2214 if (r < 0)
2215 return r;
2216
2217 return r >= CGROUP_UNIFIED_ALL;
2218 }
2219
2220 int cg_hybrid_unified(void) {
2221 int r;
2222
2223 r = cg_unified_cached(false);
2224 if (r < 0)
2225 return r;
2226
2227 return r == CGROUP_UNIFIED_SYSTEMD && !unified_systemd_v232;
2228 }
2229
2230 const uint64_t cgroup_io_limit_defaults[_CGROUP_IO_LIMIT_TYPE_MAX] = {
2231 [CGROUP_IO_RBPS_MAX] = CGROUP_LIMIT_MAX,
2232 [CGROUP_IO_WBPS_MAX] = CGROUP_LIMIT_MAX,
2233 [CGROUP_IO_RIOPS_MAX] = CGROUP_LIMIT_MAX,
2234 [CGROUP_IO_WIOPS_MAX] = CGROUP_LIMIT_MAX,
2235 };
2236
2237 static const char* const cgroup_io_limit_type_table[_CGROUP_IO_LIMIT_TYPE_MAX] = {
2238 [CGROUP_IO_RBPS_MAX] = "IOReadBandwidthMax",
2239 [CGROUP_IO_WBPS_MAX] = "IOWriteBandwidthMax",
2240 [CGROUP_IO_RIOPS_MAX] = "IOReadIOPSMax",
2241 [CGROUP_IO_WIOPS_MAX] = "IOWriteIOPSMax",
2242 };
2243
2244 DEFINE_STRING_TABLE_LOOKUP(cgroup_io_limit_type, CGroupIOLimitType);
2245
2246 bool is_cgroup_fs(const struct statfs *s) {
2247 return is_fs_type(s, CGROUP_SUPER_MAGIC) ||
2248 is_fs_type(s, CGROUP2_SUPER_MAGIC);
2249 }
2250
2251 bool fd_is_cgroup_fs(int fd) {
2252 struct statfs s;
2253
2254 if (fstatfs(fd, &s) < 0)
2255 return -errno;
2256
2257 return is_cgroup_fs(&s);
2258 }
2259
2260 static const char *const cgroup_controller_table[_CGROUP_CONTROLLER_MAX] = {
2261 [CGROUP_CONTROLLER_CPU] = "cpu",
2262 [CGROUP_CONTROLLER_CPUACCT] = "cpuacct",
2263 [CGROUP_CONTROLLER_CPUSET] = "cpuset",
2264 [CGROUP_CONTROLLER_IO] = "io",
2265 [CGROUP_CONTROLLER_BLKIO] = "blkio",
2266 [CGROUP_CONTROLLER_MEMORY] = "memory",
2267 [CGROUP_CONTROLLER_DEVICES] = "devices",
2268 [CGROUP_CONTROLLER_PIDS] = "pids",
2269 [CGROUP_CONTROLLER_BPF_FIREWALL] = "bpf-firewall",
2270 [CGROUP_CONTROLLER_BPF_DEVICES] = "bpf-devices",
2271 [CGROUP_CONTROLLER_BPF_FOREIGN] = "bpf-foreign",
2272 [CGROUP_CONTROLLER_BPF_SOCKET_BIND] = "bpf-socket-bind",
2273 [CGROUP_CONTROLLER_BPF_RESTRICT_NETWORK_INTERFACES] = "bpf-restrict-network-interfaces",
2274 };
2275
2276 DEFINE_STRING_TABLE_LOOKUP(cgroup_controller, CGroupController);
2277
2278 CGroupMask get_cpu_accounting_mask(void) {
2279 static CGroupMask needed_mask = (CGroupMask) -1;
2280
2281 /* On kernel ≥4.15 with unified hierarchy, cpu.stat's usage_usec is
2282 * provided externally from the CPU controller, which means we don't
2283 * need to enable the CPU controller just to get metrics. This is good,
2284 * because enabling the CPU controller comes at a minor performance
2285 * hit, especially when it's propagated deep into large hierarchies.
2286 * There's also no separate CPU accounting controller available within
2287 * a unified hierarchy.
2288 *
2289 * This combination of factors results in the desired cgroup mask to
2290 * enable for CPU accounting varying as follows:
2291 *
2292 * ╔═════════════════════╤═════════════════════╗
2293 * ║ Linux ≥4.15 │ Linux <4.15 ║
2294 * ╔═══════════════╬═════════════════════╪═════════════════════╣
2295 * ║ Unified ║ nothing │ CGROUP_MASK_CPU ║
2296 * ╟───────────────╫─────────────────────┼─────────────────────╢
2297 * ║ Hybrid/Legacy ║ CGROUP_MASK_CPUACCT │ CGROUP_MASK_CPUACCT ║
2298 * ╚═══════════════╩═════════════════════╧═════════════════════╝
2299 *
2300 * We check kernel version here instead of manually checking whether
2301 * cpu.stat is present for every cgroup, as that check in itself would
2302 * already be fairly expensive.
2303 *
2304 * Kernels where this patch has been backported will therefore have the
2305 * CPU controller enabled unnecessarily. This is more expensive than
2306 * necessary, but harmless. ☺️
2307 */
2308
2309 if (needed_mask == (CGroupMask) -1) {
2310 if (cg_all_unified()) {
2311 struct utsname u;
2312 assert_se(uname(&u) >= 0);
2313
2314 if (strverscmp_improved(u.release, "4.15") < 0)
2315 needed_mask = CGROUP_MASK_CPU;
2316 else
2317 needed_mask = 0;
2318 } else
2319 needed_mask = CGROUP_MASK_CPUACCT;
2320 }
2321
2322 return needed_mask;
2323 }
2324
2325 bool cpu_accounting_is_cheap(void) {
2326 return get_cpu_accounting_mask() == 0;
2327 }
2328
2329 static const char* const managed_oom_mode_table[_MANAGED_OOM_MODE_MAX] = {
2330 [MANAGED_OOM_AUTO] = "auto",
2331 [MANAGED_OOM_KILL] = "kill",
2332 };
2333
2334 DEFINE_STRING_TABLE_LOOKUP(managed_oom_mode, ManagedOOMMode);
2335
2336 static const char* const managed_oom_preference_table[_MANAGED_OOM_PREFERENCE_MAX] = {
2337 [MANAGED_OOM_PREFERENCE_NONE] = "none",
2338 [MANAGED_OOM_PREFERENCE_AVOID] = "avoid",
2339 [MANAGED_OOM_PREFERENCE_OMIT] = "omit",
2340 };
2341
2342 DEFINE_STRING_TABLE_LOOKUP(managed_oom_preference, ManagedOOMPreference);
A System and Session Manager (ALT Linux package)