#include <fcntl.h>

#include "sd-messages.h"

#include "af-list.h"

#include "alloc-util.h"

#include "blockdev-util.h"

#include "bpf-devices.h"

#include "bpf-firewall.h"

#include "bpf-foreign.h"

#include "bpf-socket-bind.h"

#include "btrfs-util.h"

#include "bus-error.h"

#include "cgroup-setup.h"

#include "cgroup-util.h"

#include "cgroup.h"

#include "fd-util.h"

#include "fileio.h"

#include "in-addr-prefix-util.h"

#include "inotify-util.h"

#include "io-util.h"

#include "ip-protocol-list.h"

#include "limits-util.h"

#include "nulstr-util.h"

#include "parse-util.h"

#include "path-util.h"

#include "percent-util.h"

#include "process-util.h"

#include "procfs-util.h"

#include "restrict-ifaces.h"

#include "special.h"

#include "stat-util.h"

#include "stdio-util.h"

#include "string-table.h"

#include "string-util.h"

#include "virt.h"

#if BPF_FRAMEWORK

#include "bpf-dlopen.h"

#include "bpf-link.h"

#include "bpf/restrict_fs/restrict-fs-skel.h"

#define CGROUP_CPU_QUOTA_DEFAULT_PERIOD_USEC ((usec_t) 100 * USEC_PER_MSEC)

#define LOG_LEVEL_CGROUP_WRITE(r) (IN_SET(abs(r), ENOENT, EROFS, EACCES, EPERM) ? LOG_DEBUG : LOG_WARNING)

uint64_t tasks_max_resolve(const TasksMax *tasks_max) {

if (tasks_max->scale == 0)

return tasks_max->value;

return system_tasks_max_scale(tasks_max->value, tasks_max->scale);

}

bool manager_owns_host_root_cgroup(Manager *m) {

assert(m);

/* Returns true if we are managing the root cgroup. Note that it isn't sufficient to just check whether the

if (MANAGER_IS_USER(m))

return false;

if (detect_container() > 0)

return false;

return empty_or_root(m->cgroup_root);

}

bool unit_has_startup_cgroup_constraints(Unit *u) {

assert(u);

/* Returns true if this unit has any directives which apply during

CGroupContext *c;

c = unit_get_cgroup_context(u);

if (!c)

return false;

return c->startup_cpu_shares != CGROUP_CPU_SHARES_INVALID ||

c->startup_io_weight != CGROUP_WEIGHT_INVALID ||

c->startup_blockio_weight != CGROUP_BLKIO_WEIGHT_INVALID ||

c->startup_cpuset_cpus.set ||

c->startup_cpuset_mems.set;

}

bool unit_has_host_root_cgroup(Unit *u) {

assert(u);

/* Returns whether this unit manages the root cgroup. This will return true if this unit is the root slice and

if (!manager_owns_host_root_cgroup(u->manager))

return false;

return unit_has_name(u, SPECIAL_ROOT_SLICE);

}

static int set_attribute_and_warn(Unit *u, const char *controller, const char *attribute, const char *value) {

int r;

r = cg_set_attribute(controller, u->cgroup_path, attribute, value);

if (r < 0)

log_unit_full_errno(u, LOG_LEVEL_CGROUP_WRITE(r), r, "Failed to set '%s' attribute on '%s' to '%.*s': %m",

strna(attribute), empty_to_root(u->cgroup_path), (int) strcspn(value, NEWLINE), value);

return r;

}

static void cgroup_compat_warn(void) {

static bool cgroup_compat_warned = false;

if (cgroup_compat_warned)

return;

log_warning("cgroup compatibility translation between legacy and unified hierarchy settings activated. "

"See cgroup-compat debug messages for details.");

cgroup_compat_warned = true;

}

#define log_cgroup_compat(unit, fmt, ...) do { \

cgroup_compat_warn(); \

log_unit_debug(unit, "cgroup-compat: " fmt, ##__VA_ARGS__); \

} while (false)

void cgroup_context_init(CGroupContext *c) {

assert(c);

/* Initialize everything to the kernel defaults. */

*c = (CGroupContext) {

.cpu_weight = CGROUP_WEIGHT_INVALID,

.startup_cpu_weight = CGROUP_WEIGHT_INVALID,

.cpu_quota_per_sec_usec = USEC_INFINITY,

.cpu_quota_period_usec = USEC_INFINITY,

.cpu_shares = CGROUP_CPU_SHARES_INVALID,

.startup_cpu_shares = CGROUP_CPU_SHARES_INVALID,

.memory_high = CGROUP_LIMIT_MAX,

.memory_max = CGROUP_LIMIT_MAX,

.memory_swap_max = CGROUP_LIMIT_MAX,

.memory_limit = CGROUP_LIMIT_MAX,

.io_weight = CGROUP_WEIGHT_INVALID,

.startup_io_weight = CGROUP_WEIGHT_INVALID,

.blockio_weight = CGROUP_BLKIO_WEIGHT_INVALID,

.startup_blockio_weight = CGROUP_BLKIO_WEIGHT_INVALID,

.tasks_max = TASKS_MAX_UNSET,

.moom_swap = MANAGED_OOM_AUTO,

.moom_mem_pressure = MANAGED_OOM_AUTO,

.moom_preference = MANAGED_OOM_PREFERENCE_NONE,

};

}

void cgroup_context_free_device_allow(CGroupContext *c, CGroupDeviceAllow *a) {

assert(c);

assert(a);

LIST_REMOVE(device_allow, c->device_allow, a);

free(a->path);

free(a);

}

void cgroup_context_free_io_device_weight(CGroupContext *c, CGroupIODeviceWeight *w) {

assert(c);

assert(w);

LIST_REMOVE(device_weights, c->io_device_weights, w);

free(w->path);

free(w);

}

void cgroup_context_free_io_device_latency(CGroupContext *c, CGroupIODeviceLatency *l) {

assert(c);

assert(l);

LIST_REMOVE(device_latencies, c->io_device_latencies, l);

free(l->path);

free(l);

}

void cgroup_context_free_io_device_limit(CGroupContext *c, CGroupIODeviceLimit *l) {

assert(c);

assert(l);

LIST_REMOVE(device_limits, c->io_device_limits, l);

free(l->path);

free(l);

}

void cgroup_context_free_blockio_device_weight(CGroupContext *c, CGroupBlockIODeviceWeight *w) {

assert(c);

assert(w);

LIST_REMOVE(device_weights, c->blockio_device_weights, w);

free(w->path);

free(w);

}

void cgroup_context_free_blockio_device_bandwidth(CGroupContext *c, CGroupBlockIODeviceBandwidth *b) {

assert(c);

assert(b);

LIST_REMOVE(device_bandwidths, c->blockio_device_bandwidths, b);

free(b->path);

free(b);

}

void cgroup_context_remove_bpf_foreign_program(CGroupContext *c, CGroupBPFForeignProgram *p) {

assert(c);

assert(p);

LIST_REMOVE(programs, c->bpf_foreign_programs, p);

free(p->bpffs_path);

free(p);

}

void cgroup_context_remove_socket_bind(CGroupSocketBindItem **head) {

assert(head);

while (*head) {

CGroupSocketBindItem *h = *head;

LIST_REMOVE(socket_bind_items, *head, h);

free(h);

}

}

void cgroup_context_done(CGroupContext *c) {

assert(c);

while (c->io_device_weights)

cgroup_context_free_io_device_weight(c, c->io_device_weights);

while (c->io_device_latencies)

cgroup_context_free_io_device_latency(c, c->io_device_latencies);

while (c->io_device_limits)

cgroup_context_free_io_device_limit(c, c->io_device_limits);

while (c->blockio_device_weights)

cgroup_context_free_blockio_device_weight(c, c->blockio_device_weights);

while (c->blockio_device_bandwidths)

cgroup_context_free_blockio_device_bandwidth(c, c->blockio_device_bandwidths);

while (c->device_allow)

cgroup_context_free_device_allow(c, c->device_allow);

cgroup_context_remove_socket_bind(&c->socket_bind_allow);

cgroup_context_remove_socket_bind(&c->socket_bind_deny);

c->ip_address_allow = set_free(c->ip_address_allow);

c->ip_address_deny = set_free(c->ip_address_deny);

c->ip_filters_ingress = strv_free(c->ip_filters_ingress);

c->ip_filters_egress = strv_free(c->ip_filters_egress);

while (c->bpf_foreign_programs)

cgroup_context_remove_bpf_foreign_program(c, c->bpf_foreign_programs);

c->restrict_network_interfaces = set_free(c->restrict_network_interfaces);

cpu_set_reset(&c->cpuset_cpus);

cpu_set_reset(&c->startup_cpuset_cpus);

cpu_set_reset(&c->cpuset_mems);

cpu_set_reset(&c->startup_cpuset_mems);

}

static int unit_get_kernel_memory_limit(Unit *u, const char *file, uint64_t *ret) {

assert(u);

if (!u->cgroup_realized)

return -EOWNERDEAD;

return cg_get_attribute_as_uint64("memory", u->cgroup_path, file, ret);

}

static int unit_compare_memory_limit(Unit *u, const char *property_name, uint64_t *ret_unit_value, uint64_t *ret_kernel_value) {

CGroupContext *c;

CGroupMask m;

const char *file;

uint64_t unit_value;

int r;

/* Compare kernel memcg configuration against our internal systemd state. Unsupported (and will

assert(u);

r = cg_all_unified();

if (r < 0)

return log_debug_errno(r, "Failed to determine cgroup hierarchy version: %m");

/* Unsupported on v1.

if (r == 0)

return -ENODATA;

/* The root slice doesn't have any controller files, so we can't compare anything. */

if (unit_has_name(u, SPECIAL_ROOT_SLICE))

return -ENODATA;

/* It's possible to have MemoryFoo set without systemd wanting to have the memory controller enabled,

m = unit_get_target_mask(u);

if (!FLAGS_SET(m, CGROUP_MASK_MEMORY))

return -ENODATA;

assert_se(c = unit_get_cgroup_context(u));

if (streq(property_name, "MemoryLow")) {

unit_value = unit_get_ancestor_memory_low(u);

file = "memory.low";

} else if (streq(property_name, "MemoryMin")) {

unit_value = unit_get_ancestor_memory_min(u);

file = "memory.min";

} else if (streq(property_name, "MemoryHigh")) {

unit_value = c->memory_high;

file = "memory.high";

} else if (streq(property_name, "MemoryMax")) {

unit_value = c->memory_max;

file = "memory.max";

} else if (streq(property_name, "MemorySwapMax")) {

unit_value = c->memory_swap_max;

file = "memory.swap.max";

} else

return -EINVAL;

r = unit_get_kernel_memory_limit(u, file, ret_kernel_value);

if (r < 0)

return log_unit_debug_errno(u, r, "Failed to parse %s: %m", file);

/* It's intended (soon) in a future kernel to not expose cgroup memory limits rounded to page

if (*ret_kernel_value == unit_value) {

*ret_unit_value = unit_value;

return 1;

}

/* The current kernel behaviour, by comparison, is that even if you write a particular number of

if (unit_value != CGROUP_LIMIT_MAX)

unit_value = PAGE_ALIGN_DOWN(unit_value);

*ret_unit_value = unit_value;

return *ret_kernel_value == *ret_unit_value;

}

#define FORMAT_CGROUP_DIFF_MAX 128

static char *format_cgroup_memory_limit_comparison(char *buf, size_t l, Unit *u, const char *property_name) {

uint64_t kval, sval;

int r;

assert(u);

assert(buf);

assert(l > 0);

r = unit_compare_memory_limit(u, property_name, &sval, &kval);

/* memory.swap.max is special in that it relies on CONFIG_MEMCG_SWAP (and the default swapaccount=1).

if (r > 0 || IN_SET(r, -ENODATA, -EOWNERDEAD) ||

(r == -ENOENT && streq(property_name, "MemorySwapMax"))) {

buf[0] = 0;

return buf;

}

if (r < 0) {

(void) snprintf(buf, l, " (error getting kernel value: %s)", strerror_safe(r));

return buf;

}

(void) snprintf(buf, l, " (different value in kernel: %" PRIu64 ")", kval);

return buf;

}

void cgroup_context_dump(Unit *u, FILE* f, const char *prefix) {

_cleanup_free_ char *disable_controllers_str = NULL, *cpuset_cpus = NULL, *cpuset_mems = NULL, *startup_cpuset_cpus = NULL, *startup_cpuset_mems = NULL;

CGroupContext *c;

struct in_addr_prefix *iaai;

char cda[FORMAT_CGROUP_DIFF_MAX];

char cdb[FORMAT_CGROUP_DIFF_MAX];

char cdc[FORMAT_CGROUP_DIFF_MAX];

char cdd[FORMAT_CGROUP_DIFF_MAX];

char cde[FORMAT_CGROUP_DIFF_MAX];

assert(u);

assert(f);

assert_se(c = unit_get_cgroup_context(u));

prefix = strempty(prefix);

(void) cg_mask_to_string(c->disable_controllers, &disable_controllers_str);

cpuset_cpus = cpu_set_to_range_string(&c->cpuset_cpus);

startup_cpuset_cpus = cpu_set_to_range_string(&c->startup_cpuset_cpus);

cpuset_mems = cpu_set_to_range_string(&c->cpuset_mems);

startup_cpuset_mems = cpu_set_to_range_string(&c->startup_cpuset_mems);

fprintf(f,

"%sCPUAccounting: %s\n"

"%sIOAccounting: %s\n"

"%sBlockIOAccounting: %s\n"

"%sMemoryAccounting: %s\n"

"%sTasksAccounting: %s\n"

"%sIPAccounting: %s\n"

"%sCPUWeight: %" PRIu64 "\n"

"%sStartupCPUWeight: %" PRIu64 "\n"

"%sCPUShares: %" PRIu64 "\n"

"%sStartupCPUShares: %" PRIu64 "\n"

"%sCPUQuotaPerSecSec: %s\n"

"%sCPUQuotaPeriodSec: %s\n"

"%sAllowedCPUs: %s\n"

"%sStartupAllowedCPUs: %s\n"

"%sAllowedMemoryNodes: %s\n"

"%sStartupAllowedMemoryNodes: %s\n"

"%sIOWeight: %" PRIu64 "\n"

"%sStartupIOWeight: %" PRIu64 "\n"

"%sBlockIOWeight: %" PRIu64 "\n"

"%sStartupBlockIOWeight: %" PRIu64 "\n"

"%sDefaultMemoryMin: %" PRIu64 "\n"

"%sDefaultMemoryLow: %" PRIu64 "\n"

"%sMemoryMin: %" PRIu64 "%s\n"

"%sMemoryLow: %" PRIu64 "%s\n"

"%sMemoryHigh: %" PRIu64 "%s\n"

"%sMemoryMax: %" PRIu64 "%s\n"

"%sMemorySwapMax: %" PRIu64 "%s\n"

"%sMemoryLimit: %" PRIu64 "\n"

"%sTasksMax: %" PRIu64 "\n"

"%sDevicePolicy: %s\n"

"%sDisableControllers: %s\n"

"%sDelegate: %s\n"

"%sManagedOOMSwap: %s\n"

"%sManagedOOMMemoryPressure: %s\n"

"%sManagedOOMMemoryPressureLimit: " PERMYRIAD_AS_PERCENT_FORMAT_STR "\n"

"%sManagedOOMPreference: %s\n",

prefix, yes_no(c->cpu_accounting),

prefix, yes_no(c->io_accounting),

prefix, yes_no(c->blockio_accounting),

prefix, yes_no(c->memory_accounting),

prefix, yes_no(c->tasks_accounting),

prefix, yes_no(c->ip_accounting),

prefix, c->cpu_weight,

prefix, c->startup_cpu_weight,

prefix, c->cpu_shares,

prefix, c->startup_cpu_shares,

prefix, FORMAT_TIMESPAN(c->cpu_quota_per_sec_usec, 1),

prefix, FORMAT_TIMESPAN(c->cpu_quota_period_usec, 1),

prefix, strempty(cpuset_cpus),

prefix, strempty(startup_cpuset_cpus),

prefix, strempty(cpuset_mems),

prefix, strempty(startup_cpuset_mems),

prefix, c->io_weight,

prefix, c->startup_io_weight,

prefix, c->blockio_weight,

prefix, c->startup_blockio_weight,

prefix, c->default_memory_min,

prefix, c->default_memory_low,

prefix, c->memory_min, format_cgroup_memory_limit_comparison(cda, sizeof(cda), u, "MemoryMin"),

prefix, c->memory_low, format_cgroup_memory_limit_comparison(cdb, sizeof(cdb), u, "MemoryLow"),

prefix, c->memory_high, format_cgroup_memory_limit_comparison(cdc, sizeof(cdc), u, "MemoryHigh"),

prefix, c->memory_max, format_cgroup_memory_limit_comparison(cdd, sizeof(cdd), u, "MemoryMax"),

prefix, c->memory_swap_max, format_cgroup_memory_limit_comparison(cde, sizeof(cde), u, "MemorySwapMax"),

prefix, c->memory_limit,

prefix, tasks_max_resolve(&c->tasks_max),

prefix, cgroup_device_policy_to_string(c->device_policy),

prefix, strempty(disable_controllers_str),

prefix, yes_no(c->delegate),

prefix, managed_oom_mode_to_string(c->moom_swap),

prefix, managed_oom_mode_to_string(c->moom_mem_pressure),

prefix, PERMYRIAD_AS_PERCENT_FORMAT_VAL(UINT32_SCALE_TO_PERMYRIAD(c->moom_mem_pressure_limit)),

prefix, managed_oom_preference_to_string(c->moom_preference));

if (c->delegate) {

_cleanup_free_ char *t = NULL;

(void) cg_mask_to_string(c->delegate_controllers, &t);

fprintf(f, "%sDelegateControllers: %s\n",

prefix,

strempty(t));

}

LIST_FOREACH(device_allow, a, c->device_allow)

fprintf(f,

"%sDeviceAllow: %s %s%s%s\n",

prefix,

a->path,

a->r ? "r" : "", a->w ? "w" : "", a->m ? "m" : "");

LIST_FOREACH(device_weights, iw, c->io_device_weights)

fprintf(f,

"%sIODeviceWeight: %s %" PRIu64 "\n",

prefix,

iw->path,

iw->weight);

LIST_FOREACH(device_latencies, l, c->io_device_latencies)

fprintf(f,

"%sIODeviceLatencyTargetSec: %s %s\n",

prefix,

l->path,

FORMAT_TIMESPAN(l->target_usec, 1));

LIST_FOREACH(device_limits, il, c->io_device_limits)

for (CGroupIOLimitType type = 0; type < _CGROUP_IO_LIMIT_TYPE_MAX; type++)

if (il->limits[type] != cgroup_io_limit_defaults[type])

fprintf(f,

"%s%s: %s %s\n",

prefix,

cgroup_io_limit_type_to_string(type),

il->path,

FORMAT_BYTES(il->limits[type]));

LIST_FOREACH(device_weights, w, c->blockio_device_weights)

fprintf(f,

"%sBlockIODeviceWeight: %s %" PRIu64,

prefix,

w->path,

w->weight);

LIST_FOREACH(device_bandwidths, b, c->blockio_device_bandwidths) {

if (b->rbps != CGROUP_LIMIT_MAX)

fprintf(f,

"%sBlockIOReadBandwidth: %s %s\n",

prefix,

b->path,

FORMAT_BYTES(b->rbps));

if (b->wbps != CGROUP_LIMIT_MAX)

fprintf(f,

"%sBlockIOWriteBandwidth: %s %s\n",

prefix,

b->path,

FORMAT_BYTES(b->wbps));

}

SET_FOREACH(iaai, c->ip_address_allow) {

_cleanup_free_ char *k = NULL;

(void) in_addr_prefix_to_string(iaai->family, &iaai->address, iaai->prefixlen, &k);

fprintf(f, "%sIPAddressAllow: %s\n", prefix, strnull(k));

}

SET_FOREACH(iaai, c->ip_address_deny) {

_cleanup_free_ char *k = NULL;

(void) in_addr_prefix_to_string(iaai->family, &iaai->address, iaai->prefixlen, &k);

fprintf(f, "%sIPAddressDeny: %s\n", prefix, strnull(k));

}

STRV_FOREACH(path, c->ip_filters_ingress)

fprintf(f, "%sIPIngressFilterPath: %s\n", prefix, *path);

STRV_FOREACH(path, c->ip_filters_egress)

fprintf(f, "%sIPEgressFilterPath: %s\n", prefix, *path);

LIST_FOREACH(programs, p, c->bpf_foreign_programs)

fprintf(f, "%sBPFProgram: %s:%s",

prefix, bpf_cgroup_attach_type_to_string(p->attach_type), p->bpffs_path);

if (c->socket_bind_allow) {

fprintf(f, "%sSocketBindAllow:", prefix);

LIST_FOREACH(socket_bind_items, bi, c->socket_bind_allow)

cgroup_context_dump_socket_bind_item(bi, f);

fputc('\n', f);

}

if (c->socket_bind_deny) {

fprintf(f, "%sSocketBindDeny:", prefix);

LIST_FOREACH(socket_bind_items, bi, c->socket_bind_deny)

cgroup_context_dump_socket_bind_item(bi, f);

fputc('\n', f);

}

if (c->restrict_network_interfaces) {

char *iface;

SET_FOREACH(iface, c->restrict_network_interfaces)

fprintf(f, "%sRestrictNetworkInterfaces: %s\n", prefix, iface);

}

}

void cgroup_context_dump_socket_bind_item(const CGroupSocketBindItem *item, FILE *f) {

const char *family, *colon1, *protocol = "", *colon2 = "";

family = strempty(af_to_ipv4_ipv6(item->address_family));

colon1 = isempty(family) ? "" : ":";

if (item->ip_protocol != 0) {

protocol = ip_protocol_to_tcp_udp(item->ip_protocol);

colon2 = ":";

}

if (item->nr_ports == 0)

fprintf(f, " %s%s%s%sany", family, colon1, protocol, colon2);

else if (item->nr_ports == 1)

fprintf(f, " %s%s%s%s%" PRIu16, family, colon1, protocol, colon2, item->port_min);

else {

uint16_t port_max = item->port_min + item->nr_ports - 1;

fprintf(f, " %s%s%s%s%" PRIu16 "-%" PRIu16, family, colon1, protocol, colon2,

item->port_min, port_max);

}

}

int cgroup_add_device_allow(CGroupContext *c, const char *dev, const char *mode) {

_cleanup_free_ CGroupDeviceAllow *a = NULL;

_cleanup_free_ char *d = NULL;

assert(c);

assert(dev);

assert(isempty(mode) || in_charset(mode, "rwm"));

a = new(CGroupDeviceAllow, 1);

if (!a)

return -ENOMEM;

d = strdup(dev);

if (!d)

return -ENOMEM;

*a = (CGroupDeviceAllow) {

.path = TAKE_PTR(d),

.r = isempty(mode) || strchr(mode, 'r'),

.w = isempty(mode) || strchr(mode, 'w'),

.m = isempty(mode) || strchr(mode, 'm'),

};

LIST_PREPEND(device_allow, c->device_allow, a);

TAKE_PTR(a);

return 0;

}

int cgroup_add_bpf_foreign_program(CGroupContext *c, uint32_t attach_type, const char *bpffs_path) {

CGroupBPFForeignProgram *p;

_cleanup_free_ char *d = NULL;

assert(c);

assert(bpffs_path);

if (!path_is_normalized(bpffs_path) || !path_is_absolute(bpffs_path))

return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Path is not normalized: %m");

d = strdup(bpffs_path);

if (!d)

return log_oom();

p = new(CGroupBPFForeignProgram, 1);

if (!p)

return log_oom();

*p = (CGroupBPFForeignProgram) {

.attach_type = attach_type,

.bpffs_path = TAKE_PTR(d),

};

LIST_PREPEND(programs, c->bpf_foreign_programs, TAKE_PTR(p));

return 0;

}

#define UNIT_DEFINE_ANCESTOR_MEMORY_LOOKUP(entry) \

uint64_t unit_get_ancestor_##entry(Unit *u) { \

CGroupContext *c; \

\

/* 1. Is entry set in this unit? If so, use that. \

* 3. Otherwise, return CGROUP_LIMIT_MIN. */ \

\

assert(u); \

\

c = unit_get_cgroup_context(u); \

if (c && c->entry##_set) \

return c->entry; \

\

while ((u = UNIT_GET_SLICE(u))) { \

c = unit_get_cgroup_context(u); \

if (c && c->default_##entry##_set) \

return c->default_##entry; \

} \

\

/* We've reached the root, but nobody had default for \

* this entry set, so set it to the kernel default. */ \

return CGROUP_LIMIT_MIN; \

}

UNIT_DEFINE_ANCESTOR_MEMORY_LOOKUP(memory_low);

UNIT_DEFINE_ANCESTOR_MEMORY_LOOKUP(memory_min);

static void unit_set_xattr_graceful(Unit *u, const char *cgroup_path, const char *name, const void *data, size_t size) {

int r;

assert(u);

assert(name);

if (!cgroup_path) {

if (!u->cgroup_path)

return;

cgroup_path = u->cgroup_path;

}

r = cg_set_xattr(SYSTEMD_CGROUP_CONTROLLER, cgroup_path, name, data, size, 0);

if (r < 0)

log_unit_debug_errno(u, r, "Failed to set '%s' xattr on control group %s, ignoring: %m", name, empty_to_root(cgroup_path));

}

static void unit_remove_xattr_graceful(Unit *u, const char *cgroup_path, const char *name) {

int r;

assert(u);

assert(name);

if (!cgroup_path) {

if (!u->cgroup_path)

return;

cgroup_path = u->cgroup_path;

}

r = cg_remove_xattr(SYSTEMD_CGROUP_CONTROLLER, cgroup_path, name);

if (r < 0 && r != -ENODATA)

log_unit_debug_errno(u, r, "Failed to remove '%s' xattr flag on control group %s, ignoring: %m", name, empty_to_root(cgroup_path));

}

void cgroup_oomd_xattr_apply(Unit *u, const char *cgroup_path) {

CGroupContext *c;

assert(u);

c = unit_get_cgroup_context(u);

if (!c)

return;

if (c->moom_preference == MANAGED_OOM_PREFERENCE_OMIT)

unit_set_xattr_graceful(u, cgroup_path, "user.oomd_omit", "1", 1);

if (c->moom_preference == MANAGED_OOM_PREFERENCE_AVOID)

unit_set_xattr_graceful(u, cgroup_path, "user.oomd_avoid", "1", 1);

if (c->moom_preference != MANAGED_OOM_PREFERENCE_AVOID)

unit_remove_xattr_graceful(u, cgroup_path, "user.oomd_avoid");

if (c->moom_preference != MANAGED_OOM_PREFERENCE_OMIT)

unit_remove_xattr_graceful(u, cgroup_path, "user.oomd_omit");

}

static void cgroup_xattr_apply(Unit *u) {

bool b;

assert(u);

if (!MANAGER_IS_SYSTEM(u->manager))

return;

b = !sd_id128_is_null(u->invocation_id);

FOREACH_STRING(xn, "trusted.invocation_id", "user.invocation_id") {

if (b)

unit_set_xattr_graceful(u, NULL, xn, SD_ID128_TO_STRING(u->invocation_id), 32);

else

unit_remove_xattr_graceful(u, NULL, xn);

}

/* Indicate on the cgroup whether delegation is on, via an xattr. This is best-effort, as old kernels

b = unit_cgroup_delegate(u);

FOREACH_STRING(xn, "trusted.delegate", "user.delegate") {

if (b)

unit_set_xattr_graceful(u, NULL, xn, "1", 1);

else

unit_remove_xattr_graceful(u, NULL, xn);

}

cgroup_oomd_xattr_apply(u, u->cgroup_path);

}

static int lookup_block_device(const char *p, dev_t *ret) {

dev_t rdev, dev = 0;

mode_t mode;

int r;

assert(p);

assert(ret);

r = device_path_parse_major_minor(p, &mode, &rdev);

if (r == -ENODEV) { /* not a parsable device node, need to go to disk */

struct stat st;

if (stat(p, &st) < 0)

return log_warning_errno(errno, "Couldn't stat device '%s': %m", p);

mode = st.st_mode;

rdev = st.st_rdev;

dev = st.st_dev;

} else if (r < 0)

return log_warning_errno(r, "Failed to parse major/minor from path '%s': %m", p);

if (S_ISCHR(mode))

return log_warning_errno(SYNTHETIC_ERRNO(ENOTBLK),

"Device node '%s' is a character device, but block device needed.", p);

if (S_ISBLK(mode))

*ret = rdev;

else if (major(dev) != 0)

*ret = dev; /* If this is not a device node then use the block device this file is stored on */

else {

/* If this is btrfs, getting the backing block device is a bit harder */

r = btrfs_get_block_device(p, ret);

if (r == -ENOTTY)

return log_warning_errno(SYNTHETIC_ERRNO(ENODEV),

"'%s' is not a block device node, and file system block device cannot be determined or is not local.", p);

if (r < 0)

return log_warning_errno(r, "Failed to determine block device backing btrfs file system '%s': %m", p);

}

/* If this is a LUKS/DM device, recursively try to get the originating block device */

while (block_get_originating(*ret, ret) > 0);

/* If this is a partition, try to get the originating block device */

(void) block_get_whole_disk(*ret, ret);

return 0;

}

static bool cgroup_context_has_cpu_weight(CGroupContext *c) {

return c->cpu_weight != CGROUP_WEIGHT_INVALID ||

c->startup_cpu_weight != CGROUP_WEIGHT_INVALID;

}

static bool cgroup_context_has_cpu_shares(CGroupContext *c) {

return c->cpu_shares != CGROUP_CPU_SHARES_INVALID ||

c->startup_cpu_shares != CGROUP_CPU_SHARES_INVALID;

}

static bool cgroup_context_has_allowed_cpus(CGroupContext *c) {

return c->cpuset_cpus.set || c->startup_cpuset_cpus.set;

}

static bool cgroup_context_has_allowed_mems(CGroupContext *c) {

return c->cpuset_mems.set || c->startup_cpuset_mems.set;

}

static uint64_t cgroup_context_cpu_weight(CGroupContext *c, ManagerState state) {

if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING, MANAGER_STOPPING) &&

c->startup_cpu_weight != CGROUP_WEIGHT_INVALID)

return c->startup_cpu_weight;

else if (c->cpu_weight != CGROUP_WEIGHT_INVALID)

return c->cpu_weight;

else

return CGROUP_WEIGHT_DEFAULT;

}

static uint64_t cgroup_context_cpu_shares(CGroupContext *c, ManagerState state) {

if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING, MANAGER_STOPPING) &&

c->startup_cpu_shares != CGROUP_CPU_SHARES_INVALID)

return c->startup_cpu_shares;

else if (c->cpu_shares != CGROUP_CPU_SHARES_INVALID)

return c->cpu_shares;

else

return CGROUP_CPU_SHARES_DEFAULT;

}

static CPUSet *cgroup_context_allowed_cpus(CGroupContext *c, ManagerState state) {

if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING, MANAGER_STOPPING) &&

c->startup_cpuset_cpus.set)

return &c->startup_cpuset_cpus;

else

return &c->cpuset_cpus;

}

static CPUSet *cgroup_context_allowed_mems(CGroupContext *c, ManagerState state) {

if (IN_SET(state, MANAGER_STARTING, MANAGER_INITIALIZING, MANAGER_STOPPING) &&

c->startup_cpuset_mems.set)

return &c->startup_cpuset_mems;

else

return &c->cpuset_mems;

}

usec_t cgroup_cpu_adjust_period(usec_t period, usec_t quota, usec_t resolution, usec_t max_period) {

/* kernel uses a minimum resolution of 1ms, so both period and (quota * period)

assert(quota > 0);

return MIN(MAX3(period, resolution, resolution * USEC_PER_SEC / quota), max_period);

}

static usec_t cgroup_cpu_adjust_period_and_log(Unit *u, usec_t period, usec_t quota) {

usec_t new_period;

if (quota == USEC_INFINITY)

/* Always use default period for infinity quota. */

return CGROUP_CPU_QUOTA_DEFAULT_PERIOD_USEC;

if (period == USEC_INFINITY)

/* Default period was requested. */

period = CGROUP_CPU_QUOTA_DEFAULT_PERIOD_USEC;

/* Clamp to interval [1ms, 1s] */

new_period = cgroup_cpu_adjust_period(period, quota, USEC_PER_MSEC, USEC_PER_SEC);

if (new_period != period) {

log_unit_full(u, u->warned_clamping_cpu_quota_period ? LOG_DEBUG : LOG_WARNING,

"Clamping CPU interval for cpu.max: period is now %s",

FORMAT_TIMESPAN(new_period, 1));

u->warned_clamping_cpu_quota_period = true;

}

return new_period;

}

static void cgroup_apply_unified_cpu_weight(Unit *u, uint64_t weight) {

char buf[DECIMAL_STR_MAX(uint64_t) + 2];

xsprintf(buf, "%" PRIu64 "\n", weight);

(void) set_attribute_and_warn(u, "cpu", "cpu.weight", buf);

}

static void cgroup_apply_unified_cpu_quota(Unit *u, usec_t quota, usec_t period) {

char buf[(DECIMAL_STR_MAX(usec_t) + 1) * 2 + 1];

period = cgroup_cpu_adjust_period_and_log(u, period, quota);

if (quota != USEC_INFINITY)

xsprintf(buf, USEC_FMT " " USEC_FMT "\n",

MAX(quota * period / USEC_PER_SEC, USEC_PER_MSEC), period);

else

xsprintf(buf, "max " USEC_FMT "\n", period);

(void) set_attribute_and_warn(u, "cpu", "cpu.max", buf);

}

static void cgroup_apply_legacy_cpu_shares(Unit *u, uint64_t shares) {

char buf[DECIMAL_STR_MAX(uint64_t) + 2];

xsprintf(buf, "%" PRIu64 "\n", shares);

(void) set_attribute_and_warn(u, "cpu", "cpu.shares", buf);

}

static void cgroup_apply_legacy_cpu_quota(Unit *u, usec_t quota, usec_t period) {

char buf[DECIMAL_STR_MAX(usec_t) + 2];

period = cgroup_cpu_adjust_period_and_log(u, period, quota);

xsprintf(buf, USEC_FMT "\n", period);

(void) set_attribute_and_warn(u, "cpu", "cpu.cfs_period_us", buf);

if (quota != USEC_INFINITY) {

xsprintf(buf, USEC_FMT "\n", MAX(quota * period / USEC_PER_SEC, USEC_PER_MSEC));

(void) set_attribute_and_warn(u, "cpu", "cpu.cfs_quota_us", buf);

} else

(void) set_attribute_and_warn(u, "cpu", "cpu.cfs_quota_us", "-1\n");

}

static uint64_t cgroup_cpu_shares_to_weight(uint64_t shares) {

return CLAMP(shares * CGROUP_WEIGHT_DEFAULT / CGROUP_CPU_SHARES_DEFAULT,

CGROUP_WEIGHT_MIN, CGROUP_WEIGHT_MAX);

}