]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/process-util.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
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.
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.
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/>.
24 #include <linux/oom.h>
29 #include <stdio_ext.h>
33 #include <sys/personality.h>
34 #include <sys/prctl.h>
35 #include <sys/types.h>
39 #if HAVE_VALGRIND_VALGRIND_H
40 #include <valgrind/valgrind.h>
43 #include "alloc-util.h"
44 #include "architecture.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"
63 int get_process_state(pid_t pid
) {
67 _cleanup_free_
char *line
= NULL
;
71 p
= procfs_file_alloca(pid
, "stat");
73 r
= read_one_line_file(p
, &line
);
79 p
= strrchr(line
, ')');
85 if (sscanf(p
, " %c", &state
) != 1)
88 return (unsigned char) state
;
91 int get_process_comm(pid_t pid
, char **name
) {
98 p
= procfs_file_alloca(pid
, "comm");
100 r
= read_one_line_file(p
, name
);
107 int get_process_cmdline(pid_t pid
, size_t max_length
, bool comm_fallback
, char **line
) {
108 _cleanup_fclose_
FILE *f
= NULL
;
110 char *k
, *ans
= NULL
;
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.
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. */
126 p
= procfs_file_alloca(pid
, "cmdline");
135 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
137 if (max_length
== 1) {
139 /* If there's only room for one byte, return the empty string */
147 } else if (max_length
== 0) {
148 size_t len
= 0, allocated
= 0;
150 while ((c
= getc(f
)) != EOF
) {
152 if (!GREEDY_REALLOC(ans
, allocated
, len
+3)) {
174 bool dotdotdot
= false;
177 ans
= new(char, max_length
);
183 while ((c
= getc(f
)) != EOF
) {
210 if (max_length
<= 4) {
214 k
= ans
+ max_length
- 4;
217 /* Eat up final spaces */
218 while (k
> ans
&& isspace(k
[-1])) {
224 strncpy(k
, "...", left
-1);
230 /* Kernel threads have no argv[] */
232 _cleanup_free_
char *t
= NULL
;
240 h
= get_process_comm(pid
, &t
);
245 ans
= strjoin("[", t
, "]");
251 if (l
+ 3 <= max_length
)
252 ans
= strjoin("[", t
, "]");
253 else if (max_length
<= 6) {
255 ans
= new(char, max_length
);
259 memcpy(ans
, "[...]", max_length
-1);
260 ans
[max_length
-1] = 0;
264 t
[max_length
- 6] = 0;
266 /* Chop off final spaces */
268 while (e
> t
&& isspace(e
[-1]))
272 ans
= strjoin("[", t
, "...]");
283 int rename_process(const char name
[]) {
284 static size_t mm_size
= 0;
285 static char *mm
= NULL
;
286 bool truncated
= false;
289 /* This is a like a poor man's setproctitle(). It changes the comm field, argv[0], and also the glibc's
290 * internally used name of the process. For the first one a limit of 16 chars applies; to the second one in
291 * many cases one of 10 (i.e. length of "/sbin/init") — however if we have CAP_SYS_RESOURCES it is unbounded;
292 * to the third one 7 (i.e. the length of "systemd". If you pass a longer string it will likely be
295 * Returns 0 if a name was set but truncated, > 0 if it was set but not truncated. */
298 return -EINVAL
; /* let's not confuse users unnecessarily with an empty name */
302 /* First step, change the comm field. */
303 (void) prctl(PR_SET_NAME
, name
);
304 if (l
> 15) /* Linux process names can be 15 chars at max */
307 /* Second step, change glibc's ID of the process name. */
308 if (program_invocation_name
) {
311 k
= strlen(program_invocation_name
);
312 strncpy(program_invocation_name
, name
, k
);
317 /* Third step, completely replace the argv[] array the kernel maintains for us. This requires privileges, but
318 * has the advantage that the argv[] array is exactly what we want it to be, and not filled up with zeros at
319 * the end. This is the best option for changing /proc/self/cmdline. */
321 /* Let's not bother with this if we don't have euid == 0. Strictly speaking we should check for the
322 * CAP_SYS_RESOURCE capability which is independent of the euid. In our own code the capability generally is
323 * present only for euid == 0, hence let's use this as quick bypass check, to avoid calling mmap() if
324 * PR_SET_MM_ARG_{START,END} fails with EPERM later on anyway. After all geteuid() is dead cheap to call, but
327 log_debug("Skipping PR_SET_MM, as we don't have privileges.");
328 else if (mm_size
< l
+1) {
332 nn_size
= PAGE_ALIGN(l
+1);
333 nn
= mmap(NULL
, nn_size
, PROT_READ
|PROT_WRITE
, MAP_PRIVATE
|MAP_ANONYMOUS
, -1, 0);
334 if (nn
== MAP_FAILED
) {
335 log_debug_errno(errno
, "mmap() failed: %m");
339 strncpy(nn
, name
, nn_size
);
341 /* Now, let's tell the kernel about this new memory */
342 if (prctl(PR_SET_MM
, PR_SET_MM_ARG_START
, (unsigned long) nn
, 0, 0) < 0) {
343 log_debug_errno(errno
, "PR_SET_MM_ARG_START failed, proceeding without: %m");
344 (void) munmap(nn
, nn_size
);
348 /* And update the end pointer to the new end, too. If this fails, we don't really know what to do, it's
349 * pretty unlikely that we can rollback, hence we'll just accept the failure, and continue. */
350 if (prctl(PR_SET_MM
, PR_SET_MM_ARG_END
, (unsigned long) nn
+ l
+ 1, 0, 0) < 0)
351 log_debug_errno(errno
, "PR_SET_MM_ARG_END failed, proceeding without: %m");
354 (void) munmap(mm
, mm_size
);
359 strncpy(mm
, name
, mm_size
);
361 /* Update the end pointer, continuing regardless of any failure. */
362 if (prctl(PR_SET_MM
, PR_SET_MM_ARG_END
, (unsigned long) mm
+ l
+ 1, 0, 0) < 0)
363 log_debug_errno(errno
, "PR_SET_MM_ARG_END failed, proceeding without: %m");
367 /* Fourth step: in all cases we'll also update the original argv[], so that our own code gets it right too if
368 * it still looks here */
370 if (saved_argc
> 0) {
376 k
= strlen(saved_argv
[0]);
377 strncpy(saved_argv
[0], name
, k
);
382 for (i
= 1; i
< saved_argc
; i
++) {
386 memzero(saved_argv
[i
], strlen(saved_argv
[i
]));
393 int is_kernel_thread(pid_t pid
) {
400 if (IN_SET(pid
, 0, 1) || pid
== getpid_cached()) /* pid 1, and we ourselves certainly aren't a kernel thread */
405 p
= procfs_file_alloca(pid
, "cmdline");
413 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
415 count
= fread(&c
, 1, 1, f
);
419 /* Kernel threads have an empty cmdline */
422 return eof
? 1 : -errno
;
427 int get_process_capeff(pid_t pid
, char **capeff
) {
434 p
= procfs_file_alloca(pid
, "status");
436 r
= get_proc_field(p
, "CapEff", WHITESPACE
, capeff
);
443 static int get_process_link_contents(const char *proc_file
, char **name
) {
449 r
= readlink_malloc(proc_file
, name
);
458 int get_process_exe(pid_t pid
, char **name
) {
465 p
= procfs_file_alloca(pid
, "exe");
466 r
= get_process_link_contents(p
, name
);
470 d
= endswith(*name
, " (deleted)");
477 static int get_process_id(pid_t pid
, const char *field
, uid_t
*uid
) {
478 _cleanup_fclose_
FILE *f
= NULL
;
488 p
= procfs_file_alloca(pid
, "status");
496 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
498 FOREACH_LINE(line
, f
, return -errno
) {
503 if (startswith(l
, field
)) {
505 l
+= strspn(l
, WHITESPACE
);
507 l
[strcspn(l
, WHITESPACE
)] = 0;
509 return parse_uid(l
, uid
);
516 int get_process_uid(pid_t pid
, uid_t
*uid
) {
518 if (pid
== 0 || pid
== getpid_cached()) {
523 return get_process_id(pid
, "Uid:", uid
);
526 int get_process_gid(pid_t pid
, gid_t
*gid
) {
528 if (pid
== 0 || pid
== getpid_cached()) {
533 assert_cc(sizeof(uid_t
) == sizeof(gid_t
));
534 return get_process_id(pid
, "Gid:", gid
);
537 int get_process_cwd(pid_t pid
, char **cwd
) {
542 p
= procfs_file_alloca(pid
, "cwd");
544 return get_process_link_contents(p
, cwd
);
547 int get_process_root(pid_t pid
, char **root
) {
552 p
= procfs_file_alloca(pid
, "root");
554 return get_process_link_contents(p
, root
);
557 int get_process_environ(pid_t pid
, char **env
) {
558 _cleanup_fclose_
FILE *f
= NULL
;
559 _cleanup_free_
char *outcome
= NULL
;
562 size_t allocated
= 0, sz
= 0;
567 p
= procfs_file_alloca(pid
, "environ");
576 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
578 while ((c
= fgetc(f
)) != EOF
) {
579 if (!GREEDY_REALLOC(outcome
, allocated
, sz
+ 5))
583 outcome
[sz
++] = '\n';
585 sz
+= cescape_char(c
, outcome
+ sz
);
589 outcome
= strdup("");
601 int get_process_ppid(pid_t pid
, pid_t
*_ppid
) {
603 _cleanup_free_
char *line
= NULL
;
610 if (pid
== 0 || pid
== getpid_cached()) {
615 p
= procfs_file_alloca(pid
, "stat");
616 r
= read_one_line_file(p
, &line
);
622 /* Let's skip the pid and comm fields. The latter is enclosed
623 * in () but does not escape any () in its value, so let's
624 * skip over it manually */
626 p
= strrchr(line
, ')');
638 if ((long unsigned) (pid_t
) ppid
!= ppid
)
641 *_ppid
= (pid_t
) ppid
;
646 int wait_for_terminate(pid_t pid
, siginfo_t
*status
) {
657 if (waitid(P_PID
, pid
, status
, WEXITED
) < 0) {
662 return negative_errno();
671 * < 0 : wait_for_terminate() failed to get the state of the
672 * process, the process was terminated by a signal, or
673 * failed for an unknown reason.
674 * >=0 : The process terminated normally, and its exit code is
677 * That is, success is indicated by a return value of zero, and an
678 * error is indicated by a non-zero value.
680 * A warning is emitted if the process terminates abnormally,
681 * and also if it returns non-zero unless check_exit_code is true.
683 int wait_for_terminate_and_warn(const char *name
, pid_t pid
, bool check_exit_code
) {
690 r
= wait_for_terminate(pid
, &status
);
692 return log_warning_errno(r
, "Failed to wait for %s: %m", name
);
694 if (status
.si_code
== CLD_EXITED
) {
695 if (status
.si_status
!= 0)
696 log_full(check_exit_code
? LOG_WARNING
: LOG_DEBUG
,
697 "%s failed with error code %i.", name
, status
.si_status
);
699 log_debug("%s succeeded.", name
);
701 return status
.si_status
;
702 } else if (IN_SET(status
.si_code
, CLD_KILLED
, CLD_DUMPED
)) {
704 log_warning("%s terminated by signal %s.", name
, signal_to_string(status
.si_status
));
708 log_warning("%s failed due to unknown reason.", name
);
714 * < 0 : wait_for_terminate_with_timeout() failed to get the state of the
715 * process, the process timed out, the process was terminated by a
716 * signal, or failed for an unknown reason.
717 * >=0 : The process terminated normally with no failures.
719 * Success is indicated by a return value of zero, a timeout is indicated
720 * by ETIMEDOUT, and all other child failure states are indicated by error
721 * is indicated by a non-zero value.
723 int wait_for_terminate_with_timeout(pid_t pid
, usec_t timeout
) {
728 assert_se(sigemptyset(&mask
) == 0);
729 assert_se(sigaddset(&mask
, SIGCHLD
) == 0);
731 /* Drop into a sigtimewait-based timeout. Waiting for the
733 until
= now(CLOCK_MONOTONIC
) + timeout
;
736 siginfo_t status
= {};
739 n
= now(CLOCK_MONOTONIC
);
743 r
= sigtimedwait(&mask
, NULL
, timespec_store(&ts
, until
- n
)) < 0 ? -errno
: 0;
744 /* Assuming we woke due to the child exiting. */
745 if (waitid(P_PID
, pid
, &status
, WEXITED
|WNOHANG
) == 0) {
746 if (status
.si_pid
== pid
) {
747 /* This is the correct child.*/
748 if (status
.si_code
== CLD_EXITED
)
749 return (status
.si_status
== 0) ? 0 : -EPROTO
;
754 /* Not the child, check for errors and proceed appropriately */
758 /* Timed out, child is likely hung. */
761 /* Received a different signal and should retry */
764 /* Return any unexpected errors */
773 void sigkill_wait(pid_t pid
) {
776 if (kill(pid
, SIGKILL
) > 0)
777 (void) wait_for_terminate(pid
, NULL
);
780 void sigkill_waitp(pid_t
*pid
) {
789 int kill_and_sigcont(pid_t pid
, int sig
) {
792 r
= kill(pid
, sig
) < 0 ? -errno
: 0;
794 /* If this worked, also send SIGCONT, unless we already just sent a SIGCONT, or SIGKILL was sent which isn't
795 * affected by a process being suspended anyway. */
796 if (r
>= 0 && !IN_SET(sig
, SIGCONT
, SIGKILL
))
797 (void) kill(pid
, SIGCONT
);
802 int getenv_for_pid(pid_t pid
, const char *field
, char **_value
) {
803 _cleanup_fclose_
FILE *f
= NULL
;
814 path
= procfs_file_alloca(pid
, "environ");
816 f
= fopen(path
, "re");
823 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
832 for (i
= 0; i
< sizeof(line
)-1; i
++) {
836 if (_unlikely_(c
== EOF
)) {
846 if (strneq(line
, field
, l
) && line
[l
] == '=') {
847 value
= strdup(line
+ l
+ 1);
861 bool pid_is_unwaited(pid_t pid
) {
862 /* Checks whether a PID is still valid at all, including a zombie */
867 if (pid
<= 1) /* If we or PID 1 would be dead and have been waited for, this code would not be running */
870 if (pid
== getpid_cached())
873 if (kill(pid
, 0) >= 0)
876 return errno
!= ESRCH
;
879 bool pid_is_alive(pid_t pid
) {
882 /* Checks whether a PID is still valid and not a zombie */
887 if (pid
<= 1) /* If we or PID 1 would be a zombie, this code would not be running */
890 if (pid
== getpid_cached())
893 r
= get_process_state(pid
);
894 if (IN_SET(r
, -ESRCH
, 'Z'))
900 int pid_from_same_root_fs(pid_t pid
) {
906 if (pid
== 0 || pid
== getpid_cached())
909 root
= procfs_file_alloca(pid
, "root");
911 return files_same(root
, "/proc/1/root", 0);
914 bool is_main_thread(void) {
915 static thread_local
int cached
= 0;
917 if (_unlikely_(cached
== 0))
918 cached
= getpid_cached() == gettid() ? 1 : -1;
923 noreturn
void freeze(void) {
927 /* Make sure nobody waits for us on a socket anymore */
928 close_all_fds(NULL
, 0);
936 bool oom_score_adjust_is_valid(int oa
) {
937 return oa
>= OOM_SCORE_ADJ_MIN
&& oa
<= OOM_SCORE_ADJ_MAX
;
940 unsigned long personality_from_string(const char *p
) {
944 return PERSONALITY_INVALID
;
946 /* Parse a personality specifier. We use our own identifiers that indicate specific ABIs, rather than just
947 * hints regarding the register size, since we want to keep things open for multiple locally supported ABIs for
948 * the same register size. */
950 architecture
= architecture_from_string(p
);
951 if (architecture
< 0)
952 return PERSONALITY_INVALID
;
954 if (architecture
== native_architecture())
956 #ifdef SECONDARY_ARCHITECTURE
957 if (architecture
== SECONDARY_ARCHITECTURE
)
961 return PERSONALITY_INVALID
;
964 const char* personality_to_string(unsigned long p
) {
965 int architecture
= _ARCHITECTURE_INVALID
;
968 architecture
= native_architecture();
969 #ifdef SECONDARY_ARCHITECTURE
970 else if (p
== PER_LINUX32
)
971 architecture
= SECONDARY_ARCHITECTURE
;
974 if (architecture
< 0)
977 return architecture_to_string(architecture
);
980 int safe_personality(unsigned long p
) {
983 /* So here's the deal, personality() is weirdly defined by glibc. In some cases it returns a failure via errno,
984 * and in others as negative return value containing an errno-like value. Let's work around this: this is a
985 * wrapper that uses errno if it is set, and uses the return value otherwise. And then it sets both errno and
986 * the return value indicating the same issue, so that we are definitely on the safe side.
988 * See https://github.com/systemd/systemd/issues/6737 */
991 ret
= personality(p
);
1002 int opinionated_personality(unsigned long *ret
) {
1005 /* Returns the current personality, or PERSONALITY_INVALID if we can't determine it. This function is a bit
1006 * opinionated though, and ignores all the finer-grained bits and exotic personalities, only distinguishing the
1007 * two most relevant personalities: PER_LINUX and PER_LINUX32. */
1009 current
= safe_personality(PERSONALITY_INVALID
);
1013 if (((unsigned long) current
& 0xffff) == PER_LINUX32
)
1021 void valgrind_summary_hack(void) {
1022 #if HAVE_VALGRIND_VALGRIND_H
1023 if (getpid_cached() == 1 && RUNNING_ON_VALGRIND
) {
1025 pid
= raw_clone(SIGCHLD
);
1027 log_emergency_errno(errno
, "Failed to fork off valgrind helper: %m");
1031 log_info("Spawned valgrind helper as PID "PID_FMT
".", pid
);
1032 (void) wait_for_terminate(pid
, NULL
);
1038 int pid_compare_func(const void *a
, const void *b
) {
1039 const pid_t
*p
= a
, *q
= b
;
1041 /* Suitable for usage in qsort() */
1050 int ioprio_parse_priority(const char *s
, int *ret
) {
1056 r
= safe_atoi(s
, &i
);
1060 if (!ioprio_priority_is_valid(i
))
1067 /* The cached PID, possible values:
1069 * == UNSET [0] → cache not initialized yet
1070 * == BUSY [-1] → some thread is initializing it at the moment
1071 * any other → the cached PID
1074 #define CACHED_PID_UNSET ((pid_t) 0)
1075 #define CACHED_PID_BUSY ((pid_t) -1)
1077 static pid_t cached_pid
= CACHED_PID_UNSET
;
1079 static void reset_cached_pid(void) {
1080 /* Invoked in the child after a fork(), i.e. at the first moment the PID changed */
1081 cached_pid
= CACHED_PID_UNSET
;
1084 /* We use glibc __register_atfork() + __dso_handle directly here, as they are not included in the glibc
1085 * headers. __register_atfork() is mostly equivalent to pthread_atfork(), but doesn't require us to link against
1086 * libpthread, as it is part of glibc anyway. */
1087 extern int __register_atfork(void (*prepare
) (void), void (*parent
) (void), void (*child
) (void), void * __dso_handle
);
1088 extern void* __dso_handle
__attribute__ ((__weak__
));
1090 pid_t
getpid_cached(void) {
1091 pid_t current_value
;
1093 /* getpid_cached() is much like getpid(), but caches the value in local memory, to avoid having to invoke a
1094 * system call each time. This restores glibc behaviour from before 2.24, when getpid() was unconditionally
1095 * cached. Starting with 2.24 getpid() started to become prohibitively expensive when used for detecting when
1096 * objects were used across fork()s. With this caching the old behaviour is somewhat restored.
1098 * https://bugzilla.redhat.com/show_bug.cgi?id=1443976
1099 * https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=c579f48edba88380635ab98cb612030e3ed8691e
1102 current_value
= __sync_val_compare_and_swap(&cached_pid
, CACHED_PID_UNSET
, CACHED_PID_BUSY
);
1104 switch (current_value
) {
1106 case CACHED_PID_UNSET
: { /* Not initialized yet, then do so now */
1111 if (__register_atfork(NULL
, NULL
, reset_cached_pid
, __dso_handle
) != 0) {
1112 /* OOM? Let's try again later */
1113 cached_pid
= CACHED_PID_UNSET
;
1117 cached_pid
= new_pid
;
1121 case CACHED_PID_BUSY
: /* Somebody else is currently initializing */
1124 default: /* Properly initialized */
1125 return current_value
;
1129 int must_be_root(void) {
1134 log_error("Need to be root.");
1140 const int except_fds
[],
1141 size_t n_except_fds
,
1145 pid_t original_pid
, pid
;
1150 /* A wrapper around fork(), that does a couple of important initializations in addition to mere forking. Always
1151 * returns the child's PID in *ret_pid. Returns == 0 in the child, and > 0 in the parent. */
1153 original_pid
= getpid_cached();
1155 block_signals
= flags
& (FORK_RESET_SIGNALS
|FORK_DEATHSIG
);
1157 if (block_signals
) {
1160 /* We temporarily block all signals, so that the new child has them blocked initially. This way, we can be sure
1161 * that SIGTERMs are not lost we might send to the child. */
1162 if (sigfillset(&ss
) < 0)
1163 return log_debug_errno(errno
, "Failed to reset signal set: %m");
1165 if (sigprocmask(SIG_SETMASK
, &ss
, &saved_ss
) < 0)
1166 return log_debug_errno(errno
, "Failed to reset signal mask: %m");
1173 if (block_signals
) /* undo what we did above */
1174 (void) sigprocmask(SIG_SETMASK
, &saved_ss
, NULL
);
1176 return log_debug_errno(r
, "Failed to fork: %m");
1179 /* We are in the parent process */
1181 if (block_signals
) /* undo what we did above */
1182 (void) sigprocmask(SIG_SETMASK
, &saved_ss
, NULL
);
1184 log_debug("Sucessfully forked off '%s' as PID " PID_FMT
".", strna(name
), pid
);
1192 /* We are in the child process */
1194 if (flags
& FORK_REOPEN_LOG
) {
1195 /* Close the logs if requested, before we log anything. And make sure we reopen it if needed. */
1197 log_set_open_when_needed(true);
1201 r
= rename_process(name
);
1203 log_debug_errno(r
, "Failed to rename process, ignoring: %m");
1206 if (flags
& FORK_DEATHSIG
)
1207 if (prctl(PR_SET_PDEATHSIG
, SIGTERM
) < 0) {
1208 log_debug_errno(errno
, "Failed to set death signal: %m");
1209 _exit(EXIT_FAILURE
);
1212 if (flags
& FORK_RESET_SIGNALS
) {
1213 r
= reset_all_signal_handlers();
1215 log_debug_errno(r
, "Failed to reset signal handlers: %m");
1216 _exit(EXIT_FAILURE
);
1219 /* This implicitly undoes the signal mask stuff we did before the fork()ing above */
1220 r
= reset_signal_mask();
1222 log_debug_errno(r
, "Failed to reset signal mask: %m");
1223 _exit(EXIT_FAILURE
);
1225 } else if (block_signals
) { /* undo what we did above */
1226 if (sigprocmask(SIG_SETMASK
, &saved_ss
, NULL
) < 0) {
1227 log_debug_errno(errno
, "Failed to restore signal mask: %m");
1228 _exit(EXIT_FAILURE
);
1232 if (flags
& FORK_DEATHSIG
) {
1233 /* Let's see if the parent PID is still the one we started from? If not, then the parent
1234 * already died by the time we set PR_SET_PDEATHSIG, hence let's emulate the effect */
1236 if (getppid() != original_pid
) {
1237 log_debug("Parent died early, raising SIGTERM.");
1238 (void) raise(SIGTERM
);
1239 _exit(EXIT_FAILURE
);
1243 if (flags
& FORK_CLOSE_ALL_FDS
) {
1244 /* Close the logs here in case it got reopened above, as close_all_fds() would close them for us */
1247 r
= close_all_fds(except_fds
, n_except_fds
);
1249 log_debug_errno(r
, "Failed to close all file descriptors: %m");
1250 _exit(EXIT_FAILURE
);
1254 /* When we were asked to reopen the logs, do so again now */
1255 if (flags
& FORK_REOPEN_LOG
) {
1257 log_set_open_when_needed(false);
1260 if (flags
& FORK_NULL_STDIO
) {
1261 r
= make_null_stdio();
1263 log_debug_errno(r
, "Failed to connect stdin/stdout to /dev/null: %m");
1264 _exit(EXIT_FAILURE
);
1269 *ret_pid
= getpid_cached();
1274 static const char *const ioprio_class_table
[] = {
1275 [IOPRIO_CLASS_NONE
] = "none",
1276 [IOPRIO_CLASS_RT
] = "realtime",
1277 [IOPRIO_CLASS_BE
] = "best-effort",
1278 [IOPRIO_CLASS_IDLE
] = "idle"
1281 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class
, int, INT_MAX
);
1283 static const char *const sigchld_code_table
[] = {
1284 [CLD_EXITED
] = "exited",
1285 [CLD_KILLED
] = "killed",
1286 [CLD_DUMPED
] = "dumped",
1287 [CLD_TRAPPED
] = "trapped",
1288 [CLD_STOPPED
] = "stopped",
1289 [CLD_CONTINUED
] = "continued",
1292 DEFINE_STRING_TABLE_LOOKUP(sigchld_code
, int);
1294 static const char* const sched_policy_table
[] = {
1295 [SCHED_OTHER
] = "other",
1296 [SCHED_BATCH
] = "batch",
1297 [SCHED_IDLE
] = "idle",
1298 [SCHED_FIFO
] = "fifo",
1302 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy
, int, INT_MAX
);