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