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