HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/manager.c

215,074 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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 */