pid1: add ./configure switch to select default cgroup hierarchy

The default default is set to "legacy", with "hybrid" and "unified"
being the other two alternatives.

There invert the behaviour for elogind.legacy_elogind_cgroup_controller:
if it is not specified on the kernel command line, "hybrid" is used if
selected as the default. If this option is specified, "hybrid" is used if false,
and full "legacy" if true.

Also make all fields in the configure summary lowercase (unless they are
capitalized names) for consistency.

v2:
- update for the fixed interpreation of elogind.legacy_elogind_cgroup_controller

diff --git a/src/basic/cgroup-util.c b/src/basic/cgroup-util.c
index 32cf4298f2628438fc6f843d2300e98fbc3b0c95..057d8478d8ddbb393fb45c45302df98afebf0913 100644 (file)
--- a/src/basic/cgroup-util.c
+++ b/src/basic/cgroup-util.c
@@ -210,6 +210,12 @@ int cg_rmdir(const char *controller, const char *path) {
         if (r < 0 && errno != ENOENT)
                 return -errno;
 
         if (r < 0 && errno != ENOENT)
                 return -errno;
 

+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER) && cg_hybrid_unified()) {
+                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;
 }
 
         return 0;
 }
 


@@ -548,6 +554,13 @@ static const char *controller_to_dirname(const char *controller) {
          * just cuts off the name= prefixed used for named
          * hierarchies, if it is specified. */
 
          * just cuts off the name= prefixed used for named
          * hierarchies, if it is specified. */
 

+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
+                if (cg_hybrid_unified())
+                        controller = SYSTEMD_CGROUP_CONTROLLER_HYBRID;
+                else
+                        controller = SYSTEMD_CGROUP_CONTROLLER_LEGACY;
+        }
+

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


@@ -600,7 +613,7 @@ static int join_path_unified(const char *path, const char *suffix, char **fs) {
 }
 
 int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {
 }
 
 int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {

-        int unified, r;
+        int r;

 
         assert(fs);
 
 
         assert(fs);
 


@@ -629,11 +642,7 @@ int cg_get_path(const char *controller, const char *path, const char *suffix, ch
         if (!cg_controller_is_valid(controller))
                 return -EINVAL;
 
         if (!cg_controller_is_valid(controller))
                 return -EINVAL;
 

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-
-        if (unified > 0)
+        if (cg_all_unified())

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


@@ -645,7 +654,6 @@ int cg_get_path(const char *controller, const char *path, const char *suffix, ch
 }
 
 static int controller_is_accessible(const char *controller) {
 }
 
 static int controller_is_accessible(const char *controller) {

-        int unified;

 
         assert(controller);
 
 
         assert(controller);
 


@@ -657,10 +665,7 @@ static int controller_is_accessible(const char *controller) {
         if (!cg_controller_is_valid(controller))
                 return -EINVAL;
 
         if (!cg_controller_is_valid(controller))
                 return -EINVAL;
 

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-        if (unified > 0) {
+        if (cg_all_unified()) {

                 /* We don't support named hierarchies if we are using
                  * the unified hierarchy. */
 
                 /* We don't support named hierarchies if we are using
                  * the unified hierarchy. */
 


@@ -714,7 +719,7 @@ static int trim_cb(const char *path, const struct stat *sb, int typeflag, struct
 
 int cg_trim(const char *controller, const char *path, bool delete_root) {
         _cleanup_free_ char *fs = NULL;
 
 int cg_trim(const char *controller, const char *path, bool delete_root) {
         _cleanup_free_ char *fs = NULL;

-        int r = 0;
+        int r = 0, q;

 
         assert(path);
 
 
         assert(path);
 


@@ -737,6 +742,12 @@ int cg_trim(const char *controller, const char *path, bool delete_root) {
                         return -errno;
         }
 
                         return -errno;
         }
 

+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER) && cg_hybrid_unified()) {
+                q = cg_trim(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path, delete_root);
+                if (q < 0)
+                        log_warning_errno(q, "Failed to trim compat systemd cgroup %s: %m", path);
+        }
+

         return r;
 }
 
         return r;
 }
 


@@ -760,6 +771,12 @@ int cg_create(const char *controller, const char *path) {
                 return -errno;
         }
 
                 return -errno;
         }
 

+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER) && cg_hybrid_unified()) {
+                r = cg_create(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path);
+                if (r < 0)
+                        log_warning_errno(r, "Failed to create compat systemd cgroup %s: %m", path);
+        }
+

         return 1;
 }
 
         return 1;
 }
 


@@ -797,7 +814,17 @@ int cg_attach(const char *controller, const char *path, pid_t pid) {
 
         xsprintf(c, PID_FMT "\n", pid);
 
 
         xsprintf(c, PID_FMT "\n", pid);
 

-        return write_string_file(fs, c, 0);
+        r = write_string_file(fs, c, 0);
+        if (r < 0)
+                return r;
+
+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER) && cg_hybrid_unified()) {
+                r = cg_attach(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path, pid);
+                if (r < 0)
+                        log_warning_errno(r, "Failed to attach %d to compat systemd cgroup %s: %m", pid, path);
+        }
+
+        return 0;

 }
 
 int cg_attach_fallback(const char *controller, const char *path, pid_t pid) {
 }
 
 int cg_attach_fallback(const char *controller, const char *path, pid_t pid) {


@@ -847,7 +874,17 @@ int cg_set_group_access(
         if (r < 0)
                 return r;
 
         if (r < 0)
                 return r;
 

-        return chmod_and_chown(fs, mode, uid, gid);
+        r = chmod_and_chown(fs, mode, uid, gid);
+        if (r < 0)
+                return r;
+
+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER) && cg_hybrid_unified()) {
+                r = cg_set_group_access(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path, mode, uid, gid);
+                if (r < 0)
+                        log_warning_errno(r, "Failed to set group access on compat systemd cgroup %s: %m", path);
+        }
+
+        return 0;

 }
 
 int cg_set_task_access(
 }
 
 int cg_set_task_access(


@@ -858,7 +895,7 @@ int cg_set_task_access(
                 gid_t gid) {
 
         _cleanup_free_ char *fs = NULL, *procs = NULL;
                 gid_t gid) {
 
         _cleanup_free_ char *fs = NULL, *procs = NULL;

-        int r, unified;
+        int r;

 
         assert(path);
 
 
         assert(path);
 


@@ -876,16 +913,18 @@ int cg_set_task_access(
         if (r < 0)
                 return r;
 
         if (r < 0)
                 return r;
 

-        unified = cg_unified(controller);
-        if (unified < 0)
-                return unified;
-        if (unified)
-                return 0;
+        if (!cg_unified(controller)) {
+                /* Compatibility, Always keep values for "tasks" in sync with
+                 * "cgroup.procs" */
+                if (cg_get_path(controller, path, "tasks", &procs) >= 0)
+                        (void) chmod_and_chown(procs, mode, uid, gid);
+        }

 
 

-        /* Compatibility, Always keep values for "tasks" in sync with
-         * "cgroup.procs" */
-        if (cg_get_path(controller, path, "tasks", &procs) >= 0)
-                (void) chmod_and_chown(procs, mode, uid, gid);
+        if (streq(controller, SYSTEMD_CGROUP_CONTROLLER) && cg_hybrid_unified()) {
+                r = cg_set_task_access(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path, mode, uid, gid);
+                if (r < 0)
+                        log_warning_errno(r, "Failed to set task access on compat systemd cgroup %s: %m", path);
+        }

 
         return 0;
 }
 
         return 0;
 }


@@ -931,9 +970,9 @@ int cg_get_xattr(const char *controller, const char *path, const char *name, voi
 int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
         _cleanup_fclose_ FILE *f = NULL;
         char line[LINE_MAX];
 int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
         _cleanup_fclose_ FILE *f = NULL;
         char line[LINE_MAX];

-        const char *fs;
+        const char *fs, *controller_str;

         size_t cs = 0;
         size_t cs = 0;

-        int unified;
+        bool unified;

 
         assert(path);
         assert(pid >= 0);
 
         assert(path);
         assert(pid >= 0);


@@ -945,10 +984,14 @@ int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
                 controller = SYSTEMD_CGROUP_CONTROLLER;
 
         unified = cg_unified(controller);
                 controller = SYSTEMD_CGROUP_CONTROLLER;
 
         unified = cg_unified(controller);

-        if (unified < 0)
-                return unified;
-        if (unified == 0)
-                cs = strlen(controller);
+        if (!unified) {
+                if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
+                        controller_str = SYSTEMD_CGROUP_CONTROLLER_LEGACY;
+                else
+                        controller_str = controller;
+
+                cs = strlen(controller_str);
+        }

 
         fs = procfs_file_alloca(pid, "cgroup");
         log_debug_elogind("Searching for PID %u in \"%s\" (controller \"%s\")",
 
         fs = procfs_file_alloca(pid, "cgroup");
         log_debug_elogind("Searching for PID %u in \"%s\" (controller \"%s\")",


@@ -987,7 +1030,7 @@ int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
 
                         *e = 0;
                         FOREACH_WORD_SEPARATOR(word, k, l, ",", state) {
 
                         *e = 0;
                         FOREACH_WORD_SEPARATOR(word, k, l, ",", state) {

-                                if (k == cs && memcmp(word, controller, cs) == 0) {
+                                if (k == cs && memcmp(word, controller_str, cs) == 0) {

                                         found = true;
                                         break;
                                 }
                                         found = true;
                                         break;
                                 }


@@ -1012,14 +1055,11 @@ int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
 int cg_install_release_agent(const char *controller, const char *agent) {
         _cleanup_free_ char *fs = NULL, *contents = NULL;
         const char *sc;
 int cg_install_release_agent(const char *controller, const char *agent) {
         _cleanup_free_ char *fs = NULL, *contents = NULL;
         const char *sc;

-        int r, unified;
+        int r;

 
         assert(agent);
 
 
         assert(agent);
 

-        unified = cg_unified(controller);
-        if (unified < 0)
-                return unified;
-        if (unified) /* doesn't apply to unified hierarchy */
+        if (cg_unified(controller)) /* doesn't apply to unified hierarchy */

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


@@ -1065,12 +1105,9 @@ int cg_install_release_agent(const char *controller, const char *agent) {
 
 int cg_uninstall_release_agent(const char *controller) {
         _cleanup_free_ char *fs = NULL;
 
 int cg_uninstall_release_agent(const char *controller) {
         _cleanup_free_ char *fs = NULL;

-        int r, unified;
+        int r;

 
 

-        unified = cg_unified(controller);
-        if (unified < 0)
-                return unified;
-        if (unified) /* Doesn't apply to unified hierarchy */
+        if (cg_unified(controller)) /* Doesn't apply to unified hierarchy */

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


@@ -1115,7 +1152,7 @@ int cg_is_empty(const char *controller, const char *path) {
 }
 
 int cg_is_empty_recursive(const char *controller, const char *path) {
 }
 
 int cg_is_empty_recursive(const char *controller, const char *path) {

-        int unified, r;
+        int r;

 
         assert(path);
 
 
         assert(path);
 


@@ -1123,11 +1160,7 @@ int cg_is_empty_recursive(const char *controller, const char *path) {
         if (controller && (isempty(path) || path_equal(path, "/")))
                 return false;
 
         if (controller && (isempty(path) || path_equal(path, "/")))
                 return false;
 

-        unified = cg_unified(controller);
-        if (unified < 0)
-                return unified;
-
-        if (unified > 0) {
+        if (cg_unified(controller)) {

                 _cleanup_free_ char *t = NULL;
 
                 /* On the unified hierarchy we can check empty state
                 _cleanup_free_ char *t = NULL;
 
                 /* On the unified hierarchy we can check empty state


@@ -1883,6 +1916,9 @@ bool cg_controller_is_valid(const char *p) {
         if (!p)
                 return false;
 
         if (!p)
                 return false;
 

+        if (streq(p, SYSTEMD_CGROUP_CONTROLLER))
+                return true;
+

         s = startswith(p, "name=");
         if (s)
                 p = s;
         s = startswith(p, "name=");
         if (s)
                 p = s;


@@ -2039,7 +2075,7 @@ int cg_get_keyed_attribute(const char *controller, const char *path, const char
 
 int cg_create_everywhere(CGroupMask supported, CGroupMask mask, const char *path) {
         CGroupController c;
 
 int cg_create_everywhere(CGroupMask supported, CGroupMask mask, const char *path) {
         CGroupController c;

-        int r, unified;
+        int r;

 
         /* This one will create a cgroup in our private tree, but also
          * duplicate it in the trees specified in mask, and remove it
 
         /* This one will create a cgroup in our private tree, but also
          * duplicate it in the trees specified in mask, and remove it


@@ -2051,10 +2087,7 @@ int cg_create_everywhere(CGroupMask supported, CGroupMask mask, const char *path
                 return r;
 
         /* If we are in the unified hierarchy, we are done now */
                 return r;
 
         /* If we are in the unified hierarchy, we are done now */

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-        if (unified > 0)
+        if (cg_all_unified())

                 return 0;
 
         /* Otherwise, do the same in the other hierarchies */
                 return 0;
 
         /* Otherwise, do the same in the other hierarchies */


@@ -2075,16 +2108,13 @@ int cg_create_everywhere(CGroupMask supported, CGroupMask mask, const char *path
 
 int cg_attach_everywhere(CGroupMask supported, const char *path, pid_t pid, cg_migrate_callback_t path_callback, void *userdata) {
         CGroupController c;
 
 int cg_attach_everywhere(CGroupMask supported, const char *path, pid_t pid, cg_migrate_callback_t path_callback, void *userdata) {
         CGroupController c;

-        int r, unified;
+        int r;

 
         r = cg_attach(SYSTEMD_CGROUP_CONTROLLER, path, pid);
         if (r < 0)
                 return r;
 
 
         r = cg_attach(SYSTEMD_CGROUP_CONTROLLER, path, pid);
         if (r < 0)
                 return r;
 

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-        if (unified > 0)
+        if (cg_all_unified())

                 return 0;
 
         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
                 return 0;
 
         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {


@@ -2125,7 +2155,7 @@ int cg_attach_many_everywhere(CGroupMask supported, const char *path, Set* pids,
 
 int cg_migrate_everywhere(CGroupMask supported, const char *from, const char *to, cg_migrate_callback_t to_callback, void *userdata) {
         CGroupController c;
 
 int cg_migrate_everywhere(CGroupMask supported, const char *from, const char *to, cg_migrate_callback_t to_callback, void *userdata) {
         CGroupController c;

-        int r = 0, unified;
+        int r = 0;

 
         if (!path_equal(from, to))  {
                 r = cg_migrate_recursive(SYSTEMD_CGROUP_CONTROLLER, from, SYSTEMD_CGROUP_CONTROLLER, to, CGROUP_REMOVE);
 
         if (!path_equal(from, to))  {
                 r = cg_migrate_recursive(SYSTEMD_CGROUP_CONTROLLER, from, SYSTEMD_CGROUP_CONTROLLER, to, CGROUP_REMOVE);


@@ -2133,10 +2163,7 @@ int cg_migrate_everywhere(CGroupMask supported, const char *from, const char *to
                         return r;
         }
 
                         return r;
         }
 

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-        if (unified > 0)
+        if (cg_all_unified())

                 return r;
 
         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
                 return r;
 
         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {


@@ -2160,16 +2187,13 @@ int cg_migrate_everywhere(CGroupMask supported, const char *from, const char *to
 
 int cg_trim_everywhere(CGroupMask supported, const char *path, bool delete_root) {
         CGroupController c;
 
 int cg_trim_everywhere(CGroupMask supported, const char *path, bool delete_root) {
         CGroupController c;

-        int r, unified;
+        int r;

 
         r = cg_trim(SYSTEMD_CGROUP_CONTROLLER, path, delete_root);
         if (r < 0)
                 return r;
 
 
         r = cg_trim(SYSTEMD_CGROUP_CONTROLLER, path, delete_root);
         if (r < 0)
                 return r;
 

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-        if (unified > 0)
+        if (cg_all_unified())

                 return r;
 
         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
                 return r;
 
         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {


@@ -2187,16 +2211,13 @@ int cg_trim_everywhere(CGroupMask supported, const char *path, bool delete_root)
 
 int cg_mask_supported(CGroupMask *ret) {
         CGroupMask mask = 0;
 
 int cg_mask_supported(CGroupMask *ret) {
         CGroupMask mask = 0;

-        int r, unified;
+        int r;

 
         /* Determines the mask of supported cgroup controllers. Only
          * includes controllers we can make sense of and that are
          * actually accessible. */
 
 
         /* Determines the mask of supported cgroup controllers. Only
          * includes controllers we can make sense of and that are
          * actually accessible. */
 

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-        if (unified > 0) {
+        if (cg_all_unified()) {

                 _cleanup_free_ char *root = NULL, *controllers = NULL, *path = NULL;
                 const char *c;
 
                 _cleanup_free_ char *root = NULL, *controllers = NULL, *path = NULL;
                 const char *c;
 


@@ -2318,6 +2339,20 @@ int cg_kernel_controllers(Set *controllers) {
 
 static thread_local CGroupUnified unified_cache = CGROUP_UNIFIED_UNKNOWN;
 
 
 static thread_local CGroupUnified unified_cache = CGROUP_UNIFIED_UNKNOWN;
 

+/* The hybrid mode was initially implemented in v232 and simply mounted
+ * cgroup v2 on /sys/fs/cgroup/systemd.  This unfortunately broke other
+ * tools (such as docker) which expected the v1 "name=systemd" hierarchy
+ * on /sys/fs/cgroup/systemd.  From v233 and on, the hybrid mode mountnbs
+ * v2 on /sys/fs/cgroup/unified and maintains "name=systemd" hierarchy
+ * on /sys/fs/cgroup/systemd for compatibility with other tools.
+ *
+ * To keep live upgrade working, we detect and support v232 layout.  When
+ * v232 layout is detected, to keep cgroup v2 process management but
+ * disable the compat dual layout, we return %true on
+ * cg_unified(SYSTEMD_CGROUP_CONTROLLER) and %false on cg_hybrid_unified().
+ */
+static thread_local bool unified_systemd_v232;
+

 static int cg_update_unified(void) {
 
         struct statfs fs;
 static int cg_update_unified(void) {
 
         struct statfs fs;


@@ -2337,11 +2372,21 @@ static int cg_update_unified(void) {
         if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC))
                 unified_cache = CGROUP_UNIFIED_ALL;
         else if (F_TYPE_EQUAL(fs.f_type, TMPFS_MAGIC)) {
         if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC))
                 unified_cache = CGROUP_UNIFIED_ALL;
         else if (F_TYPE_EQUAL(fs.f_type, TMPFS_MAGIC)) {

-                if (statfs("/sys/fs/cgroup/systemd/", &fs) < 0)
-                        return -errno;
-
-                unified_cache = F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC) ?
-                        CGROUP_UNIFIED_SYSTEMD : CGROUP_UNIFIED_NONE;
+                if (statfs("/sys/fs/cgroup/unified/", &fs) == 0 &&
+                    F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
+                        unified_cache = CGROUP_UNIFIED_SYSTEMD;
+                        unified_systemd_v232 = false;
+                } else if (statfs("/sys/fs/cgroup/systemd/", &fs) == 0 &&
+                           F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
+                        unified_cache = CGROUP_UNIFIED_SYSTEMD;
+                        unified_systemd_v232 = true;
+                } else {
+                        if (statfs("/sys/fs/cgroup/systemd/", &fs) < 0)
+                                return -errno;
+                        if (!F_TYPE_EQUAL(fs.f_type, CGROUP_SUPER_MAGIC))
+                                return -ENOMEDIUM;
+                        unified_cache = CGROUP_UNIFIED_NONE;
+                }

         } else
                 return -ENOMEDIUM;
 #else
         } else
                 return -ENOMEDIUM;
 #else


@@ -2356,13 +2401,9 @@ static int cg_update_unified(void) {
         return 0;
 }
 
         return 0;
 }
 

-int cg_unified(const char *controller) {
+bool cg_unified(const char *controller) {

 
 

-        int r;
-
-        r = cg_update_unified();
-        if (r < 0)
-                return r;
+        assert(cg_update_unified() >= 0);

 
         if (streq_ptr(controller, SYSTEMD_CGROUP_CONTROLLER))
                 return unified_cache >= CGROUP_UNIFIED_SYSTEMD;
 
         if (streq_ptr(controller, SYSTEMD_CGROUP_CONTROLLER))
                 return unified_cache >= CGROUP_UNIFIED_SYSTEMD;


@@ -2370,30 +2411,36 @@ int cg_unified(const char *controller) {
                 return unified_cache >= CGROUP_UNIFIED_ALL;
 }
 
                 return unified_cache >= CGROUP_UNIFIED_ALL;
 }
 

-int cg_all_unified(void) {
+bool cg_all_unified(void) {

 
         return cg_unified(NULL);
 }
 
 #if 0 /// UNNEEDED by elogind
 
         return cg_unified(NULL);
 }
 
 #if 0 /// UNNEEDED by elogind

-void cg_unified_flush(void) {
+bool cg_hybrid_unified(void) {
+
+        assert(cg_update_unified() >= 0);
+
+        return unified_cache == CGROUP_UNIFIED_SYSTEMD && !unified_systemd_v232;
+}
+
+int cg_unified_flush(void) {

         unified_cache = CGROUP_UNIFIED_UNKNOWN;
         unified_cache = CGROUP_UNIFIED_UNKNOWN;

+
+        return cg_update_unified();

 }
 
 int cg_enable_everywhere(CGroupMask supported, CGroupMask mask, const char *p) {
         _cleanup_free_ char *fs = NULL;
         CGroupController c;
 }
 
 int cg_enable_everywhere(CGroupMask supported, CGroupMask mask, const char *p) {
         _cleanup_free_ char *fs = NULL;
         CGroupController c;

-        int r, unified;
+        int r;

 
         assert(p);
 
         if (supported == 0)
                 return 0;
 
 
         assert(p);
 
         if (supported == 0)
                 return 0;
 

-        unified = cg_all_unified();
-        if (unified < 0)
-                return unified;
-        if (!unified) /* on the legacy hiearchy there's no joining of controllers defined */
+        if (!cg_all_unified()) /* on the legacy hiearchy there's no joining of controllers defined */

                 return 0;
 
         r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, p, "cgroup.subtree_control", &fs);
                 return 0;
 
         r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, p, "cgroup.subtree_control", &fs);


@@ -2425,26 +2472,26 @@ int cg_enable_everywhere(CGroupMask supported, CGroupMask mask, const char *p) {
 
 bool cg_is_unified_wanted(void) {
         static thread_local int wanted = -1;
 
 bool cg_is_unified_wanted(void) {
         static thread_local int wanted = -1;

-        int r, unified;
+        int r;

         bool b;
         bool b;

+        const bool is_default = DEFAULT_HIERARCHY == CGROUP_UNIFIED_ALL;

 
         /* If the hierarchy is already mounted, then follow whatever
          * was chosen for it. */
 
         /* If the hierarchy is already mounted, then follow whatever
          * was chosen for it. */

-        unified = cg_all_unified();
-        if (unified >= 0)
-                return unified;
+        if (cg_unified_flush() >= 0)
+                return cg_all_unified();

 
 

-        /* Otherwise, let's see what the kernel command line has to
-         * say. Since checking that is expensive, let's cache the
-         * result. */
+        /* If we have a cached value, return that. */

         if (wanted >= 0)
                 return wanted;
 
         if (wanted >= 0)
                 return wanted;
 

+        /* Otherwise, let's see what the kernel command line has to say.
+         * Since checking is expensive, cache a non-error result. */

         r = proc_cmdline_get_bool("systemd.unified_cgroup_hierarchy", &b);
         if (r < 0)
         r = proc_cmdline_get_bool("systemd.unified_cgroup_hierarchy", &b);
         if (r < 0)

-                return false;
+                return is_default;

 
 

-        return (wanted = r > 0 ? b : false);
+        return (wanted = r > 0 ? b : is_default);

 }
 
 bool cg_is_legacy_wanted(void) {
 }
 
 bool cg_is_legacy_wanted(void) {


@@ -2453,8 +2500,9 @@ bool cg_is_legacy_wanted(void) {
 
 bool cg_is_unified_systemd_controller_wanted(void) {
         static thread_local int wanted = -1;
 
 bool cg_is_unified_systemd_controller_wanted(void) {
         static thread_local int wanted = -1;

-        int r, unified;
+        int r;

         bool b;
         bool b;

+        const bool is_default = DEFAULT_HIERARCHY == CGROUP_UNIFIED_SYSTEMD;

 
         /* If the unified hierarchy is requested in full, no need to
          * bother with this. */
 
         /* If the unified hierarchy is requested in full, no need to
          * bother with this. */


@@ -2463,19 +2511,18 @@ bool cg_is_unified_systemd_controller_wanted(void) {
 
         /* If the hierarchy is already mounted, then follow whatever
          * was chosen for it. */
 
         /* If the hierarchy is already mounted, then follow whatever
          * was chosen for it. */

-        unified = cg_unified(SYSTEMD_CGROUP_CONTROLLER);
-        if (unified >= 0)
-                return unified;
+        if (cg_unified_flush() >= 0)
+                return cg_unified(SYSTEMD_CGROUP_CONTROLLER);

 
 

-        /* Otherwise, let's see what the kernel command line has to
-         * say. Since checking that is expensive, let's cache the
-         * result. */
+        /* If we have a cached value, return that. */

         if (wanted >= 0)
                 return wanted;
 
         if (wanted >= 0)
                 return wanted;
 

+        /* Otherwise, let's see what the kernel command line has to say.
+         * Since checking is expensive, cache a non-error result. */

         r = proc_cmdline_get_bool("systemd.legacy_systemd_cgroup_controller", &b);
         if (r < 0)
         r = proc_cmdline_get_bool("systemd.legacy_systemd_cgroup_controller", &b);
         if (r < 0)

-                return false;
+                return is_default;

 
 #else
 bool cg_is_legacy_wanted(void) {
 
 #else
 bool cg_is_legacy_wanted(void) {


@@ -2488,6 +2535,7 @@ bool cg_is_legacy_wanted(void) {
 
 bool cg_is_legacy_systemd_controller_wanted(void) {
         return cg_is_legacy_wanted() && !cg_is_unified_systemd_controller_wanted();
 
 bool cg_is_legacy_systemd_controller_wanted(void) {
         return cg_is_legacy_wanted() && !cg_is_unified_systemd_controller_wanted();

+        return (wanted = r > 0 ? !b : is_default);

 }
 #endif // 0
 
 }
 #endif // 0