HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/service.c

280,768 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 5c097c139d401c81662897faf4f6e6779f5302c7

Lines 2001–3000 of 6,768

        if (r < 0)
                return r;
 
        TAKE_FD(p[0]);
        *ret_exec_fd = TAKE_FD(p[1]);
 
        return 0;
}
 
static bool service_exec_needs_notify_socket(Service *s, ExecFlags flags) {
        assert(s);
 
        /* Notifications are accepted depending on the process and
         * the access setting of the service:
         *     process: \ access:  NONE  MAIN  EXEC   ALL
         *     main                  no   yes   yes   yes
         *     control               no    no   yes   yes
         *     other (forked)        no    no    no   yes */
 
        if (flags & EXEC_IS_CONTROL)
                /* A control process */
                return IN_SET(service_get_notify_access(s), NOTIFY_EXEC, NOTIFY_ALL);
 
        /* We only spawn main processes and control processes, so any
         * process that is not a control process is a main process */
        return service_get_notify_access(s) != NOTIFY_NONE;
}
 
static Service *service_get_triggering_service(Service *s) {
        Unit *candidate = NULL, *other;
 
        assert(s);
 
        /* Return the service which triggered service 's', this means dependency
         * types which include the UNIT_ATOM_ON_{FAILURE,SUCCESS}_OF atoms.
         *
         * N.B. if there are multiple services which could trigger 's' via OnFailure=
         * or OnSuccess= then we return NULL. This is since we don't know from which
         * one to propagate the exit status. */
 
        UNIT_FOREACH_DEPENDENCY(other, UNIT(s), UNIT_ATOM_ON_SUCCESS_OF|UNIT_ATOM_ON_FAILURE_OF) {
                if (candidate)
                        goto have_other;
                candidate = other;
        }
 
        return SERVICE(candidate);
 
 have_other:
        log_unit_warning(UNIT(s), "multiple trigger source candidates for exit status propagation (%s, %s), skipping.",
                         candidate->id, other->id);
        return NULL;
}
 
static ExecFlags service_exec_flags(
                const Service *s,
                ServiceExecCommand command_id,
                ExecFlags cred_flag) {
 
        /* All service main/control processes honor sandboxing and namespacing options (except those
        explicitly excluded in service_spawn()) */
        ExecFlags flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT;
 
        assert(s);
        assert(command_id >= 0);
        assert(command_id < _SERVICE_EXEC_COMMAND_MAX);
        assert((cred_flag & ~(EXEC_SETUP_CREDENTIALS_FRESH|EXEC_SETUP_CREDENTIALS)) == 0);
        assert((cred_flag != 0) == (command_id == SERVICE_EXEC_START));
 
        /* Control processes spawned before main process also get tty access */
        if (IN_SET(command_id, SERVICE_EXEC_CONDITION, SERVICE_EXEC_START_PRE, SERVICE_EXEC_START))
                flags |= EXEC_APPLY_TTY_STDIN;
 
        /* All start phases get access to credentials. ExecStartPre= gets a new credential store upon
         * every invocation, so that updating credential files through it works. When the first main process
         * starts, passed creds become stable. Also see 'cred_flag'. */
        if (command_id == SERVICE_EXEC_CONDITION)
                flags |= EXEC_SETUP_CREDENTIALS;
        if (command_id == SERVICE_EXEC_START_PRE)
                flags |= EXEC_SETUP_CREDENTIALS_FRESH;
        if (command_id == SERVICE_EXEC_START_POST)
                flags |= EXEC_SETUP_CREDENTIALS;
 
        if (IN_SET(command_id, SERVICE_EXEC_START_PRE, SERVICE_EXEC_START))
                flags |= EXEC_SETENV_MONITOR_RESULT;
 
        if (command_id == SERVICE_EXEC_START)
                return flags|cred_flag|EXEC_PASS_FDS|EXEC_SET_WATCHDOG;
 
        flags |= EXEC_IS_CONTROL;
 
        /* Put control processes spawned later than main process under .control sub-cgroup if appropriate */
        if (!IN_SET(command_id, SERVICE_EXEC_CONDITION, SERVICE_EXEC_START_PRE))
                flags |= EXEC_CONTROL_CGROUP;
 
        /* Pass credentials to ExecReload*= too, but only if the credentials are actually refreshed,
         * to make sure they have the same understanding of the world as the main process. */
        if (IN_SET(command_id, SERVICE_EXEC_RELOAD, SERVICE_EXEC_RELOAD_POST) &&
            FLAGS_SET(s->refreshed_mask, SERVICE_RELOAD_CREDENTIALS))
                flags |= EXEC_SETUP_CREDENTIALS;
 
        if (IN_SET(command_id, SERVICE_EXEC_STOP, SERVICE_EXEC_STOP_POST))
                flags |= EXEC_SETENV_RESULT;
 
        return flags;
}
 
static int service_spawn_internal(
                const char *caller,
                Service *s,
                ExecCommand *c,
                ExecFlags flags,
                usec_t timeout,
                PidRef *ret_pid) {
 
        _cleanup_(exec_params_shallow_clear) ExecParameters exec_params = EXEC_PARAMETERS_INIT(flags);
        _cleanup_(sd_event_source_unrefp) sd_event_source *exec_fd_source = NULL;
        _cleanup_strv_free_ char **final_env = NULL, **our_env = NULL;
        _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
        size_t n_env = 0;
        int r;
 
        assert(caller);
        assert(s);
        assert(c);
        assert(ret_pid);
 
        log_unit_debug(UNIT(s), "Will spawn child (%s): %s", caller, c->path);
 
        r = unit_prepare_exec(UNIT(s)); /* This realizes the cgroup, among other things */
        if (r < 0)
                return r;
 
        assert(!s->exec_fd_event_source);
 
        if (FLAGS_SET(exec_params.flags, EXEC_IS_CONTROL)) {
                /* If this is a control process, mask the permissions/chroot application if this is requested. */
                if (s->permissions_start_only)
                        exec_params.flags &= ~EXEC_APPLY_SANDBOXING;
                if (s->root_directory_start_only)
                        exec_params.flags &= ~EXEC_APPLY_CHROOT;
        }
 
        if (FLAGS_SET(exec_params.flags, EXEC_PASS_FDS)) {
                r = service_collect_fds(s,
                                        &exec_params.fds,
                                        &exec_params.fd_names,
                                        &exec_params.n_socket_fds,
                                        &exec_params.n_stashed_fds);
                if (r < 0)
                        return r;
 
                log_unit_debug(UNIT(s), "Passing %zu fds to service", exec_params.n_socket_fds + exec_params.n_stashed_fds);
 
                exec_params.open_files = s->open_files;
 
        } else if (IN_SET(s->exec_context.std_input, EXEC_INPUT_SOCKET, EXEC_INPUT_NAMED_FD) ||
                   IN_SET(s->exec_context.std_output, EXEC_OUTPUT_SOCKET, EXEC_OUTPUT_NAMED_FD) ||
                   IN_SET(s->exec_context.std_error, EXEC_OUTPUT_SOCKET, EXEC_OUTPUT_NAMED_FD)) {
 
                r = service_collect_fds(s,
                                        &exec_params.fds,
                                        &exec_params.fd_names,
                                        &exec_params.n_socket_fds,
                                        /* n_stashed_fds= */ NULL);
                if (r < 0)
                        return r;
 
                log_unit_debug(UNIT(s), "Passing %zu sockets to service", exec_params.n_socket_fds);
        }
 
        if (!FLAGS_SET(exec_params.flags, EXEC_IS_CONTROL) && s->type == SERVICE_EXEC) {
                r = service_allocate_exec_fd(s, &exec_fd_source, &exec_params.exec_fd);
                if (r < 0)
                        return r;
        }
 
        r = service_arm_timer(s, /* relative= */ true, timeout);
        if (r < 0)
                return r;
 
        our_env = new0(char*, 16);
        if (!our_env)
                return -ENOMEM;
 
        if (service_exec_needs_notify_socket(s, exec_params.flags)) {
                exec_params.notify_socket = UNIT(s)->manager->notify_socket;
 
                if (s->n_fd_store_max > 0)
                        if (asprintf(our_env + n_env++, "FDSTORE=%u", s->n_fd_store_max) < 0)
                                return -ENOMEM;
        }
 
        if (pidref_is_set(&s->main_pid)) {
                if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid.pid) < 0)
                        return -ENOMEM;
 
                if (pidref_acquire_pidfd_id(&s->main_pid) >= 0)
                        if (asprintf(our_env + n_env++, "MAINPIDFDID=%" PRIu64, s->main_pid.fd_id) < 0)
                                return -ENOMEM;
        }
 
        if (MANAGER_IS_USER(UNIT(s)->manager) &&
            !exec_needs_pid_namespace(&s->exec_context, /* params= */ NULL)) {
 
                if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid_cached()) < 0)
                        return -ENOMEM;
 
                uint64_t pidfdid;
                if (pidfd_get_inode_id_self_cached(&pidfdid) >= 0)
                        if (asprintf(our_env + n_env++, "MANAGERPIDFDID=%" PRIu64, pidfdid) < 0)
                                return -ENOMEM;
        }
 
        if (s->pid_file)
                if (asprintf(our_env + n_env++, "PIDFILE=%s", s->pid_file) < 0)
                        return -ENOMEM;
 
        if (s->socket_fd >= 0) {
                union sockaddr_union sa;
                socklen_t salen = sizeof(sa);
 
                /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
                 * useful. Note that we do this only when we are still connected at this point in time, which we might
                 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
                 * in ENOTCONN), and just use whate we can use. */
 
                if (getpeername(s->socket_fd, &sa.sa, &salen) >= 0 &&
                    IN_SET(sa.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK, AF_UNIX)) {
                        _cleanup_free_ char *addr = NULL;
                        char *t;
 
                        r = sockaddr_pretty(&sa.sa, salen, /* translate_ipv6= */ true, /* include_port= */ false, &addr);
                        if (r < 0)
                                return r;
 
                        if (sa.sa.sa_family != AF_UNIX || IN_SET(addr[0], '/', '@')) {
                                t = strjoin("REMOTE_ADDR=", addr);
                                if (!t)
                                        return -ENOMEM;
                                our_env[n_env++] = t;
                        }
 
                        if (IN_SET(sa.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
                                unsigned port;
 
                                r = sockaddr_port(&sa.sa, &port);
                                if (r < 0)
                                        return r;
 
                                if (asprintf(&t, "REMOTE_PORT=%u", port) < 0)
                                        return -ENOMEM;
                                our_env[n_env++] = t;
                        }
                }
 
                uint64_t cookie;
                if (socket_get_cookie(s->socket_fd, &cookie) >= 0) {
                        char *t;
                        if (asprintf(&t, "SO_COOKIE=%" PRIu64, cookie) < 0)
                                return -ENOMEM;
                        our_env[n_env++] = t;
                }
        }
 
        Service *env_source = NULL;
        const char *monitor_prefix;
        if (FLAGS_SET(exec_params.flags, EXEC_SETENV_RESULT)) {
                env_source = s;
                monitor_prefix = "";
        } else if (FLAGS_SET(exec_params.flags, EXEC_SETENV_MONITOR_RESULT)) {
                env_source = service_get_triggering_service(s);
                monitor_prefix = "MONITOR_";
        }
 
        if (env_source) {
                if (asprintf(our_env + n_env++, "%sSERVICE_RESULT=%s", monitor_prefix, service_result_to_string(env_source->result)) < 0)
                        return -ENOMEM;
 
                if (env_source->main_exec_status.pid > 0 &&
                    dual_timestamp_is_set(&env_source->main_exec_status.exit_timestamp)) {
                        if (asprintf(our_env + n_env++, "%sEXIT_CODE=%s", monitor_prefix, sigchld_code_to_string(env_source->main_exec_status.code)) < 0)
                                return -ENOMEM;
 
                        if (env_source->main_exec_status.code == CLD_EXITED)
                                r = asprintf(our_env + n_env++, "%sEXIT_STATUS=%i", monitor_prefix, env_source->main_exec_status.status);
                        else
                                r = asprintf(our_env + n_env++, "%sEXIT_STATUS=%s", monitor_prefix, signal_to_string(env_source->main_exec_status.status));
                        if (r < 0)
                                return -ENOMEM;
                }
 
                if (env_source != s) {
                        if (!sd_id128_is_null(UNIT(env_source)->invocation_id))
                                if (asprintf(our_env + n_env++, "%sINVOCATION_ID=" SD_ID128_FORMAT_STR,
                                             monitor_prefix, SD_ID128_FORMAT_VAL(UNIT(env_source)->invocation_id)) < 0)
                                        return -ENOMEM;
 
                        if (asprintf(our_env + n_env++, "%sUNIT=%s", monitor_prefix, UNIT(env_source)->id) < 0)
                                return -ENOMEM;
                }
        }
 
        if (UNIT(s)->debug_invocation) {
                char *t = strdup("DEBUG_INVOCATION=1");
                if (!t)
                        return -ENOMEM;
                our_env[n_env++] = t;
        }
 
        if (UNIT(s)->activation_details) {
                r = activation_details_append_env(UNIT(s)->activation_details, &our_env);
                if (r < 0)
                        return r;
                /* The number of env vars added here can vary, rather than keeping the allocation block in
                 * sync manually, these functions simply use the strv methods to append to it, so we need
                 * to update n_env when we are done in case of future usage. */
                n_env += r;
        }
 
        r = unit_set_exec_params(UNIT(s), &exec_params);
        if (r < 0)
                return r;
 
        final_env = strv_env_merge(exec_params.environment, our_env);
        if (!final_env)
                return -ENOMEM;
 
        /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
        SET_FLAG(exec_params.flags, EXEC_NSS_DYNAMIC_BYPASS,
                 MANAGER_IS_SYSTEM(UNIT(s)->manager) && unit_has_name(UNIT(s), SPECIAL_DBUS_SERVICE));
 
        strv_free_and_replace(exec_params.environment, final_env);
        exec_params.watchdog_usec = service_get_watchdog_usec(s);
        exec_params.selinux_context_net = s->socket_fd_selinux_context_net;
        if (s->type == SERVICE_IDLE)
                exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
        exec_params.stdin_fd = s->stdin_fd;
        exec_params.stdout_fd = s->stdout_fd;
        exec_params.stderr_fd = s->stderr_fd;
 
        if (s->root_directory_fd >= 0) {
                r = mount_fd_clone(s->root_directory_fd, /* recursive= */ true, &s->root_directory_fd);
                if (r < 0)
                        return r;
 
                exec_params.root_directory_fd = r;
        }
 
        r = exec_spawn(UNIT(s),
                       c,
                       &s->exec_context,
                       &exec_params,
                       s->exec_runtime,
                       &s->cgroup_context,
                       &pidref);
        if (r < 0)
                return r;
 
        s->exec_fd_event_source = TAKE_PTR(exec_fd_source);
        s->exec_fd_hot = false;
 
        r = unit_watch_pidref(UNIT(s), &pidref, /* exclusive= */ true);
        if (r < 0)
                return r;
 
        *ret_pid = TAKE_PIDREF(pidref);
        return 0;
}
 
static int main_pid_good(Service *s) {
        assert(s);
 
        /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
 
        /* If we know the pid file, then let's just check if it is still valid */
        if (s->main_pid_known) {
 
                /* If it's an alien child let's check if it is still alive ... */
                if (s->main_pid_alien && pidref_is_set(&s->main_pid))
                        return pidref_is_alive(&s->main_pid);
 
                /* .. otherwise assume we'll get a SIGCHLD for it, which we really should wait for to collect
                 * exit status and code */
                return pidref_is_set(&s->main_pid);
        }
 
        /* We don't know the pid */
        return -EAGAIN;
}
 
static int control_pid_good(Service *s) {
        assert(s);
 
        /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
         * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
         * means: we can't figure it out. */
 
        return pidref_is_set(&s->control_pid);
}
 
static int cgroup_good(Service *s) {
        int r;
 
        assert(s);
 
        /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
         * figure it out */
 
        if (!s->cgroup_runtime || !s->cgroup_runtime->cgroup_path)
                return 0;
 
        r = cg_is_empty(s->cgroup_runtime->cgroup_path);
        if (r < 0)
                return r;
 
        return r == 0;
}
 
static bool service_shall_restart(Service *s, const char **reason) {
        assert(s);
        assert(reason);
 
        /* Don't restart after manual stops */
        if (s->forbid_restart) {
                *reason = "manual stop";
                return false;
        }
 
        /* Never restart if this is configured as special exception */
        if (exit_status_set_test(&s->restart_prevent_status, s->main_exec_status.code, s->main_exec_status.status)) {
                *reason = "prevented by exit status";
                return false;
        }
 
        /* Restart if the exit code/status are configured as restart triggers */
        if (exit_status_set_test(&s->restart_force_status,  s->main_exec_status.code, s->main_exec_status.status)) {
                /* Don't allow Type=oneshot services to restart on success. Note that Restart=always/on-success
                 * is already rejected in service_verify. */
                if (s->type == SERVICE_ONESHOT && s->result == SERVICE_SUCCESS) {
                        *reason = "service type and exit status";
                        return false;
                }
 
                *reason = "forced by exit status";
                return true;
        }
 
        *reason = "restart setting";
        switch (s->restart) {
 
        case SERVICE_RESTART_NO:
                return false;
 
        case SERVICE_RESTART_ALWAYS:
                return s->result != SERVICE_SKIP_CONDITION;
 
        case SERVICE_RESTART_ON_SUCCESS:
                return s->result == SERVICE_SUCCESS;
 
        case SERVICE_RESTART_ON_FAILURE:
                return !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_SKIP_CONDITION);
 
        case SERVICE_RESTART_ON_ABNORMAL:
                return !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE, SERVICE_SKIP_CONDITION);
 
        case SERVICE_RESTART_ON_WATCHDOG:
                return s->result == SERVICE_FAILURE_WATCHDOG;
 
        case SERVICE_RESTART_ON_ABORT:
                return IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP);
 
        default:
                assert_not_reached();
        }
}
 
static bool service_will_restart(Unit *u) {
        Service *s = SERVICE(u);
 
        assert(s);
 
        if (IN_SET(s->state, SERVICE_DEAD_BEFORE_AUTO_RESTART, SERVICE_FAILED_BEFORE_AUTO_RESTART, SERVICE_AUTO_RESTART, SERVICE_AUTO_RESTART_QUEUED))
                return true;
 
        return unit_will_restart_default(u);
}
 
static ServiceState service_determine_dead_state(Service *s) {
        assert(s);
 
        return SERVICE_FD_STORE_POPULATED(s) && IN_SET(s->fd_store_preserve_mode, EXEC_PRESERVE_YES, EXEC_PRESERVE_ON_SUCCESS) ? SERVICE_DEAD_RESOURCES_PINNED : SERVICE_DEAD;
}
 
static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
        ServiceState end_state, restart_state;
        int r;
 
        assert(s);
 
        /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
         * undo what has already been enqueued. */
        if (unit_stop_pending(UNIT(s)))
                allow_restart = false;
 
        if (s->result == SERVICE_SUCCESS || f == SERVICE_FAILURE_START_LIMIT_HIT)
                s->result = f;
 
        if (s->result == SERVICE_SUCCESS) {
                unit_log_success(UNIT(s));
                end_state = service_determine_dead_state(s);
                restart_state = SERVICE_DEAD_BEFORE_AUTO_RESTART;
        } else if (s->result == SERVICE_SKIP_CONDITION) {
                unit_log_skip(UNIT(s), service_result_to_string(s->result));
                end_state = service_determine_dead_state(s);
                restart_state = _SERVICE_STATE_INVALID; /* Never restart if skipped due to condition failure */
        } else {
                unit_log_failure(UNIT(s), service_result_to_string(s->result));
                end_state = SERVICE_FAILED;
                restart_state = SERVICE_FAILED_BEFORE_AUTO_RESTART;
        }
        unit_warn_leftover_processes(UNIT(s), /* start= */ false);
 
        if (!allow_restart)
                log_unit_debug(UNIT(s), "Service restart not allowed.");
        else {
                const char *reason;
 
                allow_restart = service_shall_restart(s, &reason);
                log_unit_debug(UNIT(s), "Service will %srestart (%s)",
                                        allow_restart ? "" : "not ",
                                        reason);
        }
 
        if (allow_restart) {
                usec_t restart_usec_next;
 
                assert(restart_state >= 0 && restart_state < _SERVICE_STATE_MAX);
 
                /* We make two state changes here: one that maps to the high-level UNIT_INACTIVE/UNIT_FAILED
                 * state (i.e. a state indicating deactivation), and then one that maps to the
                 * high-level UNIT_STARTING state (i.e. a state indicating activation). We do this so that
                 * external software can watch the state changes and see all service failures, even if they
                 * are only transitionary and followed by an automatic restart. We have fine-grained
                 * low-level states for this though so that software can distinguish the permanent UNIT_INACTIVE
                 * state from this transitionary UNIT_INACTIVE state by looking at the low-level states. */
                if (s->restart_mode != SERVICE_RESTART_MODE_DIRECT)
                        service_set_state(s, restart_state);
 
                /* Do the randomized restart delay once and remember it so that it's stable across daemon-reload */
                s->restart_randomized_delay_chosen_usec = s->restart_randomized_delay_usec > 0 ?
                        random_u64_range(s->restart_randomized_delay_usec) : 0;
 
                restart_usec_next = service_restart_usec_next_jittered(s);
 
                r = service_arm_timer(s, /* relative= */ true, restart_usec_next);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to install restart timer: %m");
                        return service_enter_dead(s, SERVICE_FAILURE_RESOURCES, /* allow_restart= */ false);
                }
 
                /* If the relevant option is set, and the unit doesn't already have logging level set to
                 * debug, enable it now. Make sure to overwrite the state in /run/systemd/units/ too, to
                 * ensure journald doesn't prune the messages. The previous state is saved and restored
                 * once the auto-restart flow ends. */
                if (s->restart_mode == SERVICE_RESTART_MODE_DEBUG) {
                        r = unit_set_debug_invocation(UNIT(s), true);
                        if (r < 0)
                                log_unit_warning_errno(UNIT(s), r, "Failed to enable debug invocation, ignoring: %m");
                        if (r > 0)
                                log_unit_notice(UNIT(s), "Service dead, subsequent restarts will be executed with debug level logging.");
                }
 
                log_unit_debug(UNIT(s), "Next restart interval calculated as: %s (randomized delay: %s)",
                               FORMAT_TIMESPAN(restart_usec_next, 0),
                               FORMAT_TIMESPAN(s->restart_randomized_delay_chosen_usec, 0));
 
                service_set_state(s, SERVICE_AUTO_RESTART);
        } else {
                /* If we shan't restart, the restart counter would be flushed out. But rather than doing that
                 * immediately here, this is delegated to service_start(), i.e. next start, so that the user
                 * can still introspect the counter. */
                service_set_state(s, end_state);
 
                (void) unit_set_debug_invocation(UNIT(s), false);
        }
 
        /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
        s->forbid_restart = false;
 
        /* Reset notify states */
        s->notify_access_override = _NOTIFY_ACCESS_INVALID;
        s->notify_state = _NOTIFY_STATE_INVALID;
 
        /* We want fresh tmpdirs and ephemeral snapshots in case the service is started again immediately. */
        s->exec_runtime = exec_runtime_destroy(s->exec_runtime);
 
        /* Also, remove the runtime directory */
        unit_destroy_runtime_data(UNIT(s), &s->exec_context, /* destroy_runtime_dir= */ true);
 
        /* Also get rid of the fd store, if that's configured. */
        if (s->fd_store_preserve_mode == EXEC_PRESERVE_NO ||
            (s->fd_store_preserve_mode == EXEC_PRESERVE_ON_SUCCESS && s->state == SERVICE_FAILED))
                service_release_fd_store(s);
 
        /* Get rid of the IPC bits of the user */
        unit_unref_uid_gid(UNIT(s), true);
 
        /* Try to delete the pid file. At this point it will be
         * out-of-date, and some software might be confused by it, so
         * let's remove it. */
        if (s->pid_file)
                (void) unlink(s->pid_file);
 
        /* Reset TTY ownership if necessary */
        exec_context_revert_tty(&s->exec_context, UNIT(s)->invocation_id);
}
 
static void service_enter_stop_post(Service *s, ServiceResult f) {
        int r;
        assert(s);
 
        if (s->result == SERVICE_SUCCESS)
                s->result = f;
 
        service_unwatch_control_pid(s);
 
        s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
        if (s->control_command) {
                s->control_command_id = SERVICE_EXEC_STOP_POST;
 
                r = service_spawn(s,
                                  s->control_command,
                                  service_exec_flags(s, s->control_command_id, /* cred_flag = */ 0),
                                  s->timeout_stop_usec,
                                  &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'stop-post' task: %m");
                        service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
                        return;
                }
 
                service_set_state(s, SERVICE_STOP_POST);
        } else
                service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
}
 
static int state_to_kill_operation(Service *s, ServiceState state) {
        switch (state) {
 
        case SERVICE_STOP_WATCHDOG:
        case SERVICE_FINAL_WATCHDOG:
                return KILL_WATCHDOG;
 
        case SERVICE_STOP_SIGTERM:
                if (unit_has_job_type(UNIT(s), JOB_RESTART))
                        return KILL_RESTART;
                _fallthrough_;
 
        case SERVICE_FINAL_SIGTERM:
                return KILL_TERMINATE;
 
        case SERVICE_STOP_SIGKILL:
        case SERVICE_FINAL_SIGKILL:
                return KILL_KILL;
 
        default:
                return _KILL_OPERATION_INVALID;
        }
}
 
static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
        int kill_operation, r;
 
        assert(s);
 
        if (s->result == SERVICE_SUCCESS)
                s->result = f;
 
        kill_operation = state_to_kill_operation(s, state);
        r = unit_kill_context(UNIT(s), kill_operation);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
                goto fail;
        }
 
        if (r > 0) {
                r = service_arm_timer(s, /* relative= */ true,
                                      kill_operation == KILL_WATCHDOG ? service_timeout_abort_usec(s) : s->timeout_stop_usec);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                        goto fail;
                }
 
                service_set_state(s, state);
        } else if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM) && s->kill_context.send_sigkill)
                service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
        else if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
                service_enter_stop_post(s, SERVICE_SUCCESS);
        else if (IN_SET(state, SERVICE_FINAL_WATCHDOG, SERVICE_FINAL_SIGTERM) && s->kill_context.send_sigkill)
                service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
        else
                service_enter_dead(s, SERVICE_SUCCESS, /* allow_restart= */ true);
 
        return;
 
fail:
        if (IN_SET(state, SERVICE_STOP_WATCHDOG, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL))
                service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
        else
                service_enter_dead(s, SERVICE_FAILURE_RESOURCES, /* allow_restart= */ true);
}
 
static void service_enter_stop_by_notify(Service *s) {
        int r;
 
        assert(s);
 
        r = service_arm_timer(s, /* relative= */ true, s->timeout_stop_usec);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
                return;
        }
 
        /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
        service_set_state(s, SERVICE_STOP_SIGTERM);
}
 
static void service_enter_stop(Service *s, ServiceResult f) {
        int r;
 
        assert(s);
 
        if (s->result == SERVICE_SUCCESS)
                s->result = f;
 
        service_unwatch_control_pid(s);
 
        s->control_command = s->exec_command[SERVICE_EXEC_STOP];
        if (s->control_command) {
                s->control_command_id = SERVICE_EXEC_STOP;
 
                r = service_spawn(s,
                                  s->control_command,
                                  service_exec_flags(s, s->control_command_id, /* cred_flag = */ 0),
                                  s->timeout_stop_usec,
                                  &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'stop' task: %m");
                        service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
                        return;
                }
 
                service_set_state(s, SERVICE_STOP);
        } else
                service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
}
 
static bool service_good_except_bus_name(Service *s) {
        int main_pid_ok;
 
        assert(s);
 
        main_pid_ok = main_pid_good(s);
        if (main_pid_ok > 0) /* It's alive */
                return true;
        if (main_pid_ok == 0 && s->exit_type == SERVICE_EXIT_MAIN) /* It's dead */
                return false;
 
        /* OK, we don't know anything about the main PID, maybe
         * because there is none. Let's check the control group
         * instead. */
 
        return cgroup_good(s) != 0;
}
 
static bool service_good(Service *s) {
        assert(s);
 
        if (s->type == SERVICE_DBUS && !s->bus_name_good)
                return false;
 
        return service_good_except_bus_name(s);
}
 
static void service_enter_exited_or_stop(Service *s) {
        assert(s);
 
        s->revalidate_runtime_begin_usec = USEC_INFINITY;
 
        if (s->remain_after_exit)
                service_set_state(s, SERVICE_EXITED);
        else
                service_enter_stop(s, SERVICE_SUCCESS);
}
 
static void service_enter_running(Service *s, ServiceResult f) {
        int r;
 
        assert(s);
 
        if (s->result == SERVICE_SUCCESS)
                s->result = f;
 
        service_unwatch_control_pid(s);
 
        if (s->result != SERVICE_SUCCESS)
                service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
        else if (service_good(s)) {
 
                /* If there are any queued up sd_notify() notifications, process them now */
                if (s->notify_state == NOTIFY_RELOADING)
                        service_enter_reload_by_notify(s);
                else if (s->notify_state == NOTIFY_STOPPING)
                        service_enter_stop_by_notify(s);
                else {
                        service_set_state(s, SERVICE_RUNNING);
 
                        /* We're resuming. Recompute the budget from the current config (which was measured
                         * from when we entered revalidation). */
                        usec_t remaining = USEC_INFINITY;
                        if (s->revalidate_runtime_begin_usec != USEC_INFINITY)
                                remaining = usec_sub_unsigned(service_running_timeout(s), s->revalidate_runtime_begin_usec);
                        s->revalidate_runtime_begin_usec = USEC_INFINITY;
 
                        if (remaining != USEC_INFINITY)
                                r = service_arm_timer(s, /* relative= */ true, remaining);
                        else
                                r = service_arm_timer(s, /* relative= */ false, service_running_timeout(s));
                        if (r < 0) {
                                log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                                service_enter_running(s, SERVICE_FAILURE_RESOURCES);
                                return;
                        }
                }
 
        } else if (s->type == SERVICE_DBUS && !s->bus_name_good && service_good_except_bus_name(s)) {
 
                /* If we're already revalidating, just keep waiting on the timer we armed on the way in, so a
                 * flapping broker that reconnects repeatedly can't keep pushing the deadline out. */
                if (s->state == SERVICE_RUNNING_REVALIDATING)
                        return;
 
                log_unit_warning(UNIT(s),
                                 "D-Bus name %s vanished (possibly from an unsupported broker restart), giving it %s to return.",
                                 s->bus_name,
                                 FORMAT_TIMESPAN(SERVICE_BUS_NAME_GRACE_USEC, USEC_PER_SEC));
 
                r = unit_arm_timer(UNIT(s), &s->bus_name_grace_event_source, /* relative= */ true,
                                   SERVICE_BUS_NAME_GRACE_USEC, service_dispatch_bus_name_grace);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to arm D-Bus name grace timer: %m");
                        service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
                        return;
                }
 
                if (s->state == SERVICE_RUNNING)
                        s->revalidate_runtime_begin_usec = now(CLOCK_MONOTONIC);
 
                service_set_state(s, SERVICE_RUNNING_REVALIDATING);
 
        } else
                service_enter_exited_or_stop(s);
}
 
static void service_enter_start_post(Service *s) {
        int r;
 
        assert(s);
 
        service_unwatch_control_pid(s);
        service_reset_watchdog(s);
 
        s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
        if (s->control_command) {
                s->control_command_id = SERVICE_EXEC_START_POST;
 
                r = service_spawn(s,
                                  s->control_command,
                                  service_exec_flags(s, s->control_command_id, /* cred_flag = */ 0),
                                  s->timeout_start_usec,
                                  &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'start-post' task: %m");
                        service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
                        return;
                }
 
                service_set_state(s, SERVICE_START_POST);
        } else
                service_enter_running(s, SERVICE_SUCCESS);
}
 
static void service_kill_control_process(Service *s) {
        int r;
 
        assert(s);
 
        if (!pidref_is_set(&s->control_pid))
                return;
 
        r = pidref_kill_and_sigcont(&s->control_pid, SIGKILL);
        if (r < 0) {
                _cleanup_free_ char *comm = NULL;
 
                (void) pidref_get_comm(&s->control_pid, &comm);
 
                log_unit_debug_errno(UNIT(s), r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m",
                                     s->control_pid.pid, strna(comm));
        }
}
 
static int service_adverse_to_leftover_processes(Service *s) {
        assert(s);
 
        /* KillMode=mixed and control group are used to indicate that all process should be killed off.
         * SendSIGKILL= is used for services that require a clean shutdown. These are typically database
         * service where a SigKilled process would result in a lengthy recovery and who's shutdown or startup
         * time is quite variable (so Timeout settings aren't of use).
         *
         * Here we take these two factors and refuse to start a service if there are existing processes
         * within a control group. Databases, while generally having some protection against multiple
         * instances running, lets not stress the rigor of these. Also ExecStartPre= parts of the service
         * aren't as rigoriously written to protect against multiple use. */
 
        if (unit_warn_leftover_processes(UNIT(s), /* start= */ true) > 0 &&
            IN_SET(s->kill_context.kill_mode, KILL_MIXED, KILL_CONTROL_GROUP) &&
            !s->kill_context.send_sigkill)
                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(EBUSY),
                                            "Will not start SendSIGKILL=no service of type KillMode=control-group or mixed while processes exist");
 
        return 0;
}
 
static void service_enter_start(Service *s) {
        _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
        ExecCommand *c;
        usec_t timeout;
        int r;
 
        assert(s);
 
        service_unwatch_control_pid(s);
        service_unwatch_main_pid(s);
 
        r = service_setup_luo_sessions(s);
        if (r < 0)
                goto fail;
 
        r = service_adverse_to_leftover_processes(s);
        if (r < 0)
                goto fail;
 
        if (s->type == SERVICE_FORKING) {
                s->control_command_id = SERVICE_EXEC_START;
                c = s->control_command = s->exec_command[SERVICE_EXEC_START];
 
                s->main_command = NULL;
        } else {
                s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
                s->control_command = NULL;
 
                c = s->main_command = s->exec_command[SERVICE_EXEC_START];
        }
 
        if (!c) {
                if (s->type != SERVICE_ONESHOT) {
                        /* There's no command line configured for the main command? Hmm, that is strange.
                         * This can only happen if the configuration changes at runtime. In this case,
                         * let's enter a failure state. */
                        r = log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(ENXIO), "There's no 'start' task anymore we could start.");
                        goto fail;
                }
 
                /* We force a fake state transition here. Otherwise, the unit would go directly from
                 * SERVICE_DEAD to SERVICE_DEAD without SERVICE_ACTIVATING or SERVICE_ACTIVE
                 * in between. This way we can later trigger actions that depend on the state
                 * transition, including SuccessAction=. */
                service_set_state(s, SERVICE_START);
 
                service_enter_start_post(s);
                return;
        }
 
        if (IN_SET(s->type, SERVICE_SIMPLE, SERVICE_IDLE))
                /* For simple + idle this is the main process. We don't apply any timeout here, but
                 * service_enter_running() will later apply the .runtime_max_usec timeout. */
                timeout = USEC_INFINITY;
        else
                timeout = s->timeout_start_usec;
 
        r = service_spawn(s,
                          c,
                          service_exec_flags(s, SERVICE_EXEC_START, EXEC_SETUP_CREDENTIALS_FRESH),
                          timeout,
                          &pidref);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'start' task: %m");
                goto fail;