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