]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/nspawn/nspawn-stub-pid1.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2016 Lennart Poettering
8 #include <sys/reboot.h>
10 #include <sys/prctl.h>
16 #include "nspawn-stub-pid1.h"
17 #include "process-util.h"
18 #include "signal-util.h"
19 #include "time-util.h"
22 static int reset_environ(const char *new_environment
, size_t length
) {
23 unsigned long start
, end
;
25 start
= (unsigned long) new_environment
;
28 if (prctl(PR_SET_MM
, PR_SET_MM_ENV_START
, start
, 0, 0) < 0)
31 if (prctl(PR_SET_MM
, PR_SET_MM_ENV_END
, end
, 0, 0) < 0)
37 int stub_pid1(sd_id128_t uuid
) {
42 } state
= STATE_RUNNING
;
44 sigset_t fullmask
, oldmask
, waitmask
;
45 usec_t quit_usec
= USEC_INFINITY
;
49 /* The new environment we set up, on the stack. */
50 char new_environment
[] =
51 "container=systemd-nspawn\0"
52 "container_uuid=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
54 /* Implements a stub PID 1, that reaps all processes and processes a couple of standard signals. This is useful
55 * for allowing arbitrary processes run in a container, and still have all zombies reaped. */
57 assert_se(sigfillset(&fullmask
) >= 0);
58 assert_se(sigprocmask(SIG_BLOCK
, &fullmask
, &oldmask
) >= 0);
62 return log_error_errno(errno
, "Failed to fork child pid: %m");
65 /* Return in the child */
66 assert_se(sigprocmask(SIG_SETMASK
, &oldmask
, NULL
) >= 0);
71 reset_all_signal_handlers();
74 close_all_fds(NULL
, 0);
77 /* Flush out /proc/self/environ, so that we don't leak the environment from the host into the container. Also,
78 * set $container= and $container_uuid= so that clients in the container that query it from /proc/1/environ
80 sd_id128_to_string(uuid
, new_environment
+ sizeof(new_environment
) - SD_ID128_STRING_MAX
);
81 reset_environ(new_environment
, sizeof(new_environment
));
83 (void) rename_process("(sd-stubinit)");
85 assert_se(sigemptyset(&waitmask
) >= 0);
86 assert_se(sigset_add_many(&waitmask
,
87 SIGCHLD
, /* posix: process died */
88 SIGINT
, /* sysv: ctrl-alt-del */
89 SIGRTMIN
+3, /* systemd: halt */
90 SIGRTMIN
+4, /* systemd: poweroff */
91 SIGRTMIN
+5, /* systemd: reboot */
92 SIGRTMIN
+6, /* systemd: kexec */
93 SIGRTMIN
+13, /* systemd: halt */
94 SIGRTMIN
+14, /* systemd: poweroff */
95 SIGRTMIN
+15, /* systemd: reboot */
96 SIGRTMIN
+16, /* systemd: kexec */
99 /* Note that we ignore SIGTERM (sysv's reexec), SIGHUP (reload), and all other signals here, since we don't
100 * support reexec/reloading in this stub process. */
107 r
= waitid(P_ALL
, 0, &si
, WEXITED
|WNOHANG
);
109 r
= log_error_errno(errno
, "Failed to reap children: %m");
113 current_usec
= now(CLOCK_MONOTONIC
);
115 if (si
.si_pid
== pid
|| current_usec
>= quit_usec
) {
117 /* The child we started ourselves died or we reached a timeout. */
119 if (state
== STATE_REBOOT
) { /* dispatch a queued reboot */
120 (void) reboot(RB_AUTOBOOT
);
121 r
= log_error_errno(errno
, "Failed to reboot: %m");
124 } else if (state
== STATE_POWEROFF
)
125 (void) reboot(RB_POWER_OFF
); /* if this fails, fall back to normal exit. */
127 if (si
.si_pid
== pid
&& si
.si_code
== CLD_EXITED
)
128 r
= si
.si_status
; /* pass on exit code */
130 r
= 255; /* signal, coredump, timeout, … */
135 /* We reaped something. Retry until there's nothing more to reap. */
138 if (quit_usec
== USEC_INFINITY
)
139 r
= sigwaitinfo(&waitmask
, &si
);
142 r
= sigtimedwait(&waitmask
, &si
, timespec_store(&ts
, quit_usec
- current_usec
));
145 if (errno
== EINTR
) /* strace -p attach can result in EINTR, let's handle this nicely. */
147 if (errno
== EAGAIN
) /* timeout reached */
150 r
= log_error_errno(errno
, "Failed to wait for signal: %m");
154 if (si
.si_signo
== SIGCHLD
)
155 continue; /* Let's reap this */
157 if (state
!= STATE_RUNNING
)
160 /* Would love to use a switch() statement here, but SIGRTMIN is actually a function call, not a
163 if (si
.si_signo
== SIGRTMIN
+3 ||
164 si
.si_signo
== SIGRTMIN
+4 ||
165 si
.si_signo
== SIGRTMIN
+13 ||
166 si
.si_signo
== SIGRTMIN
+14)
168 state
= STATE_POWEROFF
;
170 else if (si
.si_signo
== SIGINT
||
171 si
.si_signo
== SIGRTMIN
+5 ||
172 si
.si_signo
== SIGRTMIN
+6 ||
173 si
.si_signo
== SIGRTMIN
+15 ||
174 si
.si_signo
== SIGRTMIN
+16)
176 state
= STATE_REBOOT
;
178 assert_not_reached("Got unexpected signal");
180 r
= kill_and_sigcont(pid
, SIGTERM
);
182 /* Let's send a SIGHUP after the SIGTERM, as shells tend to ignore SIGTERM but do react to SIGHUP. We
183 * do it strictly in this order, so that the SIGTERM is dispatched first, and SIGHUP second for those
184 * processes which handle both. That's because services tend to bind configuration reload or something
188 (void) kill(pid
, SIGHUP
);
190 quit_usec
= now(CLOCK_MONOTONIC
) + DEFAULT_TIMEOUT_USEC
;
194 _exit(r
< 0 ? EXIT_FAILURE
: r
);