src/basic/process-util.c

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