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"
57 #include "sd-daemon.h"
59 #include "mount-setup.h"
60 #include "loopback-setup.h"
62 #include "kmod-setup.h"
64 #include "hostname-setup.h"
65 #include "machine-id-setup.h"
66 #include "locale-setup.h"
67 #include "selinux-setup.h"
68 #include "ima-setup.h"
70 #include "smack-setup.h"
77 ACTION_DUMP_CONFIGURATION_ITEMS,
79 } arg_action = ACTION_RUN;
81 static char *arg_default_unit = NULL;
82 static SystemdRunningAs arg_running_as = _SYSTEMD_RUNNING_AS_INVALID;
84 static bool arg_dump_core = true;
85 static bool arg_crash_shell = false;
86 static int arg_crash_chvt = -1;
87 static bool arg_confirm_spawn = false;
88 static bool arg_show_status = true;
89 static bool arg_switched_root = false;
90 static char **arg_default_controllers = NULL;
91 static char ***arg_join_controllers = NULL;
92 static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
93 static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
94 static usec_t arg_runtime_watchdog = 0;
95 static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
96 static struct rlimit *arg_default_rlimit[RLIMIT_NLIMITS] = {};
97 static uint64_t arg_capability_bounding_set_drop = 0;
98 static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
100 static FILE* serialization = NULL;
102 static void nop_handler(int sig) {
105 _noreturn_ static void crash(int sig) {
108 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
113 /* We want to wait for the core process, hence let's enable SIGCHLD */
115 sa.sa_handler = nop_handler;
116 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
117 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
121 log_error("Caught <%s>, cannot fork for core dump: %s", signal_to_string(sig), strerror(errno));
126 /* Enable default signal handler for core dump */
128 sa.sa_handler = SIG_DFL;
129 assert_se(sigaction(sig, &sa, NULL) == 0);
131 /* Don't limit the core dump size */
133 rl.rlim_cur = RLIM_INFINITY;
134 rl.rlim_max = RLIM_INFINITY;
135 setrlimit(RLIMIT_CORE, &rl);
137 /* Just to be sure... */
138 assert_se(chdir("/") == 0);
140 /* Raise the signal again */
143 assert_not_reached("We shouldn't be here...");
150 /* Order things nicely. */
151 r = wait_for_terminate(pid, &status);
153 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
154 else if (status.si_code != CLD_DUMPED)
155 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
157 log_error("Caught <%s>, dumped core as pid %lu.", signal_to_string(sig), (unsigned long) pid);
162 chvt(arg_crash_chvt);
164 if (arg_crash_shell) {
168 log_info("Executing crash shell in 10s...");
171 /* Let the kernel reap children for us */
173 sa.sa_handler = SIG_IGN;
174 sa.sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART;
175 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
179 log_error("Failed to fork off crash shell: %m");
181 make_console_stdio();
182 execl("/bin/sh", "/bin/sh", NULL);
184 log_error("execl() failed: %m");
188 log_info("Successfully spawned crash shell as pid %lu.", (unsigned long) pid);
191 log_info("Freezing execution.");
195 static void install_crash_handler(void) {
200 sa.sa_handler = crash;
201 sa.sa_flags = SA_NODEFER;
203 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
206 static int console_setup(bool do_reset) {
209 /* If we are init, we connect stdin/stdout/stderr to /dev/null
210 * and make sure we don't have a controlling tty. */
217 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
219 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
223 /* We don't want to force text mode.
224 * plymouth may be showing pictures already from initrd. */
225 r = reset_terminal_fd(tty_fd, false);
227 log_error("Failed to reset /dev/console: %s", strerror(-r));
229 close_nointr_nofail(tty_fd);
233 static int set_default_unit(const char *u) {
242 free(arg_default_unit);
243 arg_default_unit = c;
248 static int parse_proc_cmdline_word(const char *word) {
250 static const char * const rlmap[] = {
251 "emergency", SPECIAL_EMERGENCY_TARGET,
252 "-b", SPECIAL_EMERGENCY_TARGET,
253 "single", SPECIAL_RESCUE_TARGET,
254 "-s", SPECIAL_RESCUE_TARGET,
255 "s", SPECIAL_RESCUE_TARGET,
256 "S", SPECIAL_RESCUE_TARGET,
257 "1", SPECIAL_RESCUE_TARGET,
258 "2", SPECIAL_RUNLEVEL2_TARGET,
259 "3", SPECIAL_RUNLEVEL3_TARGET,
260 "4", SPECIAL_RUNLEVEL4_TARGET,
261 "5", SPECIAL_RUNLEVEL5_TARGET,
266 if (startswith(word, "systemd.unit=")) {
269 return set_default_unit(word + 13);
271 } else if (startswith(word, "rd.systemd.unit=")) {
274 return set_default_unit(word + 16);
276 } else if (startswith(word, "systemd.log_target=")) {
278 if (log_set_target_from_string(word + 19) < 0)
279 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
281 } else if (startswith(word, "systemd.log_level=")) {
283 if (log_set_max_level_from_string(word + 18) < 0)
284 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
286 } else if (startswith(word, "systemd.log_color=")) {
288 if (log_show_color_from_string(word + 18) < 0)
289 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
291 } else if (startswith(word, "systemd.log_location=")) {
293 if (log_show_location_from_string(word + 21) < 0)
294 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
296 } else if (startswith(word, "systemd.dump_core=")) {
299 if ((r = parse_boolean(word + 18)) < 0)
300 log_warning("Failed to parse dump core switch %s. Ignoring.", word + 18);
304 } else if (startswith(word, "systemd.crash_shell=")) {
307 if ((r = parse_boolean(word + 20)) < 0)
308 log_warning("Failed to parse crash shell switch %s. Ignoring.", word + 20);
312 } else if (startswith(word, "systemd.confirm_spawn=")) {
315 if ((r = parse_boolean(word + 22)) < 0)
316 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", word + 22);
318 arg_confirm_spawn = r;
320 } else if (startswith(word, "systemd.crash_chvt=")) {
323 if (safe_atoi(word + 19, &k) < 0)
324 log_warning("Failed to parse crash chvt switch %s. Ignoring.", word + 19);
328 } else if (startswith(word, "systemd.show_status=")) {
331 if ((r = parse_boolean(word + 20)) < 0)
332 log_warning("Failed to parse show status switch %s. Ignoring.", word + 20);
335 } else if (startswith(word, "systemd.default_standard_output=")) {
338 if ((r = exec_output_from_string(word + 32)) < 0)
339 log_warning("Failed to parse default standard output switch %s. Ignoring.", word + 32);
341 arg_default_std_output = r;
342 } else if (startswith(word, "systemd.default_standard_error=")) {
345 if ((r = exec_output_from_string(word + 31)) < 0)
346 log_warning("Failed to parse default standard error switch %s. Ignoring.", word + 31);
348 arg_default_std_error = r;
349 } else if (startswith(word, "systemd.setenv=")) {
350 _cleanup_free_ char *cenv = NULL;
354 cenv = strdup(word + 15);
358 eq = strchr(cenv, '=');
360 if (!env_name_is_valid(cenv))
361 log_warning("Environment variable name '%s' is not valid. Ignoring.", cenv);
365 log_warning("Unsetting environment variable '%s' failed, ignoring: %m", cenv);
368 if (!env_assignment_is_valid(cenv))
369 log_warning("Environment variable assignment '%s' is not valid. Ignoring.", cenv);
372 r = setenv(cenv, eq + 1, 1);
374 log_warning("Setting environment variable '%s=%s' failed, ignoring: %m", cenv, eq + 1);
378 } else if (startswith(word, "systemd.") ||
379 (in_initrd() && startswith(word, "rd.systemd."))) {
383 /* Ignore systemd.journald.xyz and friends */
385 if (startswith(c, "rd."))
387 if (startswith(c, "systemd."))
389 if (c[strcspn(c, ".=")] != '.') {
391 log_warning("Unknown kernel switch %s. Ignoring.", word);
393 log_info("Supported kernel switches:\n"
394 "systemd.unit=UNIT Default unit to start\n"
395 "rd.systemd.unit=UNIT Default unit to start when run in initrd\n"
396 "systemd.dump_core=0|1 Dump core on crash\n"
397 "systemd.crash_shell=0|1 Run shell on crash\n"
398 "systemd.crash_chvt=N Change to VT #N on crash\n"
399 "systemd.confirm_spawn=0|1 Confirm every process spawn\n"
400 "systemd.show_status=0|1 Show status updates on the console during bootup\n"
401 "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\n"
403 "systemd.log_level=LEVEL Log level\n"
404 "systemd.log_color=0|1 Highlight important log messages\n"
405 "systemd.log_location=0|1 Include code location in log messages\n"
406 "systemd.default_standard_output=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
407 " Set default log output for services\n"
408 "systemd.default_standard_error=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
409 " Set default log error output for services\n"
410 "systemd.setenv=ASSIGNMENT Set an environment variable for all spawned processes\n");
413 } else if (streq(word, "quiet"))
414 arg_show_status = false;
415 else if (!in_initrd()) {
418 /* SysV compatibility */
419 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
420 if (streq(word, rlmap[i]))
421 return set_default_unit(rlmap[i+1]);
427 static int config_parse_level2(
428 const char *filename,
441 log_set_max_level_from_string(rvalue);
445 static int config_parse_target(
446 const char *filename,
459 log_set_target_from_string(rvalue);
463 static int config_parse_color(
464 const char *filename,
477 log_show_color_from_string(rvalue);
481 static int config_parse_location(
482 const char *filename,
495 log_show_location_from_string(rvalue);
499 static int config_parse_cpu_affinity2(
500 const char *filename,
519 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
524 if (!(t = strndup(w, l)))
527 r = safe_atou(t, &cpu);
531 if (!(c = cpu_set_malloc(&ncpus)))
534 if (r < 0 || cpu >= ncpus) {
535 log_error("[%s:%u] Failed to parse CPU affinity: %s", filename, line, rvalue);
540 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
544 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
545 log_warning("Failed to set CPU affinity: %m");
553 static void strv_free_free(char ***l) {
565 static void free_join_controllers(void) {
566 if (!arg_join_controllers)
569 strv_free_free(arg_join_controllers);
570 arg_join_controllers = NULL;
573 static int config_parse_join_controllers(
574 const char *filename,
591 free_join_controllers();
593 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
596 s = strndup(w, length);
600 l = strv_split(s, ",");
605 if (strv_length(l) <= 1) {
610 if (!arg_join_controllers) {
611 arg_join_controllers = new(char**, 2);
612 if (!arg_join_controllers) {
617 arg_join_controllers[0] = l;
618 arg_join_controllers[1] = NULL;
625 t = new0(char**, n+2);
633 for (a = arg_join_controllers; *a; a++) {
635 if (strv_overlap(*a, l)) {
638 c = strv_merge(*a, l);
661 t[n++] = strv_uniq(l);
663 strv_free_free(arg_join_controllers);
664 arg_join_controllers = t;
671 static int parse_config_file(void) {
673 const ConfigTableItem items[] = {
674 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
675 { "Manager", "LogTarget", config_parse_target, 0, NULL },
676 { "Manager", "LogColor", config_parse_color, 0, NULL },
677 { "Manager", "LogLocation", config_parse_location, 0, NULL },
678 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
679 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
680 { "Manager", "ShowStatus", config_parse_bool, 0, &arg_show_status },
681 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
682 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
683 { "Manager", "DefaultControllers", config_parse_strv, 0, &arg_default_controllers },
684 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
685 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
686 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
687 { "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },
688 { "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_shutdown_watchdog },
689 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
690 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
691 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU]},
692 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE]},
693 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA]},
694 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK]},
695 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE]},
696 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS]},
697 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE]},
698 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS]},
699 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC]},
700 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK]},
701 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS]},
702 { "Manager", "DefaultLimitSIGPENDING",config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING]},
703 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE]},
704 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE]},
705 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO]},
706 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME]},
707 { NULL, NULL, NULL, 0, NULL }
714 fn = arg_running_as == SYSTEMD_SYSTEM ? SYSTEM_CONFIG_FILE : USER_CONFIG_FILE;
720 log_warning("Failed to open configuration file '%s': %m", fn);
724 r = config_parse(fn, f, "Manager\0", config_item_table_lookup, (void*) items, false, NULL);
726 log_warning("Failed to parse configuration file: %s", strerror(-r));
733 static int parse_proc_cmdline(void) {
734 char *line, *w, *state;
738 /* Don't read /proc/cmdline if we are in a container, since
739 * that is only relevant for the host system */
740 if (detect_container(NULL) > 0)
743 if ((r = read_one_line_file("/proc/cmdline", &line)) < 0) {
744 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
748 FOREACH_WORD_QUOTED(w, l, line, state) {
751 if (!(word = strndup(w, l))) {
756 r = parse_proc_cmdline_word(word);
758 log_error("Failed on cmdline argument %s: %s", word, strerror(-r));
773 static int parse_argv(int argc, char *argv[]) {
776 ARG_LOG_LEVEL = 0x100,
785 ARG_DUMP_CONFIGURATION_ITEMS,
793 ARG_DEFAULT_STD_OUTPUT,
794 ARG_DEFAULT_STD_ERROR
797 static const struct option options[] = {
798 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
799 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
800 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
801 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
802 { "unit", required_argument, NULL, ARG_UNIT },
803 { "system", no_argument, NULL, ARG_SYSTEM },
804 { "user", no_argument, NULL, ARG_USER },
805 { "test", no_argument, NULL, ARG_TEST },
806 { "help", no_argument, NULL, 'h' },
807 { "version", no_argument, NULL, ARG_VERSION },
808 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
809 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
810 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
811 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
812 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
813 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
814 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
815 { "introspect", optional_argument, NULL, ARG_INTROSPECT },
816 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
817 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
829 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
834 if ((r = log_set_max_level_from_string(optarg)) < 0) {
835 log_error("Failed to parse log level %s.", optarg);
843 if ((r = log_set_target_from_string(optarg)) < 0) {
844 log_error("Failed to parse log target %s.", optarg);
853 if ((r = log_show_color_from_string(optarg)) < 0) {
854 log_error("Failed to parse log color setting %s.", optarg);
858 log_show_color(true);
862 case ARG_LOG_LOCATION:
865 if ((r = log_show_location_from_string(optarg)) < 0) {
866 log_error("Failed to parse log location setting %s.", optarg);
870 log_show_location(true);
874 case ARG_DEFAULT_STD_OUTPUT:
876 if ((r = exec_output_from_string(optarg)) < 0) {
877 log_error("Failed to parse default standard output setting %s.", optarg);
880 arg_default_std_output = r;
883 case ARG_DEFAULT_STD_ERROR:
885 if ((r = exec_output_from_string(optarg)) < 0) {
886 log_error("Failed to parse default standard error output setting %s.", optarg);
889 arg_default_std_error = r;
894 if ((r = set_default_unit(optarg)) < 0) {
895 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
902 arg_running_as = SYSTEMD_SYSTEM;
906 arg_running_as = SYSTEMD_USER;
910 arg_action = ACTION_TEST;
914 arg_action = ACTION_VERSION;
917 case ARG_DUMP_CONFIGURATION_ITEMS:
918 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
922 r = optarg ? parse_boolean(optarg) : 1;
924 log_error("Failed to parse dump core boolean %s.", optarg);
930 case ARG_CRASH_SHELL:
931 r = optarg ? parse_boolean(optarg) : 1;
933 log_error("Failed to parse crash shell boolean %s.", optarg);
939 case ARG_CONFIRM_SPAWN:
940 r = optarg ? parse_boolean(optarg) : 1;
942 log_error("Failed to parse confirm spawn boolean %s.", optarg);
945 arg_confirm_spawn = r;
948 case ARG_SHOW_STATUS:
949 r = optarg ? parse_boolean(optarg) : 1;
951 log_error("Failed to parse show status boolean %s.", optarg);
957 case ARG_DESERIALIZE: {
961 r = safe_atoi(optarg, &fd);
962 if (r < 0 || fd < 0) {
963 log_error("Failed to parse deserialize option %s.", optarg);
964 return r < 0 ? r : -EINVAL;
967 fd_cloexec(fd, true);
971 log_error("Failed to open serialization fd: %m");
976 fclose(serialization);
983 case ARG_SWITCHED_ROOT:
984 arg_switched_root = true;
987 case ARG_INTROSPECT: {
988 const char * const * i = NULL;
990 for (i = bus_interface_table; *i; i += 2)
991 if (!optarg || streq(i[0], optarg)) {
992 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
995 fputs("</node>\n", stdout);
1001 if (!i[0] && optarg)
1002 log_error("Unknown interface %s.", optarg);
1004 arg_action = ACTION_DONE;
1009 arg_action = ACTION_HELP;
1013 log_set_max_level(LOG_DEBUG);
1019 /* Just to eat away the sysvinit kernel
1020 * cmdline args without getopt() error
1021 * messages that we'll parse in
1022 * parse_proc_cmdline_word() or ignore. */
1026 if (getpid() != 1) {
1027 log_error("Unknown option code %c", c);
1034 if (optind < argc && getpid() != 1) {
1035 /* Hmm, when we aren't run as init system
1036 * let's complain about excess arguments */
1038 log_error("Excess arguments.");
1042 if (detect_container(NULL) > 0) {
1045 /* All /proc/cmdline arguments the kernel didn't
1046 * understand it passed to us. We're not really
1047 * interested in that usually since /proc/cmdline is
1048 * more interesting and complete. With one exception:
1049 * if we are run in a container /proc/cmdline is not
1050 * relevant for the container, hence we rely on argv[]
1053 for (a = argv; a < argv + argc; a++)
1054 if ((r = parse_proc_cmdline_word(*a)) < 0) {
1055 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
1063 static int help(void) {
1065 printf("%s [OPTIONS...]\n\n"
1066 "Starts up and maintains the system or user services.\n\n"
1067 " -h --help Show this help\n"
1068 " --test Determine startup sequence, dump it and exit\n"
1069 " --dump-configuration-items Dump understood unit configuration items\n"
1070 " --introspect[=INTERFACE] Extract D-Bus interface data\n"
1071 " --unit=UNIT Set default unit\n"
1072 " --system Run a system instance, even if PID != 1\n"
1073 " --user Run a user instance\n"
1074 " --dump-core[=0|1] Dump core on crash\n"
1075 " --crash-shell[=0|1] Run shell on crash\n"
1076 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
1077 " --show-status[=0|1] Show status updates on the console during bootup\n"
1078 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1079 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1080 " --log-color[=0|1] Highlight important log messages\n"
1081 " --log-location[=0|1] Include code location in log messages\n"
1082 " --default-standard-output= Set default standard output for services\n"
1083 " --default-standard-error= Set default standard error output for services\n",
1084 program_invocation_short_name);
1089 static int version(void) {
1090 puts(PACKAGE_STRING);
1091 puts(SYSTEMD_FEATURES);
1096 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool serialize_jobs) {
1105 /* Make sure nothing is really destructed when we shut down */
1108 r = manager_open_serialization(m, &f);
1110 log_error("Failed to create serialization file: %s", strerror(-r));
1117 log_error("Failed to allocate fd set: %s", strerror(-r));
1121 r = manager_serialize(m, f, fds, serialize_jobs);
1123 log_error("Failed to serialize state: %s", strerror(-r));
1127 if (fseeko(f, 0, SEEK_SET) < 0) {
1128 log_error("Failed to rewind serialization fd: %m");
1132 r = fd_cloexec(fileno(f), false);
1134 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1138 r = fdset_cloexec(fds, false);
1140 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1158 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1162 assert(saved_rlimit);
1164 /* Save the original RLIMIT_NOFILE so that we can reset it
1165 * later when transitioning from the initrd to the main
1166 * systemd or suchlike. */
1167 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1168 log_error("Reading RLIMIT_NOFILE failed: %m");
1172 /* Make sure forked processes get the default kernel setting */
1173 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1176 rl = newdup(struct rlimit, saved_rlimit, 1);
1180 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1183 /* Bump up the resource limit for ourselves substantially */
1184 nl.rlim_cur = nl.rlim_max = 64*1024;
1185 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1187 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1194 static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1196 unsigned long long a, b;
1200 e = getenv("RD_TIMESTAMP");
1204 if (sscanf(e, "%llu %llu", &a, &b) != 2)
1207 t->realtime = (usec_t) a;
1208 t->monotonic = (usec_t) b;
1213 static void test_mtab(void) {
1216 /* Check that /etc/mtab is a symlink */
1218 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1221 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1228 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1229 "This is not supported anymore. "
1230 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1233 static void test_usr(void) {
1235 /* Check that /usr is not a separate fs */
1237 if (dir_is_empty("/usr") <= 0)
1240 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1241 "Some things will probably break (sometimes even silently) in mysterious ways. "
1242 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1245 static void test_cgroups(void) {
1247 if (access("/proc/cgroups", F_OK) >= 0)
1250 log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1251 "Systems without control groups are not supported. "
1252 "We will now sleep for 10s, and then continue boot-up. "
1253 "Expect breakage and please do not file bugs. "
1254 "Instead fix your kernel and enable CONFIG_CGROUPS. "
1255 "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1260 static int initialize_join_controllers(void) {
1261 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1262 * + "net_prio". We'd like to add "cpuset" to the mix, but
1263 * "cpuset" does't really work for groups with no initialized
1266 arg_join_controllers = new(char**, 3);
1267 if (!arg_join_controllers)
1270 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1271 if (!arg_join_controllers[0])
1274 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1275 if (!arg_join_controllers[1])
1278 arg_join_controllers[2] = NULL;
1282 int main(int argc, char *argv[]) {
1284 int r, retval = EXIT_FAILURE;
1285 usec_t before_startup, after_startup;
1286 char timespan[FORMAT_TIMESPAN_MAX];
1288 bool reexecute = false;
1289 const char *shutdown_verb = NULL;
1290 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1291 static char systemd[] = "systemd";
1292 bool skip_setup = false;
1294 bool loaded_policy = false;
1295 bool arm_reboot_watchdog = false;
1296 bool queue_default_job = false;
1297 char *switch_root_dir = NULL, *switch_root_init = NULL;
1298 static struct rlimit saved_rlimit_nofile = { 0, 0 };
1300 #ifdef HAVE_SYSV_COMPAT
1301 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1302 /* This is compatibility support for SysV, where
1303 * calling init as a user is identical to telinit. */
1306 execv(SYSTEMCTL_BINARY_PATH, argv);
1307 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1312 /* Determine if this is a reexecution or normal bootup. We do
1313 * the full command line parsing much later, so let's just
1314 * have a quick peek here. */
1315 if (strv_find(argv+1, "--deserialize"))
1318 /* If we have switched root, do all the special setup
1320 if (strv_find(argv+1, "--switched-root"))
1323 /* If we get started via the /sbin/init symlink then we are
1324 called 'init'. After a subsequent reexecution we are then
1325 called 'systemd'. That is confusing, hence let's call us
1326 systemd right-away. */
1327 program_invocation_short_name = systemd;
1328 prctl(PR_SET_NAME, systemd);
1333 log_show_color(isatty(STDERR_FILENO) > 0);
1335 if (getpid() == 1 && detect_container(NULL) <= 0) {
1337 /* Running outside of a container as PID 1 */
1338 arg_running_as = SYSTEMD_SYSTEM;
1340 log_set_target(LOG_TARGET_KMSG);
1344 char *rd_timestamp = NULL;
1346 dual_timestamp_get(&initrd_timestamp);
1347 asprintf(&rd_timestamp, "%llu %llu",
1348 (unsigned long long) initrd_timestamp.realtime,
1349 (unsigned long long) initrd_timestamp.monotonic);
1351 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1357 mount_setup_early();
1358 if (selinux_setup(&loaded_policy) < 0)
1360 if (ima_setup() < 0)
1362 if (smack_setup() < 0)
1366 if (label_init(NULL) < 0)
1370 if (hwclock_is_localtime() > 0) {
1373 /* The first-time call to settimeofday() does a time warp in the kernel */
1374 r = hwclock_set_timezone(&min);
1376 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1378 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1379 } else if (!in_initrd()) {
1381 * Do dummy first-time call to seal the kernel's time warp magic
1383 * Do not call this this from inside the initrd. The initrd might not
1384 * carry /etc/adjtime with LOCAL, but the real system could be set up
1385 * that way. In such case, we need to delay the time-warp or the sealing
1386 * until we reach the real system.
1388 hwclock_reset_timezone();
1390 /* Tell the kernel our time zone */
1391 r = hwclock_set_timezone(NULL);
1393 log_error("Failed to set the kernel's time zone, ignoring: %s", strerror(-r));
1397 /* Set the default for later on, but don't actually
1398 * open the logs like this for now. Note that if we
1399 * are transitioning from the initrd there might still
1400 * be journal fd open, and we shouldn't attempt
1401 * opening that before we parsed /proc/cmdline which
1402 * might redirect output elsewhere. */
1403 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1405 } else if (getpid() == 1) {
1407 /* Running inside a container, as PID 1 */
1408 arg_running_as = SYSTEMD_SYSTEM;
1409 log_set_target(LOG_TARGET_CONSOLE);
1412 /* For the later on, see above... */
1413 log_set_target(LOG_TARGET_JOURNAL);
1417 /* Running as user instance */
1418 arg_running_as = SYSTEMD_USER;
1419 log_set_target(LOG_TARGET_AUTO);
1423 /* Initialize default unit */
1424 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1426 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1430 r = initialize_join_controllers();
1434 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1435 * /proc/$PID/fd is available. */
1436 if (getpid() == 1) {
1437 r = mount_setup(loaded_policy);
1442 /* Reset all signal handlers. */
1443 assert_se(reset_all_signal_handlers() == 0);
1445 /* If we are init, we can block sigkill. Yay. */
1446 ignore_signals(SIGNALS_IGNORE, -1);
1448 if (parse_config_file() < 0)
1451 if (arg_running_as == SYSTEMD_SYSTEM)
1452 if (parse_proc_cmdline() < 0)
1455 log_parse_environment();
1457 if (parse_argv(argc, argv) < 0)
1460 if (arg_action == ACTION_TEST &&
1462 log_error("Don't run test mode as root.");
1466 if (arg_running_as == SYSTEMD_USER &&
1467 arg_action == ACTION_RUN &&
1469 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1473 if (arg_running_as == SYSTEMD_SYSTEM &&
1474 arg_action == ACTION_RUN &&
1475 running_in_chroot() > 0) {
1476 log_error("Cannot be run in a chroot() environment.");
1480 if (arg_action == ACTION_HELP) {
1483 } else if (arg_action == ACTION_VERSION) {
1486 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1487 unit_dump_config_items(stdout);
1488 retval = EXIT_SUCCESS;
1490 } else if (arg_action == ACTION_DONE) {
1491 retval = EXIT_SUCCESS;
1495 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1497 /* Close logging fds, in order not to confuse fdset below */
1500 /* Remember open file descriptors for later deserialization */
1501 r = fdset_new_fill(&fds);
1503 log_error("Failed to allocate fd set: %s", strerror(-r));
1506 fdset_cloexec(fds, true);
1509 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1511 /* Set up PATH unless it is already set */
1513 #ifdef HAVE_SPLIT_USR
1514 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1516 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1518 arg_running_as == SYSTEMD_SYSTEM);
1520 if (arg_running_as == SYSTEMD_SYSTEM) {
1521 /* Parse the data passed to us. We leave this
1522 * variables set, but the manager later on will not
1523 * pass them on to our children. */
1525 parse_initrd_timestamp(&initrd_timestamp);
1527 /* Unset some environment variables passed in from the
1528 * kernel that don't really make sense for us. */
1532 /* When we are invoked by a shell, these might be set,
1533 * but make little sense to pass on */
1538 /* When we are invoked by a chroot-like tool such as
1539 * nspawn, these might be set, but make little sense
1542 unsetenv("LOGNAME");
1544 /* We suppress the socket activation env vars, as
1545 * we'll try to match *any* open fd to units if
1547 unsetenv("LISTEN_FDS");
1548 unsetenv("LISTEN_PID");
1550 /* All other variables are left as is, so that clients
1551 * can still read them via /proc/1/environ */
1554 /* Move out of the way, so that we won't block unmounts */
1555 assert_se(chdir("/") == 0);
1557 if (arg_running_as == SYSTEMD_SYSTEM) {
1558 /* Become a session leader if we aren't one yet. */
1561 /* Disable the umask logic */
1565 /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1566 dbus_connection_set_change_sigpipe(FALSE);
1568 /* Reset the console, but only if this is really init and we
1569 * are freshly booted */
1570 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1571 console_setup(getpid() == 1 && !skip_setup);
1573 /* Open the logging devices, if possible and necessary */
1576 /* Make sure we leave a core dump without panicing the
1578 if (getpid() == 1) {
1579 install_crash_handler();
1581 r = mount_cgroup_controllers(arg_join_controllers);
1586 if (arg_running_as == SYSTEMD_SYSTEM) {
1587 const char *virtualization = NULL;
1589 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1591 detect_virtualization(&virtualization);
1593 log_info("Detected virtualization '%s'.", virtualization);
1596 log_info("Running in initial RAM disk.");
1599 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES ")");
1601 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1604 if (arg_show_status || plymouth_running())
1619 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1620 watchdog_set_timeout(&arg_runtime_watchdog);
1622 if (arg_timer_slack_nsec != (nsec_t) -1)
1623 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1624 log_error("Failed to adjust timer slack: %m");
1626 if (arg_capability_bounding_set_drop) {
1627 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1629 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1632 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1634 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1639 if (arg_running_as == SYSTEMD_USER) {
1640 /* Become reaper of our children */
1641 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1642 log_warning("Failed to make us a subreaper: %m");
1643 if (errno == EINVAL)
1644 log_info("Perhaps the kernel version is too old (< 3.4?)");
1648 if (arg_running_as == SYSTEMD_SYSTEM)
1649 bump_rlimit_nofile(&saved_rlimit_nofile);
1651 r = manager_new(arg_running_as, &m);
1653 log_error("Failed to allocate manager object: %s", strerror(-r));
1657 m->confirm_spawn = arg_confirm_spawn;
1658 m->default_std_output = arg_default_std_output;
1659 m->default_std_error = arg_default_std_error;
1660 m->runtime_watchdog = arg_runtime_watchdog;
1661 m->shutdown_watchdog = arg_shutdown_watchdog;
1663 manager_set_default_rlimits(m, arg_default_rlimit);
1665 if (dual_timestamp_is_set(&initrd_timestamp))
1666 m->initrd_timestamp = initrd_timestamp;
1668 if (arg_default_controllers)
1669 manager_set_default_controllers(m, arg_default_controllers);
1671 manager_set_show_status(m, arg_show_status);
1673 /* Remember whether we should queue the default job */
1674 queue_default_job = !serialization || arg_switched_root;
1676 before_startup = now(CLOCK_MONOTONIC);
1678 r = manager_startup(m, serialization, fds);
1680 log_error("Failed to fully start up daemon: %s", strerror(-r));
1682 /* This will close all file descriptors that were opened, but
1683 * not claimed by any unit. */
1686 if (serialization) {
1687 fclose(serialization);
1688 serialization = NULL;
1691 if (queue_default_job) {
1693 Unit *target = NULL;
1694 Job *default_unit_job;
1696 dbus_error_init(&error);
1698 log_debug("Activating default unit: %s", arg_default_unit);
1700 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1702 log_error("Failed to load default target: %s", bus_error(&error, r));
1703 dbus_error_free(&error);
1704 } else if (target->load_state == UNIT_ERROR)
1705 log_error("Failed to load default target: %s", strerror(-target->load_error));
1706 else if (target->load_state == UNIT_MASKED)
1707 log_error("Default target masked.");
1709 if (!target || target->load_state != UNIT_LOADED) {
1710 log_info("Trying to load rescue target...");
1712 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1714 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1715 dbus_error_free(&error);
1717 } else if (target->load_state == UNIT_ERROR) {
1718 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1720 } else if (target->load_state == UNIT_MASKED) {
1721 log_error("Rescue target masked.");
1726 assert(target->load_state == UNIT_LOADED);
1728 if (arg_action == ACTION_TEST) {
1729 printf("-> By units:\n");
1730 manager_dump_units(m, stdout, "\t");
1733 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1735 log_error("Default target could not be isolated, starting instead: %s", bus_error(&error, r));
1736 dbus_error_free(&error);
1738 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1740 log_error("Failed to start default target: %s", bus_error(&error, r));
1741 dbus_error_free(&error);
1745 log_error("Failed to isolate default target: %s", bus_error(&error, r));
1746 dbus_error_free(&error);
1750 m->default_unit_job_id = default_unit_job->id;
1752 after_startup = now(CLOCK_MONOTONIC);
1753 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1754 "Loaded units and determined initial transaction in %s.",
1755 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1757 if (arg_action == ACTION_TEST) {
1758 printf("-> By jobs:\n");
1759 manager_dump_jobs(m, stdout, "\t");
1760 retval = EXIT_SUCCESS;
1766 r = manager_loop(m);
1768 log_error("Failed to run mainloop: %s", strerror(-r));
1772 switch (m->exit_code) {
1775 retval = EXIT_SUCCESS;
1779 case MANAGER_RELOAD:
1780 log_info("Reloading.");
1781 r = manager_reload(m);
1783 log_error("Failed to reload: %s", strerror(-r));
1786 case MANAGER_REEXECUTE:
1788 if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1792 log_notice("Reexecuting.");
1795 case MANAGER_SWITCH_ROOT:
1796 /* Steal the switch root parameters */
1797 switch_root_dir = m->switch_root;
1798 switch_root_init = m->switch_root_init;
1799 m->switch_root = m->switch_root_init = NULL;
1801 if (!switch_root_init)
1802 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1806 log_notice("Switching root.");
1809 case MANAGER_REBOOT:
1810 case MANAGER_POWEROFF:
1812 case MANAGER_KEXEC: {
1813 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1814 [MANAGER_REBOOT] = "reboot",
1815 [MANAGER_POWEROFF] = "poweroff",
1816 [MANAGER_HALT] = "halt",
1817 [MANAGER_KEXEC] = "kexec"
1820 assert_se(shutdown_verb = table[m->exit_code]);
1821 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1823 log_notice("Shutting down.");
1828 assert_not_reached("Unknown exit code.");
1836 for (j = 0; j < RLIMIT_NLIMITS; j++)
1837 free(arg_default_rlimit[j]);
1839 free(arg_default_unit);
1840 strv_free(arg_default_controllers);
1841 free_join_controllers();
1848 unsigned i, args_size;
1850 /* Close and disarm the watchdog, so that the new
1851 * instance can reinitialize it, but doesn't get
1852 * rebooted while we do that */
1853 watchdog_close(true);
1855 /* Reset the RLIMIT_NOFILE to the kernel default, so
1856 * that the new systemd can pass the kernel default to
1857 * its child processes */
1858 if (saved_rlimit_nofile.rlim_cur > 0)
1859 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1861 if (switch_root_dir) {
1862 /* Kill all remaining processes from the
1863 * initrd, but don't wait for them, so that we
1864 * can handle the SIGCHLD for them after
1866 broadcast_signal(SIGTERM, false);
1868 /* And switch root */
1869 r = switch_root(switch_root_dir);
1871 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1874 args_size = MAX(6, argc+1);
1875 args = newa(const char*, args_size);
1877 if (!switch_root_init) {
1880 /* First try to spawn ourselves with the right
1881 * path, and with full serialization. We do
1882 * this only if the user didn't specify an
1883 * explicit init to spawn. */
1885 assert(serialization);
1888 snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1892 args[i++] = SYSTEMD_BINARY_PATH;
1893 if (switch_root_dir)
1894 args[i++] = "--switched-root";
1895 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1896 args[i++] = "--deserialize";
1900 assert(i <= args_size);
1901 execv(args[0], (char* const*) args);
1904 /* Try the fallback, if there is any, without any
1905 * serialization. We pass the original argv[] and
1906 * envp[]. (Well, modulo the ordering changes due to
1907 * getopt() in argv[], and some cleanups in envp[],
1908 * but let's hope that doesn't matter.) */
1910 if (serialization) {
1911 fclose(serialization);
1912 serialization = NULL;
1920 /* Reopen the console */
1921 make_console_stdio();
1923 for (j = 1, i = 1; j < argc; j++)
1924 args[i++] = argv[j];
1926 assert(i <= args_size);
1928 if (switch_root_init) {
1929 args[0] = switch_root_init;
1930 execv(args[0], (char* const*) args);
1931 log_warning("Failed to execute configured init, trying fallback: %m");
1934 args[0] = "/sbin/init";
1935 execv(args[0], (char* const*) args);
1937 if (errno == ENOENT) {
1938 log_warning("No /sbin/init, trying fallback");
1940 args[0] = "/bin/sh";
1942 execv(args[0], (char* const*) args);
1943 log_error("Failed to execute /bin/sh, giving up: %m");
1945 log_warning("Failed to execute /sbin/init, giving up: %m");
1949 fclose(serialization);
1954 if (shutdown_verb) {
1955 const char * command_line[] = {
1956 SYSTEMD_SHUTDOWN_BINARY_PATH,
1962 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1965 /* If we reboot let's set the shutdown
1966 * watchdog and tell the shutdown binary to
1967 * repeatedly ping it */
1968 watchdog_set_timeout(&arg_shutdown_watchdog);
1969 watchdog_close(false);
1971 /* Tell the binary how often to ping */
1972 snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1975 env_block = strv_append(environ, e);
1977 env_block = strv_copy(environ);
1978 watchdog_close(true);
1981 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1983 log_error("Failed to execute shutdown binary, freezing: %m");