#include <errno.h>

#include <fcntl.h>

#include <linux/kd.h>

#include <sys/epoll.h>

#include <sys/inotify.h>

#include <sys/ioctl.h>

#include <sys/reboot.h>

#include <sys/timerfd.h>

#include <sys/utsname.h>

#include <sys/wait.h>

#include <unistd.h>

#if HAVE_AUDIT

#include <libaudit.h>

#include "sd-daemon.h"

#include "sd-messages.h"

#include "sd-path.h"

#include "all-units.h"

#include "alloc-util.h"

#include "audit-fd.h"

#include "boot-timestamps.h"

#include "bus-common-errors.h"

#include "bus-error.h"

#include "bus-kernel.h"

#include "bus-util.h"

#include "clean-ipc.h"

#include "clock-util.h"

#include "core-varlink.h"

#include "creds-util.h"

#include "dbus-job.h"

#include "dbus-manager.h"

#include "dbus-unit.h"

#include "dbus.h"

#include "def.h"

#include "dirent-util.h"

#include "env-util.h"

#include "escape.h"

#include "event-util.h"

#include "exec-util.h"

#include "execute.h"

#include "exit-status.h"

#include "fd-util.h"

#include "fileio.h"

#include "generator-setup.h"

#include "hashmap.h"

#include "inotify-util.h"

#include "install.h"

#include "io-util.h"

#include "label.h"

#include "load-fragment.h"

#include "locale-setup.h"

#include "log.h"

#include "macro.h"

#include "manager.h"

#include "manager-dump.h"

#include "manager-serialize.h"

#include "memory-util.h"

#include "mkdir-label.h"

#include "parse-util.h"

#include "path-lookup.h"

#include "path-util.h"

#include "process-util.h"

#include "ratelimit.h"

#include "rlimit-util.h"

#include "rm-rf.h"

#include "selinux-util.h"

#include "signal-util.h"

#include "socket-util.h"

#include "special.h"

#include "stat-util.h"

#include "string-table.h"

#include "string-util.h"

#include "strv.h"

#include "strxcpyx.h"

#include "sysctl-util.h"

#include "syslog-util.h"

#include "terminal-util.h"

#include "time-util.h"

#include "transaction.h"

#include "uid-range.h"

#include "umask-util.h"

#include "unit-name.h"

#include "user-util.h"

#include "virt.h"

#include "watchdog.h"

#define NOTIFY_RCVBUF_SIZE (8*1024*1024)

#define CGROUPS_AGENT_RCVBUF_SIZE (8*1024*1024)

#define JOBS_IN_PROGRESS_WAIT_USEC (2*USEC_PER_SEC)

#define JOBS_IN_PROGRESS_QUIET_WAIT_USEC (25*USEC_PER_SEC)

#define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)

#define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3

#define MANAGER_BUS_BUSY_THRESHOLD 1024LU

#define MANAGER_BUS_MESSAGE_BUDGET 100U

static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);

static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);

static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);

static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);

static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);

static int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);

static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);

static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);

static int manager_dispatch_sigchld(sd_event_source *source, void *userdata);

static int manager_dispatch_timezone_change(sd_event_source *source, const struct inotify_event *event, void *userdata);

static int manager_run_environment_generators(Manager *m);

static int manager_run_generators(Manager *m);

static void manager_vacuum(Manager *m);

static usec_t manager_watch_jobs_next_time(Manager *m) {

usec_t timeout;

if (MANAGER_IS_USER(m))

/* Let the user manager without a timeout show status quickly, so the system manager can make

timeout = JOBS_IN_PROGRESS_WAIT_USEC * 2 / 3;

else if (show_status_on(m->show_status))

/* When status is on, just use the usual timeout. */

timeout = JOBS_IN_PROGRESS_WAIT_USEC;

else

timeout = JOBS_IN_PROGRESS_QUIET_WAIT_USEC;

return usec_add(now(CLOCK_MONOTONIC), timeout);

}

static void manager_watch_jobs_in_progress(Manager *m) {

usec_t next;

int r;

assert(m);

/* We do not want to show the cylon animation if the user

if (!manager_is_confirm_spawn_disabled(m))

return;

if (m->jobs_in_progress_event_source)

return;

next = manager_watch_jobs_next_time(m);

r = sd_event_add_time(

m->event,

&m->jobs_in_progress_event_source,

CLOCK_MONOTONIC,

next, 0,

manager_dispatch_jobs_in_progress, m);

if (r < 0)

return;

(void) sd_event_source_set_description(m->jobs_in_progress_event_source, "manager-jobs-in-progress");

}

#define CYLON_BUFFER_EXTRA (2*STRLEN(ANSI_RED) + STRLEN(ANSI_HIGHLIGHT_RED) + 2*STRLEN(ANSI_NORMAL))

static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {

char *p = buffer;

assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);

assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */

if (pos > 1) {

if (pos > 2)

p = mempset(p, ' ', pos-2);

if (log_get_show_color())

p = stpcpy(p, ANSI_RED);

*p++ = '*';

}

if (pos > 0 && pos <= width) {

if (log_get_show_color())

p = stpcpy(p, ANSI_HIGHLIGHT_RED);

*p++ = '*';

}

if (log_get_show_color())

p = stpcpy(p, ANSI_NORMAL);

if (pos < width) {

if (log_get_show_color())

p = stpcpy(p, ANSI_RED);

*p++ = '*';

if (pos < width-1)

p = mempset(p, ' ', width-1-pos);

if (log_get_show_color())

strcpy(p, ANSI_NORMAL);

}

}

static void manager_flip_auto_status(Manager *m, bool enable, const char *reason) {

assert(m);

if (enable) {

if (m->show_status == SHOW_STATUS_AUTO)

manager_set_show_status(m, SHOW_STATUS_TEMPORARY, reason);

} else {

if (m->show_status == SHOW_STATUS_TEMPORARY)

manager_set_show_status(m, SHOW_STATUS_AUTO, reason);

}

}

static void manager_print_jobs_in_progress(Manager *m) {

Job *j;

unsigned counter = 0, print_nr;

char cylon[6 + CYLON_BUFFER_EXTRA + 1];

unsigned cylon_pos;

uint64_t x;

assert(m);

assert(m->n_running_jobs > 0);

manager_flip_auto_status(m, true, "delay");

print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;

HASHMAP_FOREACH(j, m->jobs)

if (j->state == JOB_RUNNING && counter++ == print_nr)

break;

/* m->n_running_jobs must be consistent with the contents of m->jobs,

assert(counter == print_nr + 1);

assert(j);

cylon_pos = m->jobs_in_progress_iteration % 14;

if (cylon_pos >= 8)

cylon_pos = 14 - cylon_pos;

draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);

m->jobs_in_progress_iteration++;

char job_of_n[STRLEN("( of ) ") + DECIMAL_STR_MAX(unsigned)*2] = "";

if (m->n_running_jobs > 1)

xsprintf(job_of_n, "(%u of %u) ", counter, m->n_running_jobs);

bool have_timeout = job_get_timeout(j, &x) > 0;

/* We want to use enough information for the user to identify previous lines talking about the same

const char *ident = unit_status_string(j->unit, NULL);

const char *time = FORMAT_TIMESPAN(now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);

const char *limit = have_timeout ? FORMAT_TIMESPAN(x - j->begin_usec, 1*USEC_PER_SEC) : "no limit";

if (m->status_unit_format == STATUS_UNIT_FORMAT_DESCRIPTION)

/* When using 'Description', we effectively don't have enough space to show the nested status

manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,

"%sA %s job is running for %s (%s / %s)",

job_of_n,

job_type_to_string(j->type),

ident,

time, limit);

else {

const char *status_text = unit_status_text(j->unit);

manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,

"%sJob %s/%s running (%s / %s)%s%s",

job_of_n,

ident,

job_type_to_string(j->type),

time, limit,

status_text ? ": " : "",

strempty(status_text));

}

sd_notifyf(false,

"STATUS=%sUser job %s/%s running (%s / %s)...",

job_of_n,

ident,

job_type_to_string(j->type),

time, limit);

m->status_ready = false;

}

static int have_ask_password(void) {

_cleanup_closedir_ DIR *dir = NULL;

dir = opendir("/run/systemd/ask-password");

if (!dir) {

if (errno == ENOENT)

return false;

else

return -errno;

}

FOREACH_DIRENT_ALL(de, dir, return -errno)

if (startswith(de->d_name, "ask."))

return true;

return false;

}

static int manager_dispatch_ask_password_fd(sd_event_source *source,

int fd, uint32_t revents, void *userdata) {

Manager *m = userdata;

assert(m);

(void) flush_fd(fd);

m->have_ask_password = have_ask_password();

if (m->have_ask_password < 0)

/* Log error but continue. Negative have_ask_password

log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");

return 0;

}

static void manager_close_ask_password(Manager *m) {

assert(m);

m->ask_password_event_source = sd_event_source_disable_unref(m->ask_password_event_source);

m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);

m->have_ask_password = -EINVAL;

}

static int manager_check_ask_password(Manager *m) {

int r;

assert(m);

if (!m->ask_password_event_source) {

assert(m->ask_password_inotify_fd < 0);

(void) mkdir_p_label("/run/systemd/ask-password", 0755);

m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);

if (m->ask_password_inotify_fd < 0)

return log_error_errno(errno, "Failed to create inotify object: %m");

r = inotify_add_watch_and_warn(m->ask_password_inotify_fd,

"/run/systemd/ask-password",

IN_CREATE|IN_DELETE|IN_MOVE);

if (r < 0) {

manager_close_ask_password(m);

return r;

}

r = sd_event_add_io(m->event, &m->ask_password_event_source,

m->ask_password_inotify_fd, EPOLLIN,

manager_dispatch_ask_password_fd, m);

if (r < 0) {

log_error_errno(r, "Failed to add event source for /run/systemd/ask-password: %m");

manager_close_ask_password(m);

return r;

}

(void) sd_event_source_set_description(m->ask_password_event_source, "manager-ask-password");

/* Queries might have been added meanwhile... */

manager_dispatch_ask_password_fd(m->ask_password_event_source,

m->ask_password_inotify_fd, EPOLLIN, m);

}

return m->have_ask_password;

}

static int manager_watch_idle_pipe(Manager *m) {

int r;

assert(m);

if (m->idle_pipe_event_source)

return 0;

if (m->idle_pipe[2] < 0)

return 0;

r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);

if (r < 0)

return log_error_errno(r, "Failed to watch idle pipe: %m");

(void) sd_event_source_set_description(m->idle_pipe_event_source, "manager-idle-pipe");

return 0;

}

static void manager_close_idle_pipe(Manager *m) {

assert(m);

m->idle_pipe_event_source = sd_event_source_disable_unref(m->idle_pipe_event_source);

safe_close_pair(m->idle_pipe);

safe_close_pair(m->idle_pipe + 2);

}

static int manager_setup_time_change(Manager *m) {

int r;

assert(m);

if (MANAGER_IS_TEST_RUN(m))

return 0;

m->time_change_event_source = sd_event_source_disable_unref(m->time_change_event_source);

r = event_add_time_change(m->event, &m->time_change_event_source, manager_dispatch_time_change_fd, m);

if (r < 0)

return log_error_errno(r, "Failed to create time change event source: %m");

/* Schedule this slightly earlier than the .timer event sources */

r = sd_event_source_set_priority(m->time_change_event_source, SD_EVENT_PRIORITY_NORMAL-1);

if (r < 0)

return log_error_errno(r, "Failed to set priority of time change event sources: %m");

log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");

return 0;

}

static int manager_read_timezone_stat(Manager *m) {

struct stat st;

bool changed;

assert(m);

/* Read the current stat() data of /etc/localtime so that we detect changes */

if (lstat("/etc/localtime", &st) < 0) {

log_debug_errno(errno, "Failed to stat /etc/localtime, ignoring: %m");

changed = m->etc_localtime_accessible;

m->etc_localtime_accessible = false;

} else {

usec_t k;

k = timespec_load(&st.st_mtim);

changed = !m->etc_localtime_accessible || k != m->etc_localtime_mtime;

m->etc_localtime_mtime = k;

m->etc_localtime_accessible = true;

}

return changed;

}

static int manager_setup_timezone_change(Manager *m) {

_cleanup_(sd_event_source_unrefp) sd_event_source *new_event = NULL;

int r;

assert(m);

if (MANAGER_IS_TEST_RUN(m))

return 0;

/* We watch /etc/localtime for three events: change of the link count (which might mean removal from /etc even

r = sd_event_add_inotify(m->event, &new_event, "/etc/localtime",

IN_ATTRIB|IN_MOVE_SELF|IN_CLOSE_WRITE|IN_DONT_FOLLOW, manager_dispatch_timezone_change, m);

if (r == -ENOENT) {

/* If the file doesn't exist yet, subscribe to /etc instead, and wait until it is created either by

log_debug_errno(r, "/etc/localtime doesn't exist yet, watching /etc instead.");

r = sd_event_add_inotify(m->event, &new_event, "/etc",

IN_CREATE|IN_MOVED_TO|IN_ONLYDIR, manager_dispatch_timezone_change, m);

}

if (r < 0)

return log_error_errno(r, "Failed to create timezone change event source: %m");

/* Schedule this slightly earlier than the .timer event sources */

r = sd_event_source_set_priority(new_event, SD_EVENT_PRIORITY_NORMAL-1);

if (r < 0)

return log_error_errno(r, "Failed to set priority of timezone change event sources: %m");

sd_event_source_unref(m->timezone_change_event_source);

m->timezone_change_event_source = TAKE_PTR(new_event);

return 0;

}

static int enable_special_signals(Manager *m) {

_cleanup_close_ int fd = -1;

assert(m);

if (MANAGER_IS_TEST_RUN(m))

return 0;

/* Enable that we get SIGINT on control-alt-del. In containers

if (reboot(RB_DISABLE_CAD) < 0 && !IN_SET(errno, EPERM, EINVAL))

log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");

fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);

if (fd < 0) {

/* Support systems without virtual console */

if (fd != -ENOENT)

log_warning_errno(errno, "Failed to open /dev/tty0: %m");

} else {

/* Enable that we get SIGWINCH on kbrequest */

if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)

log_warning_errno(errno, "Failed to enable kbrequest handling: %m");

}

return 0;

}

#define RTSIG_IF_AVAILABLE(signum) (signum <= SIGRTMAX ? signum : -1)

static int manager_setup_signals(Manager *m) {

struct sigaction sa = {

.sa_handler = SIG_DFL,

.sa_flags = SA_NOCLDSTOP|SA_RESTART,

};

sigset_t mask;

int r;

assert(m);

assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);

/* We make liberal use of realtime signals here. On

assert_se(sigemptyset(&mask) == 0);

sigset_add_many(&mask,

SIGCHLD, /* Child died */

SIGTERM, /* Reexecute daemon */

SIGHUP, /* Reload configuration */

SIGUSR1, /* systemd: reconnect to D-Bus */

SIGUSR2, /* systemd: dump status */

SIGINT, /* Kernel sends us this on control-alt-del */

SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */

SIGPWR, /* Some kernel drivers and upsd send us this on power failure */

SIGRTMIN+0, /* systemd: start default.target */

SIGRTMIN+1, /* systemd: isolate rescue.target */

SIGRTMIN+2, /* systemd: isolate emergency.target */

SIGRTMIN+3, /* systemd: start halt.target */

SIGRTMIN+4, /* systemd: start poweroff.target */

SIGRTMIN+5, /* systemd: start reboot.target */

SIGRTMIN+6, /* systemd: start kexec.target */

/* ... space for more special targets ... */

SIGRTMIN+13, /* systemd: Immediate halt */

SIGRTMIN+14, /* systemd: Immediate poweroff */

SIGRTMIN+15, /* systemd: Immediate reboot */

SIGRTMIN+16, /* systemd: Immediate kexec */

/* ... space for more immediate system state changes ... */

SIGRTMIN+20, /* systemd: enable status messages */

SIGRTMIN+21, /* systemd: disable status messages */

SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */

SIGRTMIN+23, /* systemd: set log level to LOG_INFO */

SIGRTMIN+24, /* systemd: Immediate exit (--user only) */

SIGRTMIN+25, /* systemd: reexecute manager */

/* Apparently Linux on hppa had fewer RT signals until v3.18,

RTSIG_IF_AVAILABLE(SIGRTMIN+26), /* systemd: set log target to journal-or-kmsg */

RTSIG_IF_AVAILABLE(SIGRTMIN+27), /* systemd: set log target to console */

RTSIG_IF_AVAILABLE(SIGRTMIN+28), /* systemd: set log target to kmsg */

RTSIG_IF_AVAILABLE(SIGRTMIN+29), /* systemd: set log target to syslog-or-kmsg (obsolete) */

/* ... one free signal here SIGRTMIN+30 ... */

-1);

assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);

m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);

if (m->signal_fd < 0)

return -errno;

r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);

if (r < 0)

return r;

(void) sd_event_source_set_description(m->signal_event_source, "manager-signal");

/* Process signals a bit earlier than the rest of things, but later than notify_fd processing, so that the

r = sd_event_source_set_priority(m->signal_event_source, SD_EVENT_PRIORITY_NORMAL-6);

if (r < 0)

return r;

if (MANAGER_IS_SYSTEM(m))

return enable_special_signals(m);

return 0;

}

static char** sanitize_environment(char **l) {

/* Let's remove some environment variables that we need ourselves to communicate with our clients */

strv_env_unset_many(

l,

"CACHE_DIRECTORY",

"CONFIGURATION_DIRECTORY",

"CREDENTIALS_DIRECTORY",

"EXIT_CODE",

"EXIT_STATUS",

"INVOCATION_ID",

"JOURNAL_STREAM",

"LISTEN_FDNAMES",

"LISTEN_FDS",

"LISTEN_PID",

"LOGS_DIRECTORY",

"MAINPID",

"MANAGERPID",

"NOTIFY_SOCKET",

"PIDFILE",

"REMOTE_ADDR",

"REMOTE_PORT",

"RUNTIME_DIRECTORY",

"SERVICE_RESULT",

"STATE_DIRECTORY",

"WATCHDOG_PID",

"WATCHDOG_USEC",

NULL);

/* Let's order the environment alphabetically, just to make it pretty */

return strv_sort(l);

}

int manager_default_environment(Manager *m) {

int r;

assert(m);

m->transient_environment = strv_free(m->transient_environment);

if (MANAGER_IS_SYSTEM(m)) {

/* The system manager always starts with a clean

m->transient_environment = strv_new("PATH=" DEFAULT_PATH);

if (!m->transient_environment)

return log_oom();

/* Import locale variables LC_*= from configuration */

(void) locale_setup(&m->transient_environment);

} else {

/* The user manager passes its own environment along to its children, except for $PATH. */

m->transient_environment = strv_copy(environ);

if (!m->transient_environment)

return log_oom();

r = strv_env_replace_strdup(&m->transient_environment, "PATH=" DEFAULT_USER_PATH);

if (r < 0)

return log_oom();

}

sanitize_environment(m->transient_environment);

return 0;

}

static int manager_setup_prefix(Manager *m) {

struct table_entry {

uint64_t type;

const char *suffix;

};

static const struct table_entry paths_system[_EXEC_DIRECTORY_TYPE_MAX] = {

[EXEC_DIRECTORY_RUNTIME] = { SD_PATH_SYSTEM_RUNTIME, NULL },

[EXEC_DIRECTORY_STATE] = { SD_PATH_SYSTEM_STATE_PRIVATE, NULL },

[EXEC_DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE, NULL },

[EXEC_DIRECTORY_LOGS] = { SD_PATH_SYSTEM_STATE_LOGS, NULL },

[EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_SYSTEM_CONFIGURATION, NULL },

};

static const struct table_entry paths_user[_EXEC_DIRECTORY_TYPE_MAX] = {

[EXEC_DIRECTORY_RUNTIME] = { SD_PATH_USER_RUNTIME, NULL },

[EXEC_DIRECTORY_STATE] = { SD_PATH_USER_CONFIGURATION, NULL },

[EXEC_DIRECTORY_CACHE] = { SD_PATH_USER_STATE_CACHE, NULL },

[EXEC_DIRECTORY_LOGS] = { SD_PATH_USER_CONFIGURATION, "log" },

[EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_USER_CONFIGURATION, NULL },

};

assert(m);

const struct table_entry *p = MANAGER_IS_SYSTEM(m) ? paths_system : paths_user;

int r;

for (ExecDirectoryType i = 0; i < _EXEC_DIRECTORY_TYPE_MAX; i++) {

r = sd_path_lookup(p[i].type, p[i].suffix, &m->prefix[i]);

if (r < 0)

return log_warning_errno(r, "Failed to lookup %s path: %m",

exec_directory_type_to_string(i));

}

return 0;

}

static void manager_free_unit_name_maps(Manager *m) {

m->unit_id_map = hashmap_free(m->unit_id_map);

m->unit_name_map = hashmap_free(m->unit_name_map);

m->unit_path_cache = set_free(m->unit_path_cache);

m->unit_cache_timestamp_hash = 0;

}

static int manager_setup_run_queue(Manager *m) {

int r;

assert(m);

assert(!m->run_queue_event_source);

r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);

if (r < 0)

return r;

r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);

if (r < 0)

return r;

r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);

if (r < 0)

return r;

(void) sd_event_source_set_description(m->run_queue_event_source, "manager-run-queue");

return 0;

}

static int manager_setup_sigchld_event_source(Manager *m) {

int r;

assert(m);

assert(!m->sigchld_event_source);

r = sd_event_add_defer(m->event, &m->sigchld_event_source, manager_dispatch_sigchld, m);

if (r < 0)

return r;

r = sd_event_source_set_priority(m->sigchld_event_source, SD_EVENT_PRIORITY_NORMAL-7);

if (r < 0)

return r;

r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_OFF);

if (r < 0)

return r;

(void) sd_event_source_set_description(m->sigchld_event_source, "manager-sigchld");

return 0;

}

int manager_new(LookupScope scope, ManagerTestRunFlags test_run_flags, Manager **_m) {

_cleanup_(manager_freep) Manager *m = NULL;

const char *e;

int r;

assert(_m);

assert(IN_SET(scope, LOOKUP_SCOPE_SYSTEM, LOOKUP_SCOPE_USER));

m = new(Manager, 1);

if (!m)

return -ENOMEM;

*m = (Manager) {

.unit_file_scope = scope,

.objective = _MANAGER_OBJECTIVE_INVALID,

.status_unit_format = STATUS_UNIT_FORMAT_DEFAULT,

.default_timer_accuracy_usec = USEC_PER_MINUTE,

.default_memory_accounting = MEMORY_ACCOUNTING_DEFAULT,

.default_tasks_accounting = true,

.default_tasks_max = TASKS_MAX_UNSET,

.default_timeout_start_usec = DEFAULT_TIMEOUT_USEC,

.default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC,

.default_restart_usec = DEFAULT_RESTART_USEC,

.original_log_level = -1,

.original_log_target = _LOG_TARGET_INVALID,

.watchdog_overridden[WATCHDOG_RUNTIME] = USEC_INFINITY,

.watchdog_overridden[WATCHDOG_REBOOT] = USEC_INFINITY,

.watchdog_overridden[WATCHDOG_KEXEC] = USEC_INFINITY,

.watchdog_overridden[WATCHDOG_PRETIMEOUT] = USEC_INFINITY,

.show_status_overridden = _SHOW_STATUS_INVALID,

.notify_fd = -1,

.cgroups_agent_fd = -1,

.signal_fd = -1,

.user_lookup_fds = { -1, -1 },

.private_listen_fd = -1,

.dev_autofs_fd = -1,

.cgroup_inotify_fd = -1,

.pin_cgroupfs_fd = -1,

.ask_password_inotify_fd = -1,

.idle_pipe = { -1, -1, -1, -1},

/* start as id #1, so that we can leave #0 around as "null-like" value */

.current_job_id = 1,

.have_ask_password = -EINVAL, /* we don't know */

.first_boot = -1,

.test_run_flags = test_run_flags,

.default_oom_policy = OOM_STOP,

};

#if ENABLE_EFI

if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)

boot_timestamps(m->timestamps + MANAGER_TIMESTAMP_USERSPACE,

m->timestamps + MANAGER_TIMESTAMP_FIRMWARE,

m->timestamps + MANAGER_TIMESTAMP_LOADER);

/* Prepare log fields we can use for structured logging */

if (MANAGER_IS_SYSTEM(m)) {

m->unit_log_field = "UNIT=";

m->unit_log_format_string = "UNIT=%s";

m->invocation_log_field = "INVOCATION_ID=";

m->invocation_log_format_string = "INVOCATION_ID=%s";

} else {

m->unit_log_field = "USER_UNIT=";

m->unit_log_format_string = "USER_UNIT=%s";

m->invocation_log_field = "USER_INVOCATION_ID=";

m->invocation_log_format_string = "USER_INVOCATION_ID=%s";

}

/* Reboot immediately if the user hits C-A-D more often than 7x per 2s */

m->ctrl_alt_del_ratelimit = (RateLimit) { .interval = 2 * USEC_PER_SEC, .burst = 7 };

r = manager_default_environment(m);

if (r < 0)

return r;

r = hashmap_ensure_allocated(&m->units, &string_hash_ops);

if (r < 0)

return r;

r = hashmap_ensure_allocated(&m->cgroup_unit, &path_hash_ops);

if (r < 0)

return r;

r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);

if (r < 0)

return r;

r = prioq_ensure_allocated(&m->run_queue, compare_job_priority);

if (r < 0)

return r;

r = manager_setup_prefix(m);

if (r < 0)

return r;

r = get_credentials_dir(&e);

if (r >= 0) {

m->received_credentials = strdup(e);

if (!m->received_credentials)

return -ENOMEM;

}

r = sd_event_default(&m->event);

if (r < 0)

return r;

r = manager_setup_run_queue(m);

if (r < 0)

return r;

if (FLAGS_SET(test_run_flags, MANAGER_TEST_RUN_MINIMAL)) {

m->cgroup_root = strdup("");

if (!m->cgroup_root)

return -ENOMEM;

} else {

r = manager_setup_signals(m);

if (r < 0)

return r;

r = manager_setup_cgroup(m);

if (r < 0)

return r;

r = manager_setup_time_change(m);

if (r < 0)

return r;

r = manager_read_timezone_stat(m);

if (r < 0)

return r;

(void) manager_setup_timezone_change(m);

r = manager_setup_sigchld_event_source(m);

if (r < 0)

return r;

#if HAVE_LIBBPF

if (MANAGER_IS_SYSTEM(m) && lsm_bpf_supported()) {

r = lsm_bpf_setup(m);

if (r < 0)

log_warning_errno(r, "Failed to setup LSM BPF, ignoring: %m");

}

}

if (test_run_flags == 0) {

if (MANAGER_IS_SYSTEM(m))

r = mkdir_label("/run/systemd/units", 0755);

else {

_cleanup_free_ char *units_path = NULL;

r = xdg_user_runtime_dir(&units_path, "/systemd/units");

if (r < 0)

return r;

r = mkdir_p_label(units_path, 0755);

}

if (r < 0 && r != -EEXIST)

return r;

}

m->taint_usr =

!in_initrd() &&

dir_is_empty("/usr") > 0;

/* Note that we do not set up the notify fd here. We do that after deserialization,

*_m = TAKE_PTR(m);

return 0;

}

static int manager_setup_notify(Manager *m) {

int r;

if (MANAGER_IS_TEST_RUN(m))

return 0;

if (m->notify_fd < 0) {

_cleanup_close_ int fd = -1;

union sockaddr_union sa;

socklen_t sa_len;

/* First free all secondary fields */

m->notify_socket = mfree(m->notify_socket);

m->notify_event_source = sd_event_source_disable_unref(m->notify_event_source);

fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);

if (fd < 0)

return log_error_errno(errno, "Failed to allocate notification socket: %m");

fd_inc_rcvbuf(fd, NOTIFY_RCVBUF_SIZE);

m->notify_socket = path_join(m->prefix[EXEC_DIRECTORY_RUNTIME], "systemd/notify");

if (!m->notify_socket)

return log_oom();

r = sockaddr_un_set_path(&sa.un, m->notify_socket);

if (r < 0)

return log_error_errno(r, "Notify socket '%s' not valid for AF_UNIX socket address, refusing.",

m->notify_socket);

sa_len = r;

(void) mkdir_parents_label(m->notify_socket, 0755);

(void) sockaddr_un_unlink(&sa.un);

r = mac_selinux_bind(fd, &sa.sa, sa_len);

if (r < 0)

return log_error_errno(r, "bind(%s) failed: %m", m->notify_socket);