src/basic/process-util.c

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