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