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/>.
26 #include <sys/types.h>
32 #include <sys/prctl.h>
33 #include <sys/mount.h>
35 #ifdef HAVE_VALGRIND_VALGRIND_H
36 #include <valgrind/valgrind.h>
39 #include "sd-daemon.h"
40 #include "sd-messages.h"
44 #include "load-fragment.h"
47 #include "conf-parser.h"
54 #include "architecture.h"
56 #include "path-util.h"
57 #include "switch-root.h"
58 #include "capability.h"
63 #include "dbus-manager.h"
64 #include "bus-error.h"
67 #include "mount-setup.h"
68 #include "loopback-setup.h"
69 #include "hostname-setup.h"
70 #include "machine-id-setup.h"
71 #include "selinux-setup.h"
72 #include "ima-setup.h"
73 #include "smack-setup.h"
75 #include "kmod-setup.h"
83 ACTION_DUMP_CONFIGURATION_ITEMS,
85 } arg_action = ACTION_RUN;
86 static char *arg_default_unit = NULL;
87 static SystemdRunningAs arg_running_as = _SYSTEMD_RUNNING_AS_INVALID;
88 static bool arg_dump_core = true;
89 static bool arg_crash_shell = false;
90 static int arg_crash_chvt = -1;
91 static bool arg_confirm_spawn = false;
92 static ShowStatus arg_show_status = _SHOW_STATUS_UNSET;
93 static bool arg_switched_root = false;
94 static char ***arg_join_controllers = NULL;
95 static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
96 static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
97 static usec_t arg_default_restart_usec = DEFAULT_RESTART_USEC;
98 static usec_t arg_default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
99 static usec_t arg_default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
100 static usec_t arg_default_start_limit_interval = DEFAULT_START_LIMIT_INTERVAL;
101 static unsigned arg_default_start_limit_burst = DEFAULT_START_LIMIT_BURST;
102 static usec_t arg_runtime_watchdog = 0;
103 static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
104 static char **arg_default_environment = NULL;
105 static struct rlimit *arg_default_rlimit[RLIMIT_NLIMITS] = {};
106 static uint64_t arg_capability_bounding_set_drop = 0;
107 static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
108 static Set* arg_syscall_archs = NULL;
109 static FILE* arg_serialization = NULL;
110 static bool arg_default_cpu_accounting = false;
111 static bool arg_default_blockio_accounting = false;
112 static bool arg_default_memory_accounting = false;
114 static void nop_handler(int sig) {}
116 noreturn static void crash(int sig) {
119 /* Pass this on immediately, if this is not PID 1 */
121 else if (!arg_dump_core)
122 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
124 struct sigaction sa = {
125 .sa_handler = nop_handler,
126 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
130 /* We want to wait for the core process, hence let's enable SIGCHLD */
131 sigaction(SIGCHLD, &sa, NULL);
135 log_error("Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
138 struct rlimit rl = {};
140 /* Enable default signal handler for core dump */
142 sa.sa_handler = SIG_DFL;
143 sigaction(sig, &sa, NULL);
145 /* Don't limit the core dump size */
146 rl.rlim_cur = RLIM_INFINITY;
147 rl.rlim_max = RLIM_INFINITY;
148 setrlimit(RLIMIT_CORE, &rl);
150 /* Just to be sure... */
153 /* Raise the signal again */
156 assert_not_reached("We shouldn't be here...");
163 /* Order things nicely. */
164 r = wait_for_terminate(pid, &status);
166 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
167 else if (status.si_code != CLD_DUMPED)
168 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
170 log_error("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
175 chvt(arg_crash_chvt);
177 if (arg_crash_shell) {
178 struct sigaction sa = {
179 .sa_handler = SIG_IGN,
180 .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
184 log_info("Executing crash shell in 10s...");
187 /* Let the kernel reap children for us */
188 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
192 log_error("Failed to fork off crash shell: %m");
194 make_console_stdio();
195 execl("/bin/sh", "/bin/sh", NULL);
197 log_error("execl() failed: %m");
201 log_info("Successfully spawned crash shell as pid "PID_FMT".", pid);
204 log_info("Freezing execution.");
208 static void install_crash_handler(void) {
209 struct sigaction sa = {
211 .sa_flags = SA_NODEFER,
214 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
217 static int console_setup(bool do_reset) {
220 /* If we are init, we connect stdin/stdout/stderr to /dev/null
221 * and make sure we don't have a controlling tty. */
228 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
230 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
234 /* We don't want to force text mode.
235 * plymouth may be showing pictures already from initrd. */
236 r = reset_terminal_fd(tty_fd, false);
238 log_error("Failed to reset /dev/console: %s", strerror(-r));
240 close_nointr_nofail(tty_fd);
244 static int set_default_unit(const char *u) {
253 free(arg_default_unit);
254 arg_default_unit = c;
259 static int parse_proc_cmdline_word(const char *word) {
261 static const char * const rlmap[] = {
262 "emergency", SPECIAL_EMERGENCY_TARGET,
263 "-b", SPECIAL_EMERGENCY_TARGET,
264 "single", SPECIAL_RESCUE_TARGET,
265 "-s", SPECIAL_RESCUE_TARGET,
266 "s", SPECIAL_RESCUE_TARGET,
267 "S", SPECIAL_RESCUE_TARGET,
268 "1", SPECIAL_RESCUE_TARGET,
269 "2", SPECIAL_RUNLEVEL2_TARGET,
270 "3", SPECIAL_RUNLEVEL3_TARGET,
271 "4", SPECIAL_RUNLEVEL4_TARGET,
272 "5", SPECIAL_RUNLEVEL5_TARGET,
277 if (startswith(word, "systemd.unit=")) {
280 return set_default_unit(word + 13);
282 } else if (startswith(word, "rd.systemd.unit=")) {
285 return set_default_unit(word + 16);
287 } else if (startswith(word, "systemd.log_target=")) {
289 if (log_set_target_from_string(word + 19) < 0)
290 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
292 } else if (startswith(word, "systemd.log_level=")) {
294 if (log_set_max_level_from_string(word + 18) < 0)
295 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
297 } else if (startswith(word, "systemd.log_color=")) {
299 if (log_show_color_from_string(word + 18) < 0)
300 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
302 } else if (startswith(word, "systemd.log_location=")) {
304 if (log_show_location_from_string(word + 21) < 0)
305 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
307 } else if (startswith(word, "systemd.dump_core=")) {
310 r = parse_boolean(word + 18);
312 log_warning("Failed to parse dump core switch %s. Ignoring.", word + 18);
316 } else if (startswith(word, "systemd.crash_shell=")) {
319 r = parse_boolean(word + 20);
321 log_warning("Failed to parse crash shell switch %s. Ignoring.", word + 20);
325 } else if (startswith(word, "systemd.confirm_spawn=")) {
328 r = parse_boolean(word + 22);
330 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", word + 22);
332 arg_confirm_spawn = r;
334 } else if (startswith(word, "systemd.crash_chvt=")) {
337 if (safe_atoi(word + 19, &k) < 0)
338 log_warning("Failed to parse crash chvt switch %s. Ignoring.", word + 19);
342 } else if (startswith(word, "systemd.show_status=")) {
345 r = parse_show_status(word + 20, &arg_show_status);
347 log_warning("Failed to parse show status switch %s. Ignoring.", word + 20);
348 } else if (startswith(word, "systemd.default_standard_output=")) {
351 r = exec_output_from_string(word + 32);
353 log_warning("Failed to parse default standard output switch %s. Ignoring.", word + 32);
355 arg_default_std_output = r;
356 } else if (startswith(word, "systemd.default_standard_error=")) {
359 r = exec_output_from_string(word + 31);
361 log_warning("Failed to parse default standard error switch %s. Ignoring.", word + 31);
363 arg_default_std_error = r;
364 } else if (startswith(word, "systemd.setenv=")) {
365 const char *cenv = word + 15;
367 if (env_assignment_is_valid(cenv)) {
370 env = strv_env_set(arg_default_environment, cenv);
372 arg_default_environment = env;
374 log_warning("Setting environment variable '%s' failed, ignoring: %s",
375 cenv, strerror(ENOMEM));
377 log_warning("Environment variable name '%s' is not valid. Ignoring.", cenv);
379 } else if (startswith(word, "systemd.") ||
380 (in_initrd() && startswith(word, "rd.systemd."))) {
384 /* Ignore systemd.journald.xyz and friends */
386 if (startswith(c, "rd."))
388 if (startswith(c, "systemd."))
390 if (c[strcspn(c, ".=")] != '.') {
392 log_warning("Unknown kernel switch %s. Ignoring.", word);
394 log_info("Supported kernel switches:\n"
395 "systemd.unit=UNIT Default unit to start\n"
396 "rd.systemd.unit=UNIT Default unit to start when run in initrd\n"
397 "systemd.dump_core=0|1 Dump core on crash\n"
398 "systemd.crash_shell=0|1 Run shell on crash\n"
399 "systemd.crash_chvt=N Change to VT #N on crash\n"
400 "systemd.confirm_spawn=0|1 Confirm every process spawn\n"
401 "systemd.show_status=0|1|auto Show status updates on the console during bootup\n"
402 "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\n"
404 "systemd.log_level=LEVEL Log level\n"
405 "systemd.log_color=0|1 Highlight important log messages\n"
406 "systemd.log_location=0|1 Include code location in log messages\n"
407 "systemd.default_standard_output=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
408 " Set default log output for services\n"
409 "systemd.default_standard_error=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
410 " Set default log error output for services\n"
411 "systemd.setenv=ASSIGNMENT Set an environment variable for all spawned processes\n");
414 } else if (streq(word, "quiet")) {
415 if (arg_show_status == _SHOW_STATUS_UNSET)
416 arg_show_status = SHOW_STATUS_AUTO;
417 } else if (streq(word, "debug")) {
418 /* Log to kmsg, the journal socket will fill up before the
419 * journal is started and tools running during that time
420 * will block with every log message for for 60 seconds,
421 * before they give up. */
422 log_set_max_level(LOG_DEBUG);
423 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_CONSOLE : LOG_TARGET_KMSG);
424 } else if (!in_initrd()) {
427 /* SysV compatibility */
428 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
429 if (streq(word, rlmap[i]))
430 return set_default_unit(rlmap[i+1]);
436 #define DEFINE_SETTER(name, func, descr) \
437 static int name(const char *unit, \
438 const char *filename, \
440 const char *section, \
441 unsigned section_line, \
442 const char *lvalue, \
444 const char *rvalue, \
456 log_syntax(unit, LOG_ERR, filename, line, -r, \
457 "Invalid " descr "'%s': %s", \
458 rvalue, strerror(-r)); \
463 DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
464 DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
465 DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
466 DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
468 static int config_parse_cpu_affinity2(const char *unit,
469 const char *filename,
472 unsigned section_line,
489 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
494 if (!(t = strndup(w, l)))
497 r = safe_atou(t, &cpu);
501 if (!(c = cpu_set_malloc(&ncpus)))
504 if (r < 0 || cpu >= ncpus) {
505 log_syntax(unit, LOG_ERR, filename, line, -r,
506 "Failed to parse CPU affinity '%s'", 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_unit(unit, "Failed to set CPU affinity: %m");
524 static void strv_free_free(char ***l) {
536 static void free_join_controllers(void) {
537 strv_free_free(arg_join_controllers);
538 arg_join_controllers = NULL;
541 static int config_parse_join_controllers(const char *unit,
542 const char *filename,
545 unsigned section_line,
560 free_join_controllers();
562 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
565 s = strndup(w, length);
569 l = strv_split(s, ",");
574 if (strv_length(l) <= 1) {
579 if (!arg_join_controllers) {
580 arg_join_controllers = new(char**, 2);
581 if (!arg_join_controllers) {
586 arg_join_controllers[0] = l;
587 arg_join_controllers[1] = NULL;
594 t = new0(char**, n+2);
602 for (a = arg_join_controllers; *a; a++) {
604 if (strv_overlap(*a, l)) {
605 if (strv_extend_strv(&l, *a) < 0) {
625 t[n++] = strv_uniq(l);
627 strv_free_free(arg_join_controllers);
628 arg_join_controllers = t;
635 static int parse_config_file(void) {
637 const ConfigTableItem items[] = {
638 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
639 { "Manager", "LogTarget", config_parse_target, 0, NULL },
640 { "Manager", "LogColor", config_parse_color, 0, NULL },
641 { "Manager", "LogLocation", config_parse_location, 0, NULL },
642 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
643 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
644 { "Manager", "ShowStatus", config_parse_show_status, 0, &arg_show_status },
645 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
646 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
647 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
648 { "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },
649 { "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_shutdown_watchdog },
650 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
652 { "Manager", "SystemCallArchitectures", config_parse_syscall_archs, 0, &arg_syscall_archs },
654 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
655 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
656 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
657 { "Manager", "DefaultTimeoutStartSec", config_parse_sec, 0, &arg_default_timeout_start_usec },
658 { "Manager", "DefaultTimeoutStopSec", config_parse_sec, 0, &arg_default_timeout_stop_usec },
659 { "Manager", "DefaultRestartSec", config_parse_sec, 0, &arg_default_restart_usec },
660 { "Manager", "DefaultStartLimitInterval", config_parse_sec, 0, &arg_default_start_limit_interval },
661 { "Manager", "DefaultStartLimitBurst", config_parse_unsigned, 0, &arg_default_start_limit_burst },
662 { "Manager", "DefaultEnvironment", config_parse_environ, 0, &arg_default_environment },
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 { "Manager", "DefaultCPUAccounting", config_parse_bool, 0, &arg_default_cpu_accounting },
680 { "Manager", "DefaultBlockIOAccounting", config_parse_bool, 0, &arg_default_blockio_accounting },
681 { "Manager", "DefaultMemoryAccounting", config_parse_bool, 0, &arg_default_memory_accounting },
685 _cleanup_fclose_ FILE *f;
689 fn = arg_running_as == SYSTEMD_SYSTEM ? PKGSYSCONFDIR "/system.conf" : PKGSYSCONFDIR "/user.conf";
695 log_warning("Failed to open configuration file '%s': %m", fn);
699 r = config_parse(NULL, fn, f, "Manager\0", config_item_table_lookup, (void*) items, false, false, NULL);
701 log_warning("Failed to parse configuration file: %s", strerror(-r));
706 static int parse_argv(int argc, char *argv[]) {
709 ARG_LOG_LEVEL = 0x100,
718 ARG_DUMP_CONFIGURATION_ITEMS,
725 ARG_DEFAULT_STD_OUTPUT,
726 ARG_DEFAULT_STD_ERROR
729 static const struct option options[] = {
730 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
731 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
732 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
733 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
734 { "unit", required_argument, NULL, ARG_UNIT },
735 { "system", no_argument, NULL, ARG_SYSTEM },
736 { "user", no_argument, NULL, ARG_USER },
737 { "test", no_argument, NULL, ARG_TEST },
738 { "help", no_argument, NULL, 'h' },
739 { "version", no_argument, NULL, ARG_VERSION },
740 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
741 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
742 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
743 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
744 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
745 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
746 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
747 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
748 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
760 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
765 r = log_set_max_level_from_string(optarg);
767 log_error("Failed to parse log level %s.", optarg);
774 r = log_set_target_from_string(optarg);
776 log_error("Failed to parse log target %s.", optarg);
785 r = log_show_color_from_string(optarg);
787 log_error("Failed to parse log color setting %s.", optarg);
791 log_show_color(true);
795 case ARG_LOG_LOCATION:
797 r = log_show_location_from_string(optarg);
799 log_error("Failed to parse log location setting %s.", optarg);
803 log_show_location(true);
807 case ARG_DEFAULT_STD_OUTPUT:
808 r = exec_output_from_string(optarg);
810 log_error("Failed to parse default standard output setting %s.", optarg);
813 arg_default_std_output = r;
816 case ARG_DEFAULT_STD_ERROR:
817 r = exec_output_from_string(optarg);
819 log_error("Failed to parse default standard error output setting %s.", optarg);
822 arg_default_std_error = r;
827 r = set_default_unit(optarg);
829 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
836 arg_running_as = SYSTEMD_SYSTEM;
840 arg_running_as = SYSTEMD_USER;
844 arg_action = ACTION_TEST;
848 arg_action = ACTION_VERSION;
851 case ARG_DUMP_CONFIGURATION_ITEMS:
852 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
856 r = optarg ? parse_boolean(optarg) : 1;
858 log_error("Failed to parse dump core boolean %s.", optarg);
864 case ARG_CRASH_SHELL:
865 r = optarg ? parse_boolean(optarg) : 1;
867 log_error("Failed to parse crash shell boolean %s.", optarg);
873 case ARG_CONFIRM_SPAWN:
874 r = optarg ? parse_boolean(optarg) : 1;
876 log_error("Failed to parse confirm spawn boolean %s.", optarg);
879 arg_confirm_spawn = r;
882 case ARG_SHOW_STATUS:
884 r = parse_show_status(optarg, &arg_show_status);
886 log_error("Failed to parse show status boolean %s.", optarg);
890 arg_show_status = SHOW_STATUS_YES;
893 case ARG_DESERIALIZE: {
897 r = safe_atoi(optarg, &fd);
898 if (r < 0 || fd < 0) {
899 log_error("Failed to parse deserialize option %s.", optarg);
900 return r < 0 ? r : -EINVAL;
903 fd_cloexec(fd, true);
907 log_error("Failed to open serialization fd: %m");
911 if (arg_serialization)
912 fclose(arg_serialization);
914 arg_serialization = f;
919 case ARG_SWITCHED_ROOT:
920 arg_switched_root = true;
924 arg_action = ACTION_HELP;
928 log_set_max_level(LOG_DEBUG);
934 /* Just to eat away the sysvinit kernel
935 * cmdline args without getopt() error
936 * messages that we'll parse in
937 * parse_proc_cmdline_word() or ignore. */
942 log_error("Unknown option code %c", c);
949 if (optind < argc && getpid() != 1) {
950 /* Hmm, when we aren't run as init system
951 * let's complain about excess arguments */
953 log_error("Excess arguments.");
957 if (detect_container(NULL) > 0) {
960 /* All /proc/cmdline arguments the kernel didn't
961 * understand it passed to us. We're not really
962 * interested in that usually since /proc/cmdline is
963 * more interesting and complete. With one exception:
964 * if we are run in a container /proc/cmdline is not
965 * relevant for the container, hence we rely on argv[]
968 for (a = argv; a < argv + argc; a++) {
969 r = parse_proc_cmdline_word(*a);
971 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
980 static int help(void) {
982 printf("%s [OPTIONS...]\n\n"
983 "Starts up and maintains the system or user services.\n\n"
984 " -h --help Show this help\n"
985 " --test Determine startup sequence, dump it and exit\n"
986 " --dump-configuration-items Dump understood unit configuration items\n"
987 " --unit=UNIT Set default unit\n"
988 " --system Run a system instance, even if PID != 1\n"
989 " --user Run a user instance\n"
990 " --dump-core[=0|1] Dump core on crash\n"
991 " --crash-shell[=0|1] Run shell on crash\n"
992 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
993 " --show-status[=0|1] Show status updates on the console during bootup\n"
994 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
995 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
996 " --log-color[=0|1] Highlight important log messages\n"
997 " --log-location[=0|1] Include code location in log messages\n"
998 " --default-standard-output= Set default standard output for services\n"
999 " --default-standard-error= Set default standard error output for services\n",
1000 program_invocation_short_name);
1005 static int version(void) {
1006 puts(PACKAGE_STRING);
1007 puts(SYSTEMD_FEATURES);
1012 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
1021 r = manager_open_serialization(m, &f);
1023 log_error("Failed to create serialization file: %s", strerror(-r));
1027 /* Make sure nothing is really destructed when we shut down */
1029 bus_manager_send_reloading(m, true);
1034 log_error("Failed to allocate fd set: %s", strerror(-r));
1038 r = manager_serialize(m, f, fds, switching_root);
1040 log_error("Failed to serialize state: %s", strerror(-r));
1044 if (fseeko(f, 0, SEEK_SET) < 0) {
1045 log_error("Failed to rewind serialization fd: %m");
1049 r = fd_cloexec(fileno(f), false);
1051 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1055 r = fdset_cloexec(fds, false);
1057 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1075 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1079 assert(saved_rlimit);
1081 /* Save the original RLIMIT_NOFILE so that we can reset it
1082 * later when transitioning from the initrd to the main
1083 * systemd or suchlike. */
1084 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1085 log_error("Reading RLIMIT_NOFILE failed: %m");
1089 /* Make sure forked processes get the default kernel setting */
1090 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1093 rl = newdup(struct rlimit, saved_rlimit, 1);
1097 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1100 /* Bump up the resource limit for ourselves substantially */
1101 nl.rlim_cur = nl.rlim_max = 64*1024;
1102 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1104 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1111 static void test_mtab(void) {
1114 /* Check that /etc/mtab is a symlink */
1116 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1119 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1126 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1127 "This is not supported anymore. "
1128 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1131 static void test_usr(void) {
1133 /* Check that /usr is not a separate fs */
1135 if (dir_is_empty("/usr") <= 0)
1138 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1139 "Some things will probably break (sometimes even silently) in mysterious ways. "
1140 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1143 static void test_cgroups(void) {
1145 if (access("/proc/cgroups", F_OK) >= 0)
1148 log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1149 "Systems without control groups are not supported. "
1150 "We will now sleep for 10s, and then continue boot-up. "
1151 "Expect breakage and please do not file bugs. "
1152 "Instead fix your kernel and enable CONFIG_CGROUPS. "
1153 "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1158 static int initialize_join_controllers(void) {
1159 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1160 * + "net_prio". We'd like to add "cpuset" to the mix, but
1161 * "cpuset" does't really work for groups with no initialized
1164 arg_join_controllers = new(char**, 3);
1165 if (!arg_join_controllers)
1168 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1169 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1170 arg_join_controllers[2] = NULL;
1172 if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1173 free_join_controllers();
1180 static int enforce_syscall_archs(Set *archs) {
1182 scmp_filter_ctx *seccomp;
1187 seccomp = seccomp_init(SCMP_ACT_ALLOW);
1191 SET_FOREACH(id, arg_syscall_archs, i) {
1192 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1196 log_error("Failed to add architecture to seccomp: %s", strerror(-r));
1201 r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1203 log_error("Failed to unset NO_NEW_PRIVS: %s", strerror(-r));
1207 r = seccomp_load(seccomp);
1209 log_error("Failed to add install architecture seccomp: %s", strerror(-r));
1212 seccomp_release(seccomp);
1219 static int status_welcome(void) {
1220 _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1223 r = parse_env_file("/etc/os-release", NEWLINE,
1224 "PRETTY_NAME", &pretty_name,
1225 "ANSI_COLOR", &ansi_color,
1228 if (r < 0 && r != -ENOENT)
1229 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
1231 return status_printf(NULL, false, false,
1232 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1233 isempty(ansi_color) ? "1" : ansi_color,
1234 isempty(pretty_name) ? "Linux" : pretty_name);
1237 int main(int argc, char *argv[]) {
1239 int r, retval = EXIT_FAILURE;
1240 usec_t before_startup, after_startup;
1241 char timespan[FORMAT_TIMESPAN_MAX];
1243 bool reexecute = false;
1244 const char *shutdown_verb = NULL;
1245 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1246 dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1247 dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
1248 dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1249 dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
1250 static char systemd[] = "systemd";
1251 bool skip_setup = false;
1253 bool loaded_policy = false;
1254 bool arm_reboot_watchdog = false;
1255 bool queue_default_job = false;
1256 char *switch_root_dir = NULL, *switch_root_init = NULL;
1257 static struct rlimit saved_rlimit_nofile = { 0, 0 };
1259 #ifdef HAVE_SYSV_COMPAT
1260 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1261 /* This is compatibility support for SysV, where
1262 * calling init as a user is identical to telinit. */
1265 execv(SYSTEMCTL_BINARY_PATH, argv);
1266 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1271 dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1272 dual_timestamp_get(&userspace_timestamp);
1274 /* Determine if this is a reexecution or normal bootup. We do
1275 * the full command line parsing much later, so let's just
1276 * have a quick peek here. */
1277 if (strv_find(argv+1, "--deserialize"))
1280 /* If we have switched root, do all the special setup
1282 if (strv_find(argv+1, "--switched-root"))
1285 /* If we get started via the /sbin/init symlink then we are
1286 called 'init'. After a subsequent reexecution we are then
1287 called 'systemd'. That is confusing, hence let's call us
1288 systemd right-away. */
1289 program_invocation_short_name = systemd;
1290 prctl(PR_SET_NAME, systemd);
1295 log_show_color(isatty(STDERR_FILENO) > 0);
1297 /* Disable the umask logic */
1301 if (getpid() == 1 && detect_container(NULL) <= 0) {
1303 /* Running outside of a container as PID 1 */
1304 arg_running_as = SYSTEMD_SYSTEM;
1306 log_set_target(LOG_TARGET_KMSG);
1310 initrd_timestamp = userspace_timestamp;
1313 mount_setup_early();
1314 dual_timestamp_get(&security_start_timestamp);
1315 if (selinux_setup(&loaded_policy) < 0)
1317 if (ima_setup() < 0)
1319 if (smack_setup(&loaded_policy) < 0)
1321 dual_timestamp_get(&security_finish_timestamp);
1324 if (label_init(NULL) < 0)
1328 if (hwclock_is_localtime() > 0) {
1331 /* The first-time call to settimeofday() does a time warp in the kernel */
1332 r = hwclock_set_timezone(&min);
1334 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1336 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1337 } else if (!in_initrd()) {
1339 * Do dummy first-time call to seal the kernel's time warp magic
1341 * Do not call this this from inside the initrd. The initrd might not
1342 * carry /etc/adjtime with LOCAL, but the real system could be set up
1343 * that way. In such case, we need to delay the time-warp or the sealing
1344 * until we reach the real system.
1346 hwclock_reset_timezone();
1348 /* Tell the kernel our timezone */
1349 r = hwclock_set_timezone(NULL);
1351 log_error("Failed to set the kernel's timezone, ignoring: %s", strerror(-r));
1355 /* Set the default for later on, but don't actually
1356 * open the logs like this for now. Note that if we
1357 * are transitioning from the initrd there might still
1358 * be journal fd open, and we shouldn't attempt
1359 * opening that before we parsed /proc/cmdline which
1360 * might redirect output elsewhere. */
1361 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1363 } else if (getpid() == 1) {
1364 /* Running inside a container, as PID 1 */
1365 arg_running_as = SYSTEMD_SYSTEM;
1366 log_set_target(LOG_TARGET_CONSOLE);
1367 log_close_console(); /* force reopen of /dev/console */
1370 /* For the later on, see above... */
1371 log_set_target(LOG_TARGET_JOURNAL);
1373 /* clear the kernel timestamp,
1374 * because we are in a container */
1375 kernel_timestamp.monotonic = 0ULL;
1376 kernel_timestamp.realtime = 0ULL;
1379 /* Running as user instance */
1380 arg_running_as = SYSTEMD_USER;
1381 log_set_target(LOG_TARGET_AUTO);
1384 /* clear the kernel timestamp,
1385 * because we are not PID 1 */
1386 kernel_timestamp.monotonic = 0ULL;
1387 kernel_timestamp.realtime = 0ULL;
1390 /* Initialize default unit */
1391 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1393 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1397 r = initialize_join_controllers();
1401 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1402 * /proc/$PID/fd is available. */
1403 if (getpid() == 1) {
1404 r = mount_setup(loaded_policy);
1409 /* Reset all signal handlers. */
1410 assert_se(reset_all_signal_handlers() == 0);
1412 ignore_signals(SIGNALS_IGNORE, -1);
1414 if (parse_config_file() < 0)
1417 if (arg_running_as == SYSTEMD_SYSTEM)
1418 if (parse_proc_cmdline(parse_proc_cmdline_word) < 0)
1421 log_parse_environment();
1423 if (parse_argv(argc, argv) < 0)
1426 if (arg_action == ACTION_TEST &&
1428 log_error("Don't run test mode as root.");
1432 if (arg_running_as == SYSTEMD_USER &&
1433 arg_action == ACTION_RUN &&
1435 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1439 if (arg_running_as == SYSTEMD_SYSTEM &&
1440 arg_action == ACTION_RUN &&
1441 running_in_chroot() > 0) {
1442 log_error("Cannot be run in a chroot() environment.");
1446 if (arg_action == ACTION_HELP) {
1449 } else if (arg_action == ACTION_VERSION) {
1452 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1453 unit_dump_config_items(stdout);
1454 retval = EXIT_SUCCESS;
1456 } else if (arg_action == ACTION_DONE) {
1457 retval = EXIT_SUCCESS;
1461 if (arg_running_as == SYSTEMD_USER &&
1462 !getenv("XDG_RUNTIME_DIR")) {
1463 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1467 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1469 /* Close logging fds, in order not to confuse fdset below */
1472 /* Remember open file descriptors for later deserialization */
1473 r = fdset_new_fill(&fds);
1475 log_error("Failed to allocate fd set: %s", strerror(-r));
1478 fdset_cloexec(fds, true);
1480 if (arg_serialization)
1481 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1483 if (arg_running_as == SYSTEMD_SYSTEM)
1484 /* Become a session leader if we aren't one yet. */
1487 /* Move out of the way, so that we won't block unmounts */
1488 assert_se(chdir("/") == 0);
1490 /* Reset the console, but only if this is really init and we
1491 * are freshly booted */
1492 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1493 console_setup(getpid() == 1 && !skip_setup);
1495 /* Open the logging devices, if possible and necessary */
1498 if (arg_show_status == _SHOW_STATUS_UNSET)
1499 arg_show_status = SHOW_STATUS_YES;
1501 /* Make sure we leave a core dump without panicing the
1503 if (getpid() == 1) {
1504 install_crash_handler();
1506 r = mount_cgroup_controllers(arg_join_controllers);
1511 if (arg_running_as == SYSTEMD_SYSTEM) {
1512 const char *virtualization = NULL;
1514 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1516 detect_virtualization(&virtualization);
1518 log_info("Detected virtualization '%s'.", virtualization);
1520 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1523 log_info("Running in initial RAM disk.");
1526 _cleanup_free_ char *t = uid_to_name(getuid());
1527 log_debug(PACKAGE_STRING " running in user mode for user "PID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1531 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1532 if (arg_show_status > 0 || plymouth_running())
1536 if (detect_container(NULL) <= 0)
1548 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1549 watchdog_set_timeout(&arg_runtime_watchdog);
1551 if (arg_timer_slack_nsec != (nsec_t) -1)
1552 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1553 log_error("Failed to adjust timer slack: %m");
1555 if (arg_capability_bounding_set_drop) {
1556 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1558 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1561 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1563 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1568 if (arg_syscall_archs) {
1569 r = enforce_syscall_archs(arg_syscall_archs);
1574 if (arg_running_as == SYSTEMD_USER) {
1575 /* Become reaper of our children */
1576 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1577 log_warning("Failed to make us a subreaper: %m");
1578 if (errno == EINVAL)
1579 log_info("Perhaps the kernel version is too old (< 3.4?)");
1583 if (arg_running_as == SYSTEMD_SYSTEM)
1584 bump_rlimit_nofile(&saved_rlimit_nofile);
1586 r = manager_new(arg_running_as, &m);
1588 log_error("Failed to allocate manager object: %s", strerror(-r));
1592 m->confirm_spawn = arg_confirm_spawn;
1593 m->default_std_output = arg_default_std_output;
1594 m->default_std_error = arg_default_std_error;
1595 m->default_restart_usec = arg_default_restart_usec;
1596 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1597 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1598 m->default_start_limit_interval = arg_default_start_limit_interval;
1599 m->default_start_limit_burst = arg_default_start_limit_burst;
1600 m->default_cpu_accounting = arg_default_cpu_accounting;
1601 m->default_blockio_accounting = arg_default_blockio_accounting;
1602 m->default_memory_accounting = arg_default_memory_accounting;
1603 m->runtime_watchdog = arg_runtime_watchdog;
1604 m->shutdown_watchdog = arg_shutdown_watchdog;
1605 m->userspace_timestamp = userspace_timestamp;
1606 m->kernel_timestamp = kernel_timestamp;
1607 m->initrd_timestamp = initrd_timestamp;
1608 m->security_start_timestamp = security_start_timestamp;
1609 m->security_finish_timestamp = security_finish_timestamp;
1611 manager_set_default_rlimits(m, arg_default_rlimit);
1612 manager_environment_add(m, NULL, arg_default_environment);
1613 manager_set_show_status(m, arg_show_status);
1615 /* Remember whether we should queue the default job */
1616 queue_default_job = !arg_serialization || arg_switched_root;
1618 before_startup = now(CLOCK_MONOTONIC);
1620 r = manager_startup(m, arg_serialization, fds);
1622 log_error("Failed to fully start up daemon: %s", strerror(-r));
1624 /* This will close all file descriptors that were opened, but
1625 * not claimed by any unit. */
1629 if (arg_serialization) {
1630 fclose(arg_serialization);
1631 arg_serialization = NULL;
1634 if (queue_default_job) {
1635 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1636 Unit *target = NULL;
1637 Job *default_unit_job;
1639 log_debug("Activating default unit: %s", arg_default_unit);
1641 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1643 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1644 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1645 log_error("Failed to load default target: %s", strerror(-target->load_error));
1646 else if (target->load_state == UNIT_MASKED)
1647 log_error("Default target masked.");
1649 if (!target || target->load_state != UNIT_LOADED) {
1650 log_info("Trying to load rescue target...");
1652 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1654 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1656 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1657 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1659 } else if (target->load_state == UNIT_MASKED) {
1660 log_error("Rescue target masked.");
1665 assert(target->load_state == UNIT_LOADED);
1667 if (arg_action == ACTION_TEST) {
1668 printf("-> By units:\n");
1669 manager_dump_units(m, stdout, "\t");
1672 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1674 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1676 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1678 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1682 log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1686 m->default_unit_job_id = default_unit_job->id;
1688 after_startup = now(CLOCK_MONOTONIC);
1689 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1690 "Loaded units and determined initial transaction in %s.",
1691 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1693 if (arg_action == ACTION_TEST) {
1694 printf("-> By jobs:\n");
1695 manager_dump_jobs(m, stdout, "\t");
1696 retval = EXIT_SUCCESS;
1702 r = manager_loop(m);
1704 log_error("Failed to run mainloop: %s", strerror(-r));
1708 switch (m->exit_code) {
1711 retval = EXIT_SUCCESS;
1715 case MANAGER_RELOAD:
1716 log_info("Reloading.");
1717 r = manager_reload(m);
1719 log_error("Failed to reload: %s", strerror(-r));
1722 case MANAGER_REEXECUTE:
1724 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1728 log_notice("Reexecuting.");
1731 case MANAGER_SWITCH_ROOT:
1732 /* Steal the switch root parameters */
1733 switch_root_dir = m->switch_root;
1734 switch_root_init = m->switch_root_init;
1735 m->switch_root = m->switch_root_init = NULL;
1737 if (!switch_root_init)
1738 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1742 log_notice("Switching root.");
1745 case MANAGER_REBOOT:
1746 case MANAGER_POWEROFF:
1748 case MANAGER_KEXEC: {
1749 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1750 [MANAGER_REBOOT] = "reboot",
1751 [MANAGER_POWEROFF] = "poweroff",
1752 [MANAGER_HALT] = "halt",
1753 [MANAGER_KEXEC] = "kexec"
1756 assert_se(shutdown_verb = table[m->exit_code]);
1757 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1759 log_notice("Shutting down.");
1764 assert_not_reached("Unknown exit code.");
1774 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1775 free(arg_default_rlimit[j]);
1776 arg_default_rlimit[j] = NULL;
1779 free(arg_default_unit);
1780 arg_default_unit = NULL;
1782 free_join_controllers();
1784 strv_free(arg_default_environment);
1785 arg_default_environment = NULL;
1787 set_free(arg_syscall_archs);
1788 arg_syscall_archs = NULL;
1794 unsigned i, args_size;
1796 /* Close and disarm the watchdog, so that the new
1797 * instance can reinitialize it, but doesn't get
1798 * rebooted while we do that */
1799 watchdog_close(true);
1801 /* Reset the RLIMIT_NOFILE to the kernel default, so
1802 * that the new systemd can pass the kernel default to
1803 * its child processes */
1804 if (saved_rlimit_nofile.rlim_cur > 0)
1805 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1807 if (switch_root_dir) {
1808 /* Kill all remaining processes from the
1809 * initrd, but don't wait for them, so that we
1810 * can handle the SIGCHLD for them after
1812 broadcast_signal(SIGTERM, false, true);
1814 /* And switch root */
1815 r = switch_root(switch_root_dir);
1817 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1820 args_size = MAX(6, argc+1);
1821 args = newa(const char*, args_size);
1823 if (!switch_root_init) {
1826 /* First try to spawn ourselves with the right
1827 * path, and with full serialization. We do
1828 * this only if the user didn't specify an
1829 * explicit init to spawn. */
1831 assert(arg_serialization);
1834 snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1838 args[i++] = SYSTEMD_BINARY_PATH;
1839 if (switch_root_dir)
1840 args[i++] = "--switched-root";
1841 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1842 args[i++] = "--deserialize";
1846 /* do not pass along the environment we inherit from the kernel or initrd */
1847 if (switch_root_dir)
1850 assert(i <= args_size);
1851 execv(args[0], (char* const*) args);
1854 /* Try the fallback, if there is any, without any
1855 * serialization. We pass the original argv[] and
1856 * envp[]. (Well, modulo the ordering changes due to
1857 * getopt() in argv[], and some cleanups in envp[],
1858 * but let's hope that doesn't matter.) */
1860 if (arg_serialization) {
1861 fclose(arg_serialization);
1862 arg_serialization = NULL;
1870 /* Reopen the console */
1871 make_console_stdio();
1873 for (j = 1, i = 1; j < (unsigned) argc; j++)
1874 args[i++] = argv[j];
1876 assert(i <= args_size);
1878 if (switch_root_init) {
1879 args[0] = switch_root_init;
1880 execv(args[0], (char* const*) args);
1881 log_warning("Failed to execute configured init, trying fallback: %m");
1884 args[0] = "/sbin/init";
1885 execv(args[0], (char* const*) args);
1887 if (errno == ENOENT) {
1888 log_warning("No /sbin/init, trying fallback");
1890 args[0] = "/bin/sh";
1892 execv(args[0], (char* const*) args);
1893 log_error("Failed to execute /bin/sh, giving up: %m");
1895 log_warning("Failed to execute /sbin/init, giving up: %m");
1898 if (arg_serialization) {
1899 fclose(arg_serialization);
1900 arg_serialization = NULL;
1908 #ifdef HAVE_VALGRIND_VALGRIND_H
1909 /* If we are PID 1 and running under valgrind, then let's exit
1910 * here explicitly. valgrind will only generate nice output on
1911 * exit(), not on exec(), hence let's do the former not the
1913 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1917 if (shutdown_verb) {
1918 char log_level[DECIMAL_STR_MAX(int) + 1];
1919 const char* command_line[9] = {
1920 SYSTEMD_SHUTDOWN_BINARY_PATH,
1922 "--log-level", log_level,
1926 _cleanup_strv_free_ char **env_block = NULL;
1928 assert(command_line[pos] == NULL);
1929 env_block = strv_copy(environ);
1931 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1933 switch (log_get_target()) {
1934 case LOG_TARGET_KMSG:
1935 case LOG_TARGET_JOURNAL_OR_KMSG:
1936 case LOG_TARGET_SYSLOG_OR_KMSG:
1937 command_line[pos++] = "kmsg";
1940 case LOG_TARGET_CONSOLE:
1942 command_line[pos++] = "console";
1946 if (log_get_show_color())
1947 command_line[pos++] = "--log-color";
1949 if (log_get_show_location())
1950 command_line[pos++] = "--log-location";
1952 assert(pos + 1 < ELEMENTSOF(command_line));
1954 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1957 /* If we reboot let's set the shutdown
1958 * watchdog and tell the shutdown binary to
1959 * repeatedly ping it */
1960 watchdog_set_timeout(&arg_shutdown_watchdog);
1961 watchdog_close(false);
1963 /* Tell the binary how often to ping, ignore failure */
1964 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
1965 strv_push(&env_block, e);
1967 watchdog_close(true);
1969 /* Avoid the creation of new processes forked by the
1970 * kernel; at this point, we will not listen to the
1972 if (detect_container(NULL) <= 0)
1973 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
1975 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1976 log_error("Failed to execute shutdown binary, %s: %m",
1977 getpid() == 1 ? "freezing" : "quitting");