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