HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/core/manager.c
Git blob: e0aa34f4c11534f81d2a7e0a2a8c2aa218451eb3
Lines 4001–5000 of 5,689
exec_shared_runtime_vacuum(m);
dynamic_user_vacuum(m, false);
m->uid_refs = hashmap_free(m->uid_refs);
m->gid_refs = hashmap_free(m->gid_refs);
(void) manager_run_environment_generators(m);
(void) manager_run_generators(m);
/* We flushed out generated files, for which we don't watch mtime, so we should flush the old map. */
manager_free_unit_name_maps(m);
m->unit_file_state_outdated = false;
/* First, enumerate what we can from kernel and suchlike */
manager_enumerate_perpetual(m);
manager_enumerate(m);
/* Second, deserialize our stored data */
saved_subscribed_as_strv = TAKE_PTR(m->subscribed_as_strv);
saved_deserialized_bus_id = m->deserialized_bus_id;
m->deserialized_bus_id = SD_ID128_NULL;
r = manager_deserialize(m, f, fds);
if (r < 0)
log_warning_errno(r, "Deserialization failed, proceeding anyway: %m");
/* We don't need the serialization anymore */
f = safe_fclose(f);
/* Re-register notify_fd as event source, and set up other sockets/communication channels we might need */
(void) manager_setup_notify(m);
(void) manager_setup_user_lookup_fd(m);
(void) manager_setup_handoff_timestamp_fd(m);
(void) manager_setup_pidref_transport_fd(m);
/* Discard the bus track information produced by this reload, since the bus stays connected. Preserve
* any validation state that was already pending before the reload, so its asynchronous GetId reply can
* still consume it when we return to the event loop. */
m->subscribed_as_strv = strv_free(m->subscribed_as_strv);
m->subscribed_as_strv = TAKE_PTR(saved_subscribed_as_strv);
m->deserialized_bus_id = saved_deserialized_bus_id;
/* Third, fire things up! */
manager_coldplug(m);
/* Clean up runtime objects no longer referenced */
manager_vacuum(m);
/* Consider the reload process complete now. */
assert(m->n_reloading > 0);
m->n_reloading--;
manager_ready(m);
m->send_reloading_done = true;
return 0;
}
void manager_reset_failed(Manager *m) {
Unit *u;
assert(m);
HASHMAP_FOREACH(u, m->units)
unit_reset_failed(u);
m->transactions_with_cycle = set_free(m->transactions_with_cycle);
}
bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
Unit *u;
assert(m);
assert(name);
/* Returns true if the unit is inactive or going down */
u = manager_get_unit(m, name);
if (!u)
return true;
return unit_inactive_or_pending(u);
}
static void log_taint_string(Manager *m) {
assert(m);
if (MANAGER_IS_USER(m) || m->taint_logged)
return;
m->taint_logged = true; /* only check for taint once */
_cleanup_free_ char *taint = taint_string();
if (isempty(taint))
return;
log_struct(LOG_NOTICE,
LOG_MESSAGE("System is tainted: %s", taint),
LOG_ITEM("TAINT=%s", taint),
LOG_MESSAGE_ID(SD_MESSAGE_TAINTED_STR));
}
static void manager_notify_finished(Manager *m) {
usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
if (MANAGER_IS_TEST_RUN(m))
return;
if (MANAGER_IS_SYSTEM(m) && m->soft_reboots_count > 0) {
/* The soft-reboot case, where we only report data for the last reboot */
firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
total_usec = userspace_usec = usec_sub_unsigned(m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic,
m->timestamps[MANAGER_TIMESTAMP_PREVIOUS_SHUTDOWN_START].monotonic);
log_struct(LOG_INFO,
LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED_STR),
LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Soft-reboot finished in %s, counter is now at %u.",
FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC),
m->soft_reboots_count));
} else if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0) {
char buf[FORMAT_TIMESPAN_MAX + STRLEN(" (firmware) + ") + FORMAT_TIMESPAN_MAX + STRLEN(" (loader) + ")]
= {};
char *p = buf;
size_t size = sizeof buf;
/* Note that MANAGER_TIMESTAMP_KERNEL's monotonic value is always at 0, and
* MANAGER_TIMESTAMP_FIRMWARE's and MANAGER_TIMESTAMP_LOADER's monotonic value should be considered
* negative values. */
firmware_usec = m->timestamps[MANAGER_TIMESTAMP_FIRMWARE].monotonic - m->timestamps[MANAGER_TIMESTAMP_LOADER].monotonic;
loader_usec = m->timestamps[MANAGER_TIMESTAMP_LOADER].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
userspace_usec = m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic - m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
total_usec = m->timestamps[MANAGER_TIMESTAMP_FIRMWARE].monotonic + m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic;
if (firmware_usec > 0)
size = strpcpyf(&p, size, "%s (firmware) + ", FORMAT_TIMESPAN(firmware_usec, USEC_PER_MSEC));
if (loader_usec > 0)
size = strpcpyf(&p, size, "%s (loader) + ", FORMAT_TIMESPAN(loader_usec, USEC_PER_MSEC));
if (dual_timestamp_is_set(&m->timestamps[MANAGER_TIMESTAMP_INITRD])) {
/* The initrd case on bare-metal */
kernel_usec = m->timestamps[MANAGER_TIMESTAMP_INITRD].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
initrd_usec = m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic - m->timestamps[MANAGER_TIMESTAMP_INITRD].monotonic;
log_struct(LOG_INFO,
LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED_STR),
LOG_ITEM("KERNEL_USEC="USEC_FMT, kernel_usec),
LOG_ITEM("INITRD_USEC="USEC_FMT, initrd_usec),
LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (initrd) + %s (userspace) = %s.",
buf,
FORMAT_TIMESPAN(kernel_usec, USEC_PER_MSEC),
FORMAT_TIMESPAN(initrd_usec, USEC_PER_MSEC),
FORMAT_TIMESPAN(userspace_usec, USEC_PER_MSEC),
FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC)));
} else {
/* The initrd-less case on bare-metal */
kernel_usec = m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
initrd_usec = 0;
log_struct(LOG_INFO,
LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED_STR),
LOG_ITEM("KERNEL_USEC="USEC_FMT, kernel_usec),
LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (userspace) = %s.",
buf,
FORMAT_TIMESPAN(kernel_usec, USEC_PER_MSEC),
FORMAT_TIMESPAN(userspace_usec, USEC_PER_MSEC),
FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC)));
}
} else {
/* The container and --user case */
firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
total_usec = userspace_usec = m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic - m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
log_struct(LOG_INFO,
LOG_MESSAGE_ID(SD_MESSAGE_USER_STARTUP_FINISHED_STR),
LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Startup finished in %s.",
FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC)));
}
bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
watchdog_report_if_missing();
log_taint_string(m);
}
static void manager_send_ready_on_basic_target(Manager *m) {
int r;
assert(m);
/* We send READY=1 on reaching basic.target only when running in --user mode. */
if (!MANAGER_IS_USER(m) || m->ready_sent)
return;
r = sd_notify(/* unset_environment= */ false,
"READY=1\n"
"STATUS=Reached " SPECIAL_BASIC_TARGET ".");
if (r < 0)
log_warning_errno(r, "Failed to send readiness notification, ignoring: %m");
m->ready_sent = true;
m->status_ready = false;
}
static void manager_send_ready_on_idle(Manager *m) {
int r;
assert(m);
/* Skip the notification if nothing changed. */
if (m->ready_sent && m->status_ready)
return;
/* Note that for user managers, we might have already sent READY=1 in manager_send_ready_user_scope().
* But we still need to flush STATUS=. The second READY=1 will be treated as a noop so it doesn't
* hurt to send it twice. */
r = sd_notify(/* unset_environment= */ false,
"READY=1\n"
"STATUS=Ready.");
if (r < 0)
log_full_errno(m->ready_sent ? LOG_DEBUG : LOG_WARNING, r,
"Failed to send readiness notification, ignoring: %m");
m->ready_sent = m->status_ready = true;
}
static void manager_check_basic_target(Manager *m) {
Unit *u;
assert(m);
/* Small shortcut */
if (m->ready_sent && m->taint_logged)
return;
u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
return;
/* For user managers, send out READY=1 as soon as we reach basic.target */
manager_send_ready_on_basic_target(m);
/* Log the taint string as soon as we reach basic.target */
log_taint_string(m);
}
void manager_check_finished(Manager *m) {
assert(m);
if (MANAGER_IS_RELOADING(m))
return;
/* Verify that we have entered the event loop already, and not left it again. */
if (!MANAGER_IS_RUNNING(m))
return;
manager_check_basic_target(m);
if (!hashmap_isempty(m->jobs)) {
if (m->jobs_in_progress_event_source)
/* Ignore any failure, this is only for feedback */
(void) sd_event_source_set_time(m->jobs_in_progress_event_source,
manager_watch_jobs_next_time(m));
return;
}
/* The jobs hashmap tends to grow a lot during boot, and then it's not reused until shutdown. Let's
kill the hashmap if it is relatively large. */
if (hashmap_buckets(m->jobs) > hashmap_size(m->units) / 10)
m->jobs = hashmap_free(m->jobs);
manager_send_ready_on_idle(m);
/* Notify Type=idle units that we are done now */
manager_close_idle_pipe(m);
if (MANAGER_IS_FINISHED(m))
return;
manager_flip_auto_status(m, false, "boot finished");
/* Turn off confirm spawn now */
m->confirm_spawn = NULL;
/* No need to update ask password status when we're going non-interactive */
manager_close_ask_password(m);
/* This is no longer the first boot */
manager_set_first_boot(m, false);
dual_timestamp_now(m->timestamps + MANAGER_TIMESTAMP_FINISH);
manager_notify_finished(m);
manager_invalidate_startup_units(m);
}
void manager_send_reloading(Manager *m) {
assert(m);
/* Let whoever invoked us know that we are now reloading */
(void) notify_reloading_full(/* status= */ NULL);
/* And ensure that we'll send READY=1 again as soon as we are ready again */
m->ready_sent = false;
}
static bool generator_path_any(char * const *paths) {
/* Optimize by skipping the whole process by not creating output directories if no generators are found. */
STRV_FOREACH(i, paths) {
if (access(*i, F_OK) >= 0)
return true;
if (errno != ENOENT)
log_warning_errno(errno, "Failed to check if generator dir '%s' exists, assuming not: %m", *i);
}
return false;
}
static int manager_run_environment_generators(Manager *m) {
_cleanup_strv_free_ char **paths = NULL;
int r;
assert(m);
if (MANAGER_IS_TEST_RUN(m) && !(m->test_run_flags & MANAGER_TEST_RUN_ENV_GENERATORS))
return 0;
r = env_generator_binary_paths(m->runtime_scope, &paths);
if (r < 0)
return log_error_errno(r, "Failed to initialize environment generator search paths: %m");
if (!generator_path_any(paths))
return 0;
char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
void *args[_STDOUT_CONSUME_MAX] = {
[STDOUT_GENERATE] = &tmp,
[STDOUT_COLLECT] = &tmp,
[STDOUT_CONSUME] = &m->transient_environment,
};
WITH_UMASK(0022)
r = execute_directories(
"environment-generators",
(const char* const*) paths,
DEFAULT_TIMEOUT_USEC,
gather_environment,
args,
/* argv[]= */ NULL,
m->transient_environment,
EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS | EXEC_DIR_SET_SYSTEMD_EXEC_PID);
return r;
}
static int build_generator_environment(Manager *m, char ***ret) {
_cleanup_strv_free_ char **nl = NULL;
Virtualization v;
ConfidentialVirtualization cv;
int r;
assert(m);
assert(ret);
/* Generators oftentimes want to know some basic facts about the environment they run in, in order to
* adjust generated units to that. Let's pass down some bits of information that are easy for us to
* determine (but a bit harder for generator scripts to determine), as environment variables. */
nl = strv_copy(m->transient_environment);
if (!nl)
return -ENOMEM;
r = strv_env_assign(&nl, "SYSTEMD_SCOPE", runtime_scope_to_string(m->runtime_scope));
if (r < 0)
return r;
if (MANAGER_IS_SYSTEM(m)) {
/* Note that $SYSTEMD_IN_INITRD may be used to override the initrd detection in much of our
* codebase. This is hence more than purely informational. It will shortcut detection of the
* initrd state if generators invoke our own tools. But that's OK, as it would come to the
* same results (hopefully). */
r = strv_env_assign(&nl, "SYSTEMD_IN_INITRD", one_zero(in_initrd()));
if (r < 0)
return r;
if (m->soft_reboots_count > 0) {
r = strv_env_assignf(&nl, "SYSTEMD_SOFT_REBOOTS_COUNT", "%u", m->soft_reboots_count);
if (r < 0)
return r;
}
if (m->first_boot >= 0) {
r = strv_env_assign(&nl, "SYSTEMD_FIRST_BOOT", one_zero(m->first_boot));
if (r < 0)
return r;
}
}
v = detect_virtualization();
if (v < 0)
log_debug_errno(v, "Failed to detect virtualization, ignoring: %m");
else if (v > 0) {
const char *s;
s = strjoina(VIRTUALIZATION_IS_VM(v) ? "vm:" :
VIRTUALIZATION_IS_CONTAINER(v) ? "container:" : ":",
virtualization_to_string(v));
r = strv_env_assign(&nl, "SYSTEMD_VIRTUALIZATION", s);
if (r < 0)
return r;
}
cv = detect_confidential_virtualization();
if (cv < 0)
log_debug_errno(cv, "Failed to detect confidential virtualization, ignoring: %m");
else if (cv > 0) {
r = strv_env_assign(&nl, "SYSTEMD_CONFIDENTIAL_VIRTUALIZATION", confidential_virtualization_to_string(cv));
if (r < 0)
return r;
}
r = strv_env_assign(&nl, "SYSTEMD_ARCHITECTURE", architecture_to_string(uname_architecture()));
if (r < 0)
return r;
*ret = TAKE_PTR(nl);
return 0;
}
static int manager_execute_generators(Manager *m, char * const *paths, bool remount_ro) {
_cleanup_strv_free_ char **ge = NULL;
int r;
assert(m);
r = build_generator_environment(m, &ge);
if (r < 0)
return log_error_errno(r, "Failed to build generator environment: %m");
if (remount_ro) {
/* Remount most of the filesystem tree read-only. We leave /sys/ as-is, because our code
* checks whether it is read-only to detect containerized execution environments. We leave
* /run/ as-is too, because that's where our output goes. We also leave /proc/ and /dev/shm/
* because they're API, and /tmp/ that safe_fork() mounted for us.
*/
r = bind_remount_recursive("/", MS_RDONLY, MS_RDONLY,
STRV_MAKE("/sys", "/run", "/proc", "/dev/shm", "/tmp"));
if (r < 0)
log_warning_errno(r, "Read-only bind remount failed, ignoring: %m");
}
const char *argv[] = {
NULL, /* Leave this empty, execute_directory() will fill something in */
m->lookup_paths.generator,
m->lookup_paths.generator_early,
m->lookup_paths.generator_late,
NULL,
};
BLOCK_WITH_UMASK(0022);
return execute_directories(
"generators",
(const char* const*) paths,
DEFAULT_TIMEOUT_USEC,
/* callbacks= */ NULL, /* callback_args= */ NULL,
(char**) argv,
ge,
EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS | EXEC_DIR_SET_SYSTEMD_EXEC_PID | EXEC_DIR_WARN_WORLD_WRITABLE);
}
static int manager_run_generators(Manager *m) {
ForkFlags flags = FORK_RESET_SIGNALS | FORK_WAIT | FORK_NEW_MOUNTNS | FORK_MOUNTNS_SLAVE;
_cleanup_strv_free_ char **paths = NULL;
int r;
assert(m);
if (MANAGER_IS_TEST_RUN(m) && !(m->test_run_flags & MANAGER_TEST_RUN_GENERATORS))
return 0;
r = generator_binary_paths(m->runtime_scope, &paths);
if (r < 0)
return log_error_errno(r, "Failed to initialize generator search paths: %m");
if (!generator_path_any(paths))
return 0;
r = lookup_paths_mkdir_generator(&m->lookup_paths);
if (r < 0) {
log_error_errno(r, "Failed to create generator directories: %m");
goto finish;
}
/* If we are the system manager, we fork and invoke the generators in a sanitized mount namespace. If
* we are the user manager, let's just execute the generators directly. We might not have the
* necessary privileges, and the system manager has already mounted /tmp/ and everything else for us.
*/
if (MANAGER_IS_USER(m)) {
r = manager_execute_generators(m, paths, /* remount_ro= */ false);
goto finish;
}
/* On some systems /tmp/ doesn't exist, and on some other systems we cannot create it at all. Avoid
* trying to mount a private tmpfs on it as there's no one size fits all. */
if (is_dir("/tmp", /* follow= */ false) > 0 && !MANAGER_IS_TEST_RUN(m))
flags |= FORK_PRIVATE_TMP;
r = pidref_safe_fork("(sd-gens)", flags, /* ret= */ NULL);
if (r == 0) {
r = manager_execute_generators(m, paths, /* remount_ro= */ true);
_exit(r >= 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
if (r < 0) {
if (!ERRNO_IS_PRIVILEGE(r) && r != -EINVAL) {
log_error_errno(r, "Failed to fork off sandboxing environment for executing generators: %m");
goto finish;
}
/* Failed to fork with new mount namespace? Maybe, running in a container environment with
* seccomp or without capability.
*
* We also allow -EINVAL to allow running without CLONE_NEWNS.
*
* Also, when running on non-native userland architecture via systemd-nspawn and
* qemu-user-static QEMU-emulator, clone() with CLONE_NEWNS fails with EINVAL, see
* https://github.com/systemd/systemd/issues/28901.
*/
log_debug_errno(r,
"Failed to fork off sandboxing environment for executing generators. "
"Falling back to execute generators without sandboxing: %m");
r = manager_execute_generators(m, paths, /* remount_ro= */ false);
}
finish:
lookup_paths_trim_generator(&m->lookup_paths);
return r;
}
int manager_transient_environment_add(Manager *m, char **plus) {
char **a;
assert(m);
if (strv_isempty(plus))
return 0;
a = strv_env_merge(m->transient_environment, plus);
if (!a)
return log_oom();
sanitize_environment(a);
return strv_free_and_replace(m->transient_environment, a);
}
int manager_client_environment_modify(
Manager *m,
char **minus,
char **plus) {
char **a = NULL, **b = NULL, **l;
assert(m);
if (strv_isempty(minus) && strv_isempty(plus))
return 0;
l = m->client_environment;
if (!strv_isempty(minus)) {
a = strv_env_delete(l, 1, minus);
if (!a)
return -ENOMEM;
l = a;
}
if (!strv_isempty(plus)) {
b = strv_env_merge(l, plus);
if (!b) {
strv_free(a);
return -ENOMEM;
}
l = b;
}
if (m->client_environment != l)
strv_free(m->client_environment);
if (a != l)
strv_free(a);
if (b != l)
strv_free(b);
m->client_environment = sanitize_environment(l);
return 0;
}
int manager_get_effective_environment(Manager *m, char ***ret) {
char **l;
assert(m);
assert(ret);
l = strv_env_merge(m->transient_environment, m->client_environment);
if (!l)
return -ENOMEM;
*ret = l;
return 0;
}
int manager_set_unit_defaults(Manager *m, const UnitDefaults *defaults) {
_cleanup_free_ char *label = NULL;
struct rlimit *rlimit[_RLIMIT_MAX];
int r;
assert(m);
assert(defaults);
if (streq_ptr(defaults->smack_process_label, "/"))
label = NULL;
else {
const char *l = defaults->smack_process_label;
#ifdef SMACK_DEFAULT_PROCESS_LABEL
if (!l)
l = SMACK_DEFAULT_PROCESS_LABEL;
#endif
if (l) {
label = strdup(l);
if (!label)
return -ENOMEM;
} else
label = NULL;
}
r = rlimit_copy_all(rlimit, defaults->rlimit);
if (r < 0)
return r;
m->defaults.std_output = defaults->std_output;
m->defaults.std_error = defaults->std_error;
m->defaults.restart_usec = defaults->restart_usec;
m->defaults.timeout_start_usec = defaults->timeout_start_usec;
m->defaults.timeout_stop_usec = defaults->timeout_stop_usec;
m->defaults.timeout_abort_usec = defaults->timeout_abort_usec;
m->defaults.timeout_abort_set = defaults->timeout_abort_set;
m->defaults.device_timeout_usec = defaults->device_timeout_usec;
m->defaults.restrict_suid_sgid = defaults->restrict_suid_sgid;
m->defaults.start_limit = defaults->start_limit;
m->defaults.memory_accounting = defaults->memory_accounting;
m->defaults.io_accounting = defaults->io_accounting;
m->defaults.tasks_accounting = defaults->tasks_accounting;
m->defaults.ip_accounting = defaults->ip_accounting;
m->defaults.tasks_max = defaults->tasks_max;
m->defaults.timer_accuracy_usec = defaults->timer_accuracy_usec;
m->defaults.oom_policy = defaults->oom_policy;
m->defaults.oom_score_adjust = defaults->oom_score_adjust;
m->defaults.oom_score_adjust_set = defaults->oom_score_adjust_set;
memcpy(m->defaults.pressure, defaults->pressure, sizeof(m->defaults.pressure));
m->defaults.memory_zswap_writeback = defaults->memory_zswap_writeback;
free_and_replace(m->defaults.smack_process_label, label);
rlimit_free_all(m->defaults.rlimit);
memcpy(m->defaults.rlimit, rlimit, sizeof(struct rlimit*) * _RLIMIT_MAX);
return 0;
}
void manager_recheck_dbus(Manager *m) {
assert(m);
/* Connects to the bus if the dbus service and socket are running. If we are running in user mode
* this is all it does. In system mode we'll also connect to the system bus (which will most likely
* just reuse the connection of the API bus). That's because the system bus after all runs as service
* of the system instance, while in the user instance we can assume it's already there. */
if (MANAGER_IS_RELOADING(m))
return; /* don't check while we are reloading… */
if (manager_dbus_is_running(m, false)) {
(void) bus_init_api(m);
if (MANAGER_IS_SYSTEM(m))
(void) bus_init_system(m);
} else {
bus_done_api(m);
if (MANAGER_IS_SYSTEM(m))
bus_done_system(m);
}
}
static bool manager_journal_is_running(Manager *m) {
Unit *u;
assert(m);
if (MANAGER_IS_TEST_RUN(m))
return false;
/* If we are the user manager we can safely assume that the journal is up */
if (!MANAGER_IS_SYSTEM(m))
return true;
/* Check that the socket is not only up, but in RUNNING state */
u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
if (!u)
return false;
if (SOCKET(u)->state != SOCKET_RUNNING)
return false;
/* Similar, check if the daemon itself is fully up, too */
u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
if (!u)
return false;
if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)) || SERVICE(u)->state == SERVICE_EXITED)
return false;
return true;
}
void disable_printk_ratelimit(void) {
/* Disable kernel's printk ratelimit.
*
* Logging to /dev/kmsg is most useful during early boot and shutdown, where normal logging
* mechanisms are not available. The semantics of this sysctl are such that any kernel command-line
* setting takes precedence. */
int r;
r = sysctl_write("kernel/printk_devkmsg", "on");
if (r < 0)
log_debug_errno(r, "Failed to set sysctl kernel.printk_devkmsg=on: %m");
}
void manager_recheck_journal(Manager *m) {
assert(m);
/* Don't bother with this unless we are in the special situation of being PID 1 */
if (getpid_cached() != 1)
return;
/* Don't check this while we are reloading, things might still change */
if (MANAGER_IS_RELOADING(m))
return;
/* The journal is fully and entirely up? If so, let's permit logging to it, if that's configured. If
* the journal is down, don't ever log to it, otherwise we might end up deadlocking ourselves as we
* might trigger an activation ourselves we can't fulfill. */
log_set_prohibit_ipc(!manager_journal_is_running(m));
log_open();
}
static ShowStatus manager_get_show_status(Manager *m) {
assert(m);
if (MANAGER_IS_USER(m))
return _SHOW_STATUS_INVALID;
if (m->show_status_overridden != _SHOW_STATUS_INVALID)
return m->show_status_overridden;
return m->show_status;
}
bool manager_get_show_status_on(Manager *m) {
assert(m);
return show_status_on(manager_get_show_status(m));
}
static void set_show_status_marker(bool b) {
if (b)
(void) touch("/run/systemd/show-status");
else
(void) unlink("/run/systemd/show-status");
}
void manager_set_show_status(Manager *m, ShowStatus mode, const char *reason) {
assert(m);
assert(reason);
assert(mode >= 0 && mode < _SHOW_STATUS_MAX);
if (MANAGER_IS_USER(m))
return;
if (mode == m->show_status)
return;
if (m->show_status_overridden == _SHOW_STATUS_INVALID) {
bool enabled;
enabled = show_status_on(mode);
log_debug("%s (%s) showing of status (%s).",
enabled ? "Enabling" : "Disabling",
strna(show_status_to_string(mode)),
reason);
set_show_status_marker(enabled);
}
m->show_status = mode;
}
void manager_override_show_status(Manager *m, ShowStatus mode, const char *reason) {
assert(m);
assert(mode < _SHOW_STATUS_MAX);
if (MANAGER_IS_USER(m))
return;
if (mode == m->show_status_overridden)
return;
m->show_status_overridden = mode;
if (mode == _SHOW_STATUS_INVALID)
mode = m->show_status;
log_debug("%s (%s) showing of status (%s).",
m->show_status_overridden != _SHOW_STATUS_INVALID ? "Overriding" : "Restoring",
strna(show_status_to_string(mode)),
reason);
set_show_status_marker(show_status_on(mode));
}
const char* manager_get_confirm_spawn(Manager *m) {
static int last_errno = 0;
struct stat st;
int r;
assert(m);
/* Here's the deal: we want to test the validity of the console but don't want
* PID1 to go through the whole console process which might block. But we also
* want to warn the user only once if something is wrong with the console so we
* cannot do the sanity checks after spawning our children. So here we simply do
* really basic tests to hopefully trap common errors.
*
* If the console suddenly disappear at the time our children will really it
* then they will simply fail to acquire it and a positive answer will be
* assumed. New children will fall back to /dev/console though.
*
* Note: TTYs are devices that can come and go any time, and frequently aren't
* available yet during early boot (consider a USB rs232 dongle...). If for any
* reason the configured console is not ready, we fall back to the default
* console. */
if (!m->confirm_spawn || path_equal(m->confirm_spawn, "/dev/console"))
return m->confirm_spawn;
if (stat(m->confirm_spawn, &st) < 0) {
r = -errno;
goto fail;
}
r = stat_verify_char(&st);
if (r < 0)
goto fail;
last_errno = 0;
return m->confirm_spawn;
fail:
if (last_errno != r)
last_errno = log_warning_errno(r, "Failed to open %s, using default console: %m", m->confirm_spawn);
return "/dev/console";
}
void manager_set_first_boot(Manager *m, bool b) {
int r;
assert(m);
if (!MANAGER_IS_SYSTEM(m))
return;
if (m->first_boot != (int) b) {
r = update_first_boot_file(b);
if (r < 0)
log_warning_errno(r, "Failed to update the first-boot file, ignoring: %m");
}
m->first_boot = b;
}
int update_first_boot_file(bool b) {
if (b)
return touch("/run/systemd/first-boot");
if (unlink("/run/systemd/first-boot") < 0 && errno != ENOENT)
return -errno;
return 0;
}
void manager_disable_confirm_spawn(void) {
(void) touch("/run/systemd/confirm_spawn_disabled");
}
static bool manager_should_show_status(Manager *m, StatusType type) {
assert(m);
if (!MANAGER_IS_SYSTEM(m))
return false;
if (m->no_console_output)
return false;
if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
return false;
/* If we cannot find out the status properly, just proceed. */
if (type < STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
return false;
if (type >= STATUS_TYPE_NOTICE && manager_get_show_status(m) != SHOW_STATUS_NO)
return true;
return manager_get_show_status_on(m);
}
void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
va_list ap;
/* If m is NULL, assume we're after shutdown and let the messages through. */
if (m && !manager_should_show_status(m, type))
return;
/* XXX We should totally drop the check for ephemeral here
* and thus effectively make 'Type=idle' pointless. */
if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
return;
va_start(ap, format);
status_vprintf(status, SHOW_STATUS_ELLIPSIZE|(type == STATUS_TYPE_EPHEMERAL ? SHOW_STATUS_EPHEMERAL : 0), format, ap);
va_end(ap);
}
Set* manager_get_units_needing_mounts_for(Manager *m, const char *path, UnitMountDependencyType t) {
assert(m);
assert(path);
assert(t >= 0 && t < _UNIT_MOUNT_DEPENDENCY_TYPE_MAX);
if (path_equal(path, "/"))
path = "";
return hashmap_get(m->units_needing_mounts_for[t], path);
}
int manager_update_failed_units(Manager *m, Unit *u, bool failed) {
unsigned size;
int r;
assert(m);
assert(u->manager == m);
size = set_size(m->failed_units);
if (failed) {
r = set_ensure_put(&m->failed_units, NULL, u);
if (r < 0)
return log_oom();
} else
(void) set_remove(m->failed_units, u);
if (set_size(m->failed_units) != size)
bus_manager_send_change_signal(m);
return 0;
}
ManagerState manager_state(Manager *m) {
Unit *u;
assert(m);
/* Is the special shutdown target active or queued? If so, we are in shutdown state */