src/basic/cgroup-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <ftw.h>
   5 #include <limits.h>
   6 #include <signal.h>
   7 #include <stddef.h>
   8 #include <stdlib.h>
   9 #include <sys/types.h>
  10 #include <sys/utsname.h>
  11 #include <sys/xattr.h>
  12 #include <unistd.h>
  13
  14 #include "alloc-util.h"
  15 #include "cgroup-util.h"
  16 #include "def.h"
  17 #include "dirent-util.h"
  18 #include "extract-word.h"
  19 #include "fd-util.h"
  20 #include "fileio.h"
  21 #include "format-util.h"
  22 #include "fs-util.h"
  23 #include "log.h"
  24 #include "login-util.h"
  25 #include "macro.h"
  26 #include "missing_magic.h"
  27 #include "mkdir.h"
  28 #include "parse-util.h"
  29 #include "path-util.h"
  30 #include "process-util.h"
  31 #include "set.h"
  32 #include "special.h"
  33 #include "stat-util.h"
  34 #include "stdio-util.h"
  35 #include "string-table.h"
  36 #include "string-util.h"
  37 #include "strv.h"
  38 #include "unit-name.h"
  39 #include "user-util.h"
  40
  41 static int cg_enumerate_items(const char *controller, const char *path, FILE **_f, const char *item) {
  42         _cleanup_free_ char *fs = NULL;
  43         FILE *f;
  44         int r;
  45
  46         assert(_f);
  47
  48         r = cg_get_path(controller, path, item, &fs);
  49         if (r < 0)
  50                 return r;
  51
  52         f = fopen(fs, "re");
  53         if (!f)
  54                 return -errno;
  55
  56         *_f = f;
  57         return 0;
  58 }
  59
  60 int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {
  61         return cg_enumerate_items(controller, path, _f, "cgroup.procs");
  62 }
  63
  64 int cg_read_pid(FILE *f, pid_t *_pid) {
  65         unsigned long ul;
  66
  67         /* Note that the cgroup.procs might contain duplicates! See
  68          * cgroups.txt for details. */
  69
  70         assert(f);
  71         assert(_pid);
  72
  73         errno = 0;
  74         if (fscanf(f, "%lu", &ul) != 1) {
  75
  76                 if (feof(f))
  77                         return 0;
  78
  79                 return errno_or_else(EIO);
  80         }
  81
  82         if (ul <= 0)
  83                 return -EIO;
  84
  85         *_pid = (pid_t) ul;
  86         return 1;
  87 }
  88
  89 int cg_read_event(
  90                 const char *controller,
  91                 const char *path,
  92                 const char *event,
  93                 char **ret) {
  94
  95         _cleanup_free_ char *events = NULL, *content = NULL;
  96         int r;
  97
  98         r = cg_get_path(controller, path, "cgroup.events", &events);
  99         if (r < 0)
 100                 return r;
 101
 102         r = read_full_file(events, &content, NULL);
 103         if (r < 0)
 104                 return r;
 105
 106         for (const char *p = content;;) {
 107                 _cleanup_free_ char *line = NULL, *key = NULL, *val = NULL;
 108                 const char *q;
 109
 110                 r = extract_first_word(&p, &line, "\n", 0);
 111                 if (r < 0)
 112                         return r;
 113                 if (r == 0)
 114                         return -ENOENT;
 115
 116                 q = line;
 117                 r = extract_first_word(&q, &key, " ", 0);
 118                 if (r < 0)
 119                         return r;
 120                 if (r == 0)
 121                         return -EINVAL;
 122
 123                 if (!streq(key, event))
 124                         continue;
 125
 126                 val = strdup(q);
 127                 if (!val)
 128                         return -ENOMEM;
 129
 130                 *ret = TAKE_PTR(val);
 131                 return 0;
 132         }
 133 }
 134
 135 bool cg_ns_supported(void) {
 136         static thread_local int enabled = -1;
 137
 138         if (enabled >= 0)
 139                 return enabled;
 140
 141         if (access("/proc/self/ns/cgroup", F_OK) < 0) {
 142                 if (errno != ENOENT)
 143                         log_debug_errno(errno, "Failed to check whether /proc/self/ns/cgroup is available, assuming not: %m");
 144                 enabled = false;
 145         } else
 146                 enabled = true;
 147
 148         return enabled;
 149 }
 150
 151 int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {
 152         _cleanup_free_ char *fs = NULL;
 153         int r;
 154         DIR *d;
 155
 156         assert(_d);
 157
 158         /* This is not recursive! */
 159
 160         r = cg_get_path(controller, path, NULL, &fs);
 161         if (r < 0)
 162                 return r;
 163
 164         d = opendir(fs);
 165         if (!d)
 166                 return -errno;
 167
 168         *_d = d;
 169         return 0;
 170 }
 171
 172 int cg_read_subgroup(DIR *d, char **fn) {
 173         struct dirent *de;
 174
 175         assert(d);
 176         assert(fn);
 177
 178         FOREACH_DIRENT_ALL(de, d, return -errno) {
 179                 char *b;
 180
 181                 if (de->d_type != DT_DIR)
 182                         continue;
 183
 184                 if (dot_or_dot_dot(de->d_name))
 185                         continue;
 186
 187                 b = strdup(de->d_name);
 188                 if (!b)
 189                         return -ENOMEM;
 190
 191                 *fn = b;
 192                 return 1;
 193         }
 194
 195         return 0;
 196 }
 197
 198 int cg_rmdir(const char *controller, const char *path) {
 199         _cleanup_free_ char *p = NULL;
 200         int r;
 201
 202         r = cg_get_path(controller, path, NULL, &p);
 203         if (r < 0)
 204                 return r;
 205
 206         r = rmdir(p);
 207         if (r < 0 && errno != ENOENT)
 208                 return -errno;
 209
 210         r = cg_hybrid_unified();
 211         if (r <= 0)
 212                 return r;
 213
 214         if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
 215                 r = cg_rmdir(SYSTEMD_CGROUP_CONTROLLER_LEGACY, path);
 216                 if (r < 0)
 217                         log_warning_errno(r, "Failed to remove compat systemd cgroup %s: %m", path);
 218         }
 219
 220         return 0;
 221 }
 222
 223 static int cg_kill_items(
 224                 const char *controller,
 225                 const char *path,
 226                 int sig,
 227                 CGroupFlags flags,
 228                 Set *s,
 229                 cg_kill_log_func_t log_kill,
 230                 void *userdata,
 231                 const char *item) {
 232
 233         _cleanup_set_free_ Set *allocated_set = NULL;
 234         bool done = false;
 235         int r, ret = 0, ret_log_kill = 0;
 236         pid_t my_pid;
 237
 238         assert(sig >= 0);
 239
 240          /* Don't send SIGCONT twice. Also, SIGKILL always works even when process is suspended, hence don't send
 241           * SIGCONT on SIGKILL. */
 242         if (IN_SET(sig, SIGCONT, SIGKILL))
 243                 flags &= ~CGROUP_SIGCONT;
 244
 245         /* This goes through the tasks list and kills them all. This
 246          * is repeated until no further processes are added to the
 247          * tasks list, to properly handle forking processes */
 248
 249         if (!s) {
 250                 s = allocated_set = set_new(NULL);
 251                 if (!s)
 252                         return -ENOMEM;
 253         }
 254
 255         my_pid = getpid_cached();
 256
 257         do {
 258                 _cleanup_fclose_ FILE *f = NULL;
 259                 pid_t pid = 0;
 260                 done = true;
 261
 262                 r = cg_enumerate_items(controller, path, &f, item);
 263                 if (r < 0) {
 264                         if (ret >= 0 && r != -ENOENT)
 265                                 return r;
 266
 267                         return ret;
 268                 }
 269
 270                 while ((r = cg_read_pid(f, &pid)) > 0) {
 271
 272                         if ((flags & CGROUP_IGNORE_SELF) && pid == my_pid)
 273                                 continue;
 274
 275                         if (set_get(s, PID_TO_PTR(pid)) == PID_TO_PTR(pid))
 276                                 continue;
 277
 278                         if (log_kill)
 279                                 ret_log_kill = log_kill(pid, sig, userdata);
 280
 281                         /* If we haven't killed this process yet, kill
 282                          * it */
 283                         if (kill(pid, sig) < 0) {
 284                                 if (ret >= 0 && errno != ESRCH)
 285                                         ret = -errno;
 286                         } else {
 287                                 if (flags & CGROUP_SIGCONT)
 288                                         (void) kill(pid, SIGCONT);
 289
 290                                 if (ret == 0) {
 291                                         if (log_kill)
 292                                                 ret = ret_log_kill;
 293                                         else
 294                                                 ret = 1;
 295                                 }
 296                         }
 297
 298                         done = false;
 299
 300                         r = set_put(s, PID_TO_PTR(pid));
 301                         if (r < 0) {
 302                                 if (ret >= 0)
 303                                         return r;
 304
 305                                 return ret;
 306                         }
 307                 }
 308
 309                 if (r < 0) {
 310                         if (ret >= 0)
 311                                 return r;
 312
 313                         return ret;
 314                 }
 315
 316                 /* To avoid racing against processes which fork
 317                  * quicker than we can kill them we repeat this until
 318                  * no new pids need to be killed. */
 319
 320         } while (!done);
 321
 322         return ret;
 323 }
 324
 325 int cg_kill(
 326                 const char *controller,
 327                 const char *path,
 328                 int sig,
 329                 CGroupFlags flags,
 330                 Set *s,
 331                 cg_kill_log_func_t log_kill,
 332                 void *userdata) {
 333         int r;
 334
 335         r = cg_kill_items(controller, path, sig, flags, s, log_kill, userdata, "cgroup.procs");
 336         if (r < 0 || sig != SIGKILL)
 337                 return r;
 338
 339         /* Only in case of killing with SIGKILL and when using cgroupsv2, kill remaining threads manually as
 340            a workaround for kernel bug. It was fixed in 5.2-rc5 (c03cd7738a83), backported to 4.19.66
 341            (4340d175b898) and 4.14.138 (feb6b123b7dd). */
 342         r = cg_unified_controller(controller);
 343         if (r <= 0)
 344                 return r;
 345
 346         return cg_kill_items(controller, path, sig, flags, s, log_kill, userdata, "cgroup.threads");
 347 }
 348
 349 int cg_kill_recursive(
 350                 const char *controller,
 351                 const char *path,
 352                 int sig,
 353                 CGroupFlags flags,
 354                 Set *s,
 355                 cg_kill_log_func_t log_kill,
 356                 void *userdata) {
 357
 358         _cleanup_set_free_ Set *allocated_set = NULL;
 359         _cleanup_closedir_ DIR *d = NULL;
 360         int r, ret;
 361         char *fn;
 362
 363         assert(path);
 364         assert(sig >= 0);
 365
 366         if (!s) {
 367                 s = allocated_set = set_new(NULL);
 368                 if (!s)
 369                         return -ENOMEM;
 370         }
 371
 372         ret = cg_kill(controller, path, sig, flags, s, log_kill, userdata);
 373
 374         r = cg_enumerate_subgroups(controller, path, &d);
 375         if (r < 0) {
 376                 if (ret >= 0 && r != -ENOENT)
 377                         return r;
 378
 379                 return ret;
 380         }
 381
 382         while ((r = cg_read_subgroup(d, &fn)) > 0) {
 383                 _cleanup_free_ char *p = NULL;
 384
 385                 p = path_join(empty_to_root(path), fn);
 386                 free(fn);
 387                 if (!p)
 388                         return -ENOMEM;
 389
 390                 r = cg_kill_recursive(controller, p, sig, flags, s, log_kill, userdata);
 391                 if (r != 0 && ret >= 0)
 392                         ret = r;
 393         }
 394         if (ret >= 0 && r < 0)
 395                 ret = r;
 396
 397         if (flags & CGROUP_REMOVE) {
 398                 r = cg_rmdir(controller, path);
 399                 if (r < 0 && ret >= 0 && !IN_SET(r, -ENOENT, -EBUSY))
 400                         return r;
 401         }
 402
 403         return ret;
 404 }
 405
 406 static const char *controller_to_dirname(const char *controller) {
 407         const char *e;
 408
 409         assert(controller);
 410
 411         /* Converts a controller name to the directory name below
 412          * /sys/fs/cgroup/ we want to mount it to. Effectively, this
 413          * just cuts off the name= prefixed used for named
 414          * hierarchies, if it is specified. */
 415
 416         if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
 417                 if (cg_hybrid_unified() > 0)
 418                         controller = SYSTEMD_CGROUP_CONTROLLER_HYBRID;
 419                 else
 420                         controller = SYSTEMD_CGROUP_CONTROLLER_LEGACY;
 421         }
 422
 423         e = startswith(controller, "name=");
 424         if (e)
 425                 return e;
 426
 427         return controller;
 428 }
 429
 430 static int join_path_legacy(const char *controller, const char *path, const char *suffix, char **fs) {
 431         const char *dn;
 432         char *t = NULL;
 433
 434         assert(fs);
 435         assert(controller);
 436
 437         dn = controller_to_dirname(controller);
 438
 439         if (isempty(path) && isempty(suffix))
 440                 t = path_join("/sys/fs/cgroup", dn);
 441         else if (isempty(path))
 442                 t = path_join("/sys/fs/cgroup", dn, suffix);
 443         else if (isempty(suffix))
 444                 t = path_join("/sys/fs/cgroup", dn, path);
 445         else
 446                 t = path_join("/sys/fs/cgroup", dn, path, suffix);
 447         if (!t)
 448                 return -ENOMEM;
 449
 450         *fs = t;
 451         return 0;
 452 }
 453
 454 static int join_path_unified(const char *path, const char *suffix, char **fs) {
 455         char *t;
 456
 457         assert(fs);
 458
 459         if (isempty(path) && isempty(suffix))
 460                 t = strdup("/sys/fs/cgroup");
 461         else if (isempty(path))
 462                 t = path_join("/sys/fs/cgroup", suffix);
 463         else if (isempty(suffix))
 464                 t = path_join("/sys/fs/cgroup", path);
 465         else
 466                 t = path_join("/sys/fs/cgroup", path, suffix);
 467         if (!t)
 468                 return -ENOMEM;
 469
 470         *fs = t;
 471         return 0;
 472 }
 473
 474 int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {
 475         int r;
 476
 477         assert(fs);
 478
 479         if (!controller) {
 480                 char *t;
 481
 482                 /* If no controller is specified, we return the path
 483                  * *below* the controllers, without any prefix. */
 484
 485                 if (!path && !suffix)
 486                         return -EINVAL;
 487
 488                 if (!suffix)
 489                         t = strdup(path);
 490                 else if (!path)
 491                         t = strdup(suffix);
 492                 else
 493                         t = path_join(path, suffix);
 494                 if (!t)
 495                         return -ENOMEM;
 496
 497                 *fs = path_simplify(t, false);
 498                 return 0;
 499         }
 500
 501         if (!cg_controller_is_valid(controller))
 502                 return -EINVAL;
 503
 504         r = cg_all_unified();
 505         if (r < 0)
 506                 return r;
 507         if (r > 0)
 508                 r = join_path_unified(path, suffix, fs);
 509         else
 510                 r = join_path_legacy(controller, path, suffix, fs);
 511         if (r < 0)
 512                 return r;
 513
 514         path_simplify(*fs, false);
 515         return 0;
 516 }
 517
 518 static int controller_is_accessible(const char *controller) {
 519         int r;
 520
 521         assert(controller);
 522
 523         /* Checks whether a specific controller is accessible,
 524          * i.e. its hierarchy mounted. In the unified hierarchy all
 525          * controllers are considered accessible, except for the named
 526          * hierarchies */
 527
 528         if (!cg_controller_is_valid(controller))
 529                 return -EINVAL;
 530
 531         r = cg_all_unified();
 532         if (r < 0)
 533                 return r;
 534         if (r > 0) {
 535                 /* We don't support named hierarchies if we are using
 536                  * the unified hierarchy. */
 537
 538                 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
 539                         return 0;
 540
 541                 if (startswith(controller, "name="))
 542                         return -EOPNOTSUPP;
 543
 544         } else {
 545                 const char *cc, *dn;
 546
 547                 dn = controller_to_dirname(controller);
 548                 cc = strjoina("/sys/fs/cgroup/", dn);
 549
 550                 if (laccess(cc, F_OK) < 0)
 551                         return -errno;
 552         }
 553
 554         return 0;
 555 }
 556
 557 int cg_get_path_and_check(const char *controller, const char *path, const char *suffix, char **fs) {
 558         int r;
 559
 560         assert(controller);
 561         assert(fs);
 562
 563         /* Check if the specified controller is actually accessible */
 564         r = controller_is_accessible(controller);
 565         if (r < 0)
 566                 return r;
 567
 568         return cg_get_path(controller, path, suffix, fs);
 569 }
 570
 571 int cg_set_xattr(const char *controller, const char *path, const char *name, const void *value, size_t size, int flags) {
 572         _cleanup_free_ char *fs = NULL;
 573         int r;
 574
 575         assert(path);
 576         assert(name);
 577         assert(value || size <= 0);
 578
 579         r = cg_get_path(controller, path, NULL, &fs);
 580         if (r < 0)
 581                 return r;
 582
 583         if (setxattr(fs, name, value, size, flags) < 0)
 584                 return -errno;
 585
 586         return 0;
 587 }
 588
 589 int cg_get_xattr(const char *controller, const char *path, const char *name, void *value, size_t size) {
 590         _cleanup_free_ char *fs = NULL;
 591         ssize_t n;
 592         int r;
 593
 594         assert(path);
 595         assert(name);
 596
 597         r = cg_get_path(controller, path, NULL, &fs);
 598         if (r < 0)
 599                 return r;
 600
 601         n = getxattr(fs, name, value, size);
 602         if (n < 0)
 603                 return -errno;
 604
 605         return (int) n;
 606 }
 607
 608 int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
 609         _cleanup_fclose_ FILE *f = NULL;
 610         const char *fs, *controller_str;
 611         int unified, r;
 612         size_t cs = 0;
 613
 614         assert(path);
 615         assert(pid >= 0);
 616
 617         if (controller) {
 618                 if (!cg_controller_is_valid(controller))
 619                         return -EINVAL;
 620         } else
 621                 controller = SYSTEMD_CGROUP_CONTROLLER;
 622
 623         unified = cg_unified_controller(controller);
 624         if (unified < 0)
 625                 return unified;
 626         if (unified == 0) {
 627                 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
 628                         controller_str = SYSTEMD_CGROUP_CONTROLLER_LEGACY;
 629                 else
 630                         controller_str = controller;
 631
 632                 cs = strlen(controller_str);
 633         }
 634
 635         fs = procfs_file_alloca(pid, "cgroup");
 636         r = fopen_unlocked(fs, "re", &f);
 637         if (r == -ENOENT)
 638                 return -ESRCH;
 639         if (r < 0)
 640                 return r;
 641
 642         for (;;) {
 643                 _cleanup_free_ char *line = NULL;
 644                 char *e, *p;
 645
 646                 r = read_line(f, LONG_LINE_MAX, &line);
 647                 if (r < 0)
 648                         return r;
 649                 if (r == 0)
 650                         break;
 651
 652                 if (unified) {
 653                         e = startswith(line, "0:");
 654                         if (!e)
 655                                 continue;
 656
 657                         e = strchr(e, ':');
 658                         if (!e)
 659                                 continue;
 660                 } else {
 661                         char *l;
 662                         size_t k;
 663                         const char *word, *state;
 664                         bool found = false;
 665
 666                         l = strchr(line, ':');
 667                         if (!l)
 668                                 continue;
 669
 670                         l++;
 671                         e = strchr(l, ':');
 672                         if (!e)
 673                                 continue;
 674
 675                         *e = 0;
 676                         FOREACH_WORD_SEPARATOR(word, k, l, ",", state)
 677                                 if (k == cs && memcmp(word, controller_str, cs) == 0) {
 678                                         found = true;
 679                                         break;
 680                                 }
 681                         if (!found)
 682                                 continue;
 683                 }
 684
 685                 p = strdup(e + 1);
 686                 if (!p)
 687                         return -ENOMEM;
 688
 689                 /* Truncate suffix indicating the process is a zombie */
 690                 e = endswith(p, " (deleted)");
 691                 if (e)
 692                         *e = 0;
 693
 694                 *path = p;
 695                 return 0;
 696         }
 697
 698         return -ENODATA;
 699 }
 700
 701 int cg_install_release_agent(const char *controller, const char *agent) {
 702         _cleanup_free_ char *fs = NULL, *contents = NULL;
 703         const char *sc;
 704         int r;
 705
 706         assert(agent);
 707
 708         r = cg_unified_controller(controller);
 709         if (r < 0)
 710                 return r;
 711         if (r > 0) /* doesn't apply to unified hierarchy */
 712                 return -EOPNOTSUPP;
 713
 714         r = cg_get_path(controller, NULL, "release_agent", &fs);
 715         if (r < 0)
 716                 return r;
 717
 718         r = read_one_line_file(fs, &contents);
 719         if (r < 0)
 720                 return r;
 721
 722         sc = strstrip(contents);
 723         if (isempty(sc)) {
 724                 r = write_string_file(fs, agent, WRITE_STRING_FILE_DISABLE_BUFFER);
 725                 if (r < 0)
 726                         return r;
 727         } else if (!path_equal(sc, agent))
 728                 return -EEXIST;
 729
 730         fs = mfree(fs);
 731         r = cg_get_path(controller, NULL, "notify_on_release", &fs);
 732         if (r < 0)
 733                 return r;
 734
 735         contents = mfree(contents);
 736         r = read_one_line_file(fs, &contents);
 737         if (r < 0)
 738                 return r;
 739
 740         sc = strstrip(contents);
 741         if (streq(sc, "0")) {
 742                 r = write_string_file(fs, "1", WRITE_STRING_FILE_DISABLE_BUFFER);
 743                 if (r < 0)
 744                         return r;
 745
 746                 return 1;
 747         }
 748
 749         if (!streq(sc, "1"))
 750                 return -EIO;
 751
 752         return 0;
 753 }
 754
 755 int cg_uninstall_release_agent(const char *controller) {
 756         _cleanup_free_ char *fs = NULL;
 757         int r;
 758
 759         r = cg_unified_controller(controller);
 760         if (r < 0)
 761                 return r;
 762         if (r > 0) /* Doesn't apply to unified hierarchy */
 763                 return -EOPNOTSUPP;
 764
 765         r = cg_get_path(controller, NULL, "notify_on_release", &fs);
 766         if (r < 0)
 767                 return r;
 768
 769         r = write_string_file(fs, "0", WRITE_STRING_FILE_DISABLE_BUFFER);
 770         if (r < 0)
 771                 return r;
 772
 773         fs = mfree(fs);
 774
 775         r = cg_get_path(controller, NULL, "release_agent", &fs);
 776         if (r < 0)
 777                 return r;
 778
 779         r = write_string_file(fs, "", WRITE_STRING_FILE_DISABLE_BUFFER);
 780         if (r < 0)
 781                 return r;
 782
 783         return 0;
 784 }
 785
 786 int cg_is_empty(const char *controller, const char *path) {
 787         _cleanup_fclose_ FILE *f = NULL;
 788         pid_t pid;
 789         int r;
 790
 791         assert(path);
 792
 793         r = cg_enumerate_processes(controller, path, &f);
 794         if (r == -ENOENT)
 795                 return true;
 796         if (r < 0)
 797                 return r;
 798
 799         r = cg_read_pid(f, &pid);
 800         if (r < 0)
 801                 return r;
 802
 803         return r == 0;
 804 }
 805
 806 int cg_is_empty_recursive(const char *controller, const char *path) {
 807         int r;
 808
 809         assert(path);
 810
 811         /* The root cgroup is always populated */
 812         if (controller && empty_or_root(path))
 813                 return false;
 814
 815         r = cg_unified_controller(controller);
 816         if (r < 0)
 817                 return r;
 818         if (r > 0) {
 819                 _cleanup_free_ char *t = NULL;
 820
 821                 /* On the unified hierarchy we can check empty state
 822                  * via the "populated" attribute of "cgroup.events". */
 823
 824                 r = cg_read_event(controller, path, "populated", &t);
 825                 if (r == -ENOENT)
 826                         return true;
 827                 if (r < 0)
 828                         return r;
 829
 830                 return streq(t, "0");
 831         } else {
 832                 _cleanup_closedir_ DIR *d = NULL;
 833                 char *fn;
 834
 835                 r = cg_is_empty(controller, path);
 836                 if (r <= 0)
 837                         return r;
 838
 839                 r = cg_enumerate_subgroups(controller, path, &d);
 840                 if (r == -ENOENT)
 841                         return true;
 842                 if (r < 0)
 843                         return r;
 844
 845                 while ((r = cg_read_subgroup(d, &fn)) > 0) {
 846                         _cleanup_free_ char *p = NULL;
 847
 848                         p = path_join(path, fn);
 849                         free(fn);
 850                         if (!p)
 851                                 return -ENOMEM;
 852
 853                         r = cg_is_empty_recursive(controller, p);
 854                         if (r <= 0)
 855                                 return r;
 856                 }
 857                 if (r < 0)
 858                         return r;
 859
 860                 return true;
 861         }
 862 }
 863
 864 int cg_split_spec(const char *spec, char **controller, char **path) {
 865         char *t = NULL, *u = NULL;
 866         const char *e;
 867
 868         assert(spec);
 869
 870         if (*spec == '/') {
 871                 if (!path_is_normalized(spec))
 872                         return -EINVAL;
 873
 874                 if (path) {
 875                         t = strdup(spec);
 876                         if (!t)
 877                                 return -ENOMEM;
 878
 879                         *path = path_simplify(t, false);
 880                 }
 881
 882                 if (controller)
 883                         *controller = NULL;
 884
 885                 return 0;
 886         }
 887
 888         e = strchr(spec, ':');
 889         if (!e) {
 890                 if (!cg_controller_is_valid(spec))
 891                         return -EINVAL;
 892
 893                 if (controller) {
 894                         t = strdup(spec);
 895                         if (!t)
 896                                 return -ENOMEM;
 897
 898                         *controller = t;
 899                 }
 900
 901                 if (path)
 902                         *path = NULL;
 903
 904                 return 0;
 905         }
 906
 907         t = strndup(spec, e-spec);
 908         if (!t)
 909                 return -ENOMEM;
 910         if (!cg_controller_is_valid(t)) {
 911                 free(t);
 912                 return -EINVAL;
 913         }
 914
 915         if (isempty(e+1))
 916                 u = NULL;
 917         else {
 918                 u = strdup(e+1);
 919                 if (!u) {
 920                         free(t);
 921                         return -ENOMEM;
 922                 }
 923
 924                 if (!path_is_normalized(u) ||
 925                     !path_is_absolute(u)) {
 926                         free(t);
 927                         free(u);
 928                         return -EINVAL;
 929                 }
 930
 931                 path_simplify(u, false);
 932         }
 933
 934         if (controller)
 935                 *controller = t;
 936         else
 937                 free(t);
 938
 939         if (path)
 940                 *path = u;
 941         else
 942                 free(u);
 943
 944         return 0;
 945 }
 946
 947 int cg_mangle_path(const char *path, char **result) {
 948         _cleanup_free_ char *c = NULL, *p = NULL;
 949         char *t;
 950         int r;
 951
 952         assert(path);
 953         assert(result);
 954
 955         /* First, check if it already is a filesystem path */
 956         if (path_startswith(path, "/sys/fs/cgroup")) {
 957
 958                 t = strdup(path);
 959                 if (!t)
 960                         return -ENOMEM;
 961
 962                 *result = path_simplify(t, false);
 963                 return 0;
 964         }
 965
 966         /* Otherwise, treat it as cg spec */
 967         r = cg_split_spec(path, &c, &p);
 968         if (r < 0)
 969                 return r;
 970
 971         return cg_get_path(c ?: SYSTEMD_CGROUP_CONTROLLER, p ?: "/", NULL, result);
 972 }
 973
 974 int cg_get_root_path(char **path) {
 975         char *p, *e;
 976         int r;
 977
 978         assert(path);
 979
 980         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 1, &p);
 981         if (r < 0)
 982                 return r;
 983
 984         e = endswith(p, "/" SPECIAL_INIT_SCOPE);
 985         if (!e)
 986                 e = endswith(p, "/" SPECIAL_SYSTEM_SLICE); /* legacy */
 987         if (!e)
 988                 e = endswith(p, "/system"); /* even more legacy */
 989         if (e)
 990                 *e = 0;
 991
 992         *path = p;
 993         return 0;
 994 }
 995
 996 int cg_shift_path(const char *cgroup, const char *root, const char **shifted) {
 997         _cleanup_free_ char *rt = NULL;
 998         char *p;
 999         int r;
1000
1001         assert(cgroup);
1002         assert(shifted);
1003
1004         if (!root) {
1005                 /* If the root was specified let's use that, otherwise
1006                  * let's determine it from PID 1 */
1007
1008                 r = cg_get_root_path(&rt);
1009                 if (r < 0)
1010                         return r;
1011
1012                 root = rt;
1013         }
1014
1015         p = path_startswith(cgroup, root);
1016         if (p && p > cgroup)
1017                 *shifted = p - 1;
1018         else
1019                 *shifted = cgroup;
1020
1021         return 0;
1022 }
1023
1024 int cg_pid_get_path_shifted(pid_t pid, const char *root, char **cgroup) {
1025         _cleanup_free_ char *raw = NULL;
1026         const char *c;
1027         int r;
1028
1029         assert(pid >= 0);
1030         assert(cgroup);
1031
1032         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &raw);
1033         if (r < 0)
1034                 return r;
1035
1036         r = cg_shift_path(raw, root, &c);
1037         if (r < 0)
1038                 return r;
1039
1040         if (c == raw)
1041                 *cgroup = TAKE_PTR(raw);
1042         else {
1043                 char *n;
1044
1045                 n = strdup(c);
1046                 if (!n)
1047                         return -ENOMEM;
1048
1049                 *cgroup = n;
1050         }
1051
1052         return 0;
1053 }
1054
1055 int cg_path_decode_unit(const char *cgroup, char **unit) {
1056         char *c, *s;
1057         size_t n;
1058
1059         assert(cgroup);
1060         assert(unit);
1061
1062         n = strcspn(cgroup, "/");
1063         if (n < 3)
1064                 return -ENXIO;
1065
1066         c = strndupa(cgroup, n);
1067         c = cg_unescape(c);
1068
1069         if (!unit_name_is_valid(c, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
1070                 return -ENXIO;
1071
1072         s = strdup(c);
1073         if (!s)
1074                 return -ENOMEM;
1075
1076         *unit = s;
1077         return 0;
1078 }
1079
1080 static bool valid_slice_name(const char *p, size_t n) {
1081
1082         if (!p)
1083                 return false;
1084
1085         if (n < STRLEN("x.slice"))
1086                 return false;
1087
1088         if (memcmp(p + n - 6, ".slice", 6) == 0) {
1089                 char buf[n+1], *c;
1090
1091                 memcpy(buf, p, n);
1092                 buf[n] = 0;
1093
1094                 c = cg_unescape(buf);
1095
1096                 return unit_name_is_valid(c, UNIT_NAME_PLAIN);
1097         }
1098
1099         return false;
1100 }
1101
1102 static const char *skip_slices(const char *p) {
1103         assert(p);
1104
1105         /* Skips over all slice assignments */
1106
1107         for (;;) {
1108                 size_t n;
1109
1110                 p += strspn(p, "/");
1111
1112                 n = strcspn(p, "/");
1113                 if (!valid_slice_name(p, n))
1114                         return p;
1115
1116                 p += n;
1117         }
1118 }
1119
1120 int cg_path_get_unit(const char *path, char **ret) {
1121         const char *e;
1122         char *unit;
1123         int r;
1124
1125         assert(path);
1126         assert(ret);
1127
1128         e = skip_slices(path);
1129
1130         r = cg_path_decode_unit(e, &unit);
1131         if (r < 0)
1132                 return r;
1133
1134         /* We skipped over the slices, don't accept any now */
1135         if (endswith(unit, ".slice")) {
1136                 free(unit);
1137                 return -ENXIO;
1138         }
1139
1140         *ret = unit;
1141         return 0;
1142 }
1143
1144 int cg_pid_get_unit(pid_t pid, char **unit) {
1145         _cleanup_free_ char *cgroup = NULL;
1146         int r;
1147
1148         assert(unit);
1149
1150         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1151         if (r < 0)
1152                 return r;
1153
1154         return cg_path_get_unit(cgroup, unit);
1155 }
1156
1157 /**
1158  * Skip session-*.scope, but require it to be there.
1159  */
1160 static const char *skip_session(const char *p) {
1161         size_t n;
1162
1163         if (isempty(p))
1164                 return NULL;
1165
1166         p += strspn(p, "/");
1167
1168         n = strcspn(p, "/");
1169         if (n < STRLEN("session-x.scope"))
1170                 return NULL;
1171
1172         if (memcmp(p, "session-", 8) == 0 && memcmp(p + n - 6, ".scope", 6) == 0) {
1173                 char buf[n - 8 - 6 + 1];
1174
1175                 memcpy(buf, p + 8, n - 8 - 6);
1176                 buf[n - 8 - 6] = 0;
1177
1178                 /* Note that session scopes never need unescaping,
1179                  * since they cannot conflict with the kernel's own
1180                  * names, hence we don't need to call cg_unescape()
1181                  * here. */
1182
1183                 if (!session_id_valid(buf))
1184                         return false;
1185
1186                 p += n;
1187                 p += strspn(p, "/");
1188                 return p;
1189         }
1190
1191         return NULL;
1192 }
1193
1194 /**
1195  * Skip user@*.service, but require it to be there.
1196  */
1197 static const char *skip_user_manager(const char *p) {
1198         size_t n;
1199
1200         if (isempty(p))
1201                 return NULL;
1202
1203         p += strspn(p, "/");
1204
1205         n = strcspn(p, "/");
1206         if (n < STRLEN("user@x.service"))
1207                 return NULL;
1208
1209         if (memcmp(p, "user@", 5) == 0 && memcmp(p + n - 8, ".service", 8) == 0) {
1210                 char buf[n - 5 - 8 + 1];
1211
1212                 memcpy(buf, p + 5, n - 5 - 8);
1213                 buf[n - 5 - 8] = 0;
1214
1215                 /* Note that user manager services never need unescaping,
1216                  * since they cannot conflict with the kernel's own
1217                  * names, hence we don't need to call cg_unescape()
1218                  * here. */
1219
1220                 if (parse_uid(buf, NULL) < 0)
1221                         return NULL;
1222
1223                 p += n;
1224                 p += strspn(p, "/");
1225
1226                 return p;
1227         }
1228
1229         return NULL;
1230 }
1231
1232 static const char *skip_user_prefix(const char *path) {
1233         const char *e, *t;
1234
1235         assert(path);
1236
1237         /* Skip slices, if there are any */
1238         e = skip_slices(path);
1239
1240         /* Skip the user manager, if it's in the path now... */
1241         t = skip_user_manager(e);
1242         if (t)
1243                 return t;
1244
1245         /* Alternatively skip the user session if it is in the path... */
1246         return skip_session(e);
1247 }
1248
1249 int cg_path_get_user_unit(const char *path, char **ret) {
1250         const char *t;
1251
1252         assert(path);
1253         assert(ret);
1254
1255         t = skip_user_prefix(path);
1256         if (!t)
1257                 return -ENXIO;
1258
1259         /* And from here on it looks pretty much the same as for a system unit, hence let's use the same
1260          * parser. */
1261         return cg_path_get_unit(t, ret);
1262 }
1263
1264 int cg_pid_get_user_unit(pid_t pid, char **unit) {
1265         _cleanup_free_ char *cgroup = NULL;
1266         int r;
1267
1268         assert(unit);
1269
1270         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1271         if (r < 0)
1272                 return r;
1273
1274         return cg_path_get_user_unit(cgroup, unit);
1275 }
1276
1277 int cg_path_get_machine_name(const char *path, char **machine) {
1278         _cleanup_free_ char *u = NULL;
1279         const char *sl;
1280         int r;
1281
1282         r = cg_path_get_unit(path, &u);
1283         if (r < 0)
1284                 return r;
1285
1286         sl = strjoina("/run/systemd/machines/unit:", u);
1287         return readlink_malloc(sl, machine);
1288 }
1289
1290 int cg_pid_get_machine_name(pid_t pid, char **machine) {
1291         _cleanup_free_ char *cgroup = NULL;
1292         int r;
1293
1294         assert(machine);
1295
1296         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1297         if (r < 0)
1298                 return r;
1299
1300         return cg_path_get_machine_name(cgroup, machine);
1301 }
1302
1303 int cg_path_get_session(const char *path, char **session) {
1304         _cleanup_free_ char *unit = NULL;
1305         char *start, *end;
1306         int r;
1307
1308         assert(path);
1309
1310         r = cg_path_get_unit(path, &unit);
1311         if (r < 0)
1312                 return r;
1313
1314         start = startswith(unit, "session-");
1315         if (!start)
1316                 return -ENXIO;
1317         end = endswith(start, ".scope");
1318         if (!end)
1319                 return -ENXIO;
1320
1321         *end = 0;
1322         if (!session_id_valid(start))
1323                 return -ENXIO;
1324
1325         if (session) {
1326                 char *rr;
1327
1328                 rr = strdup(start);
1329                 if (!rr)
1330                         return -ENOMEM;
1331
1332                 *session = rr;
1333         }
1334
1335         return 0;
1336 }
1337
1338 int cg_pid_get_session(pid_t pid, char **session) {
1339         _cleanup_free_ char *cgroup = NULL;
1340         int r;
1341
1342         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1343         if (r < 0)
1344                 return r;
1345
1346         return cg_path_get_session(cgroup, session);
1347 }
1348
1349 int cg_path_get_owner_uid(const char *path, uid_t *uid) {
1350         _cleanup_free_ char *slice = NULL;
1351         char *start, *end;
1352         int r;
1353
1354         assert(path);
1355
1356         r = cg_path_get_slice(path, &slice);
1357         if (r < 0)
1358                 return r;
1359
1360         start = startswith(slice, "user-");
1361         if (!start)
1362                 return -ENXIO;
1363         end = endswith(start, ".slice");
1364         if (!end)
1365                 return -ENXIO;
1366
1367         *end = 0;
1368         if (parse_uid(start, uid) < 0)
1369                 return -ENXIO;
1370
1371         return 0;
1372 }
1373
1374 int cg_pid_get_owner_uid(pid_t pid, uid_t *uid) {
1375         _cleanup_free_ char *cgroup = NULL;
1376         int r;
1377
1378         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1379         if (r < 0)
1380                 return r;
1381
1382         return cg_path_get_owner_uid(cgroup, uid);
1383 }
1384
1385 int cg_path_get_slice(const char *p, char **slice) {
1386         const char *e = NULL;
1387
1388         assert(p);
1389         assert(slice);
1390
1391         /* Finds the right-most slice unit from the beginning, but
1392          * stops before we come to the first non-slice unit. */
1393
1394         for (;;) {
1395                 size_t n;
1396
1397                 p += strspn(p, "/");
1398
1399                 n = strcspn(p, "/");
1400                 if (!valid_slice_name(p, n)) {
1401
1402                         if (!e) {
1403                                 char *s;
1404
1405                                 s = strdup(SPECIAL_ROOT_SLICE);
1406                                 if (!s)
1407                                         return -ENOMEM;
1408
1409                                 *slice = s;
1410                                 return 0;
1411                         }
1412
1413                         return cg_path_decode_unit(e, slice);
1414                 }
1415
1416                 e = p;
1417                 p += n;
1418         }
1419 }
1420
1421 int cg_pid_get_slice(pid_t pid, char **slice) {
1422         _cleanup_free_ char *cgroup = NULL;
1423         int r;
1424
1425         assert(slice);
1426
1427         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1428         if (r < 0)
1429                 return r;
1430
1431         return cg_path_get_slice(cgroup, slice);
1432 }
1433
1434 int cg_path_get_user_slice(const char *p, char **slice) {
1435         const char *t;
1436         assert(p);
1437         assert(slice);
1438
1439         t = skip_user_prefix(p);
1440         if (!t)
1441                 return -ENXIO;
1442
1443         /* And now it looks pretty much the same as for a system
1444          * slice, so let's just use the same parser from here on. */
1445         return cg_path_get_slice(t, slice);
1446 }
1447
1448 int cg_pid_get_user_slice(pid_t pid, char **slice) {
1449         _cleanup_free_ char *cgroup = NULL;
1450         int r;
1451
1452         assert(slice);
1453
1454         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1455         if (r < 0)
1456                 return r;
1457
1458         return cg_path_get_user_slice(cgroup, slice);
1459 }
1460
1461 char *cg_escape(const char *p) {
1462         bool need_prefix = false;
1463
1464         /* This implements very minimal escaping for names to be used
1465          * as file names in the cgroup tree: any name which might
1466          * conflict with a kernel name or is prefixed with '_' is
1467          * prefixed with a '_'. That way, when reading cgroup names it
1468          * is sufficient to remove a single prefixing underscore if
1469          * there is one. */
1470
1471         /* The return value of this function (unlike cg_unescape())
1472          * needs free()! */
1473
1474         if (IN_SET(p[0], 0, '_', '.') ||
1475             STR_IN_SET(p, "notify_on_release", "release_agent", "tasks") ||
1476             startswith(p, "cgroup."))
1477                 need_prefix = true;
1478         else {
1479                 const char *dot;
1480
1481                 dot = strrchr(p, '.');
1482                 if (dot) {
1483                         CGroupController c;
1484                         size_t l = dot - p;
1485
1486                         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1487                                 const char *n;
1488
1489                                 n = cgroup_controller_to_string(c);
1490
1491                                 if (l != strlen(n))
1492                                         continue;
1493
1494                                 if (memcmp(p, n, l) != 0)
1495                                         continue;
1496
1497                                 need_prefix = true;
1498                                 break;
1499                         }
1500                 }
1501         }
1502
1503         if (need_prefix)
1504                 return strjoin("_", p);
1505
1506         return strdup(p);
1507 }
1508
1509 char *cg_unescape(const char *p) {
1510         assert(p);
1511
1512         /* The return value of this function (unlike cg_escape())
1513          * doesn't need free()! */
1514
1515         if (p[0] == '_')
1516                 return (char*) p+1;
1517
1518         return (char*) p;
1519 }
1520
1521 #define CONTROLLER_VALID                        \
1522         DIGITS LETTERS                          \
1523         "_"
1524
1525 bool cg_controller_is_valid(const char *p) {
1526         const char *t, *s;
1527
1528         if (!p)
1529                 return false;
1530
1531         if (streq(p, SYSTEMD_CGROUP_CONTROLLER))
1532                 return true;
1533
1534         s = startswith(p, "name=");
1535         if (s)
1536                 p = s;
1537
1538         if (IN_SET(*p, 0, '_'))
1539                 return false;
1540
1541         for (t = p; *t; t++)
1542                 if (!strchr(CONTROLLER_VALID, *t))
1543                         return false;
1544
1545         if (t - p > FILENAME_MAX)
1546                 return false;
1547
1548         return true;
1549 }
1550
1551 int cg_slice_to_path(const char *unit, char **ret) {
1552         _cleanup_free_ char *p = NULL, *s = NULL, *e = NULL;
1553         const char *dash;
1554         int r;
1555
1556         assert(unit);
1557         assert(ret);
1558
1559         if (streq(unit, SPECIAL_ROOT_SLICE)) {
1560                 char *x;
1561
1562                 x = strdup("");
1563                 if (!x)
1564                         return -ENOMEM;
1565                 *ret = x;
1566                 return 0;
1567         }
1568
1569         if (!unit_name_is_valid(unit, UNIT_NAME_PLAIN))
1570                 return -EINVAL;
1571
1572         if (!endswith(unit, ".slice"))
1573                 return -EINVAL;
1574
1575         r = unit_name_to_prefix(unit, &p);
1576         if (r < 0)
1577                 return r;
1578
1579         dash = strchr(p, '-');
1580
1581         /* Don't allow initial dashes */
1582         if (dash == p)
1583                 return -EINVAL;
1584
1585         while (dash) {
1586                 _cleanup_free_ char *escaped = NULL;
1587                 char n[dash - p + sizeof(".slice")];
1588
1589 #if HAS_FEATURE_MEMORY_SANITIZER
1590                 /* msan doesn't instrument stpncpy, so it thinks
1591                  * n is later used uninitialized:
1592                  * https://github.com/google/sanitizers/issues/926
1593                  */
1594                 zero(n);
1595 #endif
1596
1597                 /* Don't allow trailing or double dashes */
1598                 if (IN_SET(dash[1], 0, '-'))
1599                         return -EINVAL;
1600
1601                 strcpy(stpncpy(n, p, dash - p), ".slice");
1602                 if (!unit_name_is_valid(n, UNIT_NAME_PLAIN))
1603                         return -EINVAL;
1604
1605                 escaped = cg_escape(n);
1606                 if (!escaped)
1607                         return -ENOMEM;
1608
1609                 if (!strextend(&s, escaped, "/", NULL))
1610                         return -ENOMEM;
1611
1612                 dash = strchr(dash+1, '-');
1613         }
1614
1615         e = cg_escape(unit);
1616         if (!e)
1617                 return -ENOMEM;
1618
1619         if (!strextend(&s, e, NULL))
1620                 return -ENOMEM;
1621
1622         *ret = TAKE_PTR(s);
1623
1624         return 0;
1625 }
1626
1627 int cg_set_attribute(const char *controller, const char *path, const char *attribute, const char *value) {
1628         _cleanup_free_ char *p = NULL;
1629         int r;
1630
1631         r = cg_get_path(controller, path, attribute, &p);
1632         if (r < 0)
1633                 return r;
1634
1635         return write_string_file(p, value, WRITE_STRING_FILE_DISABLE_BUFFER);
1636 }
1637
1638 int cg_get_attribute(const char *controller, const char *path, const char *attribute, char **ret) {
1639         _cleanup_free_ char *p = NULL;
1640         int r;
1641
1642         r = cg_get_path(controller, path, attribute, &p);
1643         if (r < 0)
1644                 return r;
1645
1646         return read_one_line_file(p, ret);
1647 }
1648
1649 int cg_get_keyed_attribute(
1650                 const char *controller,
1651                 const char *path,
1652                 const char *attribute,
1653                 char **keys,
1654                 char **ret_values) {
1655
1656         _cleanup_free_ char *filename = NULL, *contents = NULL;
1657         const char *p;
1658         size_t n, i, n_done = 0;
1659         char **v;
1660         int r;
1661
1662         /* Reads one or more fields of a cgroup v2 keyed attribute file. The 'keys' parameter should be an strv with
1663          * all keys to retrieve. The 'ret_values' parameter should be passed as string size with the same number of
1664          * entries as 'keys'. On success each entry will be set to the value of the matching key.
1665          *
1666          * If the attribute file doesn't exist at all returns ENOENT, if any key is not found returns ENXIO. */
1667
1668         r = cg_get_path(controller, path, attribute, &filename);
1669         if (r < 0)
1670                 return r;
1671
1672         r = read_full_file(filename, &contents, NULL);
1673         if (r < 0)
1674                 return r;
1675
1676         n = strv_length(keys);
1677         if (n == 0) /* No keys to retrieve? That's easy, we are done then */
1678                 return 0;
1679
1680         /* Let's build this up in a temporary array for now in order not to clobber the return parameter on failure */
1681         v = newa0(char*, n);
1682
1683         for (p = contents; *p;) {
1684                 const char *w = NULL;
1685
1686                 for (i = 0; i < n; i++)
1687                         if (!v[i]) {
1688                                 w = first_word(p, keys[i]);
1689                                 if (w)
1690                                         break;
1691                         }
1692
1693                 if (w) {
1694                         size_t l;
1695
1696                         l = strcspn(w, NEWLINE);
1697                         v[i] = strndup(w, l);
1698                         if (!v[i]) {
1699                                 r = -ENOMEM;
1700                                 goto fail;
1701                         }
1702
1703                         n_done++;
1704                         if (n_done >= n)
1705                                 goto done;
1706
1707                         p = w + l;
1708                 } else
1709                         p += strcspn(p, NEWLINE);
1710
1711                 p += strspn(p, NEWLINE);
1712         }
1713
1714         r = -ENXIO;
1715
1716 fail:
1717         for (i = 0; i < n; i++)
1718                 free(v[i]);
1719
1720         return r;
1721
1722 done:
1723         memcpy(ret_values, v, sizeof(char*) * n);
1724         return 0;
1725 }
1726
1727 int cg_mask_to_string(CGroupMask mask, char **ret) {
1728         _cleanup_free_ char *s = NULL;
1729         size_t n = 0, allocated = 0;
1730         bool space = false;
1731         CGroupController c;
1732
1733         assert(ret);
1734
1735         if (mask == 0) {
1736                 *ret = NULL;
1737                 return 0;
1738         }
1739
1740         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1741                 const char *k;
1742                 size_t l;
1743
1744                 if (!FLAGS_SET(mask, CGROUP_CONTROLLER_TO_MASK(c)))
1745                         continue;
1746
1747                 k = cgroup_controller_to_string(c);
1748                 l = strlen(k);
1749
1750                 if (!GREEDY_REALLOC(s, allocated, n + space + l + 1))
1751                         return -ENOMEM;
1752
1753                 if (space)
1754                         s[n] = ' ';
1755                 memcpy(s + n + space, k, l);
1756                 n += space + l;
1757
1758                 space = true;
1759         }
1760
1761         assert(s);
1762
1763         s[n] = 0;
1764         *ret = TAKE_PTR(s);
1765
1766         return 0;
1767 }
1768
1769 int cg_mask_from_string(const char *value, CGroupMask *ret) {
1770         CGroupMask m = 0;
1771
1772         assert(ret);
1773         assert(value);
1774
1775         for (;;) {
1776                 _cleanup_free_ char *n = NULL;
1777                 CGroupController v;
1778                 int r;
1779
1780                 r = extract_first_word(&value, &n, NULL, 0);
1781                 if (r < 0)
1782                         return r;
1783                 if (r == 0)
1784                         break;
1785
1786                 v = cgroup_controller_from_string(n);
1787                 if (v < 0)
1788                         continue;
1789
1790                 m |= CGROUP_CONTROLLER_TO_MASK(v);
1791         }
1792
1793         *ret = m;
1794         return 0;
1795 }
1796
1797 int cg_mask_supported(CGroupMask *ret) {
1798         CGroupMask mask;
1799         int r;
1800
1801         /* Determines the mask of supported cgroup controllers. Only includes controllers we can make sense of and that
1802          * are actually accessible. Only covers real controllers, i.e. not the CGROUP_CONTROLLER_BPF_xyz
1803          * pseudo-controllers. */
1804
1805         r = cg_all_unified();
1806         if (r < 0)
1807                 return r;
1808         if (r > 0) {
1809                 _cleanup_free_ char *root = NULL, *controllers = NULL, *path = NULL;
1810
1811                 /* In the unified hierarchy we can read the supported
1812                  * and accessible controllers from a the top-level
1813                  * cgroup attribute */
1814
1815                 r = cg_get_root_path(&root);
1816                 if (r < 0)
1817                         return r;
1818
1819                 r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, root, "cgroup.controllers", &path);
1820                 if (r < 0)
1821                         return r;
1822
1823                 r = read_one_line_file(path, &controllers);
1824                 if (r < 0)
1825                         return r;
1826
1827                 r = cg_mask_from_string(controllers, &mask);
1828                 if (r < 0)
1829                         return r;
1830
1831                 /* Mask controllers that are not supported in unified hierarchy. */
1832                 mask &= CGROUP_MASK_V2;
1833
1834         } else {
1835                 CGroupController c;
1836
1837                 /* In the legacy hierarchy, we check which hierarchies are mounted. */
1838
1839                 mask = 0;
1840                 for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1841                         CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
1842                         const char *n;
1843
1844                         if (!FLAGS_SET(CGROUP_MASK_V1, bit))
1845                                 continue;
1846
1847                         n = cgroup_controller_to_string(c);
1848                         if (controller_is_accessible(n) >= 0)
1849                                 mask |= bit;
1850                 }
1851         }
1852
1853         *ret = mask;
1854         return 0;
1855 }
1856
1857 int cg_kernel_controllers(Set **ret) {
1858         _cleanup_set_free_free_ Set *controllers = NULL;
1859         _cleanup_fclose_ FILE *f = NULL;
1860         int r;
1861
1862         assert(ret);
1863
1864         /* Determines the full list of kernel-known controllers. Might include controllers we don't actually support
1865          * and controllers that aren't currently accessible (because not mounted). This does not include "name="
1866          * pseudo-controllers. */
1867
1868         controllers = set_new(&string_hash_ops);
1869         if (!controllers)
1870                 return -ENOMEM;
1871
1872         r = fopen_unlocked("/proc/cgroups", "re", &f);
1873         if (r == -ENOENT) {
1874                 *ret = NULL;
1875                 return 0;
1876         }
1877         if (r < 0)
1878                 return r;
1879
1880         /* Ignore the header line */
1881         (void) read_line(f, (size_t) -1, NULL);
1882
1883         for (;;) {
1884                 char *controller;
1885                 int enabled = 0;
1886
1887                 errno = 0;
1888                 if (fscanf(f, "%ms %*i %*i %i", &controller, &enabled) != 2) {
1889
1890                         if (feof(f))
1891                                 break;
1892
1893                         if (ferror(f))
1894                                 return errno_or_else(EIO);
1895
1896                         return -EBADMSG;
1897                 }
1898
1899                 if (!enabled) {
1900                         free(controller);
1901                         continue;
1902                 }
1903
1904                 if (!cg_controller_is_valid(controller)) {
1905                         free(controller);
1906                         return -EBADMSG;
1907                 }
1908
1909                 r = set_consume(controllers, controller);
1910                 if (r < 0)
1911                         return r;
1912         }
1913
1914         *ret = TAKE_PTR(controllers);
1915
1916         return 0;
1917 }
1918
1919 /* The hybrid mode was initially implemented in v232 and simply mounted cgroup2 on
1920  * /sys/fs/cgroup/systemd. This unfortunately broke other tools (such as docker) which expected the v1
1921  * "name=systemd" hierarchy on /sys/fs/cgroup/systemd. From v233 and on, the hybrid mode mounts v2 on
1922  * /sys/fs/cgroup/unified and maintains "name=systemd" hierarchy on /sys/fs/cgroup/systemd for compatibility
1923  * with other tools.
1924  *
1925  * To keep live upgrade working, we detect and support v232 layout. When v232 layout is detected, to keep
1926  * cgroup v2 process management but disable the compat dual layout, we return true on
1927  * cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER) and false on cg_hybrid_unified().
1928  */
1929 static thread_local bool unified_systemd_v232;
1930
1931 int cg_unified_cached(bool flush) {
1932         static thread_local CGroupUnified unified_cache = CGROUP_UNIFIED_UNKNOWN;
1933
1934         struct statfs fs;
1935
1936         /* Checks if we support the unified hierarchy. Returns an
1937          * error when the cgroup hierarchies aren't mounted yet or we
1938          * have any other trouble determining if the unified hierarchy
1939          * is supported. */
1940
1941         if (flush)
1942                 unified_cache = CGROUP_UNIFIED_UNKNOWN;
1943         else if (unified_cache >= CGROUP_UNIFIED_NONE)
1944                 return unified_cache;
1945
1946         if (statfs("/sys/fs/cgroup/", &fs) < 0)
1947                 return log_debug_errno(errno, "statfs(\"/sys/fs/cgroup/\") failed: %m");
1948
1949         if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
1950                 log_debug("Found cgroup2 on /sys/fs/cgroup/, full unified hierarchy");
1951                 unified_cache = CGROUP_UNIFIED_ALL;
1952         } else if (F_TYPE_EQUAL(fs.f_type, TMPFS_MAGIC)) {
1953                 if (statfs("/sys/fs/cgroup/unified/", &fs) == 0 &&
1954                     F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
1955                         log_debug("Found cgroup2 on /sys/fs/cgroup/unified, unified hierarchy for systemd controller");
1956                         unified_cache = CGROUP_UNIFIED_SYSTEMD;
1957                         unified_systemd_v232 = false;
1958                 } else {
1959                         if (statfs("/sys/fs/cgroup/systemd/", &fs) < 0)
1960                                 return log_debug_errno(errno, "statfs(\"/sys/fs/cgroup/systemd\" failed: %m");
1961
1962                         if (F_TYPE_EQUAL(fs.f_type, CGROUP2_SUPER_MAGIC)) {
1963                                 log_debug("Found cgroup2 on /sys/fs/cgroup/systemd, unified hierarchy for systemd controller (v232 variant)");
1964                                 unified_cache = CGROUP_UNIFIED_SYSTEMD;
1965                                 unified_systemd_v232 = true;
1966                         } else if (F_TYPE_EQUAL(fs.f_type, CGROUP_SUPER_MAGIC)) {
1967                                 log_debug("Found cgroup on /sys/fs/cgroup/systemd, legacy hierarchy");
1968                                 unified_cache = CGROUP_UNIFIED_NONE;
1969                         } else {
1970                                 log_debug("Unexpected filesystem type %llx mounted on /sys/fs/cgroup/systemd, assuming legacy hierarchy",
1971                                           (unsigned long long) fs.f_type);
1972                                 unified_cache = CGROUP_UNIFIED_NONE;
1973                         }
1974                 }
1975         } else
1976                 return log_debug_errno(SYNTHETIC_ERRNO(ENOMEDIUM),
1977                                        "Unknown filesystem type %llx mounted on /sys/fs/cgroup.",
1978                                        (unsigned long long)fs.f_type);
1979
1980         return unified_cache;
1981 }
1982
1983 int cg_unified_controller(const char *controller) {
1984         int r;
1985
1986         r = cg_unified_cached(false);
1987         if (r < 0)
1988                 return r;
1989
1990         if (r == CGROUP_UNIFIED_NONE)
1991                 return false;
1992
1993         if (r >= CGROUP_UNIFIED_ALL)
1994                 return true;
1995
1996         return streq_ptr(controller, SYSTEMD_CGROUP_CONTROLLER);
1997 }
1998
1999 int cg_all_unified(void) {
2000         int r;
2001
2002         r = cg_unified_cached(false);
2003         if (r < 0)
2004                 return r;
2005
2006         return r >= CGROUP_UNIFIED_ALL;
2007 }
2008
2009 int cg_hybrid_unified(void) {
2010         int r;
2011
2012         r = cg_unified_cached(false);
2013         if (r < 0)
2014                 return r;
2015
2016         return r == CGROUP_UNIFIED_SYSTEMD && !unified_systemd_v232;
2017 }
2018
2019 const uint64_t cgroup_io_limit_defaults[_CGROUP_IO_LIMIT_TYPE_MAX] = {
2020         [CGROUP_IO_RBPS_MAX]    = CGROUP_LIMIT_MAX,
2021         [CGROUP_IO_WBPS_MAX]    = CGROUP_LIMIT_MAX,
2022         [CGROUP_IO_RIOPS_MAX]   = CGROUP_LIMIT_MAX,
2023         [CGROUP_IO_WIOPS_MAX]   = CGROUP_LIMIT_MAX,
2024 };
2025
2026 static const char* const cgroup_io_limit_type_table[_CGROUP_IO_LIMIT_TYPE_MAX] = {
2027         [CGROUP_IO_RBPS_MAX]    = "IOReadBandwidthMax",
2028         [CGROUP_IO_WBPS_MAX]    = "IOWriteBandwidthMax",
2029         [CGROUP_IO_RIOPS_MAX]   = "IOReadIOPSMax",
2030         [CGROUP_IO_WIOPS_MAX]   = "IOWriteIOPSMax",
2031 };
2032
2033 DEFINE_STRING_TABLE_LOOKUP(cgroup_io_limit_type, CGroupIOLimitType);
2034
2035 bool is_cgroup_fs(const struct statfs *s) {
2036         return is_fs_type(s, CGROUP_SUPER_MAGIC) ||
2037                is_fs_type(s, CGROUP2_SUPER_MAGIC);
2038 }
2039
2040 bool fd_is_cgroup_fs(int fd) {
2041         struct statfs s;
2042
2043         if (fstatfs(fd, &s) < 0)
2044                 return -errno;
2045
2046         return is_cgroup_fs(&s);
2047 }
2048
2049 static const char *const cgroup_controller_table[_CGROUP_CONTROLLER_MAX] = {
2050         [CGROUP_CONTROLLER_CPU] = "cpu",
2051         [CGROUP_CONTROLLER_CPUACCT] = "cpuacct",
2052         [CGROUP_CONTROLLER_CPUSET] = "cpuset",
2053         [CGROUP_CONTROLLER_IO] = "io",
2054         [CGROUP_CONTROLLER_BLKIO] = "blkio",
2055         [CGROUP_CONTROLLER_MEMORY] = "memory",
2056         [CGROUP_CONTROLLER_DEVICES] = "devices",
2057         [CGROUP_CONTROLLER_PIDS] = "pids",
2058         [CGROUP_CONTROLLER_BPF_FIREWALL] = "bpf-firewall",
2059         [CGROUP_CONTROLLER_BPF_DEVICES] = "bpf-devices",
2060 };
2061
2062 DEFINE_STRING_TABLE_LOOKUP(cgroup_controller, CGroupController);
2063
2064 CGroupMask get_cpu_accounting_mask(void) {
2065         static CGroupMask needed_mask = (CGroupMask) -1;
2066
2067         /* On kernel ≥4.15 with unified hierarchy, cpu.stat's usage_usec is
2068          * provided externally from the CPU controller, which means we don't
2069          * need to enable the CPU controller just to get metrics. This is good,
2070          * because enabling the CPU controller comes at a minor performance
2071          * hit, especially when it's propagated deep into large hierarchies.
2072          * There's also no separate CPU accounting controller available within
2073          * a unified hierarchy.
2074          *
2075          * This combination of factors results in the desired cgroup mask to
2076          * enable for CPU accounting varying as follows:
2077          *
2078          *                   ╔═════════════════════╤═════════════════════╗
2079          *                   ║     Linux ≥4.15     │     Linux <4.15     ║
2080          *   ╔═══════════════╬═════════════════════╪═════════════════════╣
2081          *   ║ Unified       ║ nothing             │ CGROUP_MASK_CPU     ║
2082          *   ╟───────────────╫─────────────────────┼─────────────────────╢
2083          *   ║ Hybrid/Legacy ║ CGROUP_MASK_CPUACCT │ CGROUP_MASK_CPUACCT ║
2084          *   ╚═══════════════╩═════════════════════╧═════════════════════╝
2085          *
2086          * We check kernel version here instead of manually checking whether
2087          * cpu.stat is present for every cgroup, as that check in itself would
2088          * already be fairly expensive.
2089          *
2090          * Kernels where this patch has been backported will therefore have the
2091          * CPU controller enabled unnecessarily. This is more expensive than
2092          * necessary, but harmless. ☺️
2093          */
2094
2095         if (needed_mask == (CGroupMask) -1) {
2096                 if (cg_all_unified()) {
2097                         struct utsname u;
2098                         assert_se(uname(&u) >= 0);
2099
2100                         if (str_verscmp(u.release, "4.15") < 0)
2101                                 needed_mask = CGROUP_MASK_CPU;
2102                         else
2103                                 needed_mask = 0;
2104                 } else
2105                         needed_mask = CGROUP_MASK_CPUACCT;
2106         }
2107
2108         return needed_mask;
2109 }
2110
2111 bool cpu_accounting_is_cheap(void) {
2112         return get_cpu_accounting_mask() == 0;
2113 }