src/basic/process-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6 ***/
   7
   8 #include <ctype.h>
   9 #include <errno.h>
  10 #include <limits.h>
  11 #include <linux/oom.h>
  12 #include <sched.h>
  13 #include <signal.h>
  14 #include <stdbool.h>
  15 #include <stdio.h>
  16 #include <stdio_ext.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <sys/mman.h>
  20 //#include <sys/mount.h>
  21 #include <sys/personality.h>
  22 #include <sys/prctl.h>
  23 #include <sys/types.h>
  24 #include <sys/wait.h>
  25 #include <syslog.h>
  26 #include <unistd.h>
  27 #if HAVE_VALGRIND_VALGRIND_H
  28 #include <valgrind/valgrind.h>
  29 #endif
  30
  31 #include "alloc-util.h"
  32 //#include "architecture.h"
  33 #include "escape.h"
  34 #include "fd-util.h"
  35 #include "fileio.h"
  36 #include "fs-util.h"
  37 //#include "ioprio.h"
  38 #include "log.h"
  39 #include "macro.h"
  40 #include "missing.h"
  41 #include "process-util.h"
  42 #include "raw-clone.h"
  43 #include "signal-util.h"
  44 //#include "stat-util.h"
  45 #include "string-table.h"
  46 #include "string-util.h"
  47 //#include "terminal-util.h"
  48 #include "user-util.h"
  49 #include "util.h"
  50
  51 int get_process_state(pid_t pid) {
  52         const char *p;
  53         char state;
  54         int r;
  55         _cleanup_free_ char *line = NULL;
  56
  57         assert(pid >= 0);
  58
  59         p = procfs_file_alloca(pid, "stat");
  60
  61         r = read_one_line_file(p, &line);
  62         if (r == -ENOENT)
  63                 return -ESRCH;
  64         if (r < 0)
  65                 return r;
  66
  67         p = strrchr(line, ')');
  68         if (!p)
  69                 return -EIO;
  70
  71         p++;
  72
  73         if (sscanf(p, " %c", &state) != 1)
  74                 return -EIO;
  75
  76         return (unsigned char) state;
  77 }
  78
  79 int get_process_comm(pid_t pid, char **ret) {
  80         _cleanup_free_ char *escaped = NULL, *comm = NULL;
  81         const char *p;
  82         int r;
  83
  84         assert(ret);
  85         assert(pid >= 0);
  86
  87         escaped = new(char, TASK_COMM_LEN);
  88         if (!escaped)
  89                 return -ENOMEM;
  90
  91         p = procfs_file_alloca(pid, "comm");
  92
  93         r = read_one_line_file(p, &comm);
  94         if (r == -ENOENT)
  95                 return -ESRCH;
  96         if (r < 0)
  97                 return r;
  98
  99         /* Escape unprintable characters, just in case, but don't grow the string beyond the underlying size */
 100         cellescape(escaped, TASK_COMM_LEN, comm);
 101
 102         *ret = TAKE_PTR(escaped);
 103         return 0;
 104 }
 105
 106 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
 107         _cleanup_fclose_ FILE *f = NULL;
 108         bool space = false;
 109         char *k, *ans = NULL;
 110         const char *p;
 111         int c;
 112
 113         assert(line);
 114         assert(pid >= 0);
 115
 116         /* Retrieves a process' command line. Replaces unprintable characters while doing so by whitespace (coalescing
 117          * multiple sequential ones into one). If max_length is != 0 will return a string of the specified size at most
 118          * (the trailing NUL byte does count towards the length here!), abbreviated with a "..." ellipsis. If
 119          * comm_fallback is true and the process has no command line set (the case for kernel threads), or has a
 120          * command line that resolves to the empty string will return the "comm" name of the process instead.
 121          *
 122          * Returns -ESRCH if the process doesn't exist, and -ENOENT if the process has no command line (and
 123          * comm_fallback is false). Returns 0 and sets *line otherwise. */
 124
 125         p = procfs_file_alloca(pid, "cmdline");
 126
 127         f = fopen(p, "re");
 128         if (!f) {
 129                 if (errno == ENOENT)
 130                         return -ESRCH;
 131                 return -errno;
 132         }
 133
 134         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 135
 136         if (max_length == 1) {
 137
 138                 /* If there's only room for one byte, return the empty string */
 139                 ans = new0(char, 1);
 140                 if (!ans)
 141                         return -ENOMEM;
 142
 143                 *line = ans;
 144                 return 0;
 145
 146         } else if (max_length == 0) {
 147                 size_t len = 0, allocated = 0;
 148
 149                 while ((c = getc(f)) != EOF) {
 150
 151                         if (!GREEDY_REALLOC(ans, allocated, len+3)) {
 152                                 free(ans);
 153                                 return -ENOMEM;
 154                         }
 155
 156                         if (isprint(c)) {
 157                                 if (space) {
 158                                         ans[len++] = ' ';
 159                                         space = false;
 160                                 }
 161
 162                                 ans[len++] = c;
 163                         } else if (len > 0)
 164                                 space = true;
 165                }
 166
 167                 if (len > 0)
 168                         ans[len] = '\0';
 169                 else
 170                         ans = mfree(ans);
 171
 172         } else {
 173                 bool dotdotdot = false;
 174                 size_t left;
 175
 176                 ans = new(char, max_length);
 177                 if (!ans)
 178                         return -ENOMEM;
 179
 180                 k = ans;
 181                 left = max_length;
 182                 while ((c = getc(f)) != EOF) {
 183
 184                         if (isprint(c)) {
 185
 186                                 if (space) {
 187                                         if (left <= 2) {
 188                                                 dotdotdot = true;
 189                                                 break;
 190                                         }
 191
 192                                         *(k++) = ' ';
 193                                         left--;
 194                                         space = false;
 195                                 }
 196
 197                                 if (left <= 1) {
 198                                         dotdotdot = true;
 199                                         break;
 200                                 }
 201
 202                                 *(k++) = (char) c;
 203                                 left--;
 204                         } else if (k > ans)
 205                                 space = true;
 206                 }
 207
 208                 if (dotdotdot) {
 209                         if (max_length <= 4) {
 210                                 k = ans;
 211                                 left = max_length;
 212                         } else {
 213                                 k = ans + max_length - 4;
 214                                 left = 4;
 215
 216                                 /* Eat up final spaces */
 217                                 while (k > ans && isspace(k[-1])) {
 218                                         k--;
 219                                         left++;
 220                                 }
 221                         }
 222
 223                         strncpy(k, "...", left-1);
 224                         k[left-1] = 0;
 225                 } else
 226                         *k = 0;
 227         }
 228
 229         /* Kernel threads have no argv[] */
 230         if (isempty(ans)) {
 231                 _cleanup_free_ char *t = NULL;
 232                 int h;
 233
 234                 free(ans);
 235
 236                 if (!comm_fallback)
 237                         return -ENOENT;
 238
 239                 h = get_process_comm(pid, &t);
 240                 if (h < 0)
 241                         return h;
 242
 243                 if (max_length == 0)
 244                         ans = strjoin("[", t, "]");
 245                 else {
 246                         size_t l;
 247
 248                         l = strlen(t);
 249
 250                         if (l + 3 <= max_length)
 251                                 ans = strjoin("[", t, "]");
 252                         else if (max_length <= 6) {
 253
 254                                 ans = new(char, max_length);
 255                                 if (!ans)
 256                                         return -ENOMEM;
 257
 258                                 memcpy(ans, "[...]", max_length-1);
 259                                 ans[max_length-1] = 0;
 260                         } else {
 261                                 char *e;
 262
 263                                 t[max_length - 6] = 0;
 264
 265                                 /* Chop off final spaces */
 266                                 e = strchr(t, 0);
 267                                 while (e > t && isspace(e[-1]))
 268                                         e--;
 269                                 *e = 0;
 270
 271                                 ans = strjoin("[", t, "...]");
 272                         }
 273                 }
 274                 if (!ans)
 275                         return -ENOMEM;
 276         }
 277
 278         *line = ans;
 279         return 0;
 280 }
 281
 282 int rename_process(const char name[]) {
 283         static size_t mm_size = 0;
 284         static char *mm = NULL;
 285         bool truncated = false;
 286         size_t l;
 287
 288         /* This is a like a poor man's setproctitle(). It changes the comm field, argv[0], and also the glibc's
 289          * internally used name of the process. For the first one a limit of 16 chars applies; to the second one in
 290          * many cases one of 10 (i.e. length of "/sbin/init") — however if we have CAP_SYS_RESOURCES it is unbounded;
 291          * to the third one 7 (i.e. the length of "systemd". If you pass a longer string it will likely be
 292          * truncated.
 293          *
 294          * Returns 0 if a name was set but truncated, > 0 if it was set but not truncated. */
 295
 296         if (isempty(name))
 297                 return -EINVAL; /* let's not confuse users unnecessarily with an empty name */
 298
 299         if (!is_main_thread())
 300                 return -EPERM; /* Let's not allow setting the process name from other threads than the main one, as we
 301                                 * cache things without locking, and we make assumptions that PR_SET_NAME sets the
 302                                 * process name that isn't correct on any other threads */
 303
 304         l = strlen(name);
 305
 306         /* First step, change the comm field. The main thread's comm is identical to the process comm. This means we
 307          * can use PR_SET_NAME, which sets the thread name for the calling thread. */
 308         if (prctl(PR_SET_NAME, name) < 0)
 309                 log_debug_errno(errno, "PR_SET_NAME failed: %m");
 310         if (l >= TASK_COMM_LEN) /* Linux process names can be 15 chars at max */
 311                 truncated = true;
 312
 313         /* Second step, change glibc's ID of the process name. */
 314         if (program_invocation_name) {
 315                 size_t k;
 316
 317                 k = strlen(program_invocation_name);
 318                 strncpy(program_invocation_name, name, k);
 319                 if (l > k)
 320                         truncated = true;
 321         }
 322
 323         /* Third step, completely replace the argv[] array the kernel maintains for us. This requires privileges, but
 324          * has the advantage that the argv[] array is exactly what we want it to be, and not filled up with zeros at
 325          * the end. This is the best option for changing /proc/self/cmdline. */
 326
 327         /* Let's not bother with this if we don't have euid == 0. Strictly speaking we should check for the
 328          * CAP_SYS_RESOURCE capability which is independent of the euid. In our own code the capability generally is
 329          * present only for euid == 0, hence let's use this as quick bypass check, to avoid calling mmap() if
 330          * PR_SET_MM_ARG_{START,END} fails with EPERM later on anyway. After all geteuid() is dead cheap to call, but
 331          * mmap() is not. */
 332         if (geteuid() != 0)
 333                 log_debug("Skipping PR_SET_MM, as we don't have privileges.");
 334         else if (mm_size < l+1) {
 335                 size_t nn_size;
 336                 char *nn;
 337
 338                 nn_size = PAGE_ALIGN(l+1);
 339                 nn = mmap(NULL, nn_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 340                 if (nn == MAP_FAILED) {
 341                         log_debug_errno(errno, "mmap() failed: %m");
 342                         goto use_saved_argv;
 343                 }
 344
 345                 strncpy(nn, name, nn_size);
 346
 347                 /* Now, let's tell the kernel about this new memory */
 348                 if (prctl(PR_SET_MM, PR_SET_MM_ARG_START, (unsigned long) nn, 0, 0) < 0) {
 349                         log_debug_errno(errno, "PR_SET_MM_ARG_START failed, proceeding without: %m");
 350                         (void) munmap(nn, nn_size);
 351                         goto use_saved_argv;
 352                 }
 353
 354                 /* And update the end pointer to the new end, too. If this fails, we don't really know what to do, it's
 355                  * pretty unlikely that we can rollback, hence we'll just accept the failure, and continue. */
 356                 if (prctl(PR_SET_MM, PR_SET_MM_ARG_END, (unsigned long) nn + l + 1, 0, 0) < 0)
 357                         log_debug_errno(errno, "PR_SET_MM_ARG_END failed, proceeding without: %m");
 358
 359                 if (mm)
 360                         (void) munmap(mm, mm_size);
 361
 362                 mm = nn;
 363                 mm_size = nn_size;
 364         } else {
 365                 strncpy(mm, name, mm_size);
 366
 367                 /* Update the end pointer, continuing regardless of any failure. */
 368                 if (prctl(PR_SET_MM, PR_SET_MM_ARG_END, (unsigned long) mm + l + 1, 0, 0) < 0)
 369                         log_debug_errno(errno, "PR_SET_MM_ARG_END failed, proceeding without: %m");
 370         }
 371
 372 use_saved_argv:
 373         /* Fourth step: in all cases we'll also update the original argv[], so that our own code gets it right too if
 374          * it still looks here */
 375
 376         if (saved_argc > 0) {
 377                 int i;
 378
 379                 if (saved_argv[0]) {
 380                         size_t k;
 381
 382                         k = strlen(saved_argv[0]);
 383                         strncpy(saved_argv[0], name, k);
 384                         if (l > k)
 385                                 truncated = true;
 386                 }
 387
 388                 for (i = 1; i < saved_argc; i++) {
 389                         if (!saved_argv[i])
 390                                 break;
 391
 392                         memzero(saved_argv[i], strlen(saved_argv[i]));
 393                 }
 394         }
 395
 396         return !truncated;
 397 }
 398
 399 int is_kernel_thread(pid_t pid) {
 400         _cleanup_free_ char *line = NULL;
 401         unsigned long long flags;
 402         size_t l, i;
 403         const char *p;
 404         char *q;
 405         int r;
 406
 407         if (IN_SET(pid, 0, 1) || pid == getpid_cached()) /* pid 1, and we ourselves certainly aren't a kernel thread */
 408                 return 0;
 409         if (!pid_is_valid(pid))
 410                 return -EINVAL;
 411
 412         p = procfs_file_alloca(pid, "stat");
 413         r = read_one_line_file(p, &line);
 414         if (r == -ENOENT)
 415                 return -ESRCH;
 416         if (r < 0)
 417                 return r;
 418
 419         /* Skip past the comm field */
 420         q = strrchr(line, ')');
 421         if (!q)
 422                 return -EINVAL;
 423         q++;
 424
 425         /* Skip 6 fields to reach the flags field */
 426         for (i = 0; i < 6; i++) {
 427                 l = strspn(q, WHITESPACE);
 428                 if (l < 1)
 429                         return -EINVAL;
 430                 q += l;
 431
 432                 l = strcspn(q, WHITESPACE);
 433                 if (l < 1)
 434                         return -EINVAL;
 435                 q += l;
 436         }
 437
 438         /* Skip preceeding whitespace */
 439         l = strspn(q, WHITESPACE);
 440         if (l < 1)
 441                 return -EINVAL;
 442         q += l;
 443
 444         /* Truncate the rest */
 445         l = strcspn(q, WHITESPACE);
 446         if (l < 1)
 447                 return -EINVAL;
 448         q[l] = 0;
 449
 450         r = safe_atollu(q, &flags);
 451         if (r < 0)
 452                 return r;
 453
 454         return !!(flags & PF_KTHREAD);
 455 }
 456
 457 #if 0 /// UNNEEDED by elogind
 458 int get_process_capeff(pid_t pid, char **capeff) {
 459         const char *p;
 460         int r;
 461
 462         assert(capeff);
 463         assert(pid >= 0);
 464
 465         p = procfs_file_alloca(pid, "status");
 466
 467         r = get_proc_field(p, "CapEff", WHITESPACE, capeff);
 468         if (r == -ENOENT)
 469                 return -ESRCH;
 470
 471         return r;
 472 }
 473 #endif // 0
 474
 475 static int get_process_link_contents(const char *proc_file, char **name) {
 476         int r;
 477
 478         assert(proc_file);
 479         assert(name);
 480
 481         r = readlink_malloc(proc_file, name);
 482         if (r == -ENOENT)
 483                 return -ESRCH;
 484         if (r < 0)
 485                 return r;
 486
 487         return 0;
 488 }
 489
 490 int get_process_exe(pid_t pid, char **name) {
 491         const char *p;
 492         char *d;
 493         int r;
 494
 495         assert(pid >= 0);
 496
 497         p = procfs_file_alloca(pid, "exe");
 498         r = get_process_link_contents(p, name);
 499         if (r < 0)
 500                 return r;
 501
 502         d = endswith(*name, " (deleted)");
 503         if (d)
 504                 *d = '\0';
 505
 506         return 0;
 507 }
 508
 509 #if 0 /// UNNEEDED by elogind
 510 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
 511         _cleanup_fclose_ FILE *f = NULL;
 512         char line[LINE_MAX];
 513         const char *p;
 514
 515         assert(field);
 516         assert(uid);
 517
 518         if (pid < 0)
 519                 return -EINVAL;
 520
 521         p = procfs_file_alloca(pid, "status");
 522         f = fopen(p, "re");
 523         if (!f) {
 524                 if (errno == ENOENT)
 525                         return -ESRCH;
 526                 return -errno;
 527         }
 528
 529         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 530
 531         FOREACH_LINE(line, f, return -errno) {
 532                 char *l;
 533
 534                 l = strstrip(line);
 535
 536                 if (startswith(l, field)) {
 537                         l += strlen(field);
 538                         l += strspn(l, WHITESPACE);
 539
 540                         l[strcspn(l, WHITESPACE)] = 0;
 541
 542                         return parse_uid(l, uid);
 543                 }
 544         }
 545
 546         return -EIO;
 547 }
 548
 549 int get_process_uid(pid_t pid, uid_t *uid) {
 550
 551         if (pid == 0 || pid == getpid_cached()) {
 552                 *uid = getuid();
 553                 return 0;
 554         }
 555
 556         return get_process_id(pid, "Uid:", uid);
 557 }
 558
 559 int get_process_gid(pid_t pid, gid_t *gid) {
 560
 561         if (pid == 0 || pid == getpid_cached()) {
 562                 *gid = getgid();
 563                 return 0;
 564         }
 565
 566         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 567         return get_process_id(pid, "Gid:", gid);
 568 }
 569
 570 int get_process_cwd(pid_t pid, char **cwd) {
 571         const char *p;
 572
 573         assert(pid >= 0);
 574
 575         p = procfs_file_alloca(pid, "cwd");
 576
 577         return get_process_link_contents(p, cwd);
 578 }
 579
 580 int get_process_root(pid_t pid, char **root) {
 581         const char *p;
 582
 583         assert(pid >= 0);
 584
 585         p = procfs_file_alloca(pid, "root");
 586
 587         return get_process_link_contents(p, root);
 588 }
 589
 590 int get_process_environ(pid_t pid, char **env) {
 591         _cleanup_fclose_ FILE *f = NULL;
 592         _cleanup_free_ char *outcome = NULL;
 593         int c;
 594         const char *p;
 595         size_t allocated = 0, sz = 0;
 596
 597         assert(pid >= 0);
 598         assert(env);
 599
 600         p = procfs_file_alloca(pid, "environ");
 601
 602         f = fopen(p, "re");
 603         if (!f) {
 604                 if (errno == ENOENT)
 605                         return -ESRCH;
 606                 return -errno;
 607         }
 608
 609         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 610
 611         while ((c = fgetc(f)) != EOF) {
 612                 if (!GREEDY_REALLOC(outcome, allocated, sz + 5))
 613                         return -ENOMEM;
 614
 615                 if (c == '\0')
 616                         outcome[sz++] = '\n';
 617                 else
 618                         sz += cescape_char(c, outcome + sz);
 619         }
 620
 621         if (!outcome) {
 622                 outcome = strdup("");
 623                 if (!outcome)
 624                         return -ENOMEM;
 625         } else
 626                 outcome[sz] = '\0';
 627
 628         *env = TAKE_PTR(outcome);
 629
 630         return 0;
 631 }
 632
 633 int get_process_ppid(pid_t pid, pid_t *_ppid) {
 634         int r;
 635         _cleanup_free_ char *line = NULL;
 636         long unsigned ppid;
 637         const char *p;
 638
 639         assert(pid >= 0);
 640         assert(_ppid);
 641
 642         if (pid == 0 || pid == getpid_cached()) {
 643                 *_ppid = getppid();
 644                 return 0;
 645         }
 646
 647         p = procfs_file_alloca(pid, "stat");
 648         r = read_one_line_file(p, &line);
 649         if (r == -ENOENT)
 650                 return -ESRCH;
 651         if (r < 0)
 652                 return r;
 653
 654         /* Let's skip the pid and comm fields. The latter is enclosed
 655          * in () but does not escape any () in its value, so let's
 656          * skip over it manually */
 657
 658         p = strrchr(line, ')');
 659         if (!p)
 660                 return -EIO;
 661
 662         p++;
 663
 664         if (sscanf(p, " "
 665                    "%*c "  /* state */
 666                    "%lu ", /* ppid */
 667                    &ppid) != 1)
 668                 return -EIO;
 669
 670         if ((long unsigned) (pid_t) ppid != ppid)
 671                 return -ERANGE;
 672
 673         *_ppid = (pid_t) ppid;
 674
 675         return 0;
 676 }
 677 #endif // 0
 678
 679 int wait_for_terminate(pid_t pid, siginfo_t *status) {
 680         siginfo_t dummy;
 681
 682         assert(pid >= 1);
 683
 684         if (!status)
 685                 status = &dummy;
 686
 687         for (;;) {
 688                 zero(*status);
 689
 690                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
 691
 692                         if (errno == EINTR)
 693                                 continue;
 694
 695                         return negative_errno();
 696                 }
 697
 698                 return 0;
 699         }
 700 }
 701
 702 /*
 703  * Return values:
 704  * < 0 : wait_for_terminate() failed to get the state of the
 705  *       process, the process was terminated by a signal, or
 706  *       failed for an unknown reason.
 707  * >=0 : The process terminated normally, and its exit code is
 708  *       returned.
 709  *
 710  * That is, success is indicated by a return value of zero, and an
 711  * error is indicated by a non-zero value.
 712  *
 713  * A warning is emitted if the process terminates abnormally,
 714  * and also if it returns non-zero unless check_exit_code is true.
 715  */
 716 int wait_for_terminate_and_check(const char *name, pid_t pid, WaitFlags flags) {
 717         _cleanup_free_ char *buffer = NULL;
 718         siginfo_t status;
 719         int r, prio;
 720
 721         assert(pid > 1);
 722
 723         if (!name) {
 724                 r = get_process_comm(pid, &buffer);
 725                 if (r < 0)
 726                         log_debug_errno(r, "Failed to acquire process name of " PID_FMT ", ignoring: %m", pid);
 727                 else
 728                         name = buffer;
 729         }
 730
 731         prio = flags & WAIT_LOG_ABNORMAL ? LOG_ERR : LOG_DEBUG;
 732
 733         r = wait_for_terminate(pid, &status);
 734         if (r < 0)
 735                 return log_full_errno(prio, r, "Failed to wait for %s: %m", strna(name));
 736
 737         if (status.si_code == CLD_EXITED) {
 738                 if (status.si_status != EXIT_SUCCESS)
 739                         log_full(flags & WAIT_LOG_NON_ZERO_EXIT_STATUS ? LOG_ERR : LOG_DEBUG,
 740                                  "%s failed with exit status %i.", strna(name), status.si_status);
 741                 else
 742                         log_debug("%s succeeded.", name);
 743
 744                 return status.si_status;
 745
 746         } else if (IN_SET(status.si_code, CLD_KILLED, CLD_DUMPED)) {
 747
 748                 log_full(prio, "%s terminated by signal %s.", strna(name), signal_to_string(status.si_status));
 749                 return -EPROTO;
 750         }
 751
 752         log_full(prio, "%s failed due to unknown reason.", strna(name));
 753         return -EPROTO;
 754 }
 755
 756 /*
 757  * Return values:
 758  *
 759  * < 0 : wait_for_terminate_with_timeout() failed to get the state of the process, the process timed out, the process
 760  *       was terminated by a signal, or failed for an unknown reason.
 761  *
 762  * >=0 : The process terminated normally with no failures.
 763  *
 764  * Success is indicated by a return value of zero, a timeout is indicated by ETIMEDOUT, and all other child failure
 765  * states are indicated by error is indicated by a non-zero value.
 766  *
 767  * This call assumes SIGCHLD has been blocked already, in particular before the child to wait for has been forked off
 768  * to remain entirely race-free.
 769  */
 770 int wait_for_terminate_with_timeout(pid_t pid, usec_t timeout) {
 771         sigset_t mask;
 772         int r;
 773         usec_t until;
 774
 775         assert_se(sigemptyset(&mask) == 0);
 776         assert_se(sigaddset(&mask, SIGCHLD) == 0);
 777
 778         /* Drop into a sigtimewait-based timeout. Waiting for the
 779          * pid to exit. */
 780         until = now(CLOCK_MONOTONIC) + timeout;
 781         for (;;) {
 782                 usec_t n;
 783                 siginfo_t status = {};
 784                 struct timespec ts;
 785
 786                 n = now(CLOCK_MONOTONIC);
 787                 if (n >= until)
 788                         break;
 789
 790                 r = sigtimedwait(&mask, NULL, timespec_store(&ts, until - n)) < 0 ? -errno : 0;
 791                 /* Assuming we woke due to the child exiting. */
 792                 if (waitid(P_PID, pid, &status, WEXITED|WNOHANG) == 0) {
 793                         if (status.si_pid == pid) {
 794                                 /* This is the correct child.*/
 795                                 if (status.si_code == CLD_EXITED)
 796                                         return (status.si_status == 0) ? 0 : -EPROTO;
 797                                 else
 798                                         return -EPROTO;
 799                         }
 800                 }
 801                 /* Not the child, check for errors and proceed appropriately */
 802                 if (r < 0) {
 803                         switch (r) {
 804                         case -EAGAIN:
 805                                 /* Timed out, child is likely hung. */
 806                                 return -ETIMEDOUT;
 807                         case -EINTR:
 808                                 /* Received a different signal and should retry */
 809                                 continue;
 810                         default:
 811                                 /* Return any unexpected errors */
 812                                 return r;
 813                         }
 814                 }
 815         }
 816
 817         return -EPROTO;
 818 }
 819
 820 #if 0 /// UNNEEDED by elogind
 821 void sigkill_wait(pid_t pid) {
 822         assert(pid > 1);
 823
 824         if (kill(pid, SIGKILL) > 0)
 825                 (void) wait_for_terminate(pid, NULL);
 826 }
 827
 828 void sigkill_waitp(pid_t *pid) {
 829         PROTECT_ERRNO;
 830
 831         if (!pid)
 832                 return;
 833         if (*pid <= 1)
 834                 return;
 835
 836         sigkill_wait(*pid);
 837 }
 838 #endif // 0
 839
 840 void sigterm_wait(pid_t pid) {
 841         assert(pid > 1);
 842
 843         if (kill_and_sigcont(pid, SIGTERM) > 0)
 844                 (void) wait_for_terminate(pid, NULL);
 845 }
 846
 847 int kill_and_sigcont(pid_t pid, int sig) {
 848         int r;
 849
 850         r = kill(pid, sig) < 0 ? -errno : 0;
 851
 852         /* If this worked, also send SIGCONT, unless we already just sent a SIGCONT, or SIGKILL was sent which isn't
 853          * affected by a process being suspended anyway. */
 854         if (r >= 0 && !IN_SET(sig, SIGCONT, SIGKILL))
 855                 (void) kill(pid, SIGCONT);
 856
 857         return r;
 858 }
 859
 860 int getenv_for_pid(pid_t pid, const char *field, char **ret) {
 861         _cleanup_fclose_ FILE *f = NULL;
 862         char *value = NULL;
 863         bool done = false;
 864         const char *path;
 865         size_t l;
 866
 867         assert(pid >= 0);
 868         assert(field);
 869         assert(ret);
 870
 871         if (pid == 0 || pid == getpid_cached()) {
 872                 const char *e;
 873
 874                 e = getenv(field);
 875                 if (!e) {
 876                         *ret = NULL;
 877                         return 0;
 878                 }
 879
 880                 value = strdup(e);
 881                 if (!value)
 882                         return -ENOMEM;
 883
 884                 *ret = value;
 885                 return 1;
 886         }
 887
 888         path = procfs_file_alloca(pid, "environ");
 889
 890         f = fopen(path, "re");
 891         if (!f) {
 892                 if (errno == ENOENT)
 893                         return -ESRCH;
 894
 895                 return -errno;
 896         }
 897
 898         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 899
 900         l = strlen(field);
 901
 902         do {
 903                 char line[LINE_MAX];
 904                 size_t i;
 905
 906                 for (i = 0; i < sizeof(line)-1; i++) {
 907                         int c;
 908
 909                         c = getc(f);
 910                         if (_unlikely_(c == EOF)) {
 911                                 done = true;
 912                                 break;
 913                         } else if (c == 0)
 914                                 break;
 915
 916                         line[i] = c;
 917                 }
 918                 line[i] = 0;
 919
 920                 if (strneq(line, field, l) && line[l] == '=') {
 921                         value = strdup(line + l + 1);
 922                         if (!value)
 923                                 return -ENOMEM;
 924
 925                         *ret = value;
 926                         return 1;
 927                 }
 928
 929         } while (!done);
 930
 931         *ret = NULL;
 932         return 0;
 933 }
 934
 935 bool pid_is_unwaited(pid_t pid) {
 936         /* Checks whether a PID is still valid at all, including a zombie */
 937
 938         if (pid < 0)
 939                 return false;
 940
 941         if (pid <= 1) /* If we or PID 1 would be dead and have been waited for, this code would not be running */
 942                 return true;
 943
 944         if (pid == getpid_cached())
 945                 return true;
 946
 947         if (kill(pid, 0) >= 0)
 948                 return true;
 949
 950         return errno != ESRCH;
 951 }
 952
 953 bool pid_is_alive(pid_t pid) {
 954         int r;
 955
 956         /* Checks whether a PID is still valid and not a zombie */
 957
 958         if (pid < 0)
 959                 return false;
 960
 961         if (pid <= 1) /* If we or PID 1 would be a zombie, this code would not be running */
 962                 return true;
 963
 964         if (pid == getpid_cached())
 965                 return true;
 966
 967         r = get_process_state(pid);
 968         if (IN_SET(r, -ESRCH, 'Z'))
 969                 return false;
 970
 971         return true;
 972 }
 973
 974 #if 0 /// UNNEEDED by elogind
 975 int pid_from_same_root_fs(pid_t pid) {
 976         const char *root;
 977
 978         if (pid < 0)
 979                 return false;
 980
 981         if (pid == 0 || pid == getpid_cached())
 982                 return true;
 983
 984         root = procfs_file_alloca(pid, "root");
 985
 986         return files_same(root, "/proc/1/root", 0);
 987 }
 988 #endif // 0
 989
 990 bool is_main_thread(void) {
 991         static thread_local int cached = 0;
 992
 993         if (_unlikely_(cached == 0))
 994                 cached = getpid_cached() == gettid() ? 1 : -1;
 995
 996         return cached > 0;
 997 }
 998
 999 #if 0 /// UNNEEDED by elogind
1000 _noreturn_ void freeze(void) {
1001
1002         log_close();
1003
1004         /* Make sure nobody waits for us on a socket anymore */
1005         close_all_fds(NULL, 0);
1006
1007         sync();
1008
1009         /* Let's not freeze right away, but keep reaping zombies. */
1010         for (;;) {
1011                 int r;
1012                 siginfo_t si = {};
1013
1014                 r = waitid(P_ALL, 0, &si, WEXITED);
1015                 if (r < 0 && errno != EINTR)
1016                         break;
1017         }
1018
1019         /* waitid() failed with an unexpected error, things are really borked. Freeze now! */
1020         for (;;)
1021                 pause();
1022 }
1023
1024 bool oom_score_adjust_is_valid(int oa) {
1025         return oa >= OOM_SCORE_ADJ_MIN && oa <= OOM_SCORE_ADJ_MAX;
1026 }
1027
1028 unsigned long personality_from_string(const char *p) {
1029         int architecture;
1030
1031         if (!p)
1032                 return PERSONALITY_INVALID;
1033
1034         /* Parse a personality specifier. We use our own identifiers that indicate specific ABIs, rather than just
1035          * hints regarding the register size, since we want to keep things open for multiple locally supported ABIs for
1036          * the same register size. */
1037
1038         architecture = architecture_from_string(p);
1039         if (architecture < 0)
1040                 return PERSONALITY_INVALID;
1041
1042         if (architecture == native_architecture())
1043                 return PER_LINUX;
1044 #ifdef SECONDARY_ARCHITECTURE
1045         if (architecture == SECONDARY_ARCHITECTURE)
1046                 return PER_LINUX32;
1047 #endif
1048
1049         return PERSONALITY_INVALID;
1050 }
1051
1052 const char* personality_to_string(unsigned long p) {
1053         int architecture = _ARCHITECTURE_INVALID;
1054
1055         if (p == PER_LINUX)
1056                 architecture = native_architecture();
1057 #ifdef SECONDARY_ARCHITECTURE
1058         else if (p == PER_LINUX32)
1059                 architecture = SECONDARY_ARCHITECTURE;
1060 #endif
1061
1062         if (architecture < 0)
1063                 return NULL;
1064
1065         return architecture_to_string(architecture);
1066 }
1067
1068 int safe_personality(unsigned long p) {
1069         int ret;
1070
1071         /* So here's the deal, personality() is weirdly defined by glibc. In some cases it returns a failure via errno,
1072          * and in others as negative return value containing an errno-like value. Let's work around this: this is a
1073          * wrapper that uses errno if it is set, and uses the return value otherwise. And then it sets both errno and
1074          * the return value indicating the same issue, so that we are definitely on the safe side.
1075          *
1076          * See https://github.com/systemd/systemd/issues/6737 */
1077
1078         errno = 0;
1079         ret = personality(p);
1080         if (ret < 0) {
1081                 if (errno != 0)
1082                         return -errno;
1083
1084                 errno = -ret;
1085         }
1086
1087         return ret;
1088 }
1089
1090 int opinionated_personality(unsigned long *ret) {
1091         int current;
1092
1093         /* Returns the current personality, or PERSONALITY_INVALID if we can't determine it. This function is a bit
1094          * opinionated though, and ignores all the finer-grained bits and exotic personalities, only distinguishing the
1095          * two most relevant personalities: PER_LINUX and PER_LINUX32. */
1096
1097         current = safe_personality(PERSONALITY_INVALID);
1098         if (current < 0)
1099                 return current;
1100
1101         if (((unsigned long) current & 0xffff) == PER_LINUX32)
1102                 *ret = PER_LINUX32;
1103         else
1104                 *ret = PER_LINUX;
1105
1106         return 0;
1107 }
1108
1109 void valgrind_summary_hack(void) {
1110 #if HAVE_VALGRIND_VALGRIND_H
1111         if (getpid_cached() == 1 && RUNNING_ON_VALGRIND) {
1112                 pid_t pid;
1113                 pid = raw_clone(SIGCHLD);
1114                 if (pid < 0)
1115                         log_emergency_errno(errno, "Failed to fork off valgrind helper: %m");
1116                 else if (pid == 0)
1117                         exit(EXIT_SUCCESS);
1118                 else {
1119                         log_info("Spawned valgrind helper as PID "PID_FMT".", pid);
1120                         (void) wait_for_terminate(pid, NULL);
1121                 }
1122         }
1123 #endif
1124 }
1125
1126 int pid_compare_func(const void *a, const void *b) {
1127         const pid_t *p = a, *q = b;
1128
1129         /* Suitable for usage in qsort() */
1130
1131         if (*p < *q)
1132                 return -1;
1133         if (*p > *q)
1134                 return 1;
1135         return 0;
1136 }
1137
1138 int ioprio_parse_priority(const char *s, int *ret) {
1139         int i, r;
1140
1141         assert(s);
1142         assert(ret);
1143
1144         r = safe_atoi(s, &i);
1145         if (r < 0)
1146                 return r;
1147
1148         if (!ioprio_priority_is_valid(i))
1149                 return -EINVAL;
1150
1151         *ret = i;
1152         return 0;
1153 }
1154 #endif // 0
1155
1156 /* The cached PID, possible values:
1157  *
1158  *     == UNSET [0]  → cache not initialized yet
1159  *     == BUSY [-1]  → some thread is initializing it at the moment
1160  *     any other     → the cached PID
1161  */
1162
1163 #define CACHED_PID_UNSET ((pid_t) 0)
1164 #define CACHED_PID_BUSY ((pid_t) -1)
1165
1166 static pid_t cached_pid = CACHED_PID_UNSET;
1167
1168 void reset_cached_pid(void) {
1169         /* Invoked in the child after a fork(), i.e. at the first moment the PID changed */
1170         cached_pid = CACHED_PID_UNSET;
1171 }
1172
1173 /* We use glibc __register_atfork() + __dso_handle directly here, as they are not included in the glibc
1174  * headers. __register_atfork() is mostly equivalent to pthread_atfork(), but doesn't require us to link against
1175  * libpthread, as it is part of glibc anyway. */
1176 #ifdef __GLIBC__
1177 extern int __register_atfork(void (*prepare) (void), void (*parent) (void), void (*child) (void), void * __dso_handle);
1178 extern void* __dso_handle __attribute__ ((__weak__));
1179 #endif // ifdef __GLIBC__
1180
1181 pid_t getpid_cached(void) {
1182         static bool installed = false;
1183         pid_t current_value;
1184
1185         /* getpid_cached() is much like getpid(), but caches the value in local memory, to avoid having to invoke a
1186          * system call each time. This restores glibc behaviour from before 2.24, when getpid() was unconditionally
1187          * cached. Starting with 2.24 getpid() started to become prohibitively expensive when used for detecting when
1188          * objects were used across fork()s. With this caching the old behaviour is somewhat restored.
1189          *
1190          * https://bugzilla.redhat.com/show_bug.cgi?id=1443976
1191          * https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=c579f48edba88380635ab98cb612030e3ed8691e
1192          */
1193
1194         current_value = __sync_val_compare_and_swap(&cached_pid, CACHED_PID_UNSET, CACHED_PID_BUSY);
1195
1196         switch (current_value) {
1197
1198         case CACHED_PID_UNSET: { /* Not initialized yet, then do so now */
1199                 pid_t new_pid;
1200
1201                 new_pid = raw_getpid();
1202
1203                 if (!installed) {
1204                         /* __register_atfork() either returns 0 or -ENOMEM, in its glibc implementation. Since it's
1205                          * only half-documented (glibc doesn't document it but LSB does — though only superficially)
1206                          * we'll check for errors only in the most generic fashion possible. */
1207
1208                         if (__register_atfork(NULL, NULL, reset_cached_pid, __dso_handle) != 0) {
1209                                 /* OOM? Let's try again later */
1210                                 cached_pid = CACHED_PID_UNSET;
1211                                 return new_pid;
1212                         }
1213
1214                         installed = true;
1215                 }
1216
1217                 cached_pid = new_pid;
1218                 return new_pid;
1219         }
1220
1221         case CACHED_PID_BUSY: /* Somebody else is currently initializing */
1222                 return raw_getpid();
1223
1224         default: /* Properly initialized */
1225                 return current_value;
1226         }
1227 }
1228
1229 int must_be_root(void) {
1230
1231         if (geteuid() == 0)
1232                 return 0;
1233
1234         log_error("Need to be root.");
1235         return -EPERM;
1236 }
1237
1238 int safe_fork_full(
1239                 const char *name,
1240                 const int except_fds[],
1241                 size_t n_except_fds,
1242                 ForkFlags flags,
1243                 pid_t *ret_pid) {
1244
1245         pid_t original_pid, pid;
1246         sigset_t saved_ss, ss;
1247         bool block_signals = false;
1248         int prio, r;
1249
1250         /* A wrapper around fork(), that does a couple of important initializations in addition to mere forking. Always
1251          * returns the child's PID in *ret_pid. Returns == 0 in the child, and > 0 in the parent. */
1252
1253         prio = flags & FORK_LOG ? LOG_ERR : LOG_DEBUG;
1254
1255         original_pid = getpid_cached();
1256
1257         if (flags & (FORK_RESET_SIGNALS|FORK_DEATHSIG)) {
1258
1259                 /* We temporarily block all signals, so that the new child has them blocked initially. This way, we can
1260                  * be sure that SIGTERMs are not lost we might send to the child. */
1261
1262                 if (sigfillset(&ss) < 0)
1263                         return log_full_errno(prio, errno, "Failed to reset signal set: %m");
1264
1265                 block_signals = true;
1266
1267         } else if (flags & FORK_WAIT) {
1268
1269                 /* Let's block SIGCHLD at least, so that we can safely watch for the child process */
1270
1271                 if (sigemptyset(&ss) < 0)
1272                         return log_full_errno(prio, errno, "Failed to clear signal set: %m");
1273
1274                 if (sigaddset(&ss, SIGCHLD) < 0)
1275                         return log_full_errno(prio, errno, "Failed to add SIGCHLD to signal set: %m");
1276
1277                 block_signals = true;
1278         }
1279
1280         if (block_signals)
1281                 if (sigprocmask(SIG_SETMASK, &ss, &saved_ss) < 0)
1282                         return log_full_errno(prio, errno, "Failed to set signal mask: %m");
1283
1284         if (flags & FORK_NEW_MOUNTNS)
1285                 pid = raw_clone(SIGCHLD|CLONE_NEWNS);
1286         else
1287                 pid = fork();
1288         if (pid < 0) {
1289                 r = -errno;
1290
1291                 if (block_signals) /* undo what we did above */
1292                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1293
1294                 return log_full_errno(prio, r, "Failed to fork: %m");
1295         }
1296         if (pid > 0) {
1297                 /* We are in the parent process */
1298
1299                 log_debug("Successfully forked off '%s' as PID " PID_FMT ".", strna(name), pid);
1300
1301                 if (flags & FORK_WAIT) {
1302                         r = wait_for_terminate_and_check(name, pid, (flags & FORK_LOG ? WAIT_LOG : 0));
1303                         if (r < 0)
1304                                 return r;
1305                         if (r != EXIT_SUCCESS) /* exit status > 0 should be treated as failure, too */
1306                                 return -EPROTO;
1307                 }
1308
1309                 if (block_signals) /* undo what we did above */
1310                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1311
1312                 if (ret_pid)
1313                         *ret_pid = pid;
1314
1315                 return 1;
1316         }
1317
1318         /* We are in the child process */
1319
1320         if (flags & FORK_REOPEN_LOG) {
1321                 /* Close the logs if requested, before we log anything. And make sure we reopen it if needed. */
1322                 log_close();
1323                 log_set_open_when_needed(true);
1324         }
1325
1326         if (name) {
1327                 r = rename_process(name);
1328                 if (r < 0)
1329                         log_full_errno(flags & FORK_LOG ? LOG_WARNING : LOG_DEBUG,
1330                                        r, "Failed to rename process, ignoring: %m");
1331         }
1332
1333         if (flags & FORK_DEATHSIG)
1334                 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0) {
1335                         log_full_errno(prio, errno, "Failed to set death signal: %m");
1336                         _exit(EXIT_FAILURE);
1337                 }
1338
1339         if (flags & FORK_RESET_SIGNALS) {
1340                 r = reset_all_signal_handlers();
1341                 if (r < 0) {
1342                         log_full_errno(prio, r, "Failed to reset signal handlers: %m");
1343                         _exit(EXIT_FAILURE);
1344                 }
1345
1346                 /* This implicitly undoes the signal mask stuff we did before the fork()ing above */
1347                 r = reset_signal_mask();
1348                 if (r < 0) {
1349                         log_full_errno(prio, r, "Failed to reset signal mask: %m");
1350                         _exit(EXIT_FAILURE);
1351                 }
1352         } else if (block_signals) { /* undo what we did above */
1353                 if (sigprocmask(SIG_SETMASK, &saved_ss, NULL) < 0) {
1354                         log_full_errno(prio, errno, "Failed to restore signal mask: %m");
1355                         _exit(EXIT_FAILURE);
1356                 }
1357         }
1358
1359         if (flags & FORK_DEATHSIG) {
1360                 pid_t ppid;
1361                 /* Let's see if the parent PID is still the one we started from? If not, then the parent
1362                  * already died by the time we set PR_SET_PDEATHSIG, hence let's emulate the effect */
1363
1364                 ppid = getppid();
1365                 if (ppid == 0)
1366                         /* Parent is in a differn't PID namespace. */;
1367                 else if (ppid != original_pid) {
1368                         log_debug("Parent died early, raising SIGTERM.");
1369                         (void) raise(SIGTERM);
1370                         _exit(EXIT_FAILURE);
1371                 }
1372         }
1373
1374         if ((flags & (FORK_NEW_MOUNTNS|FORK_MOUNTNS_SLAVE)) == (FORK_NEW_MOUNTNS|FORK_MOUNTNS_SLAVE)) {
1375
1376                 /* Optionally, make sure we never propagate mounts to the host. */
1377
1378                 if (mount(NULL, "/", NULL, MS_SLAVE | MS_REC, NULL) < 0) {
1379                         log_full_errno(prio, errno, "Failed to remount root directory as MS_SLAVE: %m");
1380                         _exit(EXIT_FAILURE);
1381                 }
1382         }
1383
1384         if (flags & FORK_CLOSE_ALL_FDS) {
1385                 /* Close the logs here in case it got reopened above, as close_all_fds() would close them for us */
1386                 log_close();
1387
1388                 r = close_all_fds(except_fds, n_except_fds);
1389                 if (r < 0) {
1390                         log_full_errno(prio, r, "Failed to close all file descriptors: %m");
1391                         _exit(EXIT_FAILURE);
1392                 }
1393         }
1394
1395         /* When we were asked to reopen the logs, do so again now */
1396         if (flags & FORK_REOPEN_LOG) {
1397                 log_open();
1398                 log_set_open_when_needed(false);
1399         }
1400
1401         if (flags & FORK_NULL_STDIO) {
1402                 r = make_null_stdio();
1403                 if (r < 0) {
1404                         log_full_errno(prio, r, "Failed to connect stdin/stdout to /dev/null: %m");
1405                         _exit(EXIT_FAILURE);
1406                 }
1407         }
1408
1409         if (ret_pid)
1410                 *ret_pid = getpid_cached();
1411
1412         return 0;
1413 }
1414
1415 int fork_agent(const char *name, const int except[], size_t n_except, pid_t *ret_pid, const char *path, ...) {
1416         bool stdout_is_tty, stderr_is_tty;
1417         size_t n, i;
1418         va_list ap;
1419         char **l;
1420         int r;
1421
1422         assert(path);
1423
1424         /* Spawns a temporary TTY agent, making sure it goes away when we go away */
1425
1426         r = safe_fork_full(name, except, n_except, FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_CLOSE_ALL_FDS, ret_pid);
1427         if (r < 0)
1428                 return r;
1429         if (r > 0)
1430                 return 0;
1431
1432         /* In the child: */
1433
1434         stdout_is_tty = isatty(STDOUT_FILENO);
1435         stderr_is_tty = isatty(STDERR_FILENO);
1436
1437         if (!stdout_is_tty || !stderr_is_tty) {
1438                 int fd;
1439
1440                 /* Detach from stdout/stderr. and reopen
1441                  * /dev/tty for them. This is important to
1442                  * ensure that when systemctl is started via
1443                  * popen() or a similar call that expects to
1444                  * read EOF we actually do generate EOF and
1445                  * not delay this indefinitely by because we
1446                  * keep an unused copy of stdin around. */
1447                 fd = open("/dev/tty", O_WRONLY);
1448                 if (fd < 0) {
1449                         log_error_errno(errno, "Failed to open /dev/tty: %m");
1450                         _exit(EXIT_FAILURE);
1451                 }
1452
1453                 if (!stdout_is_tty && dup2(fd, STDOUT_FILENO) < 0) {
1454                         log_error_errno(errno, "Failed to dup2 /dev/tty: %m");
1455                         _exit(EXIT_FAILURE);
1456                 }
1457
1458                 if (!stderr_is_tty && dup2(fd, STDERR_FILENO) < 0) {
1459                         log_error_errno(errno, "Failed to dup2 /dev/tty: %m");
1460                         _exit(EXIT_FAILURE);
1461                 }
1462
1463                 safe_close_above_stdio(fd);
1464         }
1465
1466         /* Count arguments */
1467         va_start(ap, path);
1468         for (n = 0; va_arg(ap, char*); n++)
1469                 ;
1470         va_end(ap);
1471
1472         /* Allocate strv */
1473         l = newa(char*, n + 1);
1474
1475         /* Fill in arguments */
1476         va_start(ap, path);
1477         for (i = 0; i <= n; i++)
1478                 l[i] = va_arg(ap, char*);
1479         va_end(ap);
1480
1481         execv(path, l);
1482         _exit(EXIT_FAILURE);
1483 }
1484
1485 int set_oom_score_adjust(int value) {
1486         char t[DECIMAL_STR_MAX(int)];
1487
1488         sprintf(t, "%i", value);
1489
1490         return write_string_file("/proc/self/oom_score_adj", t,
1491                                  WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_DISABLE_BUFFER);
1492 }
1493
1494 #if 0 /// UNNEEDED by elogind
1495 static const char *const ioprio_class_table[] = {
1496         [IOPRIO_CLASS_NONE] = "none",
1497         [IOPRIO_CLASS_RT] = "realtime",
1498         [IOPRIO_CLASS_BE] = "best-effort",
1499         [IOPRIO_CLASS_IDLE] = "idle"
1500 };
1501
1502 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, IOPRIO_N_CLASSES);
1503
1504 static const char *const sigchld_code_table[] = {
1505         [CLD_EXITED] = "exited",
1506         [CLD_KILLED] = "killed",
1507         [CLD_DUMPED] = "dumped",
1508         [CLD_TRAPPED] = "trapped",
1509         [CLD_STOPPED] = "stopped",
1510         [CLD_CONTINUED] = "continued",
1511 };
1512
1513 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
1514
1515 static const char* const sched_policy_table[] = {
1516         [SCHED_OTHER] = "other",
1517         [SCHED_BATCH] = "batch",
1518         [SCHED_IDLE] = "idle",
1519         [SCHED_FIFO] = "fifo",
1520         [SCHED_RR] = "rr"
1521 };
1522
1523 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
1524 #endif // 0