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