]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/cgroup.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #12296 from poettering/coding-style-sections
[thirdparty/systemd.git] / src / core / cgroup.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <fcntl.h>
4 #include <fnmatch.h>
5
6 #include "sd-messages.h"
7
8 #include "alloc-util.h"
9 #include "blockdev-util.h"
10 #include "bpf-devices.h"
11 #include "bpf-firewall.h"
12 #include "btrfs-util.h"
13 #include "bus-error.h"
14 #include "cgroup-util.h"
15 #include "cgroup.h"
16 #include "fd-util.h"
17 #include "fileio.h"
18 #include "fs-util.h"
19 #include "nulstr-util.h"
20 #include "parse-util.h"
21 #include "path-util.h"
22 #include "process-util.h"
23 #include "procfs-util.h"
24 #include "special.h"
25 #include "stat-util.h"
26 #include "stdio-util.h"
27 #include "string-table.h"
28 #include "string-util.h"
29 #include "virt.h"
30
31 #define CGROUP_CPU_QUOTA_DEFAULT_PERIOD_USEC ((usec_t) 100 * USEC_PER_MSEC)
32
33 /* Returns the log level to use when cgroup attribute writes fail. When an attribute is missing or we have access
34 * problems we downgrade to LOG_DEBUG. This is supposed to be nice to container managers and kernels which want to mask
35 * out specific attributes from us. */
36 #define LOG_LEVEL_CGROUP_WRITE(r) (IN_SET(abs(r), ENOENT, EROFS, EACCES, EPERM) ? LOG_DEBUG : LOG_WARNING)
37
38 bool manager_owns_host_root_cgroup(Manager *m) {
39 assert(m);
40
41 /* Returns true if we are managing the root cgroup. Note that it isn't sufficient to just check whether the
42 * group root path equals "/" since that will also be the case if CLONE_NEWCGROUP is in the mix. Since there's
43 * appears to be no nice way to detect whether we are in a CLONE_NEWCGROUP namespace we instead just check if
44 * we run in any kind of container virtualization. */
45
46 if (MANAGER_IS_USER(m))
47 return false;
48
49 if (detect_container() > 0)
50 return false;
51
52 return empty_or_root(m->cgroup_root);
53 }
54
55 bool unit_has_host_root_cgroup(Unit *u) {
56 assert(u);
57
58 /* Returns whether this unit manages the root cgroup. This will return true if this unit is the root slice and
59 * the manager manages the root cgroup. */
60
61 if (!manager_owns_host_root_cgroup(u->manager))
62 return false;
63
64 return unit_has_name(u, SPECIAL_ROOT_SLICE);
65 }
66
67 static int set_attribute_and_warn(Unit *u, const char *controller, const char *attribute, const char *value) {
68 int r;
69
70 r = cg_set_attribute(controller, u->cgroup_path, attribute, value);
71 if (r < 0)
72 log_unit_full(u, LOG_LEVEL_CGROUP_WRITE(r), r, "Failed to set '%s' attribute on '%s' to '%.*s': %m",
73 strna(attribute), isempty(u->cgroup_path) ? "/" : u->cgroup_path, (int) strcspn(value, NEWLINE), value);
74
75 return r;
76 }
77
78 static void cgroup_compat_warn(void) {
79 static bool cgroup_compat_warned = false;
80
81 if (cgroup_compat_warned)
82 return;
83
84 log_warning("cgroup compatibility translation between legacy and unified hierarchy settings activated. "
85 "See cgroup-compat debug messages for details.");
86
87 cgroup_compat_warned = true;
88 }
89
90 #define log_cgroup_compat(unit, fmt, ...) do { \
91 cgroup_compat_warn(); \
92 log_unit_debug(unit, "cgroup-compat: " fmt, ##__VA_ARGS__); \
93 } while (false)
94
95 void cgroup_context_init(CGroupContext *c) {
96 assert(c);
97
98 /* Initialize everything to the kernel defaults. */
99
100 *c = (CGroupContext) {
101 .cpu_weight = CGROUP_WEIGHT_INVALID,
102 .startup_cpu_weight = CGROUP_WEIGHT_INVALID,
103 .cpu_quota_per_sec_usec = USEC_INFINITY,
104 .cpu_quota_period_usec = USEC_INFINITY,
105
106 .cpu_shares = CGROUP_CPU_SHARES_INVALID,
107 .startup_cpu_shares = CGROUP_CPU_SHARES_INVALID,
108
109 .memory_high = CGROUP_LIMIT_MAX,
110 .memory_max = CGROUP_LIMIT_MAX,
111 .memory_swap_max = CGROUP_LIMIT_MAX,
112
113 .memory_limit = CGROUP_LIMIT_MAX,
114
115 .io_weight = CGROUP_WEIGHT_INVALID,
116 .startup_io_weight = CGROUP_WEIGHT_INVALID,
117
118 .blockio_weight = CGROUP_BLKIO_WEIGHT_INVALID,
119 .startup_blockio_weight = CGROUP_BLKIO_WEIGHT_INVALID,
120
121 .tasks_max = CGROUP_LIMIT_MAX,
122 };
123 }
124
125 void cgroup_context_free_device_allow(CGroupContext *c, CGroupDeviceAllow *a) {
126 assert(c);
127 assert(a);
128
129 LIST_REMOVE(device_allow, c->device_allow, a);
130 free(a->path);
131 free(a);
132 }
133
134 void cgroup_context_free_io_device_weight(CGroupContext *c, CGroupIODeviceWeight *w) {
135 assert(c);
136 assert(w);
137
138 LIST_REMOVE(device_weights, c->io_device_weights, w);
139 free(w->path);
140 free(w);
141 }
142
143 void cgroup_context_free_io_device_latency(CGroupContext *c, CGroupIODeviceLatency *l) {
144 assert(c);
145 assert(l);
146
147 LIST_REMOVE(device_latencies, c->io_device_latencies, l);
148 free(l->path);
149 free(l);
150 }
151
152 void cgroup_context_free_io_device_limit(CGroupContext *c, CGroupIODeviceLimit *l) {
153 assert(c);
154 assert(l);
155
156 LIST_REMOVE(device_limits, c->io_device_limits, l);
157 free(l->path);
158 free(l);
159 }
160
161 void cgroup_context_free_blockio_device_weight(CGroupContext *c, CGroupBlockIODeviceWeight *w) {
162 assert(c);
163 assert(w);
164
165 LIST_REMOVE(device_weights, c->blockio_device_weights, w);
166 free(w->path);
167 free(w);
168 }
169
170 void cgroup_context_free_blockio_device_bandwidth(CGroupContext *c, CGroupBlockIODeviceBandwidth *b) {
171 assert(c);
172 assert(b);
173
174 LIST_REMOVE(device_bandwidths, c->blockio_device_bandwidths, b);
175 free(b->path);
176 free(b);
177 }
178
179 void cgroup_context_done(CGroupContext *c) {
180 assert(c);
181
182 while (c->io_device_weights)
183 cgroup_context_free_io_device_weight(c, c->io_device_weights);
184
185 while (c->io_device_latencies)
186 cgroup_context_free_io_device_latency(c, c->io_device_latencies);
187
188 while (c->io_device_limits)
189 cgroup_context_free_io_device_limit(c, c->io_device_limits);
190
191 while (c->blockio_device_weights)
192 cgroup_context_free_blockio_device_weight(c, c->blockio_device_weights);
193
194 while (c->blockio_device_bandwidths)
195 cgroup_context_free_blockio_device_bandwidth(c, c->blockio_device_bandwidths);
196
197 while (c->device_allow)
198 cgroup_context_free_device_allow(c, c->device_allow);
199
200 c->ip_address_allow = ip_address_access_free_all(c->ip_address_allow);
201 c->ip_address_deny = ip_address_access_free_all(c->ip_address_deny);
202 }
203
204 void cgroup_context_dump(CGroupContext *c, FILE* f, const char *prefix) {
205 CGroupIODeviceLimit *il;
206 CGroupIODeviceWeight *iw;
207 CGroupIODeviceLatency *l;
208 CGroupBlockIODeviceBandwidth *b;
209 CGroupBlockIODeviceWeight *w;
210 CGroupDeviceAllow *a;
211 IPAddressAccessItem *iaai;
212 char u[FORMAT_TIMESPAN_MAX];
213 char v[FORMAT_TIMESPAN_MAX];
214
215 assert(c);
216 assert(f);
217
218 prefix = strempty(prefix);
219
220 fprintf(f,
221 "%sCPUAccounting=%s\n"
222 "%sIOAccounting=%s\n"
223 "%sBlockIOAccounting=%s\n"
224 "%sMemoryAccounting=%s\n"
225 "%sTasksAccounting=%s\n"
226 "%sIPAccounting=%s\n"
227 "%sCPUWeight=%" PRIu64 "\n"
228 "%sStartupCPUWeight=%" PRIu64 "\n"
229 "%sCPUShares=%" PRIu64 "\n"
230 "%sStartupCPUShares=%" PRIu64 "\n"
231 "%sCPUQuotaPerSecSec=%s\n"
232 "%sCPUQuotaPeriodSec=%s\n"
233 "%sIOWeight=%" PRIu64 "\n"
234 "%sStartupIOWeight=%" PRIu64 "\n"
235 "%sBlockIOWeight=%" PRIu64 "\n"
236 "%sStartupBlockIOWeight=%" PRIu64 "\n"
237 "%sDefaultMemoryLow=%" PRIu64 "\n"
238 "%sMemoryMin=%" PRIu64 "\n"
239 "%sMemoryLow=%" PRIu64 "\n"
240 "%sMemoryHigh=%" PRIu64 "\n"
241 "%sMemoryMax=%" PRIu64 "\n"
242 "%sMemorySwapMax=%" PRIu64 "\n"
243 "%sMemoryLimit=%" PRIu64 "\n"
244 "%sTasksMax=%" PRIu64 "\n"
245 "%sDevicePolicy=%s\n"
246 "%sDelegate=%s\n",
247 prefix, yes_no(c->cpu_accounting),
248 prefix, yes_no(c->io_accounting),
249 prefix, yes_no(c->blockio_accounting),
250 prefix, yes_no(c->memory_accounting),
251 prefix, yes_no(c->tasks_accounting),
252 prefix, yes_no(c->ip_accounting),
253 prefix, c->cpu_weight,
254 prefix, c->startup_cpu_weight,
255 prefix, c->cpu_shares,
256 prefix, c->startup_cpu_shares,
257 prefix, format_timespan(u, sizeof(u), c->cpu_quota_per_sec_usec, 1),
258 prefix, format_timespan(v, sizeof(v), c->cpu_quota_period_usec, 1),
259 prefix, c->io_weight,
260 prefix, c->startup_io_weight,
261 prefix, c->blockio_weight,
262 prefix, c->startup_blockio_weight,
263 prefix, c->default_memory_low,
264 prefix, c->memory_min,
265 prefix, c->memory_low,
266 prefix, c->memory_high,
267 prefix, c->memory_max,
268 prefix, c->memory_swap_max,
269 prefix, c->memory_limit,
270 prefix, c->tasks_max,
271 prefix, cgroup_device_policy_to_string(c->device_policy),
272 prefix, yes_no(c->delegate));
273
274 if (c->delegate) {
275 _cleanup_free_ char *t = NULL;
276
277 (void) cg_mask_to_string(c->delegate_controllers, &t);
278
279 fprintf(f, "%sDelegateControllers=%s\n",
280 prefix,
281 strempty(t));
282 }
283
284 LIST_FOREACH(device_allow, a, c->device_allow)
285 fprintf(f,
286 "%sDeviceAllow=%s %s%s%s\n",
287 prefix,
288 a->path,
289 a->r ? "r" : "", a->w ? "w" : "", a->m ? "m" : "");
290
291 LIST_FOREACH(device_weights, iw, c->io_device_weights)
292 fprintf(f,
293 "%sIODeviceWeight=%s %" PRIu64 "\n",
294 prefix,
295 iw->path,
296 iw->weight);
297
298 LIST_FOREACH(device_latencies, l, c->io_device_latencies)
299 fprintf(f,
300 "%sIODeviceLatencyTargetSec=%s %s\n",
301 prefix,
302 l->path,
303 format_timespan(u, sizeof(u), l->target_usec, 1));
304
305 LIST_FOREACH(device_limits, il, c->io_device_limits) {
306 char buf[FORMAT_BYTES_MAX];
307 CGroupIOLimitType type;
308
309 for (type = 0; type < _CGROUP_IO_LIMIT_TYPE_MAX; type++)
310 if (il->limits[type] != cgroup_io_limit_defaults[type])
311 fprintf(f,
312 "%s%s=%s %s\n",
313 prefix,
314 cgroup_io_limit_type_to_string(type),
315 il->path,
316 format_bytes(buf, sizeof(buf), il->limits[type]));
317 }
318
319 LIST_FOREACH(device_weights, w, c->blockio_device_weights)
320 fprintf(f,
321 "%sBlockIODeviceWeight=%s %" PRIu64,
322 prefix,
323 w->path,
324 w->weight);
325
326 LIST_FOREACH(device_bandwidths, b, c->blockio_device_bandwidths) {
327 char buf[FORMAT_BYTES_MAX];
328
329 if (b->rbps != CGROUP_LIMIT_MAX)
330 fprintf(f,
331 "%sBlockIOReadBandwidth=%s %s\n",
332 prefix,
333 b->path,
334 format_bytes(buf, sizeof(buf), b->rbps));
335 if (b->wbps != CGROUP_LIMIT_MAX)
336 fprintf(f,
337 "%sBlockIOWriteBandwidth=%s %s\n",
338 prefix,
339 b->path,
340 format_bytes(buf, sizeof(buf), b->wbps));
341 }
342
343 LIST_FOREACH(items, iaai, c->ip_address_allow) {
344 _cleanup_free_ char *k = NULL;
345
346 (void) in_addr_to_string(iaai->family, &iaai->address, &k);
347 fprintf(f, "%sIPAddressAllow=%s/%u\n", prefix, strnull(k), iaai->prefixlen);
348 }
349
350 LIST_FOREACH(items, iaai, c->ip_address_deny) {
351 _cleanup_free_ char *k = NULL;
352
353 (void) in_addr_to_string(iaai->family, &iaai->address, &k);
354 fprintf(f, "%sIPAddressDeny=%s/%u\n", prefix, strnull(k), iaai->prefixlen);
355 }
356 }
357
358 int cgroup_add_device_allow(CGroupContext *c, const char *dev, const char *mode) {
359 _cleanup_free_ CGroupDeviceAllow *a = NULL;
360 _cleanup_free_ char *d = NULL;
361
362 assert(c);
363 assert(dev);
364 assert(isempty(mode) || in_charset(mode, "rwm"));
365
366 a = new(CGroupDeviceAllow, 1);
367 if (!a)
368 return -ENOMEM;
369
370 d = strdup(dev);
371 if (!d)
372 return -ENOMEM;
373
374 *a = (CGroupDeviceAllow) {
375 .path = TAKE_PTR(d),
376 .r = isempty(mode) || strchr(mode, 'r'),
377 .w = isempty(mode) || strchr(mode, 'w'),
378 .m = isempty(mode) || strchr(mode, 'm'),
379 };
380
381 LIST_PREPEND(device_allow, c->device_allow, a);
382 TAKE_PTR(a);
383
384 return 0;
385 }
386
387 uint64_t unit_get_ancestor_memory_low(Unit *u) {
388 CGroupContext *c;
389
390 /* 1. Is MemoryLow set in this unit? If so, use that.
391 * 2. Is DefaultMemoryLow set in any ancestor? If so, use that.
392 * 3. Otherwise, return CGROUP_LIMIT_MIN. */
393
394 assert(u);
395
396 c = unit_get_cgroup_context(u);
397
398 if (c->memory_low_set)
399 return c->memory_low;
400
401 while (UNIT_ISSET(u->slice)) {
402 u = UNIT_DEREF(u->slice);
403 c = unit_get_cgroup_context(u);
404
405 if (c->default_memory_low_set)
406 return c->default_memory_low;
407 }
408
409 /* We've reached the root, but nobody had DefaultMemoryLow set, so set it to the kernel default. */
410 return CGROUP_LIMIT_MIN;
411 }
412
413 static void cgroup_xattr_apply(Unit *u) {
414 char ids[SD_ID128_STRING_MAX];
415 int r;
416
417 assert(u);
418
419 if (!MANAGER_IS_SYSTEM(u->manager))
420 return;
421
422 if (sd_id128_is_null(u->invocation_id))
423 return;
424
425 r = cg_set_xattr(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path,
426 "trusted.invocation_id",
427 sd_id128_to_string(u->invocation_id, ids), 32,
428 0);
429 if (r < 0)
430 log_unit_debug_errno(u, r, "Failed to set invocation ID on control group %s, ignoring: %m", u->cgroup_path);
431 }
432
433 static int lookup_block_device(const char *p, dev_t *ret) {
434 dev_t rdev, dev = 0;
435 mode_t mode;
436 int r;
437
438 assert(p);
439 assert(ret);
440
441 r = device_path_parse_major_minor(p, &mode, &rdev);
442 if (r == -ENODEV) { /* not a parsable device node, need to go to disk */
443 struct stat st;
444 if (stat(p, &st) < 0)
445 return log_warning_errno(errno, "Couldn't stat device '%s': %m", p);
446 rdev = (dev_t)st.st_rdev;
447 dev = (dev_t)st.st_dev;
448 mode = st.st_mode;
449 } else if (r < 0)
450 return log_warning_errno(r, "Failed to parse major/minor from path '%s': %m", p);
451
452 if (S_ISCHR(mode)) {
453 log_warning("Device node '%s' is a character device, but block device needed.", p);
454 return -ENOTBLK;
455 } else if (S_ISBLK(mode))
456 *ret = rdev;
457 else if (major(dev) != 0)
458 *ret = dev; /* If this is not a device node then use the block device this file is stored on */
459 else {
460 /* If this is btrfs, getting the backing block device is a bit harder */
461 r = btrfs_get_block_device(p, ret);
462 if (r < 0 && r != -ENOTTY)
463 return log_warning_errno(r, "Failed to determine block device backing btrfs file system '%s': %m", p);
464 if (r == -ENOTTY) {
465 log_warning("'%s' is not a block device node, and file system block device cannot be determined or is not local.", p);
466 return -ENODEV;
467 }
468 }
469
470 /* If this is a LUKS device, try to get the originating block device */
471 (void) block_get_originating(*ret, ret);
472
473 /* If this is a partition, try to get the originating block device */
474 (void) block_get_whole_disk(*ret, ret);
475 return 0;
476 }
477
478 static int whitelist_device(BPFProgram *prog, const char *path, const char *node, const char *acc) {
479 dev_t rdev;
480 mode_t mode;
481 int r;
482
483 assert(path);
484 assert(acc);
485
486 /* Some special handling for /dev/block/%u:%u, /dev/char/%u:%u, /run/systemd/inaccessible/chr and
487 * /run/systemd/inaccessible/blk paths. Instead of stat()ing these we parse out the major/minor directly. This
488 * means clients can use these path without the device node actually around */
489 r = device_path_parse_major_minor(node, &mode, &rdev);
490 if (r < 0) {
491 if (r != -ENODEV)
492 return log_warning_errno(r, "Couldn't parse major/minor from device path '%s': %m", node);
493
494 struct stat st;
495 if (stat(node, &st) < 0)
496 return log_warning_errno(errno, "Couldn't stat device %s: %m", node);
497
498 if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) {
499 log_warning("%s is not a device.", node);
500 return -ENODEV;
501 }
502 rdev = (dev_t) st.st_rdev;
503 mode = st.st_mode;
504 }
505
506 if (cg_all_unified() > 0) {
507 if (!prog)
508 return 0;
509
510 return cgroup_bpf_whitelist_device(prog, S_ISCHR(mode) ? BPF_DEVCG_DEV_CHAR : BPF_DEVCG_DEV_BLOCK,
511 major(rdev), minor(rdev), acc);
512
513 } else {
514 char buf[2+DECIMAL_STR_MAX(dev_t)*2+2+4];
515
516 sprintf(buf,
517 "%c %u:%u %s",
518 S_ISCHR(mode) ? 'c' : 'b',
519 major(rdev), minor(rdev),
520 acc);
521
522 /* Changing the devices list of a populated cgroup might result in EINVAL, hence ignore EINVAL here. */
523
524 r = cg_set_attribute("devices", path, "devices.allow", buf);
525 if (r < 0)
526 return log_full_errno(IN_SET(r, -ENOENT, -EROFS, -EINVAL, -EACCES, -EPERM) ? LOG_DEBUG : LOG_WARNING,
527 r, "Failed to set devices.allow on %s: %m", path);
528
529 return 0;
530 }
531 }
532
533 static int whitelist_major(BPFProgram *prog, const char *path, const char *name, char type, const char *acc) {
534 _cleanup_fclose_ FILE *f = NULL;
535 char buf[2+DECIMAL_STR_MAX(unsigned)+3+4];
536 bool good = false;
537 unsigned maj;
538 int r;
539
540 assert(path);
541 assert(acc);
542 assert(IN_SET(type, 'b', 'c'));
543
544 if (streq(name, "*")) {
545 /* If the name is a wildcard, then apply this list to all devices of this type */
546
547 if (cg_all_unified() > 0) {
548 if (!prog)
549 return 0;
550
551 (void) cgroup_bpf_whitelist_class(prog, type == 'c' ? BPF_DEVCG_DEV_CHAR : BPF_DEVCG_DEV_BLOCK, acc);
552 } else {
553 xsprintf(buf, "%c *:* %s", type, acc);
554
555 r = cg_set_attribute("devices", path, "devices.allow", buf);
556 if (r < 0)
557 log_full_errno(IN_SET(r, -ENOENT, -EROFS, -EINVAL, -EACCES) ? LOG_DEBUG : LOG_WARNING, r,
558 "Failed to set devices.allow on %s: %m", path);
559 return 0;
560 }
561 }
562
563 if (safe_atou(name, &maj) >= 0 && DEVICE_MAJOR_VALID(maj)) {
564 /* The name is numeric and suitable as major. In that case, let's take is major, and create the entry
565 * directly */
566
567 if (cg_all_unified() > 0) {
568 if (!prog)
569 return 0;
570
571 (void) cgroup_bpf_whitelist_major(prog,
572 type == 'c' ? BPF_DEVCG_DEV_CHAR : BPF_DEVCG_DEV_BLOCK,
573 maj, acc);
574 } else {
575 xsprintf(buf, "%c %u:* %s", type, maj, acc);
576
577 r = cg_set_attribute("devices", path, "devices.allow", buf);
578 if (r < 0)
579 log_full_errno(IN_SET(r, -ENOENT, -EROFS, -EINVAL, -EACCES) ? LOG_DEBUG : LOG_WARNING, r,
580 "Failed to set devices.allow on %s: %m", path);
581 }
582
583 return 0;
584 }
585
586 f = fopen("/proc/devices", "re");
587 if (!f)
588 return log_warning_errno(errno, "Cannot open /proc/devices to resolve %s (%c): %m", name, type);
589
590 for (;;) {
591 _cleanup_free_ char *line = NULL;
592 char *w, *p;
593
594 r = read_line(f, LONG_LINE_MAX, &line);
595 if (r < 0)
596 return log_warning_errno(r, "Failed to read /proc/devices: %m");
597 if (r == 0)
598 break;
599
600 if (type == 'c' && streq(line, "Character devices:")) {
601 good = true;
602 continue;
603 }
604
605 if (type == 'b' && streq(line, "Block devices:")) {
606 good = true;
607 continue;
608 }
609
610 if (isempty(line)) {
611 good = false;
612 continue;
613 }
614
615 if (!good)
616 continue;
617
618 p = strstrip(line);
619
620 w = strpbrk(p, WHITESPACE);
621 if (!w)
622 continue;
623 *w = 0;
624
625 r = safe_atou(p, &maj);
626 if (r < 0)
627 continue;
628 if (maj <= 0)
629 continue;
630
631 w++;
632 w += strspn(w, WHITESPACE);
633
634 if (fnmatch(name, w, 0) != 0)
635 continue;
636
637 if (cg_all_unified() > 0) {
638 if (!prog)
639 continue;
640
641 (void) cgroup_bpf_whitelist_major(prog,
642 type == 'c' ? BPF_DEVCG_DEV_CHAR : BPF_DEVCG_DEV_BLOCK,
643 maj, acc);
644 } else {
645 sprintf(buf,
646 "%c %u:* %s",
647 type,
648 maj,
649 acc);
650
651 /* Changing the devices list of a populated cgroup might result in EINVAL, hence ignore EINVAL
652 * here. */
653
654 r = cg_set_attribute("devices", path, "devices.allow", buf);
655 if (r < 0)
656 log_full_errno(IN_SET(r, -ENOENT, -EROFS, -EINVAL, -EACCES, -EPERM) ? LOG_DEBUG : LOG_WARNING,
657 r, "Failed to set devices.allow on %s: %m", path);
658 }
659 }
660
661 return 0;
662 }
663
664 static bool cgroup_context_has_cpu_weight(CGroupContext *c) {
665 return c->cpu_weight != CGROUP_WEIGHT_INVALID ||
666 c->startup_cpu_weight != CGROUP_WEIGHT_INVALID;
667 }
668
669 static bool cgroup_context_has_cpu_shares(CGroupContext *c) {
670 return c->cpu_shares != CGROUP_CPU_SHARES_INVALID ||
671 c->startup_cpu_shares != CGROUP_CPU_SHARES_INVALID;
672 }
673
674 static uint64_t cgroup_context_cpu_weight(CGroupContext *c, ManagerState state) {
675 if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING) &&
676 c->startup_cpu_weight != CGROUP_WEIGHT_INVALID)
677 return c->startup_cpu_weight;
678 else if (c->cpu_weight != CGROUP_WEIGHT_INVALID)
679 return c->cpu_weight;
680 else
681 return CGROUP_WEIGHT_DEFAULT;
682 }
683
684 static uint64_t cgroup_context_cpu_shares(CGroupContext *c, ManagerState state) {
685 if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING) &&
686 c->startup_cpu_shares != CGROUP_CPU_SHARES_INVALID)
687 return c->startup_cpu_shares;
688 else if (c->cpu_shares != CGROUP_CPU_SHARES_INVALID)
689 return c->cpu_shares;
690 else
691 return CGROUP_CPU_SHARES_DEFAULT;
692 }
693
694 usec_t cgroup_cpu_adjust_period(usec_t period, usec_t quota, usec_t resolution, usec_t max_period) {
695 /* kernel uses a minimum resolution of 1ms, so both period and (quota * period)
696 * need to be higher than that boundary. quota is specified in USecPerSec.
697 * Additionally, period must be at most max_period. */
698 assert(quota > 0);
699
700 return MIN(MAX3(period, resolution, resolution * USEC_PER_SEC / quota), max_period);
701 }
702
703 static usec_t cgroup_cpu_adjust_period_and_log(Unit *u, usec_t period, usec_t quota) {
704 usec_t new_period;
705
706 if (quota == USEC_INFINITY)
707 /* Always use default period for infinity quota. */
708 return CGROUP_CPU_QUOTA_DEFAULT_PERIOD_USEC;
709
710 if (period == USEC_INFINITY)
711 /* Default period was requested. */
712 period = CGROUP_CPU_QUOTA_DEFAULT_PERIOD_USEC;
713
714 /* Clamp to interval [1ms, 1s] */
715 new_period = cgroup_cpu_adjust_period(period, quota, USEC_PER_MSEC, USEC_PER_SEC);
716
717 if (new_period != period) {
718 char v[FORMAT_TIMESPAN_MAX];
719 log_unit_full(u, u->warned_clamping_cpu_quota_period ? LOG_DEBUG : LOG_WARNING, 0,
720 "Clamping CPU interval for cpu.max: period is now %s",
721 format_timespan(v, sizeof(v), new_period, 1));
722 u->warned_clamping_cpu_quota_period = true;
723 }
724
725 return new_period;
726 }
727
728 static void cgroup_apply_unified_cpu_weight(Unit *u, uint64_t weight) {
729 char buf[DECIMAL_STR_MAX(uint64_t) + 2];
730
731 xsprintf(buf, "%" PRIu64 "\n", weight);
732 (void) set_attribute_and_warn(u, "cpu", "cpu.weight", buf);
733 }
734
735 static void cgroup_apply_unified_cpu_quota(Unit *u, usec_t quota, usec_t period) {
736 char buf[(DECIMAL_STR_MAX(usec_t) + 1) * 2 + 1];
737
738 period = cgroup_cpu_adjust_period_and_log(u, period, quota);
739 if (quota != USEC_INFINITY)
740 xsprintf(buf, USEC_FMT " " USEC_FMT "\n",
741 MAX(quota * period / USEC_PER_SEC, USEC_PER_MSEC), period);
742 else
743 xsprintf(buf, "max " USEC_FMT "\n", period);
744 (void) set_attribute_and_warn(u, "cpu", "cpu.max", buf);
745 }
746
747 static void cgroup_apply_legacy_cpu_shares(Unit *u, uint64_t shares) {
748 char buf[DECIMAL_STR_MAX(uint64_t) + 2];
749
750 xsprintf(buf, "%" PRIu64 "\n", shares);
751 (void) set_attribute_and_warn(u, "cpu", "cpu.shares", buf);
752 }
753
754 static void cgroup_apply_legacy_cpu_quota(Unit *u, usec_t quota, usec_t period) {
755 char buf[DECIMAL_STR_MAX(usec_t) + 2];
756
757 period = cgroup_cpu_adjust_period_and_log(u, period, quota);
758
759 xsprintf(buf, USEC_FMT "\n", period);
760 (void) set_attribute_and_warn(u, "cpu", "cpu.cfs_period_us", buf);
761
762 if (quota != USEC_INFINITY) {
763 xsprintf(buf, USEC_FMT "\n", MAX(quota * period / USEC_PER_SEC, USEC_PER_MSEC));
764 (void) set_attribute_and_warn(u, "cpu", "cpu.cfs_quota_us", buf);
765 } else
766 (void) set_attribute_and_warn(u, "cpu", "cpu.cfs_quota_us", "-1\n");
767 }
768
769 static uint64_t cgroup_cpu_shares_to_weight(uint64_t shares) {
770 return CLAMP(shares * CGROUP_WEIGHT_DEFAULT / CGROUP_CPU_SHARES_DEFAULT,
771 CGROUP_WEIGHT_MIN, CGROUP_WEIGHT_MAX);
772 }
773
774 static uint64_t cgroup_cpu_weight_to_shares(uint64_t weight) {
775 return CLAMP(weight * CGROUP_CPU_SHARES_DEFAULT / CGROUP_WEIGHT_DEFAULT,
776 CGROUP_CPU_SHARES_MIN, CGROUP_CPU_SHARES_MAX);
777 }
778
779 static bool cgroup_context_has_io_config(CGroupContext *c) {
780 return c->io_accounting ||
781 c->io_weight != CGROUP_WEIGHT_INVALID ||
782 c->startup_io_weight != CGROUP_WEIGHT_INVALID ||
783 c->io_device_weights ||
784 c->io_device_latencies ||
785 c->io_device_limits;
786 }
787
788 static bool cgroup_context_has_blockio_config(CGroupContext *c) {
789 return c->blockio_accounting ||
790 c->blockio_weight != CGROUP_BLKIO_WEIGHT_INVALID ||
791 c->startup_blockio_weight != CGROUP_BLKIO_WEIGHT_INVALID ||
792 c->blockio_device_weights ||
793 c->blockio_device_bandwidths;
794 }
795
796 static uint64_t cgroup_context_io_weight(CGroupContext *c, ManagerState state) {
797 if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING) &&
798 c->startup_io_weight != CGROUP_WEIGHT_INVALID)
799 return c->startup_io_weight;
800 else if (c->io_weight != CGROUP_WEIGHT_INVALID)
801 return c->io_weight;
802 else
803 return CGROUP_WEIGHT_DEFAULT;
804 }
805
806 static uint64_t cgroup_context_blkio_weight(CGroupContext *c, ManagerState state) {
807 if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING) &&
808 c->startup_blockio_weight != CGROUP_BLKIO_WEIGHT_INVALID)
809 return c->startup_blockio_weight;
810 else if (c->blockio_weight != CGROUP_BLKIO_WEIGHT_INVALID)
811 return c->blockio_weight;
812 else
813 return CGROUP_BLKIO_WEIGHT_DEFAULT;
814 }
815
816 static uint64_t cgroup_weight_blkio_to_io(uint64_t blkio_weight) {
817 return CLAMP(blkio_weight * CGROUP_WEIGHT_DEFAULT / CGROUP_BLKIO_WEIGHT_DEFAULT,
818 CGROUP_WEIGHT_MIN, CGROUP_WEIGHT_MAX);
819 }
820
821 static uint64_t cgroup_weight_io_to_blkio(uint64_t io_weight) {
822 return CLAMP(io_weight * CGROUP_BLKIO_WEIGHT_DEFAULT / CGROUP_WEIGHT_DEFAULT,
823 CGROUP_BLKIO_WEIGHT_MIN, CGROUP_BLKIO_WEIGHT_MAX);
824 }
825
826 static void cgroup_apply_io_device_weight(Unit *u, const char *dev_path, uint64_t io_weight) {
827 char buf[DECIMAL_STR_MAX(dev_t)*2+2+DECIMAL_STR_MAX(uint64_t)+1];
828 dev_t dev;
829 int r;
830
831 r = lookup_block_device(dev_path, &dev);
832 if (r < 0)
833 return;
834
835 xsprintf(buf, "%u:%u %" PRIu64 "\n", major(dev), minor(dev), io_weight);
836 (void) set_attribute_and_warn(u, "io", "io.weight", buf);
837 }
838
839 static void cgroup_apply_blkio_device_weight(Unit *u, const char *dev_path, uint64_t blkio_weight) {
840 char buf[DECIMAL_STR_MAX(dev_t)*2+2+DECIMAL_STR_MAX(uint64_t)+1];
841 dev_t dev;
842 int r;
843
844 r = lookup_block_device(dev_path, &dev);
845 if (r < 0)
846 return;
847
848 xsprintf(buf, "%u:%u %" PRIu64 "\n", major(dev), minor(dev), blkio_weight);
849 (void) set_attribute_and_warn(u, "blkio", "blkio.weight_device", buf);
850 }
851
852 static void cgroup_apply_io_device_latency(Unit *u, const char *dev_path, usec_t target) {
853 char buf[DECIMAL_STR_MAX(dev_t)*2+2+7+DECIMAL_STR_MAX(uint64_t)+1];
854 dev_t dev;
855 int r;
856
857 r = lookup_block_device(dev_path, &dev);
858 if (r < 0)
859 return;
860
861 if (target != USEC_INFINITY)
862 xsprintf(buf, "%u:%u target=%" PRIu64 "\n", major(dev), minor(dev), target);
863 else
864 xsprintf(buf, "%u:%u target=max\n", major(dev), minor(dev));
865
866 (void) set_attribute_and_warn(u, "io", "io.latency", buf);
867 }
868
869 static void cgroup_apply_io_device_limit(Unit *u, const char *dev_path, uint64_t *limits) {
870 char limit_bufs[_CGROUP_IO_LIMIT_TYPE_MAX][DECIMAL_STR_MAX(uint64_t)];
871 char buf[DECIMAL_STR_MAX(dev_t)*2+2+(6+DECIMAL_STR_MAX(uint64_t)+1)*4];
872 CGroupIOLimitType type;
873 dev_t dev;
874 int r;
875
876 r = lookup_block_device(dev_path, &dev);
877 if (r < 0)
878 return;
879
880 for (type = 0; type < _CGROUP_IO_LIMIT_TYPE_MAX; type++)
881 if (limits[type] != cgroup_io_limit_defaults[type])
882 xsprintf(limit_bufs[type], "%" PRIu64, limits[type]);
883 else
884 xsprintf(limit_bufs[type], "%s", limits[type] == CGROUP_LIMIT_MAX ? "max" : "0");
885
886 xsprintf(buf, "%u:%u rbps=%s wbps=%s riops=%s wiops=%s\n", major(dev), minor(dev),
887 limit_bufs[CGROUP_IO_RBPS_MAX], limit_bufs[CGROUP_IO_WBPS_MAX],
888 limit_bufs[CGROUP_IO_RIOPS_MAX], limit_bufs[CGROUP_IO_WIOPS_MAX]);
889 (void) set_attribute_and_warn(u, "io", "io.max", buf);
890 }
891
892 static void cgroup_apply_blkio_device_limit(Unit *u, const char *dev_path, uint64_t rbps, uint64_t wbps) {
893 char buf[DECIMAL_STR_MAX(dev_t)*2+2+DECIMAL_STR_MAX(uint64_t)+1];
894 dev_t dev;
895 int r;
896
897 r = lookup_block_device(dev_path, &dev);
898 if (r < 0)
899 return;
900
901 sprintf(buf, "%u:%u %" PRIu64 "\n", major(dev), minor(dev), rbps);
902 (void) set_attribute_and_warn(u, "blkio", "blkio.throttle.read_bps_device", buf);
903
904 sprintf(buf, "%u:%u %" PRIu64 "\n", major(dev), minor(dev), wbps);
905 (void) set_attribute_and_warn(u, "blkio", "blkio.throttle.write_bps_device", buf);
906 }
907
908 static bool unit_has_unified_memory_config(Unit *u) {
909 CGroupContext *c;
910
911 assert(u);
912
913 c = unit_get_cgroup_context(u);
914 assert(c);
915
916 return c->memory_min > 0 || unit_get_ancestor_memory_low(u) > 0 ||
917 c->memory_high != CGROUP_LIMIT_MAX || c->memory_max != CGROUP_LIMIT_MAX ||
918 c->memory_swap_max != CGROUP_LIMIT_MAX;
919 }
920
921 static void cgroup_apply_unified_memory_limit(Unit *u, const char *file, uint64_t v) {
922 char buf[DECIMAL_STR_MAX(uint64_t) + 1] = "max\n";
923
924 if (v != CGROUP_LIMIT_MAX)
925 xsprintf(buf, "%" PRIu64 "\n", v);
926
927 (void) set_attribute_and_warn(u, "memory", file, buf);
928 }
929
930 static void cgroup_apply_firewall(Unit *u) {
931 assert(u);
932
933 /* Best-effort: let's apply IP firewalling and/or accounting if that's enabled */
934
935 if (bpf_firewall_compile(u) < 0)
936 return;
937
938 (void) bpf_firewall_install(u);
939 }
940
941 static void cgroup_context_apply(
942 Unit *u,
943 CGroupMask apply_mask,
944 ManagerState state) {
945
946 const char *path;
947 CGroupContext *c;
948 bool is_host_root, is_local_root;
949 int r;
950
951 assert(u);
952
953 /* Nothing to do? Exit early! */
954 if (apply_mask == 0)
955 return;
956
957 /* Some cgroup attributes are not supported on the host root cgroup, hence silently ignore them here. And other
958 * attributes should only be managed for cgroups further down the tree. */
959 is_local_root = unit_has_name(u, SPECIAL_ROOT_SLICE);
960 is_host_root = unit_has_host_root_cgroup(u);
961
962 assert_se(c = unit_get_cgroup_context(u));
963 assert_se(path = u->cgroup_path);
964
965 if (is_local_root) /* Make sure we don't try to display messages with an empty path. */
966 path = "/";
967
968 /* We generally ignore errors caused by read-only mounted cgroup trees (assuming we are running in a container
969 * then), and missing cgroups, i.e. EROFS and ENOENT. */
970
971 /* In fully unified mode these attributes don't exist on the host cgroup root. On legacy the weights exist, but
972 * setting the weight makes very little sense on the host root cgroup, as there are no other cgroups at this
973 * level. The quota exists there too, but any attempt to write to it is refused with EINVAL. Inside of
974 * containers we want to leave control of these to the container manager (and if cgroup v2 delegation is used
975 * we couldn't even write to them if we wanted to). */
976 if ((apply_mask & CGROUP_MASK_CPU) && !is_local_root) {
977
978 if (cg_all_unified() > 0) {
979 uint64_t weight;
980
981 if (cgroup_context_has_cpu_weight(c))
982 weight = cgroup_context_cpu_weight(c, state);
983 else if (cgroup_context_has_cpu_shares(c)) {
984 uint64_t shares;
985
986 shares = cgroup_context_cpu_shares(c, state);
987 weight = cgroup_cpu_shares_to_weight(shares);
988
989 log_cgroup_compat(u, "Applying [Startup]CPUShares=%" PRIu64 " as [Startup]CPUWeight=%" PRIu64 " on %s",
990 shares, weight, path);
991 } else
992 weight = CGROUP_WEIGHT_DEFAULT;
993
994 cgroup_apply_unified_cpu_weight(u, weight);
995 cgroup_apply_unified_cpu_quota(u, c->cpu_quota_per_sec_usec, c->cpu_quota_period_usec);
996
997 } else {
998 uint64_t shares;
999
1000 if (cgroup_context_has_cpu_weight(c)) {
1001 uint64_t weight;
1002
1003 weight = cgroup_context_cpu_weight(c, state);
1004 shares = cgroup_cpu_weight_to_shares(weight);
1005
1006 log_cgroup_compat(u, "Applying [Startup]CPUWeight=%" PRIu64 " as [Startup]CPUShares=%" PRIu64 " on %s",
1007 weight, shares, path);
1008 } else if (cgroup_context_has_cpu_shares(c))
1009 shares = cgroup_context_cpu_shares(c, state);
1010 else
1011 shares = CGROUP_CPU_SHARES_DEFAULT;
1012
1013 cgroup_apply_legacy_cpu_shares(u, shares);
1014 cgroup_apply_legacy_cpu_quota(u, c->cpu_quota_per_sec_usec, c->cpu_quota_period_usec);
1015 }
1016 }
1017
1018 /* The 'io' controller attributes are not exported on the host's root cgroup (being a pure cgroup v2
1019 * controller), and in case of containers we want to leave control of these attributes to the container manager
1020 * (and we couldn't access that stuff anyway, even if we tried if proper delegation is used). */
1021 if ((apply_mask & CGROUP_MASK_IO) && !is_local_root) {
1022 char buf[8+DECIMAL_STR_MAX(uint64_t)+1];
1023 bool has_io, has_blockio;
1024 uint64_t weight;
1025
1026 has_io = cgroup_context_has_io_config(c);
1027 has_blockio = cgroup_context_has_blockio_config(c);
1028
1029 if (has_io)
1030 weight = cgroup_context_io_weight(c, state);
1031 else if (has_blockio) {
1032 uint64_t blkio_weight;
1033
1034 blkio_weight = cgroup_context_blkio_weight(c, state);
1035 weight = cgroup_weight_blkio_to_io(blkio_weight);
1036
1037 log_cgroup_compat(u, "Applying [Startup]BlockIOWeight=%" PRIu64 " as [Startup]IOWeight=%" PRIu64,
1038 blkio_weight, weight);
1039 } else
1040 weight = CGROUP_WEIGHT_DEFAULT;
1041
1042 xsprintf(buf, "default %" PRIu64 "\n", weight);
1043 (void) set_attribute_and_warn(u, "io", "io.weight", buf);
1044
1045 if (has_io) {
1046 CGroupIODeviceLatency *latency;
1047 CGroupIODeviceLimit *limit;
1048 CGroupIODeviceWeight *w;
1049
1050 LIST_FOREACH(device_weights, w, c->io_device_weights)
1051 cgroup_apply_io_device_weight(u, w->path, w->weight);
1052
1053 LIST_FOREACH(device_limits, limit, c->io_device_limits)
1054 cgroup_apply_io_device_limit(u, limit->path, limit->limits);
1055
1056 LIST_FOREACH(device_latencies, latency, c->io_device_latencies)
1057 cgroup_apply_io_device_latency(u, latency->path, latency->target_usec);
1058
1059 } else if (has_blockio) {
1060 CGroupBlockIODeviceWeight *w;
1061 CGroupBlockIODeviceBandwidth *b;
1062
1063 LIST_FOREACH(device_weights, w, c->blockio_device_weights) {
1064 weight = cgroup_weight_blkio_to_io(w->weight);
1065
1066 log_cgroup_compat(u, "Applying BlockIODeviceWeight=%" PRIu64 " as IODeviceWeight=%" PRIu64 " for %s",
1067 w->weight, weight, w->path);
1068
1069 cgroup_apply_io_device_weight(u, w->path, weight);
1070 }
1071
1072 LIST_FOREACH(device_bandwidths, b, c->blockio_device_bandwidths) {
1073 uint64_t limits[_CGROUP_IO_LIMIT_TYPE_MAX];
1074 CGroupIOLimitType type;
1075
1076 for (type = 0; type < _CGROUP_IO_LIMIT_TYPE_MAX; type++)
1077 limits[type] = cgroup_io_limit_defaults[type];
1078
1079 limits[CGROUP_IO_RBPS_MAX] = b->rbps;
1080 limits[CGROUP_IO_WBPS_MAX] = b->wbps;
1081
1082 log_cgroup_compat(u, "Applying BlockIO{Read|Write}Bandwidth=%" PRIu64 " %" PRIu64 " as IO{Read|Write}BandwidthMax= for %s",
1083 b->rbps, b->wbps, b->path);
1084
1085 cgroup_apply_io_device_limit(u, b->path, limits);
1086 }
1087 }
1088 }
1089
1090 if (apply_mask & CGROUP_MASK_BLKIO) {
1091 bool has_io, has_blockio;
1092
1093 has_io = cgroup_context_has_io_config(c);
1094 has_blockio = cgroup_context_has_blockio_config(c);
1095
1096 /* Applying a 'weight' never makes sense for the host root cgroup, and for containers this should be
1097 * left to our container manager, too. */
1098 if (!is_local_root) {
1099 char buf[DECIMAL_STR_MAX(uint64_t)+1];
1100 uint64_t weight;
1101
1102 if (has_io) {
1103 uint64_t io_weight;
1104
1105 io_weight = cgroup_context_io_weight(c, state);
1106 weight = cgroup_weight_io_to_blkio(cgroup_context_io_weight(c, state));
1107
1108 log_cgroup_compat(u, "Applying [Startup]IOWeight=%" PRIu64 " as [Startup]BlockIOWeight=%" PRIu64,
1109 io_weight, weight);
1110 } else if (has_blockio)
1111 weight = cgroup_context_blkio_weight(c, state);
1112 else
1113 weight = CGROUP_BLKIO_WEIGHT_DEFAULT;
1114
1115 xsprintf(buf, "%" PRIu64 "\n", weight);
1116 (void) set_attribute_and_warn(u, "blkio", "blkio.weight", buf);
1117
1118 if (has_io) {
1119 CGroupIODeviceWeight *w;
1120
1121 LIST_FOREACH(device_weights, w, c->io_device_weights) {
1122 weight = cgroup_weight_io_to_blkio(w->weight);
1123
1124 log_cgroup_compat(u, "Applying IODeviceWeight=%" PRIu64 " as BlockIODeviceWeight=%" PRIu64 " for %s",
1125 w->weight, weight, w->path);
1126
1127 cgroup_apply_blkio_device_weight(u, w->path, weight);
1128 }
1129 } else if (has_blockio) {
1130 CGroupBlockIODeviceWeight *w;
1131
1132 LIST_FOREACH(device_weights, w, c->blockio_device_weights)
1133 cgroup_apply_blkio_device_weight(u, w->path, w->weight);
1134 }
1135 }
1136
1137 /* The bandwith limits are something that make sense to be applied to the host's root but not container
1138 * roots, as there we want the container manager to handle it */
1139 if (is_host_root || !is_local_root) {
1140 if (has_io) {
1141 CGroupIODeviceLimit *l;
1142
1143 LIST_FOREACH(device_limits, l, c->io_device_limits) {
1144 log_cgroup_compat(u, "Applying IO{Read|Write}Bandwidth=%" PRIu64 " %" PRIu64 " as BlockIO{Read|Write}BandwidthMax= for %s",
1145 l->limits[CGROUP_IO_RBPS_MAX], l->limits[CGROUP_IO_WBPS_MAX], l->path);
1146
1147 cgroup_apply_blkio_device_limit(u, l->path, l->limits[CGROUP_IO_RBPS_MAX], l->limits[CGROUP_IO_WBPS_MAX]);
1148 }
1149 } else if (has_blockio) {
1150 CGroupBlockIODeviceBandwidth *b;
1151
1152 LIST_FOREACH(device_bandwidths, b, c->blockio_device_bandwidths)
1153 cgroup_apply_blkio_device_limit(u, b->path, b->rbps, b->wbps);
1154 }
1155 }
1156 }
1157
1158 /* In unified mode 'memory' attributes do not exist on the root cgroup. In legacy mode 'memory.limit_in_bytes'
1159 * exists on the root cgroup, but any writes to it are refused with EINVAL. And if we run in a container we
1160 * want to leave control to the container manager (and if proper cgroup v2 delegation is used we couldn't even
1161 * write to this if we wanted to.) */
1162 if ((apply_mask & CGROUP_MASK_MEMORY) && !is_local_root) {
1163
1164 if (cg_all_unified() > 0) {
1165 uint64_t max, swap_max = CGROUP_LIMIT_MAX;
1166
1167 if (unit_has_unified_memory_config(u)) {
1168 max = c->memory_max;
1169 swap_max = c->memory_swap_max;
1170 } else {
1171 max = c->memory_limit;
1172
1173 if (max != CGROUP_LIMIT_MAX)
1174 log_cgroup_compat(u, "Applying MemoryLimit=%" PRIu64 " as MemoryMax=", max);
1175 }
1176
1177 cgroup_apply_unified_memory_limit(u, "memory.min", c->memory_min);
1178 cgroup_apply_unified_memory_limit(u, "memory.low", unit_get_ancestor_memory_low(u));
1179 cgroup_apply_unified_memory_limit(u, "memory.high", c->memory_high);
1180 cgroup_apply_unified_memory_limit(u, "memory.max", max);
1181 cgroup_apply_unified_memory_limit(u, "memory.swap.max", swap_max);
1182
1183 (void) set_attribute_and_warn(u, "memory", "memory.oom.group", one_zero(c->memory_oom_group));
1184
1185 } else {
1186 char buf[DECIMAL_STR_MAX(uint64_t) + 1];
1187 uint64_t val;
1188
1189 if (unit_has_unified_memory_config(u)) {
1190 val = c->memory_max;
1191 log_cgroup_compat(u, "Applying MemoryMax=%" PRIi64 " as MemoryLimit=", val);
1192 } else
1193 val = c->memory_limit;
1194
1195 if (val == CGROUP_LIMIT_MAX)
1196 strncpy(buf, "-1\n", sizeof(buf));
1197 else
1198 xsprintf(buf, "%" PRIu64 "\n", val);
1199
1200 (void) set_attribute_and_warn(u, "memory", "memory.limit_in_bytes", buf);
1201 }
1202 }
1203
1204 /* On cgroup v2 we can apply BPF everywhere. On cgroup v1 we apply it everywhere except for the root of
1205 * containers, where we leave this to the manager */
1206 if ((apply_mask & (CGROUP_MASK_DEVICES | CGROUP_MASK_BPF_DEVICES)) &&
1207 (is_host_root || cg_all_unified() > 0 || !is_local_root)) {
1208 _cleanup_(bpf_program_unrefp) BPFProgram *prog = NULL;
1209 CGroupDeviceAllow *a;
1210
1211 if (cg_all_unified() > 0) {
1212 r = cgroup_init_device_bpf(&prog, c->device_policy, c->device_allow);
1213 if (r < 0)
1214 log_unit_warning_errno(u, r, "Failed to initialize device control bpf program: %m");
1215 } else {
1216 /* Changing the devices list of a populated cgroup might result in EINVAL, hence ignore EINVAL
1217 * here. */
1218
1219 if (c->device_allow || c->device_policy != CGROUP_AUTO)
1220 r = cg_set_attribute("devices", path, "devices.deny", "a");
1221 else
1222 r = cg_set_attribute("devices", path, "devices.allow", "a");
1223 if (r < 0)
1224 log_unit_full(u, IN_SET(r, -ENOENT, -EROFS, -EINVAL, -EACCES, -EPERM) ? LOG_DEBUG : LOG_WARNING, r,
1225 "Failed to reset devices.allow/devices.deny: %m");
1226 }
1227
1228 if (c->device_policy == CGROUP_CLOSED ||
1229 (c->device_policy == CGROUP_AUTO && c->device_allow)) {
1230 static const char auto_devices[] =
1231 "/dev/null\0" "rwm\0"
1232 "/dev/zero\0" "rwm\0"
1233 "/dev/full\0" "rwm\0"
1234 "/dev/random\0" "rwm\0"
1235 "/dev/urandom\0" "rwm\0"
1236 "/dev/tty\0" "rwm\0"
1237 "/dev/ptmx\0" "rwm\0"
1238 /* Allow /run/systemd/inaccessible/{chr,blk} devices for mapping InaccessiblePaths */
1239 "/run/systemd/inaccessible/chr\0" "rwm\0"
1240 "/run/systemd/inaccessible/blk\0" "rwm\0";
1241
1242 const char *x, *y;
1243
1244 NULSTR_FOREACH_PAIR(x, y, auto_devices)
1245 (void) whitelist_device(prog, path, x, y);
1246
1247 /* PTS (/dev/pts) devices may not be duplicated, but accessed */
1248 (void) whitelist_major(prog, path, "pts", 'c', "rw");
1249 }
1250
1251 LIST_FOREACH(device_allow, a, c->device_allow) {
1252 char acc[4], *val;
1253 unsigned k = 0;
1254
1255 if (a->r)
1256 acc[k++] = 'r';
1257 if (a->w)
1258 acc[k++] = 'w';
1259 if (a->m)
1260 acc[k++] = 'm';
1261
1262 if (k == 0)
1263 continue;
1264
1265 acc[k++] = 0;
1266
1267 if (path_startswith(a->path, "/dev/"))
1268 (void) whitelist_device(prog, path, a->path, acc);
1269 else if ((val = startswith(a->path, "block-")))
1270 (void) whitelist_major(prog, path, val, 'b', acc);
1271 else if ((val = startswith(a->path, "char-")))
1272 (void) whitelist_major(prog, path, val, 'c', acc);
1273 else
1274 log_unit_debug(u, "Ignoring device '%s' while writing cgroup attribute.", a->path);
1275 }
1276
1277 r = cgroup_apply_device_bpf(u, prog, c->device_policy, c->device_allow);
1278 if (r < 0) {
1279 static bool warned = false;
1280
1281 log_full_errno(warned ? LOG_DEBUG : LOG_WARNING, r,
1282 "Unit %s configures device ACL, but the local system doesn't seem to support the BPF-based device controller.\n"
1283 "Proceeding WITHOUT applying ACL (all devices will be accessible)!\n"
1284 "(This warning is only shown for the first loaded unit using device ACL.)", u->id);
1285
1286 warned = true;
1287 }
1288 }
1289
1290 if (apply_mask & CGROUP_MASK_PIDS) {
1291
1292 if (is_host_root) {
1293 /* So, the "pids" controller does not expose anything on the root cgroup, in order not to
1294 * replicate knobs exposed elsewhere needlessly. We abstract this away here however, and when
1295 * the knobs of the root cgroup are modified propagate this to the relevant sysctls. There's a
1296 * non-obvious asymmetry however: unlike the cgroup properties we don't really want to take
1297 * exclusive ownership of the sysctls, but we still want to honour things if the user sets
1298 * limits. Hence we employ sort of a one-way strategy: when the user sets a bounded limit
1299 * through us it counts. When the user afterwards unsets it again (i.e. sets it to unbounded)
1300 * it also counts. But if the user never set a limit through us (i.e. we are the default of
1301 * "unbounded") we leave things unmodified. For this we manage a global boolean that we turn on
1302 * the first time we set a limit. Note that this boolean is flushed out on manager reload,
1303 * which is desirable so that there's an offical way to release control of the sysctl from
1304 * systemd: set the limit to unbounded and reload. */
1305
1306 if (c->tasks_max != CGROUP_LIMIT_MAX) {
1307 u->manager->sysctl_pid_max_changed = true;
1308 r = procfs_tasks_set_limit(c->tasks_max);
1309 } else if (u->manager->sysctl_pid_max_changed)
1310 r = procfs_tasks_set_limit(TASKS_MAX);
1311 else
1312 r = 0;
1313 if (r < 0)
1314 log_unit_full(u, LOG_LEVEL_CGROUP_WRITE(r), r,
1315 "Failed to write to tasks limit sysctls: %m");
1316 }
1317
1318 /* The attribute itself is not available on the host root cgroup, and in the container case we want to
1319 * leave it for the container manager. */
1320 if (!is_local_root) {
1321 if (c->tasks_max != CGROUP_LIMIT_MAX) {
1322 char buf[DECIMAL_STR_MAX(uint64_t) + 2];
1323
1324 sprintf(buf, "%" PRIu64 "\n", c->tasks_max);
1325 (void) set_attribute_and_warn(u, "pids", "pids.max", buf);
1326 } else
1327 (void) set_attribute_and_warn(u, "pids", "pids.max", "max\n");
1328 }
1329 }
1330
1331 if (apply_mask & CGROUP_MASK_BPF_FIREWALL)
1332 cgroup_apply_firewall(u);
1333 }
1334
1335 static bool unit_get_needs_bpf_firewall(Unit *u) {
1336 CGroupContext *c;
1337 Unit *p;
1338 assert(u);
1339
1340 c = unit_get_cgroup_context(u);
1341 if (!c)
1342 return false;
1343
1344 if (c->ip_accounting ||
1345 c->ip_address_allow ||
1346 c->ip_address_deny)
1347 return true;
1348
1349 /* If any parent slice has an IP access list defined, it applies too */
1350 for (p = UNIT_DEREF(u->slice); p; p = UNIT_DEREF(p->slice)) {
1351 c = unit_get_cgroup_context(p);
1352 if (!c)
1353 return false;
1354
1355 if (c->ip_address_allow ||
1356 c->ip_address_deny)
1357 return true;
1358 }
1359
1360 return false;
1361 }
1362
1363 static CGroupMask unit_get_cgroup_mask(Unit *u) {
1364 CGroupMask mask = 0;
1365 CGroupContext *c;
1366
1367 assert(u);
1368
1369 c = unit_get_cgroup_context(u);
1370
1371 /* Figure out which controllers we need, based on the cgroup context object */
1372
1373 if (c->cpu_accounting)
1374 mask |= get_cpu_accounting_mask();
1375
1376 if (cgroup_context_has_cpu_weight(c) ||
1377 cgroup_context_has_cpu_shares(c) ||
1378 c->cpu_quota_per_sec_usec != USEC_INFINITY)
1379 mask |= CGROUP_MASK_CPU;
1380
1381 if (cgroup_context_has_io_config(c) || cgroup_context_has_blockio_config(c))
1382 mask |= CGROUP_MASK_IO | CGROUP_MASK_BLKIO;
1383
1384 if (c->memory_accounting ||
1385 c->memory_limit != CGROUP_LIMIT_MAX ||
1386 unit_has_unified_memory_config(u))
1387 mask |= CGROUP_MASK_MEMORY;
1388
1389 if (c->device_allow ||
1390 c->device_policy != CGROUP_AUTO)
1391 mask |= CGROUP_MASK_DEVICES | CGROUP_MASK_BPF_DEVICES;
1392
1393 if (c->tasks_accounting ||
1394 c->tasks_max != CGROUP_LIMIT_MAX)
1395 mask |= CGROUP_MASK_PIDS;
1396
1397 return CGROUP_MASK_EXTEND_JOINED(mask);
1398 }
1399
1400 static CGroupMask unit_get_bpf_mask(Unit *u) {
1401 CGroupMask mask = 0;
1402
1403 /* Figure out which controllers we need, based on the cgroup context, possibly taking into account children
1404 * too. */
1405
1406 if (unit_get_needs_bpf_firewall(u))
1407 mask |= CGROUP_MASK_BPF_FIREWALL;
1408
1409 return mask;
1410 }
1411
1412 CGroupMask unit_get_own_mask(Unit *u) {
1413 CGroupContext *c;
1414
1415 /* Returns the mask of controllers the unit needs for itself. If a unit is not properly loaded, return an empty
1416 * mask, as we shouldn't reflect it in the cgroup hierarchy then. */
1417
1418 if (u->load_state != UNIT_LOADED)
1419 return 0;
1420
1421 c = unit_get_cgroup_context(u);
1422 if (!c)
1423 return 0;
1424
1425 return (unit_get_cgroup_mask(u) | unit_get_bpf_mask(u) | unit_get_delegate_mask(u)) & ~unit_get_ancestor_disable_mask(u);
1426 }
1427
1428 CGroupMask unit_get_delegate_mask(Unit *u) {
1429 CGroupContext *c;
1430
1431 /* If delegation is turned on, then turn on selected controllers, unless we are on the legacy hierarchy and the
1432 * process we fork into is known to drop privileges, and hence shouldn't get access to the controllers.
1433 *
1434 * Note that on the unified hierarchy it is safe to delegate controllers to unprivileged services. */
1435
1436 if (!unit_cgroup_delegate(u))
1437 return 0;
1438
1439 if (cg_all_unified() <= 0) {
1440 ExecContext *e;
1441
1442 e = unit_get_exec_context(u);
1443 if (e && !exec_context_maintains_privileges(e))
1444 return 0;
1445 }
1446
1447 assert_se(c = unit_get_cgroup_context(u));
1448 return CGROUP_MASK_EXTEND_JOINED(c->delegate_controllers);
1449 }
1450
1451 CGroupMask unit_get_members_mask(Unit *u) {
1452 assert(u);
1453
1454 /* Returns the mask of controllers all of the unit's children require, merged */
1455
1456 if (u->cgroup_members_mask_valid)
1457 return u->cgroup_members_mask; /* Use cached value if possible */
1458
1459 u->cgroup_members_mask = 0;
1460
1461 if (u->type == UNIT_SLICE) {
1462 void *v;
1463 Unit *member;
1464 Iterator i;
1465
1466 HASHMAP_FOREACH_KEY(v, member, u->dependencies[UNIT_BEFORE], i) {
1467 if (UNIT_DEREF(member->slice) == u)
1468 u->cgroup_members_mask |= unit_get_subtree_mask(member); /* note that this calls ourselves again, for the children */
1469 }
1470 }
1471
1472 u->cgroup_members_mask_valid = true;
1473 return u->cgroup_members_mask;
1474 }
1475
1476 CGroupMask unit_get_siblings_mask(Unit *u) {
1477 assert(u);
1478
1479 /* Returns the mask of controllers all of the unit's siblings
1480 * require, i.e. the members mask of the unit's parent slice
1481 * if there is one. */
1482
1483 if (UNIT_ISSET(u->slice))
1484 return unit_get_members_mask(UNIT_DEREF(u->slice));
1485
1486 return unit_get_subtree_mask(u); /* we are the top-level slice */
1487 }
1488
1489 CGroupMask unit_get_disable_mask(Unit *u) {
1490 CGroupContext *c;
1491
1492 c = unit_get_cgroup_context(u);
1493 if (!c)
1494 return 0;
1495
1496 return c->disable_controllers;
1497 }
1498
1499 CGroupMask unit_get_ancestor_disable_mask(Unit *u) {
1500 CGroupMask mask;
1501
1502 assert(u);
1503 mask = unit_get_disable_mask(u);
1504
1505 /* Returns the mask of controllers which are marked as forcibly
1506 * disabled in any ancestor unit or the unit in question. */
1507
1508 if (UNIT_ISSET(u->slice))
1509 mask |= unit_get_ancestor_disable_mask(UNIT_DEREF(u->slice));
1510
1511 return mask;
1512 }
1513
1514 CGroupMask unit_get_subtree_mask(Unit *u) {
1515
1516 /* Returns the mask of this subtree, meaning of the group
1517 * itself and its children. */
1518
1519 return unit_get_own_mask(u) | unit_get_members_mask(u);
1520 }
1521
1522 CGroupMask unit_get_target_mask(Unit *u) {
1523 CGroupMask mask;
1524
1525 /* This returns the cgroup mask of all controllers to enable
1526 * for a specific cgroup, i.e. everything it needs itself,
1527 * plus all that its children need, plus all that its siblings
1528 * need. This is primarily useful on the legacy cgroup
1529 * hierarchy, where we need to duplicate each cgroup in each
1530 * hierarchy that shall be enabled for it. */
1531
1532 mask = unit_get_own_mask(u) | unit_get_members_mask(u) | unit_get_siblings_mask(u);
1533 mask &= u->manager->cgroup_supported;
1534 mask &= ~unit_get_ancestor_disable_mask(u);
1535
1536 return mask;
1537 }
1538
1539 CGroupMask unit_get_enable_mask(Unit *u) {
1540 CGroupMask mask;
1541
1542 /* This returns the cgroup mask of all controllers to enable
1543 * for the children of a specific cgroup. This is primarily
1544 * useful for the unified cgroup hierarchy, where each cgroup
1545 * controls which controllers are enabled for its children. */
1546
1547 mask = unit_get_members_mask(u);
1548 mask &= u->manager->cgroup_supported;
1549 mask &= ~unit_get_ancestor_disable_mask(u);
1550
1551 return mask;
1552 }
1553
1554 void unit_invalidate_cgroup_members_masks(Unit *u) {
1555 assert(u);
1556
1557 /* Recurse invalidate the member masks cache all the way up the tree */
1558 u->cgroup_members_mask_valid = false;
1559
1560 if (UNIT_ISSET(u->slice))
1561 unit_invalidate_cgroup_members_masks(UNIT_DEREF(u->slice));
1562 }
1563
1564 const char *unit_get_realized_cgroup_path(Unit *u, CGroupMask mask) {
1565
1566 /* Returns the realized cgroup path of the specified unit where all specified controllers are available. */
1567
1568 while (u) {
1569
1570 if (u->cgroup_path &&
1571 u->cgroup_realized &&
1572 FLAGS_SET(u->cgroup_realized_mask, mask))
1573 return u->cgroup_path;
1574
1575 u = UNIT_DEREF(u->slice);
1576 }
1577
1578 return NULL;
1579 }
1580
1581 static const char *migrate_callback(CGroupMask mask, void *userdata) {
1582 return unit_get_realized_cgroup_path(userdata, mask);
1583 }
1584
1585 char *unit_default_cgroup_path(const Unit *u) {
1586 _cleanup_free_ char *escaped = NULL, *slice = NULL;
1587 int r;
1588
1589 assert(u);
1590
1591 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1592 return strdup(u->manager->cgroup_root);
1593
1594 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1595 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
1596 if (r < 0)
1597 return NULL;
1598 }
1599
1600 escaped = cg_escape(u->id);
1601 if (!escaped)
1602 return NULL;
1603
1604 if (slice)
1605 return strjoin(u->manager->cgroup_root, "/", slice, "/",
1606 escaped);
1607 else
1608 return strjoin(u->manager->cgroup_root, "/", escaped);
1609 }
1610
1611 int unit_set_cgroup_path(Unit *u, const char *path) {
1612 _cleanup_free_ char *p = NULL;
1613 int r;
1614
1615 assert(u);
1616
1617 if (streq_ptr(u->cgroup_path, path))
1618 return 0;
1619
1620 if (path) {
1621 p = strdup(path);
1622 if (!p)
1623 return -ENOMEM;
1624 }
1625
1626 if (p) {
1627 r = hashmap_put(u->manager->cgroup_unit, p, u);
1628 if (r < 0)
1629 return r;
1630 }
1631
1632 unit_release_cgroup(u);
1633 u->cgroup_path = TAKE_PTR(p);
1634
1635 return 1;
1636 }
1637
1638 int unit_watch_cgroup(Unit *u) {
1639 _cleanup_free_ char *events = NULL;
1640 int r;
1641
1642 assert(u);
1643
1644 /* Watches the "cgroups.events" attribute of this unit's cgroup for "empty" events, but only if
1645 * cgroupv2 is available. */
1646
1647 if (!u->cgroup_path)
1648 return 0;
1649
1650 if (u->cgroup_control_inotify_wd >= 0)
1651 return 0;
1652
1653 /* Only applies to the unified hierarchy */
1654 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
1655 if (r < 0)
1656 return log_error_errno(r, "Failed to determine whether the name=systemd hierarchy is unified: %m");
1657 if (r == 0)
1658 return 0;
1659
1660 /* No point in watch the top-level slice, it's never going to run empty. */
1661 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1662 return 0;
1663
1664 r = hashmap_ensure_allocated(&u->manager->cgroup_control_inotify_wd_unit, &trivial_hash_ops);
1665 if (r < 0)
1666 return log_oom();
1667
1668 r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, "cgroup.events", &events);
1669 if (r < 0)
1670 return log_oom();
1671
1672 u->cgroup_control_inotify_wd = inotify_add_watch(u->manager->cgroup_inotify_fd, events, IN_MODIFY);
1673 if (u->cgroup_control_inotify_wd < 0) {
1674
1675 if (errno == ENOENT) /* If the directory is already gone we don't need to track it, so this
1676 * is not an error */
1677 return 0;
1678
1679 return log_unit_error_errno(u, errno, "Failed to add control inotify watch descriptor for control group %s: %m", u->cgroup_path);
1680 }
1681
1682 r = hashmap_put(u->manager->cgroup_control_inotify_wd_unit, INT_TO_PTR(u->cgroup_control_inotify_wd), u);
1683 if (r < 0)
1684 return log_unit_error_errno(u, r, "Failed to add control inotify watch descriptor to hash map: %m");
1685
1686 return 0;
1687 }
1688
1689 int unit_watch_cgroup_memory(Unit *u) {
1690 _cleanup_free_ char *events = NULL;
1691 CGroupContext *c;
1692 int r;
1693
1694 assert(u);
1695
1696 /* Watches the "memory.events" attribute of this unit's cgroup for "oom_kill" events, but only if
1697 * cgroupv2 is available. */
1698
1699 if (!u->cgroup_path)
1700 return 0;
1701
1702 c = unit_get_cgroup_context(u);
1703 if (!c)
1704 return 0;
1705
1706 /* The "memory.events" attribute is only available if the memory controller is on. Let's hence tie
1707 * this to memory accounting, in a way watching for OOM kills is a form of memory accounting after
1708 * all. */
1709 if (!c->memory_accounting)
1710 return 0;
1711
1712 /* Don't watch inner nodes, as the kernel doesn't report oom_kill events recursively currently, and
1713 * we also don't want to generate a log message for each parent cgroup of a process. */
1714 if (u->type == UNIT_SLICE)
1715 return 0;
1716
1717 if (u->cgroup_memory_inotify_wd >= 0)
1718 return 0;
1719
1720 /* Only applies to the unified hierarchy */
1721 r = cg_all_unified();
1722 if (r < 0)
1723 return log_error_errno(r, "Failed to determine whether the memory controller is unified: %m");
1724 if (r == 0)
1725 return 0;
1726
1727 r = hashmap_ensure_allocated(&u->manager->cgroup_memory_inotify_wd_unit, &trivial_hash_ops);
1728 if (r < 0)
1729 return log_oom();
1730
1731 r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, "memory.events", &events);
1732 if (r < 0)
1733 return log_oom();
1734
1735 u->cgroup_memory_inotify_wd = inotify_add_watch(u->manager->cgroup_inotify_fd, events, IN_MODIFY);
1736 if (u->cgroup_memory_inotify_wd < 0) {
1737
1738 if (errno == ENOENT) /* If the directory is already gone we don't need to track it, so this
1739 * is not an error */
1740 return 0;
1741
1742 return log_unit_error_errno(u, errno, "Failed to add memory inotify watch descriptor for control group %s: %m", u->cgroup_path);
1743 }
1744
1745 r = hashmap_put(u->manager->cgroup_memory_inotify_wd_unit, INT_TO_PTR(u->cgroup_memory_inotify_wd), u);
1746 if (r < 0)
1747 return log_unit_error_errno(u, r, "Failed to add memory inotify watch descriptor to hash map: %m");
1748
1749 return 0;
1750 }
1751
1752 int unit_pick_cgroup_path(Unit *u) {
1753 _cleanup_free_ char *path = NULL;
1754 int r;
1755
1756 assert(u);
1757
1758 if (u->cgroup_path)
1759 return 0;
1760
1761 if (!UNIT_HAS_CGROUP_CONTEXT(u))
1762 return -EINVAL;
1763
1764 path = unit_default_cgroup_path(u);
1765 if (!path)
1766 return log_oom();
1767
1768 r = unit_set_cgroup_path(u, path);
1769 if (r == -EEXIST)
1770 return log_unit_error_errno(u, r, "Control group %s exists already.", path);
1771 if (r < 0)
1772 return log_unit_error_errno(u, r, "Failed to set unit's control group path to %s: %m", path);
1773
1774 return 0;
1775 }
1776
1777 static int unit_create_cgroup(
1778 Unit *u,
1779 CGroupMask target_mask,
1780 CGroupMask enable_mask,
1781 ManagerState state) {
1782
1783 bool created;
1784 int r;
1785
1786 assert(u);
1787
1788 if (!UNIT_HAS_CGROUP_CONTEXT(u))
1789 return 0;
1790
1791 /* Figure out our cgroup path */
1792 r = unit_pick_cgroup_path(u);
1793 if (r < 0)
1794 return r;
1795
1796 /* First, create our own group */
1797 r = cg_create_everywhere(u->manager->cgroup_supported, target_mask, u->cgroup_path);
1798 if (r < 0)
1799 return log_unit_error_errno(u, r, "Failed to create cgroup %s: %m", u->cgroup_path);
1800 created = r;
1801
1802 /* Start watching it */
1803 (void) unit_watch_cgroup(u);
1804 (void) unit_watch_cgroup_memory(u);
1805
1806 /* Preserve enabled controllers in delegated units, adjust others. */
1807 if (created || !u->cgroup_realized || !unit_cgroup_delegate(u)) {
1808 CGroupMask result_mask = 0;
1809
1810 /* Enable all controllers we need */
1811 r = cg_enable_everywhere(u->manager->cgroup_supported, enable_mask, u->cgroup_path, &result_mask);
1812 if (r < 0)
1813 log_unit_warning_errno(u, r, "Failed to enable/disable controllers on cgroup %s, ignoring: %m", u->cgroup_path);
1814
1815 /* If we just turned off a controller, this might release the controller for our parent too, let's
1816 * enqueue the parent for re-realization in that case again. */
1817 if (UNIT_ISSET(u->slice)) {
1818 CGroupMask turned_off;
1819
1820 turned_off = (u->cgroup_realized ? u->cgroup_enabled_mask & ~result_mask : 0);
1821 if (turned_off != 0) {
1822 Unit *parent;
1823
1824 /* Force the parent to propagate the enable mask to the kernel again, by invalidating
1825 * the controller we just turned off. */
1826
1827 for (parent = UNIT_DEREF(u->slice); parent; parent = UNIT_DEREF(parent->slice))
1828 unit_invalidate_cgroup(parent, turned_off);
1829 }
1830 }
1831
1832 /* Remember what's actually enabled now */
1833 u->cgroup_enabled_mask = result_mask;
1834 }
1835
1836 /* Keep track that this is now realized */
1837 u->cgroup_realized = true;
1838 u->cgroup_realized_mask = target_mask;
1839
1840 if (u->type != UNIT_SLICE && !unit_cgroup_delegate(u)) {
1841
1842 /* Then, possibly move things over, but not if
1843 * subgroups may contain processes, which is the case
1844 * for slice and delegation units. */
1845 r = cg_migrate_everywhere(u->manager->cgroup_supported, u->cgroup_path, u->cgroup_path, migrate_callback, u);
1846 if (r < 0)
1847 log_unit_warning_errno(u, r, "Failed to migrate cgroup from to %s, ignoring: %m", u->cgroup_path);
1848 }
1849
1850 /* Set attributes */
1851 cgroup_context_apply(u, target_mask, state);
1852 cgroup_xattr_apply(u);
1853
1854 return 0;
1855 }
1856
1857 static int unit_attach_pid_to_cgroup_via_bus(Unit *u, pid_t pid, const char *suffix_path) {
1858 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1859 char *pp;
1860 int r;
1861
1862 assert(u);
1863
1864 if (MANAGER_IS_SYSTEM(u->manager))
1865 return -EINVAL;
1866
1867 if (!u->manager->system_bus)
1868 return -EIO;
1869
1870 if (!u->cgroup_path)
1871 return -EINVAL;
1872
1873 /* Determine this unit's cgroup path relative to our cgroup root */
1874 pp = path_startswith(u->cgroup_path, u->manager->cgroup_root);
1875 if (!pp)
1876 return -EINVAL;
1877
1878 pp = strjoina("/", pp, suffix_path);
1879 path_simplify(pp, false);
1880
1881 r = sd_bus_call_method(u->manager->system_bus,
1882 "org.freedesktop.systemd1",
1883 "/org/freedesktop/systemd1",
1884 "org.freedesktop.systemd1.Manager",
1885 "AttachProcessesToUnit",
1886 &error, NULL,
1887 "ssau",
1888 NULL /* empty unit name means client's unit, i.e. us */, pp, 1, (uint32_t) pid);
1889 if (r < 0)
1890 return log_unit_debug_errno(u, r, "Failed to attach unit process " PID_FMT " via the bus: %s", pid, bus_error_message(&error, r));
1891
1892 return 0;
1893 }
1894
1895 int unit_attach_pids_to_cgroup(Unit *u, Set *pids, const char *suffix_path) {
1896 CGroupMask delegated_mask;
1897 const char *p;
1898 Iterator i;
1899 void *pidp;
1900 int r, q;
1901
1902 assert(u);
1903
1904 if (!UNIT_HAS_CGROUP_CONTEXT(u))
1905 return -EINVAL;
1906
1907 if (set_isempty(pids))
1908 return 0;
1909
1910 r = unit_realize_cgroup(u);
1911 if (r < 0)
1912 return r;
1913
1914 if (isempty(suffix_path))
1915 p = u->cgroup_path;
1916 else
1917 p = strjoina(u->cgroup_path, "/", suffix_path);
1918
1919 delegated_mask = unit_get_delegate_mask(u);
1920
1921 r = 0;
1922 SET_FOREACH(pidp, pids, i) {
1923 pid_t pid = PTR_TO_PID(pidp);
1924 CGroupController c;
1925
1926 /* First, attach the PID to the main cgroup hierarchy */
1927 q = cg_attach(SYSTEMD_CGROUP_CONTROLLER, p, pid);
1928 if (q < 0) {
1929 log_unit_debug_errno(u, q, "Couldn't move process " PID_FMT " to requested cgroup '%s': %m", pid, p);
1930
1931 if (MANAGER_IS_USER(u->manager) && IN_SET(q, -EPERM, -EACCES)) {
1932 int z;
1933
1934 /* If we are in a user instance, and we can't move the process ourselves due to
1935 * permission problems, let's ask the system instance about it instead. Since it's more
1936 * privileged it might be able to move the process across the leaves of a subtree who's
1937 * top node is not owned by us. */
1938
1939 z = unit_attach_pid_to_cgroup_via_bus(u, pid, suffix_path);
1940 if (z < 0)
1941 log_unit_debug_errno(u, z, "Couldn't move process " PID_FMT " to requested cgroup '%s' via the system bus either: %m", pid, p);
1942 else
1943 continue; /* When the bus thing worked via the bus we are fully done for this PID. */
1944 }
1945
1946 if (r >= 0)
1947 r = q; /* Remember first error */
1948
1949 continue;
1950 }
1951
1952 q = cg_all_unified();
1953 if (q < 0)
1954 return q;
1955 if (q > 0)
1956 continue;
1957
1958 /* In the legacy hierarchy, attach the process to the request cgroup if possible, and if not to the
1959 * innermost realized one */
1960
1961 for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1962 CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
1963 const char *realized;
1964
1965 if (!(u->manager->cgroup_supported & bit))
1966 continue;
1967
1968 /* If this controller is delegated and realized, honour the caller's request for the cgroup suffix. */
1969 if (delegated_mask & u->cgroup_realized_mask & bit) {
1970 q = cg_attach(cgroup_controller_to_string(c), p, pid);
1971 if (q >= 0)
1972 continue; /* Success! */
1973
1974 log_unit_debug_errno(u, q, "Failed to attach PID " PID_FMT " to requested cgroup %s in controller %s, falling back to unit's cgroup: %m",
1975 pid, p, cgroup_controller_to_string(c));
1976 }
1977
1978 /* So this controller is either not delegate or realized, or something else weird happened. In
1979 * that case let's attach the PID at least to the closest cgroup up the tree that is
1980 * realized. */
1981 realized = unit_get_realized_cgroup_path(u, bit);
1982 if (!realized)
1983 continue; /* Not even realized in the root slice? Then let's not bother */
1984
1985 q = cg_attach(cgroup_controller_to_string(c), realized, pid);
1986 if (q < 0)
1987 log_unit_debug_errno(u, q, "Failed to attach PID " PID_FMT " to realized cgroup %s in controller %s, ignoring: %m",
1988 pid, realized, cgroup_controller_to_string(c));
1989 }
1990 }
1991
1992 return r;
1993 }
1994
1995 static bool unit_has_mask_realized(
1996 Unit *u,
1997 CGroupMask target_mask,
1998 CGroupMask enable_mask) {
1999
2000 assert(u);
2001
2002 /* Returns true if this unit is fully realized. We check four things:
2003 *
2004 * 1. Whether the cgroup was created at all
2005 * 2. Whether the cgroup was created in all the hierarchies we need it to be created in (in case of cgroup v1)
2006 * 3. Whether the cgroup has all the right controllers enabled (in case of cgroup v2)
2007 * 4. Whether the invalidation mask is currently zero
2008 *
2009 * If you wonder why we mask the target realization and enable mask with CGROUP_MASK_V1/CGROUP_MASK_V2: note
2010 * that there are three sets of bitmasks: CGROUP_MASK_V1 (for real cgroup v1 controllers), CGROUP_MASK_V2 (for
2011 * real cgroup v2 controllers) and CGROUP_MASK_BPF (for BPF-based pseudo-controllers). Now, cgroup_realized_mask
2012 * is only matters for cgroup v1 controllers, and cgroup_enabled_mask only used for cgroup v2, and if they
2013 * differ in the others, we don't really care. (After all, the cgroup_enabled_mask tracks with controllers are
2014 * enabled through cgroup.subtree_control, and since the BPF pseudo-controllers don't show up there, they
2015 * simply don't matter. */
2016
2017 return u->cgroup_realized &&
2018 ((u->cgroup_realized_mask ^ target_mask) & CGROUP_MASK_V1) == 0 &&
2019 ((u->cgroup_enabled_mask ^ enable_mask) & CGROUP_MASK_V2) == 0 &&
2020 u->cgroup_invalidated_mask == 0;
2021 }
2022
2023 static bool unit_has_mask_disables_realized(
2024 Unit *u,
2025 CGroupMask target_mask,
2026 CGroupMask enable_mask) {
2027
2028 assert(u);
2029
2030 /* Returns true if all controllers which should be disabled are indeed disabled.
2031 *
2032 * Unlike unit_has_mask_realized, we don't care what was enabled, only that anything we want to remove is
2033 * already removed. */
2034
2035 return !u->cgroup_realized ||
2036 (FLAGS_SET(u->cgroup_realized_mask, target_mask & CGROUP_MASK_V1) &&
2037 FLAGS_SET(u->cgroup_enabled_mask, enable_mask & CGROUP_MASK_V2));
2038 }
2039
2040 static bool unit_has_mask_enables_realized(
2041 Unit *u,
2042 CGroupMask target_mask,
2043 CGroupMask enable_mask) {
2044
2045 assert(u);
2046
2047 /* Returns true if all controllers which should be enabled are indeed enabled.
2048 *
2049 * Unlike unit_has_mask_realized, we don't care about the controllers that are not present, only that anything
2050 * we want to add is already added. */
2051
2052 return u->cgroup_realized &&
2053 ((u->cgroup_realized_mask | target_mask) & CGROUP_MASK_V1) == (u->cgroup_realized_mask & CGROUP_MASK_V1) &&
2054 ((u->cgroup_enabled_mask | enable_mask) & CGROUP_MASK_V2) == (u->cgroup_enabled_mask & CGROUP_MASK_V2);
2055 }
2056
2057 void unit_add_to_cgroup_realize_queue(Unit *u) {
2058 assert(u);
2059
2060 if (u->in_cgroup_realize_queue)
2061 return;
2062
2063 LIST_PREPEND(cgroup_realize_queue, u->manager->cgroup_realize_queue, u);
2064 u->in_cgroup_realize_queue = true;
2065 }
2066
2067 static void unit_remove_from_cgroup_realize_queue(Unit *u) {
2068 assert(u);
2069
2070 if (!u->in_cgroup_realize_queue)
2071 return;
2072
2073 LIST_REMOVE(cgroup_realize_queue, u->manager->cgroup_realize_queue, u);
2074 u->in_cgroup_realize_queue = false;
2075 }
2076
2077 /* Controllers can only be enabled breadth-first, from the root of the
2078 * hierarchy downwards to the unit in question. */
2079 static int unit_realize_cgroup_now_enable(Unit *u, ManagerState state) {
2080 CGroupMask target_mask, enable_mask, new_target_mask, new_enable_mask;
2081 int r;
2082
2083 assert(u);
2084
2085 /* First go deal with this unit's parent, or we won't be able to enable
2086 * any new controllers at this layer. */
2087 if (UNIT_ISSET(u->slice)) {
2088 r = unit_realize_cgroup_now_enable(UNIT_DEREF(u->slice), state);
2089 if (r < 0)
2090 return r;
2091 }
2092
2093 target_mask = unit_get_target_mask(u);
2094 enable_mask = unit_get_enable_mask(u);
2095
2096 /* We can only enable in this direction, don't try to disable anything.
2097 */
2098 if (unit_has_mask_enables_realized(u, target_mask, enable_mask))
2099 return 0;
2100
2101 new_target_mask = u->cgroup_realized_mask | target_mask;
2102 new_enable_mask = u->cgroup_enabled_mask | enable_mask;
2103
2104 return unit_create_cgroup(u, new_target_mask, new_enable_mask, state);
2105 }
2106
2107 /* Controllers can only be disabled depth-first, from the leaves of the
2108 * hierarchy upwards to the unit in question. */
2109 static int unit_realize_cgroup_now_disable(Unit *u, ManagerState state) {
2110 Iterator i;
2111 Unit *m;
2112 void *v;
2113
2114 assert(u);
2115
2116 if (u->type != UNIT_SLICE)
2117 return 0;
2118
2119 HASHMAP_FOREACH_KEY(v, m, u->dependencies[UNIT_BEFORE], i) {
2120 CGroupMask target_mask, enable_mask, new_target_mask, new_enable_mask;
2121 int r;
2122
2123 if (UNIT_DEREF(m->slice) != u)
2124 continue;
2125
2126 /* The cgroup for this unit might not actually be fully
2127 * realised yet, in which case it isn't holding any controllers
2128 * open anyway. */
2129 if (!m->cgroup_path)
2130 continue;
2131
2132 /* We must disable those below us first in order to release the
2133 * controller. */
2134 if (m->type == UNIT_SLICE)
2135 (void) unit_realize_cgroup_now_disable(m, state);
2136
2137 target_mask = unit_get_target_mask(m);
2138 enable_mask = unit_get_enable_mask(m);
2139
2140 /* We can only disable in this direction, don't try to enable
2141 * anything. */
2142 if (unit_has_mask_disables_realized(m, target_mask, enable_mask))
2143 continue;
2144
2145 new_target_mask = m->cgroup_realized_mask & target_mask;
2146 new_enable_mask = m->cgroup_enabled_mask & enable_mask;
2147
2148 r = unit_create_cgroup(m, new_target_mask, new_enable_mask, state);
2149 if (r < 0)
2150 return r;
2151 }
2152
2153 return 0;
2154 }
2155
2156 /* Check if necessary controllers and attributes for a unit are in place.
2157 *
2158 * - If so, do nothing.
2159 * - If not, create paths, move processes over, and set attributes.
2160 *
2161 * Controllers can only be *enabled* in a breadth-first way, and *disabled* in
2162 * a depth-first way. As such the process looks like this:
2163 *
2164 * Suppose we have a cgroup hierarchy which looks like this:
2165 *
2166 * root
2167 * / \
2168 * / \
2169 * / \
2170 * a b
2171 * / \ / \
2172 * / \ / \
2173 * c d e f
2174 * / \ / \ / \ / \
2175 * h i j k l m n o
2176 *
2177 * 1. We want to realise cgroup "d" now.
2178 * 2. cgroup "a" has DisableControllers=cpu in the associated unit.
2179 * 3. cgroup "k" just started requesting the memory controller.
2180 *
2181 * To make this work we must do the following in order:
2182 *
2183 * 1. Disable CPU controller in k, j
2184 * 2. Disable CPU controller in d
2185 * 3. Enable memory controller in root
2186 * 4. Enable memory controller in a
2187 * 5. Enable memory controller in d
2188 * 6. Enable memory controller in k
2189 *
2190 * Notice that we need to touch j in one direction, but not the other. We also
2191 * don't go beyond d when disabling -- it's up to "a" to get realized if it
2192 * wants to disable further. The basic rules are therefore:
2193 *
2194 * - If you're disabling something, you need to realise all of the cgroups from
2195 * your recursive descendants to the root. This starts from the leaves.
2196 * - If you're enabling something, you need to realise from the root cgroup
2197 * downwards, but you don't need to iterate your recursive descendants.
2198 *
2199 * Returns 0 on success and < 0 on failure. */
2200 static int unit_realize_cgroup_now(Unit *u, ManagerState state) {
2201 CGroupMask target_mask, enable_mask;
2202 int r;
2203
2204 assert(u);
2205
2206 unit_remove_from_cgroup_realize_queue(u);
2207
2208 target_mask = unit_get_target_mask(u);
2209 enable_mask = unit_get_enable_mask(u);
2210
2211 if (unit_has_mask_realized(u, target_mask, enable_mask))
2212 return 0;
2213
2214 /* Disable controllers below us, if there are any */
2215 r = unit_realize_cgroup_now_disable(u, state);
2216 if (r < 0)
2217 return r;
2218
2219 /* Enable controllers above us, if there are any */
2220 if (UNIT_ISSET(u->slice)) {
2221 r = unit_realize_cgroup_now_enable(UNIT_DEREF(u->slice), state);
2222 if (r < 0)
2223 return r;
2224 }
2225
2226 /* Now actually deal with the cgroup we were trying to realise and set attributes */
2227 r = unit_create_cgroup(u, target_mask, enable_mask, state);
2228 if (r < 0)
2229 return r;
2230
2231 /* Now, reset the invalidation mask */
2232 u->cgroup_invalidated_mask = 0;
2233 return 0;
2234 }
2235
2236 unsigned manager_dispatch_cgroup_realize_queue(Manager *m) {
2237 ManagerState state;
2238 unsigned n = 0;
2239 Unit *i;
2240 int r;
2241
2242 assert(m);
2243
2244 state = manager_state(m);
2245
2246 while ((i = m->cgroup_realize_queue)) {
2247 assert(i->in_cgroup_realize_queue);
2248
2249 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(i))) {
2250 /* Maybe things changed, and the unit is not actually active anymore? */
2251 unit_remove_from_cgroup_realize_queue(i);
2252 continue;
2253 }
2254
2255 r = unit_realize_cgroup_now(i, state);
2256 if (r < 0)
2257 log_warning_errno(r, "Failed to realize cgroups for queued unit %s, ignoring: %m", i->id);
2258
2259 n++;
2260 }
2261
2262 return n;
2263 }
2264
2265 static void unit_add_siblings_to_cgroup_realize_queue(Unit *u) {
2266 Unit *slice;
2267
2268 /* This adds the siblings of the specified unit and the
2269 * siblings of all parent units to the cgroup queue. (But
2270 * neither the specified unit itself nor the parents.) */
2271
2272 while ((slice = UNIT_DEREF(u->slice))) {
2273 Iterator i;
2274 Unit *m;
2275 void *v;
2276
2277 HASHMAP_FOREACH_KEY(v, m, u->dependencies[UNIT_BEFORE], i) {
2278 /* Skip units that have a dependency on the slice
2279 * but aren't actually in it. */
2280 if (UNIT_DEREF(m->slice) != slice)
2281 continue;
2282
2283 /* No point in doing cgroup application for units
2284 * without active processes. */
2285 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(m)))
2286 continue;
2287
2288 /* If the unit doesn't need any new controllers
2289 * and has current ones realized, it doesn't need
2290 * any changes. */
2291 if (unit_has_mask_realized(m,
2292 unit_get_target_mask(m),
2293 unit_get_enable_mask(m)))
2294 continue;
2295
2296 unit_add_to_cgroup_realize_queue(m);
2297 }
2298
2299 u = slice;
2300 }
2301 }
2302
2303 int unit_realize_cgroup(Unit *u) {
2304 assert(u);
2305
2306 if (!UNIT_HAS_CGROUP_CONTEXT(u))
2307 return 0;
2308
2309 /* So, here's the deal: when realizing the cgroups for this
2310 * unit, we need to first create all parents, but there's more
2311 * actually: for the weight-based controllers we also need to
2312 * make sure that all our siblings (i.e. units that are in the
2313 * same slice as we are) have cgroups, too. Otherwise, things
2314 * would become very uneven as each of their processes would
2315 * get as much resources as all our group together. This call
2316 * will synchronously create the parent cgroups, but will
2317 * defer work on the siblings to the next event loop
2318 * iteration. */
2319
2320 /* Add all sibling slices to the cgroup queue. */
2321 unit_add_siblings_to_cgroup_realize_queue(u);
2322
2323 /* And realize this one now (and apply the values) */
2324 return unit_realize_cgroup_now(u, manager_state(u->manager));
2325 }
2326
2327 void unit_release_cgroup(Unit *u) {
2328 assert(u);
2329
2330 /* Forgets all cgroup details for this cgroup — but does *not* destroy the cgroup. This is hence OK to call
2331 * when we close down everything for reexecution, where we really want to leave the cgroup in place. */
2332
2333 if (u->cgroup_path) {
2334 (void) hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2335 u->cgroup_path = mfree(u->cgroup_path);
2336 }
2337
2338 if (u->cgroup_control_inotify_wd >= 0) {
2339 if (inotify_rm_watch(u->manager->cgroup_inotify_fd, u->cgroup_control_inotify_wd) < 0)
2340 log_unit_debug_errno(u, errno, "Failed to remove cgroup control inotify watch %i for %s, ignoring: %m", u->cgroup_control_inotify_wd, u->id);
2341
2342 (void) hashmap_remove(u->manager->cgroup_control_inotify_wd_unit, INT_TO_PTR(u->cgroup_control_inotify_wd));
2343 u->cgroup_control_inotify_wd = -1;
2344 }
2345
2346 if (u->cgroup_memory_inotify_wd >= 0) {
2347 if (inotify_rm_watch(u->manager->cgroup_inotify_fd, u->cgroup_memory_inotify_wd) < 0)
2348 log_unit_debug_errno(u, errno, "Failed to remove cgroup memory inotify watch %i for %s, ignoring: %m", u->cgroup_memory_inotify_wd, u->id);
2349
2350 (void) hashmap_remove(u->manager->cgroup_memory_inotify_wd_unit, INT_TO_PTR(u->cgroup_memory_inotify_wd));
2351 u->cgroup_memory_inotify_wd = -1;
2352 }
2353 }
2354
2355 void unit_prune_cgroup(Unit *u) {
2356 int r;
2357 bool is_root_slice;
2358
2359 assert(u);
2360
2361 /* Removes the cgroup, if empty and possible, and stops watching it. */
2362
2363 if (!u->cgroup_path)
2364 return;
2365
2366 (void) unit_get_cpu_usage(u, NULL); /* Cache the last CPU usage value before we destroy the cgroup */
2367
2368 is_root_slice = unit_has_name(u, SPECIAL_ROOT_SLICE);
2369
2370 r = cg_trim_everywhere(u->manager->cgroup_supported, u->cgroup_path, !is_root_slice);
2371 if (r < 0) {
2372 log_unit_debug_errno(u, r, "Failed to destroy cgroup %s, ignoring: %m", u->cgroup_path);
2373 return;
2374 }
2375
2376 if (is_root_slice)
2377 return;
2378
2379 unit_release_cgroup(u);
2380
2381 u->cgroup_realized = false;
2382 u->cgroup_realized_mask = 0;
2383 u->cgroup_enabled_mask = 0;
2384
2385 u->bpf_device_control_installed = bpf_program_unref(u->bpf_device_control_installed);
2386 }
2387
2388 int unit_search_main_pid(Unit *u, pid_t *ret) {
2389 _cleanup_fclose_ FILE *f = NULL;
2390 pid_t pid = 0, npid;
2391 int r;
2392
2393 assert(u);
2394 assert(ret);
2395
2396 if (!u->cgroup_path)
2397 return -ENXIO;
2398
2399 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &f);
2400 if (r < 0)
2401 return r;
2402
2403 while (cg_read_pid(f, &npid) > 0) {
2404
2405 if (npid == pid)
2406 continue;
2407
2408 if (pid_is_my_child(npid) == 0)
2409 continue;
2410
2411 if (pid != 0)
2412 /* Dang, there's more than one daemonized PID
2413 in this group, so we don't know what process
2414 is the main process. */
2415
2416 return -ENODATA;
2417
2418 pid = npid;
2419 }
2420
2421 *ret = pid;
2422 return 0;
2423 }
2424
2425 static int unit_watch_pids_in_path(Unit *u, const char *path) {
2426 _cleanup_closedir_ DIR *d = NULL;
2427 _cleanup_fclose_ FILE *f = NULL;
2428 int ret = 0, r;
2429
2430 assert(u);
2431 assert(path);
2432
2433 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
2434 if (r < 0)
2435 ret = r;
2436 else {
2437 pid_t pid;
2438
2439 while ((r = cg_read_pid(f, &pid)) > 0) {
2440 r = unit_watch_pid(u, pid, false);
2441 if (r < 0 && ret >= 0)
2442 ret = r;
2443 }
2444
2445 if (r < 0 && ret >= 0)
2446 ret = r;
2447 }
2448
2449 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
2450 if (r < 0) {
2451 if (ret >= 0)
2452 ret = r;
2453 } else {
2454 char *fn;
2455
2456 while ((r = cg_read_subgroup(d, &fn)) > 0) {
2457 _cleanup_free_ char *p = NULL;
2458
2459 p = strjoin(path, "/", fn);
2460 free(fn);
2461
2462 if (!p)
2463 return -ENOMEM;
2464
2465 r = unit_watch_pids_in_path(u, p);
2466 if (r < 0 && ret >= 0)
2467 ret = r;
2468 }
2469
2470 if (r < 0 && ret >= 0)
2471 ret = r;
2472 }
2473
2474 return ret;
2475 }
2476
2477 int unit_synthesize_cgroup_empty_event(Unit *u) {
2478 int r;
2479
2480 assert(u);
2481
2482 /* Enqueue a synthetic cgroup empty event if this unit doesn't watch any PIDs anymore. This is compatibility
2483 * support for non-unified systems where notifications aren't reliable, and hence need to take whatever we can
2484 * get as notification source as soon as we stopped having any useful PIDs to watch for. */
2485
2486 if (!u->cgroup_path)
2487 return -ENOENT;
2488
2489 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
2490 if (r < 0)
2491 return r;
2492 if (r > 0) /* On unified we have reliable notifications, and don't need this */
2493 return 0;
2494
2495 if (!set_isempty(u->pids))
2496 return 0;
2497
2498 unit_add_to_cgroup_empty_queue(u);
2499 return 0;
2500 }
2501
2502 int unit_watch_all_pids(Unit *u) {
2503 int r;
2504
2505 assert(u);
2506
2507 /* Adds all PIDs from our cgroup to the set of PIDs we
2508 * watch. This is a fallback logic for cases where we do not
2509 * get reliable cgroup empty notifications: we try to use
2510 * SIGCHLD as replacement. */
2511
2512 if (!u->cgroup_path)
2513 return -ENOENT;
2514
2515 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
2516 if (r < 0)
2517 return r;
2518 if (r > 0) /* On unified we can use proper notifications */
2519 return 0;
2520
2521 return unit_watch_pids_in_path(u, u->cgroup_path);
2522 }
2523
2524 static int on_cgroup_empty_event(sd_event_source *s, void *userdata) {
2525 Manager *m = userdata;
2526 Unit *u;
2527 int r;
2528
2529 assert(s);
2530 assert(m);
2531
2532 u = m->cgroup_empty_queue;
2533 if (!u)
2534 return 0;
2535
2536 assert(u->in_cgroup_empty_queue);
2537 u->in_cgroup_empty_queue = false;
2538 LIST_REMOVE(cgroup_empty_queue, m->cgroup_empty_queue, u);
2539
2540 if (m->cgroup_empty_queue) {
2541 /* More stuff queued, let's make sure we remain enabled */
2542 r = sd_event_source_set_enabled(s, SD_EVENT_ONESHOT);
2543 if (r < 0)
2544 log_debug_errno(r, "Failed to reenable cgroup empty event source, ignoring: %m");
2545 }
2546
2547 unit_add_to_gc_queue(u);
2548
2549 if (UNIT_VTABLE(u)->notify_cgroup_empty)
2550 UNIT_VTABLE(u)->notify_cgroup_empty(u);
2551
2552 return 0;
2553 }
2554
2555 void unit_add_to_cgroup_empty_queue(Unit *u) {
2556 int r;
2557
2558 assert(u);
2559
2560 /* Note that there are four different ways how cgroup empty events reach us:
2561 *
2562 * 1. On the unified hierarchy we get an inotify event on the cgroup
2563 *
2564 * 2. On the legacy hierarchy, when running in system mode, we get a datagram on the cgroup agent socket
2565 *
2566 * 3. On the legacy hierarchy, when running in user mode, we get a D-Bus signal on the system bus
2567 *
2568 * 4. On the legacy hierarchy, in service units we start watching all processes of the cgroup for SIGCHLD as
2569 * soon as we get one SIGCHLD, to deal with unreliable cgroup notifications.
2570 *
2571 * Regardless which way we got the notification, we'll verify it here, and then add it to a separate
2572 * queue. This queue will be dispatched at a lower priority than the SIGCHLD handler, so that we always use
2573 * SIGCHLD if we can get it first, and only use the cgroup empty notifications if there's no SIGCHLD pending
2574 * (which might happen if the cgroup doesn't contain processes that are our own child, which is typically the
2575 * case for scope units). */
2576
2577 if (u->in_cgroup_empty_queue)
2578 return;
2579
2580 /* Let's verify that the cgroup is really empty */
2581 if (!u->cgroup_path)
2582 return;
2583 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path);
2584 if (r < 0) {
2585 log_unit_debug_errno(u, r, "Failed to determine whether cgroup %s is empty: %m", u->cgroup_path);
2586 return;
2587 }
2588 if (r == 0)
2589 return;
2590
2591 LIST_PREPEND(cgroup_empty_queue, u->manager->cgroup_empty_queue, u);
2592 u->in_cgroup_empty_queue = true;
2593
2594 /* Trigger the defer event */
2595 r = sd_event_source_set_enabled(u->manager->cgroup_empty_event_source, SD_EVENT_ONESHOT);
2596 if (r < 0)
2597 log_debug_errno(r, "Failed to enable cgroup empty event source: %m");
2598 }
2599
2600 static int unit_check_oom(Unit *u) {
2601 _cleanup_free_ char *oom_kill = NULL;
2602 bool increased;
2603 uint64_t c;
2604 int r;
2605
2606 if (!u->cgroup_path)
2607 return 0;
2608
2609 r = cg_get_keyed_attribute("memory", u->cgroup_path, "memory.events", STRV_MAKE("oom_kill"), &oom_kill);
2610 if (r < 0)
2611 return log_unit_debug_errno(u, r, "Failed to read oom_kill field of memory.events cgroup attribute: %m");
2612
2613 r = safe_atou64(oom_kill, &c);
2614 if (r < 0)
2615 return log_unit_debug_errno(u, r, "Failed to parse oom_kill field: %m");
2616
2617 increased = c > u->oom_kill_last;
2618 u->oom_kill_last = c;
2619
2620 if (!increased)
2621 return 0;
2622
2623 log_struct(LOG_NOTICE,
2624 "MESSAGE_ID=" SD_MESSAGE_UNIT_OUT_OF_MEMORY_STR,
2625 LOG_UNIT_ID(u),
2626 LOG_UNIT_INVOCATION_ID(u),
2627 LOG_UNIT_MESSAGE(u, "A process of this unit has been killed by the OOM killer."));
2628
2629 if (UNIT_VTABLE(u)->notify_cgroup_oom)
2630 UNIT_VTABLE(u)->notify_cgroup_oom(u);
2631
2632 return 1;
2633 }
2634
2635 static int on_cgroup_oom_event(sd_event_source *s, void *userdata) {
2636 Manager *m = userdata;
2637 Unit *u;
2638 int r;
2639
2640 assert(s);
2641 assert(m);
2642
2643 u = m->cgroup_oom_queue;
2644 if (!u)
2645 return 0;
2646
2647 assert(u->in_cgroup_oom_queue);
2648 u->in_cgroup_oom_queue = false;
2649 LIST_REMOVE(cgroup_oom_queue, m->cgroup_oom_queue, u);
2650
2651 if (m->cgroup_oom_queue) {
2652 /* More stuff queued, let's make sure we remain enabled */
2653 r = sd_event_source_set_enabled(s, SD_EVENT_ONESHOT);
2654 if (r < 0)
2655 log_debug_errno(r, "Failed to reenable cgroup oom event source, ignoring: %m");
2656 }
2657
2658 (void) unit_check_oom(u);
2659 return 0;
2660 }
2661
2662 static void unit_add_to_cgroup_oom_queue(Unit *u) {
2663 int r;
2664
2665 assert(u);
2666
2667 if (u->in_cgroup_oom_queue)
2668 return;
2669 if (!u->cgroup_path)
2670 return;
2671
2672 LIST_PREPEND(cgroup_oom_queue, u->manager->cgroup_oom_queue, u);
2673 u->in_cgroup_oom_queue = true;
2674
2675 /* Trigger the defer event */
2676 if (!u->manager->cgroup_oom_event_source) {
2677 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
2678
2679 r = sd_event_add_defer(u->manager->event, &s, on_cgroup_oom_event, u->manager);
2680 if (r < 0) {
2681 log_error_errno(r, "Failed to create cgroup oom event source: %m");
2682 return;
2683 }
2684
2685 r = sd_event_source_set_priority(s, SD_EVENT_PRIORITY_NORMAL-8);
2686 if (r < 0) {
2687 log_error_errno(r, "Failed to set priority of cgroup oom event source: %m");
2688 return;
2689 }
2690
2691 (void) sd_event_source_set_description(s, "cgroup-oom");
2692 u->manager->cgroup_oom_event_source = TAKE_PTR(s);
2693 }
2694
2695 r = sd_event_source_set_enabled(u->manager->cgroup_oom_event_source, SD_EVENT_ONESHOT);
2696 if (r < 0)
2697 log_error_errno(r, "Failed to enable cgroup oom event source: %m");
2698 }
2699
2700 static int on_cgroup_inotify_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2701 Manager *m = userdata;
2702
2703 assert(s);
2704 assert(fd >= 0);
2705 assert(m);
2706
2707 for (;;) {
2708 union inotify_event_buffer buffer;
2709 struct inotify_event *e;
2710 ssize_t l;
2711
2712 l = read(fd, &buffer, sizeof(buffer));
2713 if (l < 0) {
2714 if (IN_SET(errno, EINTR, EAGAIN))
2715 return 0;
2716
2717 return log_error_errno(errno, "Failed to read control group inotify events: %m");
2718 }
2719
2720 FOREACH_INOTIFY_EVENT(e, buffer, l) {
2721 Unit *u;
2722
2723 if (e->wd < 0)
2724 /* Queue overflow has no watch descriptor */
2725 continue;
2726
2727 if (e->mask & IN_IGNORED)
2728 /* The watch was just removed */
2729 continue;
2730
2731 /* Note that inotify might deliver events for a watch even after it was removed,
2732 * because it was queued before the removal. Let's ignore this here safely. */
2733
2734 u = hashmap_get(m->cgroup_control_inotify_wd_unit, INT_TO_PTR(e->wd));
2735 if (u)
2736 unit_add_to_cgroup_empty_queue(u);
2737
2738 u = hashmap_get(m->cgroup_memory_inotify_wd_unit, INT_TO_PTR(e->wd));
2739 if (u)
2740 unit_add_to_cgroup_oom_queue(u);
2741 }
2742 }
2743 }
2744
2745 static int cg_bpf_mask_supported(CGroupMask *ret) {
2746 CGroupMask mask = 0;
2747 int r;
2748
2749 /* BPF-based firewall */
2750 r = bpf_firewall_supported();
2751 if (r > 0)
2752 mask |= CGROUP_MASK_BPF_FIREWALL;
2753
2754 /* BPF-based device access control */
2755 r = bpf_devices_supported();
2756 if (r > 0)
2757 mask |= CGROUP_MASK_BPF_DEVICES;
2758
2759 *ret = mask;
2760 return 0;
2761 }
2762
2763 int manager_setup_cgroup(Manager *m) {
2764 _cleanup_free_ char *path = NULL;
2765 const char *scope_path;
2766 CGroupController c;
2767 int r, all_unified;
2768 CGroupMask mask;
2769 char *e;
2770
2771 assert(m);
2772
2773 /* 1. Determine hierarchy */
2774 m->cgroup_root = mfree(m->cgroup_root);
2775 r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 0, &m->cgroup_root);
2776 if (r < 0)
2777 return log_error_errno(r, "Cannot determine cgroup we are running in: %m");
2778
2779 /* Chop off the init scope, if we are already located in it */
2780 e = endswith(m->cgroup_root, "/" SPECIAL_INIT_SCOPE);
2781
2782 /* LEGACY: Also chop off the system slice if we are in
2783 * it. This is to support live upgrades from older systemd
2784 * versions where PID 1 was moved there. Also see
2785 * cg_get_root_path(). */
2786 if (!e && MANAGER_IS_SYSTEM(m)) {
2787 e = endswith(m->cgroup_root, "/" SPECIAL_SYSTEM_SLICE);
2788 if (!e)
2789 e = endswith(m->cgroup_root, "/system"); /* even more legacy */
2790 }
2791 if (e)
2792 *e = 0;
2793
2794 /* And make sure to store away the root value without trailing slash, even for the root dir, so that we can
2795 * easily prepend it everywhere. */
2796 delete_trailing_chars(m->cgroup_root, "/");
2797
2798 /* 2. Show data */
2799 r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_root, NULL, &path);
2800 if (r < 0)
2801 return log_error_errno(r, "Cannot find cgroup mount point: %m");
2802
2803 r = cg_unified_flush();
2804 if (r < 0)
2805 return log_error_errno(r, "Couldn't determine if we are running in the unified hierarchy: %m");
2806
2807 all_unified = cg_all_unified();
2808 if (all_unified < 0)
2809 return log_error_errno(all_unified, "Couldn't determine whether we are in all unified mode: %m");
2810 if (all_unified > 0)
2811 log_debug("Unified cgroup hierarchy is located at %s.", path);
2812 else {
2813 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
2814 if (r < 0)
2815 return log_error_errno(r, "Failed to determine whether systemd's own controller is in unified mode: %m");
2816 if (r > 0)
2817 log_debug("Unified cgroup hierarchy is located at %s. Controllers are on legacy hierarchies.", path);
2818 else
2819 log_debug("Using cgroup controller " SYSTEMD_CGROUP_CONTROLLER_LEGACY ". File system hierarchy is at %s.", path);
2820 }
2821
2822 /* 3. Allocate cgroup empty defer event source */
2823 m->cgroup_empty_event_source = sd_event_source_unref(m->cgroup_empty_event_source);
2824 r = sd_event_add_defer(m->event, &m->cgroup_empty_event_source, on_cgroup_empty_event, m);
2825 if (r < 0)
2826 return log_error_errno(r, "Failed to create cgroup empty event source: %m");
2827
2828 /* Schedule cgroup empty checks early, but after having processed service notification messages or
2829 * SIGCHLD signals, so that a cgroup running empty is always just the last safety net of
2830 * notification, and we collected the metadata the notification and SIGCHLD stuff offers first. */
2831 r = sd_event_source_set_priority(m->cgroup_empty_event_source, SD_EVENT_PRIORITY_NORMAL-5);
2832 if (r < 0)
2833 return log_error_errno(r, "Failed to set priority of cgroup empty event source: %m");
2834
2835 r = sd_event_source_set_enabled(m->cgroup_empty_event_source, SD_EVENT_OFF);
2836 if (r < 0)
2837 return log_error_errno(r, "Failed to disable cgroup empty event source: %m");
2838
2839 (void) sd_event_source_set_description(m->cgroup_empty_event_source, "cgroup-empty");
2840
2841 /* 4. Install notifier inotify object, or agent */
2842 if (cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER) > 0) {
2843
2844 /* In the unified hierarchy we can get cgroup empty notifications via inotify. */
2845
2846 m->cgroup_inotify_event_source = sd_event_source_unref(m->cgroup_inotify_event_source);
2847 safe_close(m->cgroup_inotify_fd);
2848
2849 m->cgroup_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
2850 if (m->cgroup_inotify_fd < 0)
2851 return log_error_errno(errno, "Failed to create control group inotify object: %m");
2852
2853 r = sd_event_add_io(m->event, &m->cgroup_inotify_event_source, m->cgroup_inotify_fd, EPOLLIN, on_cgroup_inotify_event, m);
2854 if (r < 0)
2855 return log_error_errno(r, "Failed to watch control group inotify object: %m");
2856
2857 /* Process cgroup empty notifications early. Note that when this event is dispatched it'll
2858 * just add the unit to a cgroup empty queue, hence let's run earlier than that. Also see
2859 * handling of cgroup agent notifications, for the classic cgroup hierarchy support. */
2860 r = sd_event_source_set_priority(m->cgroup_inotify_event_source, SD_EVENT_PRIORITY_NORMAL-9);
2861 if (r < 0)
2862 return log_error_errno(r, "Failed to set priority of inotify event source: %m");
2863
2864 (void) sd_event_source_set_description(m->cgroup_inotify_event_source, "cgroup-inotify");
2865
2866 } else if (MANAGER_IS_SYSTEM(m) && manager_owns_host_root_cgroup(m) && !MANAGER_IS_TEST_RUN(m)) {
2867
2868 /* On the legacy hierarchy we only get notifications via cgroup agents. (Which isn't really reliable,
2869 * since it does not generate events when control groups with children run empty. */
2870
2871 r = cg_install_release_agent(SYSTEMD_CGROUP_CONTROLLER, SYSTEMD_CGROUP_AGENT_PATH);
2872 if (r < 0)
2873 log_warning_errno(r, "Failed to install release agent, ignoring: %m");
2874 else if (r > 0)
2875 log_debug("Installed release agent.");
2876 else if (r == 0)
2877 log_debug("Release agent already installed.");
2878 }
2879
2880 /* 5. Make sure we are in the special "init.scope" unit in the root slice. */
2881 scope_path = strjoina(m->cgroup_root, "/" SPECIAL_INIT_SCOPE);
2882 r = cg_create_and_attach(SYSTEMD_CGROUP_CONTROLLER, scope_path, 0);
2883 if (r >= 0) {
2884 /* Also, move all other userspace processes remaining in the root cgroup into that scope. */
2885 r = cg_migrate(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_root, SYSTEMD_CGROUP_CONTROLLER, scope_path, 0);
2886 if (r < 0)
2887 log_warning_errno(r, "Couldn't move remaining userspace processes, ignoring: %m");
2888
2889 /* 6. And pin it, so that it cannot be unmounted */
2890 safe_close(m->pin_cgroupfs_fd);
2891 m->pin_cgroupfs_fd = open(path, O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOCTTY|O_NONBLOCK);
2892 if (m->pin_cgroupfs_fd < 0)
2893 return log_error_errno(errno, "Failed to open pin file: %m");
2894
2895 } else if (!MANAGER_IS_TEST_RUN(m))
2896 return log_error_errno(r, "Failed to create %s control group: %m", scope_path);
2897
2898 /* 7. Always enable hierarchical support if it exists... */
2899 if (!all_unified && !MANAGER_IS_TEST_RUN(m))
2900 (void) cg_set_attribute("memory", "/", "memory.use_hierarchy", "1");
2901
2902 /* 8. Figure out which controllers are supported */
2903 r = cg_mask_supported(&m->cgroup_supported);
2904 if (r < 0)
2905 return log_error_errno(r, "Failed to determine supported controllers: %m");
2906
2907 /* 9. Figure out which bpf-based pseudo-controllers are supported */
2908 r = cg_bpf_mask_supported(&mask);
2909 if (r < 0)
2910 return log_error_errno(r, "Failed to determine supported bpf-based pseudo-controllers: %m");
2911 m->cgroup_supported |= mask;
2912
2913 /* 10. Log which controllers are supported */
2914 for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++)
2915 log_debug("Controller '%s' supported: %s", cgroup_controller_to_string(c), yes_no(m->cgroup_supported & CGROUP_CONTROLLER_TO_MASK(c)));
2916
2917 return 0;
2918 }
2919
2920 void manager_shutdown_cgroup(Manager *m, bool delete) {
2921 assert(m);
2922
2923 /* We can't really delete the group, since we are in it. But
2924 * let's trim it. */
2925 if (delete && m->cgroup_root && m->test_run_flags != MANAGER_TEST_RUN_MINIMAL)
2926 (void) cg_trim(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_root, false);
2927
2928 m->cgroup_empty_event_source = sd_event_source_unref(m->cgroup_empty_event_source);
2929
2930 m->cgroup_control_inotify_wd_unit = hashmap_free(m->cgroup_control_inotify_wd_unit);
2931 m->cgroup_memory_inotify_wd_unit = hashmap_free(m->cgroup_memory_inotify_wd_unit);
2932
2933 m->cgroup_inotify_event_source = sd_event_source_unref(m->cgroup_inotify_event_source);
2934 m->cgroup_inotify_fd = safe_close(m->cgroup_inotify_fd);
2935
2936 m->pin_cgroupfs_fd = safe_close(m->pin_cgroupfs_fd);
2937
2938 m->cgroup_root = mfree(m->cgroup_root);
2939 }
2940
2941 Unit* manager_get_unit_by_cgroup(Manager *m, const char *cgroup) {
2942 char *p;
2943 Unit *u;
2944
2945 assert(m);
2946 assert(cgroup);
2947
2948 u = hashmap_get(m->cgroup_unit, cgroup);
2949 if (u)
2950 return u;
2951
2952 p = strdupa(cgroup);
2953 for (;;) {
2954 char *e;
2955
2956 e = strrchr(p, '/');
2957 if (!e || e == p)
2958 return hashmap_get(m->cgroup_unit, SPECIAL_ROOT_SLICE);
2959
2960 *e = 0;
2961
2962 u = hashmap_get(m->cgroup_unit, p);
2963 if (u)
2964 return u;
2965 }
2966 }
2967
2968 Unit *manager_get_unit_by_pid_cgroup(Manager *m, pid_t pid) {
2969 _cleanup_free_ char *cgroup = NULL;
2970
2971 assert(m);
2972
2973 if (!pid_is_valid(pid))
2974 return NULL;
2975
2976 if (cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &cgroup) < 0)
2977 return NULL;
2978
2979 return manager_get_unit_by_cgroup(m, cgroup);
2980 }
2981
2982 Unit *manager_get_unit_by_pid(Manager *m, pid_t pid) {
2983 Unit *u, **array;
2984
2985 assert(m);
2986
2987 /* Note that a process might be owned by multiple units, we return only one here, which is good enough for most
2988 * cases, though not strictly correct. We prefer the one reported by cgroup membership, as that's the most
2989 * relevant one as children of the process will be assigned to that one, too, before all else. */
2990
2991 if (!pid_is_valid(pid))
2992 return NULL;
2993
2994 if (pid == getpid_cached())
2995 return hashmap_get(m->units, SPECIAL_INIT_SCOPE);
2996
2997 u = manager_get_unit_by_pid_cgroup(m, pid);
2998 if (u)
2999 return u;
3000
3001 u = hashmap_get(m->watch_pids, PID_TO_PTR(pid));
3002 if (u)
3003 return u;
3004
3005 array = hashmap_get(m->watch_pids, PID_TO_PTR(-pid));
3006 if (array)
3007 return array[0];
3008
3009 return NULL;
3010 }
3011
3012 int manager_notify_cgroup_empty(Manager *m, const char *cgroup) {
3013 Unit *u;
3014
3015 assert(m);
3016 assert(cgroup);
3017
3018 /* Called on the legacy hierarchy whenever we get an explicit cgroup notification from the cgroup agent process
3019 * or from the --system instance */
3020
3021 log_debug("Got cgroup empty notification for: %s", cgroup);
3022
3023 u = manager_get_unit_by_cgroup(m, cgroup);
3024 if (!u)
3025 return 0;
3026
3027 unit_add_to_cgroup_empty_queue(u);
3028 return 1;
3029 }
3030
3031 int unit_get_memory_current(Unit *u, uint64_t *ret) {
3032 _cleanup_free_ char *v = NULL;
3033 int r;
3034
3035 assert(u);
3036 assert(ret);
3037
3038 if (!UNIT_CGROUP_BOOL(u, memory_accounting))
3039 return -ENODATA;
3040
3041 if (!u->cgroup_path)
3042 return -ENODATA;
3043
3044 /* The root cgroup doesn't expose this information, let's get it from /proc instead */
3045 if (unit_has_host_root_cgroup(u))
3046 return procfs_memory_get_used(ret);
3047
3048 if ((u->cgroup_realized_mask & CGROUP_MASK_MEMORY) == 0)
3049 return -ENODATA;
3050
3051 r = cg_all_unified();
3052 if (r < 0)
3053 return r;
3054 if (r > 0)
3055 r = cg_get_attribute("memory", u->cgroup_path, "memory.current", &v);
3056 else
3057 r = cg_get_attribute("memory", u->cgroup_path, "memory.usage_in_bytes", &v);
3058 if (r == -ENOENT)
3059 return -ENODATA;
3060 if (r < 0)
3061 return r;
3062
3063 return safe_atou64(v, ret);
3064 }
3065
3066 int unit_get_tasks_current(Unit *u, uint64_t *ret) {
3067 _cleanup_free_ char *v = NULL;
3068 int r;
3069
3070 assert(u);
3071 assert(ret);
3072
3073 if (!UNIT_CGROUP_BOOL(u, tasks_accounting))
3074 return -ENODATA;
3075
3076 if (!u->cgroup_path)
3077 return -ENODATA;
3078
3079 /* The root cgroup doesn't expose this information, let's get it from /proc instead */
3080 if (unit_has_host_root_cgroup(u))
3081 return procfs_tasks_get_current(ret);
3082
3083 if ((u->cgroup_realized_mask & CGROUP_MASK_PIDS) == 0)
3084 return -ENODATA;
3085
3086 r = cg_get_attribute("pids", u->cgroup_path, "pids.current", &v);
3087 if (r == -ENOENT)
3088 return -ENODATA;
3089 if (r < 0)
3090 return r;
3091
3092 return safe_atou64(v, ret);
3093 }
3094
3095 static int unit_get_cpu_usage_raw(Unit *u, nsec_t *ret) {
3096 _cleanup_free_ char *v = NULL;
3097 uint64_t ns;
3098 int r;
3099
3100 assert(u);
3101 assert(ret);
3102
3103 if (!u->cgroup_path)
3104 return -ENODATA;
3105
3106 /* The root cgroup doesn't expose this information, let's get it from /proc instead */
3107 if (unit_has_host_root_cgroup(u))
3108 return procfs_cpu_get_usage(ret);
3109
3110 /* Requisite controllers for CPU accounting are not enabled */
3111 if ((get_cpu_accounting_mask() & ~u->cgroup_realized_mask) != 0)
3112 return -ENODATA;
3113
3114 r = cg_all_unified();
3115 if (r < 0)
3116 return r;
3117 if (r > 0) {
3118 _cleanup_free_ char *val = NULL;
3119 uint64_t us;
3120
3121 r = cg_get_keyed_attribute("cpu", u->cgroup_path, "cpu.stat", STRV_MAKE("usage_usec"), &val);
3122 if (IN_SET(r, -ENOENT, -ENXIO))
3123 return -ENODATA;
3124 if (r < 0)
3125 return r;
3126
3127 r = safe_atou64(val, &us);
3128 if (r < 0)
3129 return r;
3130
3131 ns = us * NSEC_PER_USEC;
3132 } else {
3133 r = cg_get_attribute("cpuacct", u->cgroup_path, "cpuacct.usage", &v);
3134 if (r == -ENOENT)
3135 return -ENODATA;
3136 if (r < 0)
3137 return r;
3138
3139 r = safe_atou64(v, &ns);
3140 if (r < 0)
3141 return r;
3142 }
3143
3144 *ret = ns;
3145 return 0;
3146 }
3147
3148 int unit_get_cpu_usage(Unit *u, nsec_t *ret) {
3149 nsec_t ns;
3150 int r;
3151
3152 assert(u);
3153
3154 /* Retrieve the current CPU usage counter. This will subtract the CPU counter taken when the unit was
3155 * started. If the cgroup has been removed already, returns the last cached value. To cache the value, simply
3156 * call this function with a NULL return value. */
3157
3158 if (!UNIT_CGROUP_BOOL(u, cpu_accounting))
3159 return -ENODATA;
3160
3161 r = unit_get_cpu_usage_raw(u, &ns);
3162 if (r == -ENODATA && u->cpu_usage_last != NSEC_INFINITY) {
3163 /* If we can't get the CPU usage anymore (because the cgroup was already removed, for example), use our
3164 * cached value. */
3165
3166 if (ret)
3167 *ret = u->cpu_usage_last;
3168 return 0;
3169 }
3170 if (r < 0)
3171 return r;
3172
3173 if (ns > u->cpu_usage_base)
3174 ns -= u->cpu_usage_base;
3175 else
3176 ns = 0;
3177
3178 u->cpu_usage_last = ns;
3179 if (ret)
3180 *ret = ns;
3181
3182 return 0;
3183 }
3184
3185 int unit_get_ip_accounting(
3186 Unit *u,
3187 CGroupIPAccountingMetric metric,
3188 uint64_t *ret) {
3189
3190 uint64_t value;
3191 int fd, r;
3192
3193 assert(u);
3194 assert(metric >= 0);
3195 assert(metric < _CGROUP_IP_ACCOUNTING_METRIC_MAX);
3196 assert(ret);
3197
3198 if (!UNIT_CGROUP_BOOL(u, ip_accounting))
3199 return -ENODATA;
3200
3201 fd = IN_SET(metric, CGROUP_IP_INGRESS_BYTES, CGROUP_IP_INGRESS_PACKETS) ?
3202 u->ip_accounting_ingress_map_fd :
3203 u->ip_accounting_egress_map_fd;
3204 if (fd < 0)
3205 return -ENODATA;
3206
3207 if (IN_SET(metric, CGROUP_IP_INGRESS_BYTES, CGROUP_IP_EGRESS_BYTES))
3208 r = bpf_firewall_read_accounting(fd, &value, NULL);
3209 else
3210 r = bpf_firewall_read_accounting(fd, NULL, &value);
3211 if (r < 0)
3212 return r;
3213
3214 /* Add in additional metrics from a previous runtime. Note that when reexecing/reloading the daemon we compile
3215 * all BPF programs and maps anew, but serialize the old counters. When deserializing we store them in the
3216 * ip_accounting_extra[] field, and add them in here transparently. */
3217
3218 *ret = value + u->ip_accounting_extra[metric];
3219
3220 return r;
3221 }
3222
3223 int unit_reset_cpu_accounting(Unit *u) {
3224 nsec_t ns;
3225 int r;
3226
3227 assert(u);
3228
3229 u->cpu_usage_last = NSEC_INFINITY;
3230
3231 r = unit_get_cpu_usage_raw(u, &ns);
3232 if (r < 0) {
3233 u->cpu_usage_base = 0;
3234 return r;
3235 }
3236
3237 u->cpu_usage_base = ns;
3238 return 0;
3239 }
3240
3241 int unit_reset_ip_accounting(Unit *u) {
3242 int r = 0, q = 0;
3243
3244 assert(u);
3245
3246 if (u->ip_accounting_ingress_map_fd >= 0)
3247 r = bpf_firewall_reset_accounting(u->ip_accounting_ingress_map_fd);
3248
3249 if (u->ip_accounting_egress_map_fd >= 0)
3250 q = bpf_firewall_reset_accounting(u->ip_accounting_egress_map_fd);
3251
3252 zero(u->ip_accounting_extra);
3253
3254 return r < 0 ? r : q;
3255 }
3256
3257 void unit_invalidate_cgroup(Unit *u, CGroupMask m) {
3258 assert(u);
3259
3260 if (!UNIT_HAS_CGROUP_CONTEXT(u))
3261 return;
3262
3263 if (m == 0)
3264 return;
3265
3266 /* always invalidate compat pairs together */
3267 if (m & (CGROUP_MASK_IO | CGROUP_MASK_BLKIO))
3268 m |= CGROUP_MASK_IO | CGROUP_MASK_BLKIO;
3269
3270 if (m & (CGROUP_MASK_CPU | CGROUP_MASK_CPUACCT))
3271 m |= CGROUP_MASK_CPU | CGROUP_MASK_CPUACCT;
3272
3273 if (FLAGS_SET(u->cgroup_invalidated_mask, m)) /* NOP? */
3274 return;
3275
3276 u->cgroup_invalidated_mask |= m;
3277 unit_add_to_cgroup_realize_queue(u);
3278 }
3279
3280 void unit_invalidate_cgroup_bpf(Unit *u) {
3281 assert(u);
3282
3283 if (!UNIT_HAS_CGROUP_CONTEXT(u))
3284 return;
3285
3286 if (u->cgroup_invalidated_mask & CGROUP_MASK_BPF_FIREWALL) /* NOP? */
3287 return;
3288
3289 u->cgroup_invalidated_mask |= CGROUP_MASK_BPF_FIREWALL;
3290 unit_add_to_cgroup_realize_queue(u);
3291
3292 /* If we are a slice unit, we also need to put compile a new BPF program for all our children, as the IP access
3293 * list of our children includes our own. */
3294 if (u->type == UNIT_SLICE) {
3295 Unit *member;
3296 Iterator i;
3297 void *v;
3298
3299 HASHMAP_FOREACH_KEY(v, member, u->dependencies[UNIT_BEFORE], i) {
3300 if (UNIT_DEREF(member->slice) == u)
3301 unit_invalidate_cgroup_bpf(member);
3302 }
3303 }
3304 }
3305
3306 bool unit_cgroup_delegate(Unit *u) {
3307 CGroupContext *c;
3308
3309 assert(u);
3310
3311 if (!UNIT_VTABLE(u)->can_delegate)
3312 return false;
3313
3314 c = unit_get_cgroup_context(u);
3315 if (!c)
3316 return false;
3317
3318 return c->delegate;
3319 }
3320
3321 void manager_invalidate_startup_units(Manager *m) {
3322 Iterator i;
3323 Unit *u;
3324
3325 assert(m);
3326
3327 SET_FOREACH(u, m->startup_units, i)
3328 unit_invalidate_cgroup(u, CGROUP_MASK_CPU|CGROUP_MASK_IO|CGROUP_MASK_BLKIO);
3329 }
3330
3331 static const char* const cgroup_device_policy_table[_CGROUP_DEVICE_POLICY_MAX] = {
3332 [CGROUP_AUTO] = "auto",
3333 [CGROUP_CLOSED] = "closed",
3334 [CGROUP_STRICT] = "strict",
3335 };
3336
3337 DEFINE_STRING_TABLE_LOOKUP(cgroup_device_policy, CGroupDevicePolicy);
Unnamed repository; edit this file 'description' to name the repository.