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>
42 #include "sd-daemon.h"
43 #include "sd-messages.h"
47 #include "load-fragment.h"
50 #include "conf-parser.h"
57 #include "architecture.h"
59 #include "path-util.h"
60 #include "switch-root.h"
61 #include "capability.h"
66 #include "dbus-manager.h"
67 #include "bus-error.h"
70 #include "mount-setup.h"
71 #include "loopback-setup.h"
72 #include "hostname-setup.h"
73 #include "machine-id-setup.h"
74 #include "selinux-setup.h"
75 #include "ima-setup.h"
76 #include "smack-setup.h"
78 #include "kmod-setup.h"
86 ACTION_DUMP_CONFIGURATION_ITEMS,
88 } arg_action = ACTION_RUN;
89 static char *arg_default_unit = NULL;
90 static SystemdRunningAs arg_running_as = _SYSTEMD_RUNNING_AS_INVALID;
91 static bool arg_dump_core = true;
92 static bool arg_crash_shell = false;
93 static int arg_crash_chvt = -1;
94 static bool arg_confirm_spawn = false;
95 static ShowStatus arg_show_status = _SHOW_STATUS_UNSET;
96 static bool arg_switched_root = false;
97 static char ***arg_join_controllers = NULL;
98 static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
99 static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
100 static usec_t arg_default_restart_usec = DEFAULT_RESTART_USEC;
101 static usec_t arg_default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
102 static usec_t arg_default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
103 static usec_t arg_default_start_limit_interval = DEFAULT_START_LIMIT_INTERVAL;
104 static unsigned arg_default_start_limit_burst = DEFAULT_START_LIMIT_BURST;
105 static usec_t arg_runtime_watchdog = 0;
106 static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
107 static char **arg_default_environment = NULL;
108 static struct rlimit *arg_default_rlimit[RLIMIT_NLIMITS] = {};
109 static uint64_t arg_capability_bounding_set_drop = 0;
110 static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
111 static Set* arg_syscall_archs = NULL;
112 static FILE* arg_serialization = NULL;
113 static bool arg_default_cpu_accounting = false;
114 static bool arg_default_blockio_accounting = false;
115 static bool arg_default_memory_accounting = false;
117 static void nop_handler(int sig) {}
119 noreturn static void crash(int sig) {
122 /* Pass this on immediately, if this is not PID 1 */
124 else if (!arg_dump_core)
125 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
127 struct sigaction sa = {
128 .sa_handler = nop_handler,
129 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
133 /* We want to wait for the core process, hence let's enable SIGCHLD */
134 sigaction(SIGCHLD, &sa, NULL);
138 log_error("Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
141 struct rlimit rl = {};
143 /* Enable default signal handler for core dump */
145 sa.sa_handler = SIG_DFL;
146 sigaction(sig, &sa, NULL);
148 /* Don't limit the core dump size */
149 rl.rlim_cur = RLIM_INFINITY;
150 rl.rlim_max = RLIM_INFINITY;
151 setrlimit(RLIMIT_CORE, &rl);
153 /* Just to be sure... */
156 /* Raise the signal again */
159 assert_not_reached("We shouldn't be here...");
166 /* Order things nicely. */
167 r = wait_for_terminate(pid, &status);
169 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
170 else if (status.si_code != CLD_DUMPED)
171 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
173 log_error("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
178 chvt(arg_crash_chvt);
180 if (arg_crash_shell) {
181 struct sigaction sa = {
182 .sa_handler = SIG_IGN,
183 .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
187 log_info("Executing crash shell in 10s...");
190 /* Let the kernel reap children for us */
191 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
195 log_error("Failed to fork off crash shell: %m");
197 make_console_stdio();
198 execl("/bin/sh", "/bin/sh", NULL);
200 log_error("execl() failed: %m");
204 log_info("Successfully spawned crash shell as pid "PID_FMT".", pid);
207 log_info("Freezing execution.");
211 static void install_crash_handler(void) {
212 struct sigaction sa = {
214 .sa_flags = SA_NODEFER,
217 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
220 static int console_setup(bool do_reset) {
223 /* If we are init, we connect stdin/stdout/stderr to /dev/null
224 * and make sure we don't have a controlling tty. */
231 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
233 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
237 /* We don't want to force text mode.
238 * plymouth may be showing pictures already from initrd. */
239 r = reset_terminal_fd(tty_fd, false);
241 log_error("Failed to reset /dev/console: %s", strerror(-r));
243 close_nointr_nofail(tty_fd);
247 static int set_default_unit(const char *u) {
256 free(arg_default_unit);
257 arg_default_unit = c;
262 static int parse_proc_cmdline_word(const char *word) {
264 static const char * const rlmap[] = {
265 "emergency", SPECIAL_EMERGENCY_TARGET,
266 "-b", SPECIAL_EMERGENCY_TARGET,
267 "single", SPECIAL_RESCUE_TARGET,
268 "-s", SPECIAL_RESCUE_TARGET,
269 "s", SPECIAL_RESCUE_TARGET,
270 "S", SPECIAL_RESCUE_TARGET,
271 "1", SPECIAL_RESCUE_TARGET,
272 "2", SPECIAL_RUNLEVEL2_TARGET,
273 "3", SPECIAL_RUNLEVEL3_TARGET,
274 "4", SPECIAL_RUNLEVEL4_TARGET,
275 "5", SPECIAL_RUNLEVEL5_TARGET,
280 if (startswith(word, "systemd.unit=")) {
283 return set_default_unit(word + 13);
285 } else if (startswith(word, "rd.systemd.unit=")) {
288 return set_default_unit(word + 16);
290 } else if (startswith(word, "systemd.log_target=")) {
292 if (log_set_target_from_string(word + 19) < 0)
293 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
295 } else if (startswith(word, "systemd.log_level=")) {
297 if (log_set_max_level_from_string(word + 18) < 0)
298 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
300 } else if (startswith(word, "systemd.log_color=")) {
302 if (log_show_color_from_string(word + 18) < 0)
303 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
305 } else if (startswith(word, "systemd.log_location=")) {
307 if (log_show_location_from_string(word + 21) < 0)
308 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
310 } else if (startswith(word, "systemd.dump_core=")) {
313 r = parse_boolean(word + 18);
315 log_warning("Failed to parse dump core switch %s. Ignoring.", word + 18);
319 } else if (startswith(word, "systemd.crash_shell=")) {
322 r = parse_boolean(word + 20);
324 log_warning("Failed to parse crash shell switch %s. Ignoring.", word + 20);
328 } else if (startswith(word, "systemd.confirm_spawn=")) {
331 r = parse_boolean(word + 22);
333 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", word + 22);
335 arg_confirm_spawn = r;
337 } else if (startswith(word, "systemd.crash_chvt=")) {
340 if (safe_atoi(word + 19, &k) < 0)
341 log_warning("Failed to parse crash chvt switch %s. Ignoring.", word + 19);
345 } else if (startswith(word, "systemd.show_status=")) {
348 r = parse_show_status(word + 20, &arg_show_status);
350 log_warning("Failed to parse show status switch %s. Ignoring.", word + 20);
351 } else if (startswith(word, "systemd.default_standard_output=")) {
354 r = exec_output_from_string(word + 32);
356 log_warning("Failed to parse default standard output switch %s. Ignoring.", word + 32);
358 arg_default_std_output = r;
359 } else if (startswith(word, "systemd.default_standard_error=")) {
362 r = exec_output_from_string(word + 31);
364 log_warning("Failed to parse default standard error switch %s. Ignoring.", word + 31);
366 arg_default_std_error = r;
367 } else if (startswith(word, "systemd.setenv=")) {
368 const char *cenv = word + 15;
370 if (env_assignment_is_valid(cenv)) {
373 env = strv_env_set(arg_default_environment, cenv);
375 arg_default_environment = env;
377 log_warning("Setting environment variable '%s' failed, ignoring: %s",
378 cenv, strerror(ENOMEM));
380 log_warning("Environment variable name '%s' is not valid. Ignoring.", cenv);
382 } else if (startswith(word, "systemd.") ||
383 (in_initrd() && startswith(word, "rd.systemd."))) {
387 /* Ignore systemd.journald.xyz and friends */
389 if (startswith(c, "rd."))
391 if (startswith(c, "systemd."))
393 if (c[strcspn(c, ".=")] != '.') {
395 log_warning("Unknown kernel switch %s. Ignoring.", word);
397 log_info("Supported kernel switches:\n"
398 "systemd.unit=UNIT Default unit to start\n"
399 "rd.systemd.unit=UNIT Default unit to start when run in initrd\n"
400 "systemd.dump_core=0|1 Dump core on crash\n"
401 "systemd.crash_shell=0|1 Run shell on crash\n"
402 "systemd.crash_chvt=N Change to VT #N on crash\n"
403 "systemd.confirm_spawn=0|1 Confirm every process spawn\n"
404 "systemd.show_status=0|1|auto Show status updates on the console during bootup\n"
405 "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\n"
407 "systemd.log_level=LEVEL Log level\n"
408 "systemd.log_color=0|1 Highlight important log messages\n"
409 "systemd.log_location=0|1 Include code location in log messages\n"
410 "systemd.default_standard_output=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
411 " Set default log output for services\n"
412 "systemd.default_standard_error=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
413 " Set default log error output for services\n"
414 "systemd.setenv=ASSIGNMENT Set an environment variable for all spawned processes\n");
417 } else if (streq(word, "quiet")) {
418 if (arg_show_status == _SHOW_STATUS_UNSET)
419 arg_show_status = SHOW_STATUS_AUTO;
420 } else if (streq(word, "debug")) {
421 /* Log to kmsg, the journal socket will fill up before the
422 * journal is started and tools running during that time
423 * will block with every log message for for 60 seconds,
424 * before they give up. */
425 log_set_max_level(LOG_DEBUG);
426 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_CONSOLE : LOG_TARGET_KMSG);
427 } else if (!in_initrd()) {
430 /* SysV compatibility */
431 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
432 if (streq(word, rlmap[i]))
433 return set_default_unit(rlmap[i+1]);
439 #define DEFINE_SETTER(name, func, descr) \
440 static int name(const char *unit, \
441 const char *filename, \
443 const char *section, \
444 unsigned section_line, \
445 const char *lvalue, \
447 const char *rvalue, \
459 log_syntax(unit, LOG_ERR, filename, line, -r, \
460 "Invalid " descr "'%s': %s", \
461 rvalue, strerror(-r)); \
466 DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
467 DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
468 DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
469 DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
471 static int config_parse_cpu_affinity2(const char *unit,
472 const char *filename,
475 unsigned section_line,
492 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
497 if (!(t = strndup(w, l)))
500 r = safe_atou(t, &cpu);
504 if (!(c = cpu_set_malloc(&ncpus)))
507 if (r < 0 || cpu >= ncpus) {
508 log_syntax(unit, LOG_ERR, filename, line, -r,
509 "Failed to parse CPU affinity '%s'", rvalue);
514 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
518 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
519 log_warning_unit(unit, "Failed to set CPU affinity: %m");
527 static void strv_free_free(char ***l) {
539 static void free_join_controllers(void) {
540 strv_free_free(arg_join_controllers);
541 arg_join_controllers = NULL;
544 static int config_parse_join_controllers(const char *unit,
545 const char *filename,
548 unsigned section_line,
563 free_join_controllers();
565 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
568 s = strndup(w, length);
572 l = strv_split(s, ",");
577 if (strv_length(l) <= 1) {
582 if (!arg_join_controllers) {
583 arg_join_controllers = new(char**, 2);
584 if (!arg_join_controllers) {
589 arg_join_controllers[0] = l;
590 arg_join_controllers[1] = NULL;
597 t = new0(char**, n+2);
605 for (a = arg_join_controllers; *a; a++) {
607 if (strv_overlap(*a, l)) {
608 if (strv_extend_strv(&l, *a) < 0) {
628 t[n++] = strv_uniq(l);
630 strv_free_free(arg_join_controllers);
631 arg_join_controllers = t;
638 static int parse_config_file(void) {
640 const ConfigTableItem items[] = {
641 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
642 { "Manager", "LogTarget", config_parse_target, 0, NULL },
643 { "Manager", "LogColor", config_parse_color, 0, NULL },
644 { "Manager", "LogLocation", config_parse_location, 0, NULL },
645 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
646 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
647 { "Manager", "ShowStatus", config_parse_show_status, 0, &arg_show_status },
648 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
649 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
650 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
651 { "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },
652 { "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_shutdown_watchdog },
653 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
655 { "Manager", "SystemCallArchitectures", config_parse_syscall_archs, 0, &arg_syscall_archs },
657 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
658 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
659 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
660 { "Manager", "DefaultTimeoutStartSec", config_parse_sec, 0, &arg_default_timeout_start_usec },
661 { "Manager", "DefaultTimeoutStopSec", config_parse_sec, 0, &arg_default_timeout_stop_usec },
662 { "Manager", "DefaultRestartSec", config_parse_sec, 0, &arg_default_restart_usec },
663 { "Manager", "DefaultStartLimitInterval", config_parse_sec, 0, &arg_default_start_limit_interval },
664 { "Manager", "DefaultStartLimitBurst", config_parse_unsigned, 0, &arg_default_start_limit_burst },
665 { "Manager", "DefaultEnvironment", config_parse_environ, 0, &arg_default_environment },
666 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU] },
667 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE] },
668 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA] },
669 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK] },
670 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE] },
671 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS] },
672 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE] },
673 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS] },
674 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC] },
675 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK] },
676 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS] },
677 { "Manager", "DefaultLimitSIGPENDING", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING] },
678 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE] },
679 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE] },
680 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO] },
681 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME] },
682 { "Manager", "DefaultCPUAccounting", config_parse_bool, 0, &arg_default_cpu_accounting },
683 { "Manager", "DefaultBlockIOAccounting", config_parse_bool, 0, &arg_default_blockio_accounting },
684 { "Manager", "DefaultMemoryAccounting", config_parse_bool, 0, &arg_default_memory_accounting },
688 _cleanup_fclose_ FILE *f;
692 fn = arg_running_as == SYSTEMD_SYSTEM ? PKGSYSCONFDIR "/system.conf" : PKGSYSCONFDIR "/user.conf";
698 log_warning("Failed to open configuration file '%s': %m", fn);
702 r = config_parse(NULL, fn, f, "Manager\0", config_item_table_lookup, (void*) items, false, false, NULL);
704 log_warning("Failed to parse configuration file: %s", strerror(-r));
709 static int parse_argv(int argc, char *argv[]) {
712 ARG_LOG_LEVEL = 0x100,
721 ARG_DUMP_CONFIGURATION_ITEMS,
728 ARG_DEFAULT_STD_OUTPUT,
729 ARG_DEFAULT_STD_ERROR
732 static const struct option options[] = {
733 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
734 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
735 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
736 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
737 { "unit", required_argument, NULL, ARG_UNIT },
738 { "system", no_argument, NULL, ARG_SYSTEM },
739 { "user", no_argument, NULL, ARG_USER },
740 { "test", no_argument, NULL, ARG_TEST },
741 { "help", no_argument, NULL, 'h' },
742 { "version", no_argument, NULL, ARG_VERSION },
743 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
744 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
745 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
746 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
747 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
748 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
749 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
750 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
751 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
763 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
768 r = log_set_max_level_from_string(optarg);
770 log_error("Failed to parse log level %s.", optarg);
777 r = log_set_target_from_string(optarg);
779 log_error("Failed to parse log target %s.", optarg);
788 r = log_show_color_from_string(optarg);
790 log_error("Failed to parse log color setting %s.", optarg);
794 log_show_color(true);
798 case ARG_LOG_LOCATION:
800 r = log_show_location_from_string(optarg);
802 log_error("Failed to parse log location setting %s.", optarg);
806 log_show_location(true);
810 case ARG_DEFAULT_STD_OUTPUT:
811 r = exec_output_from_string(optarg);
813 log_error("Failed to parse default standard output setting %s.", optarg);
816 arg_default_std_output = r;
819 case ARG_DEFAULT_STD_ERROR:
820 r = exec_output_from_string(optarg);
822 log_error("Failed to parse default standard error output setting %s.", optarg);
825 arg_default_std_error = r;
830 r = set_default_unit(optarg);
832 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
839 arg_running_as = SYSTEMD_SYSTEM;
843 arg_running_as = SYSTEMD_USER;
847 arg_action = ACTION_TEST;
851 arg_action = ACTION_VERSION;
854 case ARG_DUMP_CONFIGURATION_ITEMS:
855 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
859 r = optarg ? parse_boolean(optarg) : 1;
861 log_error("Failed to parse dump core boolean %s.", optarg);
867 case ARG_CRASH_SHELL:
868 r = optarg ? parse_boolean(optarg) : 1;
870 log_error("Failed to parse crash shell boolean %s.", optarg);
876 case ARG_CONFIRM_SPAWN:
877 r = optarg ? parse_boolean(optarg) : 1;
879 log_error("Failed to parse confirm spawn boolean %s.", optarg);
882 arg_confirm_spawn = r;
885 case ARG_SHOW_STATUS:
887 r = parse_show_status(optarg, &arg_show_status);
889 log_error("Failed to parse show status boolean %s.", optarg);
893 arg_show_status = SHOW_STATUS_YES;
896 case ARG_DESERIALIZE: {
900 r = safe_atoi(optarg, &fd);
901 if (r < 0 || fd < 0) {
902 log_error("Failed to parse deserialize option %s.", optarg);
903 return r < 0 ? r : -EINVAL;
906 fd_cloexec(fd, true);
910 log_error("Failed to open serialization fd: %m");
914 if (arg_serialization)
915 fclose(arg_serialization);
917 arg_serialization = f;
922 case ARG_SWITCHED_ROOT:
923 arg_switched_root = true;
927 arg_action = ACTION_HELP;
931 log_set_max_level(LOG_DEBUG);
937 /* Just to eat away the sysvinit kernel
938 * cmdline args without getopt() error
939 * messages that we'll parse in
940 * parse_proc_cmdline_word() or ignore. */
945 log_error("Unknown option code %c", c);
952 if (optind < argc && getpid() != 1) {
953 /* Hmm, when we aren't run as init system
954 * let's complain about excess arguments */
956 log_error("Excess arguments.");
960 if (detect_container(NULL) > 0) {
963 /* All /proc/cmdline arguments the kernel didn't
964 * understand it passed to us. We're not really
965 * interested in that usually since /proc/cmdline is
966 * more interesting and complete. With one exception:
967 * if we are run in a container /proc/cmdline is not
968 * relevant for the container, hence we rely on argv[]
971 for (a = argv; a < argv + argc; a++) {
972 r = parse_proc_cmdline_word(*a);
974 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
983 static int help(void) {
985 printf("%s [OPTIONS...]\n\n"
986 "Starts up and maintains the system or user services.\n\n"
987 " -h --help Show this help\n"
988 " --test Determine startup sequence, dump it and exit\n"
989 " --dump-configuration-items Dump understood unit configuration items\n"
990 " --unit=UNIT Set default unit\n"
991 " --system Run a system instance, even if PID != 1\n"
992 " --user Run a user instance\n"
993 " --dump-core[=0|1] Dump core on crash\n"
994 " --crash-shell[=0|1] Run shell on crash\n"
995 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
996 " --show-status[=0|1] Show status updates on the console during bootup\n"
997 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
998 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
999 " --log-color[=0|1] Highlight important log messages\n"
1000 " --log-location[=0|1] Include code location in log messages\n"
1001 " --default-standard-output= Set default standard output for services\n"
1002 " --default-standard-error= Set default standard error output for services\n",
1003 program_invocation_short_name);
1008 static int version(void) {
1009 puts(PACKAGE_STRING);
1010 puts(SYSTEMD_FEATURES);
1015 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
1024 r = manager_open_serialization(m, &f);
1026 log_error("Failed to create serialization file: %s", strerror(-r));
1030 /* Make sure nothing is really destructed when we shut down */
1032 bus_manager_send_reloading(m, true);
1037 log_error("Failed to allocate fd set: %s", strerror(-r));
1041 r = manager_serialize(m, f, fds, switching_root);
1043 log_error("Failed to serialize state: %s", strerror(-r));
1047 if (fseeko(f, 0, SEEK_SET) < 0) {
1048 log_error("Failed to rewind serialization fd: %m");
1052 r = fd_cloexec(fileno(f), false);
1054 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1058 r = fdset_cloexec(fds, false);
1060 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1078 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1082 assert(saved_rlimit);
1084 /* Save the original RLIMIT_NOFILE so that we can reset it
1085 * later when transitioning from the initrd to the main
1086 * systemd or suchlike. */
1087 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1088 log_error("Reading RLIMIT_NOFILE failed: %m");
1092 /* Make sure forked processes get the default kernel setting */
1093 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1096 rl = newdup(struct rlimit, saved_rlimit, 1);
1100 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1103 /* Bump up the resource limit for ourselves substantially */
1104 nl.rlim_cur = nl.rlim_max = 64*1024;
1105 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1107 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1114 static void test_mtab(void) {
1117 /* Check that /etc/mtab is a symlink */
1119 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1122 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1129 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1130 "This is not supported anymore. "
1131 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1134 static void test_usr(void) {
1136 /* Check that /usr is not a separate fs */
1138 if (dir_is_empty("/usr") <= 0)
1141 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1142 "Some things will probably break (sometimes even silently) in mysterious ways. "
1143 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1146 static void test_cgroups(void) {
1148 if (access("/proc/cgroups", F_OK) >= 0)
1151 log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1152 "Systems without control groups are not supported. "
1153 "We will now sleep for 10s, and then continue boot-up. "
1154 "Expect breakage and please do not file bugs. "
1155 "Instead fix your kernel and enable CONFIG_CGROUPS. "
1156 "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1161 static int initialize_join_controllers(void) {
1162 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1163 * + "net_prio". We'd like to add "cpuset" to the mix, but
1164 * "cpuset" does't really work for groups with no initialized
1167 arg_join_controllers = new(char**, 3);
1168 if (!arg_join_controllers)
1171 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1172 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1173 arg_join_controllers[2] = NULL;
1175 if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1176 free_join_controllers();
1183 static int enforce_syscall_archs(Set *archs) {
1185 scmp_filter_ctx *seccomp;
1190 seccomp = seccomp_init(SCMP_ACT_ALLOW);
1194 SET_FOREACH(id, arg_syscall_archs, i) {
1195 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1199 log_error("Failed to add architecture to seccomp: %s", strerror(-r));
1204 r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1206 log_error("Failed to unset NO_NEW_PRIVS: %s", strerror(-r));
1210 r = seccomp_load(seccomp);
1212 log_error("Failed to add install architecture seccomp: %s", strerror(-r));
1215 seccomp_release(seccomp);
1222 static int status_welcome(void) {
1223 _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1226 r = parse_env_file("/etc/os-release", NEWLINE,
1227 "PRETTY_NAME", &pretty_name,
1228 "ANSI_COLOR", &ansi_color,
1231 if (r < 0 && r != -ENOENT)
1232 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
1234 return status_printf(NULL, false, false,
1235 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1236 isempty(ansi_color) ? "1" : ansi_color,
1237 isempty(pretty_name) ? "Linux" : pretty_name);
1240 int main(int argc, char *argv[]) {
1242 int r, retval = EXIT_FAILURE;
1243 usec_t before_startup, after_startup;
1244 char timespan[FORMAT_TIMESPAN_MAX];
1246 bool reexecute = false;
1247 const char *shutdown_verb = NULL;
1248 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1249 dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1250 dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
1251 dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1252 dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
1253 static char systemd[] = "systemd";
1254 bool skip_setup = false;
1256 bool loaded_policy = false;
1257 bool arm_reboot_watchdog = false;
1258 bool queue_default_job = false;
1259 char *switch_root_dir = NULL, *switch_root_init = NULL;
1260 static struct rlimit saved_rlimit_nofile = { 0, 0 };
1262 #ifdef HAVE_SYSV_COMPAT
1263 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1264 /* This is compatibility support for SysV, where
1265 * calling init as a user is identical to telinit. */
1268 execv(SYSTEMCTL_BINARY_PATH, argv);
1269 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1274 dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1275 dual_timestamp_get(&userspace_timestamp);
1277 /* Determine if this is a reexecution or normal bootup. We do
1278 * the full command line parsing much later, so let's just
1279 * have a quick peek here. */
1280 if (strv_find(argv+1, "--deserialize"))
1283 /* If we have switched root, do all the special setup
1285 if (strv_find(argv+1, "--switched-root"))
1288 /* If we get started via the /sbin/init symlink then we are
1289 called 'init'. After a subsequent reexecution we are then
1290 called 'systemd'. That is confusing, hence let's call us
1291 systemd right-away. */
1292 program_invocation_short_name = systemd;
1293 prctl(PR_SET_NAME, systemd);
1298 log_show_color(isatty(STDERR_FILENO) > 0);
1300 /* Disable the umask logic */
1304 if (getpid() == 1 && detect_container(NULL) <= 0) {
1306 /* Running outside of a container as PID 1 */
1307 arg_running_as = SYSTEMD_SYSTEM;
1309 log_set_target(LOG_TARGET_KMSG);
1313 initrd_timestamp = userspace_timestamp;
1316 mount_setup_early();
1317 dual_timestamp_get(&security_start_timestamp);
1318 if (selinux_setup(&loaded_policy) < 0)
1320 if (ima_setup() < 0)
1322 if (smack_setup(&loaded_policy) < 0)
1324 dual_timestamp_get(&security_finish_timestamp);
1327 if (label_init(NULL) < 0)
1331 if (hwclock_is_localtime() > 0) {
1334 /* The first-time call to settimeofday() does a time warp in the kernel */
1335 r = hwclock_set_timezone(&min);
1337 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1339 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1340 } else if (!in_initrd()) {
1342 * Do dummy first-time call to seal the kernel's time warp magic
1344 * Do not call this this from inside the initrd. The initrd might not
1345 * carry /etc/adjtime with LOCAL, but the real system could be set up
1346 * that way. In such case, we need to delay the time-warp or the sealing
1347 * until we reach the real system.
1349 hwclock_reset_timezone();
1351 /* Tell the kernel our timezone */
1352 r = hwclock_set_timezone(NULL);
1354 log_error("Failed to set the kernel's timezone, ignoring: %s", strerror(-r));
1358 /* Set the default for later on, but don't actually
1359 * open the logs like this for now. Note that if we
1360 * are transitioning from the initrd there might still
1361 * be journal fd open, and we shouldn't attempt
1362 * opening that before we parsed /proc/cmdline which
1363 * might redirect output elsewhere. */
1364 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1366 } else if (getpid() == 1) {
1367 /* Running inside a container, as PID 1 */
1368 arg_running_as = SYSTEMD_SYSTEM;
1369 log_set_target(LOG_TARGET_CONSOLE);
1370 log_close_console(); /* force reopen of /dev/console */
1373 /* For the later on, see above... */
1374 log_set_target(LOG_TARGET_JOURNAL);
1376 /* clear the kernel timestamp,
1377 * because we are in a container */
1378 kernel_timestamp.monotonic = 0ULL;
1379 kernel_timestamp.realtime = 0ULL;
1382 /* Running as user instance */
1383 arg_running_as = SYSTEMD_USER;
1384 log_set_target(LOG_TARGET_AUTO);
1387 /* clear the kernel timestamp,
1388 * because we are not PID 1 */
1389 kernel_timestamp.monotonic = 0ULL;
1390 kernel_timestamp.realtime = 0ULL;
1393 /* Initialize default unit */
1394 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1396 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1400 r = initialize_join_controllers();
1404 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1405 * /proc/$PID/fd is available. */
1406 if (getpid() == 1) {
1407 r = mount_setup(loaded_policy);
1412 /* Reset all signal handlers. */
1413 assert_se(reset_all_signal_handlers() == 0);
1415 ignore_signals(SIGNALS_IGNORE, -1);
1417 if (parse_config_file() < 0)
1420 if (arg_running_as == SYSTEMD_SYSTEM)
1421 if (parse_proc_cmdline(parse_proc_cmdline_word) < 0)
1424 log_parse_environment();
1426 if (parse_argv(argc, argv) < 0)
1429 if (arg_action == ACTION_TEST &&
1431 log_error("Don't run test mode as root.");
1435 if (arg_running_as == SYSTEMD_USER &&
1436 arg_action == ACTION_RUN &&
1438 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1442 if (arg_running_as == SYSTEMD_SYSTEM &&
1443 arg_action == ACTION_RUN &&
1444 running_in_chroot() > 0) {
1445 log_error("Cannot be run in a chroot() environment.");
1449 if (arg_action == ACTION_HELP) {
1452 } else if (arg_action == ACTION_VERSION) {
1455 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1456 unit_dump_config_items(stdout);
1457 retval = EXIT_SUCCESS;
1459 } else if (arg_action == ACTION_DONE) {
1460 retval = EXIT_SUCCESS;
1464 if (arg_running_as == SYSTEMD_USER &&
1465 !getenv("XDG_RUNTIME_DIR")) {
1466 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1470 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1472 /* Close logging fds, in order not to confuse fdset below */
1475 /* Remember open file descriptors for later deserialization */
1476 r = fdset_new_fill(&fds);
1478 log_error("Failed to allocate fd set: %s", strerror(-r));
1481 fdset_cloexec(fds, true);
1483 if (arg_serialization)
1484 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1486 if (arg_running_as == SYSTEMD_SYSTEM)
1487 /* Become a session leader if we aren't one yet. */
1490 /* Move out of the way, so that we won't block unmounts */
1491 assert_se(chdir("/") == 0);
1493 /* Reset the console, but only if this is really init and we
1494 * are freshly booted */
1495 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1496 console_setup(getpid() == 1 && !skip_setup);
1498 /* Open the logging devices, if possible and necessary */
1501 if (arg_show_status == _SHOW_STATUS_UNSET)
1502 arg_show_status = SHOW_STATUS_YES;
1504 /* Make sure we leave a core dump without panicing the
1506 if (getpid() == 1) {
1507 install_crash_handler();
1509 r = mount_cgroup_controllers(arg_join_controllers);
1514 if (arg_running_as == SYSTEMD_SYSTEM) {
1515 const char *virtualization = NULL;
1517 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1519 detect_virtualization(&virtualization);
1521 log_info("Detected virtualization '%s'.", virtualization);
1523 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1526 log_info("Running in initial RAM disk.");
1529 _cleanup_free_ char *t = uid_to_name(getuid());
1530 log_debug(PACKAGE_STRING " running in user mode for user "PID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1534 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1535 if (arg_show_status > 0 || plymouth_running())
1539 if (detect_container(NULL) <= 0)
1551 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1552 watchdog_set_timeout(&arg_runtime_watchdog);
1554 if (arg_timer_slack_nsec != (nsec_t) -1)
1555 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1556 log_error("Failed to adjust timer slack: %m");
1558 if (arg_capability_bounding_set_drop) {
1559 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1561 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1564 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1566 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1571 if (arg_syscall_archs) {
1572 r = enforce_syscall_archs(arg_syscall_archs);
1577 if (arg_running_as == SYSTEMD_USER) {
1578 /* Become reaper of our children */
1579 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1580 log_warning("Failed to make us a subreaper: %m");
1581 if (errno == EINVAL)
1582 log_info("Perhaps the kernel version is too old (< 3.4?)");
1586 if (arg_running_as == SYSTEMD_SYSTEM)
1587 bump_rlimit_nofile(&saved_rlimit_nofile);
1589 r = manager_new(arg_running_as, &m);
1591 log_error("Failed to allocate manager object: %s", strerror(-r));
1595 m->confirm_spawn = arg_confirm_spawn;
1596 m->default_std_output = arg_default_std_output;
1597 m->default_std_error = arg_default_std_error;
1598 m->default_restart_usec = arg_default_restart_usec;
1599 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1600 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1601 m->default_start_limit_interval = arg_default_start_limit_interval;
1602 m->default_start_limit_burst = arg_default_start_limit_burst;
1603 m->default_cpu_accounting = arg_default_cpu_accounting;
1604 m->default_blockio_accounting = arg_default_blockio_accounting;
1605 m->default_memory_accounting = arg_default_memory_accounting;
1606 m->runtime_watchdog = arg_runtime_watchdog;
1607 m->shutdown_watchdog = arg_shutdown_watchdog;
1608 m->userspace_timestamp = userspace_timestamp;
1609 m->kernel_timestamp = kernel_timestamp;
1610 m->initrd_timestamp = initrd_timestamp;
1611 m->security_start_timestamp = security_start_timestamp;
1612 m->security_finish_timestamp = security_finish_timestamp;
1614 manager_set_default_rlimits(m, arg_default_rlimit);
1615 manager_environment_add(m, NULL, arg_default_environment);
1616 manager_set_show_status(m, arg_show_status);
1618 /* Remember whether we should queue the default job */
1619 queue_default_job = !arg_serialization || arg_switched_root;
1621 before_startup = now(CLOCK_MONOTONIC);
1623 r = manager_startup(m, arg_serialization, fds);
1625 log_error("Failed to fully start up daemon: %s", strerror(-r));
1627 /* This will close all file descriptors that were opened, but
1628 * not claimed by any unit. */
1632 if (arg_serialization) {
1633 fclose(arg_serialization);
1634 arg_serialization = NULL;
1637 if (queue_default_job) {
1638 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1639 Unit *target = NULL;
1640 Job *default_unit_job;
1642 log_debug("Activating default unit: %s", arg_default_unit);
1644 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1646 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1647 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1648 log_error("Failed to load default target: %s", strerror(-target->load_error));
1649 else if (target->load_state == UNIT_MASKED)
1650 log_error("Default target masked.");
1652 if (!target || target->load_state != UNIT_LOADED) {
1653 log_info("Trying to load rescue target...");
1655 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1657 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1659 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1660 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1662 } else if (target->load_state == UNIT_MASKED) {
1663 log_error("Rescue target masked.");
1668 assert(target->load_state == UNIT_LOADED);
1670 if (arg_action == ACTION_TEST) {
1671 printf("-> By units:\n");
1672 manager_dump_units(m, stdout, "\t");
1675 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1677 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1679 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1681 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1685 log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1689 m->default_unit_job_id = default_unit_job->id;
1691 after_startup = now(CLOCK_MONOTONIC);
1692 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1693 "Loaded units and determined initial transaction in %s.",
1694 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1696 if (arg_action == ACTION_TEST) {
1697 printf("-> By jobs:\n");
1698 manager_dump_jobs(m, stdout, "\t");
1699 retval = EXIT_SUCCESS;
1705 r = manager_loop(m);
1707 log_error("Failed to run mainloop: %s", strerror(-r));
1711 switch (m->exit_code) {
1714 retval = EXIT_SUCCESS;
1718 case MANAGER_RELOAD:
1719 log_info("Reloading.");
1720 r = manager_reload(m);
1722 log_error("Failed to reload: %s", strerror(-r));
1725 case MANAGER_REEXECUTE:
1727 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1731 log_notice("Reexecuting.");
1734 case MANAGER_SWITCH_ROOT:
1735 /* Steal the switch root parameters */
1736 switch_root_dir = m->switch_root;
1737 switch_root_init = m->switch_root_init;
1738 m->switch_root = m->switch_root_init = NULL;
1740 if (!switch_root_init)
1741 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1745 log_notice("Switching root.");
1748 case MANAGER_REBOOT:
1749 case MANAGER_POWEROFF:
1751 case MANAGER_KEXEC: {
1752 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1753 [MANAGER_REBOOT] = "reboot",
1754 [MANAGER_POWEROFF] = "poweroff",
1755 [MANAGER_HALT] = "halt",
1756 [MANAGER_KEXEC] = "kexec"
1759 assert_se(shutdown_verb = table[m->exit_code]);
1760 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1762 log_notice("Shutting down.");
1767 assert_not_reached("Unknown exit code.");
1777 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1778 free(arg_default_rlimit[j]);
1779 arg_default_rlimit[j] = NULL;
1782 free(arg_default_unit);
1783 arg_default_unit = NULL;
1785 free_join_controllers();
1787 strv_free(arg_default_environment);
1788 arg_default_environment = NULL;
1790 set_free(arg_syscall_archs);
1791 arg_syscall_archs = NULL;
1797 unsigned i, args_size;
1799 /* Close and disarm the watchdog, so that the new
1800 * instance can reinitialize it, but doesn't get
1801 * rebooted while we do that */
1802 watchdog_close(true);
1804 /* Reset the RLIMIT_NOFILE to the kernel default, so
1805 * that the new systemd can pass the kernel default to
1806 * its child processes */
1807 if (saved_rlimit_nofile.rlim_cur > 0)
1808 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1810 if (switch_root_dir) {
1811 /* Kill all remaining processes from the
1812 * initrd, but don't wait for them, so that we
1813 * can handle the SIGCHLD for them after
1815 broadcast_signal(SIGTERM, false, true);
1817 /* And switch root */
1818 r = switch_root(switch_root_dir);
1820 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1823 args_size = MAX(6, argc+1);
1824 args = newa(const char*, args_size);
1826 if (!switch_root_init) {
1829 /* First try to spawn ourselves with the right
1830 * path, and with full serialization. We do
1831 * this only if the user didn't specify an
1832 * explicit init to spawn. */
1834 assert(arg_serialization);
1837 snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1841 args[i++] = SYSTEMD_BINARY_PATH;
1842 if (switch_root_dir)
1843 args[i++] = "--switched-root";
1844 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1845 args[i++] = "--deserialize";
1849 /* do not pass along the environment we inherit from the kernel or initrd */
1850 if (switch_root_dir)
1853 assert(i <= args_size);
1854 execv(args[0], (char* const*) args);
1857 /* Try the fallback, if there is any, without any
1858 * serialization. We pass the original argv[] and
1859 * envp[]. (Well, modulo the ordering changes due to
1860 * getopt() in argv[], and some cleanups in envp[],
1861 * but let's hope that doesn't matter.) */
1863 if (arg_serialization) {
1864 fclose(arg_serialization);
1865 arg_serialization = NULL;
1873 /* Reopen the console */
1874 make_console_stdio();
1876 for (j = 1, i = 1; j < (unsigned) argc; j++)
1877 args[i++] = argv[j];
1879 assert(i <= args_size);
1881 if (switch_root_init) {
1882 args[0] = switch_root_init;
1883 execv(args[0], (char* const*) args);
1884 log_warning("Failed to execute configured init, trying fallback: %m");
1887 args[0] = "/sbin/init";
1888 execv(args[0], (char* const*) args);
1890 if (errno == ENOENT) {
1891 log_warning("No /sbin/init, trying fallback");
1893 args[0] = "/bin/sh";
1895 execv(args[0], (char* const*) args);
1896 log_error("Failed to execute /bin/sh, giving up: %m");
1898 log_warning("Failed to execute /sbin/init, giving up: %m");
1901 if (arg_serialization) {
1902 fclose(arg_serialization);
1903 arg_serialization = NULL;
1911 #ifdef HAVE_VALGRIND_VALGRIND_H
1912 /* If we are PID 1 and running under valgrind, then let's exit
1913 * here explicitly. valgrind will only generate nice output on
1914 * exit(), not on exec(), hence let's do the former not the
1916 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1920 if (shutdown_verb) {
1921 char log_level[DECIMAL_STR_MAX(int) + 1];
1922 const char* command_line[9] = {
1923 SYSTEMD_SHUTDOWN_BINARY_PATH,
1925 "--log-level", log_level,
1929 _cleanup_strv_free_ char **env_block = NULL;
1931 assert(command_line[pos] == NULL);
1932 env_block = strv_copy(environ);
1934 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1936 switch (log_get_target()) {
1937 case LOG_TARGET_KMSG:
1938 case LOG_TARGET_JOURNAL_OR_KMSG:
1939 case LOG_TARGET_SYSLOG_OR_KMSG:
1940 command_line[pos++] = "kmsg";
1943 case LOG_TARGET_CONSOLE:
1945 command_line[pos++] = "console";
1949 if (log_get_show_color())
1950 command_line[pos++] = "--log-color";
1952 if (log_get_show_location())
1953 command_line[pos++] = "--log-location";
1955 assert(pos + 1 < ELEMENTSOF(command_line));
1957 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1960 /* If we reboot let's set the shutdown
1961 * watchdog and tell the shutdown binary to
1962 * repeatedly ping it */
1963 watchdog_set_timeout(&arg_shutdown_watchdog);
1964 watchdog_close(false);
1966 /* Tell the binary how often to ping, ignore failure */
1967 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
1968 strv_push(&env_block, e);
1970 watchdog_close(true);
1972 /* Avoid the creation of new processes forked by the
1973 * kernel; at this point, we will not listen to the
1975 if (detect_container(NULL) <= 0)
1976 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
1978 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1979 log_error("Failed to execute shutdown binary, %s: %m",
1980 getpid() == 1 ? "freezing" : "quitting");