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 3001–4000 of 6,768

        }
 
        assert(pidref.pid == c->exec_status.pid);
 
        switch (s->type) {
 
        case SERVICE_SIMPLE:
        case SERVICE_IDLE:
                /* For simple services we immediately start the START_POST binaries. */
                (void) service_set_main_pidref(s, TAKE_PIDREF(pidref), &c->exec_status.start_timestamp);
                return service_enter_start_post(s);
 
        case SERVICE_FORKING:
                /* For forking services we wait until the start process exited. */
                s->control_pid = TAKE_PIDREF(pidref);
                return service_set_state(s, SERVICE_START);
 
        case SERVICE_ONESHOT: /* For oneshot services we wait until the start process exited, too, but it is our main process. */
        case SERVICE_EXEC:
        case SERVICE_DBUS:
        case SERVICE_NOTIFY:
        case SERVICE_NOTIFY_RELOAD:
                /* For D-Bus services we know the main pid right away, but wait for the bus name to appear
                 * on the bus. 'notify' and 'exec' services wait for readiness notification and EOF
                 * on exec_fd, respectively. */
                (void) service_set_main_pidref(s, TAKE_PIDREF(pidref), &c->exec_status.start_timestamp);
                return service_set_state(s, SERVICE_START);
 
        default:
                assert_not_reached();
        }
 
fail:
        service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
}
 
static void service_enter_start_pre(Service *s) {
        int r;
 
        assert(s);
 
        service_unwatch_control_pid(s);
 
        s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
        if (s->control_command) {
 
                r = service_adverse_to_leftover_processes(s);
                if (r < 0)
                        goto fail;
 
                s->control_command_id = SERVICE_EXEC_START_PRE;
 
                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-pre' task: %m");
                        goto fail;
                }
 
                service_set_state(s, SERVICE_START_PRE);
        } else
                service_enter_start(s);
 
        return;
 
fail:
        service_enter_dead(s, SERVICE_FAILURE_RESOURCES, /* allow_restart= */ true);
}
 
static void service_enter_condition(Service *s) {
        int r;
 
        assert(s);
 
        service_unwatch_control_pid(s);
 
        s->control_command = s->exec_command[SERVICE_EXEC_CONDITION];
        if (s->control_command) {
 
                r = service_adverse_to_leftover_processes(s);
                if (r < 0)
                        goto fail;
 
                s->control_command_id = SERVICE_EXEC_CONDITION;
 
                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 'exec-condition' task: %m");
                        goto fail;
                }
 
                service_set_state(s, SERVICE_CONDITION);
        } else
                service_enter_start_pre(s);
 
        return;
 
fail:
        service_enter_dead(s, SERVICE_FAILURE_RESOURCES, /* allow_restart= */ true);
}
 
static void service_enter_restart(Service *s, bool shortcut) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int r;
 
        /* shortcut: a manual start request is received, restart immediately */
 
        assert(s);
        assert(s->state == SERVICE_AUTO_RESTART);
 
        if (!shortcut && unit_has_job_type(UNIT(s), JOB_STOP)) {
                /* Don't restart things if we are going down anyway */
                log_unit_info(UNIT(s), "Stop job pending for unit, skipping automatic restart.");
                return;
        }
 
        /* Any units that are bound to this service must also be restarted, unless RestartMode=direct.
         * We use JOB_START for ourselves but then set JOB_RESTART_DEPENDENCIES which will enqueue JOB_RESTART
         * for those dependency jobs in the former case, plain JOB_REPLACE when RestartMode=direct.
         *
         * Also, when RestartMode=direct is used, the service being restarted don't enter the inactive/failed state,
         * i.e. unit_process_job -> job_finish_and_invalidate is never called, and the previous job might still
         * be running (especially for Type=oneshot services).
         * We need to refuse late merge and re-enqueue the anchor job. */
        r = manager_add_job_full(UNIT(s)->manager,
                                 JOB_START, UNIT(s),
                                 s->restart_mode == SERVICE_RESTART_MODE_DIRECT ? JOB_REPLACE : JOB_RESTART_DEPENDENCIES,
                                 TRANSACTION_REENQUEUE_ANCHOR,
                                 /* affected_jobs= */ NULL,
                                 &error, /* ret= */ NULL);
        if (r < 0) {
                log_unit_warning(UNIT(s), "Failed to schedule restart job: %s", bus_error_message(&error, r));
                return service_enter_dead(s, SERVICE_FAILURE_RESOURCES, /* allow_restart= */ false);
        }
 
        /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't
         * fully stopped, i.e. as long as it remains up or remains in auto-start states. The user can reset
         * the counter explicitly however via the usual "systemctl reset-failure" logic. */
        s->n_restarts++;
 
        log_unit_struct(UNIT(s), LOG_INFO,
                        LOG_MESSAGE_ID(SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR),
                        LOG_UNIT_INVOCATION_ID(UNIT(s)),
                        LOG_UNIT_MESSAGE(UNIT(s),
                                         "Scheduled restart job%s, restart counter is at %u.",
                                         shortcut ? " immediately on client request" : "", s->n_restarts),
                        LOG_ITEM("N_RESTARTS=%u", s->n_restarts));
 
        service_set_state(s, SERVICE_AUTO_RESTART_QUEUED);
 
        /* Notify clients about changed restart counter */
        unit_add_to_dbus_queue(UNIT(s));
}
 
static void service_enter_reload_by_notify(Service *s) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int r;
 
        assert(s);
 
        r = service_arm_timer(s, /* relative= */ true, s->timeout_start_usec);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                return service_reload_finish(s, SERVICE_FAILURE_RESOURCES);
        }
 
        service_set_state(s, SERVICE_RELOAD_NOTIFY);
 
        /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
        r = manager_propagate_reload(UNIT(s)->manager, UNIT(s), JOB_FAIL, &error);
        if (r < 0)
                log_unit_warning(UNIT(s), "Failed to schedule propagation of reload, ignoring: %s", bus_error_message(&error, r));
}
 
static void service_enter_reload_post(Service *s) {
        int r;
 
        assert(s);
 
        service_unwatch_control_pid(s);
 
        s->control_command = s->exec_command[SERVICE_EXEC_RELOAD_POST];
        if (s->control_command) {
                s->control_command_id = SERVICE_EXEC_RELOAD_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 'reload-post' task: %m");
                        return service_reload_finish(s, SERVICE_FAILURE_RESOURCES);
                }
 
                service_set_state(s, SERVICE_RELOAD_POST);
        } else
                service_reload_finish(s, SERVICE_SUCCESS);
}
 
static int service_check_reload_signal_handler(Service *s, const char *missing_suffix, const char *error_suffix) {
        int r;
 
        assert(s);
 
        if (!pidref_is_set(&s->main_pid) || IN_SET(s->reload_signal, SIGKILL, SIGSTOP))
                return 0;
 
        /* Check if the process has a traditional signal handler (SigCgt) */
        r = pidref_has_sigcgt(&s->main_pid, s->reload_signal);
        if (r < 0) {
                if (r != -ESRCH)
                        log_unit_warning_errno(
                                        UNIT(s), r,
                                        "Failed to check for reload signal handler%s: %m",
                                        strempty(error_suffix));
                return r;
        }
 
        if (r == 0) {
                /* No traditional handler, check if the signal is blocked (SigBlk). A blocked signal is
                 * typically handled via signalfd, which is a valid way to handle signals (e.g., via
                 * sd_event_add_signal() with SD_EVENT_SIGNAL_PROCMASK). */
                r = pidref_has_sigblk(&s->main_pid, s->reload_signal);
                if (r < 0) {
                        if (r != -ESRCH)
                                log_unit_warning_errno(
                                                UNIT(s), r,
                                                "Failed to check for blocked reload signal%s: %m",
                                                strempty(error_suffix));
                        return r;
                }
        }
 
        if (r == 0) {
                log_unit_warning(
                                UNIT(s),
                                "Main process " PID_FMT " lacks handler for reload signal %s%s.",
                                s->main_pid.pid,
                                signal_to_string(s->reload_signal),
                                strempty(missing_suffix));
                return -EOPNOTSUPP;
        }
 
        return 0;
}
 
static void service_enter_reload_signal(Service *s) {
        int r;
 
        assert(s);
 
        if (s->type != SERVICE_NOTIFY_RELOAD)
                return service_enter_reload_post(s);
 
        if (s->state == SERVICE_RELOAD) {
                /* We executed ExecReload=, and the service has already notified us the result?
                 * Directly transition to next state. */
                if (s->notify_state == NOTIFY_RELOADING)
                        return service_set_state(s, SERVICE_RELOAD_NOTIFY);
                if (s->notify_state == NOTIFY_RELOAD_READY)
                        return service_enter_reload_post(s);
        }
 
        if (pidref_is_set(&s->main_pid)) {
                r = service_arm_timer(s, /* relative= */ true, s->timeout_start_usec);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                        goto fail;
                }
 
                /* This is naturally racy, but that's fine. The issue we're looking for is almost always a
                 * static programming error (handler not yet installed), but if a user wants to shoot
                 * themself in the foot intentionally by racing with us, who are we to stop them :-) */
                (void) service_check_reload_signal_handler(
                                s,
                                ", sending reload signal anyway",
                                ", sending reload signal anyway");
 
                r = pidref_kill_and_sigcont(&s->main_pid, s->reload_signal);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to send reload signal: %m");
                        goto fail;
                }
 
                service_set_state(s, SERVICE_RELOAD_SIGNAL);
        } else
                service_enter_reload_post(s);
 
        return;
 
fail:
        service_reload_finish(s, SERVICE_FAILURE_RESOURCES);
}
 
static void service_enter_reload(Service *s) {
        int r;
 
        assert(s);
 
        service_unwatch_control_pid(s);
 
        if (IN_SET(s->notify_state, NOTIFY_RELOADING, NOTIFY_RELOAD_READY))
                s->notify_state = _NOTIFY_STATE_INVALID;
 
        /* Store the timestamp when we started reloading: when reloading via SIGHUP we won't leave the reload
         * state until we received both RELOADING=1 and READY=1 with MONOTONIC_USEC= set to a value above
         * this. Thus we know for sure the reload cycle was executed *after* we requested it, and is not one
         * that was already in progress before. */
        s->reload_begin_usec = now(CLOCK_MONOTONIC);
 
        s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
        if (s->control_command) {
                s->control_command_id = SERVICE_EXEC_RELOAD;
 
                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 'reload' task: %m");
                        return service_reload_finish(s, SERVICE_FAILURE_RESOURCES);
                }
 
                service_set_state(s, SERVICE_RELOAD);
        } else
                service_enter_reload_signal(s);
}
 
static bool service_get_effective_reload_credentials(Service *s) {
        assert(s);
 
        return FLAGS_SET(s->refresh_on_reload_flags, SERVICE_RELOAD_CREDENTIALS) &&
                exec_context_has_credentials(&s->exec_context);
}
 
static void service_enter_refresh_credentials(Service *s) {
        _cleanup_(pidref_done) PidRef worker = PIDREF_NULL;
        int r;
 
        assert(s);
 
        if (!service_get_effective_reload_credentials(s))
                return service_enter_reload(s);
 
        service_unwatch_control_pid(s);
        s->control_command = NULL;
        s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
 
        r = service_arm_timer(s, /* relative = */ true, s->timeout_start_usec);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                goto fail;
        }
 
        r = unit_fork_helper_process_full(UNIT(s), "(sd-refresh-creds)", /* into_cgroup = */ false,
                                          FORK_ALLOW_DLOPEN, /* allow loading libacl to avoid doing so in pid1 */
                                          &worker);
        if (r < 0) {
                log_unit_error_errno(UNIT(s), r, "Failed to fork process to refresh credentials: %m");
                goto fail;
        }
        if (r == 0) {
                LOG_CONTEXT_PUSH_UNIT(UNIT(s));
 
                r = unit_refresh_credentials(UNIT(s));
                if (ERRNO_IS_NEG_PRIVILEGE(r))
                        _exit(EXIT_NOPERMISSION);
                if (r < 0)
                        _exit(EXIT_FAILURE);
                if (r == 0)
                        _exit(EXIT_NOTINSTALLED);
 
                _exit(EXIT_SUCCESS);
        }
 
        r = unit_watch_pidref(UNIT(s), &worker, /* exclusive = */ true);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to watch credentials refresh helper process: %m");
                goto fail;
        }
 
        s->control_pid = TAKE_PIDREF(worker);
        service_set_state(s, SERVICE_REFRESH_CREDENTIALS);
        return;
 
fail:
        service_reload_finish(s, SERVICE_FAILURE_RESOURCES);
}
 
static bool service_can_reload_extensions(Service *s, bool warn) {
        assert(s);
 
        // TODO: Add support for user services, which can use ExtensionDirectories= + notify-reload.
        // For now, skip for user services.
 
        if (exec_context_has_vpicked_extensions(&s->exec_context) <= 0) {
                if (warn)
                        log_unit_warning(UNIT(s), "Service uses RefreshOnReload=extensions, but has no extensions using vpick. Ignoring.");
                return false;
        }
 
        if (!s->exec_command[SERVICE_EXEC_START]) {
                if (warn)
                        log_unit_warning(UNIT(s), "Service uses RefreshOnReload=extensions, but has no main process (ExecStart=). Ignoring.");
                return false;
        }
 
        if (!MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
                if (warn)
                        log_unit_warning(UNIT(s), "Service uses RefreshOnReload=extensions, which is not supported in user mode. Ignoring.");
                return false;
        }
 
        return true;
}
 
static bool service_get_effective_reload_extensions(Service *s) {
        assert(s);
 
        if (!FLAGS_SET(s->refresh_on_reload_flags, SERVICE_RELOAD_EXTENSIONS))
                return false;
 
        if (!service_can_reload_extensions(s, /* warn = */ false))
                return false;
 
        return true;
}
 
static bool service_should_reload_extensions(Service *s) {
        assert(s);
 
        if (!service_get_effective_reload_extensions(s))
                return false;
 
        if (!pidref_is_set(&s->main_pid)) {
                log_unit_debug(UNIT(s), "Not reloading extensions for service without main PID.");
                return false;
        }
 
        return true;
}
 
static void service_enter_refresh_extensions(Service *s) {
        _cleanup_(pidref_done) PidRef worker = PIDREF_NULL;
        int r;
 
        assert(s);
 
        /* If we don't have extensions to refresh, immediately transition to next state */
        if (!service_should_reload_extensions(s))
                return service_enter_refresh_credentials(s);
 
        service_unwatch_control_pid(s);
        s->control_command = NULL;
        s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
 
        r = service_arm_timer(s, /* relative= */ true, s->timeout_start_usec);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                goto fail;
        }
 
        /* Given we are running from PID1, avoid doing potentially heavy I/O operations like opening images
         * directly, and instead fork a worker process. */
        r = unit_fork_helper_process_full(UNIT(s), "(sd-refresh-extensions)", /* into_cgroup= */ false,
                                          FORK_ALLOW_DLOPEN, /* permit dlopen() to avoid load of libcryptsetup in pid1 */
                                          &worker);
        if (r < 0) {
                log_unit_error_errno(UNIT(s), r, "Failed to fork process to refresh extensions in unit's namespace: %m");
                goto fail;
        }
        if (r == 0) {
                LOG_CONTEXT_PUSH_UNIT(UNIT(s));
 
                assert(pidref_is_set(&s->main_pid));
 
                _cleanup_free_ char *propagate_dir = path_join("/run/systemd/propagate/", UNIT(s)->id);
                if (!propagate_dir) {
                        log_unit_error_errno(UNIT(s), -ENOMEM, "Failed to allocate memory for propagate directory: %m");
                        _exit(EXIT_FAILURE);
                }
 
                NamespaceParameters p = {
                        .private_namespace_dir = "/run/systemd",
                        .incoming_dir = "/run/systemd/incoming",
                        .propagate_dir = propagate_dir,
                        .runtime_scope = UNIT(s)->manager->runtime_scope,
                        .extension_images = s->exec_context.extension_images,
                        .n_extension_images = s->exec_context.n_extension_images,
                        .extension_directories = s->exec_context.extension_directories,
                        .extension_image_policy = s->exec_context.extension_image_policy,
                };
 
                /* Only reload confext, and not sysext as they also typically contain the executable(s) used
                 * by the service and a simply reload cannot meaningfully handle that. */
                r = refresh_extensions_in_namespace(
                                &s->main_pid,
                                "SYSTEMD_CONFEXT_HIERARCHIES",
                                &p);
                if (r < 0)
                        log_unit_error_errno(UNIT(s), r, "Failed to refresh extensions in unit's namespace: %m");
                else
                        log_unit_debug(UNIT(s), "Refreshed extensions in unit's namespace");
 
                _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
        }
 
        r = unit_watch_pidref(UNIT(s), &worker, /* exclusive= */ true);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to watch extensions refresh helper process: %m");
                goto fail;
        }
 
        s->control_pid = TAKE_PIDREF(worker);
        service_set_state(s, SERVICE_REFRESH_EXTENSIONS);
        return;
 
fail:
        service_reload_finish(s, SERVICE_FAILURE_RESOURCES);
}
 
static void service_run_next_control(Service *s) {
        usec_t timeout;
        int r;
 
        assert(s);
        assert(s->control_command);
        assert(s->control_command->command_next);
 
        assert(s->control_command_id != SERVICE_EXEC_START);
 
        s->control_command = s->control_command->command_next;
        service_unwatch_control_pid(s);
 
        if (IN_SET(s->state,
                   SERVICE_CONDITION,
                   SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
                   SERVICE_RUNNING,
                   SERVICE_RELOAD, SERVICE_RELOAD_POST))
                timeout = s->timeout_start_usec;
        else
                timeout = s->timeout_stop_usec;
 
        r = service_spawn(s,
                          s->control_command,
                          service_exec_flags(s, s->control_command_id, /* cred_flag = */ 0),
                          timeout,
                          &s->control_pid);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to spawn next control task: %m");
 
                if (IN_SET(s->state, SERVICE_CONDITION, SERVICE_START_PRE, SERVICE_START_POST, SERVICE_STOP))
                        service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
                else if (s->state == SERVICE_STOP_POST)
                        service_enter_dead(s, SERVICE_FAILURE_RESOURCES, /* allow_restart= */ true);
                else if (IN_SET(s->state, SERVICE_RELOAD, SERVICE_RELOAD_POST))
                        service_reload_finish(s, SERVICE_FAILURE_RESOURCES);
                else
                        service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
        }
}
 
static void service_run_next_main(Service *s) {
        _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
        int r;
 
        assert(s);
        assert(s->main_command);
        assert(s->main_command->command_next);
        assert(s->type == SERVICE_ONESHOT);
 
        s->main_command = s->main_command->command_next;
        service_unwatch_main_pid(s);
 
        r = service_spawn(s,
                          s->main_command,
                          service_exec_flags(s, SERVICE_EXEC_START, EXEC_SETUP_CREDENTIALS),
                          s->timeout_start_usec,
                          &pidref);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to spawn next main task: %m");
                service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
                return;
        }
 
        (void) service_set_main_pidref(s, TAKE_PIDREF(pidref), &s->main_command->exec_status.start_timestamp);
}
 
static int service_start(Unit *u) {
        Service *s = ASSERT_PTR(SERVICE(u));
        int r;
 
        if (s->state == SERVICE_AUTO_RESTART) {
                /* As mentioned in unit_start(), we allow manual starts to act as "hurry up" signals
                 * for auto restart. We need to re-enqueue the job though, as the job type has changed
                 * (JOB_RESTART_DEPENDENCIES). */
 
                service_enter_restart(s, /* shortcut= */ true);
                return -EAGAIN;
        }
 
        /* SERVICE_*_BEFORE_AUTO_RESTART are not to be expected here, as those are intermediate states
         * that should never be seen outside of service_enter_dead(). */
        assert(IN_SET(s->state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_DEAD_RESOURCES_PINNED, SERVICE_AUTO_RESTART_QUEUED));
 
        r = unit_acquire_invocation_id(u);
        if (r < 0)
                return r;
 
        s->main_pid_known = false;
        s->main_pid_alien = false;
        s->forbid_restart = false;
 
        /* This is not an automatic restart? Flush the restart counter then. */
        if (s->state != SERVICE_AUTO_RESTART_QUEUED)
                s->n_restarts = 0;
 
        s->result = SERVICE_SUCCESS;
        s->reload_result = SERVICE_SUCCESS;
        s->reload_begin_usec = USEC_INFINITY;
        s->revalidate_runtime_begin_usec = USEC_INFINITY;
 
        s->status_text = mfree(s->status_text);
        s->status_errno = 0;
        s->status_bus_error = mfree(s->status_bus_error);
        s->status_varlink_error = mfree(s->status_varlink_error);
 
        s->notify_access_override = _NOTIFY_ACCESS_INVALID;
        s->notify_state = _NOTIFY_STATE_INVALID;
 
        s->watchdog_original_usec = s->watchdog_usec;
        s->watchdog_override_enable = false;
        s->watchdog_override_usec = USEC_INFINITY;
 
        exec_command_reset_status_list_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
        exec_status_reset(&s->main_exec_status);
 
        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
        if (crt) {
                unit_cgroup_disable_all_controllers(u);
                crt->reset_accounting = true;
        }
 
        service_enter_condition(s);
        return 1;
}
 
static void service_live_mount_finish(Service *s, ServiceResult f, const char *error) {
        assert(s);
        assert(error);
 
        s->live_mount_result = f;
 
        if (!s->mount_request)
                return;
 
        if (f == SERVICE_SUCCESS) {
                (void) sd_bus_reply_method_return(s->mount_request, NULL);
                log_unit_debug(UNIT(s),
                               "'%s' method succeeded",
                               strna(sd_bus_message_get_member(s->mount_request)));
        } else {
                (void) sd_bus_reply_method_errorf(s->mount_request, error,
                                                  "method '%s' for unit '%s' failed",
                                                  strna(sd_bus_message_get_member(s->mount_request)),
                                                  UNIT(s)->id);
                log_unit_debug(UNIT(s),
                               "'%s' method failed: %s",
                               strna(sd_bus_message_get_member(s->mount_request)),
                               error);
        }
 
        s->mount_request = sd_bus_message_unref(s->mount_request);
}
 
static void service_reload_finish(Service *s, ServiceResult f) {
        assert(s);
 
        s->reload_result = f;
        s->reload_begin_usec = USEC_INFINITY;
 
        /* If notify state is still in dangling NOTIFY_RELOADING, reset it so service_enter_running()
         * won't get confused (see #37515) */
        if (s->notify_state == NOTIFY_RELOADING)
                s->notify_state = _NOTIFY_STATE_INVALID;
 
        service_enter_running(s, SERVICE_SUCCESS);
}
 
static int service_stop(Unit *u) {
        Service *s = ASSERT_PTR(SERVICE(u));
 
        /* Don't create restart jobs from manual stops. */
        s->forbid_restart = true;
 
        switch (s->state) {
 
        case SERVICE_STOP:
        case SERVICE_STOP_SIGTERM:
        case SERVICE_STOP_SIGKILL:
        case SERVICE_STOP_POST:
        case SERVICE_FINAL_WATCHDOG:
        case SERVICE_FINAL_SIGTERM:
        case SERVICE_FINAL_SIGKILL:
                /* Already on it */
                return 0;
 
        case SERVICE_AUTO_RESTART:
        case SERVICE_AUTO_RESTART_QUEUED:
                /* Give up on the auto restart */
                service_set_state(s, service_determine_dead_state(s));
                return 0;
 
        case SERVICE_MOUNTING:
                service_live_mount_finish(s, SERVICE_FAILURE_PROTOCOL, BUS_ERROR_UNIT_INACTIVE);
                _fallthrough_;
        case SERVICE_REFRESH_EXTENSIONS:
        case SERVICE_REFRESH_CREDENTIALS:
                service_kill_control_process(s);
                _fallthrough_;
        case SERVICE_CONDITION:
        case SERVICE_START_PRE:
        case SERVICE_START:
        case SERVICE_START_POST:
        case SERVICE_RELOAD:
        case SERVICE_RELOAD_SIGNAL:
        case SERVICE_RELOAD_NOTIFY:
        case SERVICE_RELOAD_POST:
        case SERVICE_STOP_WATCHDOG:
                /* If there's already something running we go directly into kill mode. */
                service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
                return 0;
 
        case SERVICE_CLEANING:
                /* If we are currently cleaning, then abort it, brutally. */
                service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
                return 0;
 
        case SERVICE_RUNNING:
        case SERVICE_RUNNING_REVALIDATING:
        case SERVICE_EXITED:
                service_enter_stop(s, SERVICE_SUCCESS);
                return 1;
 
        case SERVICE_DEAD_BEFORE_AUTO_RESTART:
        case SERVICE_FAILED_BEFORE_AUTO_RESTART:
        case SERVICE_DEAD:
        case SERVICE_FAILED:
        case SERVICE_DEAD_RESOURCES_PINNED:
        default:
                /* Unknown state, or unit_stop() should already have handled these */
                assert_not_reached();
        }
}
 
static int service_reload(Unit *u) {
        Service *s = ASSERT_PTR(SERVICE(u));
 
        assert(IN_SET(s->state, SERVICE_RUNNING, SERVICE_RUNNING_REVALIDATING, SERVICE_EXITED));
 
        s->reload_result = SERVICE_SUCCESS;
        s->refreshed_mask = 0;
 
        service_enter_refresh_extensions(s);
 
        return 1;
}
 
static bool service_can_reload(Unit *u) {
        Service *s = ASSERT_PTR(SERVICE(u));
 
        return s->exec_command[SERVICE_EXEC_RELOAD] ||
                s->type == SERVICE_NOTIFY_RELOAD ||
                (s->refresh_on_reload_set &&
                 (service_get_effective_reload_extensions(s) ||
                  service_get_effective_reload_credentials(s)));
}
 
static unsigned service_exec_command_index(Unit *u, ServiceExecCommand id, const ExecCommand *current) {
        Service *s = SERVICE(u);
        unsigned idx = 0;
 
        assert(s);
        assert(id >= 0);
        assert(id < _SERVICE_EXEC_COMMAND_MAX);
 
        const ExecCommand *first = s->exec_command[id];
 
        /* Figure out where we are in the list by walking back to the beginning */
        for (const ExecCommand *c = current; c != first; c = c->command_prev)
                idx++;
 
        return idx;
}
 
static int service_serialize_exec_command(Unit *u, FILE *f, const ExecCommand *command) {
        Service *s = ASSERT_PTR(SERVICE(u));
        _cleanup_free_ char *args = NULL, *p = NULL;
        const char *type, *key;
        ServiceExecCommand id;
        size_t length = 0;
        unsigned idx;
 
        assert(f);
 
        if (!command)
                return 0;
 
        if (command == s->control_command) {
                type = "control";
                id = s->control_command_id;
        } else {
                type = "main";
                id = SERVICE_EXEC_START;
        }
 
        idx = service_exec_command_index(u, id, command);
 
        STRV_FOREACH(arg, command->argv) {
                _cleanup_free_ char *e = NULL;
                size_t n;
 
                e = cescape(*arg);
                if (!e)
                        return log_oom();
 
                n = strlen(e);
                if (!GREEDY_REALLOC(args, length + 2 + n + 2))
                        return log_oom();
 
                if (length > 0)
                        args[length++] = ' ';
 
                args[length++] = '"';
                memcpy(args + length, e, n);
                length += n;
                args[length++] = '"';
        }
 
        if (!GREEDY_REALLOC(args, length + 1))
                return log_oom();
 
        args[length++] = 0;
 
        p = cescape(command->path);
        if (!p)
                return log_oom();
 
        key = strjoina(type, "-command");
 
        /* We use '+1234' instead of '1234' to mark the last command in a sequence.
         * This is used in service_deserialize_exec_command(). */
        (void) serialize_item_format(
                        f, key,
                        "%s %s%u %s %s",
                        service_exec_command_to_string(id),
                        command->command_next ? "" : "+",
                        idx,
                        p, args);
 
        return 0;
}
 
static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
        Service *s = ASSERT_PTR(SERVICE(u));
        int r;
 
        assert(f);
        assert(fds);
 
        (void) serialize_item(f, "state", service_state_to_string(s->state));
        (void) serialize_item(f, "result", service_result_to_string(s->result));
        (void) serialize_item(f, "reload-result", service_result_to_string(s->reload_result));
        (void) serialize_item(f, "live-mount-result", service_result_to_string(s->live_mount_result));
 
        (void) serialize_pidref(f, fds, "control-pid", &s->control_pid);
        if (s->main_pid_known)
                (void) serialize_pidref(f, fds, "main-pid", &s->main_pid);
 
        (void) serialize_bool(f, "main-pid-known", s->main_pid_known);
        (void) serialize_bool(f, "bus-name-good", s->bus_name_good);
 
        (void) serialize_item_format(f, "n-restarts", "%u", s->n_restarts);
        (void) serialize_usec(f, "restart-randomized-delay-chosen-usec", s->restart_randomized_delay_chosen_usec);
        (void) serialize_bool(f, "forbid-restart", s->forbid_restart);
 
        service_serialize_exec_command(u, f, s->control_command);
        service_serialize_exec_command(u, f, s->main_command);
 
        r = serialize_fd(f, fds, "stdin-fd", s->stdin_fd);
        if (r < 0)
                return r;
 
        r = serialize_fd(f, fds, "stdout-fd", s->stdout_fd);
        if (r < 0)
                return r;
 
        r = serialize_fd(f, fds, "stderr-fd", s->stderr_fd);
        if (r < 0)
                return r;
 
        r = serialize_fd(f, fds, "root-directory-fd", s->root_directory_fd);
        if (r < 0)
                return r;
 
        if (s->exec_fd_event_source) {
                r = serialize_fd(f, fds, "exec-fd", sd_event_source_get_io_fd(s->exec_fd_event_source));
                if (r < 0)
                        return r;
 
                (void) serialize_bool(f, "exec-fd-hot", s->exec_fd_hot);
        }
 
        if (UNIT_ISSET(s->accept_socket)) {
                r = serialize_item(f, "accept-socket", UNIT_DEREF(s->accept_socket)->id);
                if (r < 0)
                        return r;
        }
 
        r = serialize_fd(f, fds, "socket-fd", s->socket_fd);
        if (r < 0)
                return r;
 
        LIST_FOREACH(fd_store, fs, s->fd_store) {
                _cleanup_free_ char *c = NULL;
                int copy;
 
                copy = fdset_put_dup(fds, fs->fd);
                if (copy < 0)
                        return log_error_errno(copy, "Failed to copy file descriptor for serialization: %m");
 
                c = cescape(fs->fdname);
                if (!c)
                        return log_oom();
 
                (void) serialize_item_format(f, "fd-store-fd", "%i \"%s\" %s %" PRIu64,
                                             copy, c, one_zero(fs->do_poll), fs->index);
        }
 
        FOREACH_ARRAY(i, s->extra_fds, s->n_extra_fds) {
                _cleanup_free_ char *c = NULL;
                int copy;
 
                copy = fdset_put_dup(fds, i->fd);
                if (copy < 0)
                        return log_error_errno(copy, "Failed to copy file descriptor for serialization: %m");
 
                c = cescape(i->fdname);
                if (!c)
                        return log_oom();
 
                (void) serialize_item_format(f, "extra-fd", "%i \"%s\"", copy, c);
        }
 
        if (s->main_exec_status.pid > 0) {
                (void) serialize_item_format(f, "main-exec-status-pid", PID_FMT, s->main_exec_status.pid);
                (void) serialize_dual_timestamp(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
                (void) serialize_dual_timestamp(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
                (void) serialize_dual_timestamp(f, "main-exec-status-handoff", &s->main_exec_status.handoff_timestamp);
 
                if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
                        (void) serialize_item_format(f, "main-exec-status-code", "%i", s->main_exec_status.code);
                        (void) serialize_item_format(f, "main-exec-status-status", "%i", s->main_exec_status.status);
                }
        }
 
        if (s->notify_access_override >= 0)
                (void) serialize_item(f, "notify-access-override", notify_access_to_string(s->notify_access_override));
        if (s->notify_state >= 0)
                (void) serialize_item(f, "notify-state", notify_state_to_string(s->notify_state));
 
        r = serialize_item_escaped(f, "status-text", s->status_text);
        if (r < 0)
                return r;
 
        (void) serialize_item_format(f, "status-errno", "%d", s->status_errno);
        (void) serialize_item(f, "status-bus-error", s->status_bus_error);
        (void) serialize_item(f, "status-varlink-error", s->status_varlink_error);
 
        (void) serialize_dual_timestamp(f, "watchdog-timestamp", &s->watchdog_timestamp);
 
        (void) serialize_usec(f, "watchdog-original-usec", s->watchdog_original_usec);
        if (s->watchdog_override_enable)
                (void) serialize_usec(f, "watchdog-override-usec", s->watchdog_override_usec);
 
        (void) serialize_usec(f, "reload-begin-usec", s->reload_begin_usec);
        (void) serialize_usec(f, "revalidate-runtime-begin-usec", s->revalidate_runtime_begin_usec);
 
        if (s->refreshed_mask > 0) {
                _cleanup_strv_free_ char **l = NULL;
                _cleanup_free_ char *t = NULL;