src/shared/cgroup-util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <unistd.h>
  24 #include <signal.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <dirent.h>
  28 #include <sys/stat.h>
  29 #include <sys/types.h>
  30 #include <ftw.h>
  31
  32 #include "cgroup-util.h"
  33 #include "log.h"
  34 #include "set.h"
  35 #include "macro.h"
  36 #include "util.h"
  37 #include "path-util.h"
  38 #include "strv.h"
  39 #include "unit-name.h"
  40 #include "fileio.h"
  41 #include "special.h"
  42 #include "mkdir.h"
  43
  44 int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {
  45         _cleanup_free_ char *fs = NULL;
  46         FILE *f;
  47         int r;
  48
  49         assert(_f);
  50
  51         r = cg_get_path(controller, path, "cgroup.procs", &fs);
  52         if (r < 0)
  53                 return r;
  54
  55         f = fopen(fs, "re");
  56         if (!f)
  57                 return -errno;
  58
  59         *_f = f;
  60         return 0;
  61 }
  62
  63 int cg_read_pid(FILE *f, pid_t *_pid) {
  64         unsigned long ul;
  65
  66         /* Note that the cgroup.procs might contain duplicates! See
  67          * cgroups.txt for details. */
  68
  69         assert(f);
  70         assert(_pid);
  71
  72         errno = 0;
  73         if (fscanf(f, "%lu", &ul) != 1) {
  74
  75                 if (feof(f))
  76                         return 0;
  77
  78                 return errno ? -errno : -EIO;
  79         }
  80
  81         if (ul <= 0)
  82                 return -EIO;
  83
  84         *_pid = (pid_t) ul;
  85         return 1;
  86 }
  87
  88 int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {
  89         _cleanup_free_ char *fs = NULL;
  90         int r;
  91         DIR *d;
  92
  93         assert(_d);
  94
  95         /* This is not recursive! */
  96
  97         r = cg_get_path(controller, path, NULL, &fs);
  98         if (r < 0)
  99                 return r;
 100
 101         d = opendir(fs);
 102         if (!d)
 103                 return -errno;
 104
 105         *_d = d;
 106         return 0;
 107 }
 108
 109 int cg_read_subgroup(DIR *d, char **fn) {
 110         struct dirent *de;
 111
 112         assert(d);
 113         assert(fn);
 114
 115         FOREACH_DIRENT(de, d, return -errno) {
 116                 char *b;
 117
 118                 if (de->d_type != DT_DIR)
 119                         continue;
 120
 121                 if (streq(de->d_name, ".") ||
 122                     streq(de->d_name, ".."))
 123                         continue;
 124
 125                 b = strdup(de->d_name);
 126                 if (!b)
 127                         return -ENOMEM;
 128
 129                 *fn = b;
 130                 return 1;
 131         }
 132
 133         return 0;
 134 }
 135
 136 int cg_rmdir(const char *controller, const char *path) {
 137         _cleanup_free_ char *p = NULL;
 138         int r;
 139
 140         r = cg_get_path(controller, path, NULL, &p);
 141         if (r < 0)
 142                 return r;
 143
 144         r = rmdir(p);
 145         if (r < 0 && errno != ENOENT)
 146                 return -errno;
 147
 148         return 0;
 149 }
 150
 151 int cg_kill(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, Set *s) {
 152         _cleanup_set_free_ Set *allocated_set = NULL;
 153         bool done = false;
 154         int r, ret = 0;
 155         pid_t my_pid;
 156
 157         assert(sig >= 0);
 158
 159         /* This goes through the tasks list and kills them all. This
 160          * is repeated until no further processes are added to the
 161          * tasks list, to properly handle forking processes */
 162
 163         if (!s) {
 164                 s = allocated_set = set_new(NULL);
 165                 if (!s)
 166                         return -ENOMEM;
 167         }
 168
 169         my_pid = getpid();
 170
 171         do {
 172                 _cleanup_fclose_ FILE *f = NULL;
 173                 pid_t pid = 0;
 174                 done = true;
 175
 176                 r = cg_enumerate_processes(controller, path, &f);
 177                 if (r < 0) {
 178                         if (ret >= 0 && r != -ENOENT)
 179                                 return r;
 180
 181                         return ret;
 182                 }
 183
 184                 while ((r = cg_read_pid(f, &pid)) > 0) {
 185
 186                         if (ignore_self && pid == my_pid)
 187                                 continue;
 188
 189                         if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid))
 190                                 continue;
 191
 192                         /* If we haven't killed this process yet, kill
 193                          * it */
 194                         if (kill(pid, sig) < 0) {
 195                                 if (ret >= 0 && errno != ESRCH)
 196                                         ret = -errno;
 197                         } else {
 198                                 if (sigcont && sig != SIGKILL)
 199                                         kill(pid, SIGCONT);
 200
 201                                 if (ret == 0)
 202                                         ret = 1;
 203                         }
 204
 205                         done = false;
 206
 207                         r = set_put(s, LONG_TO_PTR(pid));
 208                         if (r < 0) {
 209                                 if (ret >= 0)
 210                                         return r;
 211
 212                                 return ret;
 213                         }
 214                 }
 215
 216                 if (r < 0) {
 217                         if (ret >= 0)
 218                                 return r;
 219
 220                         return ret;
 221                 }
 222
 223                 /* To avoid racing against processes which fork
 224                  * quicker than we can kill them we repeat this until
 225                  * no new pids need to be killed. */
 226
 227         } while (!done);
 228
 229         return ret;
 230 }
 231
 232 int cg_kill_recursive(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, bool rem, Set *s) {
 233         _cleanup_set_free_ Set *allocated_set = NULL;
 234         _cleanup_closedir_ DIR *d = NULL;
 235         int r, ret = 0;
 236         char *fn;
 237
 238         assert(path);
 239         assert(sig >= 0);
 240
 241         if (!s) {
 242                 s = allocated_set = set_new(NULL);
 243                 if (!s)
 244                         return -ENOMEM;
 245         }
 246
 247         ret = cg_kill(controller, path, sig, sigcont, ignore_self, s);
 248
 249         r = cg_enumerate_subgroups(controller, path, &d);
 250         if (r < 0) {
 251                 if (ret >= 0 && r != -ENOENT)
 252                         return r;
 253
 254                 return ret;
 255         }
 256
 257         while ((r = cg_read_subgroup(d, &fn)) > 0) {
 258                 _cleanup_free_ char *p = NULL;
 259
 260                 p = strjoin(path, "/", fn, NULL);
 261                 free(fn);
 262                 if (!p)
 263                         return -ENOMEM;
 264
 265                 r = cg_kill_recursive(controller, p, sig, sigcont, ignore_self, rem, s);
 266                 if (ret >= 0 && r != 0)
 267                         ret = r;
 268         }
 269
 270         if (ret >= 0 && r < 0)
 271                 ret = r;
 272
 273         if (rem) {
 274                 r = cg_rmdir(controller, path);
 275                 if (r < 0 && ret >= 0 && r != -ENOENT && r != -EBUSY)
 276                         return r;
 277         }
 278
 279         return ret;
 280 }
 281
 282 int cg_migrate(const char *cfrom, const char *pfrom, const char *cto, const char *pto, bool ignore_self) {
 283         bool done = false;
 284         _cleanup_set_free_ Set *s = NULL;
 285         int r, ret = 0;
 286         pid_t my_pid;
 287
 288         assert(cfrom);
 289         assert(pfrom);
 290         assert(cto);
 291         assert(pto);
 292
 293         s = set_new(NULL);
 294         if (!s)
 295                 return -ENOMEM;
 296
 297         my_pid = getpid();
 298
 299         do {
 300                 _cleanup_fclose_ FILE *f = NULL;
 301                 pid_t pid = 0;
 302                 done = true;
 303
 304                 r = cg_enumerate_processes(cfrom, pfrom, &f);
 305                 if (r < 0) {
 306                         if (ret >= 0 && r != -ENOENT)
 307                                 return r;
 308
 309                         return ret;
 310                 }
 311
 312                 while ((r = cg_read_pid(f, &pid)) > 0) {
 313
 314                         /* This might do weird stuff if we aren't a
 315                          * single-threaded program. However, we
 316                          * luckily know we are not */
 317                         if (ignore_self && pid == my_pid)
 318                                 continue;
 319
 320                         if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid))
 321                                 continue;
 322
 323                         r = cg_attach(cto, pto, pid);
 324                         if (r < 0) {
 325                                 if (ret >= 0 && r != -ESRCH)
 326                                         ret = r;
 327                         } else if (ret == 0)
 328                                 ret = 1;
 329
 330                         done = false;
 331
 332                         r = set_put(s, LONG_TO_PTR(pid));
 333                         if (r < 0) {
 334                                 if (ret >= 0)
 335                                         return r;
 336
 337                                 return ret;
 338                         }
 339                 }
 340
 341                 if (r < 0) {
 342                         if (ret >= 0)
 343                                 return r;
 344
 345                         return ret;
 346                 }
 347         } while (!done);
 348
 349         return ret;
 350 }
 351
 352 int cg_migrate_recursive(
 353                 const char *cfrom,
 354                 const char *pfrom,
 355                 const char *cto,
 356                 const char *pto,
 357                 bool ignore_self,
 358                 bool rem) {
 359
 360         _cleanup_closedir_ DIR *d = NULL;
 361         int r, ret = 0;
 362         char *fn;
 363
 364         assert(cfrom);
 365         assert(pfrom);
 366         assert(cto);
 367         assert(pto);
 368
 369         ret = cg_migrate(cfrom, pfrom, cto, pto, ignore_self);
 370
 371         r = cg_enumerate_subgroups(cfrom, pfrom, &d);
 372         if (r < 0) {
 373                 if (ret >= 0 && r != -ENOENT)
 374                         return r;
 375
 376                 return ret;
 377         }
 378
 379         while ((r = cg_read_subgroup(d, &fn)) > 0) {
 380                 _cleanup_free_ char *p = NULL;
 381
 382                 p = strjoin(pfrom, "/", fn, NULL);
 383                 free(fn);
 384                 if (!p) {
 385                         if (ret >= 0)
 386                                 return -ENOMEM;
 387
 388                         return ret;
 389                 }
 390
 391                 r = cg_migrate_recursive(cfrom, p, cto, pto, ignore_self, rem);
 392                 if (r != 0 && ret >= 0)
 393                         ret = r;
 394         }
 395
 396         if (r < 0 && ret >= 0)
 397                 ret = r;
 398
 399         if (rem) {
 400                 r = cg_rmdir(cfrom, pfrom);
 401                 if (r < 0 && ret >= 0 && r != -ENOENT && r != -EBUSY)
 402                         return r;
 403         }
 404
 405         return ret;
 406 }
 407
 408 int cg_migrate_recursive_fallback(
 409                 const char *cfrom,
 410                 const char *pfrom,
 411                 const char *cto,
 412                 const char *pto,
 413                 bool ignore_self,
 414                 bool rem) {
 415
 416         int r;
 417
 418         assert(cfrom);
 419         assert(pfrom);
 420         assert(cto);
 421         assert(pto);
 422
 423         r = cg_migrate_recursive(cfrom, pfrom, cto, pto, ignore_self, rem);
 424         if (r < 0) {
 425                 char prefix[strlen(pto) + 1];
 426
 427                 /* This didn't work? Then let's try all prefixes of the destination */
 428
 429                 PATH_FOREACH_PREFIX(prefix, pto) {
 430                         r = cg_migrate_recursive(cfrom, pfrom, cto, prefix, ignore_self, rem);
 431                         if (r >= 0)
 432                                 break;
 433                 }
 434         }
 435
 436         return 0;
 437 }
 438
 439 static const char *normalize_controller(const char *controller) {
 440
 441         assert(controller);
 442
 443         if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
 444                 return "systemd";
 445         else if (startswith(controller, "name="))
 446                 return controller + 5;
 447         else
 448                 return controller;
 449 }
 450
 451 static int join_path(const char *controller, const char *path, const char *suffix, char **fs) {
 452         char *t = NULL;
 453
 454         if (!isempty(controller)) {
 455                 if (!isempty(path) && !isempty(suffix))
 456                         t = strjoin("/sys/fs/cgroup/", controller, "/", path, "/", suffix, NULL);
 457                 else if (!isempty(path))
 458                         t = strjoin("/sys/fs/cgroup/", controller, "/", path, NULL);
 459                 else if (!isempty(suffix))
 460                         t = strjoin("/sys/fs/cgroup/", controller, "/", suffix, NULL);
 461                 else
 462                         t = strappend("/sys/fs/cgroup/", controller);
 463         } else {
 464                 if (!isempty(path) && !isempty(suffix))
 465                         t = strjoin(path, "/", suffix, NULL);
 466                 else if (!isempty(path))
 467                         t = strdup(path);
 468                 else
 469                         return -EINVAL;
 470         }
 471
 472         if (!t)
 473                 return -ENOMEM;
 474
 475         *fs = path_kill_slashes(t);
 476         return 0;
 477 }
 478
 479 int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {
 480         const char *p;
 481         static thread_local bool good = false;
 482
 483         assert(fs);
 484
 485         if (controller && !cg_controller_is_valid(controller, true))
 486                 return -EINVAL;
 487
 488         if (_unlikely_(!good)) {
 489                 int r;
 490
 491                 r = path_is_mount_point("/sys/fs/cgroup", false);
 492                 if (r <= 0)
 493                         return r < 0 ? r : -ENOENT;
 494
 495                 /* Cache this to save a few stat()s */
 496                 good = true;
 497         }
 498
 499         p = controller ? normalize_controller(controller) : NULL;
 500
 501         return join_path(p, path, suffix, fs);
 502 }
 503
 504 static int check_hierarchy(const char *p) {
 505         const char *cc;
 506
 507         assert(p);
 508
 509         if (!filename_is_valid(p))
 510                 return 0;
 511
 512         /* Check if this controller actually really exists */
 513         cc = strappenda("/sys/fs/cgroup/", p);
 514         if (laccess(cc, F_OK) < 0)
 515                 return -errno;
 516
 517         return 0;
 518 }
 519
 520 int cg_get_path_and_check(const char *controller, const char *path, const char *suffix, char **fs) {
 521         const char *p;
 522         int r;
 523
 524         assert(fs);
 525
 526         if (!cg_controller_is_valid(controller, true))
 527                 return -EINVAL;
 528
 529         /* Normalize the controller syntax */
 530         p = normalize_controller(controller);
 531
 532         /* Check if this controller actually really exists */
 533         r = check_hierarchy(p);
 534         if (r < 0)
 535                 return r;
 536
 537         return join_path(p, path, suffix, fs);
 538 }
 539
 540 static int trim_cb(const char *path, const struct stat *sb, int typeflag, struct FTW *ftwbuf) {
 541         assert(path);
 542         assert(sb);
 543         assert(ftwbuf);
 544
 545         if (typeflag != FTW_DP)
 546                 return 0;
 547
 548         if (ftwbuf->level < 1)
 549                 return 0;
 550
 551         rmdir(path);
 552         return 0;
 553 }
 554
 555 int cg_trim(const char *controller, const char *path, bool delete_root) {
 556         _cleanup_free_ char *fs = NULL;
 557         int r = 0;
 558
 559         assert(path);
 560
 561         r = cg_get_path(controller, path, NULL, &fs);
 562         if (r < 0)
 563                 return r;
 564
 565         errno = 0;
 566         if (nftw(fs, trim_cb, 64, FTW_DEPTH|FTW_MOUNT|FTW_PHYS) != 0)
 567                 r = errno ? -errno : -EIO;
 568
 569         if (delete_root) {
 570                 if (rmdir(fs) < 0 && errno != ENOENT)
 571                         return -errno;
 572         }
 573
 574         return r;
 575 }
 576
 577 int cg_delete(const char *controller, const char *path) {
 578         _cleanup_free_ char *parent = NULL;
 579         int r;
 580
 581         assert(path);
 582
 583         r = path_get_parent(path, &parent);
 584         if (r < 0)
 585                 return r;
 586
 587         r = cg_migrate_recursive(controller, path, controller, parent, false, true);
 588         return r == -ENOENT ? 0 : r;
 589 }
 590
 591 int cg_create(const char *controller, const char *path) {
 592         _cleanup_free_ char *fs = NULL;
 593         int r;
 594
 595         r = cg_get_path_and_check(controller, path, NULL, &fs);
 596         if (r < 0)
 597                 return r;
 598
 599         r = mkdir_parents(fs, 0755);
 600         if (r < 0)
 601                 return r;
 602
 603         if (mkdir(fs, 0755) < 0) {
 604
 605                 if (errno == EEXIST)
 606                         return 0;
 607
 608                 return -errno;
 609         }
 610
 611         return 1;
 612 }
 613
 614 int cg_create_and_attach(const char *controller, const char *path, pid_t pid) {
 615         int r, q;
 616
 617         assert(pid >= 0);
 618
 619         r = cg_create(controller, path);
 620         if (r < 0)
 621                 return r;
 622
 623         q = cg_attach(controller, path, pid);
 624         if (q < 0)
 625                 return q;
 626
 627         /* This does not remove the cgroup on failure */
 628         return r;
 629 }
 630
 631 int cg_attach(const char *controller, const char *path, pid_t pid) {
 632         _cleanup_free_ char *fs = NULL;
 633         char c[DECIMAL_STR_MAX(pid_t) + 2];
 634         int r;
 635
 636         assert(path);
 637         assert(pid >= 0);
 638
 639         r = cg_get_path_and_check(controller, path, "cgroup.procs", &fs);
 640         if (r < 0)
 641                 return r;
 642
 643         if (pid == 0)
 644                 pid = getpid();
 645
 646         snprintf(c, sizeof(c), PID_FMT"\n", pid);
 647
 648         return write_string_file_no_create(fs, c);
 649 }
 650
 651 int cg_attach_fallback(const char *controller, const char *path, pid_t pid) {
 652         int r;
 653
 654         assert(controller);
 655         assert(path);
 656         assert(pid >= 0);
 657
 658         r = cg_attach(controller, path, pid);
 659         if (r < 0) {
 660                 char prefix[strlen(path) + 1];
 661
 662                 /* This didn't work? Then let's try all prefixes of
 663                  * the destination */
 664
 665                 PATH_FOREACH_PREFIX(prefix, path) {
 666                         r = cg_attach(controller, prefix, pid);
 667                         if (r >= 0)
 668                                 break;
 669                 }
 670         }
 671
 672         return 0;
 673 }
 674
 675 int cg_set_group_access(
 676                 const char *controller,
 677                 const char *path,
 678                 mode_t mode,
 679                 uid_t uid,
 680                 gid_t gid) {
 681
 682         _cleanup_free_ char *fs = NULL;
 683         int r;
 684
 685         assert(path);
 686
 687         if (mode != MODE_INVALID)
 688                 mode &= 0777;
 689
 690         r = cg_get_path(controller, path, NULL, &fs);
 691         if (r < 0)
 692                 return r;
 693
 694         return chmod_and_chown(fs, mode, uid, gid);
 695 }
 696
 697 int cg_set_task_access(
 698                 const char *controller,
 699                 const char *path,
 700                 mode_t mode,
 701                 uid_t uid,
 702                 gid_t gid) {
 703
 704         _cleanup_free_ char *fs = NULL, *procs = NULL;
 705         int r;
 706
 707         assert(path);
 708
 709         if (mode == MODE_INVALID && uid == UID_INVALID && gid == GID_INVALID)
 710                 return 0;
 711
 712         if (mode != MODE_INVALID)
 713                 mode &= 0666;
 714
 715         r = cg_get_path(controller, path, "cgroup.procs", &fs);
 716         if (r < 0)
 717                 return r;
 718
 719         r = chmod_and_chown(fs, mode, uid, gid);
 720         if (r < 0)
 721                 return r;
 722
 723         /* Compatibility, Always keep values for "tasks" in sync with
 724          * "cgroup.procs" */
 725         r = cg_get_path(controller, path, "tasks", &procs);
 726         if (r < 0)
 727                 return r;
 728
 729         return chmod_and_chown(procs, mode, uid, gid);
 730 }
 731
 732 int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
 733         _cleanup_fclose_ FILE *f = NULL;
 734         char line[LINE_MAX];
 735         const char *fs;
 736         size_t cs;
 737
 738         assert(path);
 739         assert(pid >= 0);
 740
 741         if (controller) {
 742                 if (!cg_controller_is_valid(controller, true))
 743                         return -EINVAL;
 744
 745                 controller = normalize_controller(controller);
 746         } else
 747                 controller = SYSTEMD_CGROUP_CONTROLLER;
 748
 749         fs = procfs_file_alloca(pid, "cgroup");
 750
 751         f = fopen(fs, "re");
 752         if (!f)
 753                 return errno == ENOENT ? -ESRCH : -errno;
 754
 755         cs = strlen(controller);
 756
 757         FOREACH_LINE(line, f, return -errno) {
 758                 char *l, *p, *e;
 759                 size_t k;
 760                 const char *word, *state;
 761                 bool found = false;
 762
 763                 truncate_nl(line);
 764
 765                 l = strchr(line, ':');
 766                 if (!l)
 767                         continue;
 768
 769                 l++;
 770                 e = strchr(l, ':');
 771                 if (!e)
 772                         continue;
 773
 774                 *e = 0;
 775
 776                 FOREACH_WORD_SEPARATOR(word, k, l, ",", state) {
 777
 778                         if (k == cs && memcmp(word, controller, cs) == 0) {
 779                                 found = true;
 780                                 break;
 781                         }
 782
 783                         if (k == 5 + cs &&
 784                             memcmp(word, "name=", 5) == 0 &&
 785                             memcmp(word+5, controller, cs) == 0) {
 786                                 found = true;
 787                                 break;
 788                         }
 789                 }
 790
 791                 if (!found)
 792                         continue;
 793
 794                 p = strdup(e + 1);
 795                 if (!p)
 796                         return -ENOMEM;
 797
 798                 *path = p;
 799                 return 0;
 800         }
 801
 802         return -ENOENT;
 803 }
 804
 805 int cg_install_release_agent(const char *controller, const char *agent) {
 806         _cleanup_free_ char *fs = NULL, *contents = NULL;
 807         char *sc;
 808         int r;
 809
 810         assert(agent);
 811
 812         r = cg_get_path(controller, NULL, "release_agent", &fs);
 813         if (r < 0)
 814                 return r;
 815
 816         r = read_one_line_file(fs, &contents);
 817         if (r < 0)
 818                 return r;
 819
 820         sc = strstrip(contents);
 821         if (sc[0] == 0) {
 822                 r = write_string_file_no_create(fs, agent);
 823                 if (r < 0)
 824                         return r;
 825         } else if (!streq(sc, agent))
 826                 return -EEXIST;
 827
 828         free(fs);
 829         fs = NULL;
 830         r = cg_get_path(controller, NULL, "notify_on_release", &fs);
 831         if (r < 0)
 832                 return r;
 833
 834         free(contents);
 835         contents = NULL;
 836         r = read_one_line_file(fs, &contents);
 837         if (r < 0)
 838                 return r;
 839
 840         sc = strstrip(contents);
 841         if (streq(sc, "0")) {
 842                 r = write_string_file_no_create(fs, "1");
 843                 if (r < 0)
 844                         return r;
 845
 846                 return 1;
 847         }
 848
 849         if (!streq(sc, "1"))
 850                 return -EIO;
 851
 852         return 0;
 853 }
 854
 855 int cg_uninstall_release_agent(const char *controller) {
 856         _cleanup_free_ char *fs = NULL;
 857         int r;
 858
 859         r = cg_get_path(controller, NULL, "notify_on_release", &fs);
 860         if (r < 0)
 861                 return r;
 862
 863         r = write_string_file_no_create(fs, "0");
 864         if (r < 0)
 865                 return r;
 866
 867         free(fs);
 868         fs = NULL;
 869
 870         r = cg_get_path(controller, NULL, "release_agent", &fs);
 871         if (r < 0)
 872                 return r;
 873
 874         r = write_string_file_no_create(fs, "");
 875         if (r < 0)
 876                 return r;
 877
 878         return 0;
 879 }
 880
 881 int cg_is_empty(const char *controller, const char *path, bool ignore_self) {
 882         _cleanup_fclose_ FILE *f = NULL;
 883         pid_t pid = 0, self_pid;
 884         bool found = false;
 885         int r;
 886
 887         assert(path);
 888
 889         r = cg_enumerate_processes(controller, path, &f);
 890         if (r < 0)
 891                 return r == -ENOENT ? 1 : r;
 892
 893         self_pid = getpid();
 894
 895         while ((r = cg_read_pid(f, &pid)) > 0) {
 896
 897                 if (ignore_self && pid == self_pid)
 898                         continue;
 899
 900                 found = true;
 901                 break;
 902         }
 903
 904         if (r < 0)
 905                 return r;
 906
 907         return !found;
 908 }
 909
 910 int cg_is_empty_recursive(const char *controller, const char *path, bool ignore_self) {
 911         _cleanup_closedir_ DIR *d = NULL;
 912         char *fn;
 913         int r;
 914
 915         assert(path);
 916
 917         r = cg_is_empty(controller, path, ignore_self);
 918         if (r <= 0)
 919                 return r;
 920
 921         r = cg_enumerate_subgroups(controller, path, &d);
 922         if (r < 0)
 923                 return r == -ENOENT ? 1 : r;
 924
 925         while ((r = cg_read_subgroup(d, &fn)) > 0) {
 926                 _cleanup_free_ char *p = NULL;
 927
 928                 p = strjoin(path, "/", fn, NULL);
 929                 free(fn);
 930                 if (!p)
 931                         return -ENOMEM;
 932
 933                 r = cg_is_empty_recursive(controller, p, ignore_self);
 934                 if (r <= 0)
 935                         return r;
 936         }
 937
 938         if (r < 0)
 939                 return r;
 940
 941         return 1;
 942 }
 943
 944 int cg_split_spec(const char *spec, char **controller, char **path) {
 945         const char *e;
 946         char *t = NULL, *u = NULL;
 947         _cleanup_free_ char *v = NULL;
 948
 949         assert(spec);
 950
 951         if (*spec == '/') {
 952                 if (!path_is_safe(spec))
 953                         return -EINVAL;
 954
 955                 if (path) {
 956                         t = strdup(spec);
 957                         if (!t)
 958                                 return -ENOMEM;
 959
 960                         *path = path_kill_slashes(t);
 961                 }
 962
 963                 if (controller)
 964                         *controller = NULL;
 965
 966                 return 0;
 967         }
 968
 969         e = strchr(spec, ':');
 970         if (!e) {
 971                 if (!cg_controller_is_valid(spec, true))
 972                         return -EINVAL;
 973
 974                 if (controller) {
 975                         t = strdup(normalize_controller(spec));
 976                         if (!t)
 977                                 return -ENOMEM;
 978
 979                         *controller = t;
 980                 }
 981
 982                 if (path)
 983                         *path = NULL;
 984
 985                 return 0;
 986         }
 987
 988         v = strndup(spec, e-spec);
 989         if (!v)
 990                 return -ENOMEM;
 991         t = strdup(normalize_controller(v));
 992         if (!t)
 993                 return -ENOMEM;
 994         if (!cg_controller_is_valid(t, true)) {
 995                 free(t);
 996                 return -EINVAL;
 997         }
 998
 999         if (streq(e+1, "")) {
1000                 u = strdup("/");
1001                 if (!u) {
1002                         free(t);
1003                         return -ENOMEM;
1004                 }
1005         } else {
1006                 u = strdup(e+1);
1007                 if (!u) {
1008                         free(t);
1009                         return -ENOMEM;
1010                 }
1011
1012                 if (!path_is_safe(u) ||
1013                     !path_is_absolute(u)) {
1014                         free(t);
1015                         free(u);
1016                         return -EINVAL;
1017                 }
1018
1019                 path_kill_slashes(u);
1020         }
1021
1022         if (controller)
1023                 *controller = t;
1024         else
1025                 free(t);
1026
1027         if (path)
1028                 *path = u;
1029         else
1030                 free(u);
1031
1032         return 0;
1033 }
1034
1035 int cg_mangle_path(const char *path, char **result) {
1036         _cleanup_free_ char *c = NULL, *p = NULL;
1037         char *t;
1038         int r;
1039
1040         assert(path);
1041         assert(result);
1042
1043         /* First, check if it already is a filesystem path */
1044         if (path_startswith(path, "/sys/fs/cgroup")) {
1045
1046                 t = strdup(path);
1047                 if (!t)
1048                         return -ENOMEM;
1049
1050                 *result = path_kill_slashes(t);
1051                 return 0;
1052         }
1053
1054         /* Otherwise, treat it as cg spec */
1055         r = cg_split_spec(path, &c, &p);
1056         if (r < 0)
1057                 return r;
1058
1059         return cg_get_path(c ? c : SYSTEMD_CGROUP_CONTROLLER, p ? p : "/", NULL, result);
1060 }
1061
1062 int cg_get_root_path(char **path) {
1063         char *p, *e;
1064         int r;
1065
1066         assert(path);
1067
1068         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 1, &p);
1069         if (r < 0)
1070                 return r;
1071
1072         e = endswith(p, "/" SPECIAL_SYSTEM_SLICE);
1073         if (e)
1074                 *e = 0;
1075
1076         *path = p;
1077         return 0;
1078 }
1079
1080 int cg_shift_path(const char *cgroup, const char *root, const char **shifted) {
1081         _cleanup_free_ char *rt = NULL;
1082         char *p;
1083         int r;
1084
1085         assert(cgroup);
1086         assert(shifted);
1087
1088         if (!root) {
1089                 /* If the root was specified let's use that, otherwise
1090                  * let's determine it from PID 1 */
1091
1092                 r = cg_get_root_path(&rt);
1093                 if (r < 0)
1094                         return r;
1095
1096                 root = rt;
1097         }
1098
1099         p = path_startswith(cgroup, root);
1100         if (p)
1101                 *shifted = p - 1;
1102         else
1103                 *shifted = cgroup;
1104
1105         return 0;
1106 }
1107
1108 int cg_pid_get_path_shifted(pid_t pid, const char *root, char **cgroup) {
1109         _cleanup_free_ char *raw = NULL;
1110         const char *c;
1111         int r;
1112
1113         assert(pid >= 0);
1114         assert(cgroup);
1115
1116         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &raw);
1117         if (r < 0)
1118                 return r;
1119
1120         r = cg_shift_path(raw, root, &c);
1121         if (r < 0)
1122                 return r;
1123
1124         if (c == raw) {
1125                 *cgroup = raw;
1126                 raw = NULL;
1127         } else {
1128                 char *n;
1129
1130                 n = strdup(c);
1131                 if (!n)
1132                         return -ENOMEM;
1133
1134                 *cgroup = n;
1135         }
1136
1137         return 0;
1138 }
1139
1140 int cg_path_decode_unit(const char *cgroup, char **unit){
1141         char *e, *c, *s;
1142
1143         assert(cgroup);
1144         assert(unit);
1145
1146         e = strchrnul(cgroup, '/');
1147         c = strndupa(cgroup, e - cgroup);
1148         c = cg_unescape(c);
1149
1150         if (!unit_name_is_valid(c, TEMPLATE_INVALID))
1151                 return -EINVAL;
1152
1153         s = strdup(c);
1154         if (!s)
1155                 return -ENOMEM;
1156
1157         *unit = s;
1158         return 0;
1159 }
1160
1161 static const char *skip_slices(const char *p) {
1162         /* Skips over all slice assignments */
1163
1164         for (;;) {
1165                 size_t n;
1166
1167                 p += strspn(p, "/");
1168
1169                 n = strcspn(p, "/");
1170                 if (n <= 6 || memcmp(p + n - 6, ".slice", 6) != 0)
1171                         return p;
1172
1173                 p += n;
1174         }
1175 }
1176
1177 int cg_path_get_unit(const char *path, char **unit) {
1178         const char *e;
1179
1180         assert(path);
1181         assert(unit);
1182
1183         e = skip_slices(path);
1184
1185         return cg_path_decode_unit(e, unit);
1186 }
1187
1188 int cg_pid_get_unit(pid_t pid, char **unit) {
1189         _cleanup_free_ char *cgroup = NULL;
1190         int r;
1191
1192         assert(unit);
1193
1194         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1195         if (r < 0)
1196                 return r;
1197
1198         return cg_path_get_unit(cgroup, unit);
1199 }
1200
1201 /**
1202  * Skip session-*.scope, but require it to be there.
1203  */
1204 static const char *skip_session(const char *p) {
1205         size_t n;
1206
1207         assert(p);
1208
1209         p += strspn(p, "/");
1210
1211         n = strcspn(p, "/");
1212         if (n < strlen("session-x.scope") || memcmp(p, "session-", 8) != 0 || memcmp(p + n - 6, ".scope", 6) != 0)
1213                 return NULL;
1214
1215         p += n;
1216         p += strspn(p, "/");
1217
1218         return p;
1219 }
1220
1221 /**
1222  * Skip user@*.service, but require it to be there.
1223  */
1224 static const char *skip_user_manager(const char *p) {
1225         size_t n;
1226
1227         assert(p);
1228
1229         p += strspn(p, "/");
1230
1231         n = strcspn(p, "/");
1232         if (n < strlen("user@x.service") || memcmp(p, "user@", 5) != 0 || memcmp(p + n - 8, ".service", 8) != 0)
1233                 return NULL;
1234
1235         p += n;
1236         p += strspn(p, "/");
1237
1238         return p;
1239 }
1240
1241 int cg_path_get_user_unit(const char *path, char **unit) {
1242         const char *e, *t;
1243
1244         assert(path);
1245         assert(unit);
1246
1247         /* We always have to parse the path from the beginning as unit
1248          * cgroups might have arbitrary child cgroups and we shouldn't get
1249          * confused by those */
1250
1251         /* Skip slices, if there are any */
1252         e = skip_slices(path);
1253
1254         /* Skip the session scope... */
1255         t = skip_session(e);
1256         if (t)
1257                 /* ... and skip more slices if there's one */
1258                 e = skip_slices(t);
1259         else {
1260                 /* ... or require a user manager unit to be there */
1261                 e = skip_user_manager(e);
1262                 if (!e)
1263                         return -ENOENT;
1264         }
1265
1266         return cg_path_decode_unit(e, unit);
1267 }
1268
1269 int cg_pid_get_user_unit(pid_t pid, char **unit) {
1270         _cleanup_free_ char *cgroup = NULL;
1271         int r;
1272
1273         assert(unit);
1274
1275         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1276         if (r < 0)
1277                 return r;
1278
1279         return cg_path_get_user_unit(cgroup, unit);
1280 }
1281
1282 int cg_path_get_machine_name(const char *path, char **machine) {
1283         _cleanup_free_ char *u = NULL, *sl = NULL;
1284         int r;
1285
1286         r = cg_path_get_unit(path, &u);
1287         if (r < 0)
1288                 return r;
1289
1290         sl = strjoin("/run/systemd/machines/unit:", u, NULL);
1291         if (!sl)
1292                 return -ENOMEM;
1293
1294         return readlink_malloc(sl, machine);
1295 }
1296
1297 int cg_pid_get_machine_name(pid_t pid, char **machine) {
1298         _cleanup_free_ char *cgroup = NULL;
1299         int r;
1300
1301         assert(machine);
1302
1303         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1304         if (r < 0)
1305                 return r;
1306
1307         return cg_path_get_machine_name(cgroup, machine);
1308 }
1309
1310 int cg_path_get_session(const char *path, char **session) {
1311         const char *e, *n, *x, *y;
1312         char *s;
1313
1314         assert(path);
1315
1316         /* Skip slices, if there are any */
1317         e = skip_slices(path);
1318
1319         n = strchrnul(e, '/');
1320         if (e == n)
1321                 return -ENOENT;
1322
1323         s = strndupa(e, n - e);
1324         s = cg_unescape(s);
1325
1326         x = startswith(s, "session-");
1327         if (!x)
1328                 return -ENOENT;
1329         y = endswith(x, ".scope");
1330         if (!y || x == y)
1331                 return -ENOENT;
1332
1333         if (session) {
1334                 char *r;
1335
1336                 r = strndup(x, y - x);
1337                 if (!r)
1338                         return -ENOMEM;
1339
1340                 *session = r;
1341         }
1342
1343         return 0;
1344 }
1345
1346 int cg_pid_get_session(pid_t pid, char **session) {
1347         _cleanup_free_ char *cgroup = NULL;
1348         int r;
1349
1350         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1351         if (r < 0)
1352                 return r;
1353
1354         return cg_path_get_session(cgroup, session);
1355 }
1356
1357 int cg_path_get_owner_uid(const char *path, uid_t *uid) {
1358         _cleanup_free_ char *slice = NULL;
1359         const char *start, *end;
1360         char *s;
1361         uid_t u;
1362         int r;
1363
1364         assert(path);
1365
1366         r = cg_path_get_slice(path, &slice);
1367         if (r < 0)
1368                 return r;
1369
1370         start = startswith(slice, "user-");
1371         if (!start)
1372                 return -ENOENT;
1373         end = endswith(slice, ".slice");
1374         if (!end)
1375                 return -ENOENT;
1376
1377         s = strndupa(start, end - start);
1378         if (!s)
1379                 return -ENOENT;
1380
1381         if (parse_uid(s, &u) < 0)
1382                 return -EIO;
1383
1384         if (uid)
1385                 *uid = u;
1386
1387         return 0;
1388 }
1389
1390 int cg_pid_get_owner_uid(pid_t pid, uid_t *uid) {
1391         _cleanup_free_ char *cgroup = NULL;
1392         int r;
1393
1394         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1395         if (r < 0)
1396                 return r;
1397
1398         return cg_path_get_owner_uid(cgroup, uid);
1399 }
1400
1401 int cg_path_get_slice(const char *p, char **slice) {
1402         const char *e = NULL;
1403         size_t m = 0;
1404
1405         assert(p);
1406         assert(slice);
1407
1408         for (;;) {
1409                 size_t n;
1410
1411                 p += strspn(p, "/");
1412
1413                 n = strcspn(p, "/");
1414                 if (n <= 6 || memcmp(p + n - 6, ".slice", 6) != 0) {
1415                         char *s;
1416
1417                         if (!e)
1418                                 return -ENOENT;
1419
1420                         s = strndup(e, m);
1421                         if (!s)
1422                                 return -ENOMEM;
1423
1424                         *slice = s;
1425                         return 0;
1426                 }
1427
1428                 e = p;
1429                 m = n;
1430
1431                 p += n;
1432         }
1433 }
1434
1435 int cg_pid_get_slice(pid_t pid, char **slice) {
1436         _cleanup_free_ char *cgroup = NULL;
1437         int r;
1438
1439         assert(slice);
1440
1441         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1442         if (r < 0)
1443                 return r;
1444
1445         return cg_path_get_slice(cgroup, slice);
1446 }
1447
1448 char *cg_escape(const char *p) {
1449         bool need_prefix = false;
1450
1451         /* This implements very minimal escaping for names to be used
1452          * as file names in the cgroup tree: any name which might
1453          * conflict with a kernel name or is prefixed with '_' is
1454          * prefixed with a '_'. That way, when reading cgroup names it
1455          * is sufficient to remove a single prefixing underscore if
1456          * there is one. */
1457
1458         /* The return value of this function (unlike cg_unescape())
1459          * needs free()! */
1460
1461         if (p[0] == 0 ||
1462             p[0] == '_' ||
1463             p[0] == '.' ||
1464             streq(p, "notify_on_release") ||
1465             streq(p, "release_agent") ||
1466             streq(p, "tasks"))
1467                 need_prefix = true;
1468         else {
1469                 const char *dot;
1470
1471                 dot = strrchr(p, '.');
1472                 if (dot) {
1473
1474                         if (dot - p == 6 && memcmp(p, "cgroup", 6) == 0)
1475                                 need_prefix = true;
1476                         else {
1477                                 char *n;
1478
1479                                 n = strndupa(p, dot - p);
1480
1481                                 if (check_hierarchy(n) >= 0)
1482                                         need_prefix = true;
1483                         }
1484                 }
1485         }
1486
1487         if (need_prefix)
1488                 return strappend("_", p);
1489         else
1490                 return strdup(p);
1491 }
1492
1493 char *cg_unescape(const char *p) {
1494         assert(p);
1495
1496         /* The return value of this function (unlike cg_escape())
1497          * doesn't need free()! */
1498
1499         if (p[0] == '_')
1500                 return (char*) p+1;
1501
1502         return (char*) p;
1503 }
1504
1505 #define CONTROLLER_VALID                        \
1506         DIGITS LETTERS                          \
1507         "_"
1508
1509 bool cg_controller_is_valid(const char *p, bool allow_named) {
1510         const char *t, *s;
1511
1512         if (!p)
1513                 return false;
1514
1515         if (allow_named) {
1516                 s = startswith(p, "name=");
1517                 if (s)
1518                         p = s;
1519         }
1520
1521         if (*p == 0 || *p == '_')
1522                 return false;
1523
1524         for (t = p; *t; t++)
1525                 if (!strchr(CONTROLLER_VALID, *t))
1526                         return false;
1527
1528         if (t - p > FILENAME_MAX)
1529                 return false;
1530
1531         return true;
1532 }
1533
1534 int cg_slice_to_path(const char *unit, char **ret) {
1535         _cleanup_free_ char *p = NULL, *s = NULL, *e = NULL;
1536         const char *dash;
1537
1538         assert(unit);
1539         assert(ret);
1540
1541         if (!unit_name_is_valid(unit, TEMPLATE_INVALID))
1542                 return -EINVAL;
1543
1544         if (!endswith(unit, ".slice"))
1545                 return -EINVAL;
1546
1547         p = unit_name_to_prefix(unit);
1548         if (!p)
1549                 return -ENOMEM;
1550
1551         dash = strchr(p, '-');
1552         while (dash) {
1553                 _cleanup_free_ char *escaped = NULL;
1554                 char n[dash - p + sizeof(".slice")];
1555
1556                 strcpy(stpncpy(n, p, dash - p), ".slice");
1557
1558                 if (!unit_name_is_valid(n, TEMPLATE_INVALID))
1559                         return -EINVAL;
1560
1561                 escaped = cg_escape(n);
1562                 if (!escaped)
1563                         return -ENOMEM;
1564
1565                 if (!strextend(&s, escaped, "/", NULL))
1566                         return -ENOMEM;
1567
1568                 dash = strchr(dash+1, '-');
1569         }
1570
1571         e = cg_escape(unit);
1572         if (!e)
1573                 return -ENOMEM;
1574
1575         if (!strextend(&s, e, NULL))
1576                 return -ENOMEM;
1577
1578         *ret = s;
1579         s = NULL;
1580
1581         return 0;
1582 }
1583
1584 int cg_set_attribute(const char *controller, const char *path, const char *attribute, const char *value) {
1585         _cleanup_free_ char *p = NULL;
1586         int r;
1587
1588         r = cg_get_path(controller, path, attribute, &p);
1589         if (r < 0)
1590                 return r;
1591
1592         return write_string_file_no_create(p, value);
1593 }
1594
1595 static const char mask_names[] =
1596         "cpu\0"
1597         "cpuacct\0"
1598         "blkio\0"
1599         "memory\0"
1600         "devices\0";
1601
1602 int cg_create_everywhere(CGroupControllerMask supported, CGroupControllerMask mask, const char *path) {
1603         CGroupControllerMask bit = 1;
1604         const char *n;
1605         int r;
1606
1607         /* This one will create a cgroup in our private tree, but also
1608          * duplicate it in the trees specified in mask, and remove it
1609          * in all others */
1610
1611         /* First create the cgroup in our own hierarchy. */
1612         r = cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1613         if (r < 0)
1614                 return r;
1615
1616         /* Then, do the same in the other hierarchies */
1617         NULSTR_FOREACH(n, mask_names) {
1618                 if (mask & bit)
1619                         cg_create(n, path);
1620                 else if (supported & bit)
1621                         cg_trim(n, path, true);
1622
1623                 bit <<= 1;
1624         }
1625
1626         return 0;
1627 }
1628
1629 int cg_attach_everywhere(CGroupControllerMask supported, const char *path, pid_t pid, cg_migrate_callback_t path_callback, void *userdata) {
1630         CGroupControllerMask bit = 1;
1631         const char *n;
1632         int r;
1633
1634         r = cg_attach(SYSTEMD_CGROUP_CONTROLLER, path, pid);
1635         if (r < 0)
1636                 return r;
1637
1638         NULSTR_FOREACH(n, mask_names) {
1639
1640                 if (supported & bit) {
1641                         const char *p = NULL;
1642
1643                         if (path_callback)
1644                                 p = path_callback(bit, userdata);
1645
1646                         if (!p)
1647                                 p = path;
1648
1649                         cg_attach_fallback(n, path, pid);
1650                 }
1651
1652                 bit <<= 1;
1653         }
1654
1655         return 0;
1656 }
1657
1658 int cg_attach_many_everywhere(CGroupControllerMask supported, const char *path, Set* pids, cg_migrate_callback_t path_callback, void *userdata) {
1659         Iterator i;
1660         void *pidp;
1661         int r = 0;
1662
1663         SET_FOREACH(pidp, pids, i) {
1664                 pid_t pid = PTR_TO_LONG(pidp);
1665                 int q;
1666
1667                 q = cg_attach_everywhere(supported, path, pid, path_callback, userdata);
1668                 if (q < 0)
1669                         r = q;
1670         }
1671
1672         return r;
1673 }
1674
1675 int cg_migrate_everywhere(CGroupControllerMask supported, const char *from, const char *to, cg_migrate_callback_t to_callback, void *userdata) {
1676         CGroupControllerMask bit = 1;
1677         const char *n;
1678         int r;
1679
1680         if (!path_equal(from, to))  {
1681                 r = cg_migrate_recursive(SYSTEMD_CGROUP_CONTROLLER, from, SYSTEMD_CGROUP_CONTROLLER, to, false, true);
1682                 if (r < 0)
1683                         return r;
1684         }
1685
1686         NULSTR_FOREACH(n, mask_names) {
1687                 if (supported & bit) {
1688                         const char *p = NULL;
1689
1690                         if (to_callback)
1691                                 p = to_callback(bit, userdata);
1692
1693                         if (!p)
1694                                 p = to;
1695
1696                         cg_migrate_recursive_fallback(SYSTEMD_CGROUP_CONTROLLER, to, n, p, false, false);
1697                 }
1698
1699                 bit <<= 1;
1700         }
1701
1702         return 0;
1703 }
1704
1705 int cg_trim_everywhere(CGroupControllerMask supported, const char *path, bool delete_root) {
1706         CGroupControllerMask bit = 1;
1707         const char *n;
1708         int r;
1709
1710         r = cg_trim(SYSTEMD_CGROUP_CONTROLLER, path, delete_root);
1711         if (r < 0)
1712                 return r;
1713
1714         NULSTR_FOREACH(n, mask_names) {
1715                 if (supported & bit)
1716                         cg_trim(n, path, delete_root);
1717
1718                 bit <<= 1;
1719         }
1720
1721         return 0;
1722 }
1723
1724 CGroupControllerMask cg_mask_supported(void) {
1725         CGroupControllerMask bit = 1, mask = 0;
1726         const char *n;
1727
1728         NULSTR_FOREACH(n, mask_names) {
1729                 if (check_hierarchy(n) >= 0)
1730                         mask |= bit;
1731
1732                 bit <<= 1;
1733         }
1734
1735         return mask;
1736 }
1737
1738 int cg_kernel_controllers(Set *controllers) {
1739         _cleanup_fclose_ FILE *f = NULL;
1740         char buf[LINE_MAX];
1741         int r;
1742
1743         assert(controllers);
1744
1745         f = fopen("/proc/cgroups", "re");
1746         if (!f) {
1747                 if (errno == ENOENT)
1748                         return 0;
1749                 return -errno;
1750         }
1751
1752         /* Ignore the header line */
1753         (void) fgets(buf, sizeof(buf), f);
1754
1755         for (;;) {
1756                 char *controller;
1757                 int enabled = 0;
1758
1759                 errno = 0;
1760                 if (fscanf(f, "%ms %*i %*i %i", &controller, &enabled) != 2) {
1761
1762                         if (feof(f))
1763                                 break;
1764
1765                         if (ferror(f) && errno)
1766                                 return -errno;
1767
1768                         return -EBADMSG;
1769                 }
1770
1771                 if (!enabled) {
1772                         free(controller);
1773                         continue;
1774                 }
1775
1776                 if (!filename_is_valid(controller)) {
1777                         free(controller);
1778                         return -EBADMSG;
1779                 }
1780
1781                 r = set_consume(controllers, controller);
1782                 if (r < 0)
1783                         return r;
1784         }
1785
1786         return 0;
1787 }