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
  42 int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {
  43         _cleanup_free_ char *fs = NULL;
  44         FILE *f;
  45         int r;
  46
  47         assert(_f);
  48
  49         r = cg_get_path(controller, path, "cgroup.procs", &fs);
  50         if (r < 0)
  51                 return r;
  52
  53         f = fopen(fs, "re");
  54         if (!f)
  55                 return -errno;
  56
  57         *_f = f;
  58         return 0;
  59 }
  60
  61 int cg_enumerate_tasks(const char *controller, const char *path, FILE **_f) {
  62         _cleanup_free_ char *fs = NULL;
  63         FILE *f;
  64         int r;
  65
  66         assert(_f);
  67
  68         r = cg_get_path(controller, path, "tasks", &fs);
  69         if (r < 0)
  70                 return r;
  71
  72         f = fopen(fs, "re");
  73         if (!f)
  74                 return -errno;
  75
  76         *_f = f;
  77         return 0;
  78 }
  79
  80 int cg_read_pid(FILE *f, pid_t *_pid) {
  81         unsigned long ul;
  82
  83         /* Note that the cgroup.procs might contain duplicates! See
  84          * cgroups.txt for details. */
  85
  86         assert(f);
  87         assert(_pid);
  88
  89         errno = 0;
  90         if (fscanf(f, "%lu", &ul) != 1) {
  91
  92                 if (feof(f))
  93                         return 0;
  94
  95                 return errno ? -errno : -EIO;
  96         }
  97
  98         if (ul <= 0)
  99                 return -EIO;
 100
 101         *_pid = (pid_t) ul;
 102         return 1;
 103 }
 104
 105 int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {
 106         _cleanup_free_ char *fs = NULL;
 107         int r;
 108         DIR *d;
 109
 110         assert(_d);
 111
 112         /* This is not recursive! */
 113
 114         r = cg_get_path(controller, path, NULL, &fs);
 115         if (r < 0)
 116                 return r;
 117
 118         d = opendir(fs);
 119         if (!d)
 120                 return -errno;
 121
 122         *_d = d;
 123         return 0;
 124 }
 125
 126 int cg_read_subgroup(DIR *d, char **fn) {
 127         struct dirent *de;
 128
 129         assert(d);
 130         assert(fn);
 131
 132         FOREACH_DIRENT(de, d, return -errno) {
 133                 char *b;
 134
 135                 if (de->d_type != DT_DIR)
 136                         continue;
 137
 138                 if (streq(de->d_name, ".") ||
 139                     streq(de->d_name, ".."))
 140                         continue;
 141
 142                 b = strdup(de->d_name);
 143                 if (!b)
 144                         return -ENOMEM;
 145
 146                 *fn = b;
 147                 return 1;
 148         }
 149
 150         return 0;
 151 }
 152
 153 int cg_rmdir(const char *controller, const char *path, bool honour_sticky) {
 154         _cleanup_free_ char *p = NULL;
 155         int r;
 156
 157         r = cg_get_path(controller, path, NULL, &p);
 158         if (r < 0)
 159                 return r;
 160
 161         if (honour_sticky) {
 162                 char *tasks;
 163
 164                 /* If the sticky bit is set don't remove the directory */
 165
 166                 tasks = strappend(p, "/tasks");
 167                 if (!tasks)
 168                         return -ENOMEM;
 169
 170                 r = file_is_priv_sticky(tasks);
 171                 free(tasks);
 172
 173                 if (r > 0)
 174                         return 0;
 175         }
 176
 177         r = rmdir(p);
 178         if (r < 0 && errno != ENOENT)
 179                 return -errno;
 180
 181         return 0;
 182 }
 183
 184 int cg_kill(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, Set *s) {
 185         _cleanup_set_free_ Set *allocated_set = NULL;
 186         bool done = false;
 187         int r, ret = 0;
 188         pid_t my_pid;
 189
 190         assert(sig >= 0);
 191
 192         /* This goes through the tasks list and kills them all. This
 193          * is repeated until no further processes are added to the
 194          * tasks list, to properly handle forking processes */
 195
 196         if (!s) {
 197                 s = allocated_set = set_new(trivial_hash_func, trivial_compare_func);
 198                 if (!s)
 199                         return -ENOMEM;
 200         }
 201
 202         my_pid = getpid();
 203
 204         do {
 205                 _cleanup_fclose_ FILE *f = NULL;
 206                 pid_t pid = 0;
 207                 done = true;
 208
 209                 r = cg_enumerate_processes(controller, path, &f);
 210                 if (r < 0) {
 211                         if (ret >= 0 && r != -ENOENT)
 212                                 return r;
 213
 214                         return ret;
 215                 }
 216
 217                 while ((r = cg_read_pid(f, &pid)) > 0) {
 218
 219                         if (ignore_self && pid == my_pid)
 220                                 continue;
 221
 222                         if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid))
 223                                 continue;
 224
 225                         /* If we haven't killed this process yet, kill
 226                          * it */
 227                         if (kill(pid, sig) < 0) {
 228                                 if (ret >= 0 && errno != ESRCH)
 229                                         ret = -errno;
 230                         } else if (ret == 0) {
 231
 232                                 if (sigcont)
 233                                         kill(pid, SIGCONT);
 234
 235                                 ret = 1;
 236                         }
 237
 238                         done = false;
 239
 240                         r = set_put(s, LONG_TO_PTR(pid));
 241                         if (r < 0) {
 242                                 if (ret >= 0)
 243                                         return r;
 244
 245                                 return ret;
 246                         }
 247                 }
 248
 249                 if (r < 0) {
 250                         if (ret >= 0)
 251                                 return r;
 252
 253                         return ret;
 254                 }
 255
 256                 /* To avoid racing against processes which fork
 257                  * quicker than we can kill them we repeat this until
 258                  * no new pids need to be killed. */
 259
 260         } while (!done);
 261
 262         return ret;
 263 }
 264
 265 int cg_kill_recursive(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, bool rem, Set *s) {
 266         _cleanup_set_free_ Set *allocated_set = NULL;
 267         _cleanup_closedir_ DIR *d = NULL;
 268         int r, ret = 0;
 269         char *fn;
 270
 271         assert(path);
 272         assert(sig >= 0);
 273
 274         if (!s) {
 275                 s = allocated_set = set_new(trivial_hash_func, trivial_compare_func);
 276                 if (!s)
 277                         return -ENOMEM;
 278         }
 279
 280         ret = cg_kill(controller, path, sig, sigcont, ignore_self, s);
 281
 282         r = cg_enumerate_subgroups(controller, path, &d);
 283         if (r < 0) {
 284                 if (ret >= 0 && r != -ENOENT)
 285                         return r;
 286
 287                 return ret;
 288         }
 289
 290         while ((r = cg_read_subgroup(d, &fn)) > 0) {
 291                 _cleanup_free_ char *p = NULL;
 292
 293                 p = strjoin(path, "/", fn, NULL);
 294                 free(fn);
 295                 if (!p)
 296                         return -ENOMEM;
 297
 298                 r = cg_kill_recursive(controller, p, sig, sigcont, ignore_self, rem, s);
 299                 if (ret >= 0 && r != 0)
 300                         ret = r;
 301         }
 302
 303         if (ret >= 0 && r < 0)
 304                 ret = r;
 305
 306         if (rem) {
 307                 r = cg_rmdir(controller, path, true);
 308                 if (r < 0 && ret >= 0 && r != -ENOENT && r != -EBUSY)
 309                         return r;
 310         }
 311
 312         return ret;
 313 }
 314
 315 int cg_kill_recursive_and_wait(const char *controller, const char *path, bool rem) {
 316         unsigned i;
 317
 318         assert(path);
 319
 320         /* This safely kills all processes; first it sends a SIGTERM,
 321          * then checks 8 times after 200ms whether the group is now
 322          * empty, then kills everything that is left with SIGKILL and
 323          * finally checks 5 times after 200ms each whether the group
 324          * is finally empty. */
 325
 326         for (i = 0; i < 15; i++) {
 327                 int sig, r;
 328
 329                 if (i <= 0)
 330                         sig = SIGTERM;
 331                 else if (i == 9)
 332                         sig = SIGKILL;
 333                 else
 334                         sig = 0;
 335
 336                 r = cg_kill_recursive(controller, path, sig, true, true, rem, NULL);
 337                 if (r <= 0)
 338                         return r;
 339
 340                 usleep(200 * USEC_PER_MSEC);
 341         }
 342
 343         return 0;
 344 }
 345
 346 int cg_migrate(const char *cfrom, const char *pfrom, const char *cto, const char *pto, bool ignore_self) {
 347         bool done = false;
 348         _cleanup_set_free_ Set *s = NULL;
 349         int r, ret = 0;
 350         pid_t my_pid;
 351
 352         assert(cfrom);
 353         assert(pfrom);
 354         assert(cto);
 355         assert(pto);
 356
 357         s = set_new(trivial_hash_func, trivial_compare_func);
 358         if (!s)
 359                 return -ENOMEM;
 360
 361         my_pid = getpid();
 362
 363         do {
 364                 _cleanup_fclose_ FILE *f = NULL;
 365                 pid_t pid = 0;
 366                 done = true;
 367
 368                 r = cg_enumerate_tasks(cfrom, pfrom, &f);
 369                 if (r < 0) {
 370                         if (ret >= 0 && r != -ENOENT)
 371                                 return r;
 372
 373                         return ret;
 374                 }
 375
 376                 while ((r = cg_read_pid(f, &pid)) > 0) {
 377
 378                         /* This might do weird stuff if we aren't a
 379                          * single-threaded program. However, we
 380                          * luckily know we are not */
 381                         if (ignore_self && pid == my_pid)
 382                                 continue;
 383
 384                         if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid))
 385                                 continue;
 386
 387                         r = cg_attach(cto, pto, pid);
 388                         if (r < 0) {
 389                                 if (ret >= 0 && r != -ESRCH)
 390                                         ret = r;
 391                         } else if (ret == 0)
 392                                 ret = 1;
 393
 394                         done = false;
 395
 396                         r = set_put(s, LONG_TO_PTR(pid));
 397                         if (r < 0) {
 398                                 if (ret >= 0)
 399                                         return r;
 400
 401                                 return ret;
 402                         }
 403                 }
 404
 405                 if (r < 0) {
 406                         if (ret >= 0)
 407                                 return r;
 408
 409                         return ret;
 410                 }
 411         } while (!done);
 412
 413         return ret;
 414 }
 415
 416 int cg_migrate_recursive(const char *cfrom, const char *pfrom, const char *cto, const char *pto, bool ignore_self, bool rem) {
 417         _cleanup_closedir_ DIR *d = NULL;
 418         int r, ret = 0;
 419         char *fn;
 420
 421         assert(cfrom);
 422         assert(pfrom);
 423         assert(cto);
 424         assert(pto);
 425
 426         ret = cg_migrate(cfrom, pfrom, cto, pto, ignore_self);
 427
 428         r = cg_enumerate_subgroups(cfrom, pfrom, &d);
 429         if (r < 0) {
 430                 if (ret >= 0 && r != -ENOENT)
 431                         return r;
 432
 433                 return ret;
 434         }
 435
 436         while ((r = cg_read_subgroup(d, &fn)) > 0) {
 437                 _cleanup_free_ char *p = NULL;
 438
 439                 p = strjoin(pfrom, "/", fn, NULL);
 440                 free(fn);
 441                 if (!p) {
 442                         if (ret >= 0)
 443                                 return -ENOMEM;
 444
 445                         return ret;
 446                 }
 447
 448                 r = cg_migrate_recursive(cfrom, p, cto, pto, ignore_self, rem);
 449                 if (r != 0 && ret >= 0)
 450                         ret = r;
 451         }
 452
 453         if (r < 0 && ret >= 0)
 454                 ret = r;
 455
 456         if (rem) {
 457                 r = cg_rmdir(cfrom, pfrom, true);
 458                 if (r < 0 && ret >= 0 && r != -ENOENT && r != -EBUSY)
 459                         return r;
 460         }
 461
 462         return ret;
 463 }
 464
 465 static const char *normalize_controller(const char *controller) {
 466
 467         assert(controller);
 468
 469         if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
 470                 return "systemd";
 471         else if (startswith(controller, "name="))
 472                 return controller + 5;
 473         else
 474                 return controller;
 475 }
 476
 477 static int join_path(const char *controller, const char *path, const char *suffix, char **fs) {
 478         char *t = NULL;
 479
 480         if (controller) {
 481                 if (path && suffix)
 482                         t = strjoin("/sys/fs/cgroup/", controller, "/", path, "/", suffix, NULL);
 483                 else if (path)
 484                         t = strjoin("/sys/fs/cgroup/", controller, "/", path, NULL);
 485                 else if (suffix)
 486                         t = strjoin("/sys/fs/cgroup/", controller, "/", suffix, NULL);
 487                 else
 488                         t = strappend("/sys/fs/cgroup/", controller);
 489         } else {
 490                 if (path && suffix)
 491                         t = strjoin(path, "/", suffix, NULL);
 492                 else if (path)
 493                         t = strdup(path);
 494                 else
 495                         return -EINVAL;
 496         }
 497
 498         if (!t)
 499                 return -ENOMEM;
 500
 501         path_kill_slashes(t);
 502
 503         *fs = t;
 504         return 0;
 505 }
 506
 507 int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {
 508         const char *p;
 509         static __thread bool good = false;
 510
 511         assert(fs);
 512
 513         if (controller && !cg_controller_is_valid(controller, true))
 514                 return -EINVAL;
 515
 516         if (_unlikely_(!good)) {
 517                 int r;
 518
 519                 r = path_is_mount_point("/sys/fs/cgroup", false);
 520                 if (r <= 0)
 521                         return r < 0 ? r : -ENOENT;
 522
 523                 /* Cache this to save a few stat()s */
 524                 good = true;
 525         }
 526
 527         p = controller ? normalize_controller(controller) : NULL;
 528
 529         return join_path(p, path, suffix, fs);
 530 }
 531
 532 static int check_hierarchy(const char *p) {
 533         char *cc;
 534
 535         assert(p);
 536
 537         /* Check if this controller actually really exists */
 538         cc = alloca(sizeof("/sys/fs/cgroup/") + strlen(p));
 539         strcpy(stpcpy(cc, "/sys/fs/cgroup/"), p);
 540         if (access(cc, F_OK) < 0)
 541                 return -errno;
 542
 543         return 0;
 544 }
 545
 546 int cg_get_path_and_check(const char *controller, const char *path, const char *suffix, char **fs) {
 547         const char *p;
 548         int r;
 549
 550         assert(fs);
 551
 552         if (!cg_controller_is_valid(controller, true))
 553                 return -EINVAL;
 554
 555         /* Normalize the controller syntax */
 556         p = normalize_controller(controller);
 557
 558         /* Check if this controller actually really exists */
 559         r = check_hierarchy(p);
 560         if (r < 0)
 561                 return r;
 562
 563         return join_path(p, path, suffix, fs);
 564 }
 565
 566 static int trim_cb(const char *path, const struct stat *sb, int typeflag, struct FTW *ftwbuf) {
 567         char *p;
 568         bool is_sticky;
 569
 570         if (typeflag != FTW_DP)
 571                 return 0;
 572
 573         if (ftwbuf->level < 1)
 574                 return 0;
 575
 576         p = strappend(path, "/tasks");
 577         if (!p) {
 578                 errno = ENOMEM;
 579                 return 1;
 580         }
 581
 582         is_sticky = file_is_priv_sticky(p) > 0;
 583         free(p);
 584
 585         if (is_sticky)
 586                 return 0;
 587
 588         rmdir(path);
 589         return 0;
 590 }
 591
 592 int cg_trim(const char *controller, const char *path, bool delete_root) {
 593         _cleanup_free_ char *fs = NULL;
 594         int r = 0;
 595
 596         assert(path);
 597
 598         r = cg_get_path(controller, path, NULL, &fs);
 599         if (r < 0)
 600                 return r;
 601
 602         errno = 0;
 603         if (nftw(fs, trim_cb, 64, FTW_DEPTH|FTW_MOUNT|FTW_PHYS) != 0)
 604                 r = errno ? -errno : -EIO;
 605
 606         if (delete_root) {
 607                 bool is_sticky;
 608                 char *p;
 609
 610                 p = strappend(fs, "/tasks");
 611                 if (!p)
 612                         return -ENOMEM;
 613
 614                 is_sticky = file_is_priv_sticky(p) > 0;
 615                 free(p);
 616
 617                 if (!is_sticky)
 618                         if (rmdir(fs) < 0 && errno != ENOENT && r == 0)
 619                                 return -errno;
 620         }
 621
 622         return r;
 623 }
 624
 625 int cg_delete(const char *controller, const char *path) {
 626         _cleanup_free_ char *parent = NULL;
 627         int r;
 628
 629         assert(path);
 630
 631         r = path_get_parent(path, &parent);
 632         if (r < 0)
 633                 return r;
 634
 635         r = cg_migrate_recursive(controller, path, controller, parent, false, true);
 636         return r == -ENOENT ? 0 : r;
 637 }
 638
 639 int cg_attach(const char *controller, const char *path, pid_t pid) {
 640         _cleanup_free_ char *fs = NULL;
 641         char c[DECIMAL_STR_MAX(pid_t) + 2];
 642         int r;
 643
 644         assert(path);
 645         assert(pid >= 0);
 646
 647         r = cg_get_path_and_check(controller, path, "tasks", &fs);
 648         if (r < 0)
 649                 return r;
 650
 651         if (pid == 0)
 652                 pid = getpid();
 653
 654         snprintf(c, sizeof(c), "%lu\n", (unsigned long) pid);
 655
 656         return write_string_file(fs, c);
 657 }
 658
 659 int cg_set_group_access(
 660                 const char *controller,
 661                 const char *path,
 662                 mode_t mode,
 663                 uid_t uid,
 664                 gid_t gid) {
 665
 666         _cleanup_free_ char *fs = NULL;
 667         int r;
 668
 669         assert(path);
 670
 671         if (mode != (mode_t) -1)
 672                 mode &= 0777;
 673
 674         r = cg_get_path(controller, path, NULL, &fs);
 675         if (r < 0)
 676                 return r;
 677
 678         return chmod_and_chown(fs, mode, uid, gid);
 679 }
 680
 681 int cg_set_task_access(
 682                 const char *controller,
 683                 const char *path,
 684                 mode_t mode,
 685                 uid_t uid,
 686                 gid_t gid,
 687                 int sticky) {
 688
 689         _cleanup_free_ char *fs = NULL, *procs = NULL;
 690         int r;
 691
 692         assert(path);
 693
 694         if (mode == (mode_t) -1 && uid == (uid_t) -1 && gid == (gid_t) -1 && sticky < 0)
 695                 return 0;
 696
 697         if (mode != (mode_t) -1)
 698                 mode &= 0666;
 699
 700         r = cg_get_path(controller, path, "tasks", &fs);
 701         if (r < 0)
 702                 return r;
 703
 704         if (sticky >= 0 && mode != (mode_t) -1)
 705                 /* Both mode and sticky param are passed */
 706                 mode |= (sticky ? S_ISVTX : 0);
 707         else if ((sticky >= 0 && mode == (mode_t) -1) ||
 708                  (mode != (mode_t) -1 && sticky < 0)) {
 709                 struct stat st;
 710
 711                 /* Only one param is passed, hence read the current
 712                  * mode from the file itself */
 713
 714                 r = lstat(fs, &st);
 715                 if (r < 0)
 716                         return -errno;
 717
 718                 if (mode == (mode_t) -1)
 719                         /* No mode set, we just shall set the sticky bit */
 720                         mode = (st.st_mode & ~S_ISVTX) | (sticky ? S_ISVTX : 0);
 721                 else
 722                         /* Only mode set, leave sticky bit untouched */
 723                         mode = (st.st_mode & ~0777) | mode;
 724         }
 725
 726         r = chmod_and_chown(fs, mode, uid, gid);
 727         if (r < 0)
 728                 return r;
 729
 730         /* Always keep values for "cgroup.procs" in sync with "tasks" */
 731         r = cg_get_path(controller, path, "cgroup.procs", &procs);
 732         if (r < 0)
 733                 return r;
 734
 735         return chmod_and_chown(procs, mode, uid, gid);
 736 }
 737
 738 int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
 739         _cleanup_fclose_ FILE *f = NULL;
 740         char line[LINE_MAX];
 741         const char *fs;
 742         size_t cs;
 743
 744         assert(path);
 745         assert(pid >= 0);
 746
 747         if (controller) {
 748                 if (!cg_controller_is_valid(controller, true))
 749                         return -EINVAL;
 750
 751                 controller = normalize_controller(controller);
 752         } else
 753                 controller = SYSTEMD_CGROUP_CONTROLLER;
 754
 755         if (pid == 0)
 756                 fs = "/proc/self/cgroup";
 757         else
 758                 fs = procfs_file_alloca(pid, "cgroup");
 759
 760         f = fopen(fs, "re");
 761         if (!f)
 762                 return errno == ENOENT ? -ESRCH : -errno;
 763
 764         cs = strlen(controller);
 765
 766         FOREACH_LINE(line, f, return -errno) {
 767                 char *l, *p, *w, *e;
 768                 size_t k;
 769                 char *state;
 770                 bool found = false;
 771
 772                 truncate_nl(line);
 773
 774                 l = strchr(line, ':');
 775                 if (!l)
 776                         continue;
 777
 778                 l++;
 779                 e = strchr(l, ':');
 780                 if (!e)
 781                         continue;
 782
 783                 *e = 0;
 784
 785                 FOREACH_WORD_SEPARATOR(w, k, l, ",", state) {
 786
 787                         if (k == cs && memcmp(w, controller, cs) == 0) {
 788                                 found = true;
 789                                 break;
 790                         }
 791
 792                         if (k == 5 + cs &&
 793                             memcmp(w, "name=", 5) == 0 &&
 794                             memcmp(w+5, controller, cs) == 0) {
 795                                 found = true;
 796                                 break;
 797                         }
 798                 }
 799
 800                 if (!found)
 801                         continue;
 802
 803                 p = strdup(e + 1);
 804                 if (!p)
 805                         return -ENOMEM;
 806
 807                 *path = p;
 808                 return 0;
 809         }
 810
 811         return -ENOENT;
 812 }
 813
 814 int cg_install_release_agent(const char *controller, const char *agent) {
 815         _cleanup_free_ char *fs = NULL, *contents = NULL;
 816         char *sc;
 817         int r;
 818
 819         assert(agent);
 820
 821         r = cg_get_path(controller, NULL, "release_agent", &fs);
 822         if (r < 0)
 823                 return r;
 824
 825         r = read_one_line_file(fs, &contents);
 826         if (r < 0)
 827                 return r;
 828
 829         sc = strstrip(contents);
 830         if (sc[0] == 0) {
 831                 r = write_string_file(fs, agent);
 832                 if (r < 0)
 833                         return r;
 834         } else if (!streq(sc, agent))
 835                 return -EEXIST;
 836
 837         free(fs);
 838         fs = NULL;
 839         r = cg_get_path(controller, NULL, "notify_on_release", &fs);
 840         if (r < 0)
 841                 return r;
 842
 843         free(contents);
 844         contents = NULL;
 845         r = read_one_line_file(fs, &contents);
 846         if (r < 0)
 847                 return r;
 848
 849         sc = strstrip(contents);
 850         if (streq(sc, "0")) {
 851                 r = write_string_file(fs, "1");
 852                 if (r < 0)
 853                         return r;
 854
 855                 return 1;
 856         }
 857
 858         if (!streq(sc, "1"))
 859                 return -EIO;
 860
 861         return 0;
 862 }
 863
 864 int cg_is_empty(const char *controller, const char *path, bool ignore_self) {
 865         _cleanup_fclose_ FILE *f = NULL;
 866         pid_t pid = 0, self_pid;
 867         bool found = false;
 868         int r;
 869
 870         assert(path);
 871
 872         r = cg_enumerate_tasks(controller, path, &f);
 873         if (r < 0)
 874                 return r == -ENOENT ? 1 : r;
 875
 876         self_pid = getpid();
 877
 878         while ((r = cg_read_pid(f, &pid)) > 0) {
 879
 880                 if (ignore_self && pid == self_pid)
 881                         continue;
 882
 883                 found = true;
 884                 break;
 885         }
 886
 887         if (r < 0)
 888                 return r;
 889
 890         return !found;
 891 }
 892
 893 int cg_is_empty_by_spec(const char *spec, bool ignore_self) {
 894         _cleanup_free_ char *controller = NULL, *path = NULL;
 895         int r;
 896
 897         assert(spec);
 898
 899         r = cg_split_spec(spec, &controller, &path);
 900         if (r < 0)
 901                 return r;
 902
 903         return cg_is_empty(controller, path, ignore_self);
 904 }
 905
 906 int cg_is_empty_recursive(const char *controller, const char *path, bool ignore_self) {
 907         _cleanup_closedir_ DIR *d = NULL;
 908         char *fn;
 909         int r;
 910
 911         assert(path);
 912
 913         r = cg_is_empty(controller, path, ignore_self);
 914         if (r <= 0)
 915                 return r;
 916
 917         r = cg_enumerate_subgroups(controller, path, &d);
 918         if (r < 0)
 919                 return r == -ENOENT ? 1 : r;
 920
 921         while ((r = cg_read_subgroup(d, &fn)) > 0) {
 922                 _cleanup_free_ char *p = NULL;
 923
 924                 p = strjoin(path, "/", fn, NULL);
 925                 free(fn);
 926                 if (!p)
 927                         return -ENOMEM;
 928
 929                 r = cg_is_empty_recursive(controller, p, ignore_self);
 930                 if (r <= 0)
 931                         return r;
 932         }
 933
 934         if (r < 0)
 935                 return r;
 936
 937         return 1;
 938 }
 939
 940 int cg_split_spec(const char *spec, char **controller, char **path) {
 941         const char *e;
 942         char *t = NULL, *u = NULL;
 943         _cleanup_free_ char *v = NULL;
 944
 945         assert(spec);
 946
 947         if (*spec == '/') {
 948                 if (!path_is_safe(spec))
 949                         return -EINVAL;
 950
 951                 if (path) {
 952                         t = strdup(spec);
 953                         if (!t)
 954                                 return -ENOMEM;
 955
 956                         path_kill_slashes(t);
 957                         *path = t;
 958                 }
 959
 960                 if (controller)
 961                         *controller = NULL;
 962
 963                 return 0;
 964         }
 965
 966         e = strchr(spec, ':');
 967         if (!e) {
 968                 if (!cg_controller_is_valid(spec, true))
 969                         return -EINVAL;
 970
 971                 if (controller) {
 972                         t = strdup(normalize_controller(spec));
 973                         if (!t)
 974                                 return -ENOMEM;
 975
 976                         *controller = t;
 977                 }
 978
 979                 if (path)
 980                         *path = NULL;
 981
 982                 return 0;
 983         }
 984
 985         v = strndup(spec, e-spec);
 986         if (!v)
 987                 return -ENOMEM;
 988         t = strdup(normalize_controller(v));
 989         if (!t)
 990                 return -ENOMEM;
 991         if (!cg_controller_is_valid(t, true)) {
 992                 free(t);
 993                 return -EINVAL;
 994         }
 995
 996         u = strdup(e+1);
 997         if (!u) {
 998                 free(t);
 999                 return -ENOMEM;
1000         }
1001         if (!path_is_safe(u) ||
1002             !path_is_absolute(u)) {
1003                 free(t);
1004                 free(u);
1005                 return -EINVAL;
1006         }
1007
1008         path_kill_slashes(u);
1009
1010         if (controller)
1011                 *controller = t;
1012         else
1013                 free(t);
1014
1015         if (path)
1016                 *path = u;
1017         else
1018                 free(u);
1019
1020         return 0;
1021 }
1022
1023 int cg_join_spec(const char *controller, const char *path, char **spec) {
1024         char *s;
1025
1026         assert(path);
1027
1028         if (!controller)
1029                 controller = "systemd";
1030         else {
1031                 if (!cg_controller_is_valid(controller, true))
1032                         return -EINVAL;
1033
1034                 controller = normalize_controller(controller);
1035         }
1036
1037         if (!path_is_absolute(path))
1038                 return -EINVAL;
1039
1040         s = strjoin(controller, ":", path, NULL);
1041         if (!s)
1042                 return -ENOMEM;
1043
1044         path_kill_slashes(s + strlen(controller) + 1);
1045
1046         *spec = s;
1047         return 0;
1048 }
1049
1050 int cg_mangle_path(const char *path, char **result) {
1051         _cleanup_free_ char *c = NULL, *p = NULL;
1052         char *t;
1053         int r;
1054
1055         assert(path);
1056         assert(result);
1057
1058         /* First check if it already is a filesystem path */
1059         if (path_startswith(path, "/sys/fs/cgroup")) {
1060
1061                 t = strdup(path);
1062                 if (!t)
1063                         return -ENOMEM;
1064
1065                 path_kill_slashes(t);
1066                 *result = t;
1067                 return 0;
1068         }
1069
1070         /* Otherwise treat it as cg spec */
1071         r = cg_split_spec(path, &c, &p);
1072         if (r < 0)
1073                 return r;
1074
1075         return cg_get_path(c ? c : SYSTEMD_CGROUP_CONTROLLER, p ? p : "/", NULL, result);
1076 }
1077
1078 int cg_get_system_path(char **path) {
1079         char *p;
1080         int r;
1081
1082         assert(path);
1083
1084         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 1, &p);
1085         if (r < 0) {
1086                 p = strdup("/system");
1087                 if (!p)
1088                         return -ENOMEM;
1089         }
1090
1091         if (endswith(p, "/system"))
1092                 *path = p;
1093         else {
1094                 char *q;
1095
1096                 q = strappend(p, "/system");
1097                 free(p);
1098                 if (!q)
1099                         return -ENOMEM;
1100
1101                 *path = q;
1102         }
1103
1104         return 0;
1105 }
1106
1107 int cg_get_root_path(char **path) {
1108         char *root, *e;
1109         int r;
1110
1111         assert(path);
1112
1113         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 1, &root);
1114         if (r < 0)
1115                 return r;
1116
1117         e = endswith(root, "/system");
1118         if (e == root)
1119                 e[1] = 0;
1120         else if (e)
1121                 *e = 0;
1122
1123         *path = root;
1124         return 0;
1125 }
1126
1127 int cg_get_user_path(char **path) {
1128         _cleanup_free_ char *root = NULL;
1129         char *p;
1130
1131         assert(path);
1132
1133         /* Figure out the place to put user cgroups below. We use the
1134          * same as PID 1 has but with the "/system" suffix replaced by
1135          * "/user" */
1136
1137         if (cg_get_root_path(&root) < 0 || streq(root, "/"))
1138                 p = strdup("/user");
1139         else
1140                 p = strappend(root, "/user");
1141
1142         if (!p)
1143                 return -ENOMEM;
1144
1145         *path = p;
1146         return 0;
1147 }
1148
1149 int cg_get_machine_path(const char *machine, char **path) {
1150         _cleanup_free_ char *root = NULL, *escaped = NULL;
1151         char *p;
1152
1153         assert(path);
1154
1155         if (machine) {
1156                 const char *name = strappenda(machine, ".nspawn");
1157
1158                 escaped = cg_escape(name);
1159                 if (!escaped)
1160                         return -ENOMEM;
1161         }
1162
1163         p = strjoin(cg_get_root_path(&root) >= 0 && !streq(root, "/") ? root : "",
1164                     "/machine", machine ? "/" : "", machine ? escaped : "", NULL);
1165         if (!p)
1166                 return -ENOMEM;
1167
1168         *path = p;
1169         return 0;
1170 }
1171
1172 char **cg_shorten_controllers(char **controllers) {
1173         char **f, **t;
1174
1175         if (!controllers)
1176                 return controllers;
1177
1178         for (f = controllers, t = controllers; *f; f++) {
1179                 const char *p;
1180                 int r;
1181
1182                 p = normalize_controller(*f);
1183
1184                 if (streq(p, "systemd")) {
1185                         free(*f);
1186                         continue;
1187                 }
1188
1189                 if (!cg_controller_is_valid(p, true)) {
1190                         log_warning("Controller %s is not valid, removing from controllers list.", p);
1191                         free(*f);
1192                         continue;
1193                 }
1194
1195                 r = check_hierarchy(p);
1196                 if (r < 0) {
1197                         log_debug("Controller %s is not available, removing from controllers list.", p);
1198                         free(*f);
1199                         continue;
1200                 }
1201
1202                 *(t++) = *f;
1203         }
1204
1205         *t = NULL;
1206         return strv_uniq(controllers);
1207 }
1208
1209 int cg_pid_get_path_shifted(pid_t pid, char **root, char **cgroup) {
1210         _cleanup_free_ char *cg_root = NULL;
1211         char *cg_process, *p;
1212         int r;
1213
1214         r = cg_get_root_path(&cg_root);
1215         if (r < 0)
1216                 return r;
1217
1218         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &cg_process);
1219         if (r < 0)
1220                 return r;
1221
1222         p = path_startswith(cg_process, cg_root);
1223         if (p)
1224                 p--;
1225         else
1226                 p = cg_process;
1227
1228         if (cgroup) {
1229                 char* c;
1230
1231                 c = strdup(p);
1232                 if (!c) {
1233                         free(cg_process);
1234                         return -ENOMEM;
1235                 }
1236
1237                 *cgroup = c;
1238         }
1239
1240         if (root) {
1241                 cg_process[p-cg_process] = 0;
1242                 *root = cg_process;
1243         } else
1244                 free(cg_process);
1245
1246         return 0;
1247 }
1248
1249 int cg_path_decode_unit(const char *cgroup, char **unit){
1250         char *p, *e, *c, *s, *k;
1251
1252         assert(cgroup);
1253         assert(unit);
1254
1255         e = strchrnul(cgroup, '/');
1256         c = strndupa(cgroup, e - cgroup);
1257         c = cg_unescape(c);
1258
1259         /* Could this be a valid unit name? */
1260         if (!unit_name_is_valid(c, true))
1261                 return -EINVAL;
1262
1263         if (!unit_name_is_template(c))
1264                 s = strdup(c);
1265         else {
1266                 if (*e != '/')
1267                         return -EINVAL;
1268
1269                 e += strspn(e, "/");
1270
1271                 p = strchrnul(e, '/');
1272                 k = strndupa(e, p - e);
1273                 k = cg_unescape(k);
1274
1275                 if (!unit_name_is_valid(k, false))
1276                         return -EINVAL;
1277
1278                 s = strdup(k);
1279         }
1280
1281         if (!s)
1282                 return -ENOMEM;
1283
1284         *unit = s;
1285         return 0;
1286 }
1287
1288 int cg_path_get_unit(const char *path, char **unit) {
1289         const char *e;
1290
1291         assert(path);
1292         assert(unit);
1293
1294         e = path_startswith(path, "/system/");
1295         if (!e)
1296                 return -ENOENT;
1297
1298         return cg_path_decode_unit(e, unit);
1299 }
1300
1301 int cg_pid_get_unit(pid_t pid, char **unit) {
1302         _cleanup_free_ char *cgroup = NULL;
1303         int r;
1304
1305         assert(unit);
1306
1307         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1308         if (r < 0)
1309                 return r;
1310
1311         return cg_path_get_unit(cgroup, unit);
1312 }
1313
1314 _pure_ static const char *skip_label(const char *e) {
1315         assert(e);
1316
1317         e = strchr(e, '/');
1318         if (!e)
1319                 return NULL;
1320
1321         e += strspn(e, "/");
1322         return e;
1323 }
1324
1325 int cg_path_get_user_unit(const char *path, char **unit) {
1326         const char *e;
1327
1328         assert(path);
1329         assert(unit);
1330
1331         /* We always have to parse the path from the beginning as unit
1332          * cgroups might have arbitrary child cgroups and we shouldn't get
1333          * confused by those */
1334
1335         e = path_startswith(path, "/user/");
1336         if (!e)
1337                 return -ENOENT;
1338
1339         /* Skip the user name */
1340         e = skip_label(e);
1341         if (!e)
1342                 return -ENOENT;
1343
1344         /* Skip the session ID */
1345         e = skip_label(e);
1346         if (!e)
1347                 return -ENOENT;
1348
1349         /* Skip the systemd cgroup */
1350         e = skip_label(e);
1351         if (!e)
1352                 return -ENOENT;
1353
1354         return cg_path_decode_unit(e, unit);
1355 }
1356
1357 int cg_pid_get_user_unit(pid_t pid, char **unit) {
1358         _cleanup_free_ char *cgroup = NULL;
1359         int r;
1360
1361         assert(unit);
1362
1363         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1364         if (r < 0)
1365                 return r;
1366
1367         return cg_path_get_user_unit(cgroup, unit);
1368 }
1369
1370 int cg_path_get_machine_name(const char *path, char **machine) {
1371         const char *e, *n;
1372         char *s, *r;
1373
1374         assert(path);
1375         assert(machine);
1376
1377         e = path_startswith(path, "/machine/");
1378         if (!e)
1379                 return -ENOENT;
1380
1381         n = strchrnul(e, '/');
1382         if (e == n)
1383                 return -ENOENT;
1384
1385         s = strndupa(e, n - e);
1386
1387         r = strdup(cg_unescape(s));
1388         if (!r)
1389                 return -ENOMEM;
1390
1391         *machine = r;
1392         return 0;
1393 }
1394
1395 int cg_pid_get_machine_name(pid_t pid, char **machine) {
1396         _cleanup_free_ char *cgroup = NULL;
1397         int r;
1398
1399         assert(machine);
1400
1401         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1402         if (r < 0)
1403                 return r;
1404
1405         return cg_path_get_machine_name(cgroup, machine);
1406 }
1407
1408 int cg_path_get_session(const char *path, char **session) {
1409         const char *e, *n;
1410         char *s;
1411
1412         assert(path);
1413         assert(session);
1414
1415         e = path_startswith(path, "/user/");
1416         if (!e)
1417                 return -ENOENT;
1418
1419         /* Skip the user name */
1420         e = skip_label(e);
1421         if (!e)
1422                 return -ENOENT;
1423
1424         n = strchrnul(e, '/');
1425         if (n - e < 8)
1426                 return -ENOENT;
1427         if (memcmp(n - 8, ".session", 8) != 0)
1428                 return -ENOENT;
1429
1430         s = strndup(e, n - e - 8);
1431         if (!s)
1432                 return -ENOMEM;
1433
1434         *session = s;
1435         return 0;
1436 }
1437
1438 int cg_pid_get_session(pid_t pid, char **session) {
1439         _cleanup_free_ char *cgroup = NULL;
1440         int r;
1441
1442         assert(session);
1443
1444         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1445         if (r < 0)
1446                 return r;
1447
1448         return cg_path_get_session(cgroup, session);
1449 }
1450
1451 int cg_path_get_owner_uid(const char *path, uid_t *uid) {
1452         const char *e, *n;
1453         char *s;
1454
1455         assert(path);
1456         assert(uid);
1457
1458         e = path_startswith(path, "/user/");
1459         if (!e)
1460                 return -ENOENT;
1461
1462         n = strchrnul(e, '/');
1463         if (n - e < 5)
1464                 return -ENOENT;
1465         if (memcmp(n - 5, ".user", 5) != 0)
1466                 return -ENOENT;
1467
1468         s = strndupa(e, n - e - 5);
1469         if (!s)
1470                 return -ENOMEM;
1471
1472         return parse_uid(s, uid);
1473 }
1474
1475 int cg_pid_get_owner_uid(pid_t pid, uid_t *uid) {
1476         _cleanup_free_ char *cgroup = NULL;
1477         int r;
1478
1479         assert(uid);
1480
1481         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1482         if (r < 0)
1483                 return r;
1484
1485         return cg_path_get_owner_uid(cgroup, uid);
1486 }
1487
1488 int cg_controller_from_attr(const char *attr, char **controller) {
1489         const char *dot;
1490         char *c;
1491
1492         assert(attr);
1493         assert(controller);
1494
1495         if (!filename_is_safe(attr))
1496                 return -EINVAL;
1497
1498         dot = strchr(attr, '.');
1499         if (!dot) {
1500                 *controller = NULL;
1501                 return 0;
1502         }
1503
1504         c = strndup(attr, dot - attr);
1505         if (!c)
1506                 return -ENOMEM;
1507
1508         if (!cg_controller_is_valid(c, false)) {
1509                 free(c);
1510                 return -EINVAL;
1511         }
1512
1513         *controller = c;
1514         return 1;
1515 }
1516
1517 char *cg_escape(const char *p) {
1518         bool need_prefix = false;
1519
1520         /* This implements very minimal escaping for names to be used
1521          * as file names in the cgroup tree: any name which might
1522          * conflict with a kernel name or is prefixed with '_' is
1523          * prefixed with a '_'. That way, when reading cgroup names it
1524          * is sufficient to remove a single prefixing underscore if
1525          * there is one. */
1526
1527         /* The return value of this function (unlike cg_unescape())
1528          * needs free()! */
1529
1530         if (p[0] == '_' || streq(p, "notify_on_release") || streq(p, "release_agent") || streq(p, "tasks"))
1531                 need_prefix = true;
1532         else {
1533                 const char *dot;
1534
1535                 dot = strrchr(p, '.');
1536                 if (dot) {
1537
1538                         if (dot - p == 6 && memcmp(p, "cgroup", 6) == 0)
1539                                 need_prefix = true;
1540                         else {
1541                                 char *n;
1542
1543                                 n = strndupa(p, dot - p);
1544
1545                                 if (check_hierarchy(n) >= 0)
1546                                         need_prefix = true;
1547                         }
1548                 }
1549         }
1550
1551         if (need_prefix)
1552                 return strappend("_", p);
1553         else
1554                 return strdup(p);
1555 }
1556
1557 char *cg_unescape(const char *p) {
1558         assert(p);
1559
1560         /* The return value of this function (unlike cg_escape())
1561          * doesn't need free()! */
1562
1563         if (p[0] == '_')
1564                 return (char*) p+1;
1565
1566         return (char*) p;
1567 }
1568
1569 #define CONTROLLER_VALID                        \
1570         "0123456789"                            \
1571         "abcdefghijklmnopqrstuvwxyz"            \
1572         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"            \
1573         "_"
1574
1575 bool cg_controller_is_valid(const char *p, bool allow_named) {
1576         const char *t, *s;
1577
1578         if (!p)
1579                 return false;
1580
1581         if (allow_named) {
1582                 s = startswith(p, "name=");
1583                 if (s)
1584                         p = s;
1585         }
1586
1587         if (*p == 0 || *p == '_')
1588                 return false;
1589
1590         for (t = p; *t; t++)
1591                 if (!strchr(CONTROLLER_VALID, *t))
1592                         return false;
1593
1594         if (t - p > FILENAME_MAX)
1595                 return false;
1596
1597         return true;
1598 }