../src/basic/cgroup-util.c

Bug Summary

File:	build-scan/../src/basic/cgroup-util.c
Warning:	line 1658, column 9 Potential leak of memory pointed to by 'cgroup'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name cgroup-util.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fdenormal-fp-math=preserve-sign,preserve-sign -ffp-contract=fast -fno-rounding-math -ffast-math -ffinite-math-only -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/12.0.0 -include config.h -I src/basic/libbasic.a.p -I src/basic -I ../src/basic -I src/shared -I ../src/shared -I src/systemd -I ../src/systemd -I src/journal -I ../src/journal -I src/journal-remote -I ../src/journal-remote -I src/nspawn -I ../src/nspawn -I src/resolve -I ../src/resolve -I src/timesync -I ../src/timesync -I ../src/time-wait-sync -I src/login -I ../src/login -I src/udev -I ../src/udev -I src/libudev -I ../src/libudev -I src/core -I ../src/core -I ../src/libsystemd/sd-bus -I ../src/libsystemd/sd-device -I ../src/libsystemd/sd-hwdb -I ../src/libsystemd/sd-id128 -I ../src/libsystemd/sd-netlink -I ../src/libsystemd/sd-network -I src/libsystemd-network -I ../src/libsystemd-network -I . -I .. -I /usr/include/blkid -I /usr/include/libmount -D _FILE_OFFSET_BITS=64 -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wwrite-strings -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unused-result -Wno-format-signedness -Wno-error=nonnull -std=gnu99 -fconst-strings -fdebug-compilation-dir /home/mrc0mmand/repos/@redhat-plumbers/systemd-rhel8/build-scan -ferror-limit 19 -fvisibility default -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-07-16-221226-1465241-1 -x c ../src/basic/cgroup-util.c
1/* SPDX-License-Identifier: LGPL-2.1+ */

3#include <dirent.h>
4#include <errno(*__errno_location ()).h>
5#include <ftw.h>
6#include <limits.h>
7#include <signal.h>
8#include <stddef.h>
9#include <stdio_ext.h>
10#include <stdlib.h>
11#include <string.h>
12#include <sys/stat.h>
13#include <sys/statfs.h>
14#include <sys/types.h>
15#include <sys/xattr.h>
16#include <unistd.h>

18#include "alloc-util.h"
19#include "cgroup-util.h"
20#include "def.h"
21#include "dirent-util.h"
22#include "extract-word.h"
23#include "fd-util.h"
24#include "fileio.h"
25#include "format-util.h"
26#include "fs-util.h"
27#include "log.h"
28#include "login-util.h"
29#include "macro.h"
30#include "missing.h"
31#include "mkdir.h"
32#include "parse-util.h"
33#include "path-util.h"
34#include "proc-cmdline.h"
35#include "process-util.h"
36#include "set.h"
37#include "special.h"
38#include "stat-util.h"
39#include "stdio-util.h"
40#include "string-table.h"
41#include "string-util.h"
42#include "strv.h"
43#include "unit-name.h"
44#include "user-util.h"

46int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      FILE *f;
      int r;

      assert(_f)do { if ((__builtin_expect(!!(!(_f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_f"), "../src/basic/cgroup-util.c", 51,
 __PRETTY_FUNCTION__); } while (0);

      r = cg_get_path(controller, path, "cgroup.procs", &fs);
      if (r < 0)
              return r;

      f = fopen(fs, "re");
      if (!f)
              return -errno(*__errno_location ());

      *_f = f;
      return 0;
63}

65int cg_read_pid(FILE *f, pid_t *_pid) {
      unsigned long ul;

      /* Note that the cgroup.procs might contain duplicates! See
       * cgroups.txt for details. */

      assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/basic/cgroup-util.c", 71, __PRETTY_FUNCTION__
); } while (0);
      assert(_pid)do { if ((__builtin_expect(!!(!(_pid)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_pid"), "../src/basic/cgroup-util.c", 72
, __PRETTY_FUNCTION__); } while (0);

      errno(*__errno_location ()) = 0;
      if (fscanf(f, "%lu", &ul) != 1) {

              if (feof(f))
                      return 0;

              return errno(*__errno_location ()) > 0 ? -errno(*__errno_location ()) : -EIO5;
      }

      if (ul <= 0)
              return -EIO5;

      *_pid = (pid_t) ul;
      return 1;
88}

90int cg_read_event(
              const char *controller,
              const char *path,
              const char *event,
              char **val) {

      _cleanup_free___attribute__((cleanup(freep))) char *events = NULL((void*)0), *content = NULL((void*)0);
      char *p, *line;
      int r;

      r = cg_get_path(controller, path, "cgroup.events", &events);
      if (r < 0)
              return r;

      r = read_full_file(events, &content, NULL((void*)0));
      if (r < 0)
              return r;

      p = content;
      while ((line = strsep(&p, "\n"))) {
              char *key;

              key = strsep(&line, " ");
              if (!key || !line)
                      return -EINVAL22;

              if (strcmp(key, event))
                      continue;

              *val = strdup(line);
              return 0;
      }

      return -ENOENT2;
124}

126bool_Bool cg_ns_supported(void) {
      static thread_local__thread int enabled = -1;

      if (enabled >= 0)
              return enabled;

      if (access("/proc/self/ns/cgroup", F_OK0) == 0)
              enabled = 1;
      else
              enabled = 0;

      return enabled;
138}

140bool_Bool cg_freezer_supported(void) {
      static thread_local__thread int supported = -1;

      if (supported >= 0)
              return supported;

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

      return supported;
149}

151int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      int r;
      DIR *d;

      assert(_d)do { if ((__builtin_expect(!!(!(_d)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_d"), "../src/basic/cgroup-util.c", 156
, __PRETTY_FUNCTION__); } while (0);

      /* This is not recursive! */

      r = cg_get_path(controller, path, NULL((void*)0), &fs);
      if (r < 0)
              return r;

      d = opendir(fs);
      if (!d)
              return -errno(*__errno_location ());

      *_d = d;
      return 0;
170}

172int cg_read_subgroup(DIR *d, char **fn) {
      struct dirent *de;

      assert(d)do { if ((__builtin_expect(!!(!(d)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("d"), "../src/basic/cgroup-util.c", 175,
 __PRETTY_FUNCTION__); } while (0);
      assert(fn)do { if ((__builtin_expect(!!(!(fn)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fn"), "../src/basic/cgroup-util.c", 176
, __PRETTY_FUNCTION__); } while (0);

      FOREACH_DIRENT_ALL(de, d, return -errno)for ((*__errno_location ()) = 0, de = readdir(d);; (*__errno_location
 ()) = 0, de = readdir(d)) if (!de) { if ((*__errno_location (
)) > 0) { return -(*__errno_location ()); } break; } else {
              char *b;

              if (de->d_type != DT_DIRDT_DIR)
                      continue;

              if (dot_or_dot_dot(de->d_name))
                      continue;

              b = strdup(de->d_name);
              if (!b)
                      return -ENOMEM12;

              *fn = b;
              return 1;
      }

      return 0;
196}

198int cg_rmdir(const char *controller, const char *path) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      int r;

      r = cg_get_path(controller, path, NULL((void*)0), &p);
      if (r < 0)
              return r;

      r = rmdir(p);
      if (r < 0 && errno(*__errno_location ()) != ENOENT2)
              return -errno(*__errno_location ());

      r = cg_hybrid_unified();
      if (r < 0)
              return r;
      if (r == 0)
              return 0;

      if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0)) {
              r = cg_rmdir(SYSTEMD_CGROUP_CONTROLLER_LEGACY"name=systemd", path);
              if (r < 0)
                      log_warning_errno(r, "Failed to remove compat systemd cgroup %s: %m", path)({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 219, __func__, "Failed to remove compat systemd cgroup %s: %m"
, path) : -abs(_e); });
      }

      return 0;
223}

225int cg_kill(
              const char *controller,
              const char *path,
              int sig,
              CGroupFlags flags,
              Set *s,
              cg_kill_log_func_t log_kill,
              void *userdata) {

      _cleanup_set_free___attribute__((cleanup(set_freep))) Set *allocated_set = NULL((void*)0);
      bool_Bool done = false0;
      int r, ret = 0;
      pid_t my_pid;

      assert(sig >= 0)do { if ((__builtin_expect(!!(!(sig >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sig >= 0"), "../src/basic/cgroup-util.c"
, 239, __PRETTY_FUNCTION__); } while (0);

       /* Don't send SIGCONT twice. Also, SIGKILL always works even when process is suspended, hence don't send
        * SIGCONT on SIGKILL. */
      if (IN_SET(sig, SIGCONT, SIGKILL)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){18, 9})/sizeof(int)]; switch(sig) { case
case 9: _found = 1; break; default: break; } _found; }))
              flags &= ~CGROUP_SIGCONT;

      /* This goes through the tasks list and kills them all. This
       * is repeated until no further processes are added to the
       * tasks list, to properly handle forking processes */

      if (!s) {
              s = allocated_set = set_new(NULL)internal_set_new(((void*)0) );
              if (!s)
                      return -ENOMEM12;
      }

      my_pid = getpid_cached();

      do {
              _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
              pid_t pid = 0;
              done = true1;

              r = cg_enumerate_processes(controller, path, &f);
              if (r < 0) {
                      if (ret >= 0 && r != -ENOENT2)
                              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)
                              log_kill(pid, sig, userdata);

                      /* If we haven't killed this process yet, kill
                       * it */
                      if (kill(pid, sig) < 0) {
                              if (ret >= 0 && errno(*__errno_location ()) != ESRCH3)
                                      ret = -errno(*__errno_location ());
                      } else {
                              if (flags & CGROUP_SIGCONT)
                                      (void) kill(pid, SIGCONT18);

                              if (ret == 0)
                                      ret = 1;
                      }

                      done = false0;

                      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
               * quicker than we can kill them we repeat this until
               * no new pids need to be killed. */

      } while (!done);

      return ret;
320}

322int cg_kill_recursive(
              const char *controller,
              const char *path,
              int sig,
              CGroupFlags flags,
              Set *s,
              cg_kill_log_func_t log_kill,
              void *userdata) {

      _cleanup_set_free___attribute__((cleanup(set_freep))) Set *allocated_set = NULL((void*)0);
      _cleanup_closedir___attribute__((cleanup(closedirp))) DIR *d = NULL((void*)0);
      int r, ret;
      char *fn;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 336
, __PRETTY_FUNCTION__); } while (0);
      assert(sig >= 0)do { if ((__builtin_expect(!!(!(sig >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sig >= 0"), "../src/basic/cgroup-util.c"
, 337, __PRETTY_FUNCTION__); } while (0);

      if (!s) {
              s = allocated_set = set_new(NULL)internal_set_new(((void*)0) );
              if (!s)
                      return -ENOMEM12;
      }

      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 != -ENOENT2)
                      return r;

              return ret;
      }

      while ((r = cg_read_subgroup(d, &fn)) > 0) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

              p = strjoin(path, "/", fn)strjoin_real((path), "/", fn, ((void*)0));
              free(fn);
              if (!p)
                      return -ENOMEM12;

              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 & CGROUP_REMOVE) {
              r = cg_rmdir(controller, path);
              if (r < 0 && ret >= 0 && !IN_SET(r, -ENOENT, -EBUSY)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-2, -16})/sizeof(int)]; switch(r) { case
 -2: case -16: _found = 1; break; default: break; } _found; }
))
                      return r;
      }

      return ret;
377}

379int cg_migrate(
              const char *cfrom,
              const char *pfrom,
              const char *cto,
              const char *pto,
              CGroupFlags flags) {

      bool_Bool done = false0;
      _cleanup_set_free___attribute__((cleanup(set_freep))) Set *s = NULL((void*)0);
      int r, ret = 0;
      pid_t my_pid;

      assert(cfrom)do { if ((__builtin_expect(!!(!(cfrom)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cfrom"), "../src/basic/cgroup-util.c", 391
, __PRETTY_FUNCTION__); } while (0);
      assert(pfrom)do { if ((__builtin_expect(!!(!(pfrom)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pfrom"), "../src/basic/cgroup-util.c", 392
, __PRETTY_FUNCTION__); } while (0);
      assert(cto)do { if ((__builtin_expect(!!(!(cto)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cto"), "../src/basic/cgroup-util.c", 393
, __PRETTY_FUNCTION__); } while (0);
      assert(pto)do { if ((__builtin_expect(!!(!(pto)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pto"), "../src/basic/cgroup-util.c", 394
, __PRETTY_FUNCTION__); } while (0);

      s = set_new(NULL)internal_set_new(((void*)0) );
      if (!s)
              return -ENOMEM12;

      my_pid = getpid_cached();

      do {
              _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
              pid_t pid = 0;
              done = true1;

              r = cg_enumerate_processes(cfrom, pfrom, &f);
              if (r < 0) {
                      if (ret >= 0 && r != -ENOENT2)
                              return r;

                      return ret;
              }

              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 ((flags & CGROUP_IGNORE_SELF) && pid == my_pid)
                              continue;

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

                      /* Ignore kernel threads. Since they can only
                       * exist in the root cgroup, we only check for
                       * them there. */
                      if (cfrom &&
                          empty_or_root(pfrom) &&
                          is_kernel_thread(pid) > 0)
                              continue;

                      r = cg_attach(cto, pto, pid);
                      if (r < 0) {
                              if (ret >= 0 && r != -ESRCH3)
                                      ret = r;
                      } else if (ret == 0)
                              ret = 1;

                      done = false0;

                      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;
              }
      } while (!done);

      return ret;
461}

463int cg_migrate_recursive(
              const char *cfrom,
              const char *pfrom,
              const char *cto,
              const char *pto,
              CGroupFlags flags) {

      _cleanup_closedir___attribute__((cleanup(closedirp))) DIR *d = NULL((void*)0);
      int r, ret = 0;
      char *fn;

      assert(cfrom)do { if ((__builtin_expect(!!(!(cfrom)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cfrom"), "../src/basic/cgroup-util.c", 474
, __PRETTY_FUNCTION__); } while (0);
      assert(pfrom)do { if ((__builtin_expect(!!(!(pfrom)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pfrom"), "../src/basic/cgroup-util.c", 475
, __PRETTY_FUNCTION__); } while (0);
      assert(cto)do { if ((__builtin_expect(!!(!(cto)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cto"), "../src/basic/cgroup-util.c", 476
, __PRETTY_FUNCTION__); } while (0);
      assert(pto)do { if ((__builtin_expect(!!(!(pto)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pto"), "../src/basic/cgroup-util.c", 477
, __PRETTY_FUNCTION__); } while (0);

      ret = cg_migrate(cfrom, pfrom, cto, pto, flags);

      r = cg_enumerate_subgroups(cfrom, pfrom, &d);
      if (r < 0) {
              if (ret >= 0 && r != -ENOENT2)
                      return r;

              return ret;
      }

      while ((r = cg_read_subgroup(d, &fn)) > 0) {
              _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

              p = strjoin(pfrom, "/", fn)strjoin_real((pfrom), "/", fn, ((void*)0));
              free(fn);
              if (!p)
                      return -ENOMEM12;

              r = cg_migrate_recursive(cfrom, p, cto, pto, flags);
              if (r != 0 && ret >= 0)
                      ret = r;
      }

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

      if (flags & CGROUP_REMOVE) {
              r = cg_rmdir(cfrom, pfrom);
              if (r < 0 && ret >= 0 && !IN_SET(r, -ENOENT, -EBUSY)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-2, -16})/sizeof(int)]; switch(r) { case
 -2: case -16: _found = 1; break; default: break; } _found; }
))
                      return r;
      }

      return ret;
512}

514int cg_migrate_recursive_fallback(
              const char *cfrom,
              const char *pfrom,
              const char *cto,
              const char *pto,
              CGroupFlags flags) {

      int r;

      assert(cfrom)do { if ((__builtin_expect(!!(!(cfrom)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cfrom"), "../src/basic/cgroup-util.c", 523
, __PRETTY_FUNCTION__); } while (0);
      assert(pfrom)do { if ((__builtin_expect(!!(!(pfrom)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pfrom"), "../src/basic/cgroup-util.c", 524
, __PRETTY_FUNCTION__); } while (0);
      assert(cto)do { if ((__builtin_expect(!!(!(cto)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cto"), "../src/basic/cgroup-util.c", 525
, __PRETTY_FUNCTION__); } while (0);
      assert(pto)do { if ((__builtin_expect(!!(!(pto)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pto"), "../src/basic/cgroup-util.c", 526
, __PRETTY_FUNCTION__); } while (0);

      r = cg_migrate_recursive(cfrom, pfrom, cto, pto, flags);
      if (r < 0) {
              char prefix[strlen(pto) + 1];

              /* This didn't work? Then let's try all prefixes of the destination */

              PATH_FOREACH_PREFIX(prefix, pto)for (char *_slash = ({ path_simplify(strcpy(prefix, pto), 0);
 (strcmp((prefix),("/")) == 0) ? ((void*)0) : strrchr(prefix,
 '/'); }); _slash && ((*_slash = 0), 1); _slash = strrchr
((prefix), '/')) {
                      int q;

                      q = cg_migrate_recursive(cfrom, pfrom, cto, prefix, flags);
                      if (q >= 0)
                              return q;
              }
      }

      return r;
544}

546static const char *controller_to_dirname(const char *controller) {
      const char *e;

      assert(controller)do { if ((__builtin_expect(!!(!(controller)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("controller"), "../src/basic/cgroup-util.c"
, 549, __PRETTY_FUNCTION__); } while (0);

      /* Converts a controller name to the directory name below
       * /sys/fs/cgroup/ we want to mount it to. Effectively, this
       * just cuts off the name= prefixed used for named
       * hierarchies, if it is specified. */

      if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0)) {
              if (cg_hybrid_unified() > 0)
                      controller = SYSTEMD_CGROUP_CONTROLLER_HYBRID"name=unified";
              else
                      controller = SYSTEMD_CGROUP_CONTROLLER_LEGACY"name=systemd";
      }

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

      return controller;
568}

570static int join_path_legacy(const char *controller, const char *path, const char *suffix, char **fs) {
      const char *dn;
      char *t = NULL((void*)0);

      assert(fs)do { if ((__builtin_expect(!!(!(fs)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fs"), "../src/basic/cgroup-util.c", 574
, __PRETTY_FUNCTION__); } while (0);
      assert(controller)do { if ((__builtin_expect(!!(!(controller)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("controller"), "../src/basic/cgroup-util.c"
, 575, __PRETTY_FUNCTION__); } while (0);

      dn = controller_to_dirname(controller);

      if (isempty(path) && isempty(suffix))
              t = strappend("/sys/fs/cgroup/", dn);
      else if (isempty(path))
              t = strjoin("/sys/fs/cgroup/", dn, "/", suffix)strjoin_real(("/sys/fs/cgroup/"), dn, "/", suffix, ((void*)0)
);
      else if (isempty(suffix))
              t = strjoin("/sys/fs/cgroup/", dn, "/", path)strjoin_real(("/sys/fs/cgroup/"), dn, "/", path, ((void*)0));
      else
              t = strjoin("/sys/fs/cgroup/", dn, "/", path, "/", suffix)strjoin_real(("/sys/fs/cgroup/"), dn, "/", path, "/", suffix,
 ((void*)0));
      if (!t)
              return -ENOMEM12;

      *fs = t;
      return 0;
592}

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

      assert(fs)do { if ((__builtin_expect(!!(!(fs)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fs"), "../src/basic/cgroup-util.c", 597
, __PRETTY_FUNCTION__); } while (0);

      if (isempty(path) && isempty(suffix))
              t = strdup("/sys/fs/cgroup");
      else if (isempty(path))
              t = strappend("/sys/fs/cgroup/", suffix);
      else if (isempty(suffix))
              t = strappend("/sys/fs/cgroup/", path);
      else
              t = strjoin("/sys/fs/cgroup/", path, "/", suffix)strjoin_real(("/sys/fs/cgroup/"), path, "/", suffix, ((void*)
0));
      if (!t)
              return -ENOMEM12;

      *fs = t;
      return 0;
612}

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

      assert(fs)do { if ((__builtin_expect(!!(!(fs)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fs"), "../src/basic/cgroup-util.c", 617
, __PRETTY_FUNCTION__); } while (0);

      if (!controller) {
              char *t;

              /* If no controller is specified, we return the path
               * *below* the controllers, without any prefix. */

              if (!path && !suffix)
                      return -EINVAL22;

              if (!suffix)
                      t = strdup(path);
              else if (!path)
                      t = strdup(suffix);
              else
                      t = strjoin(path, "/", suffix)strjoin_real((path), "/", suffix, ((void*)0));
              if (!t)
                      return -ENOMEM12;

              *fs = path_simplify(t, false0);
              return 0;
      }

      if (!cg_controller_is_valid(controller))
              return -EINVAL22;

      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, false0);
      return 0;
656}

658static int controller_is_accessible(const char *controller) {
      int r;

      assert(controller)do { if ((__builtin_expect(!!(!(controller)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("controller"), "../src/basic/cgroup-util.c"
, 661, __PRETTY_FUNCTION__); } while (0);

      /* Checks whether a specific controller is accessible,
       * i.e. its hierarchy mounted. In the unified hierarchy all
       * controllers are considered accessible, except for the named
       * hierarchies */

      if (!cg_controller_is_valid(controller))
              return -EINVAL22;

      r = cg_all_unified();
      if (r < 0)
              return r;
      if (r > 0) {
              /* We don't support named hierarchies if we are using
               * the unified hierarchy. */

              if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0))
                      return 0;

              if (startswith(controller, "name="))
                      return -EOPNOTSUPP95;

      } else {
              const char *cc, *dn;

              dn = controller_to_dirname(controller);
              cc = strjoina("/sys/fs/cgroup/", dn)({ const char *_appendees_[] = { "/sys/fs/cgroup/", dn }; char
 *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ <
 __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
 (_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

              if (laccess(cc, F_OK)faccessat(-100, (cc), (0), 0x100) < 0)
                      return -errno(*__errno_location ());
      }

      return 0;
695}

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

      assert(controller)do { if ((__builtin_expect(!!(!(controller)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("controller"), "../src/basic/cgroup-util.c"
, 700, __PRETTY_FUNCTION__); } while (0);
      assert(fs)do { if ((__builtin_expect(!!(!(fs)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fs"), "../src/basic/cgroup-util.c", 701
, __PRETTY_FUNCTION__); } while (0);

      /* Check if the specified controller is actually accessible */
      r = controller_is_accessible(controller);
      if (r < 0)
              return r;

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

711static int trim_cb(const char *path, const struct stat *sb, int typeflag, struct FTW *ftwbuf) {
      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 712
, __PRETTY_FUNCTION__); } while (0);
      assert(sb)do { if ((__builtin_expect(!!(!(sb)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sb"), "../src/basic/cgroup-util.c", 713
, __PRETTY_FUNCTION__); } while (0);
      assert(ftwbuf)do { if ((__builtin_expect(!!(!(ftwbuf)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ftwbuf"), "../src/basic/cgroup-util.c",
 714, __PRETTY_FUNCTION__); } while (0);

      if (typeflag != FTW_DPFTW_DP)
              return 0;

      if (ftwbuf->level < 1)
              return 0;

      (void) rmdir(path);
      return 0;
724}

726int cg_trim(const char *controller, const char *path, bool_Bool delete_root) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      int r = 0, q;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 730
, __PRETTY_FUNCTION__); } while (0);

      r = cg_get_path(controller, path, NULL((void*)0), &fs);
      if (r < 0)
              return r;

      errno(*__errno_location ()) = 0;
      if (nftw(fs, trim_cb, 64, FTW_DEPTHFTW_DEPTH|FTW_MOUNTFTW_MOUNT|FTW_PHYSFTW_PHYS) != 0) {
              if (errno(*__errno_location ()) == ENOENT2)
                      r = 0;
              else if (errno(*__errno_location ()) > 0)
                      r = -errno(*__errno_location ());
              else
                      r = -EIO5;
      }

      if (delete_root) {
              if (rmdir(fs) < 0 && errno(*__errno_location ()) != ENOENT2)
                      return -errno(*__errno_location ());
      }

      q = cg_hybrid_unified();
      if (q < 0)
              return q;
      if (q > 0 && streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0)) {
              q = cg_trim(SYSTEMD_CGROUP_CONTROLLER_LEGACY"name=systemd", path, delete_root);
              if (q < 0)
                      log_warning_errno(q, "Failed to trim compat systemd cgroup %s: %m", path)({ int _level = ((4)), _e = ((q)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 757, __func__, "Failed to trim compat systemd cgroup %s: %m"
, path) : -abs(_e); });
      }

      return r;
761}

763/* Create a cgroup in the hierarchy of controller.
* Returns 0 if the group already existed, 1 on success, negative otherwise.
*/
766int cg_create(const char *controller, const char *path) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      int r;

      r = cg_get_path_and_check(controller, path, NULL((void*)0), &fs);
      if (r < 0)
              return r;

      r = mkdir_parents(fs, 0755);
      if (r < 0)
              return r;

      r = mkdir_errno_wrapper(fs, 0755);
      if (r == -EEXIST17)
              return 0;
      if (r < 0)
              return r;

      r = cg_hybrid_unified();
      if (r < 0)
              return r;

      if (r > 0 && streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0)) {
              r = cg_create(SYSTEMD_CGROUP_CONTROLLER_LEGACY"name=systemd", path);
              if (r < 0)
                      log_warning_errno(r, "Failed to create compat systemd cgroup %s: %m", path)({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 791, __func__, "Failed to create compat systemd cgroup %s: %m"
, path) : -abs(_e); });
      }

      return 1;
795}

797int cg_create_and_attach(const char *controller, const char *path, pid_t pid) {
      int r, q;

      assert(pid >= 0)do { if ((__builtin_expect(!!(!(pid >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid >= 0"), "../src/basic/cgroup-util.c"
, 800, __PRETTY_FUNCTION__); } while (0);

      r = cg_create(controller, path);
      if (r < 0)
              return r;

      q = cg_attach(controller, path, pid);
      if (q < 0)
              return q;

      /* This does not remove the cgroup on failure */
      return r;
812}

814int cg_attach(const char *controller, const char *path, pid_t pid) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      char c[DECIMAL_STR_MAX(pid_t)(2+(sizeof(pid_t) <= 1 ? 3 : sizeof(pid_t) <= 2 ? 5 : sizeof
(pid_t) <= 4 ? 10 : sizeof(pid_t) <= 8 ? 20 : sizeof(int
[-2*(sizeof(pid_t) > 8)]))) + 2];
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 819
, __PRETTY_FUNCTION__); } while (0);
      assert(pid >= 0)do { if ((__builtin_expect(!!(!(pid >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid >= 0"), "../src/basic/cgroup-util.c"
, 820, __PRETTY_FUNCTION__); } while (0);

      r = cg_get_path_and_check(controller, path, "cgroup.procs", &fs);
      if (r < 0)
              return r;

      if (pid == 0)
              pid = getpid_cached();

      xsprintf(c, PID_FMT "\n", pid)do { if ((__builtin_expect(!!(!(((size_t) snprintf(c, __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(c), typeof(&*(c))), sizeof(c)/sizeof((c)[0]), ((void)0))
), "%" "i" "\n", pid) < (__extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(c), typeof(&*(c)))
, sizeof(c)/sizeof((c)[0]), ((void)0))))))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("xsprintf: " "c" "[] must be big enough"
), "../src/basic/cgroup-util.c", 829, __PRETTY_FUNCTION__); }
 while (0);

      r = write_string_file(fs, c, 0);
      if (r < 0)
              return r;

      r = cg_hybrid_unified();
      if (r < 0)
              return r;

      if (r > 0 && streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0)) {
              r = cg_attach(SYSTEMD_CGROUP_CONTROLLER_LEGACY"name=systemd", path, pid);
              if (r < 0)
                      log_warning_errno(r, "Failed to attach "PID_FMT" to compat systemd cgroup %s: %m", pid, path)({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 842, __func__, "Failed to attach "
"%" "i"" to compat systemd cgroup %s: %m", pid, path) : -abs(
_e); });
      }

      return 0;
846}

848int cg_attach_fallback(const char *controller, const char *path, pid_t pid) {
      int r;

      assert(controller)do { if ((__builtin_expect(!!(!(controller)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("controller"), "../src/basic/cgroup-util.c"
, 851, __PRETTY_FUNCTION__); } while (0);
      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 852
, __PRETTY_FUNCTION__); } while (0);
      assert(pid >= 0)do { if ((__builtin_expect(!!(!(pid >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid >= 0"), "../src/basic/cgroup-util.c"
, 853, __PRETTY_FUNCTION__); } while (0);

      r = cg_attach(controller, path, pid);
      if (r < 0) {
              char prefix[strlen(path) + 1];

              /* This didn't work? Then let's try all prefixes of
               * the destination */

              PATH_FOREACH_PREFIX(prefix, path)for (char *_slash = ({ path_simplify(strcpy(prefix, path), 0)
; (strcmp((prefix),("/")) == 0) ? ((void*)0) : strrchr(prefix
, '/'); }); _slash && ((*_slash = 0), 1); _slash = strrchr
((prefix), '/')) {
                      int q;

                      q = cg_attach(controller, prefix, pid);
                      if (q >= 0)
                              return q;
              }
      }

      return r;
872}

874int cg_set_access(
              const char *controller,
              const char *path,
              uid_t uid,
              gid_t gid) {

      struct Attribute {
              const char *name;
              bool_Bool fatal;
      };

      /* cgroupsv1, aka legacy/non-unified */
      static const struct Attribute legacy_attributes[] = {
              { "cgroup.procs",           true1  },
              { "tasks",                  false0 },
              { "cgroup.clone_children",  false0 },
              {},
      };

      /* cgroupsv2, aka unified */
      static const struct Attribute unified_attributes[] = {
              { "cgroup.procs",           true1  },
              { "cgroup.subtree_control", true1  },
              { "cgroup.threads",         false0 },
              {},
      };

      static const struct Attribute* const attributes[] = {
              [false0] = legacy_attributes,
              [true1]  = unified_attributes,
      };

      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      const struct Attribute *i;
      int r, unified;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 910
, __PRETTY_FUNCTION__); } while (0);

      if (uid == UID_INVALID((uid_t) -1) && gid == GID_INVALID((gid_t) -1))
              return 0;

      unified = cg_unified_controller(controller);
      if (unified < 0)
              return unified;

      /* Configure access to the cgroup itself */
      r = cg_get_path(controller, path, NULL((void*)0), &fs);
      if (r < 0)
              return r;

      r = chmod_and_chown(fs, 0755, uid, gid);
      if (r < 0)
              return r;

      /* Configure access to the cgroup's attributes */
      for (i = attributes[unified]; i->name; i++) {
              fs = mfree(fs);

              r = cg_get_path(controller, path, i->name, &fs);
              if (r < 0)
                      return r;

              r = chmod_and_chown(fs, 0644, uid, gid);
              if (r < 0) {
                      if (i->fatal)
                              return r;

                      log_debug_errno(r, "Failed to set access on cgroup %s, ignoring: %m", fs)({ int _level = ((7)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 941, __func__, "Failed to set access on cgroup %s, ignoring: %m"
, fs) : -abs(_e); });
              }
      }

      if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0)) {
              r = cg_hybrid_unified();
              if (r < 0)
                      return r;
              if (r > 0) {
                      /* Always propagate access mode from unified to legacy controller */
                      r = cg_set_access(SYSTEMD_CGROUP_CONTROLLER_LEGACY"name=systemd", path, uid, gid);
                      if (r < 0)
                              log_debug_errno(r, "Failed to set access on compatibility systemd cgroup %s, ignoring: %m", path)({ int _level = ((7)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 953, __func__, "Failed to set access on compatibility systemd cgroup %s, ignoring: %m"
, path) : -abs(_e); });
              }
      }

      return 0;
958}

960int cg_set_xattr(const char *controller, const char *path, const char *name, const void *value, size_t size, int flags) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 964
, __PRETTY_FUNCTION__); } while (0);
      assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/basic/cgroup-util.c", 965
, __PRETTY_FUNCTION__); } while (0);
      assert(value || size <= 0)do { if ((__builtin_expect(!!(!(value || size <= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("value || size <= 0"), "../src/basic/cgroup-util.c"
, 966, __PRETTY_FUNCTION__); } while (0);

      r = cg_get_path(controller, path, NULL((void*)0), &fs);
      if (r < 0)
              return r;

      if (setxattr(fs, name, value, size, flags) < 0)
              return -errno(*__errno_location ());

      return 0;
976}

978int cg_get_xattr(const char *controller, const char *path, const char *name, void *value, size_t size) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      ssize_t n;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 983
, __PRETTY_FUNCTION__); } while (0);
      assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/basic/cgroup-util.c", 984
, __PRETTY_FUNCTION__); } while (0);

      r = cg_get_path(controller, path, NULL((void*)0), &fs);
      if (r < 0)
              return r;

      n = getxattr(fs, name, value, size);
      if (n < 0)
              return -errno(*__errno_location ());

      return (int) n;
995}

997int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      char line[LINE_MAX2048];
      const char *fs, *controller_str;
      size_t cs = 0;
      int unified;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1004
, __PRETTY_FUNCTION__); } while (0);
      assert(pid >= 0)do { if ((__builtin_expect(!!(!(pid >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid >= 0"), "../src/basic/cgroup-util.c"
, 1005, __PRETTY_FUNCTION__); } while (0);

      if (controller) {
              if (!cg_controller_is_valid(controller))
                      return -EINVAL22;
      } else
              controller = SYSTEMD_CGROUP_CONTROLLER"_systemd";

      unified = cg_unified_controller(controller);
      if (unified < 0)
              return unified;
      if (unified == 0) {
              if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)(strcmp((controller),("_systemd")) == 0))
                      controller_str = SYSTEMD_CGROUP_CONTROLLER_LEGACY"name=systemd";
              else
                      controller_str = controller;

              cs = strlen(controller_str);
      }

      fs = procfs_file_alloca(pid, "cgroup")({ pid_t _pid_ = (pid); const char *_r_; if (_pid_ == 0) { _r_
 = ("/proc/self/" "cgroup"); } else { _r_ = __builtin_alloca (
(sizeof("""/proc/""") - 1) + (2+(sizeof(pid_t) <= 1 ? 3 : sizeof
(pid_t) <= 2 ? 5 : sizeof(pid_t) <= 4 ? 10 : sizeof(pid_t
) <= 8 ? 20 : sizeof(int[-2*(sizeof(pid_t) > 8)]))) + 1
 + sizeof("cgroup")); sprintf((char*) _r_, "/proc/""%" "i""/"
 "cgroup", _pid_); } _r_; });
      f = fopen(fs, "re");
      if (!f)
              return errno(*__errno_location ()) == ENOENT2 ? -ESRCH3 : -errno(*__errno_location ());

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

      FOREACH_LINE(line, f, return -errno)for (;;) if (!fgets(line, sizeof(line), f)) { if (ferror(f)) {
 return -(*__errno_location ()); } break; } else {
              char *e, *p;

              truncate_nl(line);

              if (unified) {
                      e = startswith(line, "0:");
                      if (!e)
                              continue;

                      e = strchr(e, ':');
                      if (!e)
                              continue;
              } else {
                      char *l;
                      size_t k;
                      const char *word, *state;
                      bool_Bool found = false0;

                      l = strchr(line, ':');
                      if (!l)
                              continue;

                      l++;
                      e = strchr(l, ':');
                      if (!e)
                              continue;

                      *e = 0;
                      FOREACH_WORD_SEPARATOR(word, k, l, ",", state)for ((state) = (l), (word) = split(&(state), &(k), (","
), (0)); (word); (word) = split(&(state), &(k), (",")
, (0)))
                              if (k == cs && memcmp(word, controller_str, cs) == 0) {
                                      found = true1;
                                      break;
                              }
                      if (!found)
                              continue;
              }

              p = strdup(e + 1);
              if (!p)
                      return -ENOMEM12;

              /* Truncate suffix indicating the process is a zombie */
              e = endswith(p, " (deleted)");
              if (e)
                      *e = 0;

              *path = p;
              return 0;
      }

      return -ENODATA61;
1084}

1086int cg_install_release_agent(const char *controller, const char *agent) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0), *contents = NULL((void*)0);
      const char *sc;
      int r;

      assert(agent)do { if ((__builtin_expect(!!(!(agent)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("agent"), "../src/basic/cgroup-util.c", 1091
, __PRETTY_FUNCTION__); } while (0);

      r = cg_unified_controller(controller);
      if (r < 0)
              return r;
      if (r > 0) /* doesn't apply to unified hierarchy */
              return -EOPNOTSUPP95;

      r = cg_get_path(controller, NULL((void*)0), "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, 0);
              if (r < 0)
                      return r;
      } else if (!path_equal(sc, agent))
              return -EEXIST17;

      fs = mfree(fs);
      r = cg_get_path(controller, NULL((void*)0), "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")(strcmp((sc),("0")) == 0)) {
              r = write_string_file(fs, "1", 0);
              if (r < 0)
                      return r;

              return 1;
      }

      if (!streq(sc, "1")(strcmp((sc),("1")) == 0))
              return -EIO5;

      return 0;
1138}

1140int cg_uninstall_release_agent(const char *controller) {
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      int r;

      r = cg_unified_controller(controller);
      if (r < 0)
              return r;
      if (r > 0) /* Doesn't apply to unified hierarchy */
              return -EOPNOTSUPP95;

      r = cg_get_path(controller, NULL((void*)0), "notify_on_release", &fs);
      if (r < 0)
              return r;

      r = write_string_file(fs, "0", 0);
      if (r < 0)
              return r;

      fs = mfree(fs);

      r = cg_get_path(controller, NULL((void*)0), "release_agent", &fs);
      if (r < 0)
              return r;

      r = write_string_file(fs, "", 0);
      if (r < 0)
              return r;

      return 0;
1169}

1171int cg_is_empty(const char *controller, const char *path) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      pid_t pid;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1176
, __PRETTY_FUNCTION__); } while (0);

      r = cg_enumerate_processes(controller, path, &f);
      if (r == -ENOENT2)
              return 1;
      if (r < 0)
              return r;

      r = cg_read_pid(f, &pid);
      if (r < 0)
              return r;

      return r == 0;
1189}

1191int cg_is_empty_recursive(const char *controller, const char *path) {
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1194
, __PRETTY_FUNCTION__); } while (0);

      /* The root cgroup is always populated */
      if (controller && empty_or_root(path))
              return false0;

      r = cg_unified_controller(controller);
      if (r < 0)
              return r;
      if (r > 0) {
              _cleanup_free___attribute__((cleanup(freep))) char *t = NULL((void*)0);

              /* On the unified hierarchy we can check empty state
               * via the "populated" attribute of "cgroup.events". */

              r = cg_read_event(controller, path, "populated", &t);
              if (r < 0)
                      return r;

              return streq(t, "0")(strcmp((t),("0")) == 0);
      } else {
              _cleanup_closedir___attribute__((cleanup(closedirp))) DIR *d = NULL((void*)0);
              char *fn;

              r = cg_is_empty(controller, path);
              if (r <= 0)
                      return r;

              r = cg_enumerate_subgroups(controller, path, &d);
              if (r == -ENOENT2)
                      return 1;
              if (r < 0)
                      return r;

              while ((r = cg_read_subgroup(d, &fn)) > 0) {
                      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

                      p = strjoin(path, "/", fn)strjoin_real((path), "/", fn, ((void*)0));
                      free(fn);
                      if (!p)
                              return -ENOMEM12;

                      r = cg_is_empty_recursive(controller, p);
                      if (r <= 0)
                              return r;
              }
              if (r < 0)
                      return r;

              return true1;
      }
1245}

1247int cg_split_spec(const char *spec, char **controller, char **path) {
      char *t = NULL((void*)0), *u = NULL((void*)0);
      const char *e;

      assert(spec)do { if ((__builtin_expect(!!(!(spec)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("spec"), "../src/basic/cgroup-util.c", 1251
, __PRETTY_FUNCTION__); } while (0);

      if (*spec == '/') {
              if (!path_is_normalized(spec))
                      return -EINVAL22;

              if (path) {
                      t = strdup(spec);
                      if (!t)
                              return -ENOMEM12;

                      *path = path_simplify(t, false0);
              }

              if (controller)
                      *controller = NULL((void*)0);

              return 0;
      }

      e = strchr(spec, ':');
      if (!e) {
              if (!cg_controller_is_valid(spec))
                      return -EINVAL22;

              if (controller) {
                      t = strdup(spec);
                      if (!t)
                              return -ENOMEM12;

                      *controller = t;
              }

              if (path)
                      *path = NULL((void*)0);

              return 0;
      }

      t = strndup(spec, e-spec);
      if (!t)
              return -ENOMEM12;
      if (!cg_controller_is_valid(t)) {
              free(t);
              return -EINVAL22;
      }

      if (isempty(e+1))
              u = NULL((void*)0);
      else {
              u = strdup(e+1);
              if (!u) {
                      free(t);
                      return -ENOMEM12;
              }

              if (!path_is_normalized(u) ||
                  !path_is_absolute(u)) {
                      free(t);
                      free(u);
                      return -EINVAL22;
              }

              path_simplify(u, false0);
      }

      if (controller)
              *controller = t;
      else
              free(t);

      if (path)
              *path = u;
      else
              free(u);

      return 0;
1328}

1330int cg_mangle_path(const char *path, char **result) {
      _cleanup_free___attribute__((cleanup(freep))) char *c = NULL((void*)0), *p = NULL((void*)0);
      char *t;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1335
, __PRETTY_FUNCTION__); } while (0);
      assert(result)do { if ((__builtin_expect(!!(!(result)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("result"), "../src/basic/cgroup-util.c",
 1336, __PRETTY_FUNCTION__); } while (0);

      /* First, check if it already is a filesystem path */
      if (path_startswith(path, "/sys/fs/cgroup")) {

              t = strdup(path);
              if (!t)
                      return -ENOMEM12;

              *result = path_simplify(t, false0);
              return 0;
      }

      /* Otherwise, treat it as cg spec */
      r = cg_split_spec(path, &c, &p);
      if (r < 0)
              return r;

      return cg_get_path(c ?: SYSTEMD_CGROUP_CONTROLLER"_systemd", p ?: "/", NULL((void*)0), result);
1355}

1357int cg_get_root_path(char **path) {
      char *p, *e;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1361
, __PRETTY_FUNCTION__); } while (0);

      r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER"_systemd", 1, &p);
      if (r < 0)
              return r;

      e = endswith(p, "/" SPECIAL_INIT_SCOPE"init.scope");
      if (!e)
              e = endswith(p, "/" SPECIAL_SYSTEM_SLICE"system.slice"); /* legacy */
      if (!e)
              e = endswith(p, "/system"); /* even more legacy */
      if (e)
              *e = 0;

      *path = p;
      return 0;
1377}

1379int cg_shift_path(const char *cgroup, const char *root, const char **shifted) {
      _cleanup_free___attribute__((cleanup(freep))) char *rt = NULL((void*)0);
      char *p;
      int r;

      assert(cgroup)do { if ((__builtin_expect(!!(!(cgroup)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cgroup"), "../src/basic/cgroup-util.c",
 1384, __PRETTY_FUNCTION__); } while (0);
      assert(shifted)do { if ((__builtin_expect(!!(!(shifted)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("shifted"), "../src/basic/cgroup-util.c"
, 1385, __PRETTY_FUNCTION__); } while (0);

      if (!root) {
              /* If the root was specified let's use that, otherwise
               * let's determine it from PID 1 */

              r = cg_get_root_path(&rt);
              if (r < 0)
                      return r;

              root = rt;
      }

      p = path_startswith(cgroup, root);
      if (p && p > cgroup)
              *shifted = p - 1;
      else
              *shifted = cgroup;

      return 0;
1405}

1407int cg_pid_get_path_shifted(pid_t pid, const char *root, char **cgroup) {
      _cleanup_free___attribute__((cleanup(freep))) char *raw = NULL((void*)0);
      const char *c;
      int r;

      assert(pid >= 0)do { if ((__builtin_expect(!!(!(pid >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid >= 0"), "../src/basic/cgroup-util.c"
, 1412, __PRETTY_FUNCTION__); } while (0);
5
←
Assuming 'pid' is >= 0→
6
←
Taking false branch→
7
←
Loop condition is false.  Exiting loop→
      assert(cgroup)do { if ((__builtin_expect(!!(!(cgroup)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cgroup"), "../src/basic/cgroup-util.c",
 1413, __PRETTY_FUNCTION__); } while (0);
8
←
Taking false branch→
9
←
Loop condition is false.  Exiting loop→

      r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER"_systemd", pid, &raw);
      if (r < 0)
10
←
Assuming 'r' is >= 0→
11
←
Taking false branch→
              return r;

      r = cg_shift_path(raw, root, &c);
      if (r11.1
'r' is >= 0
 < 0)
12
←
Taking false branch→
              return r;

      if (c == raw)
13
←
Assuming 'c' is not equal to 'raw'→
14
←
Taking false branch→
              *cgroup = TAKE_PTR(raw)({ typeof(raw) _ptr_ = (raw); (raw) = ((void*)0); _ptr_; });
      else {
              char *n;

              n = strdup(c);
15
←
Memory is allocated→
              if (!n)
16
←
Assuming 'n' is non-null→
17
←
Taking false branch→
                      return -ENOMEM12;

              *cgroup = n;
      }

      return 0;
1436}

1438int cg_path_decode_unit(const char *cgroup, char **unit) {
      char *c, *s;
      size_t n;

      assert(cgroup)do { if ((__builtin_expect(!!(!(cgroup)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("cgroup"), "../src/basic/cgroup-util.c",
 1442, __PRETTY_FUNCTION__); } while (0);
      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/basic/cgroup-util.c", 1443
, __PRETTY_FUNCTION__); } while (0);

      n = strcspn(cgroup, "/");
      if (n < 3)
              return -ENXIO6;

      c = strndupa(cgroup, n)(__extension__ ({ const char *__old = (cgroup); size_t __len =
 strnlen (__old, (n)); char *__new = (char *) __builtin_alloca
 (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old
, __len); }));
      c = cg_unescape(c);

      if (!unit_name_is_valid(c, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
              return -ENXIO6;

      s = strdup(c);
      if (!s)
              return -ENOMEM12;

      *unit = s;
      return 0;
1461}

1463static bool_Bool valid_slice_name(const char *p, size_t n) {

      if (!p)
              return false0;

      if (n < STRLEN("x.slice")(sizeof("""x.slice""") - 1))
              return false0;

      if (memcmp(p + n - 6, ".slice", 6) == 0) {
              char buf[n+1], *c;

              memcpy(buf, p, n);
              buf[n] = 0;

              c = cg_unescape(buf);

              return unit_name_is_valid(c, UNIT_NAME_PLAIN);
      }

      return false0;
1483}

1485static const char *skip_slices(const char *p) {
      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/cgroup-util.c", 1486
, __PRETTY_FUNCTION__); } while (0);

      /* Skips over all slice assignments */

      for (;;) {
              size_t n;

              p += strspn(p, "/");

              n = strcspn(p, "/");
              if (!valid_slice_name(p, n))
                      return p;

              p += n;
      }
1501}

1503int cg_path_get_unit(const char *path, char **ret) {
      const char *e;
      char *unit;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1508
, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/cgroup-util.c", 1509
, __PRETTY_FUNCTION__); } while (0);

      e = skip_slices(path);

      r = cg_path_decode_unit(e, &unit);
      if (r < 0)
              return r;

      /* We skipped over the slices, don't accept any now */
      if (endswith(unit, ".slice")) {
              free(unit);
              return -ENXIO6;
      }

      *ret = unit;
      return 0;
1525}

1527int cg_pid_get_unit(pid_t pid, char **unit) {
      _cleanup_free___attribute__((cleanup(freep))) char *cgroup = NULL((void*)0);
      int r;

      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/basic/cgroup-util.c", 1531
, __PRETTY_FUNCTION__); } while (0);

      r = cg_pid_get_path_shifted(pid, NULL((void*)0), &cgroup);
      if (r < 0)
              return r;

      return cg_path_get_unit(cgroup, unit);
1538}

1540/**
* Skip session-*.scope, but require it to be there.
*/
1543static const char *skip_session(const char *p) {
      size_t n;

      if (isempty(p))
              return NULL((void*)0);

      p += strspn(p, "/");

      n = strcspn(p, "/");
      if (n < STRLEN("session-x.scope")(sizeof("""session-x.scope""") - 1))
              return NULL((void*)0);

      if (memcmp(p, "session-", 8) == 0 && memcmp(p + n - 6, ".scope", 6) == 0) {
              char buf[n - 8 - 6 + 1];

              memcpy(buf, p + 8, n - 8 - 6);
              buf[n - 8 - 6] = 0;

              /* Note that session scopes never need unescaping,
               * since they cannot conflict with the kernel's own
               * names, hence we don't need to call cg_unescape()
               * here. */

              if (!session_id_valid(buf))
                      return false0;

              p += n;
              p += strspn(p, "/");
              return p;
      }

      return NULL((void*)0);
1575}

1577/**
* Skip user@*.service, but require it to be there.
*/
1580static const char *skip_user_manager(const char *p) {
      size_t n;

      if (isempty(p))
              return NULL((void*)0);

      p += strspn(p, "/");

      n = strcspn(p, "/");
      if (n < STRLEN("user@x.service")(sizeof("""user@x.service""") - 1))
              return NULL((void*)0);

      if (memcmp(p, "user@", 5) == 0 && memcmp(p + n - 8, ".service", 8) == 0) {
              char buf[n - 5 - 8 + 1];

              memcpy(buf, p + 5, n - 5 - 8);
              buf[n - 5 - 8] = 0;

              /* Note that user manager services never need unescaping,
               * since they cannot conflict with the kernel's own
               * names, hence we don't need to call cg_unescape()
               * here. */

              if (parse_uid(buf, NULL((void*)0)) < 0)
                      return NULL((void*)0);

              p += n;
              p += strspn(p, "/");

              return p;
      }

      return NULL((void*)0);
1613}

1615static const char *skip_user_prefix(const char *path) {
      const char *e, *t;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1618
, __PRETTY_FUNCTION__); } while (0);

      /* Skip slices, if there are any */
      e = skip_slices(path);

      /* Skip the user manager, if it's in the path now... */
      t = skip_user_manager(e);
      if (t)
              return t;

      /* Alternatively skip the user session if it is in the path... */
      return skip_session(e);
1630}

1632int cg_path_get_user_unit(const char *path, char **ret) {
      const char *t;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1635
, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/cgroup-util.c", 1636
, __PRETTY_FUNCTION__); } while (0);

      t = skip_user_prefix(path);
      if (!t)
              return -ENXIO6;

      /* And from here on it looks pretty much the same as for a
       * system unit, hence let's use the same parser from here
       * on. */
      return cg_path_get_unit(t, ret);
1646}

1648int cg_pid_get_user_unit(pid_t pid, char **unit) {
      _cleanup_free___attribute__((cleanup(freep))) char *cgroup = NULL((void*)0);
      int r;

      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/basic/cgroup-util.c", 1652
, __PRETTY_FUNCTION__); } while (0);
1
Assuming 'unit' is non-null→
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→

      r = cg_pid_get_path_shifted(pid, NULL((void*)0), &cgroup);
4
←
Calling 'cg_pid_get_path_shifted'→
18
←
Returned allocated memory via 3rd parameter→
      if (r18.1
'r' is >= 0
 < 0)
19
←
Taking false branch→
              return r;

      return cg_path_get_user_unit(cgroup, unit);
20
←
Potential leak of memory pointed to by 'cgroup'
1659}

1661int cg_path_get_machine_name(const char *path, char **machine) {
      _cleanup_free___attribute__((cleanup(freep))) char *u = NULL((void*)0);
      const char *sl;
      int r;

      r = cg_path_get_unit(path, &u);
      if (r < 0)
              return r;

      sl = strjoina("/run/systemd/machines/unit:", u)({ const char *_appendees_[] = { "/run/systemd/machines/unit:"
, u }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_
 = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
 (_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });
      return readlink_malloc(sl, machine);
1672}

1674int cg_pid_get_machine_name(pid_t pid, char **machine) {
      _cleanup_free___attribute__((cleanup(freep))) char *cgroup = NULL((void*)0);
      int r;

      assert(machine)do { if ((__builtin_expect(!!(!(machine)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("machine"), "../src/basic/cgroup-util.c"
, 1678, __PRETTY_FUNCTION__); } while (0);

      r = cg_pid_get_path_shifted(pid, NULL((void*)0), &cgroup);
      if (r < 0)
              return r;

      return cg_path_get_machine_name(cgroup, machine);
1685}

1687int cg_path_get_session(const char *path, char **session) {
      _cleanup_free___attribute__((cleanup(freep))) char *unit = NULL((void*)0);
      char *start, *end;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1692
, __PRETTY_FUNCTION__); } while (0);

      r = cg_path_get_unit(path, &unit);
      if (r < 0)
              return r;

      start = startswith(unit, "session-");
      if (!start)
              return -ENXIO6;
      end = endswith(start, ".scope");
      if (!end)
              return -ENXIO6;

      *end = 0;
      if (!session_id_valid(start))
              return -ENXIO6;

      if (session) {
              char *rr;

              rr = strdup(start);
              if (!rr)
                      return -ENOMEM12;

              *session = rr;
      }

      return 0;
1720}

1722int cg_pid_get_session(pid_t pid, char **session) {
      _cleanup_free___attribute__((cleanup(freep))) char *cgroup = NULL((void*)0);
      int r;

      r = cg_pid_get_path_shifted(pid, NULL((void*)0), &cgroup);
      if (r < 0)
              return r;

      return cg_path_get_session(cgroup, session);
1731}

1733int cg_path_get_owner_uid(const char *path, uid_t *uid) {
      _cleanup_free___attribute__((cleanup(freep))) char *slice = NULL((void*)0);
      char *start, *end;
      int r;

      assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/basic/cgroup-util.c", 1738
, __PRETTY_FUNCTION__); } while (0);

      r = cg_path_get_slice(path, &slice);
      if (r < 0)
              return r;

      start = startswith(slice, "user-");
      if (!start)
              return -ENXIO6;
      end = endswith(start, ".slice");
      if (!end)
              return -ENXIO6;

      *end = 0;
      if (parse_uid(start, uid) < 0)
              return -ENXIO6;

      return 0;
1756}

1758int cg_pid_get_owner_uid(pid_t pid, uid_t *uid) {
      _cleanup_free___attribute__((cleanup(freep))) char *cgroup = NULL((void*)0);
      int r;

      r = cg_pid_get_path_shifted(pid, NULL((void*)0), &cgroup);
      if (r < 0)
              return r;

      return cg_path_get_owner_uid(cgroup, uid);
1767}

1769int cg_path_get_slice(const char *p, char **slice) {
      const char *e = NULL((void*)0);

      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/cgroup-util.c", 1772
, __PRETTY_FUNCTION__); } while (0);
      assert(slice)do { if ((__builtin_expect(!!(!(slice)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("slice"), "../src/basic/cgroup-util.c", 1773
, __PRETTY_FUNCTION__); } while (0);

      /* Finds the right-most slice unit from the beginning, but
       * stops before we come to the first non-slice unit. */

      for (;;) {
              size_t n;

              p += strspn(p, "/");

              n = strcspn(p, "/");
              if (!valid_slice_name(p, n)) {

                      if (!e) {
                              char *s;

                              s = strdup(SPECIAL_ROOT_SLICE"-.slice");
                              if (!s)
                                      return -ENOMEM12;

                              *slice = s;
                              return 0;
                      }

                      return cg_path_decode_unit(e, slice);
              }

              e = p;
              p += n;
      }
1803}

1805int cg_pid_get_slice(pid_t pid, char **slice) {
      _cleanup_free___attribute__((cleanup(freep))) char *cgroup = NULL((void*)0);
      int r;

      assert(slice)do { if ((__builtin_expect(!!(!(slice)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("slice"), "../src/basic/cgroup-util.c", 1809
, __PRETTY_FUNCTION__); } while (0);

      r = cg_pid_get_path_shifted(pid, NULL((void*)0), &cgroup);
      if (r < 0)
              return r;

      return cg_path_get_slice(cgroup, slice);
1816}

1818int cg_path_get_user_slice(const char *p, char **slice) {
      const char *t;
      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/cgroup-util.c", 1820
, __PRETTY_FUNCTION__); } while (0);
      assert(slice)do { if ((__builtin_expect(!!(!(slice)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("slice"), "../src/basic/cgroup-util.c", 1821
, __PRETTY_FUNCTION__); } while (0);

      t = skip_user_prefix(p);
      if (!t)
              return -ENXIO6;

      /* And now it looks pretty much the same as for a system
       * slice, so let's just use the same parser from here on. */
      return cg_path_get_slice(t, slice);
1830}

1832int cg_pid_get_user_slice(pid_t pid, char **slice) {
      _cleanup_free___attribute__((cleanup(freep))) char *cgroup = NULL((void*)0);
      int r;

      assert(slice)do { if ((__builtin_expect(!!(!(slice)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("slice"), "../src/basic/cgroup-util.c", 1836
, __PRETTY_FUNCTION__); } while (0);

      r = cg_pid_get_path_shifted(pid, NULL((void*)0), &cgroup);
      if (r < 0)
              return r;

      return cg_path_get_user_slice(cgroup, slice);
1843}

1845char *cg_escape(const char *p) {
      bool_Bool need_prefix = false0;

      /* This implements very minimal escaping for names to be used
       * as file names in the cgroup tree: any name which might
       * conflict with a kernel name or is prefixed with '_' is
       * prefixed with a '_'. That way, when reading cgroup names it
       * is sufficient to remove a single prefixing underscore if
       * there is one. */

      /* The return value of this function (unlike cg_unescape())
       * needs free()! */

      if (IN_SET(p[0], 0, '_', '.')({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){0, '_', '.'})/sizeof(int)]; switch(p[0])
 { case 0: case '_': case '.': _found = 1; break; default: break
; } _found; }) ||
          streq(p, "notify_on_release")(strcmp((p),("notify_on_release")) == 0) ||
          streq(p, "release_agent")(strcmp((p),("release_agent")) == 0) ||
          streq(p, "tasks")(strcmp((p),("tasks")) == 0) ||
          startswith(p, "cgroup."))
              need_prefix = true1;
      else {
              const char *dot;

              dot = strrchr(p, '.');
              if (dot) {
                      CGroupController c;
                      size_t l = dot - p;

                      for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
                              const char *n;

                              n = cgroup_controller_to_string(c);

                              if (l != strlen(n))
                                      continue;

                              if (memcmp(p, n, l) != 0)
                                      continue;

                              need_prefix = true1;
                              break;
                      }
              }
      }

      if (need_prefix)
              return strappend("_", p);

      return strdup(p);
1893}

1895char *cg_unescape(const char *p) {
      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/cgroup-util.c", 1896
, __PRETTY_FUNCTION__); } while (0);

      /* The return value of this function (unlike cg_escape())
       * doesn't need free()! */

      if (p[0] == '_')
              return (char*) p+1;

      return (char*) p;
1905}

1907#define CONTROLLER_VALID"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "_"                        \
      DIGITS"0123456789" LETTERS"abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"                          \
      "_"

1911bool_Bool cg_controller_is_valid(const char *p) {
      const char *t, *s;

      if (!p)
              return false0;

      if (streq(p, SYSTEMD_CGROUP_CONTROLLER)(strcmp((p),("_systemd")) == 0))
              return true1;

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

      if (IN_SET(*p, 0, '_')({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){0, '_'})/sizeof(int)]; switch(*p) { case
case '_': _found = 1; break; default: break; } _found; }))
              return false0;

      for (t = p; *t; t++)
              if (!strchr(CONTROLLER_VALID"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "_", *t))
                      return false0;

      if (t - p > FILENAME_MAX4096)
              return false0;

      return true1;
1935}

1937int cg_slice_to_path(const char *unit, char **ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *s = NULL((void*)0), *e = NULL((void*)0);
      const char *dash;
      int r;

      assert(unit)do { if ((__builtin_expect(!!(!(unit)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("unit"), "../src/basic/cgroup-util.c", 1942
, __PRETTY_FUNCTION__); } while (0);
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/cgroup-util.c", 1943
, __PRETTY_FUNCTION__); } while (0);

      if (streq(unit, SPECIAL_ROOT_SLICE)(strcmp((unit),("-.slice")) == 0)) {
              char *x;

              x = strdup("");
              if (!x)
                      return -ENOMEM12;
              *ret = x;
              return 0;
      }

      if (!unit_name_is_valid(unit, UNIT_NAME_PLAIN))
              return -EINVAL22;

      if (!endswith(unit, ".slice"))
              return -EINVAL22;

      r = unit_name_to_prefix(unit, &p);
      if (r < 0)
              return r;

      dash = strchr(p, '-');

      /* Don't allow initial dashes */
      if (dash == p)
              return -EINVAL22;

      while (dash) {
              _cleanup_free___attribute__((cleanup(freep))) char *escaped = NULL((void*)0);
              char n[dash - p + sizeof(".slice")];

1975#if HAS_FEATURE_MEMORY_SANITIZER0
              /* msan doesn't instrument stpncpy, so it thinks
               * n is later used unitialized:
               * https://github.com/google/sanitizers/issues/926
               */
              zero(n)(({ size_t _l_ = (sizeof(n)); void *_x_ = (&(n)); _l_ == 0
 ? _x_ : memset(_x_, 0, _l_); }));
1981#endif

              /* Don't allow trailing or double dashes */
              if (IN_SET(dash[1], 0, '-')({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){0, '-'})/sizeof(int)]; switch(dash[1]) {
 case 0: case '-': _found = 1; break; default: break; } _found
; }))
                      return -EINVAL22;

              strcpy(stpncpy(n, p, dash - p), ".slice");
              if (!unit_name_is_valid(n, UNIT_NAME_PLAIN))
                      return -EINVAL22;

              escaped = cg_escape(n);
              if (!escaped)
                      return -ENOMEM12;

              if (!strextend(&s, escaped, "/", NULL)strextend_with_separator(&s, ((void*)0), escaped, "/", ((
void*)0)))
                      return -ENOMEM12;

              dash = strchr(dash+1, '-');
      }

      e = cg_escape(unit);
      if (!e)
              return -ENOMEM12;

      if (!strextend(&s, e, NULL)strextend_with_separator(&s, ((void*)0), e, ((void*)0)))
              return -ENOMEM12;

      *ret = TAKE_PTR(s)({ typeof(s) _ptr_ = (s); (s) = ((void*)0); _ptr_; });

      return 0;
2011}

2013int cg_set_attribute(const char *controller, const char *path, const char *attribute, const char *value) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      int r;

      r = cg_get_path(controller, path, attribute, &p);
      if (r < 0)
              return r;

      return write_string_file(p, value, 0);
2022}

2024int cg_get_attribute(const char *controller, const char *path, const char *attribute, char **ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);
      int r;

      r = cg_get_path(controller, path, attribute, &p);
      if (r < 0)
              return r;

      return read_one_line_file(p, ret);
2033}

2035int cg_get_keyed_attribute_full(
              const char *controller,
              const char *path,
              const char *attribute,
              char **keys,
              char **ret_values,
              CGroupKeyMode mode) {

      _cleanup_free___attribute__((cleanup(freep))) char *filename = NULL((void*)0), *contents = NULL((void*)0);
      const char *p;
      size_t n, i, n_done = 0;
      char **v;
      int r;

      /* Reads one or more fields of a cgroupsv2 keyed attribute file. The 'keys' parameter should be an strv with
       * all keys to retrieve. The 'ret_values' parameter should be passed as string size with the same number of
       * entries as 'keys'. On success each entry will be set to the value of the matching key.
       *
       * If the attribute file doesn't exist at all returns ENOENT, if any key is not found returns ENXIO. If mode
       * is set to GG_KEY_MODE_GRACEFUL we ignore missing keys and return those that were parsed successfully. */

      r = cg_get_path(controller, path, attribute, &filename);
      if (r < 0)
              return r;

      r = read_full_file(filename, &contents, NULL((void*)0));
      if (r < 0)
              return r;

      n = strv_length(keys);
      if (n == 0) /* No keys to retrieve? That's easy, we are done then */
              return 0;

      /* Let's build this up in a temporary array for now in order not to clobber the return parameter on failure */
      v = newa0(char*, n)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(char*), n))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
 ("!size_multiply_overflow(sizeof(char*), n)"), "../src/basic/cgroup-util.c"
, 2069, __PRETTY_FUNCTION__); } while (0); (char**) ({ char *
_new_; size_t _len_ = sizeof(char*)*(n); _new_ = __builtin_alloca
 (_len_); (void *) memset(_new_, 0, _len_); }); });

      for (p = contents; *p;) {
              const char *w = NULL((void*)0);

              for (i = 0; i < n; i++)
                      if (!v[i]) {
                              w = first_word(p, keys[i]);
                              if (w)
                                      break;
                      }

              if (w) {
                      size_t l;

                      l = strcspn(w, NEWLINE"\n\r");
                      v[i] = strndup(w, l);
                      if (!v[i]) {
                              r = -ENOMEM12;
                              goto fail;
                      }

                      n_done++;
                      if (n_done >= n)
                              goto done;

                      p = w + l;
              } else
                      p += strcspn(p, NEWLINE"\n\r");

              p += strspn(p, NEWLINE"\n\r");
      }

      if (mode & CG_KEY_MODE_GRACEFUL)
              goto done;

      r = -ENXIO6;

2107fail:
      for (i = 0; i < n; i++)
              free(v[i]);

      return r;

2113done:
      memcpy(ret_values, v, sizeof(char*) * n);
      if (mode & CG_KEY_MODE_GRACEFUL)
              return n_done;

      return 0;

2120}

2122int cg_create_everywhere(CGroupMask supported, CGroupMask mask, const char *path) {
      CGroupController c;
      bool_Bool created;
      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
       * in all others.
       *
       * Returns 0 if the group already existed in the systemd hierarchy,
       * 1 on success, negative otherwise.
       */

      /* First create the cgroup in our own hierarchy. */
      r = cg_create(SYSTEMD_CGROUP_CONTROLLER"_systemd", path);
      if (r < 0)
              return r;
      created = !!r;

      /* If we are in the unified hierarchy, we are done now */
      r = cg_all_unified();
      if (r < 0)
              return r;
      if (r > 0)
              return created;

      /* Otherwise, do the same in the other hierarchies */
      for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
              CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c)(1 << (c));
              const char *n;

              n = cgroup_controller_to_string(c);

              if (mask & bit)
                      (void) cg_create(n, path);
              else if (supported & bit)
                      (void) cg_trim(n, path, true1);
      }

      return created;
2162}

2164int cg_attach_everywhere(CGroupMask supported, const char *path, pid_t pid, cg_migrate_callback_t path_callback, void *userdata) {
      CGroupController c;
      int r;

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

      r = cg_all_unified();
      if (r < 0)
              return r;
      if (r > 0)
              return 0;

      for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
              CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c)(1 << (c));
              const char *p = NULL((void*)0);

              if (!(supported & bit))
                      continue;

              if (path_callback)
                      p = path_callback(bit, userdata);

              if (!p)
                      p = path;

              (void) cg_attach_fallback(cgroup_controller_to_string(c), p, pid);
      }

      return 0;
2195}

2197int cg_attach_many_everywhere(CGroupMask supported, const char *path, Set* pids, cg_migrate_callback_t path_callback, void *userdata) {
      Iterator i;
      void *pidp;
      int r = 0;

      SET_FOREACH(pidp, pids, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((pids), &(i), (void
**)&(pidp)); ) {
              pid_t pid = PTR_TO_PID(pidp);
              int q;

              q = cg_attach_everywhere(supported, path, pid, path_callback, userdata);
              if (q < 0 && r >= 0)
                      r = q;
      }

      return r;
2212}

2214int cg_migrate_everywhere(CGroupMask supported, const char *from, const char *to, cg_migrate_callback_t to_callback, void *userdata) {
      CGroupController c;
      int r = 0, q;

      if (!path_equal(from, to))  {
              r = cg_migrate_recursive(SYSTEMD_CGROUP_CONTROLLER"_systemd", from, SYSTEMD_CGROUP_CONTROLLER"_systemd", to, CGROUP_REMOVE);
              if (r < 0)
                      return r;
      }

      q = cg_all_unified();
      if (q < 0)
              return q;
      if (q > 0)
              return r;

      for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
              CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c)(1 << (c));
              const char *p = NULL((void*)0);

              if (!(supported & bit))
                      continue;

              if (to_callback)
                      p = to_callback(bit, userdata);

              if (!p)
                      p = to;

              (void) cg_migrate_recursive_fallback(SYSTEMD_CGROUP_CONTROLLER"_systemd", to, cgroup_controller_to_string(c), p, 0);
      }

      return 0;
2247}

2249int cg_trim_everywhere(CGroupMask supported, const char *path, bool_Bool delete_root) {
      CGroupController c;
      int r, q;

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

      q = cg_all_unified();
      if (q < 0)
              return q;
      if (q > 0)
              return r;

      for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
              CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c)(1 << (c));

              if (!(supported & bit))
                      continue;

              (void) cg_trim(cgroup_controller_to_string(c), path, delete_root);
      }

      return 0;
2273}

2275int cg_mask_to_string(CGroupMask mask, char **ret) {
      _cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);
      size_t n = 0, allocated = 0;
      bool_Bool space = false0;
      CGroupController c;

      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/cgroup-util.c", 2281
, __PRETTY_FUNCTION__); } while (0);

      if (mask == 0) {
              *ret = NULL((void*)0);
              return 0;
      }

      for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
              const char *k;
              size_t l;

              if (!(mask & CGROUP_CONTROLLER_TO_MASK(c)(1 << (c))))
                      continue;

              k = cgroup_controller_to_string(c);
              l = strlen(k);

              if (!GREEDY_REALLOC(s, allocated, n + space + l + 1)greedy_realloc((void**) &(s), &(allocated), (n + space
 + l + 1), sizeof((s)[0])))
                      return -ENOMEM12;

              if (space)
                      s[n] = ' ';
              memcpy(s + n + space, k, l);
              n += space + l;

              space = true1;
      }

      assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/basic/cgroup-util.c", 2309
, __PRETTY_FUNCTION__); } while (0);

      s[n] = 0;
      *ret = TAKE_PTR(s)({ typeof(s) _ptr_ = (s); (s) = ((void*)0); _ptr_; });

      return 0;
2315}

2317int cg_mask_from_string(const char *value, CGroupMask *mask) {
      assert(mask)do { if ((__builtin_expect(!!(!(mask)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("mask"), "../src/basic/cgroup-util.c", 2318
, __PRETTY_FUNCTION__); } while (0);
      assert(value)do { if ((__builtin_expect(!!(!(value)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("value"), "../src/basic/cgroup-util.c", 2319
, __PRETTY_FUNCTION__); } while (0);

      for (;;) {
              _cleanup_free___attribute__((cleanup(freep))) char *n = NULL((void*)0);
              CGroupController v;
              int r;

              r = extract_first_word(&value, &n, NULL((void*)0), 0);
              if (r < 0)
                      return r;
              if (r == 0)
                      break;

              v = cgroup_controller_from_string(n);
              if (v < 0)
                      continue;

              *mask |= CGROUP_CONTROLLER_TO_MASK(v)(1 << (v));
      }
      return 0;
2339}

2341int cg_mask_supported(CGroupMask *ret) {
      CGroupMask mask = 0;
      int r;

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

      r = cg_all_unified();
      if (r < 0)
              return r;
      if (r > 0) {
              _cleanup_free___attribute__((cleanup(freep))) char *root = NULL((void*)0), *controllers = NULL((void*)0), *path = NULL((void*)0);

              /* In the unified hierarchy we can read the supported
               * and accessible controllers from a the top-level
               * cgroup attribute */

              r = cg_get_root_path(&root);
              if (r < 0)
                      return r;

              r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER"_systemd", root, "cgroup.controllers", &path);
              if (r < 0)
                      return r;

              r = read_one_line_file(path, &controllers);
              if (r < 0)
                      return r;

              r = cg_mask_from_string(controllers, &mask);
              if (r < 0)
                      return r;

              /* Currently, we support the cpu, memory, io, pids and cpuset
               * controller in the unified hierarchy, mask
               * everything else off. */
              mask &= CGROUP_MASK_CPU | CGROUP_MASK_MEMORY | CGROUP_MASK_IO | CGROUP_MASK_PIDS | CGROUP_MASK_CPUSET;

      } else {
              CGroupController c;

              /* In the legacy hierarchy, we check whether which
               * hierarchies are mounted. */

              for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
                      const char *n;

                      if (c == CGROUP_CONTROLLER_CPUSET)
                              continue;

                      n = cgroup_controller_to_string(c);
                      if (controller_is_accessible(n) >= 0)
                              mask |= CGROUP_CONTROLLER_TO_MASK(c)(1 << (c));
              }
      }

      *ret = mask;
      return 0;
2400}

2402int cg_kernel_controllers(Set **ret) {
      _cleanup_set_free_free___attribute__((cleanup(set_free_freep))) Set *controllers = NULL((void*)0);
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      int r;

      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/basic/cgroup-util.c", 2407
, __PRETTY_FUNCTION__); } while (0);

      /* Determines the full list of kernel-known controllers. Might
       * include controllers we don't actually support, arbitrary
       * named hierarchies and controllers that aren't currently
       * accessible (because not mounted). */

      controllers = set_new(&string_hash_ops)internal_set_new(&string_hash_ops );
      if (!controllers)
              return -ENOMEM12;

      f = fopen("/proc/cgroups", "re");
      if (!f) {
              if (errno(*__errno_location ()) == ENOENT2) {
                      *ret = NULL((void*)0);
                      return 0;
              }

              return -errno(*__errno_location ());
      }

      (void) __fsetlocking(f, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

      /* Ignore the header line */
      (void) read_line(f, (size_t) -1, NULL((void*)0));

      for (;;) {
              char *controller;
              int enabled = 0;

              errno(*__errno_location ()) = 0;
              if (fscanf(f, "%ms %*i %*i %i", &controller, &enabled) != 2) {

                      if (feof(f))
                              break;

                      if (ferror(f) && errno(*__errno_location ()) > 0)
                              return -errno(*__errno_location ());

                      return -EBADMSG74;
              }

              if (!enabled) {
                      free(controller);
                      continue;
              }

              if (!cg_controller_is_valid(controller)) {
                      free(controller);
                      return -EBADMSG74;
              }

              r = set_consume(controllers, controller);
              if (r < 0)
                      return r;
      }

      *ret = TAKE_PTR(controllers)({ typeof(controllers) _ptr_ = (controllers); (controllers) =
 ((void*)0); _ptr_; });

      return 0;
2467}

2469static thread_local__thread CGroupUnified unified_cache = CGROUP_UNIFIED_UNKNOWN;

2471/* 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_controller(SYSTEMD_CGROUP_CONTROLLER) and %false on cg_hybrid_unified().
*/
2480static thread_local__thread bool_Bool unified_systemd_v232;

2482static int cg_unified_update(void) {

      struct statfs fs;

      /* Checks if we support the unified hierarchy. Returns an
       * error when the cgroup hierarchies aren't mounted yet or we
       * have any other trouble determining if the unified hierarchy
       * is supported. */

      if (unified_cache >= CGROUP_UNIFIED_NONE)
              return 0;

      if (statfs("/sys/fs/cgroup/", &fs) < 0)
              return log_debug_errno(errno, "statfs(\"/sys/fs/cgroup/\") failed: %m")({ int _level = ((7)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/basic/cgroup-util.c", 2495, __func__
, "statfs(\"/sys/fs/cgroup/\") failed: %m") : -abs(_e); });

      if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)(fs.f_type == (typeof(fs.f_type)) 0x63677270)) {
              log_debug("Found cgroup2 on /sys/fs/cgroup/, full unified hierarchy")({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2498, __func__, "Found cgroup2 on /sys/fs/cgroup/, full unified hierarchy"
) : -abs(_e); });
              unified_cache = CGROUP_UNIFIED_ALL;
      } else if (F_TYPE_EQUAL(fs.f_type, TMPFS_MAGIC)(fs.f_type == (typeof(fs.f_type)) 0x01021994)) {
              if (statfs("/sys/fs/cgroup/unified/", &fs) == 0 &&
                  F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)(fs.f_type == (typeof(fs.f_type)) 0x63677270)) {
                      log_debug("Found cgroup2 on /sys/fs/cgroup/unified, unified hierarchy for systemd controller")({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2503, __func__, "Found cgroup2 on /sys/fs/cgroup/unified, unified hierarchy for systemd controller"
) : -abs(_e); });
                      unified_cache = CGROUP_UNIFIED_SYSTEMD;
                      unified_systemd_v232 = false0;
              } else {
                      if (statfs("/sys/fs/cgroup/systemd/", &fs) < 0)
                              return log_debug_errno(errno, "statfs(\"/sys/fs/cgroup/systemd\" failed: %m")({ int _level = ((7)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/basic/cgroup-util.c", 2508, __func__
, "statfs(\"/sys/fs/cgroup/systemd\" failed: %m") : -abs(_e);
 });

                      if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)(fs.f_type == (typeof(fs.f_type)) 0x63677270)) {
                              log_debug("Found cgroup2 on /sys/fs/cgroup/systemd, unified hierarchy for systemd controller (v232 variant)")({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2511, __func__, "Found cgroup2 on /sys/fs/cgroup/systemd, unified hierarchy for systemd controller (v232 variant)"
) : -abs(_e); });
                              unified_cache = CGROUP_UNIFIED_SYSTEMD;
                              unified_systemd_v232 = true1;
                      } else if (F_TYPE_EQUAL(fs.f_type, CGROUP_SUPER_MAGIC)(fs.f_type == (typeof(fs.f_type)) 0x27e0eb)) {
                              log_debug("Found cgroup on /sys/fs/cgroup/systemd, legacy hierarchy")({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2515, __func__, "Found cgroup on /sys/fs/cgroup/systemd, legacy hierarchy"
) : -abs(_e); });
                              unified_cache = CGROUP_UNIFIED_NONE;
                      } else {
                              log_debug("Unexpected filesystem type %llx mounted on /sys/fs/cgroup/systemd, assuming legacy hierarchy",({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2519, __func__, "Unexpected filesystem type %llx mounted on /sys/fs/cgroup/systemd, assuming legacy hierarchy"
, (unsigned long long) fs.f_type) : -abs(_e); })
                                        (unsigned long long) fs.f_type)({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2519, __func__, "Unexpected filesystem type %llx mounted on /sys/fs/cgroup/systemd, assuming legacy hierarchy"
, (unsigned long long) fs.f_type) : -abs(_e); });
                              unified_cache = CGROUP_UNIFIED_NONE;
                      }
              }
      } else {
              log_debug("Unknown filesystem type %llx mounted on /sys/fs/cgroup.",({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2525, __func__, "Unknown filesystem type %llx mounted on /sys/fs/cgroup."
, (unsigned long long) fs.f_type) : -abs(_e); })
                        (unsigned long long) fs.f_type)({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2525, __func__, "Unknown filesystem type %llx mounted on /sys/fs/cgroup."
, (unsigned long long) fs.f_type) : -abs(_e); });
              return -ENOMEDIUM123;
      }

      return 0;
2530}

2532int cg_unified_controller(const char *controller) {
      int r;

      r = cg_unified_update();
      if (r < 0)
              return r;

      if (unified_cache == CGROUP_UNIFIED_NONE)
              return false0;

      if (unified_cache >= CGROUP_UNIFIED_ALL)
              return true1;

      return streq_ptr(controller, SYSTEMD_CGROUP_CONTROLLER"_systemd");
2546}

2548int cg_all_unified(void) {
      int r;

      r = cg_unified_update();
      if (r < 0)
              return r;

      return unified_cache >= CGROUP_UNIFIED_ALL;
2556}

2558int cg_hybrid_unified(void) {
      int r;

      r = cg_unified_update();
      if (r < 0)
              return r;

      return unified_cache == CGROUP_UNIFIED_SYSTEMD && !unified_systemd_v232;
2566}

2568int cg_unified_flush(void) {
      unified_cache = CGROUP_UNIFIED_UNKNOWN;

      return cg_unified_update();
2572}

2574int cg_enable_everywhere(CGroupMask supported, CGroupMask mask, const char *p) {
      _cleanup_fclose___attribute__((cleanup(fclosep))) FILE *f = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *fs = NULL((void*)0);
      CGroupController c;
      int r;

      assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/basic/cgroup-util.c", 2580
, __PRETTY_FUNCTION__); } while (0);

      if (supported == 0)
              return 0;

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

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

      for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
              CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c)(1 << (c));
              const char *n;

              if (!(supported & bit))
                      continue;

              n = cgroup_controller_to_string(c);
              {
                      char s[1 + strlen(n) + 1];

                      s[0] = mask & bit ? '+' : '-';
                      strcpy(s + 1, n);

                      if (!f) {
                              f = fopen(fs, "we");
                              if (!f) {
                                      log_debug_errno(errno, "Failed to open cgroup.subtree_control file of %s: %m", p)({ int _level = ((7)), _e = (((*__errno_location ()))), _realm
 = (LOG_REALM_SYSTEMD); (log_get_max_level_realm(_realm) >=
 ((_level) & 0x07)) ? log_internal_realm(((_realm) <<
| (_level)), _e, "../src/basic/cgroup-util.c", 2612, __func__
, "Failed to open cgroup.subtree_control file of %s: %m", p) :
 -abs(_e); });
                                      break;
                              }
                      }

                      r = write_string_stream(f, s, 0);
                      if (r < 0) {
                              log_debug_errno(r, "Failed to enable controller %s for %s (%s): %m", n, p, fs)({ int _level = ((7)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/basic/cgroup-util.c", 2619, __func__, "Failed to enable controller %s for %s (%s): %m"
, n, p, fs) : -abs(_e); });
                              clearerr(f);
                      }
              }
      }

      return 0;
2626}

2628bool_Bool cg_is_unified_wanted(void) {
      static thread_local__thread int wanted = -1;
      int r;
      bool_Bool b;
      const bool_Bool is_default = DEFAULT_HIERARCHYCGROUP_UNIFIED_SYSTEMD == CGROUP_UNIFIED_ALL;

      /* If we have a cached value, return that. */
      if (wanted >= 0)
              return wanted;

      /* If the hierarchy is already mounted, then follow whatever
       * was chosen for it. */
      if (cg_unified_flush() >= 0)
              return (wanted = unified_cache >= CGROUP_UNIFIED_ALL);

      /* 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);

      return (wanted = r > 0 ? b : is_default);
2648}

2650bool_Bool cg_is_legacy_wanted(void) {
      static thread_local__thread int wanted = -1;

      /* If we have a cached value, return that. */
      if (wanted >= 0)
              return wanted;

      /* Check if we have cgroups2 already mounted. */
      if (cg_unified_flush() >= 0 &&
          unified_cache == CGROUP_UNIFIED_ALL)
              return (wanted = false0);

      /* Otherwise, assume that at least partial legacy is wanted,
       * since cgroups2 should already be mounted at this point. */
      return (wanted = true1);
2665}

2667bool_Bool cg_is_hybrid_wanted(void) {
      static thread_local__thread int wanted = -1;
      int r;
      bool_Bool b;
      const bool_Bool is_default = DEFAULT_HIERARCHYCGROUP_UNIFIED_SYSTEMD >= CGROUP_UNIFIED_SYSTEMD;
      /* We default to true if the default is "hybrid", obviously,
       * but also when the default is "unified", because if we get
       * called, it means that unified hierarchy was not mounted. */

      /* If we have a cached value, return that. */
      if (wanted >= 0)
              return wanted;

      /* If the hierarchy is already mounted, then follow whatever
       * was chosen for it. */
      if (cg_unified_flush() >= 0 &&
          unified_cache == CGROUP_UNIFIED_ALL)
              return (wanted = false0);

      /* 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);

      /* The meaning of the kernel option is reversed wrt. to the return value
       * of this function, hence the negation. */
      return (wanted = r > 0 ? !b : is_default);
2693}

2695int cg_weight_parse(const char *s, uint64_t *ret) {
      uint64_t u;
      int r;

      if (isempty(s)) {
              *ret = CGROUP_WEIGHT_INVALID((uint64_t) -1);
              return 0;
      }

      r = safe_atou64(s, &u);
      if (r < 0)
              return r;

      if (u < CGROUP_WEIGHT_MIN1UL || u > CGROUP_WEIGHT_MAX10000UL)
              return -ERANGE34;

      *ret = u;
      return 0;
2713}

2715const uint64_t cgroup_io_limit_defaults[_CGROUP_IO_LIMIT_TYPE_MAX] = {
      [CGROUP_IO_RBPS_MAX]    = CGROUP_LIMIT_MAX((uint64_t) -1),
      [CGROUP_IO_WBPS_MAX]    = CGROUP_LIMIT_MAX((uint64_t) -1),
      [CGROUP_IO_RIOPS_MAX]   = CGROUP_LIMIT_MAX((uint64_t) -1),
      [CGROUP_IO_WIOPS_MAX]   = CGROUP_LIMIT_MAX((uint64_t) -1),
2720};

2722static const char* const cgroup_io_limit_type_table[_CGROUP_IO_LIMIT_TYPE_MAX] = {
      [CGROUP_IO_RBPS_MAX]    = "IOReadBandwidthMax",
      [CGROUP_IO_WBPS_MAX]    = "IOWriteBandwidthMax",
      [CGROUP_IO_RIOPS_MAX]   = "IOReadIOPSMax",
      [CGROUP_IO_WIOPS_MAX]   = "IOWriteIOPSMax",
2727};

2729DEFINE_STRING_TABLE_LOOKUP(cgroup_io_limit_type, CGroupIOLimitType)const char *cgroup_io_limit_type_to_string(CGroupIOLimitType i
) { if (i < 0 || i >= (CGroupIOLimitType) __extension__
 (__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(cgroup_io_limit_type_table), typeof(&*(cgroup_io_limit_type_table
))), sizeof(cgroup_io_limit_type_table)/sizeof((cgroup_io_limit_type_table
)[0]), ((void)0)))) return ((void*)0); return cgroup_io_limit_type_table
[i]; } CGroupIOLimitType cgroup_io_limit_type_from_string(const
 char *s) { return (CGroupIOLimitType) string_table_lookup(cgroup_io_limit_type_table
, __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(cgroup_io_limit_type_table), typeof(&*(cgroup_io_limit_type_table
))), sizeof(cgroup_io_limit_type_table)/sizeof((cgroup_io_limit_type_table
)[0]), ((void)0))), s); };

2731int cg_cpu_shares_parse(const char *s, uint64_t *ret) {
      uint64_t u;
      int r;

      if (isempty(s)) {
              *ret = CGROUP_CPU_SHARES_INVALID((uint64_t) -1);
              return 0;
      }

      r = safe_atou64(s, &u);
      if (r < 0)
              return r;

      if (u < CGROUP_CPU_SHARES_MIN2UL || u > CGROUP_CPU_SHARES_MAX262144UL)
              return -ERANGE34;

      *ret = u;
      return 0;
2749}

2751int cg_blkio_weight_parse(const char *s, uint64_t *ret) {
      uint64_t u;
      int r;

      if (isempty(s)) {
              *ret = CGROUP_BLKIO_WEIGHT_INVALID((uint64_t) -1);
              return 0;
      }

      r = safe_atou64(s, &u);
      if (r < 0)
              return r;

      if (u < CGROUP_BLKIO_WEIGHT_MIN10UL || u > CGROUP_BLKIO_WEIGHT_MAX1000UL)
              return -ERANGE34;

      *ret = u;
      return 0;
2769}

2771bool_Bool is_cgroup_fs(const struct statfs *s) {
      return is_fs_type(s, CGROUP_SUPER_MAGIC0x27e0eb) ||
             is_fs_type(s, CGROUP2_SUPER_MAGIC0x63677270);
2774}

2776bool_Bool fd_is_cgroup_fs(int fd) {
      struct statfs s;

      if (fstatfs(fd, &s) < 0)
              return -errno(*__errno_location ());

      return is_cgroup_fs(&s);
2783}

2785static const char *cgroup_controller_table[_CGROUP_CONTROLLER_MAX] = {
      [CGROUP_CONTROLLER_CPU] = "cpu",
      [CGROUP_CONTROLLER_CPUACCT] = "cpuacct",
      [CGROUP_CONTROLLER_CPUSET] = "cpuset",
      [CGROUP_CONTROLLER_IO] = "io",
      [CGROUP_CONTROLLER_BLKIO] = "blkio",
      [CGROUP_CONTROLLER_MEMORY] = "memory",
      [CGROUP_CONTROLLER_DEVICES] = "devices",
      [CGROUP_CONTROLLER_PIDS] = "pids",
2794};

2796DEFINE_STRING_TABLE_LOOKUP(cgroup_controller, CGroupController)const char *cgroup_controller_to_string(CGroupController i) {
 if (i < 0 || i >= (CGroupController) __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(cgroup_controller_table
), typeof(&*(cgroup_controller_table))), sizeof(cgroup_controller_table
)/sizeof((cgroup_controller_table)[0]), ((void)0)))) return (
(void*)0); return cgroup_controller_table[i]; } CGroupController
 cgroup_controller_from_string(const char *s) { return (CGroupController
) string_table_lookup(cgroup_controller_table, __extension__ (
__builtin_choose_expr( !__builtin_types_compatible_p(typeof(cgroup_controller_table
), typeof(&*(cgroup_controller_table))), sizeof(cgroup_controller_table
)/sizeof((cgroup_controller_table)[0]), ((void)0))), s); };