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"
55 #include "mount-setup.h"
56 #include "loopback-setup.h"
57 #include "kmod-setup.h"
58 #include "hostname-setup.h"
59 #include "machine-id-setup.h"
60 #include "locale-setup.h"
62 #include "selinux-setup.h"
63 #include "ima-setup.h"
69 ACTION_DUMP_CONFIGURATION_ITEMS,
71 } arg_action = ACTION_RUN;
73 static char *arg_default_unit = NULL;
74 static ManagerRunningAs arg_running_as = _MANAGER_RUNNING_AS_INVALID;
76 static bool arg_dump_core = true;
77 static bool arg_crash_shell = false;
78 static int arg_crash_chvt = -1;
79 static bool arg_confirm_spawn = false;
80 static bool arg_show_status = true;
81 static bool arg_switched_root = false;
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 static struct rlimit *arg_default_rlimit[RLIMIT_NLIMITS] = {};
89 static uint64_t arg_capability_bounding_set_drop = 0;
90 static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
92 static FILE* serialization = NULL;
94 static void nop_handler(int sig) {
97 _noreturn_ static void crash(int sig) {
100 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
105 /* We want to wait for the core process, hence let's enable SIGCHLD */
107 sa.sa_handler = nop_handler;
108 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
109 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
111 if ((pid = fork()) < 0)
112 log_error("Caught <%s>, cannot fork for core dump: %s", signal_to_string(sig), strerror(errno));
117 /* Enable default signal handler for core dump */
119 sa.sa_handler = SIG_DFL;
120 assert_se(sigaction(sig, &sa, NULL) == 0);
122 /* Don't limit the core dump size */
124 rl.rlim_cur = RLIM_INFINITY;
125 rl.rlim_max = RLIM_INFINITY;
126 setrlimit(RLIMIT_CORE, &rl);
128 /* Just to be sure... */
129 assert_se(chdir("/") == 0);
131 /* Raise the signal again */
134 assert_not_reached("We shouldn't be here...");
141 /* Order things nicely. */
142 if ((r = wait_for_terminate(pid, &status)) < 0)
143 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
144 else if (status.si_code != CLD_DUMPED)
145 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
147 log_error("Caught <%s>, dumped core as pid %lu.", signal_to_string(sig), (unsigned long) pid);
152 chvt(arg_crash_chvt);
154 if (arg_crash_shell) {
158 log_info("Executing crash shell in 10s...");
161 /* Let the kernel reap children for us */
163 sa.sa_handler = SIG_IGN;
164 sa.sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART;
165 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
169 log_error("Failed to fork off crash shell: %s", strerror(errno));
171 make_console_stdio();
172 execl("/bin/sh", "/bin/sh", NULL);
174 log_error("execl() failed: %s", strerror(errno));
178 log_info("Successfully spawned crash shell as pid %lu.", (unsigned long) pid);
181 log_info("Freezing execution.");
185 static void install_crash_handler(void) {
190 sa.sa_handler = crash;
191 sa.sa_flags = SA_NODEFER;
193 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
196 static int console_setup(bool do_reset) {
199 /* If we are init, we connect stdin/stdout/stderr to /dev/null
200 * and make sure we don't have a controlling tty. */
207 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
209 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
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);
217 log_error("Failed to reset /dev/console: %s", strerror(-r));
219 close_nointr_nofail(tty_fd);
223 static int set_default_unit(const char *u) {
232 free(arg_default_unit);
233 arg_default_unit = c;
238 static int parse_proc_cmdline_word(const char *word) {
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,
256 if (startswith(word, "systemd.unit=")) {
259 return set_default_unit(word + 13);
261 } else if (startswith(word, "rd.systemd.unit=")) {
264 return set_default_unit(word + 16);
266 } else if (startswith(word, "systemd.log_target=")) {
268 if (log_set_target_from_string(word + 19) < 0)
269 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
271 } else if (startswith(word, "systemd.log_level=")) {
273 if (log_set_max_level_from_string(word + 18) < 0)
274 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
276 } else if (startswith(word, "systemd.log_color=")) {
278 if (log_show_color_from_string(word + 18) < 0)
279 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
281 } else if (startswith(word, "systemd.log_location=")) {
283 if (log_show_location_from_string(word + 21) < 0)
284 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
286 } else if (startswith(word, "systemd.dump_core=")) {
289 if ((r = parse_boolean(word + 18)) < 0)
290 log_warning("Failed to parse dump core switch %s. Ignoring.", word + 18);
294 } else if (startswith(word, "systemd.crash_shell=")) {
297 if ((r = parse_boolean(word + 20)) < 0)
298 log_warning("Failed to parse crash shell switch %s. Ignoring.", word + 20);
302 } else if (startswith(word, "systemd.confirm_spawn=")) {
305 if ((r = parse_boolean(word + 22)) < 0)
306 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", word + 22);
308 arg_confirm_spawn = r;
310 } else if (startswith(word, "systemd.crash_chvt=")) {
313 if (safe_atoi(word + 19, &k) < 0)
314 log_warning("Failed to parse crash chvt switch %s. Ignoring.", word + 19);
318 } else if (startswith(word, "systemd.show_status=")) {
321 if ((r = parse_boolean(word + 20)) < 0)
322 log_warning("Failed to parse show status switch %s. Ignoring.", word + 20);
325 } else if (startswith(word, "systemd.default_standard_output=")) {
328 if ((r = exec_output_from_string(word + 32)) < 0)
329 log_warning("Failed to parse default standard output switch %s. Ignoring.", word + 32);
331 arg_default_std_output = r;
332 } else if (startswith(word, "systemd.default_standard_error=")) {
335 if ((r = exec_output_from_string(word + 31)) < 0)
336 log_warning("Failed to parse default standard error switch %s. Ignoring.", word + 31);
338 arg_default_std_error = r;
339 } else if (startswith(word, "systemd.setenv=")) {
343 cenv = strdup(word + 15);
347 eq = strchr(cenv, '=');
351 log_warning("unsetenv failed %s. Ignoring.", strerror(errno));
354 r = setenv(cenv, eq + 1, 1);
356 log_warning("setenv failed %s. Ignoring.", strerror(errno));
360 } else if (startswith(word, "systemd.") ||
361 (in_initrd() && startswith(word, "rd.systemd."))) {
363 log_warning("Unknown kernel switch %s. Ignoring.", word);
365 log_info("Supported kernel switches:\n"
366 "systemd.unit=UNIT Default unit to start\n"
367 "rd.systemd.unit=UNIT Default unit to start when run in initrd\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 "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\n"
375 "systemd.log_level=LEVEL Log level\n"
376 "systemd.log_color=0|1 Highlight important log messages\n"
377 "systemd.log_location=0|1 Include code location in log messages\n"
378 "systemd.default_standard_output=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
379 " Set default log output for services\n"
380 "systemd.default_standard_error=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
381 " Set default log error output for services\n"
382 "systemd.setenv=ASSIGNMENT Set an environment variable for all spawned processes\n");
384 } else if (streq(word, "quiet"))
385 arg_show_status = false;
386 else if (!in_initrd()) {
389 /* SysV compatibility */
390 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
391 if (streq(word, rlmap[i]))
392 return set_default_unit(rlmap[i+1]);
398 static int config_parse_level2(
399 const char *filename,
412 log_set_max_level_from_string(rvalue);
416 static int config_parse_target(
417 const char *filename,
430 log_set_target_from_string(rvalue);
434 static int config_parse_color(
435 const char *filename,
448 log_show_color_from_string(rvalue);
452 static int config_parse_location(
453 const char *filename,
466 log_show_location_from_string(rvalue);
470 static int config_parse_cpu_affinity2(
471 const char *filename,
490 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
495 if (!(t = strndup(w, l)))
498 r = safe_atou(t, &cpu);
502 if (!(c = cpu_set_malloc(&ncpus)))
505 if (r < 0 || cpu >= ncpus) {
506 log_error("[%s:%u] Failed to parse CPU affinity: %s", filename, line, rvalue);
511 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
515 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
516 log_warning("Failed to set CPU affinity: %m");
524 static void strv_free_free(char ***l) {
536 static void free_join_controllers(void) {
537 if (!arg_join_controllers)
540 strv_free_free(arg_join_controllers);
541 arg_join_controllers = NULL;
544 static int config_parse_join_controllers(
545 const char *filename,
562 free_join_controllers();
564 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
567 s = strndup(w, length);
571 l = strv_split(s, ",");
576 if (strv_length(l) <= 1) {
581 if (!arg_join_controllers) {
582 arg_join_controllers = new(char**, 2);
583 if (!arg_join_controllers) {
588 arg_join_controllers[0] = l;
589 arg_join_controllers[1] = NULL;
596 t = new0(char**, n+2);
604 for (a = arg_join_controllers; *a; a++) {
606 if (strv_overlap(*a, l)) {
609 c = strv_merge(*a, l);
632 t[n++] = strv_uniq(l);
634 strv_free_free(arg_join_controllers);
635 arg_join_controllers = t;
642 static int parse_config_file(void) {
644 const ConfigTableItem items[] = {
645 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
646 { "Manager", "LogTarget", config_parse_target, 0, NULL },
647 { "Manager", "LogColor", config_parse_color, 0, NULL },
648 { "Manager", "LogLocation", config_parse_location, 0, NULL },
649 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
650 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
651 { "Manager", "ShowStatus", config_parse_bool, 0, &arg_show_status },
652 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
653 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
654 { "Manager", "DefaultControllers", config_parse_strv, 0, &arg_default_controllers },
655 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
656 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
657 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
658 { "Manager", "RuntimeWatchdogSec", config_parse_usec, 0, &arg_runtime_watchdog },
659 { "Manager", "ShutdownWatchdogSec", config_parse_usec, 0, &arg_shutdown_watchdog },
660 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
661 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
662 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU]},
663 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE]},
664 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA]},
665 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK]},
666 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE]},
667 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS]},
668 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE]},
669 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS]},
670 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC]},
671 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK]},
672 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS]},
673 { "Manager", "DefaultLimitSIGPENDING",config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING]},
674 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE]},
675 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE]},
676 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO]},
677 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME]},
678 { NULL, NULL, NULL, 0, NULL }
685 fn = arg_running_as == MANAGER_SYSTEM ? SYSTEM_CONFIG_FILE : USER_CONFIG_FILE;
691 log_warning("Failed to open configuration file '%s': %m", fn);
695 r = config_parse(fn, f, "Manager\0", config_item_table_lookup, (void*) items, false, NULL);
697 log_warning("Failed to parse configuration file: %s", strerror(-r));
704 static int parse_proc_cmdline(void) {
705 char *line, *w, *state;
709 /* Don't read /proc/cmdline if we are in a container, since
710 * that is only relevant for the host system */
711 if (detect_container(NULL) > 0)
714 if ((r = read_one_line_file("/proc/cmdline", &line)) < 0) {
715 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
719 FOREACH_WORD_QUOTED(w, l, line, state) {
722 if (!(word = strndup(w, l))) {
727 r = parse_proc_cmdline_word(word);
741 static int parse_argv(int argc, char *argv[]) {
744 ARG_LOG_LEVEL = 0x100,
752 ARG_DUMP_CONFIGURATION_ITEMS,
760 ARG_DEFAULT_STD_OUTPUT,
761 ARG_DEFAULT_STD_ERROR
764 static const struct option options[] = {
765 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
766 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
767 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
768 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
769 { "unit", required_argument, NULL, ARG_UNIT },
770 { "system", no_argument, NULL, ARG_SYSTEM },
771 { "user", no_argument, NULL, ARG_USER },
772 { "test", no_argument, NULL, ARG_TEST },
773 { "help", no_argument, NULL, 'h' },
774 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
775 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
776 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
777 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
778 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
779 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
780 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
781 { "introspect", optional_argument, NULL, ARG_INTROSPECT },
782 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
783 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
795 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
800 if ((r = log_set_max_level_from_string(optarg)) < 0) {
801 log_error("Failed to parse log level %s.", optarg);
809 if ((r = log_set_target_from_string(optarg)) < 0) {
810 log_error("Failed to parse log target %s.", optarg);
819 if ((r = log_show_color_from_string(optarg)) < 0) {
820 log_error("Failed to parse log color setting %s.", optarg);
824 log_show_color(true);
828 case ARG_LOG_LOCATION:
831 if ((r = log_show_location_from_string(optarg)) < 0) {
832 log_error("Failed to parse log location setting %s.", optarg);
836 log_show_location(true);
840 case ARG_DEFAULT_STD_OUTPUT:
842 if ((r = exec_output_from_string(optarg)) < 0) {
843 log_error("Failed to parse default standard output setting %s.", optarg);
846 arg_default_std_output = r;
849 case ARG_DEFAULT_STD_ERROR:
851 if ((r = exec_output_from_string(optarg)) < 0) {
852 log_error("Failed to parse default standard error output setting %s.", optarg);
855 arg_default_std_error = r;
860 if ((r = set_default_unit(optarg)) < 0) {
861 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
868 arg_running_as = MANAGER_SYSTEM;
872 arg_running_as = MANAGER_USER;
876 arg_action = ACTION_TEST;
879 case ARG_DUMP_CONFIGURATION_ITEMS:
880 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
884 r = optarg ? parse_boolean(optarg) : 1;
886 log_error("Failed to parse dump core boolean %s.", optarg);
892 case ARG_CRASH_SHELL:
893 r = optarg ? parse_boolean(optarg) : 1;
895 log_error("Failed to parse crash shell boolean %s.", optarg);
901 case ARG_CONFIRM_SPAWN:
902 r = optarg ? parse_boolean(optarg) : 1;
904 log_error("Failed to parse confirm spawn boolean %s.", optarg);
907 arg_confirm_spawn = r;
910 case ARG_SHOW_STATUS:
911 r = optarg ? parse_boolean(optarg) : 1;
913 log_error("Failed to parse show status boolean %s.", optarg);
919 case ARG_DESERIALIZE: {
923 if ((r = safe_atoi(optarg, &fd)) < 0 || fd < 0) {
924 log_error("Failed to parse deserialize option %s.", optarg);
928 if (!(f = fdopen(fd, "r"))) {
929 log_error("Failed to open serialization fd: %m");
934 fclose(serialization);
941 case ARG_SWITCHED_ROOT:
942 arg_switched_root = true;
945 case ARG_INTROSPECT: {
946 const char * const * i = NULL;
948 for (i = bus_interface_table; *i; i += 2)
949 if (!optarg || streq(i[0], optarg)) {
950 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
953 fputs("</node>\n", stdout);
960 log_error("Unknown interface %s.", optarg);
962 arg_action = ACTION_DONE;
967 arg_action = ACTION_HELP;
971 log_set_max_level(LOG_DEBUG);
977 /* Just to eat away the sysvinit kernel
978 * cmdline args without getopt() error
979 * messages that we'll parse in
980 * parse_proc_cmdline_word() or ignore. */
985 log_error("Unknown option code %c", c);
992 if (optind < argc && getpid() != 1) {
993 /* Hmm, when we aren't run as init system
994 * let's complain about excess arguments */
996 log_error("Excess arguments.");
1000 if (detect_container(NULL) > 0) {
1003 /* All /proc/cmdline arguments the kernel didn't
1004 * understand it passed to us. We're not really
1005 * interested in that usually since /proc/cmdline is
1006 * more interesting and complete. With one exception:
1007 * if we are run in a container /proc/cmdline is not
1008 * relevant for the container, hence we rely on argv[]
1011 for (a = argv; a < argv + argc; a++)
1012 if ((r = parse_proc_cmdline_word(*a)) < 0)
1019 static int help(void) {
1021 printf("%s [OPTIONS...]\n\n"
1022 "Starts up and maintains the system or user services.\n\n"
1023 " -h --help Show this help\n"
1024 " --test Determine startup sequence, dump it and exit\n"
1025 " --dump-configuration-items Dump understood unit configuration items\n"
1026 " --introspect[=INTERFACE] Extract D-Bus interface data\n"
1027 " --unit=UNIT Set default unit\n"
1028 " --system Run a system instance, even if PID != 1\n"
1029 " --user Run a user instance\n"
1030 " --dump-core[=0|1] Dump core on crash\n"
1031 " --crash-shell[=0|1] Run shell on crash\n"
1032 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
1033 " --show-status[=0|1] Show status updates on the console during bootup\n"
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);
1045 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds) {
1054 /* Make sure nothing is really destructed when we shut down */
1057 if ((r = manager_open_serialization(m, &f)) < 0) {
1058 log_error("Failed to create serialization file: %s", strerror(-r));
1062 if (!(fds = fdset_new())) {
1064 log_error("Failed to allocate fd set: %s", strerror(-r));
1068 if ((r = manager_serialize(m, f, fds)) < 0) {
1069 log_error("Failed to serialize state: %s", strerror(-r));
1073 if (fseeko(f, 0, SEEK_SET) < 0) {
1074 log_error("Failed to rewind serialization fd: %m");
1078 if ((r = fd_cloexec(fileno(f), false)) < 0) {
1079 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1083 if ((r = fdset_cloexec(fds, false)) < 0) {
1084 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1102 static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1104 unsigned long long a, b;
1108 e = getenv("RD_TIMESTAMP");
1112 if (sscanf(e, "%llu %llu", &a, &b) != 2)
1115 t->realtime = (usec_t) a;
1116 t->monotonic = (usec_t) b;
1121 static void test_mtab(void) {
1124 /* Check that /etc/mtab is a symlink */
1126 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1129 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
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.");
1141 static void test_usr(void) {
1143 /* Check that /usr is not a separate fs */
1145 if (dir_is_empty("/usr") <= 0)
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.");
1153 static void test_cgroups(void) {
1155 if (access("/proc/cgroups", F_OK) >= 0)
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.");
1168 int main(int argc, char *argv[]) {
1170 int r, retval = EXIT_FAILURE;
1171 usec_t before_startup, after_startup;
1172 char timespan[FORMAT_TIMESPAN_MAX];
1174 bool reexecute = false;
1175 const char *shutdown_verb = NULL;
1176 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1177 static char systemd[] = "systemd";
1178 bool skip_setup = false;
1180 bool loaded_policy = false;
1181 bool arm_reboot_watchdog = false;
1182 bool queue_default_job = false;
1183 char *switch_root_dir = NULL, *switch_root_init = NULL;
1185 #ifdef HAVE_SYSV_COMPAT
1186 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1187 /* This is compatibility support for SysV, where
1188 * calling init as a user is identical to telinit. */
1191 execv(SYSTEMCTL_BINARY_PATH, argv);
1192 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1197 /* Determine if this is a reexecution or normal bootup. We do
1198 * the full command line parsing much later, so let's just
1199 * have a quick peek here. */
1200 for (j = 1; j < argc; j++)
1201 if (streq(argv[j], "--deserialize")) {
1206 /* If we have switched root, do all the special setup
1208 for (j = 1; j < argc; j++)
1209 if (streq(argv[j], "--switched-root")) {
1214 /* If we get started via the /sbin/init symlink then we are
1215 called 'init'. After a subsequent reexecution we are then
1216 called 'systemd'. That is confusing, hence let's call us
1217 systemd right-away. */
1218 program_invocation_short_name = systemd;
1219 prctl(PR_SET_NAME, systemd);
1224 log_show_color(isatty(STDERR_FILENO) > 0);
1225 log_show_location(false);
1226 log_set_max_level(LOG_INFO);
1228 if (getpid() == 1) {
1230 char *rd_timestamp = NULL;
1232 dual_timestamp_get(&initrd_timestamp);
1233 asprintf(&rd_timestamp, "%llu %llu",
1234 (unsigned long long) initrd_timestamp.realtime,
1235 (unsigned long long) initrd_timestamp.monotonic);
1237 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1242 arg_running_as = MANAGER_SYSTEM;
1243 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
1246 if (selinux_setup(&loaded_policy) < 0)
1248 if (ima_setup() < 0)
1254 if (label_init(NULL) < 0)
1258 if (hwclock_is_localtime() > 0) {
1261 r = hwclock_apply_localtime_delta(&min);
1263 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1265 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1269 arg_running_as = MANAGER_USER;
1270 log_set_target(LOG_TARGET_AUTO);
1274 /* Initialize default unit */
1275 if (set_default_unit(SPECIAL_DEFAULT_TARGET) < 0)
1278 /* By default, mount "cpu" and "cpuacct" together */
1279 arg_join_controllers = new(char**, 2);
1280 if (!arg_join_controllers)
1283 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1284 arg_join_controllers[1] = NULL;
1286 if (!arg_join_controllers[0])
1289 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1290 * /proc/$PID/fd is available. */
1291 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1292 r = mount_setup(loaded_policy);
1297 /* Reset all signal handlers. */
1298 assert_se(reset_all_signal_handlers() == 0);
1300 /* If we are init, we can block sigkill. Yay. */
1301 ignore_signals(SIGNALS_IGNORE, -1);
1303 if (parse_config_file() < 0)
1306 if (arg_running_as == MANAGER_SYSTEM)
1307 if (parse_proc_cmdline() < 0)
1310 log_parse_environment();
1312 if (parse_argv(argc, argv) < 0)
1315 if (arg_action == ACTION_TEST && geteuid() == 0) {
1316 log_error("Don't run test mode as root.");
1320 if (arg_running_as == MANAGER_SYSTEM &&
1321 arg_action == ACTION_RUN &&
1322 running_in_chroot() > 0) {
1323 log_error("Cannot be run in a chroot() environment.");
1327 if (arg_action == ACTION_HELP) {
1330 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1331 unit_dump_config_items(stdout);
1332 retval = EXIT_SUCCESS;
1334 } else if (arg_action == ACTION_DONE) {
1335 retval = EXIT_SUCCESS;
1339 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1341 /* Close logging fds, in order not to confuse fdset below */
1344 /* Remember open file descriptors for later deserialization */
1345 if (serialization) {
1346 r = fdset_new_fill(&fds);
1348 log_error("Failed to allocate fd set: %s", strerror(-r));
1352 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1354 close_all_fds(NULL, 0);
1356 /* Set up PATH unless it is already set */
1358 #ifdef HAVE_SPLIT_USR
1359 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1361 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1363 arg_running_as == MANAGER_SYSTEM);
1365 if (arg_running_as == MANAGER_SYSTEM) {
1366 /* Parse the data passed to us. We leave this
1367 * variables set, but the manager later on will not
1368 * pass them on to our children. */
1370 parse_initrd_timestamp(&initrd_timestamp);
1372 /* Unset some environment variables passed in from the
1373 * kernel that don't really make sense for us. */
1377 /* When we are invoked by a shell, these might be set,
1378 * but make little sense to pass on */
1383 /* When we are invoked by a chroot-like tool such as
1384 * nspawn, these might be set, but make little sense
1387 unsetenv("LOGNAME");
1389 /* All other variables are left as is, so that clients
1390 * can still read them via /proc/1/environ */
1393 /* Move out of the way, so that we won't block unmounts */
1394 assert_se(chdir("/") == 0);
1396 if (arg_running_as == MANAGER_SYSTEM) {
1397 /* Become a session leader if we aren't one yet. */
1400 /* Disable the umask logic */
1404 /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1405 dbus_connection_set_change_sigpipe(FALSE);
1407 /* Reset the console, but only if this is really init and we
1408 * are freshly booted */
1409 if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
1410 console_setup(getpid() == 1 && !skip_setup);
1414 /* Open the logging devices, if possible and necessary */
1417 /* Make sure we leave a core dump without panicing the
1420 install_crash_handler();
1422 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1423 r = mount_cgroup_controllers(arg_join_controllers);
1428 if (arg_running_as == MANAGER_SYSTEM) {
1429 const char *virtualization = NULL;
1431 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1433 detect_virtualization(&virtualization);
1435 log_info("Detected virtualization '%s'.", virtualization);
1438 log_info("Running in initial RAM disk.");
1441 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1443 if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1446 if (arg_show_status || plymouth_running())
1459 if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1460 watchdog_set_timeout(&arg_runtime_watchdog);
1462 if (arg_timer_slack_nsec != (nsec_t) -1)
1463 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1464 log_error("Failed to adjust timer slack: %m");
1466 if (arg_capability_bounding_set_drop) {
1467 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1469 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1472 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1474 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1479 r = manager_new(arg_running_as, &m);
1481 log_error("Failed to allocate manager object: %s", strerror(-r));
1485 m->confirm_spawn = arg_confirm_spawn;
1486 m->default_std_output = arg_default_std_output;
1487 m->default_std_error = arg_default_std_error;
1488 m->runtime_watchdog = arg_runtime_watchdog;
1489 m->shutdown_watchdog = arg_shutdown_watchdog;
1491 manager_set_default_rlimits(m, arg_default_rlimit);
1493 if (dual_timestamp_is_set(&initrd_timestamp))
1494 m->initrd_timestamp = initrd_timestamp;
1496 if (arg_default_controllers)
1497 manager_set_default_controllers(m, arg_default_controllers);
1499 manager_set_show_status(m, arg_show_status);
1501 /* Remember whether we should queue the default job */
1502 queue_default_job = !serialization || arg_switched_root;
1504 before_startup = now(CLOCK_MONOTONIC);
1506 r = manager_startup(m, serialization, fds);
1508 log_error("Failed to fully start up daemon: %s", strerror(-r));
1510 /* This will close all file descriptors that were opened, but
1511 * not claimed by any unit. */
1517 if (serialization) {
1518 fclose(serialization);
1519 serialization = NULL;
1522 if (queue_default_job) {
1524 Unit *target = NULL;
1525 Job *default_unit_job;
1527 dbus_error_init(&error);
1529 log_debug("Activating default unit: %s", arg_default_unit);
1531 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1533 log_error("Failed to load default target: %s", bus_error(&error, r));
1534 dbus_error_free(&error);
1535 } else if (target->load_state == UNIT_ERROR)
1536 log_error("Failed to load default target: %s", strerror(-target->load_error));
1537 else if (target->load_state == UNIT_MASKED)
1538 log_error("Default target masked.");
1540 if (!target || target->load_state != UNIT_LOADED) {
1541 log_info("Trying to load rescue target...");
1543 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1545 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1546 dbus_error_free(&error);
1548 } else if (target->load_state == UNIT_ERROR) {
1549 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1551 } else if (target->load_state == UNIT_MASKED) {
1552 log_error("Rescue target masked.");
1557 assert(target->load_state == UNIT_LOADED);
1559 if (arg_action == ACTION_TEST) {
1560 printf("-> By units:\n");
1561 manager_dump_units(m, stdout, "\t");
1564 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1566 log_error("Failed to start default target: %s", bus_error(&error, r));
1567 dbus_error_free(&error);
1570 m->default_unit_job_id = default_unit_job->id;
1572 after_startup = now(CLOCK_MONOTONIC);
1573 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1574 "Loaded units and determined initial transaction in %s.",
1575 format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1577 if (arg_action == ACTION_TEST) {
1578 printf("-> By jobs:\n");
1579 manager_dump_jobs(m, stdout, "\t");
1580 retval = EXIT_SUCCESS;
1586 r = manager_loop(m);
1588 log_error("Failed to run mainloop: %s", strerror(-r));
1592 switch (m->exit_code) {
1595 retval = EXIT_SUCCESS;
1599 case MANAGER_RELOAD:
1600 log_info("Reloading.");
1601 r = manager_reload(m);
1603 log_error("Failed to reload: %s", strerror(-r));
1606 case MANAGER_REEXECUTE:
1608 if (prepare_reexecute(m, &serialization, &fds) < 0)
1612 log_notice("Reexecuting.");
1615 case MANAGER_SWITCH_ROOT:
1616 /* Steal the switch root parameters */
1617 switch_root_dir = m->switch_root;
1618 switch_root_init = m->switch_root_init;
1619 m->switch_root = m->switch_root_init = NULL;
1621 if (!switch_root_init)
1622 if (prepare_reexecute(m, &serialization, &fds) < 0)
1626 log_notice("Switching root.");
1629 case MANAGER_REBOOT:
1630 case MANAGER_POWEROFF:
1632 case MANAGER_KEXEC: {
1633 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1634 [MANAGER_REBOOT] = "reboot",
1635 [MANAGER_POWEROFF] = "poweroff",
1636 [MANAGER_HALT] = "halt",
1637 [MANAGER_KEXEC] = "kexec"
1640 assert_se(shutdown_verb = table[m->exit_code]);
1641 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1643 log_notice("Shutting down.");
1648 assert_not_reached("Unknown exit code.");
1656 for (j = 0; j < RLIMIT_NLIMITS; j++)
1657 free (arg_default_rlimit[j]);
1659 free(arg_default_unit);
1660 strv_free(arg_default_controllers);
1661 free_join_controllers();
1668 unsigned i, args_size;
1670 /* Close and disarm the watchdog, so that the new
1671 * instance can reinitialize it, but doesn't get
1672 * rebooted while we do that */
1673 watchdog_close(true);
1675 /* Reopen the console */
1676 make_console_stdio();
1678 if (switch_root_dir) {
1679 r = switch_root(switch_root_dir);
1681 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1684 args_size = MAX(6, argc+1);
1685 args = newa(const char*, args_size);
1687 if (!switch_root_init) {
1690 /* First try to spawn ourselves with the right
1691 * path, and with full serialization. We do
1692 * this only if the user didn't specify an
1693 * explicit init to spawn. */
1695 assert(serialization);
1698 snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1702 args[i++] = SYSTEMD_BINARY_PATH;
1703 if (switch_root_dir)
1704 args[i++] = "--switched-root";
1705 args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1706 args[i++] = "--deserialize";
1710 assert(i <= args_size);
1711 execv(args[0], (char* const*) args);
1714 /* Try the fallback, if there is any, without any
1715 * serialization. We pass the original argv[] and
1716 * envp[]. (Well, modulo the ordering changes due to
1717 * getopt() in argv[], and some cleanups in envp[],
1718 * but let's hope that doesn't matter.) */
1720 if (serialization) {
1721 fclose(serialization);
1722 serialization = NULL;
1730 for (j = 1, i = 1; j < argc; j++)
1731 args[i++] = argv[j];
1733 assert(i <= args_size);
1735 if (switch_root_init) {
1736 args[0] = switch_root_init;
1737 execv(args[0], (char* const*) args);
1738 log_warning("Failed to execute configured init, trying fallback: %m");
1741 args[0] = "/sbin/init";
1742 execv(args[0], (char* const*) args);
1744 if (errno == ENOENT) {
1745 log_warning("No /sbin/init, trying fallback");
1747 args[0] = "/bin/sh";
1749 execv(args[0], (char* const*) args);
1750 log_error("Failed to execute /bin/sh, giving up: %m");
1752 log_warning("Failed to execute /sbin/init, giving up: %m");
1756 fclose(serialization);
1761 if (shutdown_verb) {
1762 const char * command_line[] = {
1763 SYSTEMD_SHUTDOWN_BINARY_PATH,
1769 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1772 /* If we reboot let's set the shutdown
1773 * watchdog and tell the shutdown binary to
1774 * repeatedly ping it */
1775 watchdog_set_timeout(&arg_shutdown_watchdog);
1776 watchdog_close(false);
1778 /* Tell the binary how often to ping */
1779 snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1782 env_block = strv_append(environ, e);
1784 env_block = strv_copy(environ);
1785 watchdog_close(true);
1788 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1790 log_error("Failed to execute shutdown binary, freezing: %m");