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         l = strlen(name);
 302
 303         /* First step, change the comm field. */
 304         (void) prctl(PR_SET_NAME, name);
 305         if (l > 15) /* Linux process names can be 15 chars at max */
 306                 truncated = true;
 307
 308         /* Second step, change glibc's ID of the process name. */
 309         if (program_invocation_name) {
 310                 size_t k;
 311
 312                 k = strlen(program_invocation_name);
 313                 strncpy(program_invocation_name, name, k);
 314                 if (l > k)
 315                         truncated = true;
 316         }
 317
 318         /* Third step, completely replace the argv[] array the kernel maintains for us. This requires privileges, but
 319          * has the advantage that the argv[] array is exactly what we want it to be, and not filled up with zeros at
 320          * the end. This is the best option for changing /proc/self/cmdline. */
 321
 322         /* Let's not bother with this if we don't have euid == 0. Strictly speaking we should check for the
 323          * CAP_SYS_RESOURCE capability which is independent of the euid. In our own code the capability generally is
 324          * present only for euid == 0, hence let's use this as quick bypass check, to avoid calling mmap() if
 325          * PR_SET_MM_ARG_{START,END} fails with EPERM later on anyway. After all geteuid() is dead cheap to call, but
 326          * mmap() is not. */
 327         if (geteuid() != 0)
 328                 log_debug("Skipping PR_SET_MM, as we don't have privileges.");
 329         else if (mm_size < l+1) {
 330                 size_t nn_size;
 331                 char *nn;
 332
 333                 nn_size = PAGE_ALIGN(l+1);
 334                 nn = mmap(NULL, nn_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 335                 if (nn == MAP_FAILED) {
 336                         log_debug_errno(errno, "mmap() failed: %m");
 337                         goto use_saved_argv;
 338                 }
 339
 340                 strncpy(nn, name, nn_size);
 341
 342                 /* Now, let's tell the kernel about this new memory */
 343                 if (prctl(PR_SET_MM, PR_SET_MM_ARG_START, (unsigned long) nn, 0, 0) < 0) {
 344                         log_debug_errno(errno, "PR_SET_MM_ARG_START failed, proceeding without: %m");
 345                         (void) munmap(nn, nn_size);
 346                         goto use_saved_argv;
 347                 }
 348
 349                 /* And update the end pointer to the new end, too. If this fails, we don't really know what to do, it's
 350                  * pretty unlikely that we can rollback, hence we'll just accept the failure, and continue. */
 351                 if (prctl(PR_SET_MM, PR_SET_MM_ARG_END, (unsigned long) nn + l + 1, 0, 0) < 0)
 352                         log_debug_errno(errno, "PR_SET_MM_ARG_END failed, proceeding without: %m");
 353
 354                 if (mm)
 355                         (void) munmap(mm, mm_size);
 356
 357                 mm = nn;
 358                 mm_size = nn_size;
 359         } else {
 360                 strncpy(mm, name, mm_size);
 361
 362                 /* Update the end pointer, continuing regardless of any failure. */
 363                 if (prctl(PR_SET_MM, PR_SET_MM_ARG_END, (unsigned long) mm + l + 1, 0, 0) < 0)
 364                         log_debug_errno(errno, "PR_SET_MM_ARG_END failed, proceeding without: %m");
 365         }
 366
 367 use_saved_argv:
 368         /* Fourth step: in all cases we'll also update the original argv[], so that our own code gets it right too if
 369          * it still looks here */
 370
 371         if (saved_argc > 0) {
 372                 int i;
 373
 374                 if (saved_argv[0]) {
 375                         size_t k;
 376
 377                         k = strlen(saved_argv[0]);
 378                         strncpy(saved_argv[0], name, k);
 379                         if (l > k)
 380                                 truncated = true;
 381                 }
 382
 383                 for (i = 1; i < saved_argc; i++) {
 384                         if (!saved_argv[i])
 385                                 break;
 386
 387                         memzero(saved_argv[i], strlen(saved_argv[i]));
 388                 }
 389         }
 390
 391         return !truncated;
 392 }
 393 #endif // 0
 394
 395 int is_kernel_thread(pid_t pid) {
 396         const char *p;
 397         size_t count;
 398         char c;
 399         bool eof;
 400         FILE *f;
 401
 402         if (IN_SET(pid, 0, 1) || pid == getpid_cached()) /* pid 1, and we ourselves certainly aren't a kernel thread */
 403                 return 0;
 404
 405         assert(pid > 1);
 406
 407         p = procfs_file_alloca(pid, "cmdline");
 408         f = fopen(p, "re");
 409         if (!f) {
 410                 if (errno == ENOENT)
 411                         return -ESRCH;
 412                 return -errno;
 413         }
 414
 415         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 416
 417         count = fread(&c, 1, 1, f);
 418         eof = feof(f);
 419         fclose(f);
 420
 421         /* Kernel threads have an empty cmdline */
 422
 423         if (count <= 0)
 424                 return eof ? 1 : -errno;
 425
 426         return 0;
 427 }
 428
 429 #if 0 /// UNNEEDED by elogind
 430 int get_process_capeff(pid_t pid, char **capeff) {
 431         const char *p;
 432         int r;
 433
 434         assert(capeff);
 435         assert(pid >= 0);
 436
 437         p = procfs_file_alloca(pid, "status");
 438
 439         r = get_proc_field(p, "CapEff", WHITESPACE, capeff);
 440         if (r == -ENOENT)
 441                 return -ESRCH;
 442
 443         return r;
 444 }
 445 #endif // 0
 446
 447 static int get_process_link_contents(const char *proc_file, char **name) {
 448         int r;
 449
 450         assert(proc_file);
 451         assert(name);
 452
 453         r = readlink_malloc(proc_file, name);
 454         if (r == -ENOENT)
 455                 return -ESRCH;
 456         if (r < 0)
 457                 return r;
 458
 459         return 0;
 460 }
 461
 462 int get_process_exe(pid_t pid, char **name) {
 463         const char *p;
 464         char *d;
 465         int r;
 466
 467         assert(pid >= 0);
 468
 469         p = procfs_file_alloca(pid, "exe");
 470         r = get_process_link_contents(p, name);
 471         if (r < 0)
 472                 return r;
 473
 474         d = endswith(*name, " (deleted)");
 475         if (d)
 476                 *d = '\0';
 477
 478         return 0;
 479 }
 480
 481 #if 0 /// UNNEEDED by elogind
 482 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
 483         _cleanup_fclose_ FILE *f = NULL;
 484         char line[LINE_MAX];
 485         const char *p;
 486
 487         assert(field);
 488         assert(uid);
 489
 490         if (pid < 0)
 491                 return -EINVAL;
 492
 493         p = procfs_file_alloca(pid, "status");
 494         f = fopen(p, "re");
 495         if (!f) {
 496                 if (errno == ENOENT)
 497                         return -ESRCH;
 498                 return -errno;
 499         }
 500
 501         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 502
 503         FOREACH_LINE(line, f, return -errno) {
 504                 char *l;
 505
 506                 l = strstrip(line);
 507
 508                 if (startswith(l, field)) {
 509                         l += strlen(field);
 510                         l += strspn(l, WHITESPACE);
 511
 512                         l[strcspn(l, WHITESPACE)] = 0;
 513
 514                         return parse_uid(l, uid);
 515                 }
 516         }
 517
 518         return -EIO;
 519 }
 520
 521 int get_process_uid(pid_t pid, uid_t *uid) {
 522
 523         if (pid == 0 || pid == getpid_cached()) {
 524                 *uid = getuid();
 525                 return 0;
 526         }
 527
 528         return get_process_id(pid, "Uid:", uid);
 529 }
 530
 531 int get_process_gid(pid_t pid, gid_t *gid) {
 532
 533         if (pid == 0 || pid == getpid_cached()) {
 534                 *gid = getgid();
 535                 return 0;
 536         }
 537
 538         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 539         return get_process_id(pid, "Gid:", gid);
 540 }
 541
 542 int get_process_cwd(pid_t pid, char **cwd) {
 543         const char *p;
 544
 545         assert(pid >= 0);
 546
 547         p = procfs_file_alloca(pid, "cwd");
 548
 549         return get_process_link_contents(p, cwd);
 550 }
 551
 552 int get_process_root(pid_t pid, char **root) {
 553         const char *p;
 554
 555         assert(pid >= 0);
 556
 557         p = procfs_file_alloca(pid, "root");
 558
 559         return get_process_link_contents(p, root);
 560 }
 561
 562 int get_process_environ(pid_t pid, char **env) {
 563         _cleanup_fclose_ FILE *f = NULL;
 564         _cleanup_free_ char *outcome = NULL;
 565         int c;
 566         const char *p;
 567         size_t allocated = 0, sz = 0;
 568
 569         assert(pid >= 0);
 570         assert(env);
 571
 572         p = procfs_file_alloca(pid, "environ");
 573
 574         f = fopen(p, "re");
 575         if (!f) {
 576                 if (errno == ENOENT)
 577                         return -ESRCH;
 578                 return -errno;
 579         }
 580
 581         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 582
 583         while ((c = fgetc(f)) != EOF) {
 584                 if (!GREEDY_REALLOC(outcome, allocated, sz + 5))
 585                         return -ENOMEM;
 586
 587                 if (c == '\0')
 588                         outcome[sz++] = '\n';
 589                 else
 590                         sz += cescape_char(c, outcome + sz);
 591         }
 592
 593         if (!outcome) {
 594                 outcome = strdup("");
 595                 if (!outcome)
 596                         return -ENOMEM;
 597         } else
 598                 outcome[sz] = '\0';
 599
 600         *env = outcome;
 601         outcome = NULL;
 602
 603         return 0;
 604 }
 605
 606 int get_process_ppid(pid_t pid, pid_t *_ppid) {
 607         int r;
 608         _cleanup_free_ char *line = NULL;
 609         long unsigned ppid;
 610         const char *p;
 611
 612         assert(pid >= 0);
 613         assert(_ppid);
 614
 615         if (pid == 0 || pid == getpid_cached()) {
 616                 *_ppid = getppid();
 617                 return 0;
 618         }
 619
 620         p = procfs_file_alloca(pid, "stat");
 621         r = read_one_line_file(p, &line);
 622         if (r == -ENOENT)
 623                 return -ESRCH;
 624         if (r < 0)
 625                 return r;
 626
 627         /* Let's skip the pid and comm fields. The latter is enclosed
 628          * in () but does not escape any () in its value, so let's
 629          * skip over it manually */
 630
 631         p = strrchr(line, ')');
 632         if (!p)
 633                 return -EIO;
 634
 635         p++;
 636
 637         if (sscanf(p, " "
 638                    "%*c "  /* state */
 639                    "%lu ", /* ppid */
 640                    &ppid) != 1)
 641                 return -EIO;
 642
 643         if ((long unsigned) (pid_t) ppid != ppid)
 644                 return -ERANGE;
 645
 646         *_ppid = (pid_t) ppid;
 647
 648         return 0;
 649 }
 650 #endif // 0
 651
 652 int wait_for_terminate(pid_t pid, siginfo_t *status) {
 653         siginfo_t dummy;
 654
 655         assert(pid >= 1);
 656
 657         if (!status)
 658                 status = &dummy;
 659
 660         for (;;) {
 661                 zero(*status);
 662
 663                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
 664
 665                         if (errno == EINTR)
 666                                 continue;
 667
 668                         return negative_errno();
 669                 }
 670
 671                 return 0;
 672         }
 673 }
 674
 675 /*
 676  * Return values:
 677  * < 0 : wait_for_terminate() failed to get the state of the
 678  *       process, the process was terminated by a signal, or
 679  *       failed for an unknown reason.
 680  * >=0 : The process terminated normally, and its exit code is
 681  *       returned.
 682  *
 683  * That is, success is indicated by a return value of zero, and an
 684  * error is indicated by a non-zero value.
 685  *
 686  * A warning is emitted if the process terminates abnormally,
 687  * and also if it returns non-zero unless check_exit_code is true.
 688  */
 689 int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {
 690         int r;
 691         siginfo_t status;
 692
 693         assert(name);
 694         assert(pid > 1);
 695
 696         r = wait_for_terminate(pid, &status);
 697         if (r < 0)
 698                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
 699
 700         if (status.si_code == CLD_EXITED) {
 701                 if (status.si_status != 0)
 702                         log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
 703                                  "%s failed with error code %i.", name, status.si_status);
 704                 else
 705                         log_debug("%s succeeded.", name);
 706
 707                 return status.si_status;
 708         } else if (IN_SET(status.si_code, CLD_KILLED, CLD_DUMPED)) {
 709
 710                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
 711                 return -EPROTO;
 712         }
 713
 714         log_warning("%s failed due to unknown reason.", name);
 715         return -EPROTO;
 716 }
 717
 718 /*
 719  * Return values:
 720  * < 0 : wait_for_terminate_with_timeout() failed to get the state of the
 721  *       process, the process timed out, the process was terminated by a
 722  *       signal, or failed for an unknown reason.
 723  * >=0 : The process terminated normally with no failures.
 724  *
 725  * Success is indicated by a return value of zero, a timeout is indicated
 726  * by ETIMEDOUT, and all other child failure states are indicated by error
 727  * is indicated by a non-zero value.
 728  */
 729 int wait_for_terminate_with_timeout(pid_t pid, usec_t timeout) {
 730         sigset_t mask;
 731         int r;
 732         usec_t until;
 733
 734         assert_se(sigemptyset(&mask) == 0);
 735         assert_se(sigaddset(&mask, SIGCHLD) == 0);
 736
 737         /* Drop into a sigtimewait-based timeout. Waiting for the
 738          * pid to exit. */
 739         until = now(CLOCK_MONOTONIC) + timeout;
 740         for (;;) {
 741                 usec_t n;
 742                 siginfo_t status = {};
 743                 struct timespec ts;
 744
 745                 n = now(CLOCK_MONOTONIC);
 746                 if (n >= until)
 747                         break;
 748
 749                 r = sigtimedwait(&mask, NULL, timespec_store(&ts, until - n)) < 0 ? -errno : 0;
 750                 /* Assuming we woke due to the child exiting. */
 751                 if (waitid(P_PID, pid, &status, WEXITED|WNOHANG) == 0) {
 752                         if (status.si_pid == pid) {
 753                                 /* This is the correct child.*/
 754                                 if (status.si_code == CLD_EXITED)
 755                                         return (status.si_status == 0) ? 0 : -EPROTO;
 756                                 else
 757                                         return -EPROTO;
 758                         }
 759                 }
 760                 /* Not the child, check for errors and proceed appropriately */
 761                 if (r < 0) {
 762                         switch (r) {
 763                         case -EAGAIN:
 764                                 /* Timed out, child is likely hung. */
 765                                 return -ETIMEDOUT;
 766                         case -EINTR:
 767                                 /* Received a different signal and should retry */
 768                                 continue;
 769                         default:
 770                                 /* Return any unexpected errors */
 771                                 return r;
 772                         }
 773                 }
 774         }
 775
 776         return -EPROTO;
 777 }
 778
 779 #if 0 /// UNNEEDED by elogind
 780 void sigkill_wait(pid_t pid) {
 781         assert(pid > 1);
 782
 783         if (kill(pid, SIGKILL) > 0)
 784                 (void) wait_for_terminate(pid, NULL);
 785 }
 786
 787 void sigkill_waitp(pid_t *pid) {
 788         if (!pid)
 789                 return;
 790         if (*pid <= 1)
 791                 return;
 792
 793         sigkill_wait(*pid);
 794 }
 795
 796 int kill_and_sigcont(pid_t pid, int sig) {
 797         int r;
 798
 799         r = kill(pid, sig) < 0 ? -errno : 0;
 800
 801         /* If this worked, also send SIGCONT, unless we already just sent a SIGCONT, or SIGKILL was sent which isn't
 802          * affected by a process being suspended anyway. */
 803         if (r >= 0 && !IN_SET(sig, SIGCONT, SIGKILL))
 804                 (void) kill(pid, SIGCONT);
 805
 806         return r;
 807 }
 808 #endif // 0
 809
 810 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
 811         _cleanup_fclose_ FILE *f = NULL;
 812         char *value = NULL;
 813         int r;
 814         bool done = false;
 815         size_t l;
 816         const char *path;
 817
 818         assert(pid >= 0);
 819         assert(field);
 820         assert(_value);
 821
 822         path = procfs_file_alloca(pid, "environ");
 823
 824         f = fopen(path, "re");
 825         if (!f) {
 826                 if (errno == ENOENT)
 827                         return -ESRCH;
 828                 return -errno;
 829         }
 830
 831         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 832
 833         l = strlen(field);
 834         r = 0;
 835
 836         do {
 837                 char line[LINE_MAX];
 838                 unsigned i;
 839
 840                 for (i = 0; i < sizeof(line)-1; i++) {
 841                         int c;
 842
 843                         c = getc(f);
 844                         if (_unlikely_(c == EOF)) {
 845                                 done = true;
 846                                 break;
 847                         } else if (c == 0)
 848                                 break;
 849
 850                         line[i] = c;
 851                 }
 852                 line[i] = 0;
 853
 854                 if (strneq(line, field, l) && line[l] == '=') {
 855                         value = strdup(line + l + 1);
 856                         if (!value)
 857                                 return -ENOMEM;
 858
 859                         r = 1;
 860                         break;
 861                 }
 862
 863         } while (!done);
 864
 865         *_value = value;
 866         return r;
 867 }
 868
 869 bool pid_is_unwaited(pid_t pid) {
 870         /* Checks whether a PID is still valid at all, including a zombie */
 871
 872         if (pid < 0)
 873                 return false;
 874
 875         if (pid <= 1) /* If we or PID 1 would be dead and have been waited for, this code would not be running */
 876                 return true;
 877
 878         if (pid == getpid_cached())
 879                 return true;
 880
 881         if (kill(pid, 0) >= 0)
 882                 return true;
 883
 884         return errno != ESRCH;
 885 }
 886
 887 bool pid_is_alive(pid_t pid) {
 888         int r;
 889
 890         /* Checks whether a PID is still valid and not a zombie */
 891
 892         if (pid < 0)
 893                 return false;
 894
 895         if (pid <= 1) /* If we or PID 1 would be a zombie, this code would not be running */
 896                 return true;
 897
 898         if (pid == getpid_cached())
 899                 return true;
 900
 901         r = get_process_state(pid);
 902         if (IN_SET(r, -ESRCH, 'Z'))
 903                 return false;
 904
 905         return true;
 906 }
 907
 908 #if 0 /// UNNEEDED by elogind
 909 int pid_from_same_root_fs(pid_t pid) {
 910         const char *root;
 911
 912         if (pid < 0)
 913                 return false;
 914
 915         if (pid == 0 || pid == getpid_cached())
 916                 return true;
 917
 918         root = procfs_file_alloca(pid, "root");
 919
 920         return files_same(root, "/proc/1/root", 0);
 921 }
 922 #endif // 0
 923
 924 bool is_main_thread(void) {
 925         static thread_local int cached = 0;
 926
 927         if (_unlikely_(cached == 0))
 928                 cached = getpid_cached() == gettid() ? 1 : -1;
 929
 930         return cached > 0;
 931 }
 932
 933 #if 0 /// UNNEEDED by elogind
 934 noreturn void freeze(void) {
 935
 936         log_close();
 937
 938         /* Make sure nobody waits for us on a socket anymore */
 939         close_all_fds(NULL, 0);
 940
 941         sync();
 942
 943         for (;;)
 944                 pause();
 945 }
 946
 947 bool oom_score_adjust_is_valid(int oa) {
 948         return oa >= OOM_SCORE_ADJ_MIN && oa <= OOM_SCORE_ADJ_MAX;
 949 }
 950
 951 unsigned long personality_from_string(const char *p) {
 952         int architecture;
 953
 954         if (!p)
 955                 return PERSONALITY_INVALID;
 956
 957         /* Parse a personality specifier. We use our own identifiers that indicate specific ABIs, rather than just
 958          * hints regarding the register size, since we want to keep things open for multiple locally supported ABIs for
 959          * the same register size. */
 960
 961         architecture = architecture_from_string(p);
 962         if (architecture < 0)
 963                 return PERSONALITY_INVALID;
 964
 965         if (architecture == native_architecture())
 966                 return PER_LINUX;
 967 #ifdef SECONDARY_ARCHITECTURE
 968         if (architecture == SECONDARY_ARCHITECTURE)
 969                 return PER_LINUX32;
 970 #endif
 971
 972         return PERSONALITY_INVALID;
 973 }
 974
 975 const char* personality_to_string(unsigned long p) {
 976         int architecture = _ARCHITECTURE_INVALID;
 977
 978         if (p == PER_LINUX)
 979                 architecture = native_architecture();
 980 #ifdef SECONDARY_ARCHITECTURE
 981         else if (p == PER_LINUX32)
 982                 architecture = SECONDARY_ARCHITECTURE;
 983 #endif
 984
 985         if (architecture < 0)
 986                 return NULL;
 987
 988         return architecture_to_string(architecture);
 989 }
 990
 991 int safe_personality(unsigned long p) {
 992         int ret;
 993
 994         /* So here's the deal, personality() is weirdly defined by glibc. In some cases it returns a failure via errno,
 995          * and in others as negative return value containing an errno-like value. Let's work around this: this is a
 996          * wrapper that uses errno if it is set, and uses the return value otherwise. And then it sets both errno and
 997          * the return value indicating the same issue, so that we are definitely on the safe side.
 998          *
 999          * See https://github.com/systemd/systemd/issues/6737 */
1000
1001         errno = 0;
1002         ret = personality(p);
1003         if (ret < 0) {
1004                 if (errno != 0)
1005                         return -errno;
1006
1007                 errno = -ret;
1008         }
1009
1010         return ret;
1011 }
1012
1013 int opinionated_personality(unsigned long *ret) {
1014         int current;
1015
1016         /* Returns the current personality, or PERSONALITY_INVALID if we can't determine it. This function is a bit
1017          * opinionated though, and ignores all the finer-grained bits and exotic personalities, only distinguishing the
1018          * two most relevant personalities: PER_LINUX and PER_LINUX32. */
1019
1020         current = safe_personality(PERSONALITY_INVALID);
1021         if (current < 0)
1022                 return current;
1023
1024         if (((unsigned long) current & 0xffff) == PER_LINUX32)
1025                 *ret = PER_LINUX32;
1026         else
1027                 *ret = PER_LINUX;
1028
1029         return 0;
1030 }
1031
1032 void valgrind_summary_hack(void) {
1033 #if HAVE_VALGRIND_VALGRIND_H
1034         if (getpid_cached() == 1 && RUNNING_ON_VALGRIND) {
1035                 pid_t pid;
1036                 pid = raw_clone(SIGCHLD);
1037                 if (pid < 0)
1038                         log_emergency_errno(errno, "Failed to fork off valgrind helper: %m");
1039                 else if (pid == 0)
1040                         exit(EXIT_SUCCESS);
1041                 else {
1042                         log_info("Spawned valgrind helper as PID "PID_FMT".", pid);
1043                         (void) wait_for_terminate(pid, NULL);
1044                 }
1045         }
1046 #endif
1047 }
1048
1049 int pid_compare_func(const void *a, const void *b) {
1050         const pid_t *p = a, *q = b;
1051
1052         /* Suitable for usage in qsort() */
1053
1054         if (*p < *q)
1055                 return -1;
1056         if (*p > *q)
1057                 return 1;
1058         return 0;
1059 }
1060
1061 int ioprio_parse_priority(const char *s, int *ret) {
1062         int i, r;
1063
1064         assert(s);
1065         assert(ret);
1066
1067         r = safe_atoi(s, &i);
1068         if (r < 0)
1069                 return r;
1070
1071         if (!ioprio_priority_is_valid(i))
1072                 return -EINVAL;
1073
1074         *ret = i;
1075         return 0;
1076 }
1077 #endif // 0
1078
1079 /* The cached PID, possible values:
1080  *
1081  *     == UNSET [0]  → cache not initialized yet
1082  *     == BUSY [-1]  → some thread is initializing it at the moment
1083  *     any other     → the cached PID
1084  */
1085
1086 #define CACHED_PID_UNSET ((pid_t) 0)
1087 #define CACHED_PID_BUSY ((pid_t) -1)
1088
1089 static pid_t cached_pid = CACHED_PID_UNSET;
1090
1091 static void reset_cached_pid(void) {
1092         /* Invoked in the child after a fork(), i.e. at the first moment the PID changed */
1093         cached_pid = CACHED_PID_UNSET;
1094 }
1095
1096 /* We use glibc __register_atfork() + __dso_handle directly here, as they are not included in the glibc
1097  * headers. __register_atfork() is mostly equivalent to pthread_atfork(), but doesn't require us to link against
1098  * libpthread, as it is part of glibc anyway. */
1099 #ifdef __GLIBC__
1100 extern int __register_atfork(void (*prepare) (void), void (*parent) (void), void (*child) (void), void * __dso_handle);
1101 extern void* __dso_handle __attribute__ ((__weak__));
1102 #endif // ifdef __GLIBC__
1103
1104 pid_t getpid_cached(void) {
1105         pid_t current_value;
1106
1107         /* getpid_cached() is much like getpid(), but caches the value in local memory, to avoid having to invoke a
1108          * system call each time. This restores glibc behaviour from before 2.24, when getpid() was unconditionally
1109          * cached. Starting with 2.24 getpid() started to become prohibitively expensive when used for detecting when
1110          * objects were used across fork()s. With this caching the old behaviour is somewhat restored.
1111          *
1112          * https://bugzilla.redhat.com/show_bug.cgi?id=1443976
1113          * https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=c579f48edba88380635ab98cb612030e3ed8691e
1114          */
1115
1116         current_value = __sync_val_compare_and_swap(&cached_pid, CACHED_PID_UNSET, CACHED_PID_BUSY);
1117
1118         switch (current_value) {
1119
1120         case CACHED_PID_UNSET: { /* Not initialized yet, then do so now */
1121                 pid_t new_pid;
1122
1123                 new_pid = getpid();
1124
1125                 if (__register_atfork(NULL, NULL, reset_cached_pid, __dso_handle) != 0) {
1126                         /* OOM? Let's try again later */
1127                         cached_pid = CACHED_PID_UNSET;
1128                         return new_pid;
1129                 }
1130
1131                 cached_pid = new_pid;
1132                 return new_pid;
1133         }
1134
1135         case CACHED_PID_BUSY: /* Somebody else is currently initializing */
1136                 return getpid();
1137
1138         default: /* Properly initialized */
1139                 return current_value;
1140         }
1141 }
1142
1143 int must_be_root(void) {
1144
1145         if (geteuid() == 0)
1146                 return 0;
1147
1148         log_error("Need to be root.");
1149         return -EPERM;
1150 }
1151
1152 int safe_fork_full(
1153                 const char *name,
1154                 const int except_fds[],
1155                 size_t n_except_fds,
1156                 ForkFlags flags,
1157                 pid_t *ret_pid) {
1158
1159         pid_t original_pid, pid;
1160         sigset_t saved_ss;
1161         bool block_signals;
1162         int r;
1163
1164         /* A wrapper around fork(), that does a couple of important initializations in addition to mere forking. Always
1165          * returns the child's PID in *ret_pid. Returns == 0 in the child, and > 0 in the parent. */
1166
1167         original_pid = getpid_cached();
1168
1169         block_signals = flags & (FORK_RESET_SIGNALS|FORK_DEATHSIG);
1170
1171         if (block_signals) {
1172                 sigset_t ss;
1173
1174                 /* We temporarily block all signals, so that the new child has them blocked initially. This way, we can be sure
1175                  * that SIGTERMs are not lost we might send to the child. */
1176                 if (sigfillset(&ss) < 0)
1177                         return log_debug_errno(errno, "Failed to reset signal set: %m");
1178
1179                 if (sigprocmask(SIG_SETMASK, &ss, &saved_ss) < 0)
1180                         return log_debug_errno(errno, "Failed to reset signal mask: %m");
1181         }
1182
1183         pid = fork();
1184         if (pid < 0) {
1185                 r = -errno;
1186
1187                 if (block_signals) /* undo what we did above */
1188                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1189
1190                 return log_debug_errno(r, "Failed to fork: %m");
1191         }
1192         if (pid > 0) {
1193                 /* We are in the parent process */
1194
1195                 if (block_signals) /* undo what we did above */
1196                         (void) sigprocmask(SIG_SETMASK, &saved_ss, NULL);
1197
1198                 log_debug("Sucessfully forked off '%s' as PID " PID_FMT ".", strna(name), pid);
1199
1200                 if (ret_pid)
1201                         *ret_pid = pid;
1202
1203                 return 1;
1204         }
1205
1206         /* We are in the child process */
1207
1208         if (flags & FORK_REOPEN_LOG) {
1209                 /* Close the logs if requested, before we log anything. And make sure we reopen it if needed. */
1210                 log_close();
1211                 log_set_open_when_needed(true);
1212         }
1213
1214         if (name) {
1215                 r = rename_process(name);
1216                 if (r < 0)
1217                         log_debug_errno(r, "Failed to rename process, ignoring: %m");
1218         }
1219
1220         if (flags & FORK_DEATHSIG)
1221                 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0) {
1222                         log_debug_errno(errno, "Failed to set death signal: %m");
1223                         _exit(EXIT_FAILURE);
1224                 }
1225
1226         if (flags & FORK_RESET_SIGNALS) {
1227                 r = reset_all_signal_handlers();
1228                 if (r < 0) {
1229                         log_debug_errno(r, "Failed to reset signal handlers: %m");
1230                         _exit(EXIT_FAILURE);
1231                 }
1232
1233                 /* This implicitly undoes the signal mask stuff we did before the fork()ing above */
1234                 r = reset_signal_mask();
1235                 if (r < 0) {
1236                         log_debug_errno(r, "Failed to reset signal mask: %m");
1237                         _exit(EXIT_FAILURE);
1238                 }
1239         } else if (block_signals) { /* undo what we did above */
1240                 if (sigprocmask(SIG_SETMASK, &saved_ss, NULL) < 0) {
1241                         log_debug_errno(errno, "Failed to restore signal mask: %m");
1242                         _exit(EXIT_FAILURE);
1243                 }
1244         }
1245
1246         if (flags & FORK_DEATHSIG) {
1247                 /* Let's see if the parent PID is still the one we started from? If not, then the parent
1248                  * already died by the time we set PR_SET_PDEATHSIG, hence let's emulate the effect */
1249
1250                 if (getppid() != original_pid) {
1251                         log_debug("Parent died early, raising SIGTERM.");
1252                         (void) raise(SIGTERM);
1253                         _exit(EXIT_FAILURE);
1254                 }
1255         }
1256
1257         if (flags & FORK_CLOSE_ALL_FDS) {
1258                 /* Close the logs here in case it got reopened above, as close_all_fds() would close them for us */
1259                 log_close();
1260
1261                 r = close_all_fds(except_fds, n_except_fds);
1262                 if (r < 0) {
1263                         log_debug_errno(r, "Failed to close all file descriptors: %m");
1264                         _exit(EXIT_FAILURE);
1265                 }
1266         }
1267
1268         /* When we were asked to reopen the logs, do so again now */
1269         if (flags & FORK_REOPEN_LOG) {
1270                 log_open();
1271                 log_set_open_when_needed(false);
1272         }
1273
1274         if (flags & FORK_NULL_STDIO) {
1275                 r = make_null_stdio();
1276                 if (r < 0) {
1277                         log_debug_errno(r, "Failed to connect stdin/stdout to /dev/null: %m");
1278                         _exit(EXIT_FAILURE);
1279                 }
1280         }
1281
1282         if (ret_pid)
1283                 *ret_pid = getpid_cached();
1284
1285         return 0;
1286 }
1287
1288 #if 0 /// UNNEEDED by elogind
1289 static const char *const ioprio_class_table[] = {
1290         [IOPRIO_CLASS_NONE] = "none",
1291         [IOPRIO_CLASS_RT] = "realtime",
1292         [IOPRIO_CLASS_BE] = "best-effort",
1293         [IOPRIO_CLASS_IDLE] = "idle"
1294 };
1295
1296 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
1297
1298 static const char *const sigchld_code_table[] = {
1299         [CLD_EXITED] = "exited",
1300         [CLD_KILLED] = "killed",
1301         [CLD_DUMPED] = "dumped",
1302         [CLD_TRAPPED] = "trapped",
1303         [CLD_STOPPED] = "stopped",
1304         [CLD_CONTINUED] = "continued",
1305 };
1306
1307 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
1308
1309 static const char* const sched_policy_table[] = {
1310         [SCHED_OTHER] = "other",
1311         [SCHED_BATCH] = "batch",
1312         [SCHED_IDLE] = "idle",
1313         [SCHED_FIFO] = "fifo",
1314         [SCHED_RR] = "rr"
1315 };
1316
1317 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
1318 #endif // 0