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"
64 #include "clock-util.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_MAX] = {};
109 static uint64_t arg_capability_bounding_set_drop = 0;
110 static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
111 static usec_t arg_default_timer_accuracy_usec = 1 * USEC_PER_MINUTE;
112 static Set* arg_syscall_archs = NULL;
113 static FILE* arg_serialization = NULL;
114 static bool arg_default_cpu_accounting = false;
115 static bool arg_default_blockio_accounting = false;
116 static bool arg_default_memory_accounting = false;
118 static void nop_handler(int sig) {}
120 noreturn static void crash(int sig) {
123 /* Pass this on immediately, if this is not PID 1 */
125 else if (!arg_dump_core)
126 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
128 struct sigaction sa = {
129 .sa_handler = nop_handler,
130 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
134 /* We want to wait for the core process, hence let's enable SIGCHLD */
135 sigaction(SIGCHLD, &sa, NULL);
139 log_error("Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
142 struct rlimit rl = {};
144 /* Enable default signal handler for core dump */
146 sa.sa_handler = SIG_DFL;
147 sigaction(sig, &sa, NULL);
149 /* Don't limit the core dump size */
150 rl.rlim_cur = RLIM_INFINITY;
151 rl.rlim_max = RLIM_INFINITY;
152 setrlimit(RLIMIT_CORE, &rl);
154 /* Just to be sure... */
157 /* Raise the signal again */
160 assert_not_reached("We shouldn't be here...");
167 /* Order things nicely. */
168 r = wait_for_terminate(pid, &status);
170 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
171 else if (status.si_code != CLD_DUMPED)
172 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
174 log_error("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
179 chvt(arg_crash_chvt);
181 if (arg_crash_shell) {
182 struct sigaction sa = {
183 .sa_handler = SIG_IGN,
184 .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
188 log_info("Executing crash shell in 10s...");
191 /* Let the kernel reap children for us */
192 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
196 log_error("Failed to fork off crash shell: %m");
198 make_console_stdio();
199 execl("/bin/sh", "/bin/sh", NULL);
201 log_error("execl() failed: %m");
205 log_info("Successfully spawned crash shell as pid "PID_FMT".", pid);
208 log_info("Freezing execution.");
212 static void install_crash_handler(void) {
213 struct sigaction sa = {
215 .sa_flags = SA_NODEFER,
218 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
221 static int console_setup(bool do_reset) {
224 /* If we are init, we connect stdin/stdout/stderr to /dev/null
225 * and make sure we don't have a controlling tty. */
232 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
234 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
238 /* We don't want to force text mode.
239 * plymouth may be showing pictures already from initrd. */
240 r = reset_terminal_fd(tty_fd, false);
242 log_error("Failed to reset /dev/console: %s", strerror(-r));
248 static int set_default_unit(const char *u) {
257 free(arg_default_unit);
258 arg_default_unit = c;
263 static int parse_proc_cmdline_item(const char *key, const char *value) {
265 static const char * const rlmap[] = {
266 "emergency", SPECIAL_EMERGENCY_TARGET,
267 "-b", SPECIAL_EMERGENCY_TARGET,
268 "single", SPECIAL_RESCUE_TARGET,
269 "-s", SPECIAL_RESCUE_TARGET,
270 "s", SPECIAL_RESCUE_TARGET,
271 "S", SPECIAL_RESCUE_TARGET,
272 "1", SPECIAL_RESCUE_TARGET,
273 "2", SPECIAL_RUNLEVEL2_TARGET,
274 "3", SPECIAL_RUNLEVEL3_TARGET,
275 "4", SPECIAL_RUNLEVEL4_TARGET,
276 "5", SPECIAL_RUNLEVEL5_TARGET,
282 if (streq(key, "systemd.unit") && value) {
285 return set_default_unit(value);
287 } else if (streq(key, "rd.systemd.unit") && value) {
290 return set_default_unit(value);
292 } else if (streq(key, "systemd.log_target") && value) {
294 if (log_set_target_from_string(value) < 0)
295 log_warning("Failed to parse log target %s. Ignoring.", value);
297 } else if (streq(key, "systemd.log_level") && value) {
299 if (log_set_max_level_from_string(value) < 0)
300 log_warning("Failed to parse log level %s. Ignoring.", value);
302 } else if (streq(key, "systemd.log_color") && value) {
304 if (log_show_color_from_string(value) < 0)
305 log_warning("Failed to parse log color setting %s. Ignoring.", value);
307 } else if (streq(key, "systemd.log_location") && value) {
309 if (log_show_location_from_string(value) < 0)
310 log_warning("Failed to parse log location setting %s. Ignoring.", value);
312 } else if (streq(key, "systemd.dump_core") && value) {
314 r = parse_boolean(value);
316 log_warning("Failed to parse dump core switch %s. Ignoring.", value);
320 } else if (streq(key, "systemd.crash_shell") && value) {
322 r = parse_boolean(value);
324 log_warning("Failed to parse crash shell switch %s. Ignoring.", value);
328 } else if (streq(key, "systemd.crash_chvt") && value) {
330 if (safe_atoi(value, &r) < 0)
331 log_warning("Failed to parse crash chvt switch %s. Ignoring.", value);
335 } else if (streq(key, "systemd.confirm_spawn") && value) {
337 r = parse_boolean(value);
339 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", value);
341 arg_confirm_spawn = r;
343 } else if (streq(key, "systemd.show_status") && value) {
345 r = parse_show_status(value, &arg_show_status);
347 log_warning("Failed to parse show status switch %s. Ignoring.", value);
349 } else if (streq(key, "systemd.default_standard_output") && value) {
351 r = exec_output_from_string(value);
353 log_warning("Failed to parse default standard output switch %s. Ignoring.", value);
355 arg_default_std_output = r;
357 } else if (streq(key, "systemd.default_standard_error") && value) {
359 r = exec_output_from_string(value);
361 log_warning("Failed to parse default standard error switch %s. Ignoring.", value);
363 arg_default_std_error = r;
365 } else if (streq(key, "systemd.setenv") && value) {
367 if (env_assignment_is_valid(value)) {
370 env = strv_env_set(arg_default_environment, value);
372 arg_default_environment = env;
374 log_warning("Setting environment variable '%s' failed, ignoring: %s", value, strerror(ENOMEM));
376 log_warning("Environment variable name '%s' is not valid. Ignoring.", value);
378 } else if (streq(key, "quiet") && !value) {
380 log_set_max_level(LOG_NOTICE);
382 if (arg_show_status == _SHOW_STATUS_UNSET)
383 arg_show_status = SHOW_STATUS_AUTO;
385 } else if (streq(key, "debug") && !value) {
387 log_set_max_level(LOG_DEBUG);
389 if (detect_container(NULL) > 0)
390 log_set_target(LOG_TARGET_CONSOLE);
392 } else if (!in_initrd() && !value) {
395 /* SysV compatibility */
396 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
397 if (streq(key, rlmap[i]))
398 return set_default_unit(rlmap[i+1]);
404 #define DEFINE_SETTER(name, func, descr) \
405 static int name(const char *unit, \
406 const char *filename, \
408 const char *section, \
409 unsigned section_line, \
410 const char *lvalue, \
412 const char *rvalue, \
424 log_syntax(unit, LOG_ERR, filename, line, -r, \
425 "Invalid " descr "'%s': %s", \
426 rvalue, strerror(-r)); \
431 DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
432 DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
433 DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
434 DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
436 static int config_parse_cpu_affinity2(
438 const char *filename,
441 unsigned section_line,
458 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
463 if (!(t = strndup(w, l)))
466 r = safe_atou(t, &cpu);
470 if (!(c = cpu_set_malloc(&ncpus)))
473 if (r < 0 || cpu >= ncpus) {
474 log_syntax(unit, LOG_ERR, filename, line, -r,
475 "Failed to parse CPU affinity '%s'", rvalue);
480 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
484 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
485 log_warning_unit(unit, "Failed to set CPU affinity: %m");
493 static int config_parse_show_status(
495 const char *filename,
498 unsigned section_line,
506 ShowStatus *b = data;
513 k = parse_show_status(rvalue, b);
515 log_syntax(unit, LOG_ERR, filename, line, -k,
516 "Failed to parse show status setting, ignoring: %s", rvalue);
523 static void strv_free_free(char ***l) {
535 static void free_join_controllers(void) {
536 strv_free_free(arg_join_controllers);
537 arg_join_controllers = NULL;
540 static int config_parse_join_controllers(const char *unit,
541 const char *filename,
544 unsigned section_line,
559 free_join_controllers();
561 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
564 s = strndup(w, length);
568 l = strv_split(s, ",");
573 if (strv_length(l) <= 1) {
578 if (!arg_join_controllers) {
579 arg_join_controllers = new(char**, 2);
580 if (!arg_join_controllers) {
585 arg_join_controllers[0] = l;
586 arg_join_controllers[1] = NULL;
593 t = new0(char**, n+2);
601 for (a = arg_join_controllers; *a; a++) {
603 if (strv_overlap(*a, l)) {
604 if (strv_extend_strv(&l, *a) < 0) {
624 t[n++] = strv_uniq(l);
626 strv_free_free(arg_join_controllers);
627 arg_join_controllers = t;
634 static int parse_config_file(void) {
636 const ConfigTableItem items[] = {
637 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
638 { "Manager", "LogTarget", config_parse_target, 0, NULL },
639 { "Manager", "LogColor", config_parse_color, 0, NULL },
640 { "Manager", "LogLocation", config_parse_location, 0, NULL },
641 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
642 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
643 { "Manager", "ShowStatus", config_parse_show_status, 0, &arg_show_status },
644 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
645 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
646 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
647 { "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },
648 { "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_shutdown_watchdog },
649 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
651 { "Manager", "SystemCallArchitectures", config_parse_syscall_archs, 0, &arg_syscall_archs },
653 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
654 { "Manager", "DefaultTimerAccuracySec", config_parse_sec, 0, &arg_default_timer_accuracy_usec },
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 _cleanup_free_ char *w;
976 value = strchr(w, '=');
980 r = parse_proc_cmdline_item(w, value);
982 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
991 static int help(void) {
993 printf("%s [OPTIONS...]\n\n"
994 "Starts up and maintains the system or user services.\n\n"
995 " -h --help Show this help\n"
996 " --test Determine startup sequence, dump it and exit\n"
997 " --dump-configuration-items Dump understood unit configuration items\n"
998 " --unit=UNIT Set default unit\n"
999 " --system Run a system instance, even if PID != 1\n"
1000 " --user Run a user instance\n"
1001 " --dump-core[=0|1] Dump core on crash\n"
1002 " --crash-shell[=0|1] Run shell on crash\n"
1003 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
1004 " --show-status[=0|1] Show status updates on the console during bootup\n"
1005 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1006 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1007 " --log-color[=0|1] Highlight important log messages\n"
1008 " --log-location[=0|1] Include code location in log messages\n"
1009 " --default-standard-output= Set default standard output for services\n"
1010 " --default-standard-error= Set default standard error output for services\n",
1011 program_invocation_short_name);
1016 static int version(void) {
1017 puts(PACKAGE_STRING);
1018 puts(SYSTEMD_FEATURES);
1023 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
1032 r = manager_open_serialization(m, &f);
1034 log_error("Failed to create serialization file: %s", strerror(-r));
1038 /* Make sure nothing is really destructed when we shut down */
1040 bus_manager_send_reloading(m, true);
1045 log_error("Failed to allocate fd set: %s", strerror(-r));
1049 r = manager_serialize(m, f, fds, switching_root);
1051 log_error("Failed to serialize state: %s", strerror(-r));
1055 if (fseeko(f, 0, SEEK_SET) < 0) {
1056 log_error("Failed to rewind serialization fd: %m");
1060 r = fd_cloexec(fileno(f), false);
1062 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1066 r = fdset_cloexec(fds, false);
1068 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1086 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1090 assert(saved_rlimit);
1092 /* Save the original RLIMIT_NOFILE so that we can reset it
1093 * later when transitioning from the initrd to the main
1094 * systemd or suchlike. */
1095 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1096 log_error("Reading RLIMIT_NOFILE failed: %m");
1100 /* Make sure forked processes get the default kernel setting */
1101 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1104 rl = newdup(struct rlimit, saved_rlimit, 1);
1108 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1111 /* Bump up the resource limit for ourselves substantially */
1112 nl.rlim_cur = nl.rlim_max = 64*1024;
1113 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1115 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1122 static void test_mtab(void) {
1124 static const char ok[] =
1125 "/proc/self/mounts\0"
1127 "../proc/self/mounts\0"
1130 _cleanup_free_ char *p = NULL;
1133 /* Check that /etc/mtab is a symlink to the right place or
1134 * non-existing. But certainly not a file, or a symlink to
1135 * some weird place... */
1137 r = readlink_malloc("/etc/mtab", &p);
1140 if (r >= 0 && nulstr_contains(ok, p))
1143 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1144 "This is not supported anymore. "
1145 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1148 static void test_usr(void) {
1150 /* Check that /usr is not a separate fs */
1152 if (dir_is_empty("/usr") <= 0)
1155 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1156 "Some things will probably break (sometimes even silently) in mysterious ways. "
1157 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1160 static int initialize_join_controllers(void) {
1161 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1162 * + "net_prio". We'd like to add "cpuset" to the mix, but
1163 * "cpuset" does't really work for groups with no initialized
1166 arg_join_controllers = new(char**, 3);
1167 if (!arg_join_controllers)
1170 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1171 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1172 arg_join_controllers[2] = NULL;
1174 if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1175 free_join_controllers();
1182 static int enforce_syscall_archs(Set *archs) {
1184 scmp_filter_ctx *seccomp;
1189 seccomp = seccomp_init(SCMP_ACT_ALLOW);
1193 SET_FOREACH(id, arg_syscall_archs, i) {
1194 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1198 log_error("Failed to add architecture to seccomp: %s", strerror(-r));
1203 r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1205 log_error("Failed to unset NO_NEW_PRIVS: %s", strerror(-r));
1209 r = seccomp_load(seccomp);
1211 log_error("Failed to add install architecture seccomp: %s", strerror(-r));
1214 seccomp_release(seccomp);
1221 static int status_welcome(void) {
1222 _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1225 r = parse_env_file("/etc/os-release", NEWLINE,
1226 "PRETTY_NAME", &pretty_name,
1227 "ANSI_COLOR", &ansi_color,
1230 r = parse_env_file("/usr/lib/os-release", NEWLINE,
1231 "PRETTY_NAME", &pretty_name,
1232 "ANSI_COLOR", &ansi_color,
1236 if (r < 0 && r != -ENOENT)
1237 log_warning("Failed to read os-release file: %s", strerror(-r));
1239 return status_printf(NULL, false, false,
1240 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1241 isempty(ansi_color) ? "1" : ansi_color,
1242 isempty(pretty_name) ? "Linux" : pretty_name);
1245 static int write_container_id(void) {
1248 c = getenv("container");
1252 return write_string_file("/run/systemd/container", c);
1255 int main(int argc, char *argv[]) {
1257 int r, retval = EXIT_FAILURE;
1258 usec_t before_startup, after_startup;
1259 char timespan[FORMAT_TIMESPAN_MAX];
1261 bool reexecute = false;
1262 const char *shutdown_verb = NULL;
1263 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1264 dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1265 dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
1266 dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1267 dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
1268 static char systemd[] = "systemd";
1269 bool skip_setup = false;
1271 bool loaded_policy = false;
1272 bool arm_reboot_watchdog = false;
1273 bool queue_default_job = false;
1274 bool empty_etc = false;
1275 char *switch_root_dir = NULL, *switch_root_init = NULL;
1276 static struct rlimit saved_rlimit_nofile = { 0, 0 };
1278 #ifdef HAVE_SYSV_COMPAT
1279 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1280 /* This is compatibility support for SysV, where
1281 * calling init as a user is identical to telinit. */
1284 execv(SYSTEMCTL_BINARY_PATH, argv);
1285 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1290 dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1291 dual_timestamp_get(&userspace_timestamp);
1293 /* Determine if this is a reexecution or normal bootup. We do
1294 * the full command line parsing much later, so let's just
1295 * have a quick peek here. */
1296 if (strv_find(argv+1, "--deserialize"))
1299 /* If we have switched root, do all the special setup
1301 if (strv_find(argv+1, "--switched-root"))
1304 /* If we get started via the /sbin/init symlink then we are
1305 called 'init'. After a subsequent reexecution we are then
1306 called 'systemd'. That is confusing, hence let's call us
1307 systemd right-away. */
1308 program_invocation_short_name = systemd;
1309 prctl(PR_SET_NAME, systemd);
1314 log_show_color(isatty(STDERR_FILENO) > 0);
1316 /* Disable the umask logic */
1320 if (getpid() == 1 && detect_container(NULL) <= 0) {
1322 /* Running outside of a container as PID 1 */
1323 arg_running_as = SYSTEMD_SYSTEM;
1325 log_set_target(LOG_TARGET_KMSG);
1329 initrd_timestamp = userspace_timestamp;
1332 mount_setup_early();
1333 dual_timestamp_get(&security_start_timestamp);
1334 if (selinux_setup(&loaded_policy) < 0)
1336 if (ima_setup() < 0)
1338 if (smack_setup(&loaded_policy) < 0)
1340 dual_timestamp_get(&security_finish_timestamp);
1343 if (label_init(NULL) < 0)
1347 if (clock_is_localtime() > 0) {
1350 /* The first-time call to settimeofday() does a time warp in the kernel */
1351 r = clock_set_timezone(&min);
1353 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1355 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1356 } else if (!in_initrd()) {
1358 * Do dummy first-time call to seal the kernel's time warp magic
1360 * Do not call this this from inside the initrd. The initrd might not
1361 * carry /etc/adjtime with LOCAL, but the real system could be set up
1362 * that way. In such case, we need to delay the time-warp or the sealing
1363 * until we reach the real system.
1365 clock_reset_timezone();
1367 /* Tell the kernel our timezone */
1368 r = clock_set_timezone(NULL);
1370 log_error("Failed to set the kernel's timezone, ignoring: %s", strerror(-r));
1374 /* Set the default for later on, but don't actually
1375 * open the logs like this for now. Note that if we
1376 * are transitioning from the initrd there might still
1377 * be journal fd open, and we shouldn't attempt
1378 * opening that before we parsed /proc/cmdline which
1379 * might redirect output elsewhere. */
1380 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1382 } else if (getpid() == 1) {
1383 /* Running inside a container, as PID 1 */
1384 arg_running_as = SYSTEMD_SYSTEM;
1385 log_set_target(LOG_TARGET_CONSOLE);
1386 log_close_console(); /* force reopen of /dev/console */
1389 /* For the later on, see above... */
1390 log_set_target(LOG_TARGET_JOURNAL);
1392 /* clear the kernel timestamp,
1393 * because we are in a container */
1394 kernel_timestamp.monotonic = 0ULL;
1395 kernel_timestamp.realtime = 0ULL;
1398 /* Running as user instance */
1399 arg_running_as = SYSTEMD_USER;
1400 log_set_target(LOG_TARGET_AUTO);
1403 /* clear the kernel timestamp,
1404 * because we are not PID 1 */
1405 kernel_timestamp.monotonic = 0ULL;
1406 kernel_timestamp.realtime = 0ULL;
1409 /* Initialize default unit */
1410 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1412 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1416 r = initialize_join_controllers();
1420 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1421 * /proc/$PID/fd is available. */
1422 if (getpid() == 1) {
1423 r = mount_setup(loaded_policy);
1428 /* Reset all signal handlers. */
1429 assert_se(reset_all_signal_handlers() == 0);
1431 ignore_signals(SIGNALS_IGNORE, -1);
1433 if (parse_config_file() < 0)
1436 if (arg_running_as == SYSTEMD_SYSTEM)
1437 if (parse_proc_cmdline(parse_proc_cmdline_item) < 0)
1440 log_parse_environment();
1442 if (parse_argv(argc, argv) < 0)
1445 if (arg_action == ACTION_TEST &&
1447 log_error("Don't run test mode as root.");
1451 if (arg_running_as == SYSTEMD_USER &&
1452 arg_action == ACTION_RUN &&
1454 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1458 if (arg_running_as == SYSTEMD_SYSTEM &&
1459 arg_action == ACTION_RUN &&
1460 running_in_chroot() > 0) {
1461 log_error("Cannot be run in a chroot() environment.");
1465 if (arg_action == ACTION_HELP) {
1468 } else if (arg_action == ACTION_VERSION) {
1471 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1472 unit_dump_config_items(stdout);
1473 retval = EXIT_SUCCESS;
1475 } else if (arg_action == ACTION_DONE) {
1476 retval = EXIT_SUCCESS;
1480 if (arg_running_as == SYSTEMD_USER &&
1481 !getenv("XDG_RUNTIME_DIR")) {
1482 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1486 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1488 /* Close logging fds, in order not to confuse fdset below */
1491 /* Remember open file descriptors for later deserialization */
1492 r = fdset_new_fill(&fds);
1494 log_error("Failed to allocate fd set: %s", strerror(-r));
1497 fdset_cloexec(fds, true);
1499 if (arg_serialization)
1500 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1502 if (arg_running_as == SYSTEMD_SYSTEM)
1503 /* Become a session leader if we aren't one yet. */
1506 /* Move out of the way, so that we won't block unmounts */
1507 assert_se(chdir("/") == 0);
1509 /* Reset the console, but only if this is really init and we
1510 * are freshly booted */
1511 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1512 console_setup(getpid() == 1 && !skip_setup);
1514 /* Open the logging devices, if possible and necessary */
1517 if (arg_show_status == _SHOW_STATUS_UNSET)
1518 arg_show_status = SHOW_STATUS_YES;
1520 /* Make sure we leave a core dump without panicing the
1522 if (getpid() == 1) {
1523 install_crash_handler();
1525 r = mount_cgroup_controllers(arg_join_controllers);
1530 if (arg_running_as == SYSTEMD_SYSTEM) {
1531 const char *virtualization = NULL;
1533 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1535 detect_virtualization(&virtualization);
1537 log_info("Detected virtualization '%s'.", virtualization);
1539 write_container_id();
1541 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1544 log_info("Running in initial RAM disk.");
1546 empty_etc = dir_is_empty("/etc") > 0;
1548 log_info("Running with unpopulated /etc.");
1550 _cleanup_free_ char *t;
1552 t = uid_to_name(getuid());
1553 log_debug(PACKAGE_STRING " running in user mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")", getuid(), strna(t));
1556 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1557 if (arg_show_status > 0 || plymouth_running())
1564 machine_id_setup(NULL);
1571 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1572 watchdog_set_timeout(&arg_runtime_watchdog);
1574 if (arg_timer_slack_nsec != (nsec_t) -1)
1575 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1576 log_error("Failed to adjust timer slack: %m");
1578 if (arg_capability_bounding_set_drop) {
1579 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1581 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1584 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1586 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1591 if (arg_syscall_archs) {
1592 r = enforce_syscall_archs(arg_syscall_archs);
1597 if (arg_running_as == SYSTEMD_USER) {
1598 /* Become reaper of our children */
1599 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1600 log_warning("Failed to make us a subreaper: %m");
1601 if (errno == EINVAL)
1602 log_info("Perhaps the kernel version is too old (< 3.4?)");
1606 if (arg_running_as == SYSTEMD_SYSTEM) {
1607 bump_rlimit_nofile(&saved_rlimit_nofile);
1610 r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1612 log_warning("Failed to populate /etc with preset unit settings, ignoring: %s", strerror(-r));
1614 log_info("Populated /etc with preset unit settings.");
1618 r = manager_new(arg_running_as, &m);
1620 log_error("Failed to allocate manager object: %s", strerror(-r));
1624 m->confirm_spawn = arg_confirm_spawn;
1625 m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1626 m->default_std_output = arg_default_std_output;
1627 m->default_std_error = arg_default_std_error;
1628 m->default_restart_usec = arg_default_restart_usec;
1629 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1630 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1631 m->default_start_limit_interval = arg_default_start_limit_interval;
1632 m->default_start_limit_burst = arg_default_start_limit_burst;
1633 m->default_cpu_accounting = arg_default_cpu_accounting;
1634 m->default_blockio_accounting = arg_default_blockio_accounting;
1635 m->default_memory_accounting = arg_default_memory_accounting;
1636 m->runtime_watchdog = arg_runtime_watchdog;
1637 m->shutdown_watchdog = arg_shutdown_watchdog;
1638 m->userspace_timestamp = userspace_timestamp;
1639 m->kernel_timestamp = kernel_timestamp;
1640 m->initrd_timestamp = initrd_timestamp;
1641 m->security_start_timestamp = security_start_timestamp;
1642 m->security_finish_timestamp = security_finish_timestamp;
1644 manager_set_default_rlimits(m, arg_default_rlimit);
1645 manager_environment_add(m, NULL, arg_default_environment);
1646 manager_set_show_status(m, arg_show_status);
1648 /* Remember whether we should queue the default job */
1649 queue_default_job = !arg_serialization || arg_switched_root;
1651 before_startup = now(CLOCK_MONOTONIC);
1653 r = manager_startup(m, arg_serialization, fds);
1655 log_error("Failed to fully start up daemon: %s", strerror(-r));
1657 /* This will close all file descriptors that were opened, but
1658 * not claimed by any unit. */
1662 if (arg_serialization) {
1663 fclose(arg_serialization);
1664 arg_serialization = NULL;
1667 if (queue_default_job) {
1668 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1669 Unit *target = NULL;
1670 Job *default_unit_job;
1672 log_debug("Activating default unit: %s", arg_default_unit);
1674 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1676 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1677 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1678 log_error("Failed to load default target: %s", strerror(-target->load_error));
1679 else if (target->load_state == UNIT_MASKED)
1680 log_error("Default target masked.");
1682 if (!target || target->load_state != UNIT_LOADED) {
1683 log_info("Trying to load rescue target...");
1685 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1687 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1689 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1690 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1692 } else if (target->load_state == UNIT_MASKED) {
1693 log_error("Rescue target masked.");
1698 assert(target->load_state == UNIT_LOADED);
1700 if (arg_action == ACTION_TEST) {
1701 printf("-> By units:\n");
1702 manager_dump_units(m, stdout, "\t");
1705 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1707 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1709 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1711 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1715 log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1719 m->default_unit_job_id = default_unit_job->id;
1721 after_startup = now(CLOCK_MONOTONIC);
1722 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1723 "Loaded units and determined initial transaction in %s.",
1724 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1726 if (arg_action == ACTION_TEST) {
1727 printf("-> By jobs:\n");
1728 manager_dump_jobs(m, stdout, "\t");
1729 retval = EXIT_SUCCESS;
1735 r = manager_loop(m);
1737 log_error("Failed to run mainloop: %s", strerror(-r));
1741 switch (m->exit_code) {
1744 retval = EXIT_SUCCESS;
1748 case MANAGER_RELOAD:
1749 log_info("Reloading.");
1750 r = manager_reload(m);
1752 log_error("Failed to reload: %s", strerror(-r));
1755 case MANAGER_REEXECUTE:
1757 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1761 log_notice("Reexecuting.");
1764 case MANAGER_SWITCH_ROOT:
1765 /* Steal the switch root parameters */
1766 switch_root_dir = m->switch_root;
1767 switch_root_init = m->switch_root_init;
1768 m->switch_root = m->switch_root_init = NULL;
1770 if (!switch_root_init)
1771 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1775 log_notice("Switching root.");
1778 case MANAGER_REBOOT:
1779 case MANAGER_POWEROFF:
1781 case MANAGER_KEXEC: {
1782 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1783 [MANAGER_REBOOT] = "reboot",
1784 [MANAGER_POWEROFF] = "poweroff",
1785 [MANAGER_HALT] = "halt",
1786 [MANAGER_KEXEC] = "kexec"
1789 assert_se(shutdown_verb = table[m->exit_code]);
1790 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1792 log_notice("Shutting down.");
1797 assert_not_reached("Unknown exit code.");
1807 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1808 free(arg_default_rlimit[j]);
1809 arg_default_rlimit[j] = NULL;
1812 free(arg_default_unit);
1813 arg_default_unit = NULL;
1815 free_join_controllers();
1817 strv_free(arg_default_environment);
1818 arg_default_environment = NULL;
1820 set_free(arg_syscall_archs);
1821 arg_syscall_archs = NULL;
1827 unsigned i, args_size;
1830 /* Close and disarm the watchdog, so that the new
1831 * instance can reinitialize it, but doesn't get
1832 * rebooted while we do that */
1833 watchdog_close(true);
1835 /* Reset the RLIMIT_NOFILE to the kernel default, so
1836 * that the new systemd can pass the kernel default to
1837 * its child processes */
1838 if (saved_rlimit_nofile.rlim_cur > 0)
1839 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1841 if (switch_root_dir) {
1842 /* Kill all remaining processes from the
1843 * initrd, but don't wait for them, so that we
1844 * can handle the SIGCHLD for them after
1846 broadcast_signal(SIGTERM, false, true);
1848 /* And switch root */
1849 r = switch_root(switch_root_dir);
1851 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1854 args_size = MAX(6, argc+1);
1855 args = newa(const char*, args_size);
1857 if (!switch_root_init) {
1860 /* First try to spawn ourselves with the right
1861 * path, and with full serialization. We do
1862 * this only if the user didn't specify an
1863 * explicit init to spawn. */
1865 assert(arg_serialization);
1868 snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1872 args[i++] = SYSTEMD_BINARY_PATH;
1873 if (switch_root_dir)
1874 args[i++] = "--switched-root";
1875 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1876 args[i++] = "--deserialize";
1880 /* do not pass along the environment we inherit from the kernel or initrd */
1881 if (switch_root_dir)
1884 assert(i <= args_size);
1885 execv(args[0], (char* const*) args);
1888 /* Try the fallback, if there is any, without any
1889 * serialization. We pass the original argv[] and
1890 * envp[]. (Well, modulo the ordering changes due to
1891 * getopt() in argv[], and some cleanups in envp[],
1892 * but let's hope that doesn't matter.) */
1894 if (arg_serialization) {
1895 fclose(arg_serialization);
1896 arg_serialization = NULL;
1904 /* Reopen the console */
1905 make_console_stdio();
1907 for (j = 1, i = 1; j < (unsigned) argc; j++)
1908 args[i++] = argv[j];
1910 assert(i <= args_size);
1912 /* reenable any blocked signals, especially important
1913 * if we switch from initial ramdisk to init=... */
1914 reset_all_signal_handlers();
1916 assert_se(sigemptyset(&ss) == 0);
1917 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
1919 if (switch_root_init) {
1920 args[0] = switch_root_init;
1921 execv(args[0], (char* const*) args);
1922 log_warning("Failed to execute configured init, trying fallback: %m");
1925 args[0] = "/sbin/init";
1926 execv(args[0], (char* const*) args);
1928 if (errno == ENOENT) {
1929 log_warning("No /sbin/init, trying fallback");
1931 args[0] = "/bin/sh";
1933 execv(args[0], (char* const*) args);
1934 log_error("Failed to execute /bin/sh, giving up: %m");
1936 log_warning("Failed to execute /sbin/init, giving up: %m");
1939 if (arg_serialization) {
1940 fclose(arg_serialization);
1941 arg_serialization = NULL;
1949 #ifdef HAVE_VALGRIND_VALGRIND_H
1950 /* If we are PID 1 and running under valgrind, then let's exit
1951 * here explicitly. valgrind will only generate nice output on
1952 * exit(), not on exec(), hence let's do the former not the
1954 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1958 if (shutdown_verb) {
1959 char log_level[DECIMAL_STR_MAX(int) + 1];
1960 const char* command_line[9] = {
1961 SYSTEMD_SHUTDOWN_BINARY_PATH,
1963 "--log-level", log_level,
1967 _cleanup_strv_free_ char **env_block = NULL;
1969 assert(command_line[pos] == NULL);
1970 env_block = strv_copy(environ);
1972 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1974 switch (log_get_target()) {
1975 case LOG_TARGET_KMSG:
1976 case LOG_TARGET_JOURNAL_OR_KMSG:
1977 case LOG_TARGET_SYSLOG_OR_KMSG:
1978 command_line[pos++] = "kmsg";
1981 case LOG_TARGET_CONSOLE:
1983 command_line[pos++] = "console";
1987 if (log_get_show_color())
1988 command_line[pos++] = "--log-color";
1990 if (log_get_show_location())
1991 command_line[pos++] = "--log-location";
1993 assert(pos < ELEMENTSOF(command_line));
1995 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1998 /* If we reboot let's set the shutdown
1999 * watchdog and tell the shutdown binary to
2000 * repeatedly ping it */
2001 watchdog_set_timeout(&arg_shutdown_watchdog);
2002 watchdog_close(false);
2004 /* Tell the binary how often to ping, ignore failure */
2005 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2006 strv_push(&env_block, e);
2008 watchdog_close(true);
2010 /* Avoid the creation of new processes forked by the
2011 * kernel; at this point, we will not listen to the
2013 if (detect_container(NULL) <= 0)
2014 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2016 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2017 log_error("Failed to execute shutdown binary, %s: %m",
2018 getpid() == 1 ? "freezing" : "quitting");