src/test/test-process-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5   Copyright 2013 Thomas H.P. Andersen
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <sched.h>
  22 #include <sys/mount.h>
  23 #include <sys/personality.h>
  24 #include <sys/prctl.h>
  25 #include <sys/stat.h>
  26 #include <sys/types.h>
  27 #include <sys/wait.h>
  28 #include <unistd.h>
  29 #ifdef HAVE_VALGRIND_VALGRIND_H
  30 #include <valgrind/valgrind.h>
  31 #endif
  32
  33 #include "alloc-util.h"
  34 #include "architecture.h"
  35 #include "fd-util.h"
  36 #include "log.h"
  37 #include "macro.h"
  38 #include "parse-util.h"
  39 #include "process-util.h"
  40 #include "stdio-util.h"
  41 #include "string-util.h"
  42 #include "terminal-util.h"
  43 #include "test-helper.h"
  44 #include "util.h"
  45 #include "virt.h"
  46
  47 static void test_get_process_comm(pid_t pid) {
  48         struct stat st;
  49         _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
  50         _cleanup_free_ char *env = NULL;
  51         char path[strlen("/proc//comm") + DECIMAL_STR_MAX(pid_t)];
  52         pid_t e;
  53         uid_t u;
  54         gid_t g;
  55         dev_t h;
  56         int r;
  57
  58         xsprintf(path, "/proc/"PID_FMT"/comm", pid);
  59
  60         if (stat(path, &st) == 0) {
  61                 assert_se(get_process_comm(pid, &a) >= 0);
  62                 log_info("PID"PID_FMT" comm: '%s'", pid, a);
  63         } else
  64                 log_warning("%s not exist.", path);
  65
  66         assert_se(get_process_cmdline(pid, 0, true, &c) >= 0);
  67         log_info("PID"PID_FMT" cmdline: '%s'", pid, c);
  68
  69         assert_se(get_process_cmdline(pid, 8, false, &d) >= 0);
  70         log_info("PID"PID_FMT" cmdline truncated to 8: '%s'", pid, d);
  71
  72         free(d);
  73         assert_se(get_process_cmdline(pid, 1, false, &d) >= 0);
  74         log_info("PID"PID_FMT" cmdline truncated to 1: '%s'", pid, d);
  75
  76         assert_se(get_process_ppid(pid, &e) >= 0);
  77         log_info("PID"PID_FMT" PPID: "PID_FMT, pid, e);
  78         assert_se(pid == 1 ? e == 0 : e > 0);
  79
  80         assert_se(is_kernel_thread(pid) == 0 || pid != 1);
  81
  82         r = get_process_exe(pid, &f);
  83         assert_se(r >= 0 || r == -EACCES);
  84         log_info("PID"PID_FMT" exe: '%s'", pid, strna(f));
  85
  86         assert_se(get_process_uid(pid, &u) == 0);
  87         log_info("PID"PID_FMT" UID: "UID_FMT, pid, u);
  88         assert_se(u == 0 || pid != 1);
  89
  90         assert_se(get_process_gid(pid, &g) == 0);
  91         log_info("PID"PID_FMT" GID: "GID_FMT, pid, g);
  92         assert_se(g == 0 || pid != 1);
  93
  94         r = get_process_environ(pid, &env);
  95         assert_se(r >= 0 || r == -EACCES);
  96         log_info("PID"PID_FMT" strlen(environ): %zi", pid, env ? (ssize_t)strlen(env) : (ssize_t)-errno);
  97
  98         if (!detect_container())
  99                 assert_se(get_ctty_devnr(pid, &h) == -ENXIO || pid != 1);
 100
 101         getenv_for_pid(pid, "PATH", &i);
 102         log_info("PID"PID_FMT" $PATH: '%s'", pid, strna(i));
 103 }
 104
 105 static void test_pid_is_unwaited(void) {
 106         pid_t pid;
 107
 108         pid = fork();
 109         assert_se(pid >= 0);
 110         if (pid == 0) {
 111                 _exit(EXIT_SUCCESS);
 112         } else {
 113                 int status;
 114
 115                 waitpid(pid, &status, 0);
 116                 assert_se(!pid_is_unwaited(pid));
 117         }
 118         assert_se(pid_is_unwaited(getpid()));
 119         assert_se(!pid_is_unwaited(-1));
 120 }
 121
 122 static void test_pid_is_alive(void) {
 123         pid_t pid;
 124
 125         pid = fork();
 126         assert_se(pid >= 0);
 127         if (pid == 0) {
 128                 _exit(EXIT_SUCCESS);
 129         } else {
 130                 int status;
 131
 132                 waitpid(pid, &status, 0);
 133                 assert_se(!pid_is_alive(pid));
 134         }
 135         assert_se(pid_is_alive(getpid()));
 136         assert_se(!pid_is_alive(-1));
 137 }
 138
 139 static void test_personality(void) {
 140
 141         assert_se(personality_to_string(PER_LINUX));
 142         assert_se(!personality_to_string(PERSONALITY_INVALID));
 143
 144         assert_se(streq(personality_to_string(PER_LINUX), architecture_to_string(native_architecture())));
 145
 146         assert_se(personality_from_string(personality_to_string(PER_LINUX)) == PER_LINUX);
 147         assert_se(personality_from_string(architecture_to_string(native_architecture())) == PER_LINUX);
 148
 149 #ifdef __x86_64__
 150         assert_se(streq_ptr(personality_to_string(PER_LINUX), "x86-64"));
 151         assert_se(streq_ptr(personality_to_string(PER_LINUX32), "x86"));
 152
 153         assert_se(personality_from_string("x86-64") == PER_LINUX);
 154         assert_se(personality_from_string("x86") == PER_LINUX32);
 155         assert_se(personality_from_string("ia64") == PERSONALITY_INVALID);
 156         assert_se(personality_from_string(NULL) == PERSONALITY_INVALID);
 157
 158         assert_se(personality_from_string(personality_to_string(PER_LINUX32)) == PER_LINUX32);
 159 #endif
 160 }
 161
 162 static void test_get_process_cmdline_harder(void) {
 163         char path[] = "/tmp/test-cmdlineXXXXXX";
 164         _cleanup_close_ int fd = -1;
 165         _cleanup_free_ char *line = NULL;
 166         pid_t pid;
 167
 168         if (geteuid() != 0)
 169                 return;
 170
 171 #ifdef HAVE_VALGRIND_VALGRIND_H
 172         /* valgrind patches open(/proc//cmdline)
 173          * so, test_get_process_cmdline_harder fails always
 174          * See https://github.com/systemd/systemd/pull/3555#issuecomment-226564908 */
 175         if (RUNNING_ON_VALGRIND)
 176                 return;
 177 #endif
 178
 179         pid = fork();
 180         if (pid > 0) {
 181                 siginfo_t si;
 182
 183                 (void) wait_for_terminate(pid, &si);
 184
 185                 assert_se(si.si_code == CLD_EXITED);
 186                 assert_se(si.si_status == 0);
 187
 188                 return;
 189         }
 190
 191         assert_se(pid == 0);
 192         assert_se(unshare(CLONE_NEWNS) >= 0);
 193
 194         fd = mkostemp(path, O_CLOEXEC);
 195         assert_se(fd >= 0);
 196
 197         if (mount(path, "/proc/self/cmdline", "bind", MS_BIND, NULL) < 0) {
 198                 /* This happens under selinux… Abort the test in this case. */
 199                 log_warning_errno(errno, "mount(..., \"/proc/self/cmdline\", \"bind\", ...) failed: %m");
 200                 assert(errno == EACCES);
 201                 return;
 202         }
 203
 204         assert_se(unlink(path) >= 0);
 205
 206         assert_se(prctl(PR_SET_NAME, "testa") >= 0);
 207
 208         assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);
 209
 210         assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
 211         assert_se(streq(line, "[testa]"));
 212         line = mfree(line);
 213
 214         assert_se(get_process_cmdline(getpid(), 1, true, &line) >= 0);
 215         assert_se(streq(line, ""));
 216         line = mfree(line);
 217
 218         assert_se(get_process_cmdline(getpid(), 2, true, &line) >= 0);
 219         assert_se(streq(line, "["));
 220         line = mfree(line);
 221
 222         assert_se(get_process_cmdline(getpid(), 3, true, &line) >= 0);
 223         assert_se(streq(line, "[."));
 224         line = mfree(line);
 225
 226         assert_se(get_process_cmdline(getpid(), 4, true, &line) >= 0);
 227         assert_se(streq(line, "[.."));
 228         line = mfree(line);
 229
 230         assert_se(get_process_cmdline(getpid(), 5, true, &line) >= 0);
 231         assert_se(streq(line, "[..."));
 232         line = mfree(line);
 233
 234         assert_se(get_process_cmdline(getpid(), 6, true, &line) >= 0);
 235         assert_se(streq(line, "[...]"));
 236         line = mfree(line);
 237
 238         assert_se(get_process_cmdline(getpid(), 7, true, &line) >= 0);
 239         assert_se(streq(line, "[t...]"));
 240         line = mfree(line);
 241
 242         assert_se(get_process_cmdline(getpid(), 8, true, &line) >= 0);
 243         assert_se(streq(line, "[testa]"));
 244         line = mfree(line);
 245
 246         assert_se(write(fd, "\0\0\0\0\0\0\0\0\0", 10) == 10);
 247
 248         assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);
 249
 250         assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
 251         assert_se(streq(line, "[testa]"));
 252         line = mfree(line);
 253
 254         assert_se(write(fd, "foo\0bar\0\0\0\0\0", 10) == 10);
 255
 256         assert_se(get_process_cmdline(getpid(), 0, false, &line) >= 0);
 257         assert_se(streq(line, "foo bar"));
 258         line = mfree(line);
 259
 260         assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
 261         assert_se(streq(line, "foo bar"));
 262         line = mfree(line);
 263
 264         assert_se(write(fd, "quux", 4) == 4);
 265         assert_se(get_process_cmdline(getpid(), 0, false, &line) >= 0);
 266         assert_se(streq(line, "foo bar quux"));
 267         line = mfree(line);
 268
 269         assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
 270         assert_se(streq(line, "foo bar quux"));
 271         line = mfree(line);
 272
 273         assert_se(get_process_cmdline(getpid(), 1, true, &line) >= 0);
 274         assert_se(streq(line, ""));
 275         line = mfree(line);
 276
 277         assert_se(get_process_cmdline(getpid(), 2, true, &line) >= 0);
 278         assert_se(streq(line, "."));
 279         line = mfree(line);
 280
 281         assert_se(get_process_cmdline(getpid(), 3, true, &line) >= 0);
 282         assert_se(streq(line, ".."));
 283         line = mfree(line);
 284
 285         assert_se(get_process_cmdline(getpid(), 4, true, &line) >= 0);
 286         assert_se(streq(line, "..."));
 287         line = mfree(line);
 288
 289         assert_se(get_process_cmdline(getpid(), 5, true, &line) >= 0);
 290         assert_se(streq(line, "f..."));
 291         line = mfree(line);
 292
 293         assert_se(get_process_cmdline(getpid(), 6, true, &line) >= 0);
 294         assert_se(streq(line, "fo..."));
 295         line = mfree(line);
 296
 297         assert_se(get_process_cmdline(getpid(), 7, true, &line) >= 0);
 298         assert_se(streq(line, "foo..."));
 299         line = mfree(line);
 300
 301         assert_se(get_process_cmdline(getpid(), 8, true, &line) >= 0);
 302         assert_se(streq(line, "foo..."));
 303         line = mfree(line);
 304
 305         assert_se(get_process_cmdline(getpid(), 9, true, &line) >= 0);
 306         assert_se(streq(line, "foo b..."));
 307         line = mfree(line);
 308
 309         assert_se(get_process_cmdline(getpid(), 10, true, &line) >= 0);
 310         assert_se(streq(line, "foo ba..."));
 311         line = mfree(line);
 312
 313         assert_se(get_process_cmdline(getpid(), 11, true, &line) >= 0);
 314         assert_se(streq(line, "foo bar..."));
 315         line = mfree(line);
 316
 317         assert_se(get_process_cmdline(getpid(), 12, true, &line) >= 0);
 318         assert_se(streq(line, "foo bar..."));
 319         line = mfree(line);
 320
 321         assert_se(get_process_cmdline(getpid(), 13, true, &line) >= 0);
 322         assert_se(streq(line, "foo bar quux"));
 323         line = mfree(line);
 324
 325         assert_se(get_process_cmdline(getpid(), 14, true, &line) >= 0);
 326         assert_se(streq(line, "foo bar quux"));
 327         line = mfree(line);
 328
 329         assert_se(get_process_cmdline(getpid(), 1000, true, &line) >= 0);
 330         assert_se(streq(line, "foo bar quux"));
 331         line = mfree(line);
 332
 333         assert_se(ftruncate(fd, 0) >= 0);
 334         assert_se(prctl(PR_SET_NAME, "aaaa bbbb cccc") >= 0);
 335
 336         assert_se(get_process_cmdline(getpid(), 0, false, &line) == -ENOENT);
 337
 338         assert_se(get_process_cmdline(getpid(), 0, true, &line) >= 0);
 339         assert_se(streq(line, "[aaaa bbbb cccc]"));
 340         line = mfree(line);
 341
 342         assert_se(get_process_cmdline(getpid(), 10, true, &line) >= 0);
 343         assert_se(streq(line, "[aaaa...]"));
 344         line = mfree(line);
 345
 346         assert_se(get_process_cmdline(getpid(), 11, true, &line) >= 0);
 347         assert_se(streq(line, "[aaaa...]"));
 348         line = mfree(line);
 349
 350         assert_se(get_process_cmdline(getpid(), 12, true, &line) >= 0);
 351         assert_se(streq(line, "[aaaa b...]"));
 352         line = mfree(line);
 353
 354         safe_close(fd);
 355         _exit(0);
 356 }
 357
 358 static void test_rename_process_one(const char *p, int ret) {
 359         _cleanup_free_ char *comm = NULL, *cmdline = NULL;
 360         pid_t pid;
 361         int r;
 362
 363         pid = fork();
 364         assert_se(pid >= 0);
 365
 366         if (pid > 0) {
 367                 siginfo_t si;
 368
 369                 assert_se(wait_for_terminate(pid, &si) >= 0);
 370                 assert_se(si.si_code == CLD_EXITED);
 371                 assert_se(si.si_status == EXIT_SUCCESS);
 372
 373                 return;
 374         }
 375
 376         /* child */
 377         r = rename_process(p);
 378
 379         assert_se(r == ret ||
 380                   (ret == 0 && r >= 0) ||
 381                   (ret > 0 && r > 0));
 382
 383         if (r < 0)
 384                 goto finish;
 385
 386 #ifdef HAVE_VALGRIND_VALGRIND_H
 387         /* see above, valgrind is weird, we can't verify what we are doing here */
 388         if (RUNNING_ON_VALGRIND)
 389                 goto finish;
 390 #endif
 391
 392         assert_se(get_process_comm(0, &comm) >= 0);
 393         log_info("comm = <%s>", comm);
 394         assert_se(strneq(comm, p, 15));
 395
 396         assert_se(get_process_cmdline(0, 0, false, &cmdline) >= 0);
 397         log_info("cmdline = <%s>", cmdline);
 398         assert_se(strneq(p, cmdline, strlen("test-process-util")));
 399         assert_se(startswith(p, cmdline));
 400
 401 finish:
 402         _exit(EXIT_SUCCESS);
 403 }
 404
 405 static void test_rename_process(void) {
 406         test_rename_process_one(NULL, -EINVAL);
 407         test_rename_process_one("", -EINVAL);
 408         test_rename_process_one("foo", 1); /* should always fit */
 409         test_rename_process_one("this is a really really long process name, followed by some more words", 0); /* unlikely to fit */
 410         test_rename_process_one("1234567", 1); /* should always fit */
 411 }
 412
 413 static void test_getpid_cached(void) {
 414         siginfo_t si;
 415         pid_t a, b, c, d, e, f, child;
 416
 417         a = raw_getpid();
 418         b = getpid_cached();
 419         c = getpid();
 420
 421         assert_se(a == b && a == c);
 422
 423         child = fork();
 424         assert_se(child >= 0);
 425
 426         if (child == 0) {
 427                 /* In child */
 428                 a = raw_getpid();
 429                 b = getpid_cached();
 430                 c = getpid();
 431
 432                 assert_se(a == b && a == c);
 433                 _exit(0);
 434         }
 435
 436         d = raw_getpid();
 437         e = getpid_cached();
 438         f = getpid();
 439
 440         assert_se(a == d && a == e && a == f);
 441
 442         assert_se(wait_for_terminate(child, &si) >= 0);
 443         assert_se(si.si_status == 0);
 444         assert_se(si.si_code == CLD_EXITED);
 445 }
 446
 447 #define MEASURE_ITERATIONS (10000000LLU)
 448
 449 static void test_getpid_measure(void) {
 450         unsigned long long i;
 451         usec_t t, q;
 452
 453         t = now(CLOCK_MONOTONIC);
 454         for (i = 0; i < MEASURE_ITERATIONS; i++)
 455                 (void) getpid();
 456         q = now(CLOCK_MONOTONIC) - t;
 457
 458         log_info(" glibc getpid(): %llu/s\n", (unsigned long long) (MEASURE_ITERATIONS*USEC_PER_SEC/q));
 459
 460         t = now(CLOCK_MONOTONIC);
 461         for (i = 0; i < MEASURE_ITERATIONS; i++)
 462                 (void) getpid_cached();
 463         q = now(CLOCK_MONOTONIC) - t;
 464
 465         log_info("getpid_cached(): %llu/s\n", (unsigned long long) (MEASURE_ITERATIONS*USEC_PER_SEC/q));
 466 }
 467
 468 int main(int argc, char *argv[]) {
 469
 470         log_set_max_level(LOG_DEBUG);
 471         log_parse_environment();
 472         log_open();
 473
 474         saved_argc = argc;
 475         saved_argv = argv;
 476
 477         if (argc > 1) {
 478                 pid_t pid = 0;
 479
 480                 (void) parse_pid(argv[1], &pid);
 481                 test_get_process_comm(pid);
 482         } else {
 483                 TEST_REQ_RUNNING_SYSTEMD(test_get_process_comm(1));
 484                 test_get_process_comm(getpid());
 485         }
 486
 487         test_pid_is_unwaited();
 488         test_pid_is_alive();
 489         test_personality();
 490         test_get_process_cmdline_harder();
 491         test_rename_process();
 492         test_getpid_cached();
 493         test_getpid_measure();
 494
 495         return 0;
 496 }