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