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, 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 /* Let's check whether /etc is already populated. We
1547 * don't actually really check for that, but use
1548 * /etc/machine-id as flag file. This allows container
1549 * managers and installers to provision a couple of
1550 * files already. If the container manager wants to
1551 * provision the machine ID itself it should pass
1552 * $container_uuid to PID 1.*/
1554 empty_etc = access("/etc/machine-id", F_OK) < 0;
1556 log_info("Running with unpopulated /etc.");
1558 _cleanup_free_ char *t;
1560 t = uid_to_name(getuid());
1561 log_debug(PACKAGE_STRING " running in user mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")", getuid(), strna(t));
1564 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1565 if (arg_show_status > 0 || plymouth_running())
1572 machine_id_setup(NULL);
1579 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1580 watchdog_set_timeout(&arg_runtime_watchdog);
1582 if (arg_timer_slack_nsec != (nsec_t) -1)
1583 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1584 log_error("Failed to adjust timer slack: %m");
1586 if (arg_capability_bounding_set_drop) {
1587 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1589 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1592 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1594 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1599 if (arg_syscall_archs) {
1600 r = enforce_syscall_archs(arg_syscall_archs);
1605 if (arg_running_as == SYSTEMD_USER) {
1606 /* Become reaper of our children */
1607 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1608 log_warning("Failed to make us a subreaper: %m");
1609 if (errno == EINVAL)
1610 log_info("Perhaps the kernel version is too old (< 3.4?)");
1614 if (arg_running_as == SYSTEMD_SYSTEM) {
1615 bump_rlimit_nofile(&saved_rlimit_nofile);
1618 r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1620 log_warning("Failed to populate /etc with preset unit settings, ignoring: %s", strerror(-r));
1622 log_info("Populated /etc with preset unit settings.");
1626 r = manager_new(arg_running_as, &m);
1628 log_error("Failed to allocate manager object: %s", strerror(-r));
1632 m->confirm_spawn = arg_confirm_spawn;
1633 m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1634 m->default_std_output = arg_default_std_output;
1635 m->default_std_error = arg_default_std_error;
1636 m->default_restart_usec = arg_default_restart_usec;
1637 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1638 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1639 m->default_start_limit_interval = arg_default_start_limit_interval;
1640 m->default_start_limit_burst = arg_default_start_limit_burst;
1641 m->default_cpu_accounting = arg_default_cpu_accounting;
1642 m->default_blockio_accounting = arg_default_blockio_accounting;
1643 m->default_memory_accounting = arg_default_memory_accounting;
1644 m->runtime_watchdog = arg_runtime_watchdog;
1645 m->shutdown_watchdog = arg_shutdown_watchdog;
1646 m->userspace_timestamp = userspace_timestamp;
1647 m->kernel_timestamp = kernel_timestamp;
1648 m->initrd_timestamp = initrd_timestamp;
1649 m->security_start_timestamp = security_start_timestamp;
1650 m->security_finish_timestamp = security_finish_timestamp;
1652 manager_set_default_rlimits(m, arg_default_rlimit);
1653 manager_environment_add(m, NULL, arg_default_environment);
1654 manager_set_show_status(m, arg_show_status);
1655 manager_set_first_boot(m, empty_etc);
1657 /* Remember whether we should queue the default job */
1658 queue_default_job = !arg_serialization || arg_switched_root;
1660 before_startup = now(CLOCK_MONOTONIC);
1662 r = manager_startup(m, arg_serialization, fds);
1664 log_error("Failed to fully start up daemon: %s", strerror(-r));
1666 /* This will close all file descriptors that were opened, but
1667 * not claimed by any unit. */
1671 if (arg_serialization) {
1672 fclose(arg_serialization);
1673 arg_serialization = NULL;
1676 if (queue_default_job) {
1677 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1678 Unit *target = NULL;
1679 Job *default_unit_job;
1681 log_debug("Activating default unit: %s", arg_default_unit);
1683 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1685 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1686 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1687 log_error("Failed to load default target: %s", strerror(-target->load_error));
1688 else if (target->load_state == UNIT_MASKED)
1689 log_error("Default target masked.");
1691 if (!target || target->load_state != UNIT_LOADED) {
1692 log_info("Trying to load rescue target...");
1694 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1696 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1698 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1699 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1701 } else if (target->load_state == UNIT_MASKED) {
1702 log_error("Rescue target masked.");
1707 assert(target->load_state == UNIT_LOADED);
1709 if (arg_action == ACTION_TEST) {
1710 printf("-> By units:\n");
1711 manager_dump_units(m, stdout, "\t");
1714 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1716 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1718 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1720 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1724 log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1728 m->default_unit_job_id = default_unit_job->id;
1730 after_startup = now(CLOCK_MONOTONIC);
1731 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1732 "Loaded units and determined initial transaction in %s.",
1733 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1735 if (arg_action == ACTION_TEST) {
1736 printf("-> By jobs:\n");
1737 manager_dump_jobs(m, stdout, "\t");
1738 retval = EXIT_SUCCESS;
1744 r = manager_loop(m);
1746 log_error("Failed to run mainloop: %s", strerror(-r));
1750 switch (m->exit_code) {
1753 retval = EXIT_SUCCESS;
1757 case MANAGER_RELOAD:
1758 log_info("Reloading.");
1759 r = manager_reload(m);
1761 log_error("Failed to reload: %s", strerror(-r));
1764 case MANAGER_REEXECUTE:
1766 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1770 log_notice("Reexecuting.");
1773 case MANAGER_SWITCH_ROOT:
1774 /* Steal the switch root parameters */
1775 switch_root_dir = m->switch_root;
1776 switch_root_init = m->switch_root_init;
1777 m->switch_root = m->switch_root_init = NULL;
1779 if (!switch_root_init)
1780 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1784 log_notice("Switching root.");
1787 case MANAGER_REBOOT:
1788 case MANAGER_POWEROFF:
1790 case MANAGER_KEXEC: {
1791 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1792 [MANAGER_REBOOT] = "reboot",
1793 [MANAGER_POWEROFF] = "poweroff",
1794 [MANAGER_HALT] = "halt",
1795 [MANAGER_KEXEC] = "kexec"
1798 assert_se(shutdown_verb = table[m->exit_code]);
1799 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1801 log_notice("Shutting down.");
1806 assert_not_reached("Unknown exit code.");
1816 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1817 free(arg_default_rlimit[j]);
1818 arg_default_rlimit[j] = NULL;
1821 free(arg_default_unit);
1822 arg_default_unit = NULL;
1824 free_join_controllers();
1826 strv_free(arg_default_environment);
1827 arg_default_environment = NULL;
1829 set_free(arg_syscall_archs);
1830 arg_syscall_archs = NULL;
1836 unsigned i, args_size;
1839 /* Close and disarm the watchdog, so that the new
1840 * instance can reinitialize it, but doesn't get
1841 * rebooted while we do that */
1842 watchdog_close(true);
1844 /* Reset the RLIMIT_NOFILE to the kernel default, so
1845 * that the new systemd can pass the kernel default to
1846 * its child processes */
1847 if (saved_rlimit_nofile.rlim_cur > 0)
1848 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1850 if (switch_root_dir) {
1851 /* Kill all remaining processes from the
1852 * initrd, but don't wait for them, so that we
1853 * can handle the SIGCHLD for them after
1855 broadcast_signal(SIGTERM, false, true);
1857 /* And switch root */
1858 r = switch_root(switch_root_dir);
1860 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1863 args_size = MAX(6, argc+1);
1864 args = newa(const char*, args_size);
1866 if (!switch_root_init) {
1869 /* First try to spawn ourselves with the right
1870 * path, and with full serialization. We do
1871 * this only if the user didn't specify an
1872 * explicit init to spawn. */
1874 assert(arg_serialization);
1877 snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1881 args[i++] = SYSTEMD_BINARY_PATH;
1882 if (switch_root_dir)
1883 args[i++] = "--switched-root";
1884 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1885 args[i++] = "--deserialize";
1889 /* do not pass along the environment we inherit from the kernel or initrd */
1890 if (switch_root_dir)
1893 assert(i <= args_size);
1894 execv(args[0], (char* const*) args);
1897 /* Try the fallback, if there is any, without any
1898 * serialization. We pass the original argv[] and
1899 * envp[]. (Well, modulo the ordering changes due to
1900 * getopt() in argv[], and some cleanups in envp[],
1901 * but let's hope that doesn't matter.) */
1903 if (arg_serialization) {
1904 fclose(arg_serialization);
1905 arg_serialization = NULL;
1913 /* Reopen the console */
1914 make_console_stdio();
1916 for (j = 1, i = 1; j < (unsigned) argc; j++)
1917 args[i++] = argv[j];
1919 assert(i <= args_size);
1921 /* reenable any blocked signals, especially important
1922 * if we switch from initial ramdisk to init=... */
1923 reset_all_signal_handlers();
1925 assert_se(sigemptyset(&ss) == 0);
1926 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
1928 if (switch_root_init) {
1929 args[0] = switch_root_init;
1930 execv(args[0], (char* const*) args);
1931 log_warning("Failed to execute configured init, trying fallback: %m");
1934 args[0] = "/sbin/init";
1935 execv(args[0], (char* const*) args);
1937 if (errno == ENOENT) {
1938 log_warning("No /sbin/init, trying fallback");
1940 args[0] = "/bin/sh";
1942 execv(args[0], (char* const*) args);
1943 log_error("Failed to execute /bin/sh, giving up: %m");
1945 log_warning("Failed to execute /sbin/init, giving up: %m");
1948 if (arg_serialization) {
1949 fclose(arg_serialization);
1950 arg_serialization = NULL;
1958 #ifdef HAVE_VALGRIND_VALGRIND_H
1959 /* If we are PID 1 and running under valgrind, then let's exit
1960 * here explicitly. valgrind will only generate nice output on
1961 * exit(), not on exec(), hence let's do the former not the
1963 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1967 if (shutdown_verb) {
1968 char log_level[DECIMAL_STR_MAX(int) + 1];
1969 const char* command_line[9] = {
1970 SYSTEMD_SHUTDOWN_BINARY_PATH,
1972 "--log-level", log_level,
1976 _cleanup_strv_free_ char **env_block = NULL;
1978 assert(command_line[pos] == NULL);
1979 env_block = strv_copy(environ);
1981 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1983 switch (log_get_target()) {
1984 case LOG_TARGET_KMSG:
1985 case LOG_TARGET_JOURNAL_OR_KMSG:
1986 case LOG_TARGET_SYSLOG_OR_KMSG:
1987 command_line[pos++] = "kmsg";
1990 case LOG_TARGET_CONSOLE:
1992 command_line[pos++] = "console";
1996 if (log_get_show_color())
1997 command_line[pos++] = "--log-color";
1999 if (log_get_show_location())
2000 command_line[pos++] = "--log-location";
2002 assert(pos < ELEMENTSOF(command_line));
2004 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
2007 /* If we reboot let's set the shutdown
2008 * watchdog and tell the shutdown binary to
2009 * repeatedly ping it */
2010 watchdog_set_timeout(&arg_shutdown_watchdog);
2011 watchdog_close(false);
2013 /* Tell the binary how often to ping, ignore failure */
2014 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2015 strv_push(&env_block, e);
2017 watchdog_close(true);
2019 /* Avoid the creation of new processes forked by the
2020 * kernel; at this point, we will not listen to the
2022 if (detect_container(NULL) <= 0)
2023 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2025 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2026 log_error("Failed to execute shutdown binary, %s: %m",
2027 getpid() == 1 ? "freezing" : "quitting");