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 = outcome;
 630         outcome = NULL;
 631
 632         return 0;
 633 }
 634
 635 int get_process_ppid(pid_t pid, pid_t *_ppid) {
 636         int r;
 637         _cleanup_free_ char *line = NULL;
 638         long unsigned ppid;
 639         const char *p;
 640
 641         assert(pid >= 0);
 642         assert(_ppid);
 643
 644         if (pid == 0 || pid == getpid_cached()) {
 645                 *_ppid = getppid();
 646                 return 0;
 647         }
 648
 649         p = procfs_file_alloca(pid, "stat");
 650         r = read_one_line_file(p, &line);
 651         if (r == -ENOENT)
 652                 return -ESRCH;
 653         if (r < 0)
 654                 return r;
 655
 656         /* Let's skip the pid and comm fields. The latter is enclosed
 657          * in () but does not escape any () in its value, so let's
 658          * skip over it manually */
 659
 660         p = strrchr(line, ')');
 661         if (!p)
 662                 return -EIO;
 663
 664         p++;
 665
 666         if (sscanf(p, " "
 667                    "%*c "  /* state */
 668                    "%lu ", /* ppid */
 669                    &ppid) != 1)
 670                 return -EIO;
 671
 672         if ((long unsigned) (pid_t) ppid != ppid)
 673                 return -ERANGE;
 674
 675         *_ppid = (pid_t) ppid;
 676
 677         return 0;
 678 }
 679 #endif // 0
 680
 681 int wait_for_terminate(pid_t pid, siginfo_t *status) {
 682         siginfo_t dummy;
 683
 684         assert(pid >= 1);
 685
 686         if (!status)
 687                 status = &dummy;
 688
 689         for (;;) {
 690                 zero(*status);
 691
 692                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
 693
 694                         if (errno == EINTR)
 695                                 continue;
 696
 697                         return negative_errno();
 698                 }
 699
 700                 return 0;
 701         }
 702 }
 703
 704 /*
 705  * Return values:
 706  * < 0 : wait_for_terminate() failed to get the state of the
 707  *       process, the process was terminated by a signal, or
 708  *       failed for an unknown reason.
 709  * >=0 : The process terminated normally, and its exit code is
 710  *       returned.
 711  *
 712  * That is, success is indicated by a return value of zero, and an
 713  * error is indicated by a non-zero value.
 714  *
 715  * A warning is emitted if the process terminates abnormally,
 716  * and also if it returns non-zero unless check_exit_code is true.
 717  */
 718 int wait_for_terminate_and_check(const char *name, pid_t pid, WaitFlags flags) {
 719         _cleanup_free_ char *buffer = NULL;
 720         siginfo_t status;
 721         int r, prio;
 722
 723         assert(pid > 1);
 724
 725         if (!name) {
 726                 r = get_process_comm(pid, &buffer);
 727                 if (r < 0)
 728                         log_debug_errno(r, "Failed to acquire process name of " PID_FMT ", ignoring: %m", pid);
 729                 else
 730                         name = buffer;
 731         }
 732
 733         prio = flags & WAIT_LOG_ABNORMAL ? LOG_ERR : LOG_DEBUG;
 734
 735         r = wait_for_terminate(pid, &status);
 736         if (r < 0)
 737                 return log_full_errno(prio, r, "Failed to wait for %s: %m", strna(name));
 738
 739         if (status.si_code == CLD_EXITED) {
 740                 if (status.si_status != EXIT_SUCCESS)
 741                         log_full(flags & WAIT_LOG_NON_ZERO_EXIT_STATUS ? LOG_ERR : LOG_DEBUG,
 742                                  "%s failed with exit status %i.", strna(name), status.si_status);
 743                 else
 744                         log_debug("%s succeeded.", name);
 745
 746                 return status.si_status;
 747
 748         } else if (IN_SET(status.si_code, CLD_KILLED, CLD_DUMPED)) {
 749
 750                 log_full(prio, "%s terminated by signal %s.", strna(name), signal_to_string(status.si_status));
 751                 return -EPROTO;
 752         }
 753
 754         log_full(prio, "%s failed due to unknown reason.", strna(name));
 755         return -EPROTO;
 756 }
 757
 758 /*
 759  * Return values:
 760  * < 0 : wait_for_terminate_with_timeout() failed to get the state of the
 761  *       process, the process timed out, the process was terminated by a
 762  *       signal, or failed for an unknown reason.
 763  * >=0 : The process terminated normally with no failures.
 764  *
 765  * Success is indicated by a return value of zero, a timeout is indicated
 766  * by ETIMEDOUT, and all other child failure states are indicated by error
 767  * is indicated by a non-zero value.
 768  */
 769 int wait_for_terminate_with_timeout(pid_t pid, usec_t timeout) {
 770         sigset_t mask;
 771         int r;
 772         usec_t until;
 773
 774         assert_se(sigemptyset(&mask) == 0);
 775         assert_se(sigaddset(&mask, SIGCHLD) == 0);
 776
 777         /* Drop into a sigtimewait-based timeout. Waiting for the
 778          * pid to exit. */
 779         until = now(CLOCK_MONOTONIC) + timeout;
 780         for (;;) {
 781                 usec_t n;
 782                 siginfo_t status = {};
 783                 struct timespec ts;
 784
 785                 n = now(CLOCK_MONOTONIC);
 786                 if (n >= until)
 787                         break;
 788
 789                 r = sigtimedwait(&mask, NULL, timespec_store(&ts, until - n)) < 0 ? -errno : 0;
 790                 /* Assuming we woke due to the child exiting. */
 791                 if (waitid(P_PID, pid, &status, WEXITED|WNOHANG) == 0) {
 792                         if (status.si_pid == pid) {
 793                                 /* This is the correct child.*/
 794                                 if (status.si_code == CLD_EXITED)
 795                                         return (status.si_status == 0) ? 0 : -EPROTO;
 796                                 else
 797                                         return -EPROTO;
 798                         }
 799                 }
 800                 /* Not the child, check for errors and proceed appropriately */
 801                 if (r < 0) {
 802                         switch (r) {
 803                         case -EAGAIN:
 804                                 /* Timed out, child is likely hung. */
 805                                 return -ETIMEDOUT;
 806                         case -EINTR:
 807                                 /* Received a different signal and should retry */
 808                                 continue;
 809                         default:
 810                                 /* Return any unexpected errors */
 811                                 return r;
 812                         }
 813                 }
 814         }
 815
 816         return -EPROTO;
 817 }
 818
 819 #if 0 /// UNNEEDED by elogind
 820 void sigkill_wait(pid_t pid) {
 821         assert(pid > 1);
 822
 823         if (kill(pid, SIGKILL) > 0)
 824                 (void) wait_for_terminate(pid, NULL);
 825 }
 826
 827 void sigkill_waitp(pid_t *pid) {
 828         PROTECT_ERRNO;
 829
 830         if (!pid)
 831                 return;
 832         if (*pid <= 1)
 833                 return;
 834
 835         sigkill_wait(*pid);
 836 }
 837 #endif // 0
 838
 839 void sigterm_wait(pid_t pid) {
 840         assert(pid > 1);
 841
 842         if (kill_and_sigcont(pid, SIGTERM) > 0)
 843                 (void) wait_for_terminate(pid, NULL);
 844 }
 845
 846 int kill_and_sigcont(pid_t pid, int sig) {
 847         int r;
 848
 849         r = kill(pid, sig) < 0 ? -errno : 0;
 850
 851         /* If this worked, also send SIGCONT, unless we already just sent a SIGCONT, or SIGKILL was sent which isn't
 852          * affected by a process being suspended anyway. */
 853         if (r >= 0 && !IN_SET(sig, SIGCONT, SIGKILL))
 854                 (void) kill(pid, SIGCONT);
 855
 856         return r;
 857 }
 858
 859 int getenv_for_pid(pid_t pid, const char *field, char **ret) {
 860         _cleanup_fclose_ FILE *f = NULL;
 861         char *value = NULL;
 862         bool done = false;
 863         const char *path;
 864         size_t l;
 865
 866         assert(pid >= 0);
 867         assert(field);
 868         assert(ret);
 869
 870         if (pid == 0 || pid == getpid_cached()) {
 871                 const char *e;
 872
 873                 e = getenv(field);
 874                 if (!e) {
 875                         *ret = NULL;
 876                         return 0;
 877                 }
 878
 879                 value = strdup(e);
 880                 if (!value)
 881                         return -ENOMEM;
 882
 883                 *ret = value;
 884                 return 1;
 885         }
 886
 887         path = procfs_file_alloca(pid, "environ");
 888
 889         f = fopen(path, "re");
 890         if (!f) {
 891                 if (errno == ENOENT)
 892                         return -ESRCH;
 893
 894                 return -errno;
 895         }
 896
 897         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 898
 899         l = strlen(field);
 900
 901         do {
 902                 char line[LINE_MAX];
 903                 unsigned i;
 904
 905                 for (i = 0; i < sizeof(line)-1; i++) {
 906                         int c;
 907
 908                         c = getc(f);
 909                         if (_unlikely_(c == EOF)) {
 910                                 done = true;
 911                                 break;
 912                         } else if (c == 0)
 913                                 break;
 914
 915                         line[i] = c;
 916                 }
 917                 line[i] = 0;
 918
 919                 if (strneq(line, field, l) && line[l] == '=') {
 920                         value = strdup(line + l + 1);
 921                         if (!value)
 922                                 return -ENOMEM;
 923
 924                         *ret = value;
 925                         return 1;
 926                 }
 927
 928         } while (!done);
 929
 930         *ret = NULL;
 931         return 0;
 932 }
 933
 934 bool pid_is_unwaited(pid_t pid) {
 935         /* Checks whether a PID is still valid at all, including a zombie */
 936
 937         if (pid < 0)
 938                 return false;
 939
 940         if (pid <= 1) /* If we or PID 1 would be dead and have been waited for, this code would not be running */
 941                 return true;
 942
 943         if (pid == getpid_cached())
 944                 return true;
 945
 946         if (kill(pid, 0) >= 0)
 947                 return true;
 948
 949         return errno != ESRCH;
 950 }
 951
 952 bool pid_is_alive(pid_t pid) {
 953         int r;
 954
 955         /* Checks whether a PID is still valid and not a zombie */
 956
 957         if (pid < 0)
 958                 return false;
 959
 960         if (pid <= 1) /* If we or PID 1 would be a zombie, this code would not be running */
 961                 return true;
 962
 963         if (pid == getpid_cached())
 964                 return true;
 965
 966         r = get_process_state(pid);
 967         if (IN_SET(r, -ESRCH, 'Z'))
 968                 return false;
 969
 970         return true;
 971 }
 972
 973 #if 0 /// UNNEEDED by elogind
 974 int pid_from_same_root_fs(pid_t pid) {
 975         const char *root;
 976
 977         if (pid < 0)
 978                 return false;
 979
 980         if (pid == 0 || pid == getpid_cached())
 981                 return true;
 982
 983         root = procfs_file_alloca(pid, "root");
 984
 985         return files_same(root, "/proc/1/root", 0);
 986 }
 987 #endif // 0
 988
 989 bool is_main_thread(void) {
 990         static thread_local int cached = 0;
 991
 992         if (_unlikely_(cached == 0))
 993                 cached = getpid_cached() == gettid() ? 1 : -1;
 994
 995         return cached > 0;
 996 }
 997
 998 #if 0 /// UNNEEDED by elogind
 999 _noreturn_ void freeze(void) {
1000
1001         log_close();
1002
1003         /* Make sure nobody waits for us on a socket anymore */
1004         close_all_fds(NULL, 0);
1005
1006         sync();
1007
1008         /* Let's not freeze right away, but keep reaping zombies. */
1009         for (;;) {
1010                 int r;
1011                 siginfo_t si = {};
1012
1013                 r = waitid(P_ALL, 0, &si, WEXITED);
1014                 if (r < 0 && errno != EINTR)
1015                         break;
1016         }
1017
1018         /* waitid() failed with an unexpected error, things are really borked. Freeze now! */
1019         for (;;)
1020                 pause();
1021 }
1022
1023 bool oom_score_adjust_is_valid(int oa) {
1024         return oa >= OOM_SCORE_ADJ_MIN && oa <= OOM_SCORE_ADJ_MAX;
1025 }
1026
1027 unsigned long personality_from_string(const char *p) {
1028         int architecture;
1029
1030         if (!p)
1031                 return PERSONALITY_INVALID;
1032
1033         /* Parse a personality specifier. We use our own identifiers that indicate specific ABIs, rather than just
1034          * hints regarding the register size, since we want to keep things open for multiple locally supported ABIs for
1035          * the same register size. */
1036
1037         architecture = architecture_from_string(p);
1038         if (architecture < 0)
1039                 return PERSONALITY_INVALID;
1040
1041         if (architecture == native_architecture())
1042                 return PER_LINUX;
1043 #ifdef SECONDARY_ARCHITECTURE
1044         if (architecture == SECONDARY_ARCHITECTURE)
1045                 return PER_LINUX32;
1046 #endif
1047
1048         return PERSONALITY_INVALID;
1049 }
1050
1051 const char* personality_to_string(unsigned long p) {
1052         int architecture = _ARCHITECTURE_INVALID;
1053
1054         if (p == PER_LINUX)
1055                 architecture = native_architecture();
1056 #ifdef SECONDARY_ARCHITECTURE
1057         else if (p == PER_LINUX32)
1058                 architecture = SECONDARY_ARCHITECTURE;
1059 #endif
1060
1061         if (architecture < 0)
1062                 return NULL;
1063
1064         return architecture_to_string(architecture);
1065 }
1066
1067 int safe_personality(unsigned long p) {
1068         int ret;
1069
1070         /* So here's the deal, personality() is weirdly defined by glibc. In some cases it returns a failure via errno,
1071          * and in others as negative return value containing an errno-like value. Let's work around this: this is a
1072          * wrapper that uses errno if it is set, and uses the return value otherwise. And then it sets both errno and
1073          * the return value indicating the same issue, so that we are definitely on the safe side.
1074          *
1075          * See https://github.com/systemd/systemd/issues/6737 */
1076
1077         errno = 0;
1078         ret = personality(p);
1079         if (ret < 0) {
1080                 if (errno != 0)
1081                         return -errno;
1082
1083                 errno = -ret;
1084         }
1085
1086         return ret;
1087 }
1088
1089 int opinionated_personality(unsigned long *ret) {
1090         int current;
1091
1092         /* Returns the current personality, or PERSONALITY_INVALID if we can't determine it. This function is a bit
1093          * opinionated though, and ignores all the finer-grained bits and exotic personalities, only distinguishing the
1094          * two most relevant personalities: PER_LINUX and PER_LINUX32. */
1095
1096         current = safe_personality(PERSONALITY_INVALID);
1097         if (current < 0)
1098                 return current;
1099
1100         if (((unsigned long) current & 0xffff) == PER_LINUX32)
1101                 *ret = PER_LINUX32;
1102         else
1103                 *ret = PER_LINUX;
1104
1105         return 0;
1106 }
1107
1108 void valgrind_summary_hack(void) {
1109 #if HAVE_VALGRIND_VALGRIND_H
1110         if (getpid_cached() == 1 && RUNNING_ON_VALGRIND) {
1111                 pid_t pid;
1112                 pid = raw_clone(SIGCHLD);
1113                 if (pid < 0)
1114                         log_emergency_errno(errno, "Failed to fork off valgrind helper: %m");
1115                 else if (pid == 0)
1116                         exit(EXIT_SUCCESS);
1117                 else {
1118                         log_info("Spawned valgrind helper as PID "PID_FMT".", pid);
1119                         (void) wait_for_terminate(pid, NULL);
1120                 }
1121         }
1122 #endif
1123 }
1124
1125 int pid_compare_func(const void *a, const void *b) {
1126         const pid_t *p = a, *q = b;
1127
1128         /* Suitable for usage in qsort() */
1129
1130         if (*p < *q)
1131                 return -1;
1132         if (*p > *q)
1133                 return 1;
1134         return 0;
1135 }
1136
1137 int ioprio_parse_priority(const char *s, int *ret) {
1138         int i, r;
1139
1140         assert(s);
1141         assert(ret);
1142
1143         r = safe_atoi(s, &i);
1144         if (r < 0)
1145                 return r;
1146
1147         if (!ioprio_priority_is_valid(i))
1148                 return -EINVAL;
1149
1150         *ret = i;
1151         return 0;
1152 }
1153 #endif // 0
1154
1155 /* The cached PID, possible values:
1156  *
1157  *     == UNSET [0]  → cache not initialized yet
1158  *     == BUSY [-1]  → some thread is initializing it at the moment
1159  *     any other     → the cached PID
1160  */
1161
1162 #define CACHED_PID_UNSET ((pid_t) 0)
1163 #define CACHED_PID_BUSY ((pid_t) -1)
1164
1165 static pid_t cached_pid = CACHED_PID_UNSET;
1166
1167 void reset_cached_pid(void) {
1168         /* Invoked in the child after a fork(), i.e. at the first moment the PID changed */
1169         cached_pid = CACHED_PID_UNSET;
1170 }
1171
1172 /* We use glibc __register_atfork() + __dso_handle directly here, as they are not included in the glibc
1173  * headers. __register_atfork() is mostly equivalent to pthread_atfork(), but doesn't require us to link against
1174  * libpthread, as it is part of glibc anyway. */
1175 #ifdef __GLIBC__
1176 extern int __register_atfork(void (*prepare) (void), void (*parent) (void), void (*child) (void), void * __dso_handle);
1177 extern void* __dso_handle __attribute__ ((__weak__));
1178 #endif // ifdef __GLIBC__
1179
1180 pid_t getpid_cached(void) {
1181         static bool installed = false;
1182         pid_t current_value;
1183
1184         /* getpid_cached() is much like getpid(), but caches the value in local memory, to avoid having to invoke a
1185          * system call each time. This restores glibc behaviour from before 2.24, when getpid() was unconditionally
1186          * cached. Starting with 2.24 getpid() started to become prohibitively expensive when used for detecting when
1187          * objects were used across fork()s. With this caching the old behaviour is somewhat restored.
1188          *
1189          * https://bugzilla.redhat.com/show_bug.cgi?id=1443976
1190          * https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=c579f48edba88380635ab98cb612030e3ed8691e
1191          */
1192
1193         current_value = __sync_val_compare_and_swap(&cached_pid, CACHED_PID_UNSET, CACHED_PID_BUSY);
1194
1195         switch (current_value) {
1196
1197         case CACHED_PID_UNSET: { /* Not initialized yet, then do so now */
1198                 pid_t new_pid;
1199
1200                 new_pid = raw_getpid();
1201
1202                 if (!installed) {
1203                         /* __register_atfork() either returns 0 or -ENOMEM, in its glibc implementation. Since it's
1204                          * only half-documented (glibc doesn't document it but LSB does — though only superficially)
1205                          * we'll check for errors only in the most generic fashion possible. */
1206
1207                         if (__register_atfork(NULL, NULL, reset_cached_pid, __dso_handle) != 0) {
1208                                 /* OOM? Let's try again later */
1209                                 cached_pid = CACHED_PID_UNSET;
1210                                 return new_pid;
1211                         }
1212
1213                         installed = true;
1214                 }
1215
1216                 cached_pid = new_pid;
1217                 return new_pid;
1218         }
1219
1220         case CACHED_PID_BUSY: /* Somebody else is currently initializing */
1221                 return raw_getpid();
1222
1223         default: /* Properly initialized */
1224                 return current_value;
1225         }
1226 }
1227
1228 int must_be_root(void) {
1229
1230         if (geteuid() == 0)
1231                 return 0;
1232
1233         log_error("Need to be root.");
1234         return -EPERM;
1235 }
1236
1237 int safe_fork_full(
1238                 const char *name,
1239                 const int except_fds[],
1240                 size_t n_except_fds,
1241                 ForkFlags flags,
1242                 pid_t *ret_pid) {
1243
1244         pid_t original_pid, pid;
1245         sigset_t saved_ss, ss;
1246         bool block_signals = false;
1247         int prio, r;
1248
1249         /* A wrapper around fork(), that does a couple of important initializations in addition to mere forking. Always
1250          * returns the child's PID in *ret_pid. Returns == 0 in the child, and > 0 in the parent. */
1251
1252         prio = flags & FORK_LOG ? LOG_ERR : LOG_DEBUG;
1253
1254         original_pid = getpid_cached();
1255
1256         if (flags & (FORK_RESET_SIGNALS|FORK_DEATHSIG)) {
1257
1258                 /* We temporarily block all signals, so that the new child has them blocked initially. This way, we can
1259                  * be sure that SIGTERMs are not lost we might send to the child. */
1260
1261                 if (sigfillset(&ss) < 0)
1262                         return log_full_errno(prio, errno, "Failed to reset signal set: %m");
1263
1264                 block_signals = true;
1265
1266         } else if (flags & FORK_WAIT) {
1267
1268                 /* Let's block SIGCHLD at least, so that we can safely watch for the child process */
1269
1270                 if (sigemptyset(&ss) < 0)
1271                         return log_full_errno(prio, errno, "Failed to clear signal set: %m");
1272
1273                 if (sigaddset(&ss, SIGCHLD) < 0)
1274                         return log_full_errno(prio, errno, "Failed to add SIGCHLD to signal set: %m");
1275
1276                 block_signals = true;
1277         }
1278
1279         if (block_signals)
1280                 if (sigprocmask(SIG_SETMASK, &ss, &saved_ss) < 0)
1281                         return log_full_errno(prio, errno, "Failed to set signal mask: %m");
1282
1283         if (flags & FORK_NEW_MOUNTNS)
1284                 pid = raw_clone(SIGCHLD|CLONE_NEWNS);
1285         else
1286                 pid = fork();
1287         if (pid < 0) {
1288                 r = -errno;
1289
1290                 if (block_signals) /* undo what we did above */
1291                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1292
1293                 return log_full_errno(prio, r, "Failed to fork: %m");
1294         }
1295         if (pid > 0) {
1296                 /* We are in the parent process */
1297
1298                 log_debug("Successfully forked off '%s' as PID " PID_FMT ".", strna(name), pid);
1299
1300                 if (flags & FORK_WAIT) {
1301                         r = wait_for_terminate_and_check(name, pid, (flags & FORK_LOG ? WAIT_LOG : 0));
1302                         if (r < 0)
1303                                 return r;
1304                         if (r != EXIT_SUCCESS) /* exit status > 0 should be treated as failure, too */
1305                                 return -EPROTO;
1306                 }
1307
1308                 if (block_signals) /* undo what we did above */
1309                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1310
1311                 if (ret_pid)
1312                         *ret_pid = pid;
1313
1314                 return 1;
1315         }
1316
1317         /* We are in the child process */
1318
1319         if (flags & FORK_REOPEN_LOG) {
1320                 /* Close the logs if requested, before we log anything. And make sure we reopen it if needed. */
1321                 log_close();
1322                 log_set_open_when_needed(true);
1323         }
1324
1325         if (name) {
1326                 r = rename_process(name);
1327                 if (r < 0)
1328                         log_full_errno(flags & FORK_LOG ? LOG_WARNING : LOG_DEBUG,
1329                                        r, "Failed to rename process, ignoring: %m");
1330         }
1331
1332         if (flags & FORK_DEATHSIG)
1333                 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0) {
1334                         log_full_errno(prio, errno, "Failed to set death signal: %m");
1335                         _exit(EXIT_FAILURE);
1336                 }
1337
1338         if (flags & FORK_RESET_SIGNALS) {
1339                 r = reset_all_signal_handlers();
1340                 if (r < 0) {
1341                         log_full_errno(prio, r, "Failed to reset signal handlers: %m");
1342                         _exit(EXIT_FAILURE);
1343                 }
1344
1345                 /* This implicitly undoes the signal mask stuff we did before the fork()ing above */
1346                 r = reset_signal_mask();
1347                 if (r < 0) {
1348                         log_full_errno(prio, r, "Failed to reset signal mask: %m");
1349                         _exit(EXIT_FAILURE);
1350                 }
1351         } else if (block_signals) { /* undo what we did above */
1352                 if (sigprocmask(SIG_SETMASK, &saved_ss, NULL) < 0) {
1353                         log_full_errno(prio, errno, "Failed to restore signal mask: %m");
1354                         _exit(EXIT_FAILURE);
1355                 }
1356         }
1357
1358         if (flags & FORK_DEATHSIG) {
1359                 pid_t ppid;
1360                 /* Let's see if the parent PID is still the one we started from? If not, then the parent
1361                  * already died by the time we set PR_SET_PDEATHSIG, hence let's emulate the effect */
1362
1363                 ppid = getppid();
1364                 if (ppid == 0)
1365                         /* Parent is in a differn't PID namespace. */;
1366                 else if (ppid != original_pid) {
1367                         log_debug("Parent died early, raising SIGTERM.");
1368                         (void) raise(SIGTERM);
1369                         _exit(EXIT_FAILURE);
1370                 }
1371         }
1372
1373         if (flags & FORK_CLOSE_ALL_FDS) {
1374                 /* Close the logs here in case it got reopened above, as close_all_fds() would close them for us */
1375                 log_close();
1376
1377                 r = close_all_fds(except_fds, n_except_fds);
1378                 if (r < 0) {
1379                         log_full_errno(prio, r, "Failed to close all file descriptors: %m");
1380                         _exit(EXIT_FAILURE);
1381                 }
1382         }
1383
1384         /* When we were asked to reopen the logs, do so again now */
1385         if (flags & FORK_REOPEN_LOG) {
1386                 log_open();
1387                 log_set_open_when_needed(false);
1388         }
1389
1390         if (flags & FORK_NULL_STDIO) {
1391                 r = make_null_stdio();
1392                 if (r < 0) {
1393                         log_full_errno(prio, r, "Failed to connect stdin/stdout to /dev/null: %m");
1394                         _exit(EXIT_FAILURE);
1395                 }
1396         }
1397
1398         if (ret_pid)
1399                 *ret_pid = getpid_cached();
1400
1401         return 0;
1402 }
1403
1404 int fork_agent(const char *name, const int except[], unsigned n_except, pid_t *ret_pid, const char *path, ...) {
1405         bool stdout_is_tty, stderr_is_tty;
1406         unsigned n, i;
1407         va_list ap;
1408         char **l;
1409         int r;
1410
1411         assert(path);
1412
1413         /* Spawns a temporary TTY agent, making sure it goes away when we go away */
1414
1415         r = safe_fork_full(name, except, n_except, FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_CLOSE_ALL_FDS, ret_pid);
1416         if (r < 0)
1417                 return r;
1418         if (r > 0)
1419                 return 0;
1420
1421         /* In the child: */
1422
1423         stdout_is_tty = isatty(STDOUT_FILENO);
1424         stderr_is_tty = isatty(STDERR_FILENO);
1425
1426         if (!stdout_is_tty || !stderr_is_tty) {
1427                 int fd;
1428
1429                 /* Detach from stdout/stderr. and reopen
1430                  * /dev/tty for them. This is important to
1431                  * ensure that when systemctl is started via
1432                  * popen() or a similar call that expects to
1433                  * read EOF we actually do generate EOF and
1434                  * not delay this indefinitely by because we
1435                  * keep an unused copy of stdin around. */
1436                 fd = open("/dev/tty", O_WRONLY);
1437                 if (fd < 0) {
1438                         log_error_errno(errno, "Failed to open /dev/tty: %m");
1439                         _exit(EXIT_FAILURE);
1440                 }
1441
1442                 if (!stdout_is_tty && dup2(fd, STDOUT_FILENO) < 0) {
1443                         log_error_errno(errno, "Failed to dup2 /dev/tty: %m");
1444                         _exit(EXIT_FAILURE);
1445                 }
1446
1447                 if (!stderr_is_tty && dup2(fd, STDERR_FILENO) < 0) {
1448                         log_error_errno(errno, "Failed to dup2 /dev/tty: %m");
1449                         _exit(EXIT_FAILURE);
1450                 }
1451
1452                 safe_close_above_stdio(fd);
1453         }
1454
1455         /* Count arguments */
1456         va_start(ap, path);
1457         for (n = 0; va_arg(ap, char*); n++)
1458                 ;
1459         va_end(ap);
1460
1461         /* Allocate strv */
1462         l = alloca(sizeof(char *) * (n + 1));
1463
1464         /* Fill in arguments */
1465         va_start(ap, path);
1466         for (i = 0; i <= n; i++)
1467                 l[i] = va_arg(ap, char*);
1468         va_end(ap);
1469
1470         execv(path, l);
1471         _exit(EXIT_FAILURE);
1472 }
1473
1474 #if 0 /// UNNEEDED by elogind
1475 static const char *const ioprio_class_table[] = {
1476         [IOPRIO_CLASS_NONE] = "none",
1477         [IOPRIO_CLASS_RT] = "realtime",
1478         [IOPRIO_CLASS_BE] = "best-effort",
1479         [IOPRIO_CLASS_IDLE] = "idle"
1480 };
1481
1482 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
1483
1484 static const char *const sigchld_code_table[] = {
1485         [CLD_EXITED] = "exited",
1486         [CLD_KILLED] = "killed",
1487         [CLD_DUMPED] = "dumped",
1488         [CLD_TRAPPED] = "trapped",
1489         [CLD_STOPPED] = "stopped",
1490         [CLD_CONTINUED] = "continued",
1491 };
1492
1493 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
1494
1495 static const char* const sched_policy_table[] = {
1496         [SCHED_OTHER] = "other",
1497         [SCHED_BATCH] = "batch",
1498         [SCHED_IDLE] = "idle",
1499         [SCHED_FIFO] = "fifo",
1500         [SCHED_RR] = "rr"
1501 };
1502
1503 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
1504 #endif // 0