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 void sigterm_wait(pid_t pid) {
 817         assert(pid > 1);
 818
 819         if (kill_and_sigcont(pid, SIGTERM) > 0)
 820                 (void) wait_for_terminate(pid, NULL);
 821 }
 822
 823 int kill_and_sigcont(pid_t pid, int sig) {
 824         int r;
 825
 826         r = kill(pid, sig) < 0 ? -errno : 0;
 827
 828         /* If this worked, also send SIGCONT, unless we already just sent a SIGCONT, or SIGKILL was sent which isn't
 829          * affected by a process being suspended anyway. */
 830         if (r >= 0 && !IN_SET(sig, SIGCONT, SIGKILL))
 831                 (void) kill(pid, SIGCONT);
 832
 833         return r;
 834 }
 835 #endif // 0
 836
 837 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
 838         _cleanup_fclose_ FILE *f = NULL;
 839         char *value = NULL;
 840         int r;
 841         bool done = false;
 842         size_t l;
 843         const char *path;
 844
 845         assert(pid >= 0);
 846         assert(field);
 847         assert(_value);
 848
 849         path = procfs_file_alloca(pid, "environ");
 850
 851         f = fopen(path, "re");
 852         if (!f) {
 853                 if (errno == ENOENT)
 854                         return -ESRCH;
 855                 return -errno;
 856         }
 857
 858         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 859
 860         l = strlen(field);
 861         r = 0;
 862
 863         do {
 864                 char line[LINE_MAX];
 865                 unsigned i;
 866
 867                 for (i = 0; i < sizeof(line)-1; i++) {
 868                         int c;
 869
 870                         c = getc(f);
 871                         if (_unlikely_(c == EOF)) {
 872                                 done = true;
 873                                 break;
 874                         } else if (c == 0)
 875                                 break;
 876
 877                         line[i] = c;
 878                 }
 879                 line[i] = 0;
 880
 881                 if (strneq(line, field, l) && line[l] == '=') {
 882                         value = strdup(line + l + 1);
 883                         if (!value)
 884                                 return -ENOMEM;
 885
 886                         r = 1;
 887                         break;
 888                 }
 889
 890         } while (!done);
 891
 892         *_value = value;
 893         return r;
 894 }
 895
 896 bool pid_is_unwaited(pid_t pid) {
 897         /* Checks whether a PID is still valid at all, including a zombie */
 898
 899         if (pid < 0)
 900                 return false;
 901
 902         if (pid <= 1) /* If we or PID 1 would be dead and have been waited for, this code would not be running */
 903                 return true;
 904
 905         if (pid == getpid_cached())
 906                 return true;
 907
 908         if (kill(pid, 0) >= 0)
 909                 return true;
 910
 911         return errno != ESRCH;
 912 }
 913
 914 bool pid_is_alive(pid_t pid) {
 915         int r;
 916
 917         /* Checks whether a PID is still valid and not a zombie */
 918
 919         if (pid < 0)
 920                 return false;
 921
 922         if (pid <= 1) /* If we or PID 1 would be a zombie, this code would not be running */
 923                 return true;
 924
 925         if (pid == getpid_cached())
 926                 return true;
 927
 928         r = get_process_state(pid);
 929         if (IN_SET(r, -ESRCH, 'Z'))
 930                 return false;
 931
 932         return true;
 933 }
 934
 935 #if 0 /// UNNEEDED by elogind
 936 int pid_from_same_root_fs(pid_t pid) {
 937         const char *root;
 938
 939         if (pid < 0)
 940                 return false;
 941
 942         if (pid == 0 || pid == getpid_cached())
 943                 return true;
 944
 945         root = procfs_file_alloca(pid, "root");
 946
 947         return files_same(root, "/proc/1/root", 0);
 948 }
 949 #endif // 0
 950
 951 bool is_main_thread(void) {
 952         static thread_local int cached = 0;
 953
 954         if (_unlikely_(cached == 0))
 955                 cached = getpid_cached() == gettid() ? 1 : -1;
 956
 957         return cached > 0;
 958 }
 959
 960 #if 0 /// UNNEEDED by elogind
 961 noreturn void freeze(void) {
 962
 963         log_close();
 964
 965         /* Make sure nobody waits for us on a socket anymore */
 966         close_all_fds(NULL, 0);
 967
 968         sync();
 969
 970         /* Let's not freeze right away, but keep reaping zombies. */
 971         for (;;) {
 972                 int r;
 973                 siginfo_t si = {};
 974
 975                 r = waitid(P_ALL, 0, &si, WEXITED);
 976                 if (r < 0 && errno != EINTR)
 977                         break;
 978         }
 979
 980         /* waitid() failed with an unexpected error, things are really borked. Freeze now! */
 981         for (;;)
 982                 pause();
 983 }
 984
 985 bool oom_score_adjust_is_valid(int oa) {
 986         return oa >= OOM_SCORE_ADJ_MIN && oa <= OOM_SCORE_ADJ_MAX;
 987 }
 988
 989 unsigned long personality_from_string(const char *p) {
 990         int architecture;
 991
 992         if (!p)
 993                 return PERSONALITY_INVALID;
 994
 995         /* Parse a personality specifier. We use our own identifiers that indicate specific ABIs, rather than just
 996          * hints regarding the register size, since we want to keep things open for multiple locally supported ABIs for
 997          * the same register size. */
 998
 999         architecture = architecture_from_string(p);
1000         if (architecture < 0)
1001                 return PERSONALITY_INVALID;
1002
1003         if (architecture == native_architecture())
1004                 return PER_LINUX;
1005 #ifdef SECONDARY_ARCHITECTURE
1006         if (architecture == SECONDARY_ARCHITECTURE)
1007                 return PER_LINUX32;
1008 #endif
1009
1010         return PERSONALITY_INVALID;
1011 }
1012
1013 const char* personality_to_string(unsigned long p) {
1014         int architecture = _ARCHITECTURE_INVALID;
1015
1016         if (p == PER_LINUX)
1017                 architecture = native_architecture();
1018 #ifdef SECONDARY_ARCHITECTURE
1019         else if (p == PER_LINUX32)
1020                 architecture = SECONDARY_ARCHITECTURE;
1021 #endif
1022
1023         if (architecture < 0)
1024                 return NULL;
1025
1026         return architecture_to_string(architecture);
1027 }
1028
1029 int safe_personality(unsigned long p) {
1030         int ret;
1031
1032         /* So here's the deal, personality() is weirdly defined by glibc. In some cases it returns a failure via errno,
1033          * and in others as negative return value containing an errno-like value. Let's work around this: this is a
1034          * wrapper that uses errno if it is set, and uses the return value otherwise. And then it sets both errno and
1035          * the return value indicating the same issue, so that we are definitely on the safe side.
1036          *
1037          * See https://github.com/systemd/systemd/issues/6737 */
1038
1039         errno = 0;
1040         ret = personality(p);
1041         if (ret < 0) {
1042                 if (errno != 0)
1043                         return -errno;
1044
1045                 errno = -ret;
1046         }
1047
1048         return ret;
1049 }
1050
1051 int opinionated_personality(unsigned long *ret) {
1052         int current;
1053
1054         /* Returns the current personality, or PERSONALITY_INVALID if we can't determine it. This function is a bit
1055          * opinionated though, and ignores all the finer-grained bits and exotic personalities, only distinguishing the
1056          * two most relevant personalities: PER_LINUX and PER_LINUX32. */
1057
1058         current = safe_personality(PERSONALITY_INVALID);
1059         if (current < 0)
1060                 return current;
1061
1062         if (((unsigned long) current & 0xffff) == PER_LINUX32)
1063                 *ret = PER_LINUX32;
1064         else
1065                 *ret = PER_LINUX;
1066
1067         return 0;
1068 }
1069
1070 void valgrind_summary_hack(void) {
1071 #if HAVE_VALGRIND_VALGRIND_H
1072         if (getpid_cached() == 1 && RUNNING_ON_VALGRIND) {
1073                 pid_t pid;
1074                 pid = raw_clone(SIGCHLD);
1075                 if (pid < 0)
1076                         log_emergency_errno(errno, "Failed to fork off valgrind helper: %m");
1077                 else if (pid == 0)
1078                         exit(EXIT_SUCCESS);
1079                 else {
1080                         log_info("Spawned valgrind helper as PID "PID_FMT".", pid);
1081                         (void) wait_for_terminate(pid, NULL);
1082                 }
1083         }
1084 #endif
1085 }
1086
1087 int pid_compare_func(const void *a, const void *b) {
1088         const pid_t *p = a, *q = b;
1089
1090         /* Suitable for usage in qsort() */
1091
1092         if (*p < *q)
1093                 return -1;
1094         if (*p > *q)
1095                 return 1;
1096         return 0;
1097 }
1098
1099 int ioprio_parse_priority(const char *s, int *ret) {
1100         int i, r;
1101
1102         assert(s);
1103         assert(ret);
1104
1105         r = safe_atoi(s, &i);
1106         if (r < 0)
1107                 return r;
1108
1109         if (!ioprio_priority_is_valid(i))
1110                 return -EINVAL;
1111
1112         *ret = i;
1113         return 0;
1114 }
1115 #endif // 0
1116
1117 /* The cached PID, possible values:
1118  *
1119  *     == UNSET [0]  → cache not initialized yet
1120  *     == BUSY [-1]  → some thread is initializing it at the moment
1121  *     any other     → the cached PID
1122  */
1123
1124 #define CACHED_PID_UNSET ((pid_t) 0)
1125 #define CACHED_PID_BUSY ((pid_t) -1)
1126
1127 static pid_t cached_pid = CACHED_PID_UNSET;
1128
1129 void reset_cached_pid(void) {
1130         /* Invoked in the child after a fork(), i.e. at the first moment the PID changed */
1131         cached_pid = CACHED_PID_UNSET;
1132 }
1133
1134 /* We use glibc __register_atfork() + __dso_handle directly here, as they are not included in the glibc
1135  * headers. __register_atfork() is mostly equivalent to pthread_atfork(), but doesn't require us to link against
1136  * libpthread, as it is part of glibc anyway. */
1137 #ifdef __GLIBC__
1138 extern int __register_atfork(void (*prepare) (void), void (*parent) (void), void (*child) (void), void * __dso_handle);
1139 extern void* __dso_handle __attribute__ ((__weak__));
1140 #endif // ifdef __GLIBC__
1141
1142 pid_t getpid_cached(void) {
1143         pid_t current_value;
1144
1145         /* getpid_cached() is much like getpid(), but caches the value in local memory, to avoid having to invoke a
1146          * system call each time. This restores glibc behaviour from before 2.24, when getpid() was unconditionally
1147          * cached. Starting with 2.24 getpid() started to become prohibitively expensive when used for detecting when
1148          * objects were used across fork()s. With this caching the old behaviour is somewhat restored.
1149          *
1150          * https://bugzilla.redhat.com/show_bug.cgi?id=1443976
1151          * https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=c579f48edba88380635ab98cb612030e3ed8691e
1152          */
1153
1154         current_value = __sync_val_compare_and_swap(&cached_pid, CACHED_PID_UNSET, CACHED_PID_BUSY);
1155
1156         switch (current_value) {
1157
1158         case CACHED_PID_UNSET: { /* Not initialized yet, then do so now */
1159                 pid_t new_pid;
1160
1161                 new_pid = raw_getpid();
1162
1163                 if (__register_atfork(NULL, NULL, reset_cached_pid, __dso_handle) != 0) {
1164                         /* OOM? Let's try again later */
1165                         cached_pid = CACHED_PID_UNSET;
1166                         return new_pid;
1167                 }
1168
1169                 cached_pid = new_pid;
1170                 return new_pid;
1171         }
1172
1173         case CACHED_PID_BUSY: /* Somebody else is currently initializing */
1174                 return raw_getpid();
1175
1176         default: /* Properly initialized */
1177                 return current_value;
1178         }
1179 }
1180
1181 int must_be_root(void) {
1182
1183         if (geteuid() == 0)
1184                 return 0;
1185
1186         log_error("Need to be root.");
1187         return -EPERM;
1188 }
1189
1190 int safe_fork_full(
1191                 const char *name,
1192                 const int except_fds[],
1193                 size_t n_except_fds,
1194                 ForkFlags flags,
1195                 pid_t *ret_pid) {
1196
1197         pid_t original_pid, pid;
1198         sigset_t saved_ss, ss;
1199         bool block_signals = false;
1200         int prio, r;
1201
1202         /* A wrapper around fork(), that does a couple of important initializations in addition to mere forking. Always
1203          * returns the child's PID in *ret_pid. Returns == 0 in the child, and > 0 in the parent. */
1204
1205         prio = flags & FORK_LOG ? LOG_ERR : LOG_DEBUG;
1206
1207         original_pid = getpid_cached();
1208
1209         if (flags & (FORK_RESET_SIGNALS|FORK_DEATHSIG)) {
1210
1211                 /* We temporarily block all signals, so that the new child has them blocked initially. This way, we can
1212                  * be sure that SIGTERMs are not lost we might send to the child. */
1213
1214                 if (sigfillset(&ss) < 0)
1215                         return log_full_errno(prio, errno, "Failed to reset signal set: %m");
1216
1217                 block_signals = true;
1218
1219         } else if (flags & FORK_WAIT) {
1220
1221                 /* Let's block SIGCHLD at least, so that we can safely watch for the child process */
1222
1223                 if (sigemptyset(&ss) < 0)
1224                         return log_full_errno(prio, errno, "Failed to clear signal set: %m");
1225
1226                 if (sigaddset(&ss, SIGCHLD) < 0)
1227                         return log_full_errno(prio, errno, "Failed to add SIGCHLD to signal set: %m");
1228
1229                 block_signals = true;
1230         }
1231
1232         if (block_signals)
1233                 if (sigprocmask(SIG_SETMASK, &ss, &saved_ss) < 0)
1234                         return log_full_errno(prio, errno, "Failed to set signal mask: %m");
1235
1236         if (flags & FORK_NEW_MOUNTNS)
1237                 pid = raw_clone(SIGCHLD|CLONE_NEWNS);
1238         else
1239                 pid = fork();
1240         if (pid < 0) {
1241                 r = -errno;
1242
1243                 if (block_signals) /* undo what we did above */
1244                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1245
1246                 return log_full_errno(prio, r, "Failed to fork: %m");
1247         }
1248         if (pid > 0) {
1249                 /* We are in the parent process */
1250
1251                 log_debug("Successfully forked off '%s' as PID " PID_FMT ".", strna(name), pid);
1252
1253                 if (flags & FORK_WAIT) {
1254                         r = wait_for_terminate_and_check(name, pid, (flags & FORK_LOG ? WAIT_LOG : 0));
1255                         if (r < 0)
1256                                 return r;
1257                         if (r != EXIT_SUCCESS) /* exit status > 0 should be treated as failure, too */
1258                                 return -EPROTO;
1259                 }
1260
1261                 if (block_signals) /* undo what we did above */
1262                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1263
1264                 if (ret_pid)
1265                         *ret_pid = pid;
1266
1267                 return 1;
1268         }
1269
1270         /* We are in the child process */
1271
1272         if (flags & FORK_REOPEN_LOG) {
1273                 /* Close the logs if requested, before we log anything. And make sure we reopen it if needed. */
1274                 log_close();
1275                 log_set_open_when_needed(true);
1276         }
1277
1278         if (name) {
1279                 r = rename_process(name);
1280                 if (r < 0)
1281                         log_full_errno(flags & FORK_LOG ? LOG_WARNING : LOG_DEBUG,
1282                                        r, "Failed to rename process, ignoring: %m");
1283         }
1284
1285         if (flags & FORK_DEATHSIG)
1286                 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0) {
1287                         log_full_errno(prio, errno, "Failed to set death signal: %m");
1288                         _exit(EXIT_FAILURE);
1289                 }
1290
1291         if (flags & FORK_RESET_SIGNALS) {
1292                 r = reset_all_signal_handlers();
1293                 if (r < 0) {
1294                         log_full_errno(prio, r, "Failed to reset signal handlers: %m");
1295                         _exit(EXIT_FAILURE);
1296                 }
1297
1298                 /* This implicitly undoes the signal mask stuff we did before the fork()ing above */
1299                 r = reset_signal_mask();
1300                 if (r < 0) {
1301                         log_full_errno(prio, r, "Failed to reset signal mask: %m");
1302                         _exit(EXIT_FAILURE);
1303                 }
1304         } else if (block_signals) { /* undo what we did above */
1305                 if (sigprocmask(SIG_SETMASK, &saved_ss, NULL) < 0) {
1306                         log_full_errno(prio, errno, "Failed to restore signal mask: %m");
1307                         _exit(EXIT_FAILURE);
1308                 }
1309         }
1310
1311         if (flags & FORK_DEATHSIG) {
1312                 pid_t ppid;
1313                 /* Let's see if the parent PID is still the one we started from? If not, then the parent
1314                  * already died by the time we set PR_SET_PDEATHSIG, hence let's emulate the effect */
1315
1316                 ppid = getppid();
1317                 if (ppid == 0)
1318                         /* Parent is in a differn't PID namespace. */;
1319                 else if (ppid != original_pid) {
1320                         log_debug("Parent died early, raising SIGTERM.");
1321                         (void) raise(SIGTERM);
1322                         _exit(EXIT_FAILURE);
1323                 }
1324         }
1325
1326         if (flags & FORK_CLOSE_ALL_FDS) {
1327                 /* Close the logs here in case it got reopened above, as close_all_fds() would close them for us */
1328                 log_close();
1329
1330                 r = close_all_fds(except_fds, n_except_fds);
1331                 if (r < 0) {
1332                         log_full_errno(prio, r, "Failed to close all file descriptors: %m");
1333                         _exit(EXIT_FAILURE);
1334                 }
1335         }
1336
1337         /* When we were asked to reopen the logs, do so again now */
1338         if (flags & FORK_REOPEN_LOG) {
1339                 log_open();
1340                 log_set_open_when_needed(false);
1341         }
1342
1343         if (flags & FORK_NULL_STDIO) {
1344                 r = make_null_stdio();
1345                 if (r < 0) {
1346                         log_full_errno(prio, r, "Failed to connect stdin/stdout to /dev/null: %m");
1347                         _exit(EXIT_FAILURE);
1348                 }
1349         }
1350
1351         if (ret_pid)
1352                 *ret_pid = getpid_cached();
1353
1354         return 0;
1355 }
1356
1357 int fork_agent(const char *name, const int except[], unsigned n_except, pid_t *ret_pid, const char *path, ...) {
1358         bool stdout_is_tty, stderr_is_tty;
1359         unsigned n, i;
1360         va_list ap;
1361         char **l;
1362         int r;
1363
1364         assert(path);
1365
1366         /* Spawns a temporary TTY agent, making sure it goes away when we go away */
1367
1368         r = safe_fork_full(name, except, n_except, FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_CLOSE_ALL_FDS, ret_pid);
1369         if (r < 0)
1370                 return r;
1371         if (r > 0)
1372                 return 0;
1373
1374         /* In the child: */
1375
1376         stdout_is_tty = isatty(STDOUT_FILENO);
1377         stderr_is_tty = isatty(STDERR_FILENO);
1378
1379         if (!stdout_is_tty || !stderr_is_tty) {
1380                 int fd;
1381
1382                 /* Detach from stdout/stderr. and reopen
1383                  * /dev/tty for them. This is important to
1384                  * ensure that when systemctl is started via
1385                  * popen() or a similar call that expects to
1386                  * read EOF we actually do generate EOF and
1387                  * not delay this indefinitely by because we
1388                  * keep an unused copy of stdin around. */
1389                 fd = open("/dev/tty", O_WRONLY);
1390                 if (fd < 0) {
1391                         log_error_errno(errno, "Failed to open /dev/tty: %m");
1392                         _exit(EXIT_FAILURE);
1393                 }
1394
1395                 if (!stdout_is_tty && dup2(fd, STDOUT_FILENO) < 0) {
1396                         log_error_errno(errno, "Failed to dup2 /dev/tty: %m");
1397                         _exit(EXIT_FAILURE);
1398                 }
1399
1400                 if (!stderr_is_tty && dup2(fd, STDERR_FILENO) < 0) {
1401                         log_error_errno(errno, "Failed to dup2 /dev/tty: %m");
1402                         _exit(EXIT_FAILURE);
1403                 }
1404
1405                 if (fd > STDERR_FILENO)
1406                         close(fd);
1407         }
1408
1409         /* Count arguments */
1410         va_start(ap, path);
1411         for (n = 0; va_arg(ap, char*); n++)
1412                 ;
1413         va_end(ap);
1414
1415         /* Allocate strv */
1416         l = alloca(sizeof(char *) * (n + 1));
1417
1418         /* Fill in arguments */
1419         va_start(ap, path);
1420         for (i = 0; i <= n; i++)
1421                 l[i] = va_arg(ap, char*);
1422         va_end(ap);
1423
1424         execv(path, l);
1425         _exit(EXIT_FAILURE);
1426 }
1427
1428 #if 0 /// UNNEEDED by elogind
1429 static const char *const ioprio_class_table[] = {
1430         [IOPRIO_CLASS_NONE] = "none",
1431         [IOPRIO_CLASS_RT] = "realtime",
1432         [IOPRIO_CLASS_BE] = "best-effort",
1433         [IOPRIO_CLASS_IDLE] = "idle"
1434 };
1435
1436 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
1437
1438 static const char *const sigchld_code_table[] = {
1439         [CLD_EXITED] = "exited",
1440         [CLD_KILLED] = "killed",
1441         [CLD_DUMPED] = "dumped",
1442         [CLD_TRAPPED] = "trapped",
1443         [CLD_STOPPED] = "stopped",
1444         [CLD_CONTINUED] = "continued",
1445 };
1446
1447 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
1448
1449 static const char* const sched_policy_table[] = {
1450         [SCHED_OTHER] = "other",
1451         [SCHED_BATCH] = "batch",
1452         [SCHED_IDLE] = "idle",
1453         [SCHED_FIFO] = "fifo",
1454         [SCHED_RR] = "rr"
1455 };
1456
1457 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
1458 #endif // 0