src/basic/process-util.c

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