#include <errno.h>

#include <fcntl.h>

#include <getopt.h>

#include <sys/mount.h>

#include <sys/prctl.h>

#include <sys/reboot.h>

#include <unistd.h>

#if HAVE_SECCOMP

#include <seccomp.h>

#if HAVE_VALGRIND_VALGRIND_H

#include <valgrind/valgrind.h>

#include "sd-bus.h"

#include "sd-daemon.h"

#include "sd-messages.h"

#include "alloc-util.h"

#include "apparmor-setup.h"

#include "architecture.h"

#include "build.h"

#include "bus-error.h"

#include "bus-util.h"

#include "capability-util.h"

#include "cgroup-util.h"

#include "clock-util.h"

#include "conf-parser.h"

#include "cpu-set-util.h"

#include "dbus-manager.h"

#include "dbus.h"

#include "def.h"

#include "dev-setup.h"

#include "efi-random.h"

#include "efivars.h"

#include "emergency-action.h"

#include "env-util.h"

#include "exit-status.h"

#include "fd-util.h"

#include "fdset.h"

#include "fileio.h"

#include "format-util.h"

#include "fs-util.h"

#include "hexdecoct.h"

#include "hostname-setup.h"

#include "ima-setup.h"

#include "killall.h"

#include "kmod-setup.h"

#include "limits-util.h"

#include "load-fragment.h"

#include "log.h"

#include "loopback-setup.h"

#include "machine-id-setup.h"

#include "manager.h"

#include "manager-dump.h"

#include "mkdir.h"

#include "mount-setup.h"

#include "os-util.h"

#include "pager.h"

#include "parse-argument.h"

#include "parse-util.h"

#include "path-util.h"

#include "pretty-print.h"

#include "proc-cmdline.h"

#include "process-util.h"

#include "random-util.h"

#include "raw-clone.h"

#include "rlimit-util.h"

#if HAVE_SECCOMP

#include "seccomp-util.h"

#include "selinux-setup.h"

#include "selinux-util.h"

#include "signal-util.h"

#include "smack-setup.h"

#include "special.h"

#include "stat-util.h"

#include "stdio-util.h"

#include "strv.h"

#include "switch-root.h"

#include "sysctl-util.h"

#include "terminal-util.h"

#include "umask-util.h"

#include "user-util.h"

#include "util.h"

#include "virt.h"

#include "watchdog.h"

#if HAS_FEATURE_ADDRESS_SANITIZER

#include <sanitizer/lsan_interface.h>

#define DEFAULT_TASKS_MAX ((TasksMax) { 15U, 100U }) /* 15% */

static enum {

ACTION_RUN,

ACTION_HELP,

ACTION_VERSION,

ACTION_TEST,

ACTION_DUMP_CONFIGURATION_ITEMS,

ACTION_DUMP_BUS_PROPERTIES,

ACTION_BUS_INTROSPECT,

} arg_action = ACTION_RUN;

static const char *arg_bus_introspect = NULL;

static char *arg_default_unit;

static bool arg_system;

static bool arg_dump_core;

static int arg_crash_chvt;

static bool arg_crash_shell;

static bool arg_crash_reboot;

static char *arg_confirm_spawn;

static ShowStatus arg_show_status;

static StatusUnitFormat arg_status_unit_format;

static bool arg_switched_root;

static PagerFlags arg_pager_flags;

static bool arg_service_watchdogs;

static ExecOutput arg_default_std_output;

static ExecOutput arg_default_std_error;

static usec_t arg_default_restart_usec;

static usec_t arg_default_timeout_start_usec;

static usec_t arg_default_timeout_stop_usec;

static usec_t arg_default_timeout_abort_usec;

static bool arg_default_timeout_abort_set;

static usec_t arg_default_start_limit_interval;

static unsigned arg_default_start_limit_burst;

static usec_t arg_runtime_watchdog;

static usec_t arg_reboot_watchdog;

static usec_t arg_kexec_watchdog;

static char *arg_early_core_pattern;

static char *arg_watchdog_device;

static char **arg_default_environment;

static char **arg_manager_environment;

static struct rlimit *arg_default_rlimit[_RLIMIT_MAX];

static uint64_t arg_capability_bounding_set;

static bool arg_no_new_privs;

static nsec_t arg_timer_slack_nsec;

static usec_t arg_default_timer_accuracy_usec;

static Set* arg_syscall_archs;

static FILE* arg_serialization;

static int arg_default_cpu_accounting;

static bool arg_default_io_accounting;

static bool arg_default_ip_accounting;

static bool arg_default_blockio_accounting;

static bool arg_default_memory_accounting;

static bool arg_default_tasks_accounting;

static TasksMax arg_default_tasks_max;

static sd_id128_t arg_machine_id;

static EmergencyAction arg_cad_burst_action;

static OOMPolicy arg_default_oom_policy;

static CPUSet arg_cpu_affinity;

static NUMAPolicy arg_numa_policy;

static usec_t arg_clock_usec;

static void *arg_random_seed;

static size_t arg_random_seed_size;

static char **saved_env = NULL;

static int parse_configuration(const struct rlimit *saved_rlimit_nofile,

const struct rlimit *saved_rlimit_memlock);

static int manager_find_user_config_paths(char ***ret_files, char ***ret_dirs) {

_cleanup_free_ char *base = NULL;

_cleanup_strv_free_ char **files = NULL, **dirs = NULL;

int r;

r = xdg_user_config_dir(&base, "/systemd");

if (r < 0)

return r;

r = strv_extendf(&files, "%s/user.conf", base);

if (r < 0)

return r;

r = strv_extend(&files, PKGSYSCONFDIR "/user.conf");

if (r < 0)

return r;

r = strv_consume(&dirs, TAKE_PTR(base));

if (r < 0)

return r;

r = strv_extend_strv(&dirs, CONF_PATHS_STRV("systemd"), false);

if (r < 0)

return r;

*ret_files = TAKE_PTR(files);

*ret_dirs = TAKE_PTR(dirs);

return 0;

}

_noreturn_ static void freeze_or_exit_or_reboot(void) {

/* If we are running in a container, let's prefer exiting, after all we can propagate an exit code to

if (detect_container() > 0) {

log_emergency("Exiting PID 1...");

_exit(EXIT_EXCEPTION);

}

if (arg_crash_reboot) {

log_notice("Rebooting in 10s...");

(void) sleep(10);

log_notice("Rebooting now...");

(void) reboot(RB_AUTOBOOT);

log_emergency_errno(errno, "Failed to reboot: %m");

}

log_emergency("Freezing execution.");

freeze();

}

_noreturn_ static void crash(int sig) {

struct sigaction sa;

pid_t pid;

if (getpid_cached() != 1)

/* Pass this on immediately, if this is not PID 1 */

(void) raise(sig);

else if (!arg_dump_core)

log_emergency("Caught <%s>, not dumping core.", signal_to_string(sig));

else {

sa = (struct sigaction) {

.sa_handler = nop_signal_handler,

.sa_flags = SA_NOCLDSTOP|SA_RESTART,

};

/* We want to wait for the core process, hence let's enable SIGCHLD */

(void) sigaction(SIGCHLD, &sa, NULL);

pid = raw_clone(SIGCHLD);

if (pid < 0)

log_emergency_errno(errno, "Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));

else if (pid == 0) {

/* Enable default signal handler for core dump */

sa = (struct sigaction) {

.sa_handler = SIG_DFL,

};

(void) sigaction(sig, &sa, NULL);

/* Don't limit the coredump size */

(void) setrlimit(RLIMIT_CORE, &RLIMIT_MAKE_CONST(RLIM_INFINITY));

/* Just to be sure... */

(void) chdir("/");

/* Raise the signal again */

pid = raw_getpid();

(void) kill(pid, sig); /* raise() would kill the parent */

assert_not_reached("We shouldn't be here...");

_exit(EXIT_EXCEPTION);

} else {

siginfo_t status;

int r;

/* Order things nicely. */

r = wait_for_terminate(pid, &status);

if (r < 0)

log_emergency_errno(r, "Caught <%s>, waitpid() failed: %m", signal_to_string(sig));

else if (status.si_code != CLD_DUMPED) {

const char *s = status.si_code == CLD_EXITED

? exit_status_to_string(status.si_status, EXIT_STATUS_LIBC)

: signal_to_string(status.si_status);

log_emergency("Caught <%s>, core dump failed (child "PID_FMT", code=%s, status=%i/%s).",

signal_to_string(sig),

pid,

sigchld_code_to_string(status.si_code),

status.si_status, strna(s));

} else

log_emergency("Caught <%s>, dumped core as pid "PID_FMT".",

signal_to_string(sig), pid);

}

}

if (arg_crash_chvt >= 0)

(void) chvt(arg_crash_chvt);

sa = (struct sigaction) {

.sa_handler = SIG_IGN,

.sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,

};

/* Let the kernel reap children for us */

(void) sigaction(SIGCHLD, &sa, NULL);

if (arg_crash_shell) {

log_notice("Executing crash shell in 10s...");

(void) sleep(10);

pid = raw_clone(SIGCHLD);

if (pid < 0)

log_emergency_errno(errno, "Failed to fork off crash shell: %m");

else if (pid == 0) {

(void) setsid();

(void) make_console_stdio();

(void) rlimit_nofile_safe();

(void) execle("/bin/sh", "/bin/sh", NULL, environ);

log_emergency_errno(errno, "execle() failed: %m");

_exit(EXIT_EXCEPTION);

} else {

log_info("Spawned crash shell as PID "PID_FMT".", pid);

(void) wait_for_terminate(pid, NULL);

}

}

freeze_or_exit_or_reboot();

}

static void install_crash_handler(void) {

static const struct sigaction sa = {

.sa_handler = crash,

.sa_flags = SA_NODEFER, /* So that we can raise the signal again from the signal handler */

};

int r;

/* We ignore the return value here, since, we don't mind if we cannot set up a crash handler */

r = sigaction_many(&sa, SIGNALS_CRASH_HANDLER);

if (r < 0)

log_debug_errno(r, "I had trouble setting up the crash handler, ignoring: %m");

}

static int console_setup(void) {

_cleanup_close_ int tty_fd = -1;

int r;

tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);

if (tty_fd < 0)

return log_error_errno(tty_fd, "Failed to open /dev/console: %m");

/* We don't want to force text mode. plymouth may be showing

r = reset_terminal_fd(tty_fd, false);

if (r < 0)

return log_error_errno(r, "Failed to reset /dev/console: %m");

return 0;

}

static int set_machine_id(const char *m) {

sd_id128_t t;

assert(m);

if (sd_id128_from_string(m, &t) < 0)

return -EINVAL;

if (sd_id128_is_null(t))

return -EINVAL;

arg_machine_id = t;

return 0;

}

static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {

int r;

assert(key);

if (STR_IN_SET(key, "systemd.unit", "rd.systemd.unit")) {

if (proc_cmdline_value_missing(key, value))

return 0;

if (!unit_name_is_valid(value, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))

log_warning("Unit name specified on %s= is not valid, ignoring: %s", key, value);

else if (in_initrd() == !!startswith(key, "rd."))

return free_and_strdup_warn(&arg_default_unit, value);

} else if (proc_cmdline_key_streq(key, "systemd.dump_core")) {

r = value ? parse_boolean(value) : true;

if (r < 0)

log_warning_errno(r, "Failed to parse dump core switch %s, ignoring: %m", value);

else

arg_dump_core = r;

} else if (proc_cmdline_key_streq(key, "systemd.early_core_pattern")) {

if (proc_cmdline_value_missing(key, value))

return 0;

if (path_is_absolute(value))

(void) parse_path_argument(value, false, &arg_early_core_pattern);

else

log_warning("Specified core pattern '%s' is not an absolute path, ignoring.", value);

} else if (proc_cmdline_key_streq(key, "systemd.crash_chvt")) {

if (!value)

arg_crash_chvt = 0; /* turn on */

else {

r = parse_crash_chvt(value, &arg_crash_chvt);

if (r < 0)

log_warning_errno(r, "Failed to parse crash chvt switch %s, ignoring: %m", value);

}

} else if (proc_cmdline_key_streq(key, "systemd.crash_shell")) {

r = value ? parse_boolean(value) : true;

if (r < 0)

log_warning_errno(r, "Failed to parse crash shell switch %s, ignoring: %m", value);

else

arg_crash_shell = r;

} else if (proc_cmdline_key_streq(key, "systemd.crash_reboot")) {

r = value ? parse_boolean(value) : true;

if (r < 0)

log_warning_errno(r, "Failed to parse crash reboot switch %s, ignoring: %m", value);

else

arg_crash_reboot = r;

} else if (proc_cmdline_key_streq(key, "systemd.confirm_spawn")) {

char *s;

r = parse_confirm_spawn(value, &s);

if (r < 0)

log_warning_errno(r, "Failed to parse confirm_spawn switch %s, ignoring: %m", value);

else

free_and_replace(arg_confirm_spawn, s);

} else if (proc_cmdline_key_streq(key, "systemd.service_watchdogs")) {

r = value ? parse_boolean(value) : true;

if (r < 0)

log_warning_errno(r, "Failed to parse service watchdog switch %s, ignoring: %m", value);

else

arg_service_watchdogs = r;

} else if (proc_cmdline_key_streq(key, "systemd.show_status")) {

if (value) {

r = parse_show_status(value, &arg_show_status);

if (r < 0)

log_warning_errno(r, "Failed to parse show status switch %s, ignoring: %m", value);

} else

arg_show_status = SHOW_STATUS_YES;

} else if (proc_cmdline_key_streq(key, "systemd.status_unit_format")) {

if (proc_cmdline_value_missing(key, value))

return 0;

r = status_unit_format_from_string(value);

if (r < 0)

log_warning_errno(r, "Failed to parse %s=%s, ignoring: %m", key, value);

else

arg_status_unit_format = r;

} else if (proc_cmdline_key_streq(key, "systemd.default_standard_output")) {

if (proc_cmdline_value_missing(key, value))

return 0;

r = exec_output_from_string(value);

if (r < 0)

log_warning_errno(r, "Failed to parse default standard output switch %s, ignoring: %m", value);

else

arg_default_std_output = r;

} else if (proc_cmdline_key_streq(key, "systemd.default_standard_error")) {

if (proc_cmdline_value_missing(key, value))

return 0;

r = exec_output_from_string(value);

if (r < 0)

log_warning_errno(r, "Failed to parse default standard error switch %s, ignoring: %m", value);

else

arg_default_std_error = r;

} else if (streq(key, "systemd.setenv")) {

if (proc_cmdline_value_missing(key, value))

return 0;

if (!env_assignment_is_valid(value))

log_warning("Environment variable assignment '%s' is not valid. Ignoring.", value);

else {

r = strv_env_replace_strdup(&arg_default_environment, value);

if (r < 0)

return log_oom();

}

} else if (proc_cmdline_key_streq(key, "systemd.machine_id")) {

if (proc_cmdline_value_missing(key, value))

return 0;

r = set_machine_id(value);

if (r < 0)

log_warning_errno(r, "MachineID '%s' is not valid, ignoring: %m", value);

} else if (proc_cmdline_key_streq(key, "systemd.default_timeout_start_sec")) {

if (proc_cmdline_value_missing(key, value))

return 0;

r = parse_sec(value, &arg_default_timeout_start_usec);

if (r < 0)

log_warning_errno(r, "Failed to parse default start timeout '%s', ignoring: %m", value);

if (arg_default_timeout_start_usec <= 0)

arg_default_timeout_start_usec = USEC_INFINITY;

} else if (proc_cmdline_key_streq(key, "systemd.cpu_affinity")) {

if (proc_cmdline_value_missing(key, value))

return 0;

r = parse_cpu_set(value, &arg_cpu_affinity);

if (r < 0)

log_warning_errno(r, "Failed to parse CPU affinity mask '%s', ignoring: %m", value);

} else if (proc_cmdline_key_streq(key, "systemd.watchdog_device")) {

if (proc_cmdline_value_missing(key, value))

return 0;

(void) parse_path_argument(value, false, &arg_watchdog_device);

} else if (proc_cmdline_key_streq(key, "systemd.clock_usec")) {

if (proc_cmdline_value_missing(key, value))

return 0;

r = safe_atou64(value, &arg_clock_usec);

if (r < 0)

log_warning_errno(r, "Failed to parse systemd.clock_usec= argument, ignoring: %s", value);

} else if (proc_cmdline_key_streq(key, "systemd.random_seed")) {

void *p;

size_t sz;

if (proc_cmdline_value_missing(key, value))

return 0;

r = unbase64mem(value, SIZE_MAX, &p, &sz);

if (r < 0)

log_warning_errno(r, "Failed to parse systemd.random_seed= argument, ignoring: %s", value);

free(arg_random_seed);

arg_random_seed = sz > 0 ? p : mfree(p);

arg_random_seed_size = sz;

} else if (streq(key, "quiet") && !value) {

if (arg_show_status == _SHOW_STATUS_INVALID)

arg_show_status = SHOW_STATUS_ERROR;

} else if (streq(key, "debug") && !value) {

/* Note that log_parse_environment() handles 'debug'

if (detect_container() > 0)

log_set_target(LOG_TARGET_CONSOLE);

} else if (!value) {

const char *target;

/* Compatible with SysV, but supported independently even if SysV compatibility is disabled. */

target = runlevel_to_target(key);

if (target)

return free_and_strdup_warn(&arg_default_unit, target);

}

return 0;

}

#define DEFINE_SETTER(name, func, descr) \

static int name(const char *unit, \

const char *filename, \

unsigned line, \

const char *section, \

unsigned section_line, \

const char *lvalue, \

int ltype, \

const char *rvalue, \

void *data, \

void *userdata) { \

\

int r; \

\

assert(filename); \

assert(lvalue); \

assert(rvalue); \

\

r = func(rvalue); \

if (r < 0) \

log_syntax(unit, LOG_ERR, filename, line, r, \

"Invalid " descr "'%s': %m", \

rvalue); \

\

return 0; \

}

DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level");

DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target");

DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color");

DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location");

DEFINE_SETTER(config_parse_time, log_show_time_from_string, "time");

static int config_parse_default_timeout_abort(

void *userdata) {

int r;

r = config_parse_timeout_abort(unit, filename, line, section, section_line, lvalue, ltype, rvalue,

&arg_default_timeout_abort_usec, userdata);

if (r >= 0)

arg_default_timeout_abort_set = r;

return 0;

}

static int parse_config_file(void) {

const ConfigTableItem items[] = {

{ "Manager", "LogLevel", config_parse_level2, 0, NULL },

{ "Manager", "LogTarget", config_parse_target, 0, NULL },

{ "Manager", "LogColor", config_parse_color, 0, NULL },

{ "Manager", "LogLocation", config_parse_location, 0, NULL },

{ "Manager", "LogTime", config_parse_time, 0, NULL },

{ "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },

{ "Manager", "CrashChVT", /* legacy */ config_parse_crash_chvt, 0, &arg_crash_chvt },

{ "Manager", "CrashChangeVT", config_parse_crash_chvt, 0, &arg_crash_chvt },

{ "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },

{ "Manager", "CrashReboot", config_parse_bool, 0, &arg_crash_reboot },

{ "Manager", "ShowStatus", config_parse_show_status, 0, &arg_show_status },

{ "Manager", "StatusUnitFormat", config_parse_status_unit_format, 0, &arg_status_unit_format },

{ "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, &arg_cpu_affinity },

{ "Manager", "NUMAPolicy", config_parse_numa_policy, 0, &arg_numa_policy.type },

{ "Manager", "NUMAMask", config_parse_numa_mask, 0, &arg_numa_policy },

{ "Manager", "JoinControllers", config_parse_warn_compat, DISABLED_CONFIGURATION, NULL },

{ "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },

{ "Manager", "RebootWatchdogSec", config_parse_sec, 0, &arg_reboot_watchdog },

{ "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_reboot_watchdog }, /* obsolete alias */

{ "Manager", "KExecWatchdogSec", config_parse_sec, 0, &arg_kexec_watchdog },

{ "Manager", "WatchdogDevice", config_parse_path, 0, &arg_watchdog_device },

{ "Manager", "CapabilityBoundingSet", config_parse_capability_set, 0, &arg_capability_bounding_set },

{ "Manager", "NoNewPrivileges", config_parse_bool, 0, &arg_no_new_privs },

#if HAVE_SECCOMP

{ "Manager", "SystemCallArchitectures", config_parse_syscall_archs, 0, &arg_syscall_archs },

{ "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },

{ "Manager", "DefaultTimerAccuracySec", config_parse_sec, 0, &arg_default_timer_accuracy_usec },

{ "Manager", "DefaultStandardOutput", config_parse_output_restricted, 0, &arg_default_std_output },

{ "Manager", "DefaultStandardError", config_parse_output_restricted, 0, &arg_default_std_error },

{ "Manager", "DefaultTimeoutStartSec", config_parse_sec, 0, &arg_default_timeout_start_usec },

{ "Manager", "DefaultTimeoutStopSec", config_parse_sec, 0, &arg_default_timeout_stop_usec },

{ "Manager", "DefaultTimeoutAbortSec", config_parse_default_timeout_abort, 0, NULL },

{ "Manager", "DefaultRestartSec", config_parse_sec, 0, &arg_default_restart_usec },

{ "Manager", "DefaultStartLimitInterval", config_parse_sec, 0, &arg_default_start_limit_interval }, /* obsolete alias */

{ "Manager", "DefaultStartLimitIntervalSec", config_parse_sec, 0, &arg_default_start_limit_interval },

{ "Manager", "DefaultStartLimitBurst", config_parse_unsigned, 0, &arg_default_start_limit_burst },

{ "Manager", "DefaultEnvironment", config_parse_environ, 0, &arg_default_environment },

{ "Manager", "ManagerEnvironment", config_parse_environ, 0, &arg_manager_environment },

{ "Manager", "DefaultLimitCPU", config_parse_rlimit, RLIMIT_CPU, arg_default_rlimit },

{ "Manager", "DefaultLimitFSIZE", config_parse_rlimit, RLIMIT_FSIZE, arg_default_rlimit },

{ "Manager", "DefaultLimitDATA", config_parse_rlimit, RLIMIT_DATA, arg_default_rlimit },

{ "Manager", "DefaultLimitSTACK", config_parse_rlimit, RLIMIT_STACK, arg_default_rlimit },

{ "Manager", "DefaultLimitCORE", config_parse_rlimit, RLIMIT_CORE, arg_default_rlimit },

{ "Manager", "DefaultLimitRSS", config_parse_rlimit, RLIMIT_RSS, arg_default_rlimit },

{ "Manager", "DefaultLimitNOFILE", config_parse_rlimit, RLIMIT_NOFILE, arg_default_rlimit },

{ "Manager", "DefaultLimitAS", config_parse_rlimit, RLIMIT_AS, arg_default_rlimit },

{ "Manager", "DefaultLimitNPROC", config_parse_rlimit, RLIMIT_NPROC, arg_default_rlimit },

{ "Manager", "DefaultLimitMEMLOCK", config_parse_rlimit, RLIMIT_MEMLOCK, arg_default_rlimit },

{ "Manager", "DefaultLimitLOCKS", config_parse_rlimit, RLIMIT_LOCKS, arg_default_rlimit },

{ "Manager", "DefaultLimitSIGPENDING", config_parse_rlimit, RLIMIT_SIGPENDING, arg_default_rlimit },

{ "Manager", "DefaultLimitMSGQUEUE", config_parse_rlimit, RLIMIT_MSGQUEUE, arg_default_rlimit },

{ "Manager", "DefaultLimitNICE", config_parse_rlimit, RLIMIT_NICE, arg_default_rlimit },

{ "Manager", "DefaultLimitRTPRIO", config_parse_rlimit, RLIMIT_RTPRIO, arg_default_rlimit },

{ "Manager", "DefaultLimitRTTIME", config_parse_rlimit, RLIMIT_RTTIME, arg_default_rlimit },

{ "Manager", "DefaultCPUAccounting", config_parse_tristate, 0, &arg_default_cpu_accounting },

{ "Manager", "DefaultIOAccounting", config_parse_bool, 0, &arg_default_io_accounting },

{ "Manager", "DefaultIPAccounting", config_parse_bool, 0, &arg_default_ip_accounting },

{ "Manager", "DefaultBlockIOAccounting", config_parse_bool, 0, &arg_default_blockio_accounting },

{ "Manager", "DefaultMemoryAccounting", config_parse_bool, 0, &arg_default_memory_accounting },

{ "Manager", "DefaultTasksAccounting", config_parse_bool, 0, &arg_default_tasks_accounting },

{ "Manager", "DefaultTasksMax", config_parse_tasks_max, 0, &arg_default_tasks_max },

{ "Manager", "CtrlAltDelBurstAction", config_parse_emergency_action, 0, &arg_cad_burst_action },

{ "Manager", "DefaultOOMPolicy", config_parse_oom_policy, 0, &arg_default_oom_policy },

{}

};

_cleanup_strv_free_ char **files = NULL, **dirs = NULL;

const char *suffix;

int r;

if (arg_system)

suffix = "system.conf.d";

else {

r = manager_find_user_config_paths(&files, &dirs);

if (r < 0)

return log_error_errno(r, "Failed to determine config file paths: %m");

suffix = "user.conf.d";

}

(void) config_parse_many(

(const char* const*) (files ?: STRV_MAKE(PKGSYSCONFDIR "/system.conf")),

(const char* const*) (dirs ?: CONF_PATHS_STRV("systemd")),

suffix,

"Manager\0",

config_item_table_lookup, items,

CONFIG_PARSE_WARN,

NULL,

NULL);

/* Traditionally "0" was used to turn off the default unit timeouts. Fix this up so that we use

if (arg_default_timeout_start_usec <= 0)

arg_default_timeout_start_usec = USEC_INFINITY;

if (arg_default_timeout_stop_usec <= 0)

arg_default_timeout_stop_usec = USEC_INFINITY;

return 0;

}

static void set_manager_defaults(Manager *m) {

assert(m);

/* Propagates the various default unit property settings into the manager object, i.e. properties that do not

m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;

m->default_std_output = arg_default_std_output;

m->default_std_error = arg_default_std_error;

m->default_timeout_start_usec = arg_default_timeout_start_usec;

m->default_timeout_stop_usec = arg_default_timeout_stop_usec;

m->default_timeout_abort_usec = arg_default_timeout_abort_usec;

m->default_timeout_abort_set = arg_default_timeout_abort_set;

m->default_restart_usec = arg_default_restart_usec;

m->default_start_limit_interval = arg_default_start_limit_interval;

m->default_start_limit_burst = arg_default_start_limit_burst;

/* On 4.15+ with unified hierarchy, CPU accounting is essentially free as it doesn't require the CPU

if (arg_default_cpu_accounting >= 0)

m->default_cpu_accounting = arg_default_cpu_accounting;

else

m->default_cpu_accounting = cpu_accounting_is_cheap();

m->default_io_accounting = arg_default_io_accounting;

m->default_ip_accounting = arg_default_ip_accounting;

m->default_blockio_accounting = arg_default_blockio_accounting;

m->default_memory_accounting = arg_default_memory_accounting;

m->default_tasks_accounting = arg_default_tasks_accounting;

m->default_tasks_max = arg_default_tasks_max;

m->default_oom_policy = arg_default_oom_policy;

(void) manager_set_default_rlimits(m, arg_default_rlimit);

(void) manager_default_environment(m);

(void) manager_transient_environment_add(m, arg_default_environment);

}

static void set_manager_settings(Manager *m) {

assert(m);

/* Propagates the various manager settings into the manager object, i.e. properties that

m->confirm_spawn = arg_confirm_spawn;

m->service_watchdogs = arg_service_watchdogs;

m->cad_burst_action = arg_cad_burst_action;

manager_set_watchdog(m, WATCHDOG_RUNTIME, arg_runtime_watchdog);

manager_set_watchdog(m, WATCHDOG_REBOOT, arg_reboot_watchdog);

manager_set_watchdog(m, WATCHDOG_KEXEC, arg_kexec_watchdog);

manager_set_show_status(m, arg_show_status, "commandline");

m->status_unit_format = arg_status_unit_format;

}

static int parse_argv(int argc, char *argv[]) {

enum {

ARG_LOG_LEVEL = 0x100,

ARG_LOG_TARGET,

ARG_LOG_COLOR,

ARG_LOG_LOCATION,

ARG_LOG_TIME,

ARG_UNIT,

ARG_SYSTEM,

ARG_USER,

ARG_TEST,

ARG_NO_PAGER,

ARG_VERSION,

ARG_DUMP_CONFIGURATION_ITEMS,

ARG_DUMP_BUS_PROPERTIES,

ARG_BUS_INTROSPECT,

ARG_DUMP_CORE,

ARG_CRASH_CHVT,

ARG_CRASH_SHELL,

ARG_CRASH_REBOOT,

ARG_CONFIRM_SPAWN,

ARG_SHOW_STATUS,

ARG_DESERIALIZE,

ARG_SWITCHED_ROOT,

ARG_DEFAULT_STD_OUTPUT,

ARG_DEFAULT_STD_ERROR,

ARG_MACHINE_ID,

ARG_SERVICE_WATCHDOGS,

};

static const struct option options[] = {

{ "log-level", required_argument, NULL, ARG_LOG_LEVEL },

{ "log-target", required_argument, NULL, ARG_LOG_TARGET },

{ "log-color", optional_argument, NULL, ARG_LOG_COLOR },

{ "log-location", optional_argument, NULL, ARG_LOG_LOCATION },

{ "log-time", optional_argument, NULL, ARG_LOG_TIME },

{ "unit", required_argument, NULL, ARG_UNIT },

{ "system", no_argument, NULL, ARG_SYSTEM },

{ "user", no_argument, NULL, ARG_USER },

{ "test", no_argument, NULL, ARG_TEST },

{ "no-pager", no_argument, NULL, ARG_NO_PAGER },

{ "help", no_argument, NULL, 'h' },

{ "version", no_argument, NULL, ARG_VERSION },

{ "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },

{ "dump-bus-properties", no_argument, NULL, ARG_DUMP_BUS_PROPERTIES },

{ "bus-introspect", required_argument, NULL, ARG_BUS_INTROSPECT },

{ "dump-core", optional_argument, NULL, ARG_DUMP_CORE },

{ "crash-chvt", required_argument, NULL, ARG_CRASH_CHVT },

{ "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },

{ "crash-reboot", optional_argument, NULL, ARG_CRASH_REBOOT },

{ "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },

{ "show-status", optional_argument, NULL, ARG_SHOW_STATUS },

{ "deserialize", required_argument, NULL, ARG_DESERIALIZE },

{ "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },

{ "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },

{ "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },

{ "machine-id", required_argument, NULL, ARG_MACHINE_ID },

{ "service-watchdogs", required_argument, NULL, ARG_SERVICE_WATCHDOGS },

{}

};

int c, r;

bool user_arg_seen = false;

assert(argc >= 1);

assert(argv);

if (getpid_cached() == 1)

opterr = 0;

while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)

switch (c) {

case ARG_LOG_LEVEL:

r = log_set_max_level_from_string(optarg);

if (r < 0)

return log_error_errno(r, "Failed to parse log level \"%s\": %m", optarg);

break;

case ARG_LOG_TARGET:

r = log_set_target_from_string(optarg);

if (r < 0)

return log_error_errno(r, "Failed to parse log target \"%s\": %m", optarg);

break;

case ARG_LOG_COLOR:

if (optarg) {

r = log_show_color_from_string(optarg);

if (r < 0)

return log_error_errno(r, "Failed to parse log color setting \"%s\": %m",

optarg);

} else

log_show_color(true);

break;

case ARG_LOG_LOCATION:

if (optarg) {

r = log_show_location_from_string(optarg);

if (r < 0)

return log_error_errno(r, "Failed to parse log location setting \"%s\": %m",

optarg);

} else

log_show_location(true);

break;

case ARG_LOG_TIME:

if (optarg) {

r = log_show_time_from_string(optarg);

if (r < 0)

return log_error_errno(r, "Failed to parse log time setting \"%s\": %m",

optarg);

} else

log_show_time(true);

break;

case ARG_DEFAULT_STD_OUTPUT:

r = exec_output_from_string(optarg);

if (r < 0)

return log_error_errno(r, "Failed to parse default standard output setting \"%s\": %m",

optarg);

arg_default_std_output = r;

break;

case ARG_DEFAULT_STD_ERROR:

r = exec_output_from_string(optarg);

if (r < 0)

return log_error_errno(r, "Failed to parse default standard error output setting \"%s\": %m",

optarg);

arg_default_std_error = r;

break;

case ARG_UNIT:

r = free_and_strdup(&arg_default_unit, optarg);

if (r < 0)

return log_error_errno(r, "Failed to set default unit \"%s\": %m", optarg);

break;

case ARG_SYSTEM:

arg_system = true;

break;

case ARG_USER:

arg_system = false;

user_arg_seen = true;

break;

case ARG_TEST:

arg_action = ACTION_TEST;

break;

case ARG_NO_PAGER:

arg_pager_flags |= PAGER_DISABLE;

break;

case ARG_VERSION:

arg_action = ACTION_VERSION;

break;

case ARG_DUMP_CONFIGURATION_ITEMS:

arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;

break;

case ARG_DUMP_BUS_PROPERTIES:

arg_action = ACTION_DUMP_BUS_PROPERTIES;

break;

case ARG_BUS_INTROSPECT:

arg_bus_introspect = optarg;

arg_action = ACTION_BUS_INTROSPECT;

break;

case ARG_DUMP_CORE:

r = parse_boolean_argument("--dump-core", optarg, &arg_dump_core);

if (r < 0)

return r;

break;

case ARG_CRASH_CHVT:

r = parse_crash_chvt(optarg, &arg_crash_chvt);

if (r < 0)

return log_error_errno(r, "Failed to parse crash virtual terminal index: \"%s\": %m",

optarg);

break;

case ARG_CRASH_SHELL:

r = parse_boolean_argument("--crash-shell", optarg, &arg_crash_shell);

if (r < 0)

return r;

break;

case ARG_CRASH_REBOOT:

r = parse_boolean_argument("--crash-reboot", optarg, &arg_crash_reboot);

if (r < 0)

return r;

break;