src/basic/process-util.c

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