HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/core/service.c
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;