chiark / gitweb /
util: place a couple of _likely_ around cache TLS vars
[elogind.git] / src / cgroup-util.c
index 0b8678c..fd0ac98 100644 (file)
@@ -1,4 +1,4 @@
-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
 
 /***
   This file is part of systemd.
@@ -24,8 +24,9 @@
 #include <signal.h>
 #include <string.h>
 #include <stdlib.h>
-
-#include <libcgroup.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 
 #include "cgroup-util.h"
 #include "log.h"
 #include "macro.h"
 #include "util.h"
 
-/*
-   Currently, the only remaining functionality from libcgroup we call
-   here is:
-
-   - cgroup_get_subsys_mount_point()
-   - cgroup_walk_tree_begin()/cgroup_walk_tree_next()
-   - cgroup_delete_cgroup_ext()
- */
-
-int cg_translate_error(int error, int _errno) {
-
-        switch (error) {
-
-        case ECGROUPNOTCOMPILED:
-        case ECGROUPNOTMOUNTED:
-        case ECGROUPNOTEXIST:
-        case ECGROUPNOTCREATED:
-                return -ENOENT;
-
-        case ECGINVAL:
-                return -EINVAL;
-
-        case ECGROUPNOTALLOWED:
-                return -EPERM;
-
-        case ECGOTHER:
-                return -_errno;
-        }
-
-        return -EIO;
-}
-
-static struct cgroup* cg_new(const char *controller, const char *path) {
-        struct cgroup *cgroup;
-
-        assert(path);
-        assert(controller);
-
-        if (!(cgroup = cgroup_new_cgroup(path)))
-                return NULL;
-
-        if (!cgroup_add_controller(cgroup, controller)) {
-                cgroup_free(&cgroup);
-                return NULL;
-        }
-
-        return cgroup;
-}
-
 int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {
         char *fs;
         int r;
@@ -148,12 +100,78 @@ int cg_read_pid(FILE *f, pid_t *_pid) {
         return 1;
 }
 
-int cg_kill(const char *controller, const char *path, int sig, bool ignore_self) {
-        bool killed = false, done = false;
-        Set *s;
-        pid_t my_pid;
+int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {
+        char *fs;
+        int r;
+        DIR *d;
+
+        assert(controller);
+        assert(path);
+        assert(_d);
+
+        /* This is not recursive! */
+
+        if ((r = cg_get_path(controller, path, NULL, &fs)) < 0)
+                return r;
+
+        d = opendir(fs);
+        free(fs);
+
+        if (!d)
+                return -errno;
+
+        *_d = d;
+        return 0;
+}
+
+int cg_read_subgroup(DIR *d, char **fn) {
+        struct dirent *de;
+
+        assert(d);
+
+        errno = 0;
+        while ((de = readdir(d))) {
+                char *b;
+
+                if (de->d_type != DT_DIR)
+                        continue;
+
+                if (streq(de->d_name, ".") ||
+                    streq(de->d_name, ".."))
+                        continue;
+
+                if (!(b = strdup(de->d_name)))
+                        return -ENOMEM;
+
+                *fn = b;
+                return 1;
+        }
+
+        if (errno)
+                return -errno;
+
+        return 0;
+}
+
+int cg_rmdir(const char *controller, const char *path) {
+        char *p;
+        int r;
+
+        if ((r = cg_get_path(controller, path, NULL, &p)) < 0)
+                return r;
+
+        r = rmdir(p);
+        free(p);
+
+        return r < 0 ? -errno : 0;
+}
+
+int cg_kill(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, Set *s) {
+        bool done = false;
         int r, ret = 0;
+        pid_t my_pid;
         FILE *f = NULL;
+        Set *allocated_set = NULL;
 
         assert(controller);
         assert(path);
@@ -163,17 +181,22 @@ int cg_kill(const char *controller, const char *path, int sig, bool ignore_self)
          * is repeated until no further processes are added to the
          * tasks list, to properly handle forking processes */
 
-        if (!(s = set_new(trivial_hash_func, trivial_compare_func)))
-                return -ENOMEM;
+        if (!s)
+                if (!(s = allocated_set = set_new(trivial_hash_func, trivial_compare_func)))
+                        return -ENOMEM;
 
         my_pid = getpid();
 
         do {
-                pid_t pid;
+                pid_t pid = 0;
                 done = true;
 
-                if ((r = cg_enumerate_processes(controller, path, &f)) < 0)
+                if ((r = cg_enumerate_processes(controller, path, &f)) < 0) {
+                        if (ret >= 0 && r != -ENOENT)
+                                ret = r;
+
                         goto finish;
+                }
 
                 while ((r = cg_read_pid(f, &pid)) > 0) {
 
@@ -185,16 +208,32 @@ int cg_kill(const char *controller, const char *path, int sig, bool ignore_self)
 
                         /* If we haven't killed this process yet, kill
                          * it */
-                        if (kill(pid, sig) < 0 && errno != ESRCH) {
-                                if (ret == 0)
+                        if (kill(pid, sig) < 0) {
+                                if (ret >= 0 && errno != ESRCH)
                                         ret = -errno;
+                        } else if (ret == 0) {
+
+                                if (sigcont)
+                                        kill(pid, SIGCONT);
+
+                                ret = 1;
                         }
 
-                        killed = true;
                         done = false;
 
-                        if ((r = set_put(s, LONG_TO_PTR(pid))) < 0)
-                                break;
+                        if ((r = set_put(s, LONG_TO_PTR(pid))) < 0) {
+                                if (ret >= 0)
+                                        ret = r;
+
+                                goto finish;
+                        }
+                }
+
+                if (r < 0) {
+                        if (ret >= 0)
+                                ret = r;
+
+                        goto finish;
                 }
 
                 fclose(f);
@@ -204,108 +243,116 @@ int cg_kill(const char *controller, const char *path, int sig, bool ignore_self)
                  * quicker than we can kill them we repeat this until
                  * no new pids need to be killed. */
 
-        } while (!done && r >= 0);
+        } while (!done);
 
 finish:
-        set_free(s);
+        if (allocated_set)
+                set_free(allocated_set);
 
         if (f)
                 fclose(f);
 
-        if (r < 0)
-                return r;
-
-        if (ret < 0)
-                return ret;
-
-        return !!killed;
+        return ret;
 }
 
-int cg_kill_recursive(const char *controller, const char *path, int sig, bool ignore_self) {
-        struct cgroup_file_info info;
-        int level = 0, r, ret = 0;
-        void *iterator = NULL;
-        bool killed = false;
+int cg_kill_recursive(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, bool rem, Set *s) {
+        int r, ret = 0;
+        DIR *d = NULL;
+        char *fn;
+        Set *allocated_set = NULL;
 
         assert(path);
         assert(controller);
         assert(sig >= 0);
 
-        zero(info);
+        if (!s)
+                if (!(s = allocated_set = set_new(trivial_hash_func, trivial_compare_func)))
+                        return -ENOMEM;
+
+        ret = cg_kill(controller, path, sig, sigcont, ignore_self, s);
+
+        if ((r = cg_enumerate_subgroups(controller, path, &d)) < 0) {
+                if (ret >= 0 && r != -ENOENT)
+                        ret = r;
+
+                goto finish;
+        }
+
+        while ((r = cg_read_subgroup(d, &fn)) > 0) {
+                char *p = NULL;
 
-        r = cgroup_walk_tree_begin(controller, path, 0, &iterator, &info, &level);
-        while (r == 0) {
-                int k;
-                char *p;
+                r = asprintf(&p, "%s/%s", path, fn);
+                free(fn);
 
-                if (info.type != CGROUP_FILE_TYPE_DIR)
-                        goto next;
+                if (r < 0) {
+                        if (ret >= 0)
+                                ret = -ENOMEM;
 
-                if (asprintf(&p, "%s/%s", path, info.path) < 0) {
-                        ret = -ENOMEM;
-                        break;
+                        goto finish;
                 }
 
-                k = cg_kill(controller, p, sig, ignore_self);
+                r = cg_kill_recursive(controller, p, sig, sigcont, ignore_self, rem, s);
                 free(p);
 
-                if (k < 0) {
-                        if (ret == 0)
-                                ret = k;
-                } else if (k > 0)
-                        killed = true;
+                if (r != 0 && ret >= 0)
+                        ret = r;
+        }
 
-        next:
+        if (r < 0 && ret >= 0)
+                ret = r;
 
-                r = cgroup_walk_tree_next(0, &iterator, &info, level);
-        }
+        if (rem)
+                if ((r = cg_rmdir(controller, path)) < 0) {
+                        if (ret >= 0 &&
+                            r != -ENOENT &&
+                            r != -EBUSY)
+                                ret = r;
+                }
 
-        if (ret == 0) {
-                if (r == 0 || r == ECGEOF)
-                        ret = !!killed;
-                else if (r == ECGOTHER && errno == ENOENT)
-                        ret = -ESRCH;
-                else
-                        ret = cg_translate_error(r, errno);
-        }
+finish:
+        if (d)
+                closedir(d);
 
-        assert_se(cgroup_walk_tree_end(&iterator) == 0);
+        if (allocated_set)
+                set_free(allocated_set);
 
         return ret;
 }
 
-int cg_kill_recursive_and_wait(const char *controller, const char *path) {
+int cg_kill_recursive_and_wait(const char *controller, const char *path, bool rem) {
         unsigned i;
 
         assert(path);
         assert(controller);
 
         /* This safely kills all processes; first it sends a SIGTERM,
-         * then checks 8 times after 50ms whether the group is
-         * now empty, and finally kills everything that is left with
-         * SIGKILL */
+         * then checks 8 times after 200ms whether the group is now
+         * empty, then kills everything that is left with SIGKILL and
+         * finally checks 5 times after 200ms each whether the group
+         * is finally empty. */
 
-        for (i = 0; i < 10; i++) {
+        for (i = 0; i < 15; i++) {
                 int sig, r;
 
                 if (i <= 0)
                         sig = SIGTERM;
-                else if (i >= 9)
+                else if (i == 9)
                         sig = SIGKILL;
                 else
                         sig = 0;
 
-                if ((r = cg_kill_recursive(controller, path, sig, true)) <= 0)
+                if ((r = cg_kill_recursive(controller, path, sig, true, true, rem, NULL)) <= 0)
                         return r;
 
-                usleep(50 * USEC_PER_MSEC);
+                usleep(200 * USEC_PER_MSEC);
         }
 
         return 0;
 }
 
 int cg_migrate(const char *controller, const char *from, const char *to, bool ignore_self) {
-        bool migrated = false, done = false;
+        bool done = false;
+        Set *s;
         int r, ret = 0;
         pid_t my_pid;
         FILE *f = NULL;
@@ -314,124 +361,176 @@ int cg_migrate(const char *controller, const char *from, const char *to, bool ig
         assert(from);
         assert(to);
 
+        if (!(s = set_new(trivial_hash_func, trivial_compare_func)))
+                return -ENOMEM;
+
         my_pid = getpid();
 
         do {
-                pid_t pid;
+                pid_t pid = 0;
                 done = true;
 
-                if ((r = cg_enumerate_tasks(controller, from, &f)) < 0)
+                if ((r = cg_enumerate_tasks(controller, from, &f)) < 0) {
+                        if (ret >= 0 && r != -ENOENT)
+                                ret = r;
+
                         goto finish;
+                }
 
                 while ((r = cg_read_pid(f, &pid)) > 0) {
 
+                        /* This might do weird stuff if we aren't a
+                         * single-threaded program. However, we
+                         * luckily know we are not */
                         if (pid == my_pid && ignore_self)
                                 continue;
 
+                        if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid))
+                                continue;
+
                         if ((r = cg_attach(controller, to, pid)) < 0) {
-                                if (ret == 0)
-                                        ret = -r;
-                        }
+                                if (ret >= 0 && r != -ESRCH)
+                                        ret = r;
+                        } else if (ret == 0)
+                                ret = 1;
 
-                        migrated = true;
                         done = false;
+
+                        if ((r = set_put(s, LONG_TO_PTR(pid))) < 0) {
+                                if (ret >= 0)
+                                        ret = r;
+
+                                goto finish;
+                        }
+                }
+
+                if (r < 0) {
+                        if (ret >= 0)
+                                ret = r;
+
+                        goto finish;
                 }
 
                 fclose(f);
                 f = NULL;
 
-        } while (!done && r >= 0);
+        } while (!done);
 
 finish:
+        set_free(s);
 
         if (f)
                 fclose(f);
 
-        if (r < 0)
-                return r;
-
-        if (ret < 0)
-                return ret;
-
-        return !!migrated;
+        return ret;
 }
 
-int cg_migrate_recursive(const char *controller, const char *from, const char *to, bool ignore_self) {
-        struct cgroup_file_info info;
-        int level = 0, r, ret = 0;
-        void *iterator = NULL;
-        bool migrated = false;
+int cg_migrate_recursive(const char *controller, const char *from, const char *to, bool ignore_self, bool rem) {
+        int r, ret = 0;
+        DIR *d = NULL;
+        char *fn;
 
         assert(controller);
         assert(from);
         assert(to);
 
-        zero(info);
+        ret = cg_migrate(controller, from, to, ignore_self);
+
+        if ((r = cg_enumerate_subgroups(controller, from, &d)) < 0) {
+                if (ret >= 0 && r != -ENOENT)
+                        ret = r;
+                goto finish;
+        }
+
+        while ((r = cg_read_subgroup(d, &fn)) > 0) {
+                char *p = NULL;
 
-        r = cgroup_walk_tree_begin(controller, from, 0, &iterator, &info, &level);
-        while (r == 0) {
-                int k;
-                char *p;
+                r = asprintf(&p, "%s/%s", from, fn);
+                free(fn);
 
-                if (info.type != CGROUP_FILE_TYPE_DIR)
-                        goto next;
+                if (r < 0) {
+                        if (ret >= 0)
+                                ret = -ENOMEM;
 
-                if (asprintf(&p, "%s/%s", from, info.path) < 0) {
-                        ret = -ENOMEM;
-                        break;
+                        goto finish;
                 }
 
-                k = cg_migrate(controller, p, to, ignore_self);
+                r = cg_migrate_recursive(controller, p, to, ignore_self, rem);
                 free(p);
 
-                if (k < 0) {
-                        if (ret == 0)
-                                ret = k;
-                } else if (k > 0)
-                        migrated = true;
-
-        next:
-                r = cgroup_walk_tree_next(0, &iterator, &info, level);
+                if (r != 0 && ret >= 0)
+                        ret = r;
         }
 
-        if (ret == 0) {
-                if (r == 0 || r == ECGEOF)
-                        r = !!migrated;
-                else if (r == ECGOTHER && errno == ENOENT)
-                        r = -ESRCH;
-                else
-                        r = cg_translate_error(r, errno);
-        }
+        if (r < 0 && ret >= 0)
+                ret = r;
 
-        assert_se(cgroup_walk_tree_end(&iterator) == 0);
+        if (rem)
+                if ((r = cg_rmdir(controller, from)) < 0) {
+                        if (ret >= 0 &&
+                            r != -ENOENT &&
+                            r != -EBUSY)
+                                ret = r;
+                }
+
+finish:
+        if (d)
+                closedir(d);
 
         return ret;
 }
 
 int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {
-        char *mp;
-        int r;
+        const char *p;
+        char *t;
+        static __thread bool good = false;
 
         assert(controller);
+        assert(fs);
+
+        if (_unlikely_(!good)) {
+                int r;
 
-        if ((r = cgroup_get_subsys_mount_point(controller, &mp)) != 0)
-                return cg_translate_error(r, errno);
+                r = path_is_mount_point("/sys/fs/cgroup");
+                if (r <= 0)
+                        return r < 0 ? r : -ENOENT;
+
+                /* Cache this to save a few stat()s */
+                good = true;
+        }
+
+        if (isempty(controller))
+                return -EINVAL;
+
+        /* This is a very minimal lookup from controller names to
+         * paths. Since we have mounted most hierarchies ourselves
+         * should be kinda safe, but eventually we might want to
+         * extend this to have a fallback to actually check
+         * /proc/mounts. Might need caching then. */
+
+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
+                p = "systemd";
+        else if (startswith(controller, "name="))
+                p = controller + 5;
+        else
+                p = controller;
 
         if (path && suffix)
-                r = asprintf(fs, "%s/%s/%s", mp, path, suffix);
+                t = join("/sys/fs/cgroup/", p, "/", path, "/", suffix, NULL);
         else if (path)
-                r = asprintf(fs, "%s/%s", mp, path);
+                t = join("/sys/fs/cgroup/", p, "/", path, NULL);
         else if (suffix)
-                r = asprintf(fs, "%s/%s", mp, suffix);
-        else {
-                path_kill_slashes(mp);
-                *fs = mp;
-                return 0;
-        }
+                t = join("/sys/fs/cgroup/", p, "/", suffix, NULL);
+        else
+                t = join("/sys/fs/cgroup/", p, NULL);
+
+        if (!t)
+                return -ENOMEM;
+
+        path_kill_slashes(t);
 
-        free(mp);
-        path_kill_slashes(*fs);
-        return r < 0 ? -ENOMEM : 0;
+        *fs = t;
+        return 0;
 }
 
 int cg_trim(const char *controller, const char *path, bool delete_root) {
@@ -447,30 +546,23 @@ int cg_trim(const char *controller, const char *path, bool delete_root) {
         r = rm_rf(fs, true, delete_root);
         free(fs);
 
-        return r;
+        return r == -ENOENT ? 0 : r;
 }
 
 int cg_delete(const char *controller, const char *path) {
-        struct cgroup *cg;
+        char *parent;
         int r;
 
         assert(controller);
         assert(path);
 
-        if (!(cg = cg_new(controller, path)))
-                return -ENOMEM;
-
-        if ((r = cgroup_delete_cgroup_ext(cg, CGFLAG_DELETE_RECURSIVE|CGFLAG_DELETE_IGNORE_MIGRATION)) != 0) {
-                r = cg_translate_error(r, errno);
-                goto finish;
-        }
-
-        r = 0;
+        if ((r = parent_of_path(path, &parent)) < 0)
+                return r;
 
-finish:
-        cgroup_free(&cg);
+        r = cg_migrate_recursive(controller, path, parent, false, true);
+        free(parent);
 
-        return r;
+        return r == -ENOENT ? 0 : r;
 }
 
 int cg_create(const char *controller, const char *path) {
@@ -483,7 +575,17 @@ int cg_create(const char *controller, const char *path) {
         if ((r = cg_get_path(controller, path, NULL, &fs)) < 0)
                 return r;
 
-        r = mkdir_p(fs, 0755);
+        r = mkdir_parents(fs, 0755);
+
+        if (r >= 0) {
+                if (mkdir(fs, 0755) >= 0)
+                        r = 1;
+                else if (errno == EEXIST)
+                        r = 0;
+                else
+                        r = -errno;
+        }
+
         free(fs);
 
         return r;
@@ -514,7 +616,7 @@ int cg_attach(const char *controller, const char *path, pid_t pid) {
 }
 
 int cg_create_and_attach(const char *controller, const char *path, pid_t pid) {
-        int r;
+        int r, q;
 
         assert(controller);
         assert(path);
@@ -523,8 +625,8 @@ int cg_create_and_attach(const char *controller, const char *path, pid_t pid) {
         if ((r = cg_create(controller, path)) < 0)
                 return r;
 
-        if ((r = cg_attach(controller, path, pid)) < 0)
-                return r;
+        if ((q = cg_attach(controller, path, pid)) < 0)
+                return q;
 
         /* This does not remove the cgroup on failure */
 
@@ -583,6 +685,9 @@ int cg_get_by_pid(const char *controller, pid_t pid, char **path) {
         f = fopen(fs, "re");
         free(fs);
 
+        if (!f)
+                return errno == ENOENT ? -ESRCH : -errno;
+
         cs = strlen(controller);
 
         while (!feof(f)) {
@@ -659,10 +764,8 @@ int cg_install_release_agent(const char *controller, const char *agent) {
 
         free(fs);
         fs = NULL;
-        if ((r = cg_get_path(controller, NULL, "notify_on_release", &fs)) < 0) {
-                r = -ENOMEM;
+        if ((r = cg_get_path(controller, NULL, "notify_on_release", &fs)) < 0)
                 goto finish;
-        }
 
         free(contents);
         contents = NULL;
@@ -691,16 +794,16 @@ finish:
 }
 
 int cg_is_empty(const char *controller, const char *path, bool ignore_self) {
-        pid_t pid;
+        pid_t pid = 0;
         int r;
-        FILE *f;
+        FILE *f = NULL;
         bool found = false;
 
         assert(controller);
         assert(path);
 
         if ((r = cg_enumerate_tasks(controller, path, &f)) < 0)
-                return r;
+                return r == -ENOENT ? 1 : r;
 
         while ((r = cg_read_pid(f, &pid)) > 0) {
 
@@ -720,63 +823,182 @@ int cg_is_empty(const char *controller, const char *path, bool ignore_self) {
 }
 
 int cg_is_empty_recursive(const char *controller, const char *path, bool ignore_self) {
-        struct cgroup_file_info info;
-        int level = 0, r, ret = 0;
-        void *iterator = NULL;
-        bool empty = true;
+        int r;
+        DIR *d = NULL;
+        char *fn;
 
         assert(controller);
         assert(path);
 
-        zero(info);
+        if ((r = cg_is_empty(controller, path, ignore_self)) <= 0)
+                return r;
+
+        if ((r = cg_enumerate_subgroups(controller, path, &d)) < 0)
+                return r == -ENOENT ? 1 : r;
 
-        r = cgroup_walk_tree_begin(controller, path, 0, &iterator, &info, &level);
-        while (r == 0) {
-                int k;
-                char *p;
+        while ((r = cg_read_subgroup(d, &fn)) > 0) {
+                char *p = NULL;
 
-                if (info.type != CGROUP_FILE_TYPE_DIR)
-                        goto next;
+                r = asprintf(&p, "%s/%s", path, fn);
+                free(fn);
 
-                if (asprintf(&p, "%s/%s", path, info.path) < 0) {
-                        ret = -ENOMEM;
-                        break;
+                if (r < 0) {
+                        r = -ENOMEM;
+                        goto finish;
                 }
 
-                k = cg_is_empty(controller, p, ignore_self);
+                r = cg_is_empty_recursive(controller, p, ignore_self);
                 free(p);
 
-                if (k < 0) {
-                        ret = k;
-                        break;
-                } else if (k == 0) {
-                        empty = false;
-                        break;
+                if (r <= 0)
+                        goto finish;
+        }
+
+        if (r >= 0)
+                r = 1;
+
+finish:
+
+        if (d)
+                closedir(d);
+
+        return r;
+}
+
+int cg_split_spec(const char *spec, char **controller, char **path) {
+        const char *e;
+        char *t = NULL, *u = NULL;
+
+        assert(spec);
+        assert(controller || path);
+
+        if (*spec == '/') {
+
+                if (path) {
+                        if (!(t = strdup(spec)))
+                                return -ENOMEM;
+
+                        *path = t;
                 }
 
-        next:
-                r = cgroup_walk_tree_next(0, &iterator, &info, level);
+                if (controller)
+                        *controller = NULL;
+
+                return 0;
         }
 
-        if (ret == 0) {
-                if (r == 0 || r == ECGEOF)
-                        ret = !!empty;
-                else if (r == ECGOTHER && errno == ENOENT)
-                        ret = -ESRCH;
-                else
-                        ret = cg_translate_error(r, errno);
+        if (!(e = strchr(spec, ':'))) {
+
+                if (strchr(spec, '/') || spec[0] == 0)
+                        return -EINVAL;
+
+                if (controller) {
+                        if (!(t = strdup(spec)))
+                                return -ENOMEM;
+
+                        *controller = t;
+                }
+
+                if (path)
+                        *path = NULL;
+
+                return 0;
         }
 
-        assert_se(cgroup_walk_tree_end(&iterator) == 0);
+        if (e[1] != '/' ||
+            e == spec ||
+            memchr(spec, '/', e-spec))
+                return -EINVAL;
 
-        return ret;
+        if (controller)
+                if (!(t = strndup(spec, e-spec)))
+                        return -ENOMEM;
+
+        if (path)
+                if (!(u = strdup(e+1))) {
+                        free(t);
+                        return -ENOMEM;
+                }
+
+        if (controller)
+                *controller = t;
+
+        if (path)
+                *path = u;
+
+        return 0;
 }
 
-int cg_init(void) {
+int cg_join_spec(const char *controller, const char *path, char **spec) {
+        assert(controller);
+        assert(path);
+
+        if (!path_is_absolute(path) ||
+            controller[0] == 0 ||
+            strchr(controller, ':') ||
+            strchr(controller, '/'))
+                return -EINVAL;
+
+        if (asprintf(spec, "%s:%s", controller, path) < 0)
+                return -ENOMEM;
+
+        return 0;
+}
+
+int cg_fix_path(const char *path, char **result) {
+        char *t, *c, *p;
         int r;
 
-        if ((r = cgroup_init()) != 0)
-                return cg_translate_error(r, errno);
+        assert(path);
+        assert(result);
+
+        /* First check if it already is a filesystem path */
+        if (path_is_absolute(path) &&
+            path_startswith(path, "/sys/fs/cgroup") &&
+            access(path, F_OK) >= 0) {
+
+                if (!(t = strdup(path)))
+                        return -ENOMEM;
+
+                *result = t;
+                return 0;
+        }
+
+        /* Otherwise treat it as cg spec */
+        if ((r = cg_split_spec(path, &c, &p)) < 0)
+                return r;
+
+        r = cg_get_path(c ? c : SYSTEMD_CGROUP_CONTROLLER, p ? p : "/", NULL, result);
+        free(c);
+        free(p);
+
+        return r;
+}
+
+int cg_get_user_path(char **path) {
+        char *root, *p;
+
+        assert(path);
+
+        /* Figure out the place to put user cgroups below. We use the
+         * same as PID 1 has but with the "/system" suffix replaced by
+         * "/user" */
+
+        if (cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 1, &root) < 0)
+                p = strdup("/user");
+        else {
+                if (endswith(root, "/system"))
+                        root[strlen(root) - 7] = 0;
+                else if (streq(root, "/"))
+                        root[0] = 0;
+
+                p = strappend(root, "/user");
+                free(root);
+        }
+
+        if (!p)
+                return -ENOMEM;
 
+        *path = p;
         return 0;
 }