chiark / gitweb /
[1/5] Apply missing fixes from upstream
[elogind.git] / src / basic / 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 "set.h"
33 #include "macro.h"
34 #include "util.h"
35 #include "formats-util.h"
36 #include "process-util.h"
37 #include "path-util.h"
38 // #include "unit-name.h"
39 #include "fileio.h"
40 // #include "special.h"
41 #include "mkdir.h"
42 #include "login-util.h"
43 #include "cgroup-util.h"
44
45 int cg_enumerate_processes(const char *controller, const char *path, FILE **_f) {
46         _cleanup_free_ char *fs = NULL;
47         FILE *f;
48         int r;
49
50         assert(_f);
51
52         r = cg_get_path(controller, path, "cgroup.procs", &fs);
53         if (r < 0)
54                 return r;
55
56         f = fopen(fs, "re");
57         if (!f)
58                 return -errno;
59
60         *_f = f;
61         return 0;
62 }
63
64 int cg_read_pid(FILE *f, pid_t *_pid) {
65         unsigned long ul;
66
67         /* Note that the cgroup.procs might contain duplicates! See
68          * cgroups.txt for details. */
69
70         assert(f);
71         assert(_pid);
72
73         errno = 0;
74         if (fscanf(f, "%lu", &ul) != 1) {
75
76                 if (feof(f))
77                         return 0;
78
79                 return errno ? -errno : -EIO;
80         }
81
82         if (ul <= 0)
83                 return -EIO;
84
85         *_pid = (pid_t) ul;
86         return 1;
87 }
88
89 int cg_enumerate_subgroups(const char *controller, const char *path, DIR **_d) {
90         _cleanup_free_ char *fs = NULL;
91         int r;
92         DIR *d;
93
94         assert(_d);
95
96         /* This is not recursive! */
97
98         r = cg_get_path(controller, path, NULL, &fs);
99         if (r < 0)
100                 return r;
101
102         d = opendir(fs);
103         if (!d)
104                 return -errno;
105
106         *_d = d;
107         return 0;
108 }
109
110 int cg_read_subgroup(DIR *d, char **fn) {
111         struct dirent *de;
112
113         assert(d);
114         assert(fn);
115
116         FOREACH_DIRENT_ALL(de, d, return -errno) {
117                 char *b;
118
119                 if (de->d_type != DT_DIR)
120                         continue;
121
122                 if (streq(de->d_name, ".") ||
123                     streq(de->d_name, ".."))
124                         continue;
125
126                 b = strdup(de->d_name);
127                 if (!b)
128                         return -ENOMEM;
129
130                 *fn = b;
131                 return 1;
132         }
133
134         return 0;
135 }
136
137 int cg_rmdir(const char *controller, const char *path) {
138         _cleanup_free_ char *p = NULL;
139         int r;
140
141         r = cg_get_path(controller, path, NULL, &p);
142         if (r < 0)
143                 return r;
144
145         r = rmdir(p);
146         if (r < 0 && errno != ENOENT)
147                 return -errno;
148
149         return 0;
150 }
151
152 int cg_kill(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, Set *s) {
153         _cleanup_set_free_ Set *allocated_set = NULL;
154         bool done = false;
155         int r, ret = 0;
156         pid_t my_pid;
157
158         assert(sig >= 0);
159
160         /* This goes through the tasks list and kills them all. This
161          * is repeated until no further processes are added to the
162          * tasks list, to properly handle forking processes */
163
164         if (!s) {
165                 s = allocated_set = set_new(NULL);
166                 if (!s)
167                         return -ENOMEM;
168         }
169
170         my_pid = getpid();
171
172         do {
173                 _cleanup_fclose_ FILE *f = NULL;
174                 pid_t pid = 0;
175                 done = true;
176
177                 r = cg_enumerate_processes(controller, path, &f);
178                 if (r < 0) {
179                         if (ret >= 0 && r != -ENOENT)
180                                 return r;
181
182                         return ret;
183                 }
184
185                 while ((r = cg_read_pid(f, &pid)) > 0) {
186
187                         if (ignore_self && pid == my_pid)
188                                 continue;
189
190                         if (set_get(s, PID_TO_PTR(pid)) == PID_TO_PTR(pid))
191                                 continue;
192
193                         /* If we haven't killed this process yet, kill
194                          * it */
195                         if (kill(pid, sig) < 0) {
196                                 if (ret >= 0 && errno != ESRCH)
197                                         ret = -errno;
198                         } else {
199                                 if (sigcont && sig != SIGKILL)
200                                         (void) kill(pid, SIGCONT);
201
202                                 if (ret == 0)
203                                         ret = 1;
204                         }
205
206                         done = false;
207
208                         r = set_put(s, PID_TO_PTR(pid));
209                         if (r < 0) {
210                                 if (ret >= 0)
211                                         return r;
212
213                                 return ret;
214                         }
215                 }
216
217                 if (r < 0) {
218                         if (ret >= 0)
219                                 return r;
220
221                         return ret;
222                 }
223
224                 /* To avoid racing against processes which fork
225                  * quicker than we can kill them we repeat this until
226                  * no new pids need to be killed. */
227
228         } while (!done);
229
230         return ret;
231 }
232
233 int cg_kill_recursive(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, bool rem, Set *s) {
234         _cleanup_set_free_ Set *allocated_set = NULL;
235         _cleanup_closedir_ DIR *d = NULL;
236         int r, ret;
237         char *fn;
238
239         assert(path);
240         assert(sig >= 0);
241
242         if (!s) {
243                 s = allocated_set = set_new(NULL);
244                 if (!s)
245                         return -ENOMEM;
246         }
247
248         ret = cg_kill(controller, path, sig, sigcont, ignore_self, s);
249
250         r = cg_enumerate_subgroups(controller, path, &d);
251         if (r < 0) {
252                 if (ret >= 0 && r != -ENOENT)
253                         return r;
254
255                 return ret;
256         }
257
258         while ((r = cg_read_subgroup(d, &fn)) > 0) {
259                 _cleanup_free_ char *p = NULL;
260
261                 p = strjoin(path, "/", fn, NULL);
262                 free(fn);
263                 if (!p)
264                         return -ENOMEM;
265
266                 r = cg_kill_recursive(controller, p, sig, sigcont, ignore_self, rem, s);
267                 if (r != 0 && ret >= 0)
268                         ret = r;
269         }
270
271         if (ret >= 0 && r < 0)
272                 ret = r;
273
274         if (rem) {
275                 r = cg_rmdir(controller, path);
276                 if (r < 0 && ret >= 0 && r != -ENOENT && r != -EBUSY)
277                         return r;
278         }
279
280         return ret;
281 }
282
283 int cg_migrate(const char *cfrom, const char *pfrom, const char *cto, const char *pto, bool ignore_self) {
284         bool done = false;
285         _cleanup_set_free_ Set *s = NULL;
286         int r, ret = 0;
287         pid_t my_pid;
288
289         assert(cfrom);
290         assert(pfrom);
291         assert(cto);
292         assert(pto);
293
294         s = set_new(NULL);
295         if (!s)
296                 return -ENOMEM;
297
298         my_pid = getpid();
299
300         log_debug_elogind("Migrating \"%s\"/\"%s\" to \"%s\"/\"%s\" (%s)",
301                           cfrom, pfrom, cto, pto,
302                           ignore_self ? "ignoring self" : "watching self");
303
304         do {
305                 _cleanup_fclose_ FILE *f = NULL;
306                 pid_t pid = 0;
307                 done = true;
308
309                 r = cg_enumerate_processes(cfrom, pfrom, &f);
310                 if (r < 0) {
311                         if (ret >= 0 && r != -ENOENT)
312                                 return r;
313
314                         return ret;
315                 }
316
317                 while ((r = cg_read_pid(f, &pid)) > 0) {
318
319                         /* This might do weird stuff if we aren't a
320                          * single-threaded program. However, we
321                          * luckily know we are not */
322                         if (ignore_self && pid == my_pid)
323                                 continue;
324
325                         if (set_get(s, PID_TO_PTR(pid)) == PID_TO_PTR(pid))
326                                 continue;
327
328                         /* Ignore kernel threads. Since they can only
329                          * exist in the root cgroup, we only check for
330                          * them there. */
331                         if (cfrom &&
332                             (isempty(pfrom) || path_equal(pfrom, "/")) &&
333                             is_kernel_thread(pid) > 0)
334                                 continue;
335
336                         r = cg_attach(cto, pto, pid);
337                         if (r < 0) {
338                                 if (ret >= 0 && r != -ESRCH)
339                                         ret = r;
340                         } else if (ret == 0)
341                                 ret = 1;
342
343                         done = false;
344
345                         r = set_put(s, PID_TO_PTR(pid));
346                         if (r < 0) {
347                                 if (ret >= 0)
348                                         return r;
349
350                                 return ret;
351                         }
352                 }
353
354                 if (r < 0) {
355                         if (ret >= 0)
356                                 return r;
357
358                         return ret;
359                 }
360         } while (!done);
361
362         return ret;
363 }
364
365 int cg_migrate_recursive(
366                 const char *cfrom,
367                 const char *pfrom,
368                 const char *cto,
369                 const char *pto,
370                 bool ignore_self,
371                 bool rem) {
372
373         _cleanup_closedir_ DIR *d = NULL;
374         int r, ret = 0;
375         char *fn;
376
377         assert(cfrom);
378         assert(pfrom);
379         assert(cto);
380         assert(pto);
381
382         ret = cg_migrate(cfrom, pfrom, cto, pto, ignore_self);
383
384         r = cg_enumerate_subgroups(cfrom, pfrom, &d);
385         if (r < 0) {
386                 if (ret >= 0 && r != -ENOENT)
387                         return r;
388
389                 return ret;
390         }
391
392         while ((r = cg_read_subgroup(d, &fn)) > 0) {
393                 _cleanup_free_ char *p = NULL;
394
395                 p = strjoin(pfrom, "/", fn, NULL);
396                 free(fn);
397                 if (!p)
398                                 return -ENOMEM;
399
400                 r = cg_migrate_recursive(cfrom, p, cto, pto, ignore_self, rem);
401                 if (r != 0 && ret >= 0)
402                         ret = r;
403         }
404
405         if (r < 0 && ret >= 0)
406                 ret = r;
407
408         if (rem) {
409                 r = cg_rmdir(cfrom, pfrom);
410                 if (r < 0 && ret >= 0 && r != -ENOENT && r != -EBUSY)
411                         return r;
412         }
413
414         return ret;
415 }
416
417 int cg_migrate_recursive_fallback(
418                 const char *cfrom,
419                 const char *pfrom,
420                 const char *cto,
421                 const char *pto,
422                 bool ignore_self,
423                 bool rem) {
424
425         int r;
426
427         assert(cfrom);
428         assert(pfrom);
429         assert(cto);
430         assert(pto);
431
432         r = cg_migrate_recursive(cfrom, pfrom, cto, pto, ignore_self, rem);
433         if (r < 0) {
434                 char prefix[strlen(pto) + 1];
435
436                 /* This didn't work? Then let's try all prefixes of the destination */
437
438                 PATH_FOREACH_PREFIX(prefix, pto) {
439                         int q;
440
441                         q = cg_migrate_recursive(cfrom, pfrom, cto, prefix, ignore_self, rem);
442                         if (q >= 0)
443                                 return q;
444                 }
445         }
446
447         return r;
448 }
449
450 static const char *controller_to_dirname(const char *controller) {
451         const char *e;
452
453         assert(controller);
454
455         /* Converts a controller name to the directory name below
456          * /sys/fs/cgroup/ we want to mount it to. Effectively, this
457          * just cuts off the name= prefixed used for named
458          * hierarchies, if it is specified. */
459
460         e = startswith(controller, "name=");
461         if (e)
462                 return e;
463
464         return controller;
465 }
466
467 static int join_path_legacy(const char *controller, const char *path, const char *suffix, char **fs) {
468         const char *dn;
469         char *t = NULL;
470
471         assert(fs);
472         assert(controller);
473
474         dn = controller_to_dirname(controller);
475
476         if (isempty(path) && isempty(suffix))
477                 t = strappend("/sys/fs/cgroup/", dn);
478         else if (isempty(path))
479                 t = strjoin("/sys/fs/cgroup/", dn, "/", suffix, NULL);
480         else if (isempty(suffix))
481                 t = strjoin("/sys/fs/cgroup/", dn, "/", path, NULL);
482                 else
483                 t = strjoin("/sys/fs/cgroup/", dn, "/", path, "/", suffix, NULL);
484         if (!t)
485                 return -ENOMEM;
486
487         *fs = t;
488         return 0;
489         }
490
491 static int join_path_unified(const char *path, const char *suffix, char **fs) {
492         char *t;
493
494         assert(fs);
495
496         if (isempty(path) && isempty(suffix))
497                 t = strdup("/sys/fs/cgroup");
498         else if (isempty(path))
499                 t = strappend("/sys/fs/cgroup/", suffix);
500         else if (isempty(suffix))
501                 t = strappend("/sys/fs/cgroup/", path);
502         else
503                 t = strjoin("/sys/fs/cgroup/", path, "/", suffix, NULL);
504         if (!t)
505                 return -ENOMEM;
506
507         *fs = t;
508         return 0;
509 }
510
511 int cg_get_path(const char *controller, const char *path, const char *suffix, char **fs) {
512         int unified, r;
513
514         assert(fs);
515
516         if (!controller) {
517                 char *t;
518
519                 /* If no controller is specified, we return the path
520                  * *below* the controllers, without any prefix. */
521
522                 if (!path && !suffix)
523                         return -EINVAL;
524
525                 if (!suffix)
526                         t = strdup(path);
527                 else if (!path)
528                         t = strdup(suffix);
529                 else
530                         t = strjoin(path, "/", suffix, NULL);
531                 if (!t)
532                         return -ENOMEM;
533
534                 *fs = path_kill_slashes(t);
535                 return 0;
536         }
537
538         if (!cg_controller_is_valid(controller))
539                 return -EINVAL;
540
541         unified = cg_unified();
542         if (unified < 0)
543                 return unified;
544
545         if (unified > 0)
546                 r = join_path_unified(path, suffix, fs);
547         else
548                 r = join_path_legacy(controller, path, suffix, fs);
549
550         if (r < 0)
551                 return r;
552
553         path_kill_slashes(*fs);
554         return 0;
555 }
556
557 static int controller_is_accessible(const char *controller) {
558         int unified;
559
560         assert(controller);
561
562         /* Checks whether a specific controller is accessible,
563          * i.e. its hierarchy mounted. In the unified hierarchy all
564          * controllers are considered accessible, except for the named
565          * hierarchies */
566
567         if (!cg_controller_is_valid(controller))
568                 return -EINVAL;
569
570         unified = cg_unified();
571         if (unified < 0)
572                 return unified;
573         if (unified > 0) {
574                 /* We don't support named hierarchies if we are using
575                  * the unified hierarchy. */
576
577                 if (streq(controller, SYSTEMD_CGROUP_CONTROLLER))
578                         return 0;
579
580                 if (startswith(controller, "name="))
581                         return -EOPNOTSUPP;
582
583         } else {
584                 const char *cc, *dn;
585
586                 dn = controller_to_dirname(controller);
587                 cc = strjoina("/sys/fs/cgroup/", dn);
588
589                 if (laccess(cc, F_OK) < 0)
590                         return -errno;
591         }
592
593         return 0;
594 }
595
596 int cg_get_path_and_check(const char *controller, const char *path, const char *suffix, char **fs) {
597         int r;
598
599         assert(controller);
600         assert(fs);
601
602         /* Check if the specified controller is actually accessible */
603         r = controller_is_accessible(controller);
604         if (r < 0)
605                 return r;
606
607         return cg_get_path(controller, path, suffix, fs);
608 }
609
610 static int trim_cb(const char *path, const struct stat *sb, int typeflag, struct FTW *ftwbuf) {
611         assert(path);
612         assert(sb);
613         assert(ftwbuf);
614
615         if (typeflag != FTW_DP)
616                 return 0;
617
618         if (ftwbuf->level < 1)
619                 return 0;
620
621         (void) rmdir(path);
622         return 0;
623 }
624
625 int cg_trim(const char *controller, const char *path, bool delete_root) {
626         _cleanup_free_ char *fs = NULL;
627         int r = 0;
628
629         assert(path);
630
631         r = cg_get_path(controller, path, NULL, &fs);
632         if (r < 0)
633                 return r;
634
635         errno = 0;
636         if (nftw(fs, trim_cb, 64, FTW_DEPTH|FTW_MOUNT|FTW_PHYS) != 0) {
637                 if (errno == ENOENT)
638                         r = 0;
639                 else if (errno != 0)
640                         r = -errno;
641                 else
642                         r = -EIO;
643         }
644
645         if (delete_root) {
646                 if (rmdir(fs) < 0 && errno != ENOENT)
647                         return -errno;
648         }
649
650         return r;
651 }
652
653 int cg_create(const char *controller, const char *path) {
654         _cleanup_free_ char *fs = NULL;
655         int r;
656
657         r = cg_get_path_and_check(controller, path, NULL, &fs);
658         if (r < 0)
659                 return r;
660
661         r = mkdir_parents(fs, 0755);
662         if (r < 0)
663                 return r;
664
665         if (mkdir(fs, 0755) < 0) {
666
667                 if (errno == EEXIST)
668                         return 0;
669
670                 return -errno;
671         }
672
673         return 1;
674 }
675
676 int cg_create_and_attach(const char *controller, const char *path, pid_t pid) {
677         int r, q;
678
679         assert(pid >= 0);
680
681         r = cg_create(controller, path);
682         if (r < 0)
683                 return r;
684
685         q = cg_attach(controller, path, pid);
686         if (q < 0)
687                 return q;
688
689         /* This does not remove the cgroup on failure */
690         return r;
691 }
692
693 int cg_attach(const char *controller, const char *path, pid_t pid) {
694         _cleanup_free_ char *fs = NULL;
695         char c[DECIMAL_STR_MAX(pid_t) + 2];
696         int r;
697
698         assert(path);
699         assert(pid >= 0);
700
701         r = cg_get_path_and_check(controller, path, "cgroup.procs", &fs);
702         if (r < 0)
703                 return r;
704
705         if (pid == 0)
706                 pid = getpid();
707
708         snprintf(c, sizeof(c), PID_FMT"\n", pid);
709
710         return write_string_file(fs, c, 0);
711 }
712
713 int cg_attach_fallback(const char *controller, const char *path, pid_t pid) {
714         int r;
715
716         assert(controller);
717         assert(path);
718         assert(pid >= 0);
719
720         r = cg_attach(controller, path, pid);
721         if (r < 0) {
722                 char prefix[strlen(path) + 1];
723
724                 /* This didn't work? Then let's try all prefixes of
725                  * the destination */
726
727                 PATH_FOREACH_PREFIX(prefix, path) {
728                         int q;
729
730                         q = cg_attach(controller, prefix, pid);
731                         if (q >= 0)
732                                 return q;
733                 }
734         }
735
736         return r;
737 }
738
739 /// UNNEEDED by elogind
740 #if 0
741 int cg_set_group_access(
742                 const char *controller,
743                 const char *path,
744                 mode_t mode,
745                 uid_t uid,
746                 gid_t gid) {
747
748         _cleanup_free_ char *fs = NULL;
749         int r;
750
751         if (mode == MODE_INVALID && uid == UID_INVALID && gid == GID_INVALID)
752                 return 0;
753
754         if (mode != MODE_INVALID)
755                 mode &= 0777;
756
757         r = cg_get_path(controller, path, NULL, &fs);
758         if (r < 0)
759                 return r;
760
761         return chmod_and_chown(fs, mode, uid, gid);
762 }
763
764 int cg_set_task_access(
765                 const char *controller,
766                 const char *path,
767                 mode_t mode,
768                 uid_t uid,
769                 gid_t gid) {
770
771         _cleanup_free_ char *fs = NULL, *procs = NULL;
772         int r, unified;
773
774         assert(path);
775
776         if (mode == MODE_INVALID && uid == UID_INVALID && gid == GID_INVALID)
777                 return 0;
778
779         if (mode != MODE_INVALID)
780                 mode &= 0666;
781
782         r = cg_get_path(controller, path, "cgroup.procs", &fs);
783         if (r < 0)
784                 return r;
785
786         r = chmod_and_chown(fs, mode, uid, gid);
787         if (r < 0)
788                 return r;
789
790         unified = cg_unified();
791         if (unified < 0)
792                 return unified;
793         if (unified)
794                 return 0;
795
796         /* Compatibility, Always keep values for "tasks" in sync with
797          * "cgroup.procs" */
798         if (cg_get_path(controller, path, "tasks", &procs) >= 0)
799                 (void) chmod_and_chown(procs, mode, uid, gid);
800
801         return 0;
802 }
803 #endif // 0
804
805 int cg_pid_get_path(const char *controller, pid_t pid, char **path) {
806         _cleanup_fclose_ FILE *f = NULL;
807         char line[LINE_MAX];
808         const char *fs;
809         size_t cs = 0;
810         int unified;
811
812         assert(path);
813         assert(pid >= 0);
814
815         unified = cg_unified();
816         if (unified < 0)
817                 return unified;
818         if (unified == 0) {
819                 if (controller) {
820                         if (!cg_controller_is_valid(controller))
821                                 return -EINVAL;
822                 } else
823                         controller = SYSTEMD_CGROUP_CONTROLLER;
824
825                 cs = strlen(controller);
826         }
827
828         fs = procfs_file_alloca(pid, "cgroup");
829         log_debug_elogind("Searching for PID %u in \"%s\" (controller \"%s\")",
830                           pid, fs, controller);
831         f = fopen(fs, "re");
832         if (!f)
833                 return errno == ENOENT ? -ESRCH : -errno;
834
835         FOREACH_LINE(line, f, return -errno) {
836                 char *e, *p;
837
838                 truncate_nl(line);
839
840                 if (unified) {
841                         e = startswith(line, "0:");
842                         if (!e)
843                                 continue;
844
845                         e = strchr(e, ':');
846                         if (!e)
847                                 continue;
848                 } else {
849                         char *l;
850                         size_t k;
851                         const char *word, *state;
852                         bool found = false;
853
854                         l = strchr(line, ':');
855                         if (!l)
856                                 continue;
857
858                         l++;
859                         e = strchr(l, ':');
860                         if (!e)
861                                 continue;
862
863                         *e = 0;
864                         FOREACH_WORD_SEPARATOR(word, k, l, ",", state) {
865                                 if (k == cs && memcmp(word, controller, cs) == 0) {
866                                         found = true;
867                                         break;
868                                 }
869                         }
870
871                         if (!found)
872                                 continue;
873                 }
874
875                 log_debug_elogind("Found %s:%s", line, e+1);
876                 p = strdup(e + 1);
877                 if (!p)
878                         return -ENOMEM;
879
880                 *path = p;
881                 return 0;
882         }
883
884         return -ENODATA;
885 }
886
887 int cg_install_release_agent(const char *controller, const char *agent) {
888         _cleanup_free_ char *fs = NULL, *contents = NULL;
889         const char *sc;
890         int r, unified;
891
892         assert(agent);
893
894         unified = cg_unified();
895         if (unified < 0)
896                 return unified;
897         if (unified) /* doesn't apply to unified hierarchy */
898                 return -EOPNOTSUPP;
899
900         r = cg_get_path(controller, NULL, "release_agent", &fs);
901         if (r < 0)
902                 return r;
903
904         r = read_one_line_file(fs, &contents);
905         if (r < 0)
906                 return r;
907
908         sc = strstrip(contents);
909         if (isempty(sc)) {
910                 r = write_string_file(fs, agent, 0);
911                 if (r < 0)
912                         return r;
913         } else if (!path_equal(sc, agent))
914                 return -EEXIST;
915
916         fs = mfree(fs);
917         r = cg_get_path(controller, NULL, "notify_on_release", &fs);
918         if (r < 0)
919                 return r;
920
921         contents = mfree(contents);
922         r = read_one_line_file(fs, &contents);
923         if (r < 0)
924                 return r;
925
926         sc = strstrip(contents);
927         if (streq(sc, "0")) {
928                 r = write_string_file(fs, "1", 0);
929                 if (r < 0)
930                         return r;
931
932                 return 1;
933         }
934
935         if (!streq(sc, "1"))
936                 return -EIO;
937
938         return 0;
939 }
940
941 int cg_uninstall_release_agent(const char *controller) {
942         _cleanup_free_ char *fs = NULL;
943         int r, unified;
944
945         unified = cg_unified();
946         if (unified < 0)
947                 return unified;
948         if (unified) /* Doesn't apply to unified hierarchy */
949                 return -EOPNOTSUPP;
950
951         r = cg_get_path(controller, NULL, "notify_on_release", &fs);
952         if (r < 0)
953                 return r;
954
955         r = write_string_file(fs, "0", 0);
956         if (r < 0)
957                 return r;
958
959         fs = mfree(fs);
960
961         r = cg_get_path(controller, NULL, "release_agent", &fs);
962         if (r < 0)
963                 return r;
964
965         r = write_string_file(fs, "", 0);
966         if (r < 0)
967                 return r;
968
969         return 0;
970 }
971
972 int cg_is_empty(const char *controller, const char *path) {
973         _cleanup_fclose_ FILE *f = NULL;
974         pid_t pid;
975         int r;
976
977         assert(path);
978
979         r = cg_enumerate_processes(controller, path, &f);
980         if (r == -ENOENT)
981                 return 1;
982         if (r < 0)
983                 return r;
984
985         r = cg_read_pid(f, &pid);
986         if (r < 0)
987                 return r;
988
989         return r == 0;
990 }
991
992 int cg_is_empty_recursive(const char *controller, const char *path) {
993         int unified, r;
994
995         assert(path);
996
997         /* The root cgroup is always populated */
998         if (controller && (isempty(path) || path_equal(path, "/")))
999                 return false;
1000
1001         unified = cg_unified();
1002         if (unified < 0)
1003                 return unified;
1004
1005         if (unified > 0) {
1006                 _cleanup_free_ char *populated = NULL, *t = NULL;
1007
1008                 /* On the unified hierarchy we can check empty state
1009                  * via the "cgroup.populated" attribute. */
1010
1011                 r = cg_get_path(controller, path, "cgroup.populated", &populated);
1012                 if (r < 0)
1013                         return r;
1014
1015                 r = read_one_line_file(populated, &t);
1016                 if (r == -ENOENT)
1017                         return 1;
1018                 if (r < 0)
1019                         return r;
1020
1021                 return streq(t, "0");
1022         } else {
1023                 _cleanup_closedir_ DIR *d = NULL;
1024                 char *fn;
1025
1026                 r = cg_is_empty(controller, path);
1027                 if (r <= 0)
1028                         return r;
1029
1030                 r = cg_enumerate_subgroups(controller, path, &d);
1031                         if (r == -ENOENT)
1032                                 return 1;
1033                 if (r < 0)
1034                         return r;
1035
1036                 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1037                         _cleanup_free_ char *p = NULL;
1038
1039                         p = strjoin(path, "/", fn, NULL);
1040                         free(fn);
1041                         if (!p)
1042                                 return -ENOMEM;
1043
1044                         r = cg_is_empty_recursive(controller, p);
1045                         if (r <= 0)
1046                                 return r;
1047                 }
1048                 if (r < 0)
1049                         return r;
1050
1051                 return true;
1052         }
1053 }
1054
1055 int cg_split_spec(const char *spec, char **controller, char **path) {
1056         char *t = NULL, *u = NULL;
1057         const char *e;
1058
1059         assert(spec);
1060
1061         if (*spec == '/') {
1062                 if (!path_is_safe(spec))
1063                         return -EINVAL;
1064
1065                 if (path) {
1066                         t = strdup(spec);
1067                         if (!t)
1068                                 return -ENOMEM;
1069
1070                         *path = path_kill_slashes(t);
1071                 }
1072
1073                 if (controller)
1074                         *controller = NULL;
1075
1076                 return 0;
1077         }
1078
1079         e = strchr(spec, ':');
1080         if (!e) {
1081                 if (!cg_controller_is_valid(spec))
1082                         return -EINVAL;
1083
1084                 if (controller) {
1085                         t = strdup(spec);
1086                         if (!t)
1087                                 return -ENOMEM;
1088
1089                         *controller = t;
1090                 }
1091
1092                 if (path)
1093                         *path = NULL;
1094
1095                 return 0;
1096         }
1097
1098         t = strndup(spec, e-spec);
1099         if (!t)
1100                 return -ENOMEM;
1101         if (!cg_controller_is_valid(t)) {
1102                 free(t);
1103                 return -EINVAL;
1104         }
1105
1106         if (isempty(e+1))
1107                 u = NULL;
1108         else {
1109                 u = strdup(e+1);
1110                 if (!u) {
1111                         free(t);
1112                         return -ENOMEM;
1113                 }
1114
1115                 if (!path_is_safe(u) ||
1116                     !path_is_absolute(u)) {
1117                         free(t);
1118                         free(u);
1119                         return -EINVAL;
1120                 }
1121
1122                 path_kill_slashes(u);
1123         }
1124
1125         if (controller)
1126                 *controller = t;
1127         else
1128                 free(t);
1129
1130         if (path)
1131                 *path = u;
1132         else
1133                 free(u);
1134
1135         return 0;
1136 }
1137
1138 int cg_mangle_path(const char *path, char **result) {
1139         _cleanup_free_ char *c = NULL, *p = NULL;
1140         char *t;
1141         int r;
1142
1143         assert(path);
1144         assert(result);
1145
1146         /* First, check if it already is a filesystem path */
1147         if (path_startswith(path, "/sys/fs/cgroup")) {
1148
1149                 t = strdup(path);
1150                 if (!t)
1151                         return -ENOMEM;
1152
1153                 *result = path_kill_slashes(t);
1154                 return 0;
1155         }
1156
1157         /* Otherwise, treat it as cg spec */
1158         r = cg_split_spec(path, &c, &p);
1159         if (r < 0)
1160                 return r;
1161
1162         return cg_get_path(c ? c : SYSTEMD_CGROUP_CONTROLLER, p ? p : "/", NULL, result);
1163 }
1164
1165 int cg_get_root_path(char **path) {
1166 /// elogind does not support systemd scopes and slices
1167 #if 0
1168         char *p, *e;
1169         int r;
1170
1171         assert(path);
1172
1173         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 1, &p);
1174         if (r < 0)
1175                 return r;
1176
1177         e = endswith(p, "/" SPECIAL_INIT_SCOPE);
1178         if (!e)
1179                 e = endswith(p, "/" SPECIAL_SYSTEM_SLICE); /* legacy */
1180         if (!e)
1181                 e = endswith(p, "/system"); /* even more legacy */
1182         if (e)
1183                 *e = 0;
1184
1185         *path = p;
1186         return 0;
1187 #else
1188         assert(path);
1189         return cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 1, path);
1190 #endif // 0
1191 }
1192
1193 int cg_shift_path(const char *cgroup, const char *root, const char **shifted) {
1194         _cleanup_free_ char *rt = NULL;
1195         char *p;
1196         int r;
1197
1198         assert(cgroup);
1199         assert(shifted);
1200
1201         if (!root) {
1202                 /* If the root was specified let's use that, otherwise
1203                  * let's determine it from PID 1 */
1204
1205                 r = cg_get_root_path(&rt);
1206                 if (r < 0)
1207                         return r;
1208
1209                 root = rt;
1210                 log_debug_elogind("Determined root path: \"%s\"", root);
1211         }
1212
1213         p = path_startswith(cgroup, root);
1214         if (p && p[0] && (p > cgroup))
1215                 *shifted = p - 1;
1216         else
1217                 *shifted = cgroup;
1218
1219         return 0;
1220 }
1221
1222 int cg_pid_get_path_shifted(pid_t pid, const char *root, char **cgroup) {
1223         _cleanup_free_ char *raw = NULL;
1224         const char *c;
1225         int r;
1226
1227         assert(pid >= 0);
1228         assert(cgroup);
1229
1230         r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &raw);
1231         if (r < 0)
1232                 return r;
1233
1234         log_debug_elogind("Shifting path: \"%s\" (PID %u, root: \"%s\")",
1235                           raw, pid, root ? root : "NULL");
1236         r = cg_shift_path(raw, root, &c);
1237         if (r < 0)
1238                 return r;
1239
1240         if (c == raw) {
1241                 *cgroup = raw;
1242                 raw = NULL;
1243         } else {
1244                 char *n;
1245
1246                 n = strdup(c);
1247                 if (!n)
1248                         return -ENOMEM;
1249
1250                 *cgroup = n;
1251         }
1252         log_debug_elogind("Resulting cgroup:\"%s\"", *cgroup);
1253
1254         return 0;
1255 }
1256
1257 /// UNNEEDED by elogind
1258 #if 0
1259 int cg_path_decode_unit(const char *cgroup, char **unit){
1260         char *c, *s;
1261         size_t n;
1262
1263         assert(cgroup);
1264         assert(unit);
1265
1266         n = strcspn(cgroup, "/");
1267         if (n < 3)
1268                 return -ENXIO;
1269
1270         c = strndupa(cgroup, n);
1271         c = cg_unescape(c);
1272
1273         if (!unit_name_is_valid(c, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
1274                 return -ENXIO;
1275
1276         s = strdup(c);
1277         if (!s)
1278                 return -ENOMEM;
1279
1280         *unit = s;
1281         return 0;
1282 }
1283
1284 static bool valid_slice_name(const char *p, size_t n) {
1285
1286         if (!p)
1287                 return false;
1288
1289         if (n < strlen("x.slice"))
1290                 return false;
1291
1292         if (memcmp(p + n - 6, ".slice", 6) == 0) {
1293                 char buf[n+1], *c;
1294
1295                 memcpy(buf, p, n);
1296                 buf[n] = 0;
1297
1298                 c = cg_unescape(buf);
1299
1300                 return unit_name_is_valid(c, UNIT_NAME_PLAIN);
1301         }
1302
1303         return false;
1304 }
1305
1306 static const char *skip_slices(const char *p) {
1307         assert(p);
1308
1309         /* Skips over all slice assignments */
1310
1311         for (;;) {
1312                 size_t n;
1313
1314                 p += strspn(p, "/");
1315
1316                 n = strcspn(p, "/");
1317                 if (!valid_slice_name(p, n))
1318                         return p;
1319
1320                 p += n;
1321         }
1322 }
1323
1324 int cg_path_get_unit(const char *path, char **ret) {
1325         const char *e;
1326         char *unit;
1327         int r;
1328
1329         assert(path);
1330         assert(ret);
1331
1332         e = skip_slices(path);
1333
1334         r = cg_path_decode_unit(e, &unit);
1335         if (r < 0)
1336                 return r;
1337
1338         /* We skipped over the slices, don't accept any now */
1339         if (endswith(unit, ".slice")) {
1340                 free(unit);
1341                 return -ENXIO;
1342         }
1343
1344         *ret = unit;
1345         return 0;
1346 }
1347
1348 int cg_pid_get_unit(pid_t pid, char **unit) {
1349         _cleanup_free_ char *cgroup = NULL;
1350         int r;
1351
1352         assert(unit);
1353
1354         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1355         if (r < 0)
1356                 return r;
1357
1358         return cg_path_get_unit(cgroup, unit);
1359 }
1360
1361 /**
1362  * Skip session-*.scope, but require it to be there.
1363  */
1364 static const char *skip_session(const char *p) {
1365         size_t n;
1366
1367         if (isempty(p))
1368                 return NULL;
1369
1370         p += strspn(p, "/");
1371
1372         n = strcspn(p, "/");
1373         if (n < strlen("session-x.scope"))
1374                 return NULL;
1375
1376         if (memcmp(p, "session-", 8) == 0 && memcmp(p + n - 6, ".scope", 6) == 0) {
1377                 char buf[n - 8 - 6 + 1];
1378
1379                 memcpy(buf, p + 8, n - 8 - 6);
1380                 buf[n - 8 - 6] = 0;
1381
1382                 /* Note that session scopes never need unescaping,
1383                  * since they cannot conflict with the kernel's own
1384                  * names, hence we don't need to call cg_unescape()
1385                  * here. */
1386
1387                 if (!session_id_valid(buf))
1388                         return false;
1389
1390                 p += n;
1391                 p += strspn(p, "/");
1392                 return p;
1393         }
1394
1395         return NULL;
1396 }
1397
1398 /**
1399  * Skip user@*.service, but require it to be there.
1400  */
1401 static const char *skip_user_manager(const char *p) {
1402         size_t n;
1403
1404         if (isempty(p))
1405                 return NULL;
1406
1407         p += strspn(p, "/");
1408
1409         n = strcspn(p, "/");
1410         if (n < strlen("user@x.service"))
1411                 return NULL;
1412
1413         if (memcmp(p, "user@", 5) == 0 && memcmp(p + n - 8, ".service", 8) == 0) {
1414                 char buf[n - 5 - 8 + 1];
1415
1416                 memcpy(buf, p + 5, n - 5 - 8);
1417                 buf[n - 5 - 8] = 0;
1418
1419                 /* Note that user manager services never need unescaping,
1420                  * since they cannot conflict with the kernel's own
1421                  * names, hence we don't need to call cg_unescape()
1422                  * here. */
1423
1424                 if (parse_uid(buf, NULL) < 0)
1425                         return NULL;
1426
1427                 p += n;
1428                 p += strspn(p, "/");
1429
1430                 return p;
1431         }
1432
1433         return NULL;
1434 }
1435
1436 static const char *skip_user_prefix(const char *path) {
1437         const char *e, *t;
1438
1439         assert(path);
1440
1441         /* Skip slices, if there are any */
1442         e = skip_slices(path);
1443
1444         /* Skip the user manager, if it's in the path now... */
1445         t = skip_user_manager(e);
1446         if (t)
1447                 return t;
1448
1449         /* Alternatively skip the user session if it is in the path... */
1450         return skip_session(e);
1451 }
1452
1453 int cg_path_get_user_unit(const char *path, char **ret) {
1454         const char *t;
1455
1456         assert(path);
1457         assert(ret);
1458
1459         t = skip_user_prefix(path);
1460         if (!t)
1461                 return -ENXIO;
1462
1463         /* And from here on it looks pretty much the same as for a
1464          * system unit, hence let's use the same parser from here
1465          * on. */
1466         return cg_path_get_unit(t, ret);
1467 }
1468
1469 int cg_pid_get_user_unit(pid_t pid, char **unit) {
1470         _cleanup_free_ char *cgroup = NULL;
1471         int r;
1472
1473         assert(unit);
1474
1475         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1476         if (r < 0)
1477                 return r;
1478
1479         return cg_path_get_user_unit(cgroup, unit);
1480 }
1481
1482 int cg_path_get_machine_name(const char *path, char **machine) {
1483         _cleanup_free_ char *u = NULL;
1484         const char *sl;
1485         int r;
1486
1487         r = cg_path_get_unit(path, &u);
1488         if (r < 0)
1489                 return r;
1490
1491         sl = strjoina("/run/systemd/machines/unit:", u);
1492         return readlink_malloc(sl, machine);
1493 }
1494
1495 int cg_pid_get_machine_name(pid_t pid, char **machine) {
1496         _cleanup_free_ char *cgroup = NULL;
1497         int r;
1498
1499         assert(machine);
1500
1501         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1502         if (r < 0)
1503                 return r;
1504
1505         return cg_path_get_machine_name(cgroup, machine);
1506 }
1507 #endif // 0
1508
1509 int cg_path_get_session(const char *path, char **session) {
1510         /* Elogind uses a flat hierarchy, just "/SESSION".  The only
1511            wrinkle is that SESSION might be escaped.  */
1512 #if 0
1513         _cleanup_free_ char *unit = NULL;
1514         char *start, *end;
1515         int r;
1516
1517         assert(path);
1518
1519         r = cg_path_get_unit(path, &unit);
1520         if (r < 0)
1521                 return r;
1522
1523         start = startswith(unit, "session-");
1524         if (!start)
1525                 return -ENXIO;
1526         end = endswith(start, ".scope");
1527         if (!end)
1528                 return -ENXIO;
1529
1530         *end = 0;
1531         if (!session_id_valid(start))
1532                 return -ENXIO;
1533 #else
1534         const char *e, *n, *start;
1535
1536         assert(path);
1537         log_debug_elogind("path is \"%s\"", path);
1538         assert(path[0] == '/');
1539
1540         e = path + 1;
1541         n = strchrnul(e, '/');
1542         if (e == n)
1543                 return -ENOENT;
1544
1545         start = strndupa(e, n - e);
1546         start = cg_unescape(start);
1547
1548         if (!start[0])
1549                 return -ENOENT;
1550 #endif // 0
1551
1552         if (session) {
1553                 char *rr;
1554
1555                 log_debug_elogind("found session: \"%s\"", start);
1556                 rr = strdup(start);
1557                 if (!rr)
1558                         return -ENOMEM;
1559
1560                 *session = rr;
1561         }
1562
1563         return 0;
1564 }
1565
1566 int cg_pid_get_session(pid_t pid, char **session) {
1567         _cleanup_free_ char *cgroup = NULL;
1568         int r;
1569
1570         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1571         if (r < 0)
1572                 return r;
1573
1574         return cg_path_get_session(cgroup, session);
1575 }
1576
1577 /// UNNEEDED by elogind
1578 #if 0
1579 int cg_path_get_owner_uid(const char *path, uid_t *uid) {
1580         _cleanup_free_ char *slice = NULL;
1581         char *start, *end;
1582         int r;
1583
1584         assert(path);
1585
1586         r = cg_path_get_slice(path, &slice);
1587         if (r < 0)
1588                 return r;
1589
1590         start = startswith(slice, "user-");
1591         if (!start)
1592                 return -ENXIO;
1593         end = endswith(start, ".slice");
1594         if (!end)
1595                 return -ENXIO;
1596
1597         *end = 0;
1598         if (parse_uid(start, uid) < 0)
1599                 return -ENXIO;
1600
1601         return 0;
1602 }
1603
1604 int cg_pid_get_owner_uid(pid_t pid, uid_t *uid) {
1605         _cleanup_free_ char *cgroup = NULL;
1606         int r;
1607
1608         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1609         if (r < 0)
1610                 return r;
1611
1612         return cg_path_get_owner_uid(cgroup, uid);
1613 }
1614
1615 int cg_path_get_slice(const char *p, char **slice) {
1616         const char *e = NULL;
1617
1618         assert(p);
1619         assert(slice);
1620
1621         /* Finds the right-most slice unit from the beginning, but
1622          * stops before we come to the first non-slice unit. */
1623
1624         for (;;) {
1625                 size_t n;
1626
1627                 p += strspn(p, "/");
1628
1629                 n = strcspn(p, "/");
1630                 if (!valid_slice_name(p, n)) {
1631
1632                         if (!e) {
1633                                 char *s;
1634
1635                                 s = strdup("-.slice");
1636                                 if (!s)
1637                                         return -ENOMEM;
1638
1639                                 *slice = s;
1640                                 return 0;
1641                         }
1642
1643                         return cg_path_decode_unit(e, slice);
1644                 }
1645
1646                 e = p;
1647                 p += n;
1648         }
1649 }
1650
1651 int cg_pid_get_slice(pid_t pid, char **slice) {
1652         _cleanup_free_ char *cgroup = NULL;
1653         int r;
1654
1655         assert(slice);
1656
1657         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1658         if (r < 0)
1659                 return r;
1660
1661         return cg_path_get_slice(cgroup, slice);
1662 }
1663
1664 int cg_path_get_user_slice(const char *p, char **slice) {
1665         const char *t;
1666         assert(p);
1667         assert(slice);
1668
1669         t = skip_user_prefix(p);
1670         if (!t)
1671                 return -ENXIO;
1672
1673         /* And now it looks pretty much the same as for a system
1674          * slice, so let's just use the same parser from here on. */
1675         return cg_path_get_slice(t, slice);
1676 }
1677
1678 int cg_pid_get_user_slice(pid_t pid, char **slice) {
1679         _cleanup_free_ char *cgroup = NULL;
1680         int r;
1681
1682         assert(slice);
1683
1684         r = cg_pid_get_path_shifted(pid, NULL, &cgroup);
1685         if (r < 0)
1686                 return r;
1687
1688         return cg_path_get_user_slice(cgroup, slice);
1689 }
1690 #endif // 0
1691
1692 char *cg_escape(const char *p) {
1693         bool need_prefix = false;
1694
1695         /* This implements very minimal escaping for names to be used
1696          * as file names in the cgroup tree: any name which might
1697          * conflict with a kernel name or is prefixed with '_' is
1698          * prefixed with a '_'. That way, when reading cgroup names it
1699          * is sufficient to remove a single prefixing underscore if
1700          * there is one. */
1701
1702         /* The return value of this function (unlike cg_unescape())
1703          * needs free()! */
1704
1705         if (p[0] == 0 ||
1706             p[0] == '_' ||
1707             p[0] == '.' ||
1708             streq(p, "notify_on_release") ||
1709             streq(p, "release_agent") ||
1710             streq(p, "tasks") ||
1711             startswith(p, "cgroup."))
1712                 need_prefix = true;
1713         else {
1714                 const char *dot;
1715
1716                 dot = strrchr(p, '.');
1717                 if (dot) {
1718                         CGroupController c;
1719                         size_t l = dot - p;
1720
1721                         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1722                                 const char *n;
1723
1724                                 n = cgroup_controller_to_string(c);
1725
1726                                 if (l != strlen(n))
1727                                         continue;
1728
1729                                 if (memcmp(p, n, l) != 0)
1730                                         continue;
1731
1732                                 need_prefix = true;
1733                                 break;
1734                         }
1735                 }
1736         }
1737
1738         if (need_prefix)
1739                 return strappend("_", p);
1740
1741         return strdup(p);
1742 }
1743
1744 char *cg_unescape(const char *p) {
1745         assert(p);
1746
1747         /* The return value of this function (unlike cg_escape())
1748          * doesn't need free()! */
1749
1750         if (p[0] == '_')
1751                 return (char*) p+1;
1752
1753         return (char*) p;
1754 }
1755
1756 #define CONTROLLER_VALID                        \
1757         DIGITS LETTERS                          \
1758         "_"
1759
1760 bool cg_controller_is_valid(const char *p) {
1761         const char *t, *s;
1762
1763         if (!p)
1764                 return false;
1765
1766         s = startswith(p, "name=");
1767         if (s)
1768                 p = s;
1769
1770         if (*p == 0 || *p == '_')
1771                 return false;
1772
1773         for (t = p; *t; t++)
1774                 if (!strchr(CONTROLLER_VALID, *t))
1775                         return false;
1776
1777         if (t - p > FILENAME_MAX)
1778                 return false;
1779
1780         return true;
1781 }
1782
1783 /// UNNEEDED by elogind
1784 #if 0
1785 int cg_slice_to_path(const char *unit, char **ret) {
1786         _cleanup_free_ char *p = NULL, *s = NULL, *e = NULL;
1787         const char *dash;
1788         int r;
1789
1790         assert(unit);
1791         assert(ret);
1792
1793         if (streq(unit, "-.slice")) {
1794                 char *x;
1795
1796                 x = strdup("");
1797                 if (!x)
1798                         return -ENOMEM;
1799                 *ret = x;
1800                 return 0;
1801         }
1802
1803         if (!unit_name_is_valid(unit, UNIT_NAME_PLAIN))
1804                 return -EINVAL;
1805
1806         if (!endswith(unit, ".slice"))
1807                 return -EINVAL;
1808
1809         r = unit_name_to_prefix(unit, &p);
1810         if (r < 0)
1811                 return r;
1812
1813         dash = strchr(p, '-');
1814
1815         /* Don't allow initial dashes */
1816         if (dash == p)
1817                 return -EINVAL;
1818
1819         while (dash) {
1820                 _cleanup_free_ char *escaped = NULL;
1821                 char n[dash - p + sizeof(".slice")];
1822
1823                 /* Don't allow trailing or double dashes */
1824                 if (dash[1] == 0 || dash[1] == '-')
1825                         return -EINVAL;
1826
1827                 strcpy(stpncpy(n, p, dash - p), ".slice");
1828                 if (!unit_name_is_valid(n, UNIT_NAME_PLAIN))
1829                         return -EINVAL;
1830
1831                 escaped = cg_escape(n);
1832                 if (!escaped)
1833                         return -ENOMEM;
1834
1835                 if (!strextend(&s, escaped, "/", NULL))
1836                         return -ENOMEM;
1837
1838                 dash = strchr(dash+1, '-');
1839         }
1840
1841         e = cg_escape(unit);
1842         if (!e)
1843                 return -ENOMEM;
1844
1845         if (!strextend(&s, e, NULL))
1846                 return -ENOMEM;
1847
1848         *ret = s;
1849         s = NULL;
1850
1851         return 0;
1852 }
1853 #endif // 0
1854
1855 int cg_set_attribute(const char *controller, const char *path, const char *attribute, const char *value) {
1856         _cleanup_free_ char *p = NULL;
1857         int r;
1858
1859         r = cg_get_path(controller, path, attribute, &p);
1860         if (r < 0)
1861                 return r;
1862
1863         return write_string_file(p, value, 0);
1864 }
1865
1866 /// UNNEEDED by elogind
1867 #if 0
1868 int cg_get_attribute(const char *controller, const char *path, const char *attribute, char **ret) {
1869         _cleanup_free_ char *p = NULL;
1870         int r;
1871
1872         r = cg_get_path(controller, path, attribute, &p);
1873         if (r < 0)
1874                 return r;
1875
1876         return read_one_line_file(p, ret);
1877 }
1878
1879 int cg_create_everywhere(CGroupMask supported, CGroupMask mask, const char *path) {
1880         CGroupController c;
1881         int r, unified;
1882
1883         /* This one will create a cgroup in our private tree, but also
1884          * duplicate it in the trees specified in mask, and remove it
1885          * in all others */
1886
1887         /* First create the cgroup in our own hierarchy. */
1888         r = cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1889         if (r < 0)
1890                 return r;
1891
1892         /* If we are in the unified hierarchy, we are done now */
1893         unified = cg_unified();
1894         if (unified < 0)
1895                 return unified;
1896         if (unified > 0)
1897                 return 0;
1898
1899         /* Otherwise, do the same in the other hierarchies */
1900         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1901                 CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
1902                 const char *n;
1903
1904                 n = cgroup_controller_to_string(c);
1905
1906                 if (mask & bit)
1907                         (void) cg_create(n, path);
1908                 else if (supported & bit)
1909                         (void) cg_trim(n, path, true);
1910         }
1911
1912         return 0;
1913 }
1914
1915 int cg_attach_everywhere(CGroupMask supported, const char *path, pid_t pid, cg_migrate_callback_t path_callback, void *userdata) {
1916         CGroupController c;
1917         int r, unified;
1918
1919         r = cg_attach(SYSTEMD_CGROUP_CONTROLLER, path, pid);
1920         if (r < 0)
1921                 return r;
1922
1923         unified = cg_unified();
1924         if (unified < 0)
1925                 return unified;
1926         if (unified > 0)
1927                 return 0;
1928
1929         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1930                 CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
1931                         const char *p = NULL;
1932
1933                 if (!(supported & bit))
1934                         continue;
1935
1936                         if (path_callback)
1937                                 p = path_callback(bit, userdata);
1938
1939                         if (!p)
1940                                 p = path;
1941
1942                 (void) cg_attach_fallback(cgroup_controller_to_string(c), p, pid);
1943         }
1944
1945         return 0;
1946 }
1947
1948 int cg_attach_many_everywhere(CGroupMask supported, const char *path, Set* pids, cg_migrate_callback_t path_callback, void *userdata) {
1949         Iterator i;
1950         void *pidp;
1951         int r = 0;
1952
1953         SET_FOREACH(pidp, pids, i) {
1954                 pid_t pid = PTR_TO_PID(pidp);
1955                 int q;
1956
1957                 q = cg_attach_everywhere(supported, path, pid, path_callback, userdata);
1958                 if (q < 0 && r >= 0)
1959                         r = q;
1960         }
1961
1962         return r;
1963 }
1964
1965 int cg_migrate_everywhere(CGroupMask supported, const char *from, const char *to, cg_migrate_callback_t to_callback, void *userdata) {
1966         CGroupController c;
1967         int r = 0, unified;
1968
1969         if (!path_equal(from, to))  {
1970                 r = cg_migrate_recursive(SYSTEMD_CGROUP_CONTROLLER, from, SYSTEMD_CGROUP_CONTROLLER, to, false, true);
1971                 if (r < 0)
1972                         return r;
1973         }
1974
1975         unified = cg_unified();
1976         if (unified < 0)
1977                 return unified;
1978         if (unified > 0)
1979                 return r;
1980
1981         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
1982                 CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
1983                         const char *p = NULL;
1984
1985                 if (!(supported & bit))
1986                         continue;
1987
1988                         if (to_callback)
1989                                 p = to_callback(bit, userdata);
1990
1991                         if (!p)
1992                                 p = to;
1993
1994                 (void) cg_migrate_recursive_fallback(SYSTEMD_CGROUP_CONTROLLER, to, cgroup_controller_to_string(c), p, false, false);
1995         }
1996
1997         return 0;
1998 }
1999
2000 int cg_trim_everywhere(CGroupMask supported, const char *path, bool delete_root) {
2001         CGroupController c;
2002         int r, unified;
2003
2004         r = cg_trim(SYSTEMD_CGROUP_CONTROLLER, path, delete_root);
2005         if (r < 0)
2006                 return r;
2007
2008         unified = cg_unified();
2009         if (unified < 0)
2010                 return unified;
2011         if (unified > 0)
2012                 return r;
2013
2014         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
2015                 CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
2016
2017                 if (!(supported & bit))
2018                         continue;
2019
2020                 (void) cg_trim(cgroup_controller_to_string(c), path, delete_root);
2021         }
2022
2023         return 0;
2024 }
2025 #endif // 0
2026
2027 int cg_mask_supported(CGroupMask *ret) {
2028         CGroupMask mask = 0;
2029         int r, unified;
2030
2031         /* Determines the mask of supported cgroup controllers. Only
2032          * includes controllers we can make sense of and that are
2033          * actually accessible. */
2034
2035         unified = cg_unified();
2036         if (unified < 0)
2037                 return unified;
2038         if (unified > 0) {
2039                 _cleanup_free_ char *root = NULL, *controllers = NULL, *path = NULL;
2040                 const char *c;
2041
2042                 /* In the unified hierarchy we can read the supported
2043                  * and accessible controllers from a the top-level
2044                  * cgroup attribute */
2045
2046                 r = cg_get_root_path(&root);
2047                 if (r < 0)
2048                         return r;
2049
2050                 r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, root, "cgroup.controllers", &path);
2051                 if (r < 0)
2052                         return r;
2053
2054                 r = read_one_line_file(path, &controllers);
2055                 if (r < 0)
2056                         return r;
2057
2058                 c = controllers;
2059                 for (;;) {
2060                         _cleanup_free_ char *n = NULL;
2061                         CGroupController v;
2062
2063                         r = extract_first_word(&c, &n, NULL, 0);
2064                         if (r < 0)
2065                                 return r;
2066                         if (r == 0)
2067                                 break;
2068
2069                         v = cgroup_controller_from_string(n);
2070                         if (v < 0)
2071                                 continue;
2072
2073                         mask |= CGROUP_CONTROLLER_TO_MASK(v);
2074         }
2075
2076                 /* Currently, we only support the memory and pids
2077                  * controller in the unified hierarchy, mask
2078                  * everything else off. */
2079                 mask &= CGROUP_MASK_MEMORY | CGROUP_MASK_PIDS;
2080
2081         } else {
2082                 CGroupController c;
2083
2084                 /* In the legacy hierarchy, we check whether which
2085                  * hierarchies are mounted. */
2086
2087                 for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
2088                         const char *n;
2089
2090                         n = cgroup_controller_to_string(c);
2091                         if (controller_is_accessible(n) >= 0)
2092                                 mask |= CGROUP_CONTROLLER_TO_MASK(c);
2093                 }
2094         }
2095
2096         *ret = mask;
2097         return 0;
2098 }
2099
2100 /// UNNEEDED by elogind
2101 #if 0
2102 int cg_kernel_controllers(Set *controllers) {
2103         _cleanup_fclose_ FILE *f = NULL;
2104         char buf[LINE_MAX];
2105         int r;
2106
2107         assert(controllers);
2108
2109         /* Determines the full list of kernel-known controllers. Might
2110          * include controllers we don't actually support, arbitrary
2111          * named hierarchies and controllers that aren't currently
2112          * accessible (because not mounted). */
2113
2114         f = fopen("/proc/cgroups", "re");
2115         if (!f) {
2116                 if (errno == ENOENT)
2117                         return 0;
2118                 return -errno;
2119         }
2120
2121         /* Ignore the header line */
2122         (void) fgets(buf, sizeof(buf), f);
2123
2124         for (;;) {
2125                 char *controller;
2126                 int enabled = 0;
2127
2128                 errno = 0;
2129                 if (fscanf(f, "%ms %*i %*i %i", &controller, &enabled) != 2) {
2130
2131                         if (feof(f))
2132                                 break;
2133
2134                         if (ferror(f) && errno != 0)
2135                                 return -errno;
2136
2137                         return -EBADMSG;
2138                 }
2139
2140                 if (!enabled) {
2141                         free(controller);
2142                         continue;
2143                 }
2144
2145                 if (!cg_controller_is_valid(controller)) {
2146                         free(controller);
2147                         return -EBADMSG;
2148                 }
2149
2150                 r = set_consume(controllers, controller);
2151                 if (r < 0)
2152                         return r;
2153         }
2154
2155         return 0;
2156 }
2157 #endif // 0
2158
2159 static thread_local int unified_cache = -1;
2160
2161 int cg_unified(void) {
2162         struct statfs fs;
2163
2164         /* Checks if we support the unified hierarchy. Returns an
2165          * error when the cgroup hierarchies aren't mounted yet or we
2166          * have any other trouble determining if the unified hierarchy
2167          * is supported. */
2168
2169         if (unified_cache >= 0)
2170                 return unified_cache;
2171
2172         if (statfs("/sys/fs/cgroup/", &fs) < 0)
2173                 return -errno;
2174
2175 /// elogind can not support the unified hierarchy as a controller,
2176 /// so always assume a classical hierarchy.
2177 /// If, ond only *if*, someone really wants to substitute systemd-login
2178 /// in an environment managed by systemd with elogin, we might have to
2179 /// add such a support.
2180 #if 0
2181         if (F_TYPE_EQUAL(fs.f_type, CGROUP_SUPER_MAGIC))
2182                 unified_cache = true;
2183         else if (F_TYPE_EQUAL(fs.f_type, TMPFS_MAGIC))
2184 #else
2185         if (F_TYPE_EQUAL(fs.f_type, TMPFS_MAGIC))
2186 #endif // 0
2187                 unified_cache = false;
2188         else
2189                 return -ENOEXEC;
2190
2191         return unified_cache;
2192 }
2193
2194 /// UNNEEDED by elogind
2195 #if 0
2196 void cg_unified_flush(void) {
2197         unified_cache = -1;
2198 }
2199
2200 int cg_enable_everywhere(CGroupMask supported, CGroupMask mask, const char *p) {
2201         _cleanup_free_ char *fs = NULL;
2202         CGroupController c;
2203         int r, unified;
2204
2205         assert(p);
2206
2207         if (supported == 0)
2208                 return 0;
2209
2210         unified = cg_unified();
2211         if (unified < 0)
2212                 return unified;
2213         if (!unified) /* on the legacy hiearchy there's no joining of controllers defined */
2214                 return 0;
2215
2216         r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, p, "cgroup.subtree_control", &fs);
2217         if (r < 0)
2218                 return r;
2219
2220         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++) {
2221                 CGroupMask bit = CGROUP_CONTROLLER_TO_MASK(c);
2222                 const char *n;
2223
2224                 if (!(supported & bit))
2225                         continue;
2226
2227                 n = cgroup_controller_to_string(c);
2228                 {
2229                         char s[1 + strlen(n) + 1];
2230
2231                         s[0] = mask & bit ? '+' : '-';
2232                         strcpy(s + 1, n);
2233
2234                         r = write_string_file(fs, s, 0);
2235                         if (r < 0)
2236                                 log_debug_errno(r, "Failed to enable controller %s for %s (%s): %m", n, p, fs);
2237                 }
2238         }
2239
2240         return 0;
2241 }
2242
2243 bool cg_is_unified_wanted(void) {
2244         static thread_local int wanted = -1;
2245         int r, unified;
2246
2247         /* If the hierarchy is already mounted, then follow whatever
2248          * was chosen for it. */
2249         unified = cg_unified();
2250         if (unified >= 0)
2251                 return unified;
2252
2253         /* Otherwise, let's see what the kernel command line has to
2254          * say. Since checking that is expensive, let's cache the
2255          * result. */
2256         if (wanted >= 0)
2257                 return wanted;
2258
2259         r = get_proc_cmdline_key("systemd.unified_cgroup_hierarchy", NULL);
2260         if (r > 0)
2261                 return (wanted = true);
2262         else {
2263                 _cleanup_free_ char *value = NULL;
2264
2265                 r = get_proc_cmdline_key("systemd.unified_cgroup_hierarchy=", &value);
2266                 if (r < 0)
2267                         return false;
2268                 if (r == 0)
2269                         return (wanted = false);
2270
2271                 return (wanted = parse_boolean(value) > 0);
2272         }
2273 }
2274
2275 bool cg_is_legacy_wanted(void) {
2276         return !cg_is_unified_wanted();
2277 }
2278 #else
2279 bool cg_is_legacy_wanted(void) {
2280         return true;
2281 }
2282 #endif // 0
2283
2284 int cg_cpu_shares_parse(const char *s, uint64_t *ret) {
2285         uint64_t u;
2286         int r;
2287
2288         if (isempty(s)) {
2289                 *ret = CGROUP_CPU_SHARES_INVALID;
2290                 return 0;
2291         }
2292
2293         r = safe_atou64(s, &u);
2294         if (r < 0)
2295                 return r;
2296
2297         if (u < CGROUP_CPU_SHARES_MIN || u > CGROUP_CPU_SHARES_MAX)
2298                 return -ERANGE;
2299
2300         *ret = u;
2301         return 0;
2302 }
2303
2304 int cg_blkio_weight_parse(const char *s, uint64_t *ret) {
2305         uint64_t u;
2306         int r;
2307
2308         if (isempty(s)) {
2309                 *ret = CGROUP_BLKIO_WEIGHT_INVALID;
2310                 return 0;
2311         }
2312
2313         r = safe_atou64(s, &u);
2314         if (r < 0)
2315                 return r;
2316
2317         if (u < CGROUP_BLKIO_WEIGHT_MIN || u > CGROUP_BLKIO_WEIGHT_MAX)
2318                 return -ERANGE;
2319
2320         *ret = u;
2321         return 0;
2322  }
2323
2324 static const char *cgroup_controller_table[_CGROUP_CONTROLLER_MAX] = {
2325         [CGROUP_CONTROLLER_CPU] = "cpu",
2326         [CGROUP_CONTROLLER_CPUACCT] = "cpuacct",
2327         [CGROUP_CONTROLLER_BLKIO] = "blkio",
2328         [CGROUP_CONTROLLER_MEMORY] = "memory",
2329         [CGROUP_CONTROLLER_DEVICES] = "devices",
2330         [CGROUP_CONTROLLER_PIDS] = "pids",
2331         [CGROUP_CONTROLLER_NET_CLS] = "net_cls",
2332 };
2333
2334 DEFINE_STRING_TABLE_LOOKUP(cgroup_controller, CGroupController);