1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
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.
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.
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/>.
22 #include <dbus/dbus.h>
28 #include <sys/types.h>
34 #include <sys/prctl.h>
35 #include <sys/mount.h>
39 #include "load-fragment.h"
42 #include "conf-parser.h"
43 #include "bus-errors.h"
51 #include "path-util.h"
52 #include "switch-root.h"
53 #include "capability.h"
56 #include "mount-setup.h"
57 #include "loopback-setup.h"
58 #include "kmod-setup.h"
59 #include "hostname-setup.h"
60 #include "machine-id-setup.h"
61 #include "locale-setup.h"
63 #include "selinux-setup.h"
64 #include "ima-setup.h"
70 ACTION_DUMP_CONFIGURATION_ITEMS,
72 } arg_action = ACTION_RUN;
74 static char *arg_default_unit = NULL;
75 static ManagerRunningAs arg_running_as = _MANAGER_RUNNING_AS_INVALID;
77 static bool arg_dump_core = true;
78 static bool arg_crash_shell = false;
79 static int arg_crash_chvt = -1;
80 static bool arg_confirm_spawn = false;
81 static bool arg_show_status = true;
82 static bool arg_switched_root = false;
83 static char **arg_default_controllers = NULL;
84 static char ***arg_join_controllers = NULL;
85 static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
86 static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
87 static usec_t arg_runtime_watchdog = 0;
88 static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
89 static struct rlimit *arg_default_rlimit[RLIMIT_NLIMITS] = {};
90 static uint64_t arg_capability_bounding_set_drop = 0;
91 static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
93 static FILE* serialization = NULL;
95 static void nop_handler(int sig) {
98 _noreturn_ static void crash(int sig) {
101 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
106 /* We want to wait for the core process, hence let's enable SIGCHLD */
108 sa.sa_handler = nop_handler;
109 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
110 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
112 if ((pid = fork()) < 0)
113 log_error("Caught <%s>, cannot fork for core dump: %s", signal_to_string(sig), strerror(errno));
118 /* Enable default signal handler for core dump */
120 sa.sa_handler = SIG_DFL;
121 assert_se(sigaction(sig, &sa, NULL) == 0);
123 /* Don't limit the core dump size */
125 rl.rlim_cur = RLIM_INFINITY;
126 rl.rlim_max = RLIM_INFINITY;
127 setrlimit(RLIMIT_CORE, &rl);
129 /* Just to be sure... */
130 assert_se(chdir("/") == 0);
132 /* Raise the signal again */
135 assert_not_reached("We shouldn't be here...");
142 /* Order things nicely. */
143 if ((r = wait_for_terminate(pid, &status)) < 0)
144 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
145 else if (status.si_code != CLD_DUMPED)
146 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
148 log_error("Caught <%s>, dumped core as pid %lu.", signal_to_string(sig), (unsigned long) pid);
153 chvt(arg_crash_chvt);
155 if (arg_crash_shell) {
159 log_info("Executing crash shell in 10s...");
162 /* Let the kernel reap children for us */
164 sa.sa_handler = SIG_IGN;
165 sa.sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART;
166 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
170 log_error("Failed to fork off crash shell: %s", strerror(errno));
172 make_console_stdio();
173 execl("/bin/sh", "/bin/sh", NULL);
175 log_error("execl() failed: %s", strerror(errno));
179 log_info("Successfully spawned crash shell as pid %lu.", (unsigned long) pid);
182 log_info("Freezing execution.");
186 static void install_crash_handler(void) {
191 sa.sa_handler = crash;
192 sa.sa_flags = SA_NODEFER;
194 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
197 static int console_setup(bool do_reset) {
200 /* If we are init, we connect stdin/stdout/stderr to /dev/null
201 * and make sure we don't have a controlling tty. */
208 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
210 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
214 /* We don't want to force text mode.
215 * plymouth may be showing pictures already from initrd. */
216 r = reset_terminal_fd(tty_fd, false);
218 log_error("Failed to reset /dev/console: %s", strerror(-r));
220 close_nointr_nofail(tty_fd);
224 static int set_default_unit(const char *u) {
233 free(arg_default_unit);
234 arg_default_unit = c;
239 static int parse_proc_cmdline_word(const char *word) {
241 static const char * const rlmap[] = {
242 "emergency", SPECIAL_EMERGENCY_TARGET,
243 "-b", SPECIAL_EMERGENCY_TARGET,
244 "single", SPECIAL_RESCUE_TARGET,
245 "-s", SPECIAL_RESCUE_TARGET,
246 "s", SPECIAL_RESCUE_TARGET,
247 "S", SPECIAL_RESCUE_TARGET,
248 "1", SPECIAL_RESCUE_TARGET,
249 "2", SPECIAL_RUNLEVEL2_TARGET,
250 "3", SPECIAL_RUNLEVEL3_TARGET,
251 "4", SPECIAL_RUNLEVEL4_TARGET,
252 "5", SPECIAL_RUNLEVEL5_TARGET,
257 if (startswith(word, "systemd.unit=")) {
260 return set_default_unit(word + 13);
262 } else if (startswith(word, "rd.systemd.unit=")) {
265 return set_default_unit(word + 16);
267 } else if (startswith(word, "systemd.log_target=")) {
269 if (log_set_target_from_string(word + 19) < 0)
270 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
272 } else if (startswith(word, "systemd.log_level=")) {
274 if (log_set_max_level_from_string(word + 18) < 0)
275 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
277 } else if (startswith(word, "systemd.log_color=")) {
279 if (log_show_color_from_string(word + 18) < 0)
280 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
282 } else if (startswith(word, "systemd.log_location=")) {
284 if (log_show_location_from_string(word + 21) < 0)
285 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
287 } else if (startswith(word, "systemd.dump_core=")) {
290 if ((r = parse_boolean(word + 18)) < 0)
291 log_warning("Failed to parse dump core switch %s. Ignoring.", word + 18);
295 } else if (startswith(word, "systemd.crash_shell=")) {
298 if ((r = parse_boolean(word + 20)) < 0)
299 log_warning("Failed to parse crash shell switch %s. Ignoring.", word + 20);
303 } else if (startswith(word, "systemd.confirm_spawn=")) {
306 if ((r = parse_boolean(word + 22)) < 0)
307 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", word + 22);
309 arg_confirm_spawn = r;
311 } else if (startswith(word, "systemd.crash_chvt=")) {
314 if (safe_atoi(word + 19, &k) < 0)
315 log_warning("Failed to parse crash chvt switch %s. Ignoring.", word + 19);
319 } else if (startswith(word, "systemd.show_status=")) {
322 if ((r = parse_boolean(word + 20)) < 0)
323 log_warning("Failed to parse show status switch %s. Ignoring.", word + 20);
326 } else if (startswith(word, "systemd.default_standard_output=")) {
329 if ((r = exec_output_from_string(word + 32)) < 0)
330 log_warning("Failed to parse default standard output switch %s. Ignoring.", word + 32);
332 arg_default_std_output = r;
333 } else if (startswith(word, "systemd.default_standard_error=")) {
336 if ((r = exec_output_from_string(word + 31)) < 0)
337 log_warning("Failed to parse default standard error switch %s. Ignoring.", word + 31);
339 arg_default_std_error = r;
340 } else if (startswith(word, "systemd.setenv=")) {
344 cenv = strdup(word + 15);
348 eq = strchr(cenv, '=');
352 log_warning("unsetenv failed %s. Ignoring.", strerror(errno));
355 r = setenv(cenv, eq + 1, 1);
357 log_warning("setenv failed %s. Ignoring.", strerror(errno));
361 } else if (startswith(word, "systemd.") ||
362 (in_initrd() && startswith(word, "rd.systemd."))) {
364 log_warning("Unknown kernel switch %s. Ignoring.", word);
366 log_info("Supported kernel switches:\n"
367 "systemd.unit=UNIT Default unit to start\n"
368 "rd.systemd.unit=UNIT Default unit to start when run in initrd\n"
369 "systemd.dump_core=0|1 Dump core on crash\n"
370 "systemd.crash_shell=0|1 Run shell on crash\n"
371 "systemd.crash_chvt=N Change to VT #N on crash\n"
372 "systemd.confirm_spawn=0|1 Confirm every process spawn\n"
373 "systemd.show_status=0|1 Show status updates on the console during bootup\n"
374 "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\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 "systemd.setenv=ASSIGNMENT Set an environment variable for all spawned processes\n");
385 } else if (streq(word, "quiet"))
386 arg_show_status = false;
387 else if (!in_initrd()) {
390 /* SysV compatibility */
391 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
392 if (streq(word, rlmap[i]))
393 return set_default_unit(rlmap[i+1]);
399 static int config_parse_level2(
400 const char *filename,
413 log_set_max_level_from_string(rvalue);
417 static int config_parse_target(
418 const char *filename,
431 log_set_target_from_string(rvalue);
435 static int config_parse_color(
436 const char *filename,
449 log_show_color_from_string(rvalue);
453 static int config_parse_location(
454 const char *filename,
467 log_show_location_from_string(rvalue);
471 static int config_parse_cpu_affinity2(
472 const char *filename,
491 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
496 if (!(t = strndup(w, l)))
499 r = safe_atou(t, &cpu);
503 if (!(c = cpu_set_malloc(&ncpus)))
506 if (r < 0 || cpu >= ncpus) {
507 log_error("[%s:%u] Failed to parse CPU affinity: %s", filename, line, rvalue);
512 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
516 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
517 log_warning("Failed to set CPU affinity: %m");
525 static void strv_free_free(char ***l) {
537 static void free_join_controllers(void) {
538 if (!arg_join_controllers)
541 strv_free_free(arg_join_controllers);
542 arg_join_controllers = NULL;
545 static int config_parse_join_controllers(
546 const char *filename,
563 free_join_controllers();
565 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
568 s = strndup(w, length);
572 l = strv_split(s, ",");
577 if (strv_length(l) <= 1) {
582 if (!arg_join_controllers) {
583 arg_join_controllers = new(char**, 2);
584 if (!arg_join_controllers) {
589 arg_join_controllers[0] = l;
590 arg_join_controllers[1] = NULL;
597 t = new0(char**, n+2);
605 for (a = arg_join_controllers; *a; a++) {
607 if (strv_overlap(*a, l)) {
610 c = strv_merge(*a, l);
633 t[n++] = strv_uniq(l);
635 strv_free_free(arg_join_controllers);
636 arg_join_controllers = t;
643 static int parse_config_file(void) {
645 const ConfigTableItem items[] = {
646 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
647 { "Manager", "LogTarget", config_parse_target, 0, NULL },
648 { "Manager", "LogColor", config_parse_color, 0, NULL },
649 { "Manager", "LogLocation", config_parse_location, 0, NULL },
650 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
651 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
652 { "Manager", "ShowStatus", config_parse_bool, 0, &arg_show_status },
653 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
654 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
655 { "Manager", "DefaultControllers", config_parse_strv, 0, &arg_default_controllers },
656 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
657 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
658 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
659 { "Manager", "RuntimeWatchdogSec", config_parse_usec, 0, &arg_runtime_watchdog },
660 { "Manager", "ShutdownWatchdogSec", config_parse_usec, 0, &arg_shutdown_watchdog },
661 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
662 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
663 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU]},
664 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE]},
665 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA]},
666 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK]},
667 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE]},
668 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS]},
669 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE]},
670 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS]},
671 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC]},
672 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK]},
673 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS]},
674 { "Manager", "DefaultLimitSIGPENDING",config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING]},
675 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE]},
676 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE]},
677 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO]},
678 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME]},
679 { NULL, NULL, NULL, 0, NULL }
686 fn = arg_running_as == MANAGER_SYSTEM ? SYSTEM_CONFIG_FILE : USER_CONFIG_FILE;
692 log_warning("Failed to open configuration file '%s': %m", fn);
696 r = config_parse(fn, f, "Manager\0", config_item_table_lookup, (void*) items, false, NULL);
698 log_warning("Failed to parse configuration file: %s", strerror(-r));
705 static int parse_proc_cmdline(void) {
706 char *line, *w, *state;
710 /* Don't read /proc/cmdline if we are in a container, since
711 * that is only relevant for the host system */
712 if (detect_container(NULL) > 0)
715 if ((r = read_one_line_file("/proc/cmdline", &line)) < 0) {
716 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
720 FOREACH_WORD_QUOTED(w, l, line, state) {
723 if (!(word = strndup(w, l))) {
728 r = parse_proc_cmdline_word(word);
742 static int parse_argv(int argc, char *argv[]) {
745 ARG_LOG_LEVEL = 0x100,
753 ARG_DUMP_CONFIGURATION_ITEMS,
761 ARG_DEFAULT_STD_OUTPUT,
762 ARG_DEFAULT_STD_ERROR
765 static const struct option options[] = {
766 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
767 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
768 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
769 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
770 { "unit", required_argument, NULL, ARG_UNIT },
771 { "system", no_argument, NULL, ARG_SYSTEM },
772 { "user", no_argument, NULL, ARG_USER },
773 { "test", no_argument, NULL, ARG_TEST },
774 { "help", no_argument, NULL, 'h' },
775 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
776 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
777 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
778 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
779 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
780 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
781 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
782 { "introspect", optional_argument, NULL, ARG_INTROSPECT },
783 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
784 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
796 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
801 if ((r = log_set_max_level_from_string(optarg)) < 0) {
802 log_error("Failed to parse log level %s.", optarg);
810 if ((r = log_set_target_from_string(optarg)) < 0) {
811 log_error("Failed to parse log target %s.", optarg);
820 if ((r = log_show_color_from_string(optarg)) < 0) {
821 log_error("Failed to parse log color setting %s.", optarg);
825 log_show_color(true);
829 case ARG_LOG_LOCATION:
832 if ((r = log_show_location_from_string(optarg)) < 0) {
833 log_error("Failed to parse log location setting %s.", optarg);
837 log_show_location(true);
841 case ARG_DEFAULT_STD_OUTPUT:
843 if ((r = exec_output_from_string(optarg)) < 0) {
844 log_error("Failed to parse default standard output setting %s.", optarg);
847 arg_default_std_output = r;
850 case ARG_DEFAULT_STD_ERROR:
852 if ((r = exec_output_from_string(optarg)) < 0) {
853 log_error("Failed to parse default standard error output setting %s.", optarg);
856 arg_default_std_error = r;
861 if ((r = set_default_unit(optarg)) < 0) {
862 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
869 arg_running_as = MANAGER_SYSTEM;
873 arg_running_as = MANAGER_USER;
877 arg_action = ACTION_TEST;
880 case ARG_DUMP_CONFIGURATION_ITEMS:
881 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
885 r = optarg ? parse_boolean(optarg) : 1;
887 log_error("Failed to parse dump core boolean %s.", optarg);
893 case ARG_CRASH_SHELL:
894 r = optarg ? parse_boolean(optarg) : 1;
896 log_error("Failed to parse crash shell boolean %s.", optarg);
902 case ARG_CONFIRM_SPAWN:
903 r = optarg ? parse_boolean(optarg) : 1;
905 log_error("Failed to parse confirm spawn boolean %s.", optarg);
908 arg_confirm_spawn = r;
911 case ARG_SHOW_STATUS:
912 r = optarg ? parse_boolean(optarg) : 1;
914 log_error("Failed to parse show status boolean %s.", optarg);
920 case ARG_DESERIALIZE: {
924 if ((r = safe_atoi(optarg, &fd)) < 0 || fd < 0) {
925 log_error("Failed to parse deserialize option %s.", optarg);
929 if (!(f = fdopen(fd, "r"))) {
930 log_error("Failed to open serialization fd: %m");
935 fclose(serialization);
942 case ARG_SWITCHED_ROOT:
943 arg_switched_root = true;
946 case ARG_INTROSPECT: {
947 const char * const * i = NULL;
949 for (i = bus_interface_table; *i; i += 2)
950 if (!optarg || streq(i[0], optarg)) {
951 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
954 fputs("</node>\n", stdout);
961 log_error("Unknown interface %s.", optarg);
963 arg_action = ACTION_DONE;
968 arg_action = ACTION_HELP;
972 log_set_max_level(LOG_DEBUG);
978 /* Just to eat away the sysvinit kernel
979 * cmdline args without getopt() error
980 * messages that we'll parse in
981 * parse_proc_cmdline_word() or ignore. */
986 log_error("Unknown option code %c", c);
993 if (optind < argc && getpid() != 1) {
994 /* Hmm, when we aren't run as init system
995 * let's complain about excess arguments */
997 log_error("Excess arguments.");
1001 if (detect_container(NULL) > 0) {
1004 /* All /proc/cmdline arguments the kernel didn't
1005 * understand it passed to us. We're not really
1006 * interested in that usually since /proc/cmdline is
1007 * more interesting and complete. With one exception:
1008 * if we are run in a container /proc/cmdline is not
1009 * relevant for the container, hence we rely on argv[]
1012 for (a = argv; a < argv + argc; a++)
1013 if ((r = parse_proc_cmdline_word(*a)) < 0)
1020 static int help(void) {
1022 printf("%s [OPTIONS...]\n\n"
1023 "Starts up and maintains the system or user services.\n\n"
1024 " -h --help Show this help\n"
1025 " --test Determine startup sequence, dump it and exit\n"
1026 " --dump-configuration-items Dump understood unit configuration items\n"
1027 " --introspect[=INTERFACE] Extract D-Bus interface data\n"
1028 " --unit=UNIT Set default unit\n"
1029 " --system Run a system instance, even if PID != 1\n"
1030 " --user Run a user instance\n"
1031 " --dump-core[=0|1] Dump core on crash\n"
1032 " --crash-shell[=0|1] Run shell on crash\n"
1033 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
1034 " --show-status[=0|1] Show status updates on the console during bootup\n"
1035 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1036 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1037 " --log-color[=0|1] Highlight important log messages\n"
1038 " --log-location[=0|1] Include code location in log messages\n"
1039 " --default-standard-output= Set default standard output for services\n"
1040 " --default-standard-error= Set default standard error output for services\n",
1041 program_invocation_short_name);
1046 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds) {
1055 /* Make sure nothing is really destructed when we shut down */
1058 if ((r = manager_open_serialization(m, &f)) < 0) {
1059 log_error("Failed to create serialization file: %s", strerror(-r));
1063 if (!(fds = fdset_new())) {
1065 log_error("Failed to allocate fd set: %s", strerror(-r));
1069 if ((r = manager_serialize(m, f, fds)) < 0) {
1070 log_error("Failed to serialize state: %s", strerror(-r));
1074 if (fseeko(f, 0, SEEK_SET) < 0) {
1075 log_error("Failed to rewind serialization fd: %m");
1079 if ((r = fd_cloexec(fileno(f), false)) < 0) {
1080 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1084 if ((r = fdset_cloexec(fds, false)) < 0) {
1085 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1103 static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1105 unsigned long long a, b;
1109 e = getenv("RD_TIMESTAMP");
1113 if (sscanf(e, "%llu %llu", &a, &b) != 2)
1116 t->realtime = (usec_t) a;
1117 t->monotonic = (usec_t) b;
1122 static void test_mtab(void) {
1125 /* Check that /etc/mtab is a symlink */
1127 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1130 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1137 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1138 "This is not supported anymore. "
1139 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1142 static void test_usr(void) {
1144 /* Check that /usr is not a separate fs */
1146 if (dir_is_empty("/usr") <= 0)
1149 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1150 "Some things will probably break (sometimes even silently) in mysterious ways. "
1151 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1154 static void test_cgroups(void) {
1156 if (access("/proc/cgroups", F_OK) >= 0)
1159 log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1160 "Systems without control groups are not supported. "
1161 "We will now sleep for 10s, and then continue boot-up. "
1162 "Expect breakage and please do not file bugs. "
1163 "Instead fix your kernel and enable CONFIG_CGROUPS. "
1164 "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1169 int main(int argc, char *argv[]) {
1171 int r, retval = EXIT_FAILURE;
1172 usec_t before_startup, after_startup;
1173 char timespan[FORMAT_TIMESPAN_MAX];
1175 bool reexecute = false;
1176 const char *shutdown_verb = NULL;
1177 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1178 static char systemd[] = "systemd";
1179 bool skip_setup = false;
1181 bool loaded_policy = false;
1182 bool arm_reboot_watchdog = false;
1183 bool queue_default_job = false;
1184 char *switch_root_dir = NULL, *switch_root_init = NULL;
1186 #ifdef HAVE_SYSV_COMPAT
1187 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1188 /* This is compatibility support for SysV, where
1189 * calling init as a user is identical to telinit. */
1192 execv(SYSTEMCTL_BINARY_PATH, argv);
1193 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1198 /* Determine if this is a reexecution or normal bootup. We do
1199 * the full command line parsing much later, so let's just
1200 * have a quick peek here. */
1201 for (j = 1; j < argc; j++)
1202 if (streq(argv[j], "--deserialize")) {
1207 /* If we have switched root, do all the special setup
1209 for (j = 1; j < argc; j++)
1210 if (streq(argv[j], "--switched-root")) {
1215 /* If we get started via the /sbin/init symlink then we are
1216 called 'init'. After a subsequent reexecution we are then
1217 called 'systemd'. That is confusing, hence let's call us
1218 systemd right-away. */
1219 program_invocation_short_name = systemd;
1220 prctl(PR_SET_NAME, systemd);
1225 log_show_color(isatty(STDERR_FILENO) > 0);
1226 log_show_location(false);
1227 log_set_max_level(LOG_INFO);
1229 if (getpid() == 1) {
1231 char *rd_timestamp = NULL;
1233 dual_timestamp_get(&initrd_timestamp);
1234 asprintf(&rd_timestamp, "%llu %llu",
1235 (unsigned long long) initrd_timestamp.realtime,
1236 (unsigned long long) initrd_timestamp.monotonic);
1238 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1243 arg_running_as = MANAGER_SYSTEM;
1244 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
1247 if (selinux_setup(&loaded_policy) < 0)
1249 if (ima_setup() < 0)
1255 if (label_init(NULL) < 0)
1259 if (hwclock_is_localtime() > 0) {
1262 r = hwclock_apply_localtime_delta(&min);
1264 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1266 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1270 arg_running_as = MANAGER_USER;
1271 log_set_target(LOG_TARGET_AUTO);
1275 /* Initialize default unit */
1276 if (set_default_unit(SPECIAL_DEFAULT_TARGET) < 0)
1279 /* By default, mount "cpu" and "cpuacct" together */
1280 arg_join_controllers = new(char**, 2);
1281 if (!arg_join_controllers)
1284 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1285 arg_join_controllers[1] = NULL;
1287 if (!arg_join_controllers[0])
1290 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1291 * /proc/$PID/fd is available. */
1292 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1293 r = mount_setup(loaded_policy);
1298 /* Reset all signal handlers. */
1299 assert_se(reset_all_signal_handlers() == 0);
1301 /* If we are init, we can block sigkill. Yay. */
1302 ignore_signals(SIGNALS_IGNORE, -1);
1304 if (parse_config_file() < 0)
1307 if (arg_running_as == MANAGER_SYSTEM)
1308 if (parse_proc_cmdline() < 0)
1311 log_parse_environment();
1313 if (parse_argv(argc, argv) < 0)
1316 if (arg_action == ACTION_TEST && geteuid() == 0) {
1317 log_error("Don't run test mode as root.");
1321 if (arg_running_as == MANAGER_SYSTEM &&
1322 arg_action == ACTION_RUN &&
1323 running_in_chroot() > 0) {
1324 log_error("Cannot be run in a chroot() environment.");
1328 if (arg_action == ACTION_HELP) {
1331 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1332 unit_dump_config_items(stdout);
1333 retval = EXIT_SUCCESS;
1335 } else if (arg_action == ACTION_DONE) {
1336 retval = EXIT_SUCCESS;
1340 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1342 /* Close logging fds, in order not to confuse fdset below */
1345 /* Remember open file descriptors for later deserialization */
1346 if (serialization) {
1347 r = fdset_new_fill(&fds);
1349 log_error("Failed to allocate fd set: %s", strerror(-r));
1353 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1355 close_all_fds(NULL, 0);
1357 /* Set up PATH unless it is already set */
1359 #ifdef HAVE_SPLIT_USR
1360 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1362 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1364 arg_running_as == MANAGER_SYSTEM);
1366 if (arg_running_as == MANAGER_SYSTEM) {
1367 /* Parse the data passed to us. We leave this
1368 * variables set, but the manager later on will not
1369 * pass them on to our children. */
1371 parse_initrd_timestamp(&initrd_timestamp);
1373 /* Unset some environment variables passed in from the
1374 * kernel that don't really make sense for us. */
1378 /* When we are invoked by a shell, these might be set,
1379 * but make little sense to pass on */
1384 /* When we are invoked by a chroot-like tool such as
1385 * nspawn, these might be set, but make little sense
1388 unsetenv("LOGNAME");
1390 /* All other variables are left as is, so that clients
1391 * can still read them via /proc/1/environ */
1394 /* Move out of the way, so that we won't block unmounts */
1395 assert_se(chdir("/") == 0);
1397 if (arg_running_as == MANAGER_SYSTEM) {
1398 /* Become a session leader if we aren't one yet. */
1401 /* Disable the umask logic */
1405 /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1406 dbus_connection_set_change_sigpipe(FALSE);
1408 /* Reset the console, but only if this is really init and we
1409 * are freshly booted */
1410 if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
1411 console_setup(getpid() == 1 && !skip_setup);
1415 /* Open the logging devices, if possible and necessary */
1418 /* Make sure we leave a core dump without panicing the
1421 install_crash_handler();
1423 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1424 r = mount_cgroup_controllers(arg_join_controllers);
1429 if (arg_running_as == MANAGER_SYSTEM) {
1430 const char *virtualization = NULL;
1432 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1434 detect_virtualization(&virtualization);
1436 log_info("Detected virtualization '%s'.", virtualization);
1439 log_info("Running in initial RAM disk.");
1442 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1444 if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1447 if (arg_show_status || plymouth_running())
1460 if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1461 watchdog_set_timeout(&arg_runtime_watchdog);
1463 if (arg_timer_slack_nsec != (nsec_t) -1)
1464 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1465 log_error("Failed to adjust timer slack: %m");
1467 if (arg_capability_bounding_set_drop) {
1468 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1470 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1473 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1475 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1480 r = manager_new(arg_running_as, &m);
1482 log_error("Failed to allocate manager object: %s", strerror(-r));
1486 m->confirm_spawn = arg_confirm_spawn;
1487 m->default_std_output = arg_default_std_output;
1488 m->default_std_error = arg_default_std_error;
1489 m->runtime_watchdog = arg_runtime_watchdog;
1490 m->shutdown_watchdog = arg_shutdown_watchdog;
1492 manager_set_default_rlimits(m, arg_default_rlimit);
1494 if (dual_timestamp_is_set(&initrd_timestamp))
1495 m->initrd_timestamp = initrd_timestamp;
1497 if (arg_default_controllers)
1498 manager_set_default_controllers(m, arg_default_controllers);
1500 manager_set_show_status(m, arg_show_status);
1502 /* Remember whether we should queue the default job */
1503 queue_default_job = !serialization || arg_switched_root;
1505 before_startup = now(CLOCK_MONOTONIC);
1507 r = manager_startup(m, serialization, fds);
1509 log_error("Failed to fully start up daemon: %s", strerror(-r));
1511 /* This will close all file descriptors that were opened, but
1512 * not claimed by any unit. */
1518 if (serialization) {
1519 fclose(serialization);
1520 serialization = NULL;
1523 if (queue_default_job) {
1525 Unit *target = NULL;
1526 Job *default_unit_job;
1528 dbus_error_init(&error);
1530 log_debug("Activating default unit: %s", arg_default_unit);
1532 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1534 log_error("Failed to load default target: %s", bus_error(&error, r));
1535 dbus_error_free(&error);
1536 } else if (target->load_state == UNIT_ERROR)
1537 log_error("Failed to load default target: %s", strerror(-target->load_error));
1538 else if (target->load_state == UNIT_MASKED)
1539 log_error("Default target masked.");
1541 if (!target || target->load_state != UNIT_LOADED) {
1542 log_info("Trying to load rescue target...");
1544 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1546 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1547 dbus_error_free(&error);
1549 } else if (target->load_state == UNIT_ERROR) {
1550 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1552 } else if (target->load_state == UNIT_MASKED) {
1553 log_error("Rescue target masked.");
1558 assert(target->load_state == UNIT_LOADED);
1560 if (arg_action == ACTION_TEST) {
1561 printf("-> By units:\n");
1562 manager_dump_units(m, stdout, "\t");
1565 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1567 log_error("Failed to start default target: %s", bus_error(&error, r));
1568 dbus_error_free(&error);
1571 m->default_unit_job_id = default_unit_job->id;
1573 after_startup = now(CLOCK_MONOTONIC);
1574 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1575 "Loaded units and determined initial transaction in %s.",
1576 format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1578 if (arg_action == ACTION_TEST) {
1579 printf("-> By jobs:\n");
1580 manager_dump_jobs(m, stdout, "\t");
1581 retval = EXIT_SUCCESS;
1587 r = manager_loop(m);
1589 log_error("Failed to run mainloop: %s", strerror(-r));
1593 switch (m->exit_code) {
1596 retval = EXIT_SUCCESS;
1600 case MANAGER_RELOAD:
1601 log_info("Reloading.");
1602 r = manager_reload(m);
1604 log_error("Failed to reload: %s", strerror(-r));
1607 case MANAGER_REEXECUTE:
1609 if (prepare_reexecute(m, &serialization, &fds) < 0)
1613 log_notice("Reexecuting.");
1616 case MANAGER_SWITCH_ROOT:
1617 /* Steal the switch root parameters */
1618 switch_root_dir = m->switch_root;
1619 switch_root_init = m->switch_root_init;
1620 m->switch_root = m->switch_root_init = NULL;
1622 if (!switch_root_init)
1623 if (prepare_reexecute(m, &serialization, &fds) < 0)
1627 log_notice("Switching root.");
1630 case MANAGER_REBOOT:
1631 case MANAGER_POWEROFF:
1633 case MANAGER_KEXEC: {
1634 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1635 [MANAGER_REBOOT] = "reboot",
1636 [MANAGER_POWEROFF] = "poweroff",
1637 [MANAGER_HALT] = "halt",
1638 [MANAGER_KEXEC] = "kexec"
1641 assert_se(shutdown_verb = table[m->exit_code]);
1642 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1644 log_notice("Shutting down.");
1649 assert_not_reached("Unknown exit code.");
1657 for (j = 0; j < RLIMIT_NLIMITS; j++)
1658 free (arg_default_rlimit[j]);
1660 free(arg_default_unit);
1661 strv_free(arg_default_controllers);
1662 free_join_controllers();
1669 unsigned i, args_size;
1671 /* Close and disarm the watchdog, so that the new
1672 * instance can reinitialize it, but doesn't get
1673 * rebooted while we do that */
1674 watchdog_close(true);
1676 if (switch_root_dir) {
1677 /* Kill all remaining processes from the initrd */
1678 broadcast_signal(SIGTERM);
1679 broadcast_signal(SIGKILL);
1681 /* And switch root */
1682 r = switch_root(switch_root_dir);
1684 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1687 args_size = MAX(6, argc+1);
1688 args = newa(const char*, args_size);
1690 if (!switch_root_init) {
1693 /* First try to spawn ourselves with the right
1694 * path, and with full serialization. We do
1695 * this only if the user didn't specify an
1696 * explicit init to spawn. */
1698 assert(serialization);
1701 snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1705 args[i++] = SYSTEMD_BINARY_PATH;
1706 if (switch_root_dir)
1707 args[i++] = "--switched-root";
1708 args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1709 args[i++] = "--deserialize";
1713 assert(i <= args_size);
1714 execv(args[0], (char* const*) args);
1717 /* Try the fallback, if there is any, without any
1718 * serialization. We pass the original argv[] and
1719 * envp[]. (Well, modulo the ordering changes due to
1720 * getopt() in argv[], and some cleanups in envp[],
1721 * but let's hope that doesn't matter.) */
1723 if (serialization) {
1724 fclose(serialization);
1725 serialization = NULL;
1733 /* Reopen the console */
1734 make_console_stdio();
1736 for (j = 1, i = 1; j < argc; j++)
1737 args[i++] = argv[j];
1739 assert(i <= args_size);
1741 if (switch_root_init) {
1742 args[0] = switch_root_init;
1743 execv(args[0], (char* const*) args);
1744 log_warning("Failed to execute configured init, trying fallback: %m");
1747 args[0] = "/sbin/init";
1748 execv(args[0], (char* const*) args);
1750 if (errno == ENOENT) {
1751 log_warning("No /sbin/init, trying fallback");
1753 args[0] = "/bin/sh";
1755 execv(args[0], (char* const*) args);
1756 log_error("Failed to execute /bin/sh, giving up: %m");
1758 log_warning("Failed to execute /sbin/init, giving up: %m");
1762 fclose(serialization);
1767 if (shutdown_verb) {
1768 const char * command_line[] = {
1769 SYSTEMD_SHUTDOWN_BINARY_PATH,
1775 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1778 /* If we reboot let's set the shutdown
1779 * watchdog and tell the shutdown binary to
1780 * repeatedly ping it */
1781 watchdog_set_timeout(&arg_shutdown_watchdog);
1782 watchdog_close(false);
1784 /* Tell the binary how often to ping */
1785 snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1788 env_block = strv_append(environ, e);
1790 env_block = strv_copy(environ);
1791 watchdog_close(true);
1794 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1796 log_error("Failed to execute shutdown binary, freezing: %m");