#include <errno.h>

#include <limits.h>

#include <signal.h>

#include <stddef.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/utsname.h>

#include <sys/xattr.h>

#include <unistd.h>

#include "alloc-util.h"

#include "cgroup-util.h"

#include "def.h"

#include "dirent-util.h"

#include "extract-word.h"

#include "fd-util.h"

#include "fileio.h"

#include "format-util.h"

#include "fs-util.h"

#include "log.h"

#include "login-util.h"

#include "macro.h"

#include "missing_magic.h"

#include "mkdir.h"

#include "parse-util.h"

#include "path-util.h"

#include "process-util.h"

#include "set.h"

#include "special.h"

#include "stat-util.h"

#include "stdio-util.h"

#include "string-table.h"

#include "string-util.h"

#include "strv.h"

#include "unit-name.h"

#include "user-util.h"

#include "xattr-util.h"

static int cg_enumerate_items(const char *controller, const char *path, FILE **_f, const char *item) {

_cleanup_free_ char *fs = NULL;

FILE *f;

int r;

assert(_f);

r = cg_get_path(controller, path, item, &fs);

if (r < 0)

return r;

f = fopen(fs, "re");

if (!f)

return -errno;

*_f = f;

return 0;

}

int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {

return cg_enumerate_items(controller, path, _f, "cgroup.procs");

}

int cg_read_pid(FILE *f, pid_t *_pid) {

unsigned long ul;

/* Note that the cgroup.procs might contain duplicates! See

assert(f);

assert(_pid);

errno = 0;

if (fscanf(f, "%lu", &ul) != 1) {

if (feof(f))

return 0;

return errno_or_else(EIO);

}

if (ul <= 0)

return -EIO;

*_pid = (pid_t) ul;

return 1;

}

int cg_read_event(

char **ret) {

_cleanup_free_ char *events = NULL, *content = NULL;

int r;

r = cg_get_path(controller, path, "cgroup.events", &events);

if (r < 0)

return r;

r = read_full_virtual_file(events, &content, NULL);

if (r < 0)

return r;

for (const char *p = content;;) {

_cleanup_free_ char *line = NULL, *key = NULL, *val = NULL;

const char *q;

r = extract_first_word(&p, &line, "\n", 0);

if (r < 0)

return r;

if (r == 0)

return -ENOENT;

q = line;

r = extract_first_word(&q, &key, " ", 0);

if (r < 0)

return r;

if (r == 0)

return -EINVAL;

if (!streq(key, event))

continue;

val = strdup(q);

if (!val)

return -ENOMEM;

*ret = TAKE_PTR(val);

return 0;

}

}

bool cg_ns_supported(void) {

static thread_local int enabled = -1;

if (enabled >= 0)

return enabled;

if (access("/proc/self/ns/cgroup", F_OK) < 0) {

if (errno != ENOENT)

log_debug_errno(errno, "Failed to check whether /proc/self/ns/cgroup is available, assuming not: %m");

enabled = false;

} else

enabled = true;

return enabled;

}

bool cg_freezer_supported(void) {

static thread_local int supported = -1;

if (supported >= 0)

return supported;

supported = cg_all_unified() > 0 && access("/sys/fs/cgroup/init.scope/cgroup.freeze", F_OK) == 0;

return supported;

}

bool cg_kill_supported(void) {

static thread_local int supported = -1;

if (supported >= 0)

return supported;

if (cg_all_unified() <= 0)

supported = false;

else if (access("/sys/fs/cgroup/init.scope/cgroup.kill", F_OK) < 0) {

if (errno != ENOENT)

log_debug_errno(errno, "Failed to check if cgroup.kill is available, assuming not: %m");

supported = false;

} else

supported = true;

return supported;

}

int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {

_cleanup_free_ char *fs = NULL;

int r;

DIR *d;

assert(_d);

/* This is not recursive! */

r = cg_get_path(controller, path, NULL, &fs);

if (r < 0)

return r;

d = opendir(fs);

if (!d)

return -errno;

*_d = d;

return 0;

}

int cg_read_subgroup(DIR *d, char **fn) {

assert(d);

assert(fn);

FOREACH_DIRENT_ALL(de, d, return -errno) {

char *b;

if (de->d_type != DT_DIR)

continue;

if (dot_or_dot_dot(de->d_name))

continue;

b = strdup(de->d_name);

if (!b)

return -ENOMEM;

*fn = b;

return 1;

}

return 0;

}

int cg_rmdir(const char *controller, const char *path) {

_cleanup_free_ char *p = NULL;

int r;

r = cg_get_path(controller, path, NULL, &p);

if (r < 0)

return r;

r = rmdir(p);

if (r < 0 && errno != ENOENT)

return -errno;

r = cg_hybrid_unified();

if (r <= 0)

return r;

if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {

r = cg_rmdir(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path);

if (r < 0)

log_warning_errno(r, "Failed to remove compat systemd cgroup %s: %m", path);

}

return 0;

}

static int cg_kill_items(

const char *item) {

_cleanup_set_free_ Set *allocated_set = NULL;

bool done = false;

int r, ret = 0, ret_log_kill = 0;

pid_t my_pid;

assert(sig >= 0);

/* Don't send SIGCONT twice. Also, SIGKILL always works even when process is suspended, hence don't send

if (IN_SET(sig, SIGCONT, SIGKILL))

flags &= ~CGROUP_SIGCONT;

/* This goes through the tasks list and kills them all. This

if (!s) {

s = allocated_set = set_new(NULL);

if (!s)

return -ENOMEM;

}

my_pid = getpid_cached();

do {

_cleanup_fclose_ FILE *f = NULL;

pid_t pid = 0;

done = true;

r = cg_enumerate_items(controller, path, &f, item);

if (r < 0) {

if (ret >= 0 && r != -ENOENT)

return r;

return ret;

}

while ((r = cg_read_pid(f, &pid)) > 0) {

if ((flags & CGROUP_IGNORE_SELF) && pid == my_pid)

continue;

if (set_get(s, PID_TO_PTR(pid)) == PID_TO_PTR(pid))

continue;

if (log_kill)

ret_log_kill = log_kill(pid, sig, userdata);

/* If we haven't killed this process yet, kill

if (kill(pid, sig) < 0) {

if (ret >= 0 && errno != ESRCH)

ret = -errno;

} else {

if (flags & CGROUP_SIGCONT)

(void) kill(pid, SIGCONT);

if (ret == 0) {

if (log_kill)

ret = ret_log_kill;

else

ret = 1;

}

}

done = false;

r = set_put(s, PID_TO_PTR(pid));

if (r < 0) {

if (ret >= 0)

return r;

return ret;

}

}

if (r < 0) {

if (ret >= 0)

return r;

return ret;

}

/* To avoid racing against processes which fork

} while (!done);

return ret;

}

int cg_kill(

void *userdata) {

int r;

r = cg_kill_items(controller, path, sig, flags, s, log_kill, userdata, "cgroup.procs");

if (r < 0 || sig != SIGKILL)

return r;

/* Only in case of killing with SIGKILL and when using cgroupsv2, kill remaining threads manually as

r = cg_unified_controller(controller);

if (r <= 0)

return r;

return cg_kill_items(controller, path, sig, flags, s, log_kill, userdata, "cgroup.threads");

}

int cg_kill_kernel_sigkill(const char *controller, const char *path) {

/* Kills the cgroup at `path` directly by writing to its cgroup.kill file.

int r;

_cleanup_free_ char *killfile = NULL;

assert(path);

if (!cg_kill_supported())

return -EOPNOTSUPP;

r = cg_get_path(controller, path, "cgroup.kill", &killfile);

if (r < 0)

return r;

r = write_string_file(killfile, "1", WRITE_STRING_FILE_DISABLE_BUFFER);

if (r < 0)

return r;

return 0;

}

int cg_kill_recursive(

void *userdata) {

_cleanup_set_free_ Set *allocated_set = NULL;

_cleanup_closedir_ DIR *d = NULL;

int r, ret;

char *fn;

assert(path);

assert(sig >= 0);

if (sig == SIGKILL && cg_kill_supported() &&

!FLAGS_SET(flags, CGROUP_IGNORE_SELF) && !s && !log_kill) {

/* ignore CGROUP_SIGCONT, since this is a no-op alongside SIGKILL */

ret = cg_kill_kernel_sigkill(controller, path);

if (ret < 0)

return ret;

} else {

if (!s) {

s = allocated_set = set_new(NULL);

if (!s)

return -ENOMEM;

}

ret = cg_kill(controller, path, sig, flags, s, log_kill, userdata);

r = cg_enumerate_subgroups(controller, path, &d);

if (r < 0) {

if (ret >= 0 && r != -ENOENT)

return r;

return ret;

}

while ((r = cg_read_subgroup(d, &fn)) > 0) {

_cleanup_free_ char *p = NULL;

p = path_join(empty_to_root(path), fn);

free(fn);

if (!p)

return -ENOMEM;

r = cg_kill_recursive(controller, p, sig, flags, s, log_kill, userdata);

if (r != 0 && ret >= 0)

ret = r;

}

if (ret >= 0 && r < 0)

ret = r;

}

if (FLAGS_SET(flags, CGROUP_REMOVE)) {

r = cg_rmdir(controller, path);

if (r < 0 && ret >= 0 && !IN_SET(r, -ENOENT, -EBUSY))

return r;

}

return ret;

}

static const char *controller_to_dirname(const char *controller) {

const char *e;

assert(controller);

/* Converts a controller name to the directory name below

if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {

if (cg_hybrid_unified() > 0)

controller = SYSTEMD_CGROUP_CONTROLLER_HYBRID;

else

controller = SYSTEMD_CGROUP_CONTROLLER_LEGACY;

}

e = startswith(controller, "name=");

if (e)

return e;

return controller;

}

static int join_path_legacy(const char *controller, const char *path, const char *suffix, char **fs) {

const char *dn;

char *t = NULL;

assert(fs);

assert(controller);

dn = controller_to_dirname(controller);

if (isempty(path) && isempty(suffix))

t = path_join("/sys/fs/cgroup", dn);

else if (isempty(path))

t = path_join("/sys/fs/cgroup", dn, suffix);

else if (isempty(suffix))

t = path_join("/sys/fs/cgroup", dn, path);

else

t = path_join("/sys/fs/cgroup", dn, path, suffix);

if (!t)

return -ENOMEM;

*fs = t;

return 0;

}

static int join_path_unified(const char *path, const char *suffix, char **fs) {

char *t;

assert(fs);

if (isempty(path) && isempty(suffix))

t = strdup("/sys/fs/cgroup");

else if (isempty(path))

t = path_join("/sys/fs/cgroup", suffix);

else if (isempty(suffix))

t = path_join("/sys/fs/cgroup", path);

else

t = path_join("/sys/fs/cgroup", path, suffix);

if (!t)

return -ENOMEM;

*fs = t;

return 0;

}

int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {

int r;

assert(fs);

if (!controller) {

char *t;

/* If no controller is specified, we return the path

if (!path && !suffix)

return -EINVAL;

if (!suffix)

t = strdup(path);

else if (!path)

t = strdup(suffix);

else

t = path_join(path, suffix);

if (!t)

return -ENOMEM;

*fs = path_simplify(t);

return 0;

}

if (!cg_controller_is_valid(controller))

return -EINVAL;

r = cg_all_unified();

if (r < 0)

return r;

if (r > 0)

r = join_path_unified(path, suffix, fs);

else

r = join_path_legacy(controller, path, suffix, fs);

if (r < 0)

return r;

path_simplify(*fs);

return 0;

}

static int controller_is_v1_accessible(const char *root, const char *controller) {

const char *cpath, *dn;

assert(controller);

dn = controller_to_dirname(controller);

/* If root if specified, we check that:

cpath = strjoina("/sys/fs/cgroup/", dn, root, root ? "/cgroup.procs" : NULL);

return laccess(cpath, root ? W_OK : F_OK);

}

int cg_get_path_and_check(const char *controller, const char *path, const char *suffix, char **fs) {

int r;

assert(controller);

assert(fs);

if (!cg_controller_is_valid(controller))

return -EINVAL;

r = cg_all_unified();

if (r < 0)

return r;

if (r > 0) {

/* In the unified hierarchy all controllers are considered accessible,

if (startswith(controller, "name="))

return -EOPNOTSUPP;

} else {

/* Check if the specified controller is actually accessible */

r = controller_is_v1_accessible(NULL, controller);

if (r < 0)

return r;

}

return cg_get_path(controller, path, suffix, fs);

}

int cg_set_xattr(const char *controller, const char *path, const char *name, const void *value, size_t size, int flags) {

_cleanup_free_ char *fs = NULL;

int r;

assert(path);

assert(name);

assert(value || size <= 0);

r = cg_get_path(controller, path, NULL, &fs);

if (r < 0)

return r;

return RET_NERRNO(setxattr(fs, name, value, size, flags));

}

int cg_get_xattr(const char *controller, const char *path, const char *name, void *value, size_t size) {

_cleanup_free_ char *fs = NULL;

ssize_t n;

int r;

assert(path);

assert(name);

r = cg_get_path(controller, path, NULL, &fs);

if (r < 0)

return r;

n = getxattr(fs, name, value, size);

if (n < 0)

return -errno;

return (int) n;

}

int cg_get_xattr_malloc(const char *controller, const char *path, const char *name, char **ret) {

_cleanup_free_ char *fs = NULL;

int r;

assert(path);

assert(name);

r = cg_get_path(controller, path, NULL, &fs);

if (r < 0)

return r;

r = lgetxattr_malloc(fs, name, ret);

if (r < 0)

return r;

return r;

}

int cg_get_xattr_bool(const char *controller, const char *path, const char *name) {

_cleanup_free_ char *val = NULL;

int r;

assert(path);

assert(name);

r = cg_get_xattr_malloc(controller, path, name, &val);

if (r < 0)

return r;

return parse_boolean(val);

}

int cg_remove_xattr(const char *controller, const char *path, const char *name) {

_cleanup_free_ char *fs = NULL;

int r;

assert(path);

assert(name);

r = cg_get_path(controller, path, NULL, &fs);

if (r < 0)

return r;

return RET_NERRNO(removexattr(fs, name));

}

int cg_pid_get_path(const char *controller, pid_t pid, char **ret_path) {

_cleanup_fclose_ FILE *f = NULL;

const char *fs, *controller_str = NULL; /* avoid false maybe-uninitialized warning */

int unified, r;

assert(pid >= 0);

assert(ret_path);

if (controller) {

if (!cg_controller_is_valid(controller))

return -EINVAL;

} else

controller = SYSTEMD_CGROUP_CONTROLLER;

unified = cg_unified_controller(controller);

if (unified < 0)

return unified;

if (unified == 0) {

if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))

controller_str = SYSTEMD_CGROUP_CONTROLLER_LEGACY;

else

controller_str = controller;

}

fs = procfs_file_alloca(pid, "cgroup");

r = fopen_unlocked(fs, "re", &f);

if (r == -ENOENT)

return -ESRCH;

if (r < 0)

return r;

for (;;) {

_cleanup_free_ char *line = NULL;

char *e;

r = read_line(f, LONG_LINE_MAX, &line);

if (r < 0)

return r;

if (r == 0)

return -ENODATA;

if (unified) {

e = startswith(line, "0:");

if (!e)

continue;

e = strchr(e, ':');

if (!e)

continue;

} else {

char *l;

l = strchr(line, ':');

if (!l)

continue;

l++;

e = strchr(l, ':');

if (!e)

continue;

*e = 0;

assert(controller_str);

r = string_contains_word(l, ",", controller_str);

if (r < 0)

return r;

if (r == 0)

continue;

}

char *path = strdup(e + 1);

if (!path)

return -ENOMEM;

/* Truncate suffix indicating the process is a zombie */

e = endswith(path, " (deleted)");

if (e)

*e = 0;

*ret_path = path;

return 0;

}

}

int cg_install_release_agent(const char *controller, const char *agent) {

_cleanup_free_ char *fs = NULL, *contents = NULL;

const char *sc;

int r;

assert(agent);

r = cg_unified_controller(controller);

if (r < 0)

return r;

if (r > 0) /* doesn't apply to unified hierarchy */

return -EOPNOTSUPP;

r = cg_get_path(controller, NULL, "release_agent", &fs);

if (r < 0)

return r;

r = read_one_line_file(fs, &contents);

if (r < 0)

return r;

sc = strstrip(contents);

if (isempty(sc)) {

r = write_string_file(fs, agent, WRITE_STRING_FILE_DISABLE_BUFFER);

if (r < 0)

return r;

} else if (!path_equal(sc, agent))

return -EEXIST;

fs = mfree(fs);

r = cg_get_path(controller, NULL, "notify_on_release", &fs);

if (r < 0)

return r;

contents = mfree(contents);

r = read_one_line_file(fs, &contents);

if (r < 0)

return r;

sc = strstrip(contents);

if (streq(sc, "0")) {

r = write_string_file(fs, "1", WRITE_STRING_FILE_DISABLE_BUFFER);

if (r < 0)

return r;

return 1;

}

if (!streq(sc, "1"))

return -EIO;

return 0;

}

int cg_uninstall_release_agent(const char *controller) {

_cleanup_free_ char *fs = NULL;

int r;

r = cg_unified_controller(controller);

if (r < 0)

return r;

if (r > 0) /* Doesn't apply to unified hierarchy */

return -EOPNOTSUPP;

r = cg_get_path(controller, NULL, "notify_on_release", &fs);

if (r < 0)

return r;

r = write_string_file(fs, "0", WRITE_STRING_FILE_DISABLE_BUFFER);

if (r < 0)

return r;

fs = mfree(fs);

r = cg_get_path(controller, NULL, "release_agent", &fs);

if (r < 0)

return r;

r = write_string_file(fs, "", WRITE_STRING_FILE_DISABLE_BUFFER);

if (r < 0)

return r;

return 0;

}

int cg_is_empty(const char *controller, const char *path) {

_cleanup_fclose_ FILE *f = NULL;

pid_t pid;

int r;

assert(path);

r = cg_enumerate_processes(controller, path, &f);

if (r == -ENOENT)

return true;

if (r < 0)

return r;

r = cg_read_pid(f, &pid);

if (r < 0)

return r;

return r == 0;

}

int cg_is_empty_recursive(const char *controller, const char *path) {

int r;

assert(path);

/* The root cgroup is always populated */

if (controller && empty_or_root(path))

return false;

r = cg_unified_controller(controller);

if (r < 0)

return r;

if (r > 0) {

_cleanup_free_ char *t = NULL;

/* On the unified hierarchy we can check empty state

r = cg_read_event(controller, path, "populated", &t);

if (r == -ENOENT)

return true;

if (r < 0)

return r;

return streq(t, "0");

} else {

_cleanup_closedir_ DIR *d = NULL;

char *fn;

r = cg_is_empty(controller, path);

if (r <= 0)

return r;

r = cg_enumerate_subgroups(controller, path, &d);

if (r == -ENOENT)

return true;

if (r < 0)

return r;

while ((r = cg_read_subgroup(d, &fn)) > 0) {

_cleanup_free_ char *p = NULL;

p = path_join(path, fn);

free(fn);

if (!p)

return -ENOMEM;

r = cg_is_empty_recursive(controller, p);

if (r <= 0)

return r;

}

if (r < 0)

return r;

return true;

}

}

int cg_split_spec(const char *spec, char **ret_controller, char **ret_path) {

_cleanup_free_ char *controller = NULL, *path = NULL;

assert(spec);

if (*spec == '/') {

if (!path_is_normalized(spec))

return -EINVAL;

if (ret_path) {

path = strdup(spec);

if (!path)

return -ENOMEM;

path_simplify(path);

}

} else {

const char *e;

e = strchr(spec, ':');

if (e) {

controller = strndup(spec, e-spec);

if (!controller)

return -ENOMEM;

if (!cg_controller_is_valid(controller))

return -EINVAL;

if (!isempty(e + 1)) {

path = strdup(e+1);

if (!path)

return -ENOMEM;

if (!path_is_normalized(path) ||

!path_is_absolute(path))

return -EINVAL;

path_simplify(path);

}

} else {

if (!cg_controller_is_valid(spec))

return -EINVAL;

if (ret_controller) {

controller = strdup(spec);

if (!controller)

return -ENOMEM;

}

}

}

if (ret_controller)

*ret_controller = TAKE_PTR(controller);

if (ret_path)

*ret_path = TAKE_PTR(path);