src/test/test-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 2013 Zbigniew Jędrzejewski-Szmek
   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 "cgroup-util.h"
  23 #include "fd-util.h"
  24 #include "formats-util.h"
  25 #include "parse-util.h"
  26 #include "process-util.h"
  27 #include "string-util.h"
  28 #include "test-helper.h"
  29 #include "util.h"
  30
  31 static void check_p_d_u(const char *path, int code, const char *result) {
  32         _cleanup_free_ char *unit = NULL;
  33         int r;
  34
  35         r = cg_path_decode_unit(path, &unit);
  36         printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, result, code);
  37         assert_se(r == code);
  38         assert_se(streq_ptr(unit, result));
  39 }
  40
  41 static void test_path_decode_unit(void) {
  42         check_p_d_u("getty@tty2.service", 0, "getty@tty2.service");
  43         check_p_d_u("getty@tty2.service/", 0, "getty@tty2.service");
  44         check_p_d_u("getty@tty2.service/xxx", 0, "getty@tty2.service");
  45         check_p_d_u("getty@.service/", -ENXIO, NULL);
  46         check_p_d_u("getty@.service", -ENXIO, NULL);
  47         check_p_d_u("getty.service", 0, "getty.service");
  48         check_p_d_u("getty", -ENXIO, NULL);
  49         check_p_d_u("getty/waldo", -ENXIO, NULL);
  50         check_p_d_u("_cpu.service", 0, "cpu.service");
  51 }
  52
  53 static void check_p_g_u(const char *path, int code, const char *result) {
  54         _cleanup_free_ char *unit = NULL;
  55         int r;
  56
  57         r = cg_path_get_unit(path, &unit);
  58         printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, result, code);
  59         assert_se(r == code);
  60         assert_se(streq_ptr(unit, result));
  61 }
  62
  63 static void test_path_get_unit(void) {
  64         check_p_g_u("/system.slice/foobar.service/sdfdsaf", 0, "foobar.service");
  65         check_p_g_u("/system.slice/getty@tty5.service", 0, "getty@tty5.service");
  66         check_p_g_u("/system.slice/getty@tty5.service/aaa/bbb", 0, "getty@tty5.service");
  67         check_p_g_u("/system.slice/getty@tty5.service/", 0, "getty@tty5.service");
  68         check_p_g_u("/system.slice/getty@tty6.service/tty5", 0, "getty@tty6.service");
  69         check_p_g_u("sadfdsafsda", -ENXIO, NULL);
  70         check_p_g_u("/system.slice/getty####@tty6.service/xxx", -ENXIO, NULL);
  71         check_p_g_u("/system.slice/system-waldo.slice/foobar.service/sdfdsaf", 0, "foobar.service");
  72         check_p_g_u("/system.slice/system-waldo.slice/_cpu.service/sdfdsaf", 0, "cpu.service");
  73         check_p_g_u("/user.slice/user-1000.slice/user@1000.service/server.service", 0, "user@1000.service");
  74         check_p_g_u("/user.slice/user-1000.slice/user@.service/server.service", -ENXIO, NULL);
  75 }
  76
  77 static void check_p_g_u_u(const char *path, int code, const char *result) {
  78         _cleanup_free_ char *unit = NULL;
  79         int r;
  80
  81         r = cg_path_get_user_unit(path, &unit);
  82         printf("%s: %s → %s %d expected %s %d\n", __func__, path, unit, r, result, code);
  83         assert_se(r == code);
  84         assert_se(streq_ptr(unit, result));
  85 }
  86
  87 static void test_path_get_user_unit(void) {
  88         check_p_g_u_u("/user.slice/user-1000.slice/session-2.scope/foobar.service", 0, "foobar.service");
  89         check_p_g_u_u("/user.slice/user-1000.slice/session-2.scope/waldo.slice/foobar.service", 0, "foobar.service");
  90         check_p_g_u_u("/user.slice/user-1002.slice/session-2.scope/foobar.service/waldo", 0, "foobar.service");
  91         check_p_g_u_u("/user.slice/user-1000.slice/session-2.scope/foobar.service/waldo/uuuux", 0, "foobar.service");
  92         check_p_g_u_u("/user.slice/user-1000.slice/session-2.scope/waldo/waldo/uuuux", -ENXIO, NULL);
  93         check_p_g_u_u("/user.slice/user-1000.slice/session-2.scope/foobar@pie.service/pa/po", 0, "foobar@pie.service");
  94         check_p_g_u_u("/session-2.scope/foobar@pie.service/pa/po", 0, "foobar@pie.service");
  95         check_p_g_u_u("/xyz.slice/xyz-waldo.slice/session-77.scope/foobar@pie.service/pa/po", 0, "foobar@pie.service");
  96         check_p_g_u_u("/meh.service", -ENXIO, NULL);
  97         check_p_g_u_u("/session-3.scope/_cpu.service", 0, "cpu.service");
  98         check_p_g_u_u("/user.slice/user-1000.slice/user@1000.service/server.service", 0, "server.service");
  99         check_p_g_u_u("/user.slice/user-1000.slice/user@1000.service/foobar.slice/foobar@pie.service", 0, "foobar@pie.service");
 100         check_p_g_u_u("/user.slice/user-1000.slice/user@.service/server.service", -ENXIO, NULL);
 101 }
 102
 103 static void check_p_g_s(const char *path, int code, const char *result) {
 104         _cleanup_free_ char *s = NULL;
 105
 106         assert_se(cg_path_get_session(path, &s) == code);
 107         assert_se(streq_ptr(s, result));
 108 }
 109
 110 static void test_path_get_session(void) {
 111         check_p_g_s("/user.slice/user-1000.slice/session-2.scope/foobar.service", 0, "2");
 112         check_p_g_s("/session-3.scope", 0, "3");
 113         check_p_g_s("/session-.scope", -ENXIO, NULL);
 114         check_p_g_s("", -ENXIO, NULL);
 115 }
 116
 117 static void check_p_g_o_u(const char *path, int code, uid_t result) {
 118         uid_t uid = 0;
 119
 120         assert_se(cg_path_get_owner_uid(path, &uid) == code);
 121         assert_se(uid == result);
 122 }
 123
 124 static void test_path_get_owner_uid(void) {
 125         check_p_g_o_u("/user.slice/user-1000.slice/session-2.scope/foobar.service", 0, 1000);
 126         check_p_g_o_u("/user.slice/user-1006.slice", 0, 1006);
 127         check_p_g_o_u("", -ENXIO, 0);
 128 }
 129
 130 static void check_p_g_slice(const char *path, int code, const char *result) {
 131         _cleanup_free_ char *s = NULL;
 132
 133         assert_se(cg_path_get_slice(path, &s) == code);
 134         assert_se(streq_ptr(s, result));
 135 }
 136
 137 static void test_path_get_slice(void) {
 138         check_p_g_slice("/user.slice", 0, "user.slice");
 139         check_p_g_slice("/foobar", 0, "-.slice");
 140         check_p_g_slice("/user.slice/user-waldo.slice", 0, "user-waldo.slice");
 141         check_p_g_slice("", 0, "-.slice");
 142         check_p_g_slice("foobar", 0, "-.slice");
 143         check_p_g_slice("foobar.slice", 0, "foobar.slice");
 144         check_p_g_slice("foo.slice/foo-bar.slice/waldo.service", 0, "foo-bar.slice");
 145 }
 146
 147 static void check_p_g_u_slice(const char *path, int code, const char *result) {
 148         _cleanup_free_ char *s = NULL;
 149
 150         assert_se(cg_path_get_user_slice(path, &s) == code);
 151         assert_se(streq_ptr(s, result));
 152 }
 153
 154 static void test_path_get_user_slice(void) {
 155         check_p_g_u_slice("/user.slice", -ENXIO, NULL);
 156         check_p_g_u_slice("/foobar", -ENXIO, NULL);
 157         check_p_g_u_slice("/user.slice/user-waldo.slice", -ENXIO, NULL);
 158         check_p_g_u_slice("", -ENXIO, NULL);
 159         check_p_g_u_slice("foobar", -ENXIO, NULL);
 160         check_p_g_u_slice("foobar.slice", -ENXIO, NULL);
 161         check_p_g_u_slice("foo.slice/foo-bar.slice/waldo.service", -ENXIO, NULL);
 162
 163         check_p_g_u_slice("foo.slice/foo-bar.slice/user@1000.service", 0, "-.slice");
 164         check_p_g_u_slice("foo.slice/foo-bar.slice/user@1000.service/", 0, "-.slice");
 165         check_p_g_u_slice("foo.slice/foo-bar.slice/user@1000.service///", 0, "-.slice");
 166         check_p_g_u_slice("foo.slice/foo-bar.slice/user@1000.service/waldo.service", 0, "-.slice");
 167         check_p_g_u_slice("foo.slice/foo-bar.slice/user@1000.service/piep.slice/foo.service", 0, "piep.slice");
 168         check_p_g_u_slice("/foo.slice//foo-bar.slice/user@1000.service/piep.slice//piep-pap.slice//foo.service", 0, "piep-pap.slice");
 169 }
 170
 171 static void test_get_paths(void) {
 172         _cleanup_free_ char *a = NULL;
 173
 174         assert_se(cg_get_root_path(&a) >= 0);
 175         log_info("Root = %s", a);
 176 }
 177
 178 static void test_proc(void) {
 179         _cleanup_closedir_ DIR *d = NULL;
 180         struct dirent *de;
 181         int r;
 182
 183         d = opendir("/proc");
 184         assert_se(d);
 185
 186         FOREACH_DIRENT(de, d, break) {
 187                 _cleanup_free_ char *path = NULL, *path_shifted = NULL, *session = NULL, *unit = NULL, *user_unit = NULL, *machine = NULL, *slice = NULL;
 188                 pid_t pid;
 189                 uid_t uid = UID_INVALID;
 190
 191                 if (de->d_type != DT_DIR &&
 192                     de->d_type != DT_UNKNOWN)
 193                         continue;
 194
 195                 r = parse_pid(de->d_name, &pid);
 196                 if (r < 0)
 197                         continue;
 198
 199                 if (is_kernel_thread(pid))
 200                         continue;
 201
 202                 cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &path);
 203                 cg_pid_get_path_shifted(pid, NULL, &path_shifted);
 204                 cg_pid_get_owner_uid(pid, &uid);
 205                 cg_pid_get_session(pid, &session);
 206                 cg_pid_get_unit(pid, &unit);
 207                 cg_pid_get_user_unit(pid, &user_unit);
 208                 cg_pid_get_machine_name(pid, &machine);
 209                 cg_pid_get_slice(pid, &slice);
 210
 211                 printf(PID_FMT"\t%s\t%s\t"UID_FMT"\t%s\t%s\t%s\t%s\t%s\n",
 212                        pid,
 213                        path,
 214                        path_shifted,
 215                        uid,
 216                        session,
 217                        unit,
 218                        user_unit,
 219                        machine,
 220                        slice);
 221         }
 222 }
 223
 224 static void test_escape_one(const char *s, const char *r) {
 225         _cleanup_free_ char *b;
 226
 227         b = cg_escape(s);
 228         assert_se(b);
 229         assert_se(streq(b, r));
 230
 231         assert_se(streq(cg_unescape(b), s));
 232 }
 233
 234 static void test_escape(void) {
 235         test_escape_one("foobar", "foobar");
 236         test_escape_one(".foobar", "_.foobar");
 237         test_escape_one("foobar.service", "foobar.service");
 238         test_escape_one("cgroup.service", "_cgroup.service");
 239         test_escape_one("tasks", "_tasks");
 240         if (access("/sys/fs/cgroup/cpu", F_OK) == 0)
 241                 test_escape_one("cpu.service", "_cpu.service");
 242         test_escape_one("_foobar", "__foobar");
 243         test_escape_one("", "_");
 244         test_escape_one("_", "__");
 245         test_escape_one(".", "_.");
 246 }
 247
 248 static void test_controller_is_valid(void) {
 249         assert_se(cg_controller_is_valid("foobar"));
 250         assert_se(cg_controller_is_valid("foo_bar"));
 251         assert_se(cg_controller_is_valid("name=foo"));
 252         assert_se(!cg_controller_is_valid(""));
 253         assert_se(!cg_controller_is_valid("name="));
 254         assert_se(!cg_controller_is_valid("="));
 255         assert_se(!cg_controller_is_valid("cpu,cpuacct"));
 256         assert_se(!cg_controller_is_valid("_"));
 257         assert_se(!cg_controller_is_valid("_foobar"));
 258         assert_se(!cg_controller_is_valid("tatü"));
 259 }
 260
 261 static void test_slice_to_path_one(const char *unit, const char *path, int error) {
 262         _cleanup_free_ char *ret = NULL;
 263
 264         assert_se(cg_slice_to_path(unit, &ret) == error);
 265         assert_se(streq_ptr(ret, path));
 266 }
 267
 268 static void test_slice_to_path(void) {
 269
 270         test_slice_to_path_one("foobar.slice", "foobar.slice", 0);
 271         test_slice_to_path_one("foobar-waldo.slice", "foobar.slice/foobar-waldo.slice", 0);
 272         test_slice_to_path_one("foobar-waldo.service", NULL, -EINVAL);
 273         test_slice_to_path_one("-.slice", "", 0);
 274         test_slice_to_path_one("--.slice", NULL, -EINVAL);
 275         test_slice_to_path_one("-", NULL, -EINVAL);
 276         test_slice_to_path_one("-foo-.slice", NULL, -EINVAL);
 277         test_slice_to_path_one("-foo.slice", NULL, -EINVAL);
 278         test_slice_to_path_one("foo-.slice", NULL, -EINVAL);
 279         test_slice_to_path_one("foo--bar.slice", NULL, -EINVAL);
 280         test_slice_to_path_one("foo.slice/foo--bar.slice", NULL, -EINVAL);
 281         test_slice_to_path_one("a-b.slice", "a.slice/a-b.slice", 0);
 282         test_slice_to_path_one("a-b-c-d-e.slice", "a.slice/a-b.slice/a-b-c.slice/a-b-c-d.slice/a-b-c-d-e.slice", 0);
 283 }
 284
 285 static void test_shift_path_one(const char *raw, const char *root, const char *shifted) {
 286         const char *s = NULL;
 287
 288         assert_se(cg_shift_path(raw, root, &s) >= 0);
 289         assert_se(streq(s, shifted));
 290 }
 291
 292 static void test_shift_path(void) {
 293
 294         test_shift_path_one("/foobar/waldo", "/", "/foobar/waldo");
 295         test_shift_path_one("/foobar/waldo", "", "/foobar/waldo");
 296         test_shift_path_one("/foobar/waldo", "/foobar", "/waldo");
 297         test_shift_path_one("/foobar/waldo", "/fuckfuck", "/foobar/waldo");
 298 }
 299
 300 static void test_mask_supported(void) {
 301
 302         CGroupMask m;
 303         CGroupController c;
 304
 305         assert_se(cg_mask_supported(&m) >= 0);
 306
 307         for (c = 0; c < _CGROUP_CONTROLLER_MAX; c++)
 308                 printf("'%s' is supported: %s\n", cgroup_controller_to_string(c), yes_no(m & CGROUP_CONTROLLER_TO_MASK(c)));
 309 }
 310
 311 int main(void) {
 312         test_path_decode_unit();
 313         test_path_get_unit();
 314         test_path_get_user_unit();
 315         test_path_get_session();
 316         test_path_get_owner_uid();
 317         test_path_get_slice();
 318         test_path_get_user_slice();
 319         TEST_REQ_RUNNING_SYSTEMD(test_get_paths());
 320         test_proc();
 321         TEST_REQ_RUNNING_SYSTEMD(test_escape());
 322         test_controller_is_valid();
 323         test_slice_to_path();
 324         test_shift_path();
 325         TEST_REQ_RUNNING_SYSTEMD(test_mask_supported());
 326
 327         return 0;
 328 }