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 = strjoina("/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 or user manager... */
1255         t = skip_session(e);
1256         if (!t)
1257                 t = skip_user_manager(e);
1258         if (!t)
1259                 return -ENOENT;
1260
1261         /* ... and skip more slices if there are any */
1262         e = skip_slices(t);
1263
1264         return cg_path_decode_unit(e, unit);
1265 }
1266
1267 int cg_pid_get_user_unit(pid_t pid, char **unit) {
1268         _cleanup_free_ char *cgroup = NULL;
1269         int r;
1270
1271         assert(unit);
1272
1273         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1274         if (r < 0)
1275                 return r;
1276
1277         return cg_path_get_user_unit(cgroup, unit);
1278 }
1279
1280 int cg_path_get_machine_name(const char *path, char **machine) {
1281         _cleanup_free_ char *u = NULL, *sl = NULL;
1282         int r;
1283
1284         r = cg_path_get_unit(path, &u);
1285         if (r < 0)
1286                 return r;
1287
1288         sl = strjoin("/run/systemd/machines/unit:", u, NULL);
1289         if (!sl)
1290                 return -ENOMEM;
1291
1292         return readlink_malloc(sl, machine);
1293 }
1294
1295 int cg_pid_get_machine_name(pid_t pid, char **machine) {
1296         _cleanup_free_ char *cgroup = NULL;
1297         int r;
1298
1299         assert(machine);
1300
1301         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1302         if (r < 0)
1303                 return r;
1304
1305         return cg_path_get_machine_name(cgroup, machine);
1306 }
1307
1308 int cg_path_get_session(const char *path, char **session) {
1309         const char *e, *n, *x, *y;
1310         char *s;
1311
1312         assert(path);
1313
1314         /* Skip slices, if there are any */
1315         e = skip_slices(path);
1316
1317         n = strchrnul(e, '/');
1318         if (e == n)
1319                 return -ENOENT;
1320
1321         s = strndupa(e, n - e);
1322         s = cg_unescape(s);
1323
1324         x = startswith(s, "session-");
1325         if (!x)
1326                 return -ENOENT;
1327         y = endswith(x, ".scope");
1328         if (!y || x == y)
1329                 return -ENOENT;
1330
1331         if (session) {
1332                 char *r;
1333
1334                 r = strndup(x, y - x);
1335                 if (!r)
1336                         return -ENOMEM;
1337
1338                 *session = r;
1339         }
1340
1341         return 0;
1342 }
1343
1344 int cg_pid_get_session(pid_t pid, char **session) {
1345         _cleanup_free_ char *cgroup = NULL;
1346         int r;
1347
1348         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1349         if (r < 0)
1350                 return r;
1351
1352         return cg_path_get_session(cgroup, session);
1353 }
1354
1355 int cg_path_get_owner_uid(const char *path, uid_t *uid) {
1356         _cleanup_free_ char *slice = NULL;
1357         const char *start, *end;
1358         char *s;
1359         uid_t u;
1360         int r;
1361
1362         assert(path);
1363
1364         r = cg_path_get_slice(path, &slice);
1365         if (r < 0)
1366                 return r;
1367
1368         start = startswith(slice, "user-");
1369         if (!start)
1370                 return -ENOENT;
1371         end = endswith(slice, ".slice");
1372         if (!end)
1373                 return -ENOENT;
1374
1375         s = strndupa(start, end - start);
1376         if (!s)
1377                 return -ENOENT;
1378
1379         if (parse_uid(s, &u) < 0)
1380                 return -EIO;
1381
1382         if (uid)
1383                 *uid = u;
1384
1385         return 0;
1386 }
1387
1388 int cg_pid_get_owner_uid(pid_t pid, uid_t *uid) {
1389         _cleanup_free_ char *cgroup = NULL;
1390         int r;
1391
1392         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1393         if (r < 0)
1394                 return r;
1395
1396         return cg_path_get_owner_uid(cgroup, uid);
1397 }
1398
1399 int cg_path_get_slice(const char *p, char **slice) {
1400         const char *e = NULL;
1401         size_t m = 0;
1402
1403         assert(p);
1404         assert(slice);
1405
1406         for (;;) {
1407                 size_t n;
1408
1409                 p += strspn(p, "/");
1410
1411                 n = strcspn(p, "/");
1412                 if (n <= 6 || memcmp(p + n - 6, ".slice", 6) != 0) {
1413                         char *s;
1414
1415                         if (!e)
1416                                 return -ENOENT;
1417
1418                         s = strndup(e, m);
1419                         if (!s)
1420                                 return -ENOMEM;
1421
1422                         *slice = s;
1423                         return 0;
1424                 }
1425
1426                 e = p;
1427                 m = n;
1428
1429                 p += n;
1430         }
1431 }
1432
1433 int cg_pid_get_slice(pid_t pid, char **slice) {
1434         _cleanup_free_ char *cgroup = NULL;
1435         int r;
1436
1437         assert(slice);
1438
1439         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1440         if (r < 0)
1441                 return r;
1442
1443         return cg_path_get_slice(cgroup, slice);
1444 }
1445
1446 char *cg_escape(const char *p) {
1447         bool need_prefix = false;
1448
1449         /* This implements very minimal escaping for names to be used
1450          * as file names in the cgroup tree: any name which might
1451          * conflict with a kernel name or is prefixed with '_' is
1452          * prefixed with a '_'. That way, when reading cgroup names it
1453          * is sufficient to remove a single prefixing underscore if
1454          * there is one. */
1455
1456         /* The return value of this function (unlike cg_unescape())
1457          * needs free()! */
1458
1459         if (p[0] == 0 ||
1460             p[0] == '_' ||
1461             p[0] == '.' ||
1462             streq(p, "notify_on_release") ||
1463             streq(p, "release_agent") ||
1464             streq(p, "tasks"))
1465                 need_prefix = true;
1466         else {
1467                 const char *dot;
1468
1469                 dot = strrchr(p, '.');
1470                 if (dot) {
1471
1472                         if (dot - p == 6 && memcmp(p, "cgroup", 6) == 0)
1473                                 need_prefix = true;
1474                         else {
1475                                 char *n;
1476
1477                                 n = strndupa(p, dot - p);
1478
1479                                 if (check_hierarchy(n) >= 0)
1480                                         need_prefix = true;
1481                         }
1482                 }
1483         }
1484
1485         if (need_prefix)
1486                 return strappend("_", p);
1487         else
1488                 return strdup(p);
1489 }
1490
1491 char *cg_unescape(const char *p) {
1492         assert(p);
1493
1494         /* The return value of this function (unlike cg_escape())
1495          * doesn't need free()! */
1496
1497         if (p[0] == '_')
1498                 return (char*) p+1;
1499
1500         return (char*) p;
1501 }
1502
1503 #define CONTROLLER_VALID                        \
1504         DIGITS LETTERS                          \
1505         "_"
1506
1507 bool cg_controller_is_valid(const char *p, bool allow_named) {
1508         const char *t, *s;
1509
1510         if (!p)
1511                 return false;
1512
1513         if (allow_named) {
1514                 s = startswith(p, "name=");
1515                 if (s)
1516                         p = s;
1517         }
1518
1519         if (*p == 0 || *p == '_')
1520                 return false;
1521
1522         for (t = p; *t; t++)
1523                 if (!strchr(CONTROLLER_VALID, *t))
1524                         return false;
1525
1526         if (t - p > FILENAME_MAX)
1527                 return false;
1528
1529         return true;
1530 }
1531
1532 int cg_slice_to_path(const char *unit, char **ret) {
1533         _cleanup_free_ char *p = NULL, *s = NULL, *e = NULL;
1534         const char *dash;
1535
1536         assert(unit);
1537         assert(ret);
1538
1539         if (!unit_name_is_valid(unit, TEMPLATE_INVALID))
1540                 return -EINVAL;
1541
1542         if (!endswith(unit, ".slice"))
1543                 return -EINVAL;
1544
1545         p = unit_name_to_prefix(unit);
1546         if (!p)
1547                 return -ENOMEM;
1548
1549         dash = strchr(p, '-');
1550         while (dash) {
1551                 _cleanup_free_ char *escaped = NULL;
1552                 char n[dash - p + sizeof(".slice")];
1553
1554                 strcpy(stpncpy(n, p, dash - p), ".slice");
1555
1556                 if (!unit_name_is_valid(n, TEMPLATE_INVALID))
1557                         return -EINVAL;
1558
1559                 escaped = cg_escape(n);
1560                 if (!escaped)
1561                         return -ENOMEM;
1562
1563                 if (!strextend(&s, escaped, "/", NULL))
1564                         return -ENOMEM;
1565
1566                 dash = strchr(dash+1, '-');
1567         }
1568
1569         e = cg_escape(unit);
1570         if (!e)
1571                 return -ENOMEM;
1572
1573         if (!strextend(&s, e, NULL))
1574                 return -ENOMEM;
1575
1576         *ret = s;
1577         s = NULL;
1578
1579         return 0;
1580 }
1581
1582 int cg_set_attribute(const char *controller, const char *path, const char *attribute, const char *value) {
1583         _cleanup_free_ char *p = NULL;
1584         int r;
1585
1586         r = cg_get_path(controller, path, attribute, &p);
1587         if (r < 0)
1588                 return r;
1589
1590         return write_string_file_no_create(p, value);
1591 }
1592
1593 int cg_get_attribute(const char *controller, const char *path, const char *attribute, char **ret) {
1594         _cleanup_free_ char *p = NULL;
1595         int r;
1596
1597         r = cg_get_path(controller, path, attribute, &p);
1598         if (r < 0)
1599                 return r;
1600
1601         return read_one_line_file(p, ret);
1602 }
1603
1604 static const char mask_names[] =
1605         "cpu\0"
1606         "cpuacct\0"
1607         "blkio\0"
1608         "memory\0"
1609         "devices\0";
1610
1611 int cg_create_everywhere(CGroupControllerMask supported, CGroupControllerMask mask, const char *path) {
1612         CGroupControllerMask bit = 1;
1613         const char *n;
1614         int r;
1615
1616         /* This one will create a cgroup in our private tree, but also
1617          * duplicate it in the trees specified in mask, and remove it
1618          * in all others */
1619
1620         /* First create the cgroup in our own hierarchy. */
1621         r = cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1622         if (r < 0)
1623                 return r;
1624
1625         /* Then, do the same in the other hierarchies */
1626         NULSTR_FOREACH(n, mask_names) {
1627                 if (mask & bit)
1628                         cg_create(n, path);
1629                 else if (supported & bit)
1630                         cg_trim(n, path, true);
1631
1632                 bit <<= 1;
1633         }
1634
1635         return 0;
1636 }
1637
1638 int cg_attach_everywhere(CGroupControllerMask supported, const char *path, pid_t pid, cg_migrate_callback_t path_callback, void *userdata) {
1639         CGroupControllerMask bit = 1;
1640         const char *n;
1641         int r;
1642
1643         r = cg_attach(SYSTEMD_CGROUP_CONTROLLER, path, pid);
1644         if (r < 0)
1645                 return r;
1646
1647         NULSTR_FOREACH(n, mask_names) {
1648
1649                 if (supported & bit) {
1650                         const char *p = NULL;
1651
1652                         if (path_callback)
1653                                 p = path_callback(bit, userdata);
1654
1655                         if (!p)
1656                                 p = path;
1657
1658                         cg_attach_fallback(n, path, pid);
1659                 }
1660
1661                 bit <<= 1;
1662         }
1663
1664         return 0;
1665 }
1666
1667 int cg_attach_many_everywhere(CGroupControllerMask supported, const char *path, Set* pids, cg_migrate_callback_t path_callback, void *userdata) {
1668         Iterator i;
1669         void *pidp;
1670         int r = 0;
1671
1672         SET_FOREACH(pidp, pids, i) {
1673                 pid_t pid = PTR_TO_LONG(pidp);
1674                 int q;
1675
1676                 q = cg_attach_everywhere(supported, path, pid, path_callback, userdata);
1677                 if (q < 0)
1678                         r = q;
1679         }
1680
1681         return r;
1682 }
1683
1684 int cg_migrate_everywhere(CGroupControllerMask supported, const char *from, const char *to, cg_migrate_callback_t to_callback, void *userdata) {
1685         CGroupControllerMask bit = 1;
1686         const char *n;
1687         int r;
1688
1689         if (!path_equal(from, to))  {
1690                 r = cg_migrate_recursive(SYSTEMD_CGROUP_CONTROLLER, from, SYSTEMD_CGROUP_CONTROLLER, to, false, true);
1691                 if (r < 0)
1692                         return r;
1693         }
1694
1695         NULSTR_FOREACH(n, mask_names) {
1696                 if (supported & bit) {
1697                         const char *p = NULL;
1698
1699                         if (to_callback)
1700                                 p = to_callback(bit, userdata);
1701
1702                         if (!p)
1703                                 p = to;
1704
1705                         cg_migrate_recursive_fallback(SYSTEMD_CGROUP_CONTROLLER, to, n, p, false, false);
1706                 }
1707
1708                 bit <<= 1;
1709         }
1710
1711         return 0;
1712 }
1713
1714 int cg_trim_everywhere(CGroupControllerMask supported, const char *path, bool delete_root) {
1715         CGroupControllerMask bit = 1;
1716         const char *n;
1717         int r;
1718
1719         r = cg_trim(SYSTEMD_CGROUP_CONTROLLER, path, delete_root);
1720         if (r < 0)
1721                 return r;
1722
1723         NULSTR_FOREACH(n, mask_names) {
1724                 if (supported & bit)
1725                         cg_trim(n, path, delete_root);
1726
1727                 bit <<= 1;
1728         }
1729
1730         return 0;
1731 }
1732
1733 CGroupControllerMask cg_mask_supported(void) {
1734         CGroupControllerMask bit = 1, mask = 0;
1735         const char *n;
1736
1737         NULSTR_FOREACH(n, mask_names) {
1738                 if (check_hierarchy(n) >= 0)
1739                         mask |= bit;
1740
1741                 bit <<= 1;
1742         }
1743
1744         return mask;
1745 }
1746
1747 int cg_kernel_controllers(Set *controllers) {
1748         _cleanup_fclose_ FILE *f = NULL;
1749         char buf[LINE_MAX];
1750         int r;
1751
1752         assert(controllers);
1753
1754         f = fopen("/proc/cgroups", "re");
1755         if (!f) {
1756                 if (errno == ENOENT)
1757                         return 0;
1758                 return -errno;
1759         }
1760
1761         /* Ignore the header line */
1762         (void) fgets(buf, sizeof(buf), f);
1763
1764         for (;;) {
1765                 char *controller;
1766                 int enabled = 0;
1767
1768                 errno = 0;
1769                 if (fscanf(f, "%ms %*i %*i %i", &controller, &enabled) != 2) {
1770
1771                         if (feof(f))
1772                                 break;
1773
1774                         if (ferror(f) && errno)
1775                                 return -errno;
1776
1777                         return -EBADMSG;
1778                 }
1779
1780                 if (!enabled) {
1781                         free(controller);
1782                         continue;
1783                 }
1784
1785                 if (!filename_is_valid(controller)) {
1786                         free(controller);
1787                         return -EBADMSG;
1788                 }
1789
1790                 r = set_consume(controllers, controller);
1791                 if (r < 0)
1792                         return r;
1793         }
1794
1795         return 0;
1796 }