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