[SERVICE_START] = UNIT_ACTIVATING,
[SERVICE_START_POST] = UNIT_ACTIVATING,
[SERVICE_RUNNING] = UNIT_ACTIVE,
+ [SERVICE_EXITED] = UNIT_ACTIVE,
[SERVICE_RELOAD] = UNIT_ACTIVE_RELOADING,
[SERVICE_STOP] = UNIT_DEACTIVATING,
[SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
[SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
};
+static void service_unwatch_control_pid(Service *s) {
+ assert(s);
+
+ if (s->control_pid <= 0)
+ return;
+
+ unit_unwatch_pid(UNIT(s), s->control_pid);
+ s->control_pid = 0;
+}
+
+static void service_unwatch_main_pid(Service *s) {
+ assert(s);
+
+ if (s->main_pid <= 0)
+ return;
+
+ unit_unwatch_pid(UNIT(s), s->main_pid);
+ s->main_pid = 0;
+}
+
static void service_done(Unit *u) {
Service *s = SERVICE(u);
/* This will leak a process, but at least no memory or any of
* our resources */
- if (s->main_pid > 0) {
- unit_unwatch_pid(u, s->main_pid);
- s->main_pid = 0;
- }
-
- if (s->control_pid > 0) {
- unit_unwatch_pid(u, s->control_pid);
- s->control_pid = 0;
- }
+ service_unwatch_main_pid(s);
+ service_unwatch_control_pid(s);
unit_unwatch_timer(u, &s->timer_watch);
}
goto finish;
}
+ /* Special setting for all SysV services */
+ s->valid_no_process = true;
+
u->meta.load_state = UNIT_LOADED;
r = 0;
if (s->main_pid_known)
return 0;
+ assert(s->main_pid <= 0);
+
if (!s->pid_file)
return -ENOENT;
state != SERVICE_STOP &&
state != SERVICE_STOP_SIGTERM &&
state != SERVICE_STOP_SIGKILL)
- if (s->main_pid > 0) {
- unit_unwatch_pid(UNIT(s), s->main_pid);
- s->main_pid = 0;
- }
+ service_unwatch_main_pid(s);
if (state != SERVICE_START_PRE &&
state != SERVICE_START &&
state != SERVICE_STOP_POST &&
state != SERVICE_FINAL_SIGTERM &&
state != SERVICE_FINAL_SIGKILL) {
- if (s->control_pid > 0) {
- unit_unwatch_pid(UNIT(s), s->control_pid);
- s->control_pid = 0;
- }
-
+ service_unwatch_control_pid(s);
s->control_command = NULL;
}
fds, n_fds,
apply_permissions,
apply_chroot,
+ UNIT(s)->meta.manager->confirm_spawn,
UNIT(s)->meta.cgroup_bondings,
&pid)) < 0)
goto fail;
return r;
}
+static int main_pid_good(Service *s) {
+ assert(s);
+
+ /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
+ * don't know */
+
+ /* If we know the pid file, then lets just check if it is
+ * still valid */
+ if (s->main_pid_known)
+ return s->main_pid > 0;
+
+ /* We don't know the pid */
+ return -EAGAIN;
+}
+
+static int control_pid_good(Service *s) {
+ assert(s);
+
+ return s->control_pid > 0;
+}
+
+static int cgroup_good(Service *s) {
+ int r;
+
+ assert(s);
+
+ if (s->valid_no_process)
+ return -EAGAIN;
+
+ if ((r = cgroup_bonding_is_empty_list(UNIT(s)->meta.cgroup_bondings)) < 0)
+ return r;
+
+ return !r;
+}
+
static void service_enter_dead(Service *s, bool success, bool allow_restart) {
int r;
assert(s);
if (!success)
s->failure = true;
- if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST]))
+ service_unwatch_control_pid(s);
+
+ if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
if ((r = service_spawn(s,
s->control_command,
true,
goto fail;
- service_set_state(s, SERVICE_STOP_POST);
-
- if (!s->control_command)
- service_enter_dead(s, true, true);
+ service_set_state(s, SERVICE_STOP_POST);
+ } else
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, true);
return;
fail:
- log_warning("%s failed to run stop executable: %s", unit_id(UNIT(s)), strerror(-r));
+ log_warning("%s failed to run stop-post executable: %s", unit_id(UNIT(s)), strerror(-r));
service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
}
if (!success)
s->failure = true;
- if (s->main_pid > 0 || s->control_pid > 0) {
- int sig;
-
- sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
+ if (s->kill_mode != KILL_NONE) {
+ int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
if (s->kill_mode == KILL_CONTROL_GROUP) {
if (!sent) {
r = 0;
+
if (s->main_pid > 0) {
if (kill(s->kill_mode == KILL_PROCESS ? s->main_pid : -s->main_pid, sig) < 0 && errno != ESRCH)
r = -errno;
}
}
- service_set_state(s, state);
+ if (sent) {
+ if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
+ goto fail;
- if (s->main_pid <= 0 && s->control_pid <= 0)
+ service_set_state(s, state);
+ } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
+ service_enter_stop_post(s, true);
+ else
service_enter_dead(s, true, true);
return;
fail:
log_warning("%s failed to kill processes: %s", unit_id(UNIT(s)), strerror(-r));
- if (sent) {
- s->failure = true;
- service_set_state(s, state);
- } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
+ if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
service_enter_stop_post(s, false);
else
service_enter_dead(s, false, true);
if (!success)
s->failure = true;
- if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP]))
+ service_unwatch_control_pid(s);
+
+ if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
if ((r = service_spawn(s,
s->control_command,
true,
&s->control_pid)) < 0)
goto fail;
- service_set_state(s, SERVICE_STOP);
-
- if (!s->control_command)
+ service_set_state(s, SERVICE_STOP);
+ } else
service_enter_signal(s, SERVICE_STOP_SIGTERM, true);
return;
service_enter_signal(s, SERVICE_STOP_SIGTERM, false);
}
+static void service_enter_running(Service *s, bool success) {
+ assert(s);
+
+ if (!success)
+ s->failure = true;
+
+ if (main_pid_good(s) != 0 && cgroup_good(s) != 0)
+ service_set_state(s, SERVICE_RUNNING);
+ else if (s->valid_no_process)
+ service_set_state(s, SERVICE_EXITED);
+ else
+ service_enter_stop(s, true);
+}
+
static void service_enter_start_post(Service *s) {
int r;
assert(s);
- if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST]))
+ service_unwatch_control_pid(s);
+
+ if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
if ((r = service_spawn(s,
s->control_command,
true,
goto fail;
- service_set_state(s, SERVICE_START_POST);
-
- if (!s->control_command)
- service_set_state(s, SERVICE_RUNNING);
+ service_set_state(s, SERVICE_START_POST);
+ } else
+ service_enter_running(s, true);
return;
assert(s->exec_command[SERVICE_EXEC_START]);
assert(!s->exec_command[SERVICE_EXEC_START]->command_next);
+ if (s->type == SERVICE_FORKING)
+ service_unwatch_control_pid(s);
+ else
+ service_unwatch_main_pid(s);
+
if ((r = service_spawn(s,
s->exec_command[SERVICE_EXEC_START],
s->type == SERVICE_FORKING,
&pid)) < 0)
goto fail;
- service_set_state(s, SERVICE_START);
-
if (s->type == SERVICE_SIMPLE) {
/* For simple services we immediately start
* the START_POST binaries. */
s->main_pid = pid;
s->main_pid_known = true;
+
service_enter_start_post(s);
} else if (s->type == SERVICE_FORKING) {
* process exited. */
s->control_pid = pid;
+
s->control_command = s->exec_command[SERVICE_EXEC_START];
+ service_set_state(s, SERVICE_START);
+
} else if (s->type == SERVICE_FINISH) {
/* For finishing services we wait until the start
* process exited, too, but it is our main process. */
s->main_pid = pid;
+ s->main_pid_known = true;
+
s->control_command = s->exec_command[SERVICE_EXEC_START];
+ service_set_state(s, SERVICE_START);
} else
assert_not_reached("Unknown service type");
fail:
log_warning("%s failed to run start exectuable: %s", unit_id(UNIT(s)), strerror(-r));
- service_enter_stop(s, false);
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
}
static void service_enter_start_pre(Service *s) {
assert(s);
- if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE]))
+ service_unwatch_control_pid(s);
+
+ if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
if ((r = service_spawn(s,
s->control_command,
true,
&s->control_pid)) < 0)
goto fail;
- service_set_state(s, SERVICE_START_PRE);
-
- if (!s->control_command)
+ service_set_state(s, SERVICE_START_PRE);
+ } else
service_enter_start(s);
return;
assert(s);
- if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD]))
+ service_unwatch_control_pid(s);
+
+ if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
if ((r = service_spawn(s,
s->control_command,
true,
&s->control_pid)) < 0)
goto fail;
- service_set_state(s, SERVICE_RELOAD);
-
- if (!s->control_command)
- service_set_state(s, SERVICE_RUNNING);
+ service_set_state(s, SERVICE_RELOAD);
+ } else
+ service_enter_running(s, true);
return;
s->control_command = s->control_command->command_next;
+ service_unwatch_control_pid(s);
+
if ((r = service_spawn(s,
s->control_command,
true,
fail:
log_warning("%s failed to run spawn next executable: %s", unit_id(UNIT(s)), strerror(-r));
- if (s->state == SERVICE_STOP)
- service_enter_stop_post(s, false);
+ if (s->state == SERVICE_START_PRE)
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
+ else if (s->state == SERVICE_STOP)
+ service_enter_signal(s, SERVICE_STOP_SIGTERM, false);
else if (s->state == SERVICE_STOP_POST)
service_enter_dead(s, false, true);
else
return 0;
}
- assert(s->state == SERVICE_RUNNING);
+ assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
service_enter_stop(s, true);
return 0;
assert(s);
- assert(s->state == SERVICE_RUNNING);
+ assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
service_enter_reload(s);
return 0;
return state_translation_table[SERVICE(u)->state];
}
-static int main_pid_good(Service *s) {
- assert(s);
-
- /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
- * don't know */
-
- /* If we know the pid file, then lets just check if it is
- * still valid */
- if (s->main_pid_known)
- return s->main_pid > 0;
-
- /* We don't know the pid */
- return -EAGAIN;
-}
-
-static bool control_pid_good(Service *s) {
- assert(s);
-
- return s->control_pid > 0;
-}
-
-static int cgroup_good(Service *s) {
- assert(s);
-
- if (s->valid_no_process)
- return -EAGAIN;
-
- return cgroup_bonding_is_empty_list(UNIT(s)->meta.cgroup_bondings);
-}
-
static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
Service *s = SERVICE(u);
bool success;
if (success)
service_enter_start_post(s);
else
- service_enter_stop(s, false);
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
break;
case SERVICE_RUNNING:
- service_enter_stop(s, success);
+ service_enter_running(s, success);
break;
case SERVICE_STOP_SIGTERM:
/* If we are shutting things down anyway we
* don't care about failing commands. */
- if (s->control_command->command_next &&
- (success || (s->state == SERVICE_STOP || s->state == SERVICE_STOP_POST)))
+ if (s->control_command->command_next && success) {
/* There is another command to *
* execute, so let's do that. */
+ log_debug("%s running next command for state %s", unit_id(u), service_state_to_string(s->state));
service_run_next(s, success);
- else {
+ } else {
/* No further commands for this step, so let's
* figure out what to do next */
if (success)
service_enter_start(s);
else
- service_enter_stop(s, false);
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
break;
case SERVICE_START:
service_enter_start_post(s);
} else
- service_enter_stop(s, false);
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
break;
/* Fall through */
case SERVICE_RELOAD:
- if (success) {
- if (main_pid_good(s) != 0 && cgroup_good(s) != 0)
- service_set_state(s, SERVICE_RUNNING);
- else
- service_enter_stop(s, true);
- } else
+ if (success)
+ service_enter_running(s, true);
+ else
service_enter_stop(s, false);
break;
case SERVICE_STOP:
- if (main_pid_good(s) > 0)
- /* Still not dead and we know the PID? Let's go hunting. */
- service_enter_signal(s, SERVICE_STOP_SIGTERM, success);
- else
- service_enter_stop_post(s, success);
+ service_enter_signal(s, SERVICE_STOP_SIGTERM, success);
break;
case SERVICE_STOP_SIGTERM:
case SERVICE_START_PRE:
case SERVICE_START:
+ log_warning("%s operation timed out. Terminating.", unit_id(u));
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
+ break;
+
case SERVICE_START_POST:
case SERVICE_RELOAD:
log_warning("%s operation timed out. Stopping.", unit_id(u));
* SIGCHLD for. */
case SERVICE_RUNNING:
-
- if (!s->valid_no_process && main_pid_good(s) <= 0)
- service_enter_stop(s, true);
-
+ service_enter_running(s, true);
break;
default:
[SERVICE_START] = "start",
[SERVICE_START_POST] = "start-post",
[SERVICE_RUNNING] = "running",
+ [SERVICE_EXITED] = "exited",
[SERVICE_RELOAD] = "reload",
[SERVICE_STOP] = "stop",
[SERVICE_STOP_SIGTERM] = "stop-sigterm",
static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
[SERVICE_ONCE] = "once",
[SERVICE_RESTART_ON_SUCCESS] = "restart-on-success",
- [SERVICE_RESTART_ALWAYS] = "restart-on-failure",
+ [SERVICE_RESTART_ALWAYS] = "restart-always",
};
DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
~ianmdlvl / elogind.git / blobdiff