]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/main.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
button: don't exit if we cannot handle a button press
[thirdparty/systemd.git] / src / core / main.c
CommitLineData
d6c9574f 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
60918275 2
a7334b09
LP		 3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
5430f7f2
LP		 9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
a7334b09
LP		 11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2 16 Lesser General Public License for more details.
a7334b09 17
5430f7f2 18 You should have received a copy of the GNU Lesser General Public License
a7334b09
LP		 19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
ea430986
LP		 22#include <dbus/dbus.h>
23
60918275
LP		 24#include <stdio.h>
25#include <errno.h>
26#include <string.h>
16354eff 27#include <unistd.h>
4ade7963
LP		 28#include <sys/types.h>
29#include <sys/stat.h>
f170852a 30#include <getopt.h>
97c4f35c 31#include <signal.h>
4fc935ca 32#include <sys/wait.h>
80876c20 33#include <fcntl.h>
f3b6a3ed 34#include <sys/prctl.h>
664f88a7 35#include <sys/mount.h>
60918275
LP		 36
37#include "manager.h"
16354eff 38#include "log.h"
302e8c4c 39#include "load-fragment.h"
a16e1123 40#include "fdset.h"
514f4ef5 41#include "special.h"
487393e9 42#include "conf-parser.h"
449101fc 43#include "dbus-common.h"
ad780f19 44#include "missing.h"
e51bc1a2 45#include "label.h"
302e27c8 46#include "build.h"
06d4c99a 47#include "strv.h"
f6a6225e 48#include "def.h"
b52aae1d 49#include "virt.h"
e96d6be7 50#include "watchdog.h"
664f88a7 51#include "path-util.h"
41669317 52#include "switch-root.h"
ec8927ca 53#include "capability.h"
bd3fa1d2 54#include "killall.h"
0c4025d1
LP		 55#include "env-util.h"
56#include "hwclock.h"
57#include "sd-daemon.h"
e8e581bf 58#include "sd-messages.h"
60918275 59
b6e66135
LP		 60#include "mount-setup.h"
61#include "loopback-setup.h"
e3043162 62#ifdef HAVE_KMOD
b6e66135 63#include "kmod-setup.h"
e3043162 64#endif
b6e66135
LP		 65#include "hostname-setup.h"
66#include "machine-id-setup.h"
b6e66135
LP		 67#include "selinux-setup.h"
68#include "ima-setup.h"
a5c32cff 69#include "fileio.h"
ffbd2c4d 70#include "smack-setup.h"
b6e66135 71
f170852a
LP		 72static enum {
73 ACTION_RUN,
e965d56d 74 ACTION_HELP,
9ba0bc4e 75 ACTION_VERSION,
e537352b 76 ACTION_TEST,
4288f619
LP		 77 ACTION_DUMP_CONFIGURATION_ITEMS,
78 ACTION_DONE
fa0f4d8a 79} arg_action = ACTION_RUN;
f170852a 80
fa0f4d8a 81static char *arg_default_unit = NULL;
67445f4e 82static SystemdRunningAs arg_running_as = _SYSTEMD_RUNNING_AS_INVALID;
fa0f4d8a
LP		 83
84static bool arg_dump_core = true;
85static bool arg_crash_shell = false;
86static int arg_crash_chvt = -1;
87static bool arg_confirm_spawn = false;
9e58ff9c 88static bool arg_show_status = true;
bf4df7c3 89static bool arg_switched_root = false;
0c85a4f3 90static char ***arg_join_controllers = NULL;
706343f4 91static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
0a494f1f 92static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
1f19a534
OS		 93static usec_t arg_default_restart_usec = DEFAULT_RESTART_USEC;
94static usec_t arg_default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
95static usec_t arg_default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
3f41e1e5
LN		 96static usec_t arg_default_start_limit_interval = DEFAULT_START_LIMIT_INTERVAL;
97static unsigned arg_default_start_limit_burst = DEFAULT_START_LIMIT_BURST;
e96d6be7
LP		 98static usec_t arg_runtime_watchdog = 0;
99static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
97d0e5f8 100static char **arg_default_environment = NULL;
c93ff2e9 101static struct rlimit *arg_default_rlimit[RLIMIT_NLIMITS] = {};
ec8927ca 102static uint64_t arg_capability_bounding_set_drop = 0;
aa0f64ac 103static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
4fc935ca 104
a16e1123 105static FILE* serialization = NULL;
80876c20 106
6f5e3f35
LP		 107static void nop_handler(int sig) {
108}
109
93a46b0b 110_noreturn_ static void crash(int sig) {
97c4f35c 111
abb26902
LP		 112 if (getpid() != 1)
113 /* Pass this on immediately, if this is not PID 1 */
114 raise(sig);
115 else if (!arg_dump_core)
582a507f 116 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
97c4f35c 117 else {
b92bea5d
ZJS		 118 struct sigaction sa = {
119 .sa_handler = nop_handler,
120 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
121 };
97c4f35c
LP		 122 pid_t pid;
123
6f5e3f35 124 /* We want to wait for the core process, hence let's enable SIGCHLD */
abb26902 125 sigaction(SIGCHLD, &sa, NULL);
6f5e3f35 126
e62d8c39
ZJS		 127 pid = fork();
128 if (pid < 0)
7989e1f2 129 log_error("Caught <%s>, cannot fork for core dump: %s", signal_to_string(sig), strerror(errno));
97c4f35c
LP		 130
131 else if (pid == 0) {
b92bea5d 132 struct rlimit rl = {};
97c4f35c
LP		 133
134 /* Enable default signal handler for core dump */
135 zero(sa);
136 sa.sa_handler = SIG_DFL;
abb26902 137 sigaction(sig, &sa, NULL);
97c4f35c
LP		 138
139 /* Don't limit the core dump size */
97c4f35c
LP		 140 rl.rlim_cur = RLIM_INFINITY;
141 rl.rlim_max = RLIM_INFINITY;
142 setrlimit(RLIMIT_CORE, &rl);
143
144 /* Just to be sure... */
abb26902 145 chdir("/");
97c4f35c
LP		 146
147 /* Raise the signal again */
148 raise(sig);
149
150 assert_not_reached("We shouldn't be here...");
151 _exit(1);
4fc935ca
LP		 152
153 } else {
8e12a6ae
LP		 154 siginfo_t status;
155 int r;
4fc935ca
LP		 156
157 /* Order things nicely. */
e62d8c39
ZJS		 158 r = wait_for_terminate(pid, &status);
159 if (r < 0)
7989e1f2 160 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
8e12a6ae 161 else if (status.si_code != CLD_DUMPED)
7989e1f2 162 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
4fc935ca 163 else
7989e1f2 164 log_error("Caught <%s>, dumped core as pid %lu.", signal_to_string(sig), (unsigned long) pid);
97c4f35c
LP		 165 }
166 }
167
fa0f4d8a
LP		 168 if (arg_crash_chvt)
169 chvt(arg_crash_chvt);
601f6a1e 170
fa0f4d8a 171 if (arg_crash_shell) {
b92bea5d
ZJS		 172 struct sigaction sa = {
173 .sa_handler = SIG_IGN,
174 .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
175 };
6f5e3f35 176 pid_t pid;
8c43883a 177
4fc935ca
LP		 178 log_info("Executing crash shell in 10s...");
179 sleep(10);
180
6f5e3f35 181 /* Let the kernel reap children for us */
6f5e3f35 182 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
8c43883a 183
cd3bd60a
LP		 184 pid = fork();
185 if (pid < 0)
14212119 186 log_error("Failed to fork off crash shell: %m");
6f5e3f35 187 else if (pid == 0) {
cd3bd60a 188 make_console_stdio();
6f5e3f35
LP		 189 execl("/bin/sh", "/bin/sh", NULL);
190
14212119 191 log_error("execl() failed: %m");
6f5e3f35
LP		 192 _exit(1);
193 }
c99b188e 194
7989e1f2 195 log_info("Successfully spawned crash shell as pid %lu.", (unsigned long) pid);
4fc935ca
LP		 196 }
197
198 log_info("Freezing execution.");
97c4f35c
LP		 199 freeze();
200}
201
202static void install_crash_handler(void) {
b92bea5d
ZJS		 203 struct sigaction sa = {
204 .sa_handler = crash,
205 .sa_flags = SA_NODEFER,
206 };
97c4f35c 207
1b91d3e8 208 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
97c4f35c 209}
f170852a 210
843d2643
LP		 211static int console_setup(bool do_reset) {
212 int tty_fd, r;
80876c20 213
843d2643
LP		 214 /* If we are init, we connect stdin/stdout/stderr to /dev/null
215 * and make sure we don't have a controlling tty. */
80876c20 216
843d2643
LP		 217 release_terminal();
218
219 if (!do_reset)
220 return 0;
80876c20 221
512947d4
MS		 222 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
223 if (tty_fd < 0) {
843d2643
LP		 224 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
225 return -tty_fd;
226 }
80876c20 227
512947d4
MS		 228 /* We don't want to force text mode.
229 * plymouth may be showing pictures already from initrd. */
230 r = reset_terminal_fd(tty_fd, false);
231 if (r < 0)
843d2643
LP		 232 log_error("Failed to reset /dev/console: %s", strerror(-r));
233
234 close_nointr_nofail(tty_fd);
80876c20
LP		 235 return r;
236}
237
f170852a
LP		 238static int set_default_unit(const char *u) {
239 char *c;
240
241 assert(u);
242
bf4df7c3
LP		 243 c = strdup(u);
244 if (!c)
f170852a
LP		 245 return -ENOMEM;
246
fa0f4d8a
LP		 247 free(arg_default_unit);
248 arg_default_unit = c;
bf4df7c3 249
f170852a
LP		 250 return 0;
251}
252
253static int parse_proc_cmdline_word(const char *word) {
254
255 static const char * const rlmap[] = {
ed370f5d 256 "emergency", SPECIAL_EMERGENCY_TARGET,
099663ff 257 "-b", SPECIAL_EMERGENCY_TARGET,
ed370f5d
LP		 258 "single", SPECIAL_RESCUE_TARGET,
259 "-s", SPECIAL_RESCUE_TARGET,
260 "s", SPECIAL_RESCUE_TARGET,
261 "S", SPECIAL_RESCUE_TARGET,
262 "1", SPECIAL_RESCUE_TARGET,
263 "2", SPECIAL_RUNLEVEL2_TARGET,
264 "3", SPECIAL_RUNLEVEL3_TARGET,
265 "4", SPECIAL_RUNLEVEL4_TARGET,
266 "5", SPECIAL_RUNLEVEL5_TARGET,
f170852a
LP		 267 };
268
5192bd19
LP		 269 assert(word);
270
bf4df7c3
LP		 271 if (startswith(word, "systemd.unit=")) {
272
273 if (!in_initrd())
274 return set_default_unit(word + 13);
275
276 } else if (startswith(word, "rd.systemd.unit=")) {
277
278 if (in_initrd())
279 return set_default_unit(word + 16);
f170852a 280
bf4df7c3 281 } else if (startswith(word, "systemd.log_target=")) {
f170852a
LP		 282
283 if (log_set_target_from_string(word + 19) < 0)
284 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
285
286 } else if (startswith(word, "systemd.log_level=")) {
287
288 if (log_set_max_level_from_string(word + 18) < 0)
289 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
290
bbe63281
LP		 291 } else if (startswith(word, "systemd.log_color=")) {
292
293 if (log_show_color_from_string(word + 18) < 0)
294 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
295
296 } else if (startswith(word, "systemd.log_location=")) {
297
298 if (log_show_location_from_string(word + 21) < 0)
299 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
300
4fc935ca
LP		 301 } else if (startswith(word, "systemd.dump_core=")) {
302 int r;
303
304 if ((r = parse_boolean(word + 18)) < 0)
509b6efb 305 log_warning("Failed to parse dump core switch %s. Ignoring.", word + 18);
4fc935ca 306 else
fa0f4d8a 307 arg_dump_core = r;
4fc935ca
LP		 308
309 } else if (startswith(word, "systemd.crash_shell=")) {
310 int r;
311
312 if ((r = parse_boolean(word + 20)) < 0)
509b6efb 313 log_warning("Failed to parse crash shell switch %s. Ignoring.", word + 20);
4fc935ca 314 else
fa0f4d8a 315 arg_crash_shell = r;
5e7ee61c
LP		 316
317 } else if (startswith(word, "systemd.confirm_spawn=")) {
318 int r;
319
320 if ((r = parse_boolean(word + 22)) < 0)
509b6efb 321 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", word + 22);
5e7ee61c 322 else
fa0f4d8a 323 arg_confirm_spawn = r;
5e7ee61c 324
601f6a1e
LP		 325 } else if (startswith(word, "systemd.crash_chvt=")) {
326 int k;
327
328 if (safe_atoi(word + 19, &k) < 0)
509b6efb 329 log_warning("Failed to parse crash chvt switch %s. Ignoring.", word + 19);
601f6a1e 330 else
fa0f4d8a 331 arg_crash_chvt = k;
601f6a1e 332
9e58ff9c
LP		 333 } else if (startswith(word, "systemd.show_status=")) {
334 int r;
335
336 if ((r = parse_boolean(word + 20)) < 0)
509b6efb 337 log_warning("Failed to parse show status switch %s. Ignoring.", word + 20);
6e98720f 338 else
9e58ff9c 339 arg_show_status = r;
0a494f1f
LP		 340 } else if (startswith(word, "systemd.default_standard_output=")) {
341 int r;
342
343 if ((r = exec_output_from_string(word + 32)) < 0)
509b6efb 344 log_warning("Failed to parse default standard output switch %s. Ignoring.", word + 32);
0a494f1f
LP		 345 else
346 arg_default_std_output = r;
347 } else if (startswith(word, "systemd.default_standard_error=")) {
348 int r;
349
350 if ((r = exec_output_from_string(word + 31)) < 0)
509b6efb 351 log_warning("Failed to parse default standard error switch %s. Ignoring.", word + 31);
0a494f1f
LP		 352 else
353 arg_default_std_error = r;
9e7c5357 354 } else if (startswith(word, "systemd.setenv=")) {
0c4025d1 355 _cleanup_free_ char *cenv = NULL;
9e7c5357
WD		 356
357 cenv = strdup(word + 15);
358 if (!cenv)
359 return -ENOMEM;
360
e21fea24
KS		 361 if (env_assignment_is_valid(cenv)) {
362 char **env;
363
364 env = strv_env_set(arg_default_environment, cenv);
365 if (env)
366 arg_default_environment = env;
367 else
368 log_warning("Setting environment variable '%s' failed, ignoring: %m", cenv);
369 } else
370 log_warning("Environment variable name '%s' is not valid. Ignoring.", cenv);
9e58ff9c 371
66a78c2b
LP		 372 } else if (startswith(word, "systemd.") ||
373 (in_initrd() && startswith(word, "rd.systemd."))) {
4fc935ca 374
dd7c30c3
LP		 375 const char *c;
376
377 /* Ignore systemd.journald.xyz and friends */
378 c = word;
379 if (startswith(c, "rd."))
380 c += 3;
381 if (startswith(c, "systemd."))
382 c += 8;
383 if (c[strcspn(c, ".=")] != '.') {
384
385 log_warning("Unknown kernel switch %s. Ignoring.", word);
386
387 log_info("Supported kernel switches:\n"
388 "systemd.unit=UNIT Default unit to start\n"
389 "rd.systemd.unit=UNIT Default unit to start when run in initrd\n"
390 "systemd.dump_core=0|1 Dump core on crash\n"
391 "systemd.crash_shell=0|1 Run shell on crash\n"
392 "systemd.crash_chvt=N Change to VT #N on crash\n"
393 "systemd.confirm_spawn=0|1 Confirm every process spawn\n"
394 "systemd.show_status=0|1 Show status updates on the console during bootup\n"
395 "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\n"
396 " Log target\n"
397 "systemd.log_level=LEVEL Log level\n"
398 "systemd.log_color=0|1 Highlight important log messages\n"
399 "systemd.log_location=0|1 Include code location in log messages\n"
400 "systemd.default_standard_output=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
401 " Set default log output for services\n"
402 "systemd.default_standard_error=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
403 " Set default log error output for services\n"
404 "systemd.setenv=ASSIGNMENT Set an environment variable for all spawned processes\n");
405 }
4fc935ca 406
d081dffb 407 } else if (streq(word, "quiet"))
6e98720f 408 arg_show_status = false;
bd6d2963
KS		 409 else if (streq(word, "debug")) {
410 /* Log to kmsg, the journal socket will fill up before the
411 * journal is started and tools running during that time
412 * will block with every log message for for 60 seconds,
413 * before they give up. */
9749cd77 414 log_set_max_level(LOG_DEBUG);
bd6d2963
KS		 415 log_set_target(LOG_TARGET_KMSG);
416 } else if (!in_initrd()) {
f170852a
LP		 417 unsigned i;
418
419 /* SysV compatibility */
f170852a
LP		 420 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
421 if (streq(word, rlmap[i]))
422 return set_default_unit(rlmap[i+1]);
423 }
424
425 return 0;
426}
427
e8e581bf
ZJS		 428#define DEFINE_SETTER(name, func, descr) \
429 static int name(const char *unit, \
430 const char *filename, \
431 unsigned line, \
432 const char *section, \
433 const char *lvalue, \
434 int ltype, \
435 const char *rvalue, \
436 void *data, \
437 void *userdata) { \
438 \
439 int r; \
440 \
441 assert(filename); \
442 assert(lvalue); \
443 assert(rvalue); \
444 \
445 r = func(rvalue); \
446 if (r < 0) \
447 log_syntax(unit, LOG_ERR, filename, line, -r, \
448 "Invalid " descr "'%s': %s", \
449 rvalue, strerror(-r)); \
450 \
451 return 0; \
452 }
487393e9 453
e8e581bf
ZJS		 454DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
455DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
456DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
457DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
487393e9 458
487393e9 459
e8e581bf
ZJS		 460static int config_parse_cpu_affinity2(const char *unit,
461 const char *filename,
462 unsigned line,
463 const char *section,
464 const char *lvalue,
465 int ltype,
466 const char *rvalue,
467 void *data,
468 void *userdata) {
487393e9
LP		 469
470 char *w;
471 size_t l;
472 char *state;
473 cpu_set_t *c = NULL;
474 unsigned ncpus = 0;
475
476 assert(filename);
477 assert(lvalue);
478 assert(rvalue);
479
f60f22df 480 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
487393e9
LP		 481 char *t;
482 int r;
483 unsigned cpu;
484
485 if (!(t = strndup(w, l)))
14212119 486 return log_oom();
487393e9
LP		 487
488 r = safe_atou(t, &cpu);
489 free(t);
490
491 if (!c)
492 if (!(c = cpu_set_malloc(&ncpus)))
14212119 493 return log_oom();
487393e9
LP		 494
495 if (r < 0 || cpu >= ncpus) {
e8e581bf
ZJS		 496 log_syntax(unit, LOG_ERR, filename, line, -r,
497 "Failed to parse CPU affinity '%s'", rvalue);
487393e9
LP		 498 CPU_FREE(c);
499 return -EBADMSG;
500 }
501
502 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
503 }
504
505 if (c) {
506 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
e8e581bf 507 log_warning_unit(unit, "Failed to set CPU affinity: %m");
487393e9
LP		 508
509 CPU_FREE(c);
510 }
511
512 return 0;
513}
514
0c85a4f3
LP		 515static void strv_free_free(char ***l) {
516 char ***i;
517
518 if (!l)
519 return;
520
521 for (i = l; *i; i++)
522 strv_free(*i);
523
524 free(l);
525}
526
527static void free_join_controllers(void) {
0c85a4f3
LP		 528 strv_free_free(arg_join_controllers);
529 arg_join_controllers = NULL;
530}
531
e8e581bf
ZJS		 532static int config_parse_join_controllers(const char *unit,
533 const char *filename,
534 unsigned line,
535 const char *section,
536 const char *lvalue,
537 int ltype,
538 const char *rvalue,
539 void *data,
540 void *userdata) {
0c85a4f3
LP		 541
542 unsigned n = 0;
543 char *state, *w;
544 size_t length;
545
546 assert(filename);
547 assert(lvalue);
548 assert(rvalue);
549
550 free_join_controllers();
551
552 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
553 char *s, **l;
554
555 s = strndup(w, length);
556 if (!s)
14212119 557 return log_oom();
0c85a4f3
LP		 558
559 l = strv_split(s, ",");
560 free(s);
561
562 strv_uniq(l);
563
564 if (strv_length(l) <= 1) {
565 strv_free(l);
566 continue;
567 }
568
569 if (!arg_join_controllers) {
570 arg_join_controllers = new(char**, 2);
571 if (!arg_join_controllers) {
572 strv_free(l);
14212119 573 return log_oom();
0c85a4f3
LP		 574 }
575
576 arg_join_controllers[0] = l;
577 arg_join_controllers[1] = NULL;
578
579 n = 1;
580 } else {
581 char ***a;
582 char ***t;
583
584 t = new0(char**, n+2);
585 if (!t) {
586 strv_free(l);
14212119 587 return log_oom();
0c85a4f3
LP		 588 }
589
590 n = 0;
591
592 for (a = arg_join_controllers; *a; a++) {
593
594 if (strv_overlap(*a, l)) {
595 char **c;
596
597 c = strv_merge(*a, l);
598 if (!c) {
599 strv_free(l);
600 strv_free_free(t);
14212119 601 return log_oom();
0c85a4f3
LP		 602 }
603
604 strv_free(l);
605 l = c;
606 } else {
607 char **c;
608
609 c = strv_copy(*a);
610 if (!c) {
611 strv_free(l);
612 strv_free_free(t);
14212119 613 return log_oom();
0c85a4f3
LP		 614 }
615
616 t[n++] = c;
617 }
618 }
619
620 t[n++] = strv_uniq(l);
621
622 strv_free_free(arg_join_controllers);
623 arg_join_controllers = t;
624 }
625 }
626
627 return 0;
628}
629
487393e9
LP		 630static int parse_config_file(void) {
631
f975e971
LP		 632 const ConfigTableItem items[] = {
633 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
634 { "Manager", "LogTarget", config_parse_target, 0, NULL },
635 { "Manager", "LogColor", config_parse_color, 0, NULL },
636 { "Manager", "LogLocation", config_parse_location, 0, NULL },
637 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
638 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
639 { "Manager", "ShowStatus", config_parse_bool, 0, &arg_show_status },
f975e971
LP		 640 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
641 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
f975e971
LP		 642 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
643 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
1f19a534
OS		 644 { "Manager", "DefaultTimeoutStartSec", config_parse_sec, 0, &arg_default_timeout_start_usec },
645 { "Manager", "DefaultTimeoutStopSec", config_parse_sec, 0, &arg_default_timeout_stop_usec },
646 { "Manager", "DefaultRestartSec", config_parse_sec, 0, &arg_default_restart_usec },
3f41e1e5
LN		 647 { "Manager", "DefaultStartLimitInterval", config_parse_sec, 0, &arg_default_start_limit_interval },
648 { "Manager", "DefaultStartLimitBurst", config_parse_unsigned, 0, &arg_default_start_limit_burst },
0c85a4f3 649 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
7f602784
LP		 650 { "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },
651 { "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_shutdown_watchdog },
ec8927ca 652 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
aa0f64ac 653 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
97d0e5f8 654 { "Manager", "DefaultEnvironment", config_parse_environ, 0, &arg_default_environment },
c93ff2e9
FC		 655 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU]},
656 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE]},
657 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA]},
658 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK]},
659 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE]},
660 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS]},
661 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE]},
662 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS]},
663 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC]},
664 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK]},
665 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS]},
666 { "Manager", "DefaultLimitSIGPENDING",config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING]},
667 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE]},
668 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE]},
669 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO]},
670 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME]},
f975e971 671 { NULL, NULL, NULL, 0, NULL }
487393e9
LP		 672 };
673
7fd1b19b 674 _cleanup_fclose_ FILE *f;
487393e9
LP		 675 const char *fn;
676 int r;
677
19adb8a3 678 fn = arg_running_as == SYSTEMD_SYSTEM ? PKGSYSCONFDIR "/system.conf" : PKGSYSCONFDIR "/user.conf";
f975e971
LP		 679 f = fopen(fn, "re");
680 if (!f) {
487393e9
LP		 681 if (errno == ENOENT)
682 return 0;
683
684 log_warning("Failed to open configuration file '%s': %m", fn);
685 return 0;
686 }
687
db5c0122 688 r = config_parse(NULL, fn, f, "Manager\0", config_item_table_lookup, (void*) items, false, false, NULL);
f975e971 689 if (r < 0)
487393e9
LP		 690 log_warning("Failed to parse configuration file: %s", strerror(-r));
691
487393e9
LP		 692 return 0;
693}
694
f170852a 695static int parse_proc_cmdline(void) {
7fd1b19b 696 _cleanup_free_ char *line = NULL;
543295ad 697 char *w, *state;
f170852a 698 size_t l;
74df0fca 699 int r;
f170852a 700
74df0fca
LP		 701 r = proc_cmdline(&line);
702 if (r < 0)
e364ad06 703 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
74df0fca 704 if (r <= 0)
f170852a 705 return 0;
f170852a
LP		 706
707 FOREACH_WORD_QUOTED(w, l, line, state) {
7fd1b19b 708 _cleanup_free_ char *word;
f170852a 709
543295ad
ZJS		 710 word = strndup(w, l);
711 if (!word)
712 return log_oom();
f170852a
LP		 713
714 r = parse_proc_cmdline_word(word);
14212119
SL		 715 if (r < 0) {
716 log_error("Failed on cmdline argument %s: %s", word, strerror(-r));
543295ad 717 return r;
14212119 718 }
f170852a
LP		 719 }
720
543295ad 721 return 0;
f170852a
LP		 722}
723
724static int parse_argv(int argc, char *argv[]) {
725
726 enum {
727 ARG_LOG_LEVEL = 0x100,
728 ARG_LOG_TARGET,
bbe63281
LP		 729 ARG_LOG_COLOR,
730 ARG_LOG_LOCATION,
2f198e2f 731 ARG_UNIT,
edb9aaa8 732 ARG_SYSTEM,
af2d49f7 733 ARG_USER,
e537352b 734 ARG_TEST,
9ba0bc4e 735 ARG_VERSION,
80876c20 736 ARG_DUMP_CONFIGURATION_ITEMS,
9e58ff9c
LP		 737 ARG_DUMP_CORE,
738 ARG_CRASH_SHELL,
a16e1123 739 ARG_CONFIRM_SPAWN,
9e58ff9c 740 ARG_SHOW_STATUS,
4288f619 741 ARG_DESERIALIZE,
2660882b 742 ARG_SWITCHED_ROOT,
0a494f1f
LP		 743 ARG_DEFAULT_STD_OUTPUT,
744 ARG_DEFAULT_STD_ERROR
f170852a
LP		 745 };
746
747 static const struct option options[] = {
a16e1123
LP		 748 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
749 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
bbe63281
LP		 750 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
751 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
2f198e2f 752 { "unit", required_argument, NULL, ARG_UNIT },
edb9aaa8 753 { "system", no_argument, NULL, ARG_SYSTEM },
af2d49f7 754 { "user", no_argument, NULL, ARG_USER },
a16e1123
LP		 755 { "test", no_argument, NULL, ARG_TEST },
756 { "help", no_argument, NULL, 'h' },
9ba0bc4e 757 { "version", no_argument, NULL, ARG_VERSION },
a16e1123 758 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
a5d87bf0
LP		 759 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
760 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
761 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
6e98720f 762 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
a16e1123 763 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
2660882b 764 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
0a494f1f
LP		 765 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
766 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
a16e1123 767 { NULL, 0, NULL, 0 }
f170852a
LP		 768 };
769
770 int c, r;
771
772 assert(argc >= 1);
773 assert(argv);
774
b770165a
LP		 775 if (getpid() == 1)
776 opterr = 0;
777
099663ff 778 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
f170852a
LP		 779
780 switch (c) {
781
782 case ARG_LOG_LEVEL:
783 if ((r = log_set_max_level_from_string(optarg)) < 0) {
784 log_error("Failed to parse log level %s.", optarg);
785 return r;
786 }
787
788 break;
789
790 case ARG_LOG_TARGET:
791
792 if ((r = log_set_target_from_string(optarg)) < 0) {
793 log_error("Failed to parse log target %s.", optarg);
794 return r;
795 }
796
797 break;
798
bbe63281
LP		 799 case ARG_LOG_COLOR:
800
d0b170c8
LP		 801 if (optarg) {
802 if ((r = log_show_color_from_string(optarg)) < 0) {
803 log_error("Failed to parse log color setting %s.", optarg);
804 return r;
805 }
806 } else
807 log_show_color(true);
bbe63281
LP		 808
809 break;
810
811 case ARG_LOG_LOCATION:
812
d0b170c8
LP		 813 if (optarg) {
814 if ((r = log_show_location_from_string(optarg)) < 0) {
815 log_error("Failed to parse log location setting %s.", optarg);
816 return r;
817 }
818 } else
819 log_show_location(true);
bbe63281
LP		 820
821 break;
822
0a494f1f
LP		 823 case ARG_DEFAULT_STD_OUTPUT:
824
825 if ((r = exec_output_from_string(optarg)) < 0) {
826 log_error("Failed to parse default standard output setting %s.", optarg);
827 return r;
828 } else
829 arg_default_std_output = r;
830 break;
831
832 case ARG_DEFAULT_STD_ERROR:
833
834 if ((r = exec_output_from_string(optarg)) < 0) {
835 log_error("Failed to parse default standard error output setting %s.", optarg);
836 return r;
837 } else
838 arg_default_std_error = r;
839 break;
840
2f198e2f 841 case ARG_UNIT:
f170852a
LP		 842
843 if ((r = set_default_unit(optarg)) < 0) {
844 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
845 return r;
846 }
847
848 break;
849
edb9aaa8 850 case ARG_SYSTEM:
67445f4e 851 arg_running_as = SYSTEMD_SYSTEM;
edb9aaa8 852 break;
a5dab5ce 853
af2d49f7 854 case ARG_USER:
67445f4e 855 arg_running_as = SYSTEMD_USER;
a5dab5ce 856 break;
a5dab5ce 857
e965d56d 858 case ARG_TEST:
fa0f4d8a 859 arg_action = ACTION_TEST;
e965d56d
LP		 860 break;
861
9ba0bc4e
ZJS		 862 case ARG_VERSION:
863 arg_action = ACTION_VERSION;
864 break;
865
e537352b 866 case ARG_DUMP_CONFIGURATION_ITEMS:
fa0f4d8a 867 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
e537352b
LP		 868 break;
869
9e58ff9c 870 case ARG_DUMP_CORE:
a5d87bf0
LP		 871 r = optarg ? parse_boolean(optarg) : 1;
872 if (r < 0) {
873 log_error("Failed to parse dump core boolean %s.", optarg);
874 return r;
875 }
876 arg_dump_core = r;
9e58ff9c
LP		 877 break;
878
879 case ARG_CRASH_SHELL:
a5d87bf0
LP		 880 r = optarg ? parse_boolean(optarg) : 1;
881 if (r < 0) {
882 log_error("Failed to parse crash shell boolean %s.", optarg);
883 return r;
884 }
885 arg_crash_shell = r;
9e58ff9c
LP		 886 break;
887
80876c20 888 case ARG_CONFIRM_SPAWN:
a5d87bf0
LP		 889 r = optarg ? parse_boolean(optarg) : 1;
890 if (r < 0) {
891 log_error("Failed to parse confirm spawn boolean %s.", optarg);
892 return r;
893 }
894 arg_confirm_spawn = r;
80876c20
LP		 895 break;
896
9e58ff9c 897 case ARG_SHOW_STATUS:
a5d87bf0
LP		 898 r = optarg ? parse_boolean(optarg) : 1;
899 if (r < 0) {
900 log_error("Failed to parse show status boolean %s.", optarg);
901 return r;
902 }
903 arg_show_status = r;
6e98720f 904 break;
a5d87bf0 905
a16e1123
LP		 906 case ARG_DESERIALIZE: {
907 int fd;
908 FILE *f;
909
01e10de3
LP		 910 r = safe_atoi(optarg, &fd);
911 if (r < 0 || fd < 0) {
a16e1123 912 log_error("Failed to parse deserialize option %s.", optarg);
01e10de3 913 return r < 0 ? r : -EINVAL;
a16e1123
LP		 914 }
915
01e10de3
LP		 916 fd_cloexec(fd, true);
917
918 f = fdopen(fd, "r");
919 if (!f) {
a16e1123 920 log_error("Failed to open serialization fd: %m");
01e10de3 921 return -errno;
a16e1123
LP		 922 }
923
924 if (serialization)
925 fclose(serialization);
926
927 serialization = f;
928
929 break;
930 }
931
2660882b 932 case ARG_SWITCHED_ROOT:
bf4df7c3 933 arg_switched_root = true;
d03bc1b8
HH		 934 break;
935
f170852a 936 case 'h':
fa0f4d8a 937 arg_action = ACTION_HELP;
f170852a
LP		 938 break;
939
1d2e23ab
LP		 940 case 'D':
941 log_set_max_level(LOG_DEBUG);
942 break;
943
099663ff
LP		 944 case 'b':
945 case 's':
946 case 'z':
947 /* Just to eat away the sysvinit kernel
948 * cmdline args without getopt() error
949 * messages that we'll parse in
950 * parse_proc_cmdline_word() or ignore. */
f170852a 951
099663ff 952 case '?':
f170852a 953 default:
099663ff
LP		 954 if (getpid() != 1) {
955 log_error("Unknown option code %c", c);
956 return -EINVAL;
957 }
958
959 break;
f170852a
LP		 960 }
961
d821e6d6
LP		 962 if (optind < argc && getpid() != 1) {
963 /* Hmm, when we aren't run as init system
964 * let's complain about excess arguments */
965
966 log_error("Excess arguments.");
967 return -EINVAL;
968 }
969
970 if (detect_container(NULL) > 0) {
971 char **a;
972
973 /* All /proc/cmdline arguments the kernel didn't
974 * understand it passed to us. We're not really
975 * interested in that usually since /proc/cmdline is
976 * more interesting and complete. With one exception:
977 * if we are run in a container /proc/cmdline is not
978 * relevant for the container, hence we rely on argv[]
979 * instead. */
980
74df0fca
LP		 981 for (a = argv; a < argv + argc; a++) {
982 r = parse_proc_cmdline_word(*a);
983 if (r < 0) {
14212119 984 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
d821e6d6 985 return r;
14212119 986 }
74df0fca 987 }
51f0e189
LP		 988 }
989
f170852a
LP		 990 return 0;
991}
992
993static int help(void) {
994
2e33c433 995 printf("%s [OPTIONS...]\n\n"
af2d49f7 996 "Starts up and maintains the system or user services.\n\n"
e537352b 997 " -h --help Show this help\n"
e537352b 998 " --test Determine startup sequence, dump it and exit\n"
80876c20 999 " --dump-configuration-items Dump understood unit configuration items\n"
9e58ff9c 1000 " --unit=UNIT Set default unit\n"
edb9aaa8 1001 " --system Run a system instance, even if PID != 1\n"
af2d49f7 1002 " --user Run a user instance\n"
a5d87bf0
LP		 1003 " --dump-core[=0|1] Dump core on crash\n"
1004 " --crash-shell[=0|1] Run shell on crash\n"
1005 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
6e98720f 1006 " --show-status[=0|1] Show status updates on the console during bootup\n"
4cfa2c99 1007 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
9e58ff9c 1008 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
2218198b 1009 " --log-color[=0|1] Highlight important log messages\n"
0a494f1f
LP		 1010 " --log-location[=0|1] Include code location in log messages\n"
1011 " --default-standard-output= Set default standard output for services\n"
1012 " --default-standard-error= Set default standard error output for services\n",
5b6319dc 1013 program_invocation_short_name);
f170852a
LP		 1014
1015 return 0;
1016}
1017
9ba0bc4e
ZJS		 1018static int version(void) {
1019 puts(PACKAGE_STRING);
9ba0bc4e
ZJS		 1020 puts(SYSTEMD_FEATURES);
1021
1022 return 0;
1023}
1024
b3680f49 1025static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
a16e1123
LP		 1026 FILE *f = NULL;
1027 FDSet *fds = NULL;
1028 int r;
1029
1030 assert(m);
1031 assert(_f);
1032 assert(_fds);
1033
6b78f9b4
LP		 1034 r = manager_open_serialization(m, &f);
1035 if (r < 0) {
35b8ca3a 1036 log_error("Failed to create serialization file: %s", strerror(-r));
a16e1123
LP		 1037 goto fail;
1038 }
1039
71445ae7
LP		 1040 /* Make sure nothing is really destructed when we shut down */
1041 m->n_reloading ++;
1042 bus_broadcast_reloading(m, true);
1043
6b78f9b4
LP		 1044 fds = fdset_new();
1045 if (!fds) {
a16e1123
LP		 1046 r = -ENOMEM;
1047 log_error("Failed to allocate fd set: %s", strerror(-r));
1048 goto fail;
1049 }
1050
b3680f49 1051 r = manager_serialize(m, f, fds, switching_root);
6b78f9b4 1052 if (r < 0) {
a16e1123
LP		 1053 log_error("Failed to serialize state: %s", strerror(-r));
1054 goto fail;
1055 }
1056
1057 if (fseeko(f, 0, SEEK_SET) < 0) {
1058 log_error("Failed to rewind serialization fd: %m");
1059 goto fail;
1060 }
1061
6b78f9b4
LP		 1062 r = fd_cloexec(fileno(f), false);
1063 if (r < 0) {
a16e1123
LP		 1064 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1065 goto fail;
1066 }
1067
6b78f9b4
LP		 1068 r = fdset_cloexec(fds, false);
1069 if (r < 0) {
a16e1123
LP		 1070 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1071 goto fail;
1072 }
1073
1074 *_f = f;
1075 *_fds = fds;
1076
1077 return 0;
1078
1079fail:
1080 fdset_free(fds);
1081
1082 if (f)
1083 fclose(f);
1084
1085 return r;
1086}
1087
4096d6f5
LP		 1088static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1089 struct rlimit nl;
1090 int r;
1091
1092 assert(saved_rlimit);
1093
1094 /* Save the original RLIMIT_NOFILE so that we can reset it
1095 * later when transitioning from the initrd to the main
1096 * systemd or suchlike. */
1097 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1098 log_error("Reading RLIMIT_NOFILE failed: %m");
1099 return -errno;
1100 }
1101
1102 /* Make sure forked processes get the default kernel setting */
1103 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1104 struct rlimit *rl;
1105
1106 rl = newdup(struct rlimit, saved_rlimit, 1);
1107 if (!rl)
1108 return log_oom();
1109
1110 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1111 }
1112
1113 /* Bump up the resource limit for ourselves substantially */
1114 nl.rlim_cur = nl.rlim_max = 64*1024;
1115 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1116 if (r < 0) {
1117 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1118 return r;
1119 }
1120
1121 return 0;
1122}
1123
6ee5bbf8
LP		 1124static void test_mtab(void) {
1125 char *p;
1126
80758717
LP		 1127 /* Check that /etc/mtab is a symlink */
1128
6ee5bbf8
LP		 1129 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1130 bool b;
1131
ed86ebc4 1132 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
6ee5bbf8
LP		 1133 free(p);
1134
1135 if (b)
1136 return;
1137 }
1138
80758717
LP		 1139 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1140 "This is not supported anymore. "
1141 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1142}
1143
1144static void test_usr(void) {
80758717 1145
ed1c99fc 1146 /* Check that /usr is not a separate fs */
80758717 1147
871c44a7
LP		 1148 if (dir_is_empty("/usr") <= 0)
1149 return;
1150
2376ce13 1151 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
871c44a7
LP		 1152 "Some things will probably break (sometimes even silently) in mysterious ways. "
1153 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1154}
1155
1156static void test_cgroups(void) {
1157
1158 if (access("/proc/cgroups", F_OK) >= 0)
1159 return;
1160
1161 log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1162 "Systems without control groups are not supported. "
1163 "We will now sleep for 10s, and then continue boot-up. "
1164 "Expect breakage and please do not file bugs. "
966a5d37
LP		 1165 "Instead fix your kernel and enable CONFIG_CGROUPS. "
1166 "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
871c44a7
LP		 1167
1168 sleep(10);
6ee5bbf8
LP		 1169}
1170
a07fdfa3
LP		 1171static int initialize_join_controllers(void) {
1172 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1173 * + "net_prio". We'd like to add "cpuset" to the mix, but
1174 * "cpuset" does't really work for groups with no initialized
1175 * attributes. */
1176
1177 arg_join_controllers = new(char**, 3);
1178 if (!arg_join_controllers)
1179 return -ENOMEM;
1180
1181 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
a07fdfa3 1182 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
a6b26d90
ZJS		 1183 arg_join_controllers[2] = NULL;
1184
1185 if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1186 free_join_controllers();
a07fdfa3 1187 return -ENOMEM;
a6b26d90 1188 }
a07fdfa3 1189
a07fdfa3
LP		 1190 return 0;
1191}
1192
60918275
LP		 1193int main(int argc, char *argv[]) {
1194 Manager *m = NULL;
22f4096c 1195 int r, retval = EXIT_FAILURE;
9d76d730
LP		 1196 usec_t before_startup, after_startup;
1197 char timespan[FORMAT_TIMESPAN_MAX];
a16e1123
LP		 1198 FDSet *fds = NULL;
1199 bool reexecute = false;
b9080b03 1200 const char *shutdown_verb = NULL;
e9ddabc2 1201 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
c3a170f3
HH		 1202 dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1203 dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
5d6b1584 1204 static char systemd[] = "systemd";
2660882b 1205 bool skip_setup = false;
0b3325e7
LP		 1206 int j;
1207 bool loaded_policy = false;
e96d6be7 1208 bool arm_reboot_watchdog = false;
bf4df7c3 1209 bool queue_default_job = false;
41669317 1210 char *switch_root_dir = NULL, *switch_root_init = NULL;
4096d6f5 1211 static struct rlimit saved_rlimit_nofile = { 0, 0 };
27b14a22 1212
058dc6f3 1213#ifdef HAVE_SYSV_COMPAT
2cb1a60d 1214 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
35b8ca3a 1215 /* This is compatibility support for SysV, where
2cb1a60d
LP		 1216 * calling init as a user is identical to telinit. */
1217
1218 errno = -ENOENT;
1219 execv(SYSTEMCTL_BINARY_PATH, argv);
1220 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1221 return 1;
1222 }
058dc6f3 1223#endif
2cb1a60d 1224
c3a170f3
HH		 1225 dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1226 dual_timestamp_get(&userspace_timestamp);
1227
0b3325e7
LP		 1228 /* Determine if this is a reexecution or normal bootup. We do
1229 * the full command line parsing much later, so let's just
1230 * have a quick peek here. */
db813c2a
LP		 1231 if (strv_find(argv+1, "--deserialize"))
1232 skip_setup = true;
0b3325e7 1233
2660882b
LP		 1234 /* If we have switched root, do all the special setup
1235 * things */
db813c2a
LP		 1236 if (strv_find(argv+1, "--switched-root"))
1237 skip_setup = false;
d03bc1b8 1238
f3b6a3ed
LP		 1239 /* If we get started via the /sbin/init symlink then we are
1240 called 'init'. After a subsequent reexecution we are then
1241 called 'systemd'. That is confusing, hence let's call us
1242 systemd right-away. */
f3b6a3ed
LP		 1243 program_invocation_short_name = systemd;
1244 prctl(PR_SET_NAME, systemd);
5d6b1584 1245
9a0e6896
LP		 1246 saved_argv = argv;
1247 saved_argc = argc;
f3b6a3ed 1248
2cc59dbf 1249 log_show_color(isatty(STDERR_FILENO) > 0);
bbe63281 1250
90dc8c2e
MG		 1251 /* Disable the umask logic */
1252 if (getpid() == 1)
1253 umask(0);
1254
a866073d 1255 if (getpid() == 1 && detect_container(NULL) <= 0) {
4f8d551f 1256
a866073d 1257 /* Running outside of a container as PID 1 */
67445f4e 1258 arg_running_as = SYSTEMD_SYSTEM;
a866073d
LP		 1259 make_null_stdio();
1260 log_set_target(LOG_TARGET_KMSG);
1261 log_open();
1262
21bf2ab0 1263 if (in_initrd())
c3a170f3 1264 initrd_timestamp = userspace_timestamp;
c3ba6250 1265
2660882b 1266 if (!skip_setup) {
8f838d8a 1267 mount_setup_early();
0b3325e7
LP		 1268 if (selinux_setup(&loaded_policy) < 0)
1269 goto finish;
81611586
RS		 1270 if (ima_setup() < 0)
1271 goto finish;
ffbd2c4d
NC		 1272 if (smack_setup() < 0)
1273 goto finish;
81611586 1274 }
0b3325e7 1275
e9a5ef7c 1276 if (label_init(NULL) < 0)
0ff4cdd9 1277 goto finish;
7948c4df 1278
72edcff5 1279 if (!skip_setup) {
0b3325e7
LP		 1280 if (hwclock_is_localtime() > 0) {
1281 int min;
7948c4df 1282
72edcff5
KS		 1283 /* The first-time call to settimeofday() does a time warp in the kernel */
1284 r = hwclock_set_timezone(&min);
0b3325e7
LP		 1285 if (r < 0)
1286 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1287 else
1288 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
19e65613
KS		 1289 } else if (!in_initrd()) {
1290 /*
1291 * Do dummy first-time call to seal the kernel's time warp magic
1292 *
1293 * Do not call this this from inside the initrd. The initrd might not
1294 * carry /etc/adjtime with LOCAL, but the real system could be set up
1295 * that way. In such case, we need to delay the time-warp or the sealing
1296 * until we reach the real system.
1297 */
72edcff5 1298 hwclock_reset_timezone();
871e5809 1299
e9dd9f95 1300 /* Tell the kernel our timezone */
72edcff5
KS		 1301 r = hwclock_set_timezone(NULL);
1302 if (r < 0)
e9dd9f95 1303 log_error("Failed to set the kernel's timezone, ignoring: %s", strerror(-r));
72edcff5
KS		 1304 }
1305 }
a866073d
LP		 1306
1307 /* Set the default for later on, but don't actually
1308 * open the logs like this for now. Note that if we
1309 * are transitioning from the initrd there might still
1310 * be journal fd open, and we shouldn't attempt
1311 * opening that before we parsed /proc/cmdline which
1312 * might redirect output elsewhere. */
1313 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1314
1315 } else if (getpid() == 1) {
a866073d 1316 /* Running inside a container, as PID 1 */
67445f4e 1317 arg_running_as = SYSTEMD_SYSTEM;
a866073d
LP		 1318 log_set_target(LOG_TARGET_CONSOLE);
1319 log_open();
1320
1321 /* For the later on, see above... */
1322 log_set_target(LOG_TARGET_JOURNAL);
1323
c3a170f3
HH		 1324 /* clear the kernel timestamp,
1325 * because we are in a container */
1326 kernel_timestamp.monotonic = 0ULL;
1327 kernel_timestamp.realtime = 0ULL;
a866073d 1328
c3a170f3 1329 } else {
a866073d 1330 /* Running as user instance */
67445f4e 1331 arg_running_as = SYSTEMD_USER;
eeecf6e6 1332 log_set_target(LOG_TARGET_AUTO);
871e5809 1333 log_open();
c3a170f3
HH		 1334
1335 /* clear the kernel timestamp,
1336 * because we are not PID 1 */
1337 kernel_timestamp.monotonic = 0ULL;
1338 kernel_timestamp.realtime = 0ULL;
bbe63281 1339 }
a5dab5ce 1340
0c85a4f3 1341 /* Initialize default unit */
6afa301b
LP		 1342 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1343 if (r < 0) {
14212119 1344 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
f170852a 1345 goto finish;
14212119 1346 }
60918275 1347
a07fdfa3
LP		 1348 r = initialize_join_controllers();
1349 if (r < 0)
0c85a4f3
LP		 1350 goto finish;
1351
f170852a
LP		 1352 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1353 * /proc/$PID/fd is available. */
c1dae1b3 1354 if (getpid() == 1) {
0c85a4f3
LP		 1355 r = mount_setup(loaded_policy);
1356 if (r < 0)
8efe3c01 1357 goto finish;
0c85a4f3 1358 }
4ade7963
LP		 1359
1360 /* Reset all signal handlers. */
1361 assert_se(reset_all_signal_handlers() == 0);
1362
9a34ec5f 1363 ignore_signals(SIGNALS_IGNORE, -1);
078e4539 1364
487393e9
LP		 1365 if (parse_config_file() < 0)
1366 goto finish;
1367
67445f4e 1368 if (arg_running_as == SYSTEMD_SYSTEM)
a5dab5ce
LP		 1369 if (parse_proc_cmdline() < 0)
1370 goto finish;
f170852a
LP		 1371
1372 log_parse_environment();
1373
1374 if (parse_argv(argc, argv) < 0)
1375 goto finish;
1376
6bae23a0
TB		 1377 if (arg_action == ACTION_TEST &&
1378 geteuid() == 0) {
b5c6cf87
LP		 1379 log_error("Don't run test mode as root.");
1380 goto finish;
1381 }
1382
6bae23a0
TB		 1383 if (arg_running_as == SYSTEMD_USER &&
1384 arg_action == ACTION_RUN &&
1385 sd_booted() <= 0) {
1386 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1387 goto finish;
1388 }
1389
67445f4e 1390 if (arg_running_as == SYSTEMD_SYSTEM &&
fe783b03
LP		 1391 arg_action == ACTION_RUN &&
1392 running_in_chroot() > 0) {
1393 log_error("Cannot be run in a chroot() environment.");
1394 goto finish;
1395 }
1396
fa0f4d8a 1397 if (arg_action == ACTION_HELP) {
f170852a
LP		 1398 retval = help();
1399 goto finish;
9ba0bc4e
ZJS		 1400 } else if (arg_action == ACTION_VERSION) {
1401 retval = version();
1402 goto finish;
fa0f4d8a 1403 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
e537352b 1404 unit_dump_config_items(stdout);
22f4096c 1405 retval = EXIT_SUCCESS;
e537352b 1406 goto finish;
fa0f4d8a 1407 } else if (arg_action == ACTION_DONE) {
22f4096c 1408 retval = EXIT_SUCCESS;
4288f619 1409 goto finish;
f170852a
LP		 1410 }
1411
8be28fb1
KS		 1412 if (arg_running_as == SYSTEMD_USER &&
1413 !getenv("XDG_RUNTIME_DIR")) {
1414 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1415 goto finish;
1416 }
1417
fa0f4d8a 1418 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
f170852a 1419
871e5809
LP		 1420 /* Close logging fds, in order not to confuse fdset below */
1421 log_close();
1422
a16e1123 1423 /* Remember open file descriptors for later deserialization */
01e10de3
LP		 1424 r = fdset_new_fill(&fds);
1425 if (r < 0) {
1426 log_error("Failed to allocate fd set: %s", strerror(-r));
1427 goto finish;
1428 } else
1429 fdset_cloexec(fds, true);
a16e1123 1430
01e10de3 1431 if (serialization)
a16e1123 1432 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
a16e1123 1433
90dc8c2e 1434 if (arg_running_as == SYSTEMD_SYSTEM)
80876c20
LP		 1435 /* Become a session leader if we aren't one yet. */
1436 setsid();
4ade7963 1437
befb5b6a
LP		 1438 /* Move out of the way, so that we won't block unmounts */
1439 assert_se(chdir("/") == 0);
1440
843d2643
LP		 1441 /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1442 dbus_connection_set_change_sigpipe(FALSE);
1443
2146621b
LP		 1444 /* Reset the console, but only if this is really init and we
1445 * are freshly booted */
67445f4e 1446 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
2660882b 1447 console_setup(getpid() == 1 && !skip_setup);
4ade7963 1448
18149b9f 1449 /* Open the logging devices, if possible and necessary */
843d2643 1450 log_open();
4ade7963 1451
5373d602
LP		 1452 /* Make sure we leave a core dump without panicing the
1453 * kernel. */
ab422445 1454 if (getpid() == 1) {
4fc935ca 1455 install_crash_handler();
97c4f35c 1456
0c85a4f3
LP		 1457 r = mount_cgroup_controllers(arg_join_controllers);
1458 if (r < 0)
1459 goto finish;
1460 }
1461
67445f4e 1462 if (arg_running_as == SYSTEMD_SYSTEM) {
c20f5ac7
LP		 1463 const char *virtualization = NULL;
1464
bc270841 1465 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
c20f5ac7
LP		 1466
1467 detect_virtualization(&virtualization);
1468 if (virtualization)
1469 log_info("Detected virtualization '%s'.", virtualization);
1470
26a1efdf
LP		 1471 if (in_initrd())
1472 log_info("Running in initial RAM disk.");
1473
c20f5ac7 1474 } else
bc270841 1475 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES ")");
a5dab5ce 1476
67445f4e 1477 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
6faa1114 1478 if (arg_show_status || plymouth_running())
888c6216
LP		 1479 status_welcome();
1480
e3043162 1481#ifdef HAVE_KMOD
888c6216 1482 kmod_setup();
e3043162 1483#endif
888c6216 1484 hostname_setup();
d7ccca2e 1485 machine_id_setup();
888c6216 1486 loopback_setup();
490aed58 1487
6ee5bbf8 1488 test_mtab();
80758717 1489 test_usr();
871c44a7 1490 test_cgroups();
af5bc85d 1491 }
302e8c4c 1492
67445f4e 1493 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
e96d6be7
LP		 1494 watchdog_set_timeout(&arg_runtime_watchdog);
1495
aa0f64ac
LP		 1496 if (arg_timer_slack_nsec != (nsec_t) -1)
1497 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1498 log_error("Failed to adjust timer slack: %m");
1499
ec8927ca 1500 if (arg_capability_bounding_set_drop) {
31c885e9 1501 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
ec8927ca 1502 if (r < 0) {
31c885e9 1503 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
ec8927ca
LP		 1504 goto finish;
1505 }
31c885e9 1506 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
939b8f14 1507 if (r < 0) {
31c885e9 1508 log_error("Failed to drop capability bounding set: %s", strerror(-r));
939b8f14
LP		 1509 goto finish;
1510 }
ec8927ca
LP		 1511 }
1512
67445f4e 1513 if (arg_running_as == SYSTEMD_USER) {
d4447f4d 1514 /* Become reaper of our children */
8b8ffe68
LP		 1515 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1516 log_warning("Failed to make us a subreaper: %m");
1517 if (errno == EINVAL)
ddfa5101 1518 log_info("Perhaps the kernel version is too old (< 3.4?)");
8b8ffe68 1519 }
d4447f4d
AK		 1520 }
1521
67445f4e 1522 if (arg_running_as == SYSTEMD_SYSTEM)
4096d6f5
LP		 1523 bump_rlimit_nofile(&saved_rlimit_nofile);
1524
6fa48533 1525 r = manager_new(arg_running_as, !!serialization, &m);
e96d6be7 1526 if (r < 0) {
8e274523 1527 log_error("Failed to allocate manager object: %s", strerror(-r));
60918275
LP		 1528 goto finish;
1529 }
1530
9e58ff9c 1531 m->confirm_spawn = arg_confirm_spawn;
0a494f1f
LP		 1532 m->default_std_output = arg_default_std_output;
1533 m->default_std_error = arg_default_std_error;
1f19a534
OS		 1534 m->default_restart_usec = arg_default_restart_usec;
1535 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1536 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
3f41e1e5
LN		 1537 m->default_start_limit_interval = arg_default_start_limit_interval;
1538 m->default_start_limit_burst = arg_default_start_limit_burst;
e96d6be7
LP		 1539 m->runtime_watchdog = arg_runtime_watchdog;
1540 m->shutdown_watchdog = arg_shutdown_watchdog;
c3a170f3
HH		 1541 m->userspace_timestamp = userspace_timestamp;
1542 m->kernel_timestamp = kernel_timestamp;
c3a170f3 1543 m->initrd_timestamp = initrd_timestamp;
9e58ff9c 1544
c93ff2e9
FC		 1545 manager_set_default_rlimits(m, arg_default_rlimit);
1546
97d0e5f8 1547 if (arg_default_environment)
e21fea24 1548 manager_environment_add(m, arg_default_environment);
97d0e5f8 1549
27d340c7
LP		 1550 manager_set_show_status(m, arg_show_status);
1551
bf4df7c3
LP		 1552 /* Remember whether we should queue the default job */
1553 queue_default_job = !serialization || arg_switched_root;
1554
9d76d730
LP		 1555 before_startup = now(CLOCK_MONOTONIC);
1556
e96d6be7
LP		 1557 r = manager_startup(m, serialization, fds);
1558 if (r < 0)
6e2ef85b 1559 log_error("Failed to fully start up daemon: %s", strerror(-r));
a16e1123 1560
bf4df7c3
LP		 1561 /* This will close all file descriptors that were opened, but
1562 * not claimed by any unit. */
01e10de3 1563 fdset_free(fds);
6c081276 1564 fds = NULL;
f50e0a01 1565
a16e1123
LP		 1566 if (serialization) {
1567 fclose(serialization);
1568 serialization = NULL;
bf4df7c3
LP		 1569 }
1570
1571 if (queue_default_job) {
398ef8ba 1572 DBusError error;
1c27d3f3 1573 Unit *target = NULL;
bacbccb7 1574 Job *default_unit_job;
398ef8ba
LP		 1575
1576 dbus_error_init(&error);
1577
fa0f4d8a 1578 log_debug("Activating default unit: %s", arg_default_unit);
a16e1123 1579
e96d6be7
LP		 1580 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1581 if (r < 0) {
398ef8ba
LP		 1582 log_error("Failed to load default target: %s", bus_error(&error, r));
1583 dbus_error_free(&error);
c2756a68 1584 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
ac155bb8
MS		 1585 log_error("Failed to load default target: %s", strerror(-target->load_error));
1586 else if (target->load_state == UNIT_MASKED)
6daf4f90 1587 log_error("Default target masked.");
27b14a22 1588
ac155bb8 1589 if (!target || target->load_state != UNIT_LOADED) {
a16e1123 1590 log_info("Trying to load rescue target...");
1c27d3f3 1591
e96d6be7
LP		 1592 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1593 if (r < 0) {
398ef8ba
LP		 1594 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1595 dbus_error_free(&error);
a16e1123 1596 goto finish;
11ddb6f4 1597 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
ac155bb8 1598 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1c27d3f3 1599 goto finish;
ac155bb8 1600 } else if (target->load_state == UNIT_MASKED) {
6daf4f90 1601 log_error("Rescue target masked.");
00dc5d76 1602 goto finish;
a16e1123
LP		 1603 }
1604 }
37d88da7 1605
ac155bb8 1606 assert(target->load_state == UNIT_LOADED);
00dc5d76 1607
fa0f4d8a 1608 if (arg_action == ACTION_TEST) {
40d50879 1609 printf("-> By units:\n");
a16e1123
LP		 1610 manager_dump_units(m, stdout, "\t");
1611 }
1612
95f1b47d 1613 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
ab17a050 1614 if (r == -EPERM) {
cd8f53ab 1615 log_debug("Default target could not be isolated, starting instead: %s", bus_error(&error, r));
ab17a050
LP		 1616 dbus_error_free(&error);
1617
1618 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1619 if (r < 0) {
1620 log_error("Failed to start default target: %s", bus_error(&error, r));
1621 dbus_error_free(&error);
1622 goto finish;
1623 }
1624 } else if (r < 0) {
1625 log_error("Failed to isolate default target: %s", bus_error(&error, r));
398ef8ba 1626 dbus_error_free(&error);
37d88da7
LP		 1627 goto finish;
1628 }
ab17a050 1629
bacbccb7 1630 m->default_unit_job_id = default_unit_job->id;
60918275 1631
07672f49
LP		 1632 after_startup = now(CLOCK_MONOTONIC);
1633 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1634 "Loaded units and determined initial transaction in %s.",
2fa4092c 1635 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
07672f49 1636
fa0f4d8a 1637 if (arg_action == ACTION_TEST) {
40d50879 1638 printf("-> By jobs:\n");
a16e1123 1639 manager_dump_jobs(m, stdout, "\t");
22f4096c 1640 retval = EXIT_SUCCESS;
a16e1123
LP		 1641 goto finish;
1642 }
e965d56d 1643 }
d46de8a1 1644
a16e1123 1645 for (;;) {
e96d6be7
LP		 1646 r = manager_loop(m);
1647 if (r < 0) {
a16e1123
LP		 1648 log_error("Failed to run mainloop: %s", strerror(-r));
1649 goto finish;
1650 }
11dd41ce 1651
a16e1123 1652 switch (m->exit_code) {
e965d56d 1653
a16e1123 1654 case MANAGER_EXIT:
22f4096c 1655 retval = EXIT_SUCCESS;
a16e1123
LP		 1656 log_debug("Exit.");
1657 goto finish;
e965d56d 1658
a16e1123 1659 case MANAGER_RELOAD:
e015090f 1660 log_info("Reloading.");
e96d6be7
LP		 1661 r = manager_reload(m);
1662 if (r < 0)
a16e1123
LP		 1663 log_error("Failed to reload: %s", strerror(-r));
1664 break;
cea8e32e 1665
a16e1123 1666 case MANAGER_REEXECUTE:
664f88a7 1667
b3680f49 1668 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
a16e1123 1669 goto finish;
60918275 1670
a16e1123 1671 reexecute = true;
e015090f 1672 log_notice("Reexecuting.");
a16e1123
LP		 1673 goto finish;
1674
664f88a7
LP		 1675 case MANAGER_SWITCH_ROOT:
1676 /* Steal the switch root parameters */
41669317 1677 switch_root_dir = m->switch_root;
664f88a7
LP		 1678 switch_root_init = m->switch_root_init;
1679 m->switch_root = m->switch_root_init = NULL;
1680
1681 if (!switch_root_init)
b3680f49 1682 if (prepare_reexecute(m, &serialization, &fds, true) < 0)
664f88a7
LP		 1683 goto finish;
1684
1685 reexecute = true;
1686 log_notice("Switching root.");
1687 goto finish;
1688
b9080b03
FF		 1689 case MANAGER_REBOOT:
1690 case MANAGER_POWEROFF:
1691 case MANAGER_HALT:
1692 case MANAGER_KEXEC: {
1693 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1694 [MANAGER_REBOOT] = "reboot",
1695 [MANAGER_POWEROFF] = "poweroff",
1696 [MANAGER_HALT] = "halt",
1697 [MANAGER_KEXEC] = "kexec"
1698 };
1699
1700 assert_se(shutdown_verb = table[m->exit_code]);
e96d6be7 1701 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
b9080b03
FF		 1702
1703 log_notice("Shutting down.");
1704 goto finish;
1705 }
1706
a16e1123
LP		 1707 default:
1708 assert_not_reached("Unknown exit code.");
1709 }
1710 }
f170852a 1711
60918275
LP		 1712finish:
1713 if (m)
1714 manager_free(m);
1715
c93ff2e9 1716 for (j = 0; j < RLIMIT_NLIMITS; j++)
4096d6f5 1717 free(arg_default_rlimit[j]);
c93ff2e9 1718
fa0f4d8a 1719 free(arg_default_unit);
0c85a4f3 1720 free_join_controllers();
b9cd2ec1 1721
ea430986 1722 dbus_shutdown();
b2bb3dbe
LP		 1723 label_finish();
1724
a16e1123 1725 if (reexecute) {
664f88a7 1726 const char **args;
e564a982 1727 unsigned i, args_size;
a16e1123 1728
664f88a7
LP		 1729 /* Close and disarm the watchdog, so that the new
1730 * instance can reinitialize it, but doesn't get
1731 * rebooted while we do that */
1732 watchdog_close(true);
a16e1123 1733
4096d6f5
LP		 1734 /* Reset the RLIMIT_NOFILE to the kernel default, so
1735 * that the new systemd can pass the kernel default to
1736 * its child processes */
1737 if (saved_rlimit_nofile.rlim_cur > 0)
1738 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1739
41669317 1740 if (switch_root_dir) {
cee530bb
LP		 1741 /* Kill all remaining processes from the
1742 * initrd, but don't wait for them, so that we
1743 * can handle the SIGCHLD for them after
1744 * deserializing. */
1745 broadcast_signal(SIGTERM, false);
bd3fa1d2
LP		 1746
1747 /* And switch root */
41669317
LP		 1748 r = switch_root(switch_root_dir);
1749 if (r < 0)
1750 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1751 }
a16e1123 1752
d03bc1b8 1753 args_size = MAX(6, argc+1);
e564a982 1754 args = newa(const char*, args_size);
a16e1123 1755
664f88a7
LP		 1756 if (!switch_root_init) {
1757 char sfd[16];
a16e1123 1758
664f88a7
LP		 1759 /* First try to spawn ourselves with the right
1760 * path, and with full serialization. We do
1761 * this only if the user didn't specify an
1762 * explicit init to spawn. */
edb9aaa8 1763
664f88a7
LP		 1764 assert(serialization);
1765 assert(fds);
edb9aaa8 1766
664f88a7
LP		 1767 snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1768 char_array_0(sfd);
edb9aaa8 1769
664f88a7
LP		 1770 i = 0;
1771 args[i++] = SYSTEMD_BINARY_PATH;
41669317 1772 if (switch_root_dir)
2660882b 1773 args[i++] = "--switched-root";
67445f4e 1774 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
664f88a7
LP		 1775 args[i++] = "--deserialize";
1776 args[i++] = sfd;
1777 args[i++] = NULL;
edb9aaa8 1778
ce8aba56
KS		 1779 /* do not pass along the environment we inherit from the kernel or initrd */
1780 if (switch_root_dir)
1781 clearenv();
1782
e564a982 1783 assert(i <= args_size);
664f88a7
LP		 1784 execv(args[0], (char* const*) args);
1785 }
6e98720f 1786
664f88a7
LP		 1787 /* Try the fallback, if there is any, without any
1788 * serialization. We pass the original argv[] and
1789 * envp[]. (Well, modulo the ordering changes due to
1790 * getopt() in argv[], and some cleanups in envp[],
1791 * but let's hope that doesn't matter.) */
a16e1123 1792
b8f83232 1793 if (serialization) {
664f88a7 1794 fclose(serialization);
b8f83232
LP		 1795 serialization = NULL;
1796 }
a16e1123 1797
b8f83232 1798 if (fds) {
664f88a7 1799 fdset_free(fds);
b8f83232
LP		 1800 fds = NULL;
1801 }
a16e1123 1802
a504223d
HH		 1803 /* Reopen the console */
1804 make_console_stdio();
1805
b8f83232 1806 for (j = 1, i = 1; j < argc; j++)
664f88a7 1807 args[i++] = argv[j];
a16e1123 1808 args[i++] = NULL;
e564a982 1809 assert(i <= args_size);
b8f83232
LP		 1810
1811 if (switch_root_init) {
1812 args[0] = switch_root_init;
1813 execv(args[0], (char* const*) args);
1814 log_warning("Failed to execute configured init, trying fallback: %m");
1815 }
1816
1817 args[0] = "/sbin/init";
a16e1123
LP		 1818 execv(args[0], (char* const*) args);
1819
745e2fb7
KS		 1820 if (errno == ENOENT) {
1821 log_warning("No /sbin/init, trying fallback");
b8f83232 1822
745e2fb7
KS		 1823 args[0] = "/bin/sh";
1824 args[1] = NULL;
1825 execv(args[0], (char* const*) args);
1826 log_error("Failed to execute /bin/sh, giving up: %m");
1827 } else
1828 log_warning("Failed to execute /sbin/init, giving up: %m");
a16e1123
LP		 1829 }
1830
1831 if (serialization)
1832 fclose(serialization);
1833
1834 if (fds)
1835 fdset_free(fds);
1836
b9080b03
FF		 1837 if (shutdown_verb) {
1838 const char * command_line[] = {
1839 SYSTEMD_SHUTDOWN_BINARY_PATH,
1840 shutdown_verb,
1841 NULL
1842 };
d18f337c 1843 char **env_block;
b9080b03 1844
e96d6be7 1845 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
d18f337c
LP		 1846 char e[32];
1847
e96d6be7
LP		 1848 /* If we reboot let's set the shutdown
1849 * watchdog and tell the shutdown binary to
1850 * repeatedly ping it */
1851 watchdog_set_timeout(&arg_shutdown_watchdog);
1852 watchdog_close(false);
1853
1854 /* Tell the binary how often to ping */
1855 snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1856 char_array_0(e);
d18f337c
LP		 1857
1858 env_block = strv_append(environ, e);
1859 } else {
1860 env_block = strv_copy(environ);
e96d6be7 1861 watchdog_close(true);
d18f337c 1862 }
e96d6be7 1863
66713f77
LP		 1864 /* Avoid the creation of new processes forked by the
1865 * kernel; at this point, we will not listen to the
1866 * signals anyway */
1867 if (detect_container(NULL) <= 0)
1868 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
ad929bcc 1869
d18f337c
LP		 1870 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1871 free(env_block);
b9080b03
FF		 1872 log_error("Failed to execute shutdown binary, freezing: %m");
1873 }
1874
c3b3c274
LP		 1875 if (getpid() == 1)
1876 freeze();
1877
60918275
LP		 1878 return retval;
1879}
Unnamed repository; edit this file 'description' to name the repository.