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