X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=service.c;h=e661dc7586cc7a2d0f3b9913f58d1ce861a2e041;hp=ac9c39c3c83d16dfd88b69c045e0483b6771b945;hb=034c6ed7da5e44bfdde5a5d0da75f7b7a59953b8;hpb=9152c765065184d0c1267ed2499e3fe4cac53755 diff --git a/service.c b/service.c index ac9c39c3c..e661dc758 100644 --- a/service.c +++ b/service.c @@ -1,11 +1,30 @@ /*-*- Mode: C; c-basic-offset: 8 -*-*/ #include +#include #include "name.h" #include "service.h" #include "load-fragment.h" #include "load-dropin.h" +#include "log.h" + +static const NameActiveState state_table[_SERVICE_STATE_MAX] = { + [SERVICE_DEAD] = NAME_INACTIVE, + [SERVICE_START_PRE] = NAME_ACTIVATING, + [SERVICE_START] = NAME_ACTIVATING, + [SERVICE_START_POST] = NAME_ACTIVATING, + [SERVICE_RUNNING] = NAME_ACTIVE, + [SERVICE_RELOAD] = NAME_ACTIVE_RELOADING, + [SERVICE_STOP] = NAME_DEACTIVATING, + [SERVICE_STOP_SIGTERM] = NAME_DEACTIVATING, + [SERVICE_STOP_SIGKILL] = NAME_DEACTIVATING, + [SERVICE_STOP_POST] = NAME_DEACTIVATING, + [SERVICE_FINAL_SIGTERM] = NAME_DEACTIVATING, + [SERVICE_FINAL_SIGKILL] = NAME_DEACTIVATING, + [SERVICE_MAINTAINANCE] = NAME_INACTIVE, + [SERVICE_AUTO_RESTART] = NAME_ACTIVATING, +}; static int service_load_sysv(Service *s) { assert(s); @@ -16,13 +35,26 @@ static int service_load_sysv(Service *s) { return -ENOENT; } -static int service_load(Name *n) { +static int service_init(Name *n) { int r; Service *s = SERVICE(n); assert(s); - exec_context_defaults(&s->exec_context); + /* First, reset everything to the defaults, in case this is a + * reload */ + + s->type = 0; + s->restart = 0; + + s->timeout_usec = DEFAULT_TIMEOUT_USEC; + s->restart_usec = DEFAULT_RESTART_USEC; + + exec_context_init(&s->exec_context); + + s->timer_id = -1; + + s->state = SERVICE_DEAD; /* Load a .service file */ r = name_load_fragment(n); @@ -41,6 +73,33 @@ static int service_load(Name *n) { return 0; } +static void service_done(Name *n) { + Service *s = SERVICE(n); + + assert(s); + + free(s->pid_file); + s->pid_file = NULL; + + exec_context_done(&s->exec_context); + exec_command_free_array(s->exec_command, _SERVICE_EXEC_MAX); + s->control_command = NULL; + + /* This will leak a process, but at least no memory or any of + * our resources */ + if (s->main_pid > 0) { + name_unwatch_pid(n, s->main_pid); + s->main_pid = 0; + } + + if (s->control_pid > 0) { + name_unwatch_pid(n, s->control_pid); + s->control_pid = 0; + } + + name_unwatch_timer(n, &s->timer_id); +} + static void service_dump(Name *n, FILE *f, const char *prefix) { static const char* const state_table[_SERVICE_STATE_MAX] = { @@ -49,27 +108,24 @@ static void service_dump(Name *n, FILE *f, const char *prefix) { [SERVICE_START] = "start", [SERVICE_START_POST] = "post", [SERVICE_RUNNING] = "running", - [SERVICE_RELOAD_PRE] = "reload-pre", [SERVICE_RELOAD] = "reload", - [SERVICE_RELOAD_POST] = "reload-post", - [SERVICE_STOP_PRE] = "stop-pre", [SERVICE_STOP] = "stop", - [SERVICE_SIGTERM] = "sigterm", - [SERVICE_SIGKILL] = "sigkill", + [SERVICE_STOP_SIGTERM] = "stop-sigterm", + [SERVICE_STOP_SIGKILL] = "stop-sigkill", [SERVICE_STOP_POST] = "stop-post", - [SERVICE_MAINTAINANCE] = "maintainance" + [SERVICE_FINAL_SIGTERM] = "final-sigterm", + [SERVICE_FINAL_SIGKILL] = "final-sigkill", + [SERVICE_MAINTAINANCE] = "maintainance", + [SERVICE_AUTO_RESTART] = "auto-restart", }; static const char* const command_table[_SERVICE_EXEC_MAX] = { - [SERVICE_EXEC_START_PRE] = "StartPre", - [SERVICE_EXEC_START] = "Start", - [SERVICE_EXEC_START_POST] = "StartPost", - [SERVICE_EXEC_RELOAD_PRE] = "ReloadPre", - [SERVICE_EXEC_RELOAD] = "Reload", - [SERVICE_EXEC_RELOAD_POST] = "ReloadPost", - [SERVICE_EXEC_STOP_PRE] = "StopPre", - [SERVICE_EXEC_STOP] = "Stop", - [SERVICE_EXEC_STOP_POST] = "StopPost", + [SERVICE_EXEC_START_PRE] = "ExecStartPre", + [SERVICE_EXEC_START] = "ExecStart", + [SERVICE_EXEC_START_POST] = "ExecStartPost", + [SERVICE_EXEC_RELOAD] = "ExecReload", + [SERVICE_EXEC_STOP] = "ExecStop", + [SERVICE_EXEC_STOP_POST] = "ExecStopPost", }; ServiceExecCommand c; @@ -81,21 +137,407 @@ static void service_dump(Name *n, FILE *f, const char *prefix) { "%sService State: %s\n", prefix, state_table[s->state]); + if (s->pid_file) + fprintf(f, + "%sPIDFile: %s\n", + prefix, s->pid_file); + + exec_context_dump(&s->exec_context, f, prefix); for (c = 0; c < _SERVICE_EXEC_MAX; c++) { ExecCommand *i; - LIST_FOREACH(i, s->exec_command[c]) + LIST_FOREACH(command, i, s->exec_command[c]) fprintf(f, "%s%s: %s\n", prefix, command_table[c], i->path); } } -static int service_set_state(Service *s, ServiceState state) { +static int service_load_pid_file(Service *s) { + char *k; + unsigned long p; + int r; + + assert(s); + + if (s->main_pid_known) + return 0; + + if (!s->pid_file) + return -ENOENT; + + if ((r = read_one_line_file(s->pid_file, &k)) < 0) + return r; + + if ((r = safe_atolu(k, &p)) < 0) { + free(k); + return r; + } + + if ((unsigned long) (pid_t) p != p) + return -ERANGE; + + s->main_pid = p; + s->main_pid_known = true; + + return 0; +} + +static void service_set_state(Service *s, ServiceState state) { + ServiceState old_state; assert(s); + old_state = s->state; s->state = state; + + if (state != SERVICE_START_PRE && + state != SERVICE_START && + state != SERVICE_START_POST && + state != SERVICE_RELOAD && + state != SERVICE_STOP && + state != SERVICE_STOP_SIGTERM && + state != SERVICE_STOP_SIGKILL && + state != SERVICE_STOP_POST && + state != SERVICE_FINAL_SIGTERM && + state != SERVICE_FINAL_SIGKILL && + state != SERVICE_AUTO_RESTART) + name_unwatch_timer(NAME(s), &s->timer_id); + + if (state != SERVICE_START_POST && + state != SERVICE_RUNNING && + state != SERVICE_RELOAD && + state != SERVICE_STOP && + state != SERVICE_STOP_SIGTERM && + state != SERVICE_STOP_SIGKILL) + if (s->main_pid >= 0) { + name_unwatch_pid(NAME(s), s->main_pid); + s->main_pid = 0; + } + + if (state != SERVICE_START_PRE && + state != SERVICE_START && + state != SERVICE_START_POST && + state != SERVICE_RELOAD && + state != SERVICE_STOP && + state != SERVICE_STOP_SIGTERM && + state != SERVICE_STOP_SIGKILL && + state != SERVICE_STOP_POST && + state != SERVICE_FINAL_SIGTERM && + state != SERVICE_FINAL_SIGKILL) + if (s->control_pid >= 0) { + name_unwatch_pid(NAME(s), s->control_pid); + s->control_pid = 0; + } + + if (state != SERVICE_START_PRE && + state != SERVICE_START && + state != SERVICE_START_POST && + state != SERVICE_RELOAD && + state != SERVICE_STOP && + state != SERVICE_STOP_POST) + s->control_command = NULL; + + name_notify(NAME(s), state_table[old_state], state_table[s->state]); +} + +static int service_spawn(Service *s, ExecCommand *c, bool timeout, pid_t *_pid) { + pid_t pid; + int r; + + assert(s); + assert(c); + assert(_pid); + + if (timeout) { + if ((r = name_watch_timer(NAME(s), s->timeout_usec, &s->timer_id)) < 0) + goto fail; + } else + name_unwatch_timer(NAME(s), &s->timer_id); + + if ((r = exec_spawn(c, &s->exec_context, NULL, 0, &pid)) < 0) + goto fail; + + if ((r = name_watch_pid(NAME(s), pid)) < 0) + /* FIXME: we need to do something here */ + goto fail; + + *_pid = pid; + return 0; + +fail: + if (timeout) + name_unwatch_timer(NAME(s), &s->timer_id); + + return r; +} + +static void service_enter_dead(Service *s, bool success, bool allow_restart) { + int r; + assert(s); + + if (!success) + s->failure = true; + + if (allow_restart && + (s->restart == SERVICE_RESTART_ALWAYS || + (s->restart == SERVICE_RESTART_ON_SUCCESS && !s->failure))) { + + if ((r = name_watch_timer(NAME(s), s->restart_usec, &s->timer_id)) < 0) + goto fail; + + service_set_state(s, SERVICE_AUTO_RESTART); + } else + service_set_state(s, s->failure ? SERVICE_MAINTAINANCE : SERVICE_DEAD); + + return; + +fail: + log_warning("%s failed to run install restart timer: %s", name_id(NAME(s)), strerror(-r)); + service_enter_dead(s, false, false); +} + +static void service_enter_signal(Service *s, ServiceState state, bool success); + +static void service_enter_stop_post(Service *s, bool success) { + int r; + assert(s); + + if (!success) + s->failure = true; + + if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) { + + if ((r = service_spawn(s, s->control_command, true, &s->control_pid)) < 0) + goto fail; + + service_set_state(s, SERVICE_STOP_POST); + } else + service_enter_dead(s, true, true); + + return; + +fail: + log_warning("%s failed to run stop executable: %s", name_id(NAME(s)), strerror(-r)); + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); +} + +static void service_enter_signal(Service *s, ServiceState state, bool success) { + int r; + bool sent = false; + + assert(s); + + 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; + + r = 0; + if (s->main_pid > 0) { + if (kill(s->main_pid, sig) < 0 && errno != ESRCH) + r = -errno; + else + sent = true; + } + + if (s->control_pid > 0) { + if (kill(s->control_pid, sig) < 0 && errno != ESRCH) + r = -errno; + else + sent = true; + } + + if (r < 0) + goto fail; + + service_set_state(s, state); + } else + service_enter_dead(s, true, true); + + return; + +fail: + log_warning("%s failed to kill processes: %s", name_id(NAME(s)), strerror(-r)); + + if (sent) { + s->failure = true; + service_set_state(s, state); + } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL) + service_enter_stop_post(s, false); + else + service_enter_dead(s, false, true); +} + +static void service_enter_stop(Service *s, bool success) { + int r; + assert(s); + + if (!success) + s->failure = true; + + 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); + } else + service_enter_signal(s, SERVICE_STOP_SIGTERM, true); + + return; + +fail: + log_warning("%s failed to run stop executable: %s", name_id(NAME(s)), strerror(-r)); + service_enter_signal(s, SERVICE_STOP_SIGTERM, false); +} + +static void service_enter_start_post(Service *s) { + int r; + assert(s); + + if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) { + + if ((r = service_spawn(s, s->control_command, true, &s->control_pid)) < 0) + goto fail; + + service_set_state(s, SERVICE_START_POST); + } else + service_set_state(s, SERVICE_RUNNING); + + return; + +fail: + log_warning("%s failed to run start-post executable: %s", name_id(NAME(s)), strerror(-r)); + service_enter_stop(s, false); +} + +static void service_enter_start(Service *s) { + pid_t pid; + int r; + + assert(s); + + assert(s->exec_command[SERVICE_EXEC_START]); + assert(!s->exec_command[SERVICE_EXEC_START]->command_next); + + if ((r = service_spawn(s, s->exec_command[SERVICE_EXEC_START], s->type == SERVICE_FORKING, &pid)) < 0) + goto fail; + + 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) { + + /* For forking services we wait until the start + * process exited. */ + + s->control_pid = pid; + s->control_command = s->exec_command[SERVICE_EXEC_START]; + service_set_state(s, SERVICE_START); + } else + assert_not_reached("Unknown service type"); + + return; + +fail: + log_warning("%s failed to run start exectuable: %s", name_id(NAME(s)), strerror(-r)); + service_enter_stop(s, false); +} + +static void service_enter_start_pre(Service *s) { + int r; + + assert(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); + } else + service_enter_start(s); + + return; + +fail: + log_warning("%s failed to run start-pre executable: %s", name_id(NAME(s)), strerror(-r)); + service_enter_dead(s, false, true); +} + +static void service_enter_restart(Service *s) { + int r; + assert(s); + + if ((r = manager_add_job(NAME(s)->meta.manager, JOB_START, NAME(s), JOB_FAIL, false, NULL)) < 0) + goto fail; + + log_debug("%s scheduled restart job.", name_id(NAME(s))); + service_enter_dead(s, true, false); + return; + +fail: + + log_warning("%s failed to schedule restart job: %s", name_id(NAME(s)), strerror(-r)); + service_enter_dead(s, false, false); +} + +static void service_enter_reload(Service *s) { + int r; + + assert(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); + } else + service_set_state(s, SERVICE_RUNNING); + + return; + +fail: + log_warning("%s failed to run reload executable: %s", name_id(NAME(s)), strerror(-r)); + service_enter_stop(s, false); +} + +static void service_run_next(Service *s, bool success) { + int r; + + assert(s); + assert(s->control_command); + assert(s->control_command->command_next); + + if (!success) + s->failure = true; + + s->control_command = s->control_command->command_next; + + if ((r = service_spawn(s, s->control_command, true, &s->control_pid)) < 0) + goto fail; + + return; + +fail: + log_warning("%s failed to run spawn next executable: %s", name_id(NAME(s)), strerror(-r)); + + if (s->state == SERVICE_STOP) + service_enter_stop_post(s, false); + else if (s->state == SERVICE_STOP_POST) + service_enter_dead(s, false, true); + else + service_enter_stop(s, false); } static int service_start(Name *n) { @@ -103,17 +545,29 @@ static int service_start(Name *n) { assert(s); - /* We cannot fulfill this request right now */ - if (s->state == SERVICE_STOP_PRE || - s->state == SERVICE_STOP || - s->state == SERVICE_SIGTERM || - s->state == SERVICE_SIGKILL || - s->state == SERVICE_STOP_POST) + /* We cannot fulfill this request right now, try again later + * please! */ + if (s->state == SERVICE_STOP || + s->state == SERVICE_STOP_SIGTERM || + s->state == SERVICE_STOP_SIGKILL || + s->state == SERVICE_STOP_POST || + s->state == SERVICE_FINAL_SIGTERM || + s->state == SERVICE_FINAL_SIGKILL) return -EAGAIN; - assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTAINANCE); + /* Already on it! */ + if (s->state == SERVICE_START_PRE || + s->state == SERVICE_START || + s->state == SERVICE_START_POST) + return 0; + + assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTAINANCE || s->state == SERVICE_AUTO_RESTART); - return service_set_state(s, SERVICE_START_PRE); + s->failure = false; + s->main_pid_known = false; + + service_enter_start_pre(s); + return 0; } static int service_stop(Name *n) { @@ -121,62 +575,308 @@ static int service_stop(Name *n) { assert(s); + if (s->state == SERVICE_START_PRE || + s->state == SERVICE_START || + s->state == SERVICE_START_POST || + s->state == SERVICE_RELOAD) + return -EAGAIN; + + if (s->state == SERVICE_AUTO_RESTART) { + service_set_state(s, SERVICE_DEAD); + return 0; + } + + assert(s->state == SERVICE_RUNNING); + service_enter_stop(s, true); return 0; } static int service_reload(Name *n) { + Service *s = SERVICE(n); + + assert(s); + + assert(s->state == SERVICE_RUNNING); + + service_enter_reload(s); return 0; } +static bool service_can_reload(Name *n) { + Service *s = SERVICE(n); + + assert(s); + + return !!s->exec_command[SERVICE_EXEC_RELOAD]; +} + static NameActiveState service_active_state(Name *n) { + assert(n); - static const NameActiveState table[_SERVICE_STATE_MAX] = { - [SERVICE_DEAD] = NAME_INACTIVE, - [SERVICE_START_PRE] = NAME_ACTIVATING, - [SERVICE_START] = NAME_ACTIVATING, - [SERVICE_START_POST] = NAME_ACTIVATING, - [SERVICE_RUNNING] = NAME_ACTIVE, - [SERVICE_RELOAD_PRE] = NAME_ACTIVE_RELOADING, - [SERVICE_RELOAD] = NAME_ACTIVE_RELOADING, - [SERVICE_RELOAD_POST] = NAME_ACTIVE_RELOADING, - [SERVICE_STOP_PRE] = NAME_DEACTIVATING, - [SERVICE_STOP] = NAME_DEACTIVATING, - [SERVICE_SIGTERM] = NAME_DEACTIVATING, - [SERVICE_SIGKILL] = NAME_DEACTIVATING, - [SERVICE_STOP_POST] = NAME_DEACTIVATING, - [SERVICE_MAINTAINANCE] = NAME_INACTIVE, - }; + return state_table[SERVICE(n)->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 -1; +} + +static bool control_pid_good(Service *s) { + assert(s); - return table[SERVICE(n)->state]; + return s->control_pid > 0; } -static void service_free_hook(Name *n) { +static void service_sigchld_event(Name *n, pid_t pid, int code, int status) { Service *s = SERVICE(n); - unsigned c; + bool success; assert(s); + assert(pid >= 0); + + success = code == CLD_EXITED || status == 0; + s->failure = s->failure || !success; + + if (s->main_pid == pid) { + + exec_status_fill(&s->main_exec_status, pid, code, status); + s->main_pid = 0; + + if (s->type == SERVICE_SIMPLE) { + assert(s->exec_command[SERVICE_EXEC_START]); + s->exec_command[SERVICE_EXEC_START]->exec_status = s->main_exec_status; + } + + log_debug("%s: main process exited, code=%s status=%i", name_id(n), sigchld_code(code), status); + + /* The service exited, so the service is officially + * gone. */ + + switch (s->state) { + + case SERVICE_START_POST: + case SERVICE_RELOAD: + case SERVICE_STOP: + /* Need to wait until the operation is + * done */ + break; + + case SERVICE_RUNNING: + service_enter_stop(s, success); + break; + + case SERVICE_STOP_SIGTERM: + case SERVICE_STOP_SIGKILL: + + if (!control_pid_good(s)) + service_enter_stop_post(s, success); - exec_context_free(&s->exec_context); + /* If there is still a control process, wait for that first */ + break; - for (c = 0; c < _SERVICE_EXEC_MAX; c++) - exec_command_free_list(s->exec_command[c]); + default: + assert_not_reached("Uh, main process died at wrong time."); + } - if (s->socket) - s->socket->service = NULL; + } else if (s->control_pid == pid) { + assert(s->control_command); + + exec_status_fill(&s->control_command->exec_status, pid, code, status); + s->control_pid = 0; + + log_debug("%s: control process exited, code=%s status=%i", name_id(n), sigchld_code(code), status); + + /* If we are shutting things down anyway we + * don't care about failing commands. */ + + if (s->control_command->command_next && + (success || (s->state == SERVICE_EXEC_STOP || s->state == SERVICE_EXEC_STOP_POST))) + + /* There is another command to * + * execute, so let's do that. */ + + service_run_next(s, success); + + else { + /* No further commands for this step, so let's + * figure out what to do next */ + + switch (s->state) { + + case SERVICE_START_PRE: + if (success) + service_enter_start(s); + else + service_enter_stop(s, false); + break; + + case SERVICE_START: + assert(s->type == SERVICE_FORKING); + + /* Let's try to load the pid + * file here if we can. We + * ignore the return value, + * since the PID file might + * actually be created by a + * START_POST script */ + + if (success) { + if (s->pid_file) + service_load_pid_file(s); + + service_enter_start_post(s); + } else + service_enter_stop(s, false); + + break; + + case SERVICE_START_POST: + if (success && s->pid_file && !s->main_pid_known) { + int r; + + /* Hmm, let's see if we can + * load the pid now after the + * start-post scripts got + * executed. */ + + if ((r = service_load_pid_file(s)) < 0) + log_warning("%s: failed to load PID file %s: %s", name_id(NAME(s)), s->pid_file, strerror(-r)); + } + + /* Fall through */ + + case SERVICE_RELOAD: + if (success) { + if (main_pid_good(s) != 0) + service_set_state(s, SERVICE_RUNNING); + else + service_enter_stop(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); + break; + + case SERVICE_STOP_SIGTERM: + case SERVICE_STOP_SIGKILL: + if (main_pid_good(s) <= 0) + service_enter_stop_post(s, success); + + /* If there is still a service + * process around, wait until + * that one quit, too */ + break; + + case SERVICE_STOP_POST: + case SERVICE_FINAL_SIGTERM: + case SERVICE_FINAL_SIGKILL: + service_enter_dead(s, success, true); + break; + + default: + assert_not_reached("Uh, control process died at wrong time."); + } + } + } else + assert_not_reached("Got SIGCHLD for unkown PID"); +} + +static void service_timer_event(Name *n, int id, uint64_t elapsed) { + Service *s = SERVICE(n); + + assert(s); + assert(elapsed == 1); + + assert(s->timer_id == id); + + switch (s->state) { + + case SERVICE_START_PRE: + case SERVICE_START: + case SERVICE_START_POST: + case SERVICE_RELOAD: + log_warning("%s operation timed out. Stopping.", name_id(n)); + service_enter_stop(s, false); + break; + + case SERVICE_STOP: + log_warning("%s stopping timed out. Terminating.", name_id(n)); + service_enter_signal(s, SERVICE_STOP_SIGTERM, false); + break; + + case SERVICE_STOP_SIGTERM: + log_warning("%s stopping timed out. Killing.", name_id(n)); + service_enter_signal(s, SERVICE_STOP_SIGKILL, false); + break; + + case SERVICE_STOP_SIGKILL: + /* Uh, wie sent a SIGKILL and it is still not gone? + * Must be something we cannot kill, so let's just be + * weirded out and continue */ + + log_warning("%s still around after SIGKILL. Ignoring.", name_id(n)); + service_enter_stop_post(s, false); + break; + + case SERVICE_STOP_POST: + log_warning("%s stopping timed out (2). Terminating.", name_id(n)); + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); + break; + + case SERVICE_FINAL_SIGTERM: + log_warning("%s stopping timed out (2). Killing.", name_id(n)); + service_enter_signal(s, SERVICE_FINAL_SIGKILL, false); + break; + + case SERVICE_FINAL_SIGKILL: + log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", name_id(n)); + service_enter_dead(s, false, true); + break; + + case SERVICE_AUTO_RESTART: + log_debug("%s holdoff time over, scheduling restart.", name_id(n)); + service_enter_restart(s); + break; + + default: + assert_not_reached("Timeout at wrong time."); + } } const NameVTable service_vtable = { .suffix = ".service", - .load = service_load, + .init = service_init, + .done = service_done, + .dump = service_dump, .start = service_start, .stop = service_stop, .reload = service_reload, + .can_reload = service_can_reload, + .active_state = service_active_state, - .free_hook = service_free_hook + .sigchld_event = service_sigchld_event, + .timer_event = service_timer_event, };