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