X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=service.c;h=96e9d83ad90902d5e59d927a195fd9f28211b4de;hb=4f2d528d3bb25cebf8d3ebe83d8193ab4016cb90;hp=73e733bd845703e55e769265f02e7c7f5fe48d47;hpb=e537352b9bfffe6f6286483bff2c7601c78407e3;p=elogind.git diff --git a/service.c b/service.c index 73e733bd8..96e9d83ad 100644 --- a/service.c +++ b/service.c @@ -30,6 +30,7 @@ #include "load-dropin.h" #include "log.h" #include "strv.h" +#include "unit-name.h" #define COMMENTS "#;\n" #define NEWLINES "\n\r" @@ -52,6 +53,7 @@ static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = { [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, @@ -63,6 +65,36 @@ static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = { [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_close_socket_fd(Service *s) { + assert(s); + + if (s->socket_fd < 0) + return; + + close_nointr_nofail(s->socket_fd); + s->socket_fd = -1; +} + static void service_done(Unit *u) { Service *s = SERVICE(u); @@ -83,15 +115,10 @@ static void service_done(Unit *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; - } + service_unwatch_main_pid(s); + service_unwatch_control_pid(s); - if (s->control_pid > 0) { - unit_unwatch_pid(u, s->control_pid); - s->control_pid = 0; - } + service_close_socket_fd(s); unit_unwatch_timer(u, &s->timer_watch); } @@ -268,7 +295,7 @@ static int priority_from_rcd(Service *s, const char *init_script) { s->sysv_start_priority = a*10 + b; - log_debug("Determined priority %i from link farm for %s", s->sysv_start_priority, unit_id(UNIT(s))); + log_debug("Determined priority %i from link farm for %s", s->sysv_start_priority, UNIT(s)->meta.id); closedir(d); return 0; @@ -471,8 +498,8 @@ static int service_load_sysv_path(Service *s, const char *path) { if (unit_name_to_type(m) == UNIT_SERVICE) r = unit_add_name(u, m); else { - if ((r = unit_add_dependency_by_name_inverse(u, UNIT_REQUIRES, m)) >= 0) - r = unit_add_dependency_by_name(u, UNIT_BEFORE, m); + if ((r = unit_add_dependency_by_name_inverse(u, UNIT_REQUIRES, m, NULL)) >= 0) + r = unit_add_dependency_by_name(u, UNIT_BEFORE, m, NULL); } free(m); @@ -505,7 +532,7 @@ static int service_load_sysv_path(Service *s, const char *path) { if (r == 0) continue; - r = unit_add_dependency_by_name(u, UNIT_AFTER, m); + r = unit_add_dependency_by_name(u, UNIT_AFTER, m, NULL); free(m); if (r < 0) @@ -582,13 +609,13 @@ static int service_load_sysv_path(Service *s, const char *path) { * needed as soon as at least one non-LSB script is used. */ if (s->sysv_start_priority < 0) { - log_debug("%s has no chkconfig header, trying to determine SysV priority from link farm.", unit_id(u)); + log_debug("%s has no chkconfig header, trying to determine SysV priority from link farm.", u->meta.id); if ((r = priority_from_rcd(s, file_name_from_path(path))) < 0) goto finish; if (s->sysv_start_priority < 0) - log_warning("%s has neither a chkconfig header nor a directory link, cannot order unit!", unit_id(u)); + log_warning("%s has neither a chkconfig header nor a directory link, cannot order unit!", u->meta.id); } if ((r = sysv_exec_commands(s)) < 0) @@ -601,11 +628,18 @@ static int service_load_sysv_path(Service *s, const char *path) { * needed for early boot) and don't create any links * to it. */ - if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_BASIC_TARGET)) < 0 || - (r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_BASIC_TARGET)) < 0) + if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL)) < 0 || + (r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_BASIC_TARGET, NULL)) < 0) goto finish; } + /* Special setting for all SysV services */ + s->valid_no_process = true; + + /* Don't timeout special services during boot (like fsck) */ + if (s->sysv_runlevels && !chars_intersect("12345", s->sysv_runlevels)) + s->timeout_usec = -1; + u->meta.load_state = UNIT_LOADED; r = 0; @@ -659,13 +693,13 @@ static int service_load_sysv(Service *s) { if (strv_isempty(UNIT(s)->meta.manager->sysvinit_path)) return 0; - if ((t = unit_id(UNIT(s)))) + if ((t = UNIT(s)->meta.id)) if ((r = service_load_sysv_name(s, t)) < 0) return r; if (UNIT(s)->meta.load_state == UNIT_STUB) SET_FOREACH(t, UNIT(s)->meta.names, i) { - if (t == unit_id(UNIT(s))) + if (t == UNIT(s)->meta.id) continue; if ((r == service_load_sysv_name(s, t)) < 0) @@ -706,9 +740,25 @@ static void service_init(Unit *u) { s->main_pid_known = false; s->failure = false; + s->socket_fd = -1; + RATELIMIT_INIT(s->ratelimit, 10*USEC_PER_SEC, 5); } +static int service_verify(Service *s) { + assert(s); + + if (UNIT(s)->meta.load_state != UNIT_LOADED) + return 0; + + if (!s->exec_command[SERVICE_EXEC_START]) { + log_error("%s lacks ExecStart setting. Refusing.", UNIT(s)->meta.id); + return -EINVAL; + } + + return 0; +} + static int service_load(Unit *u) { int r; Service *s = SERVICE(u); @@ -745,7 +795,7 @@ static int service_load(Unit *u) { return r; } - return 0; + return service_verify(s); } static void service_dump(Unit *u, FILE *f, const char *prefix) { @@ -831,6 +881,8 @@ static int service_load_pid_file(Service *s) { if (s->main_pid_known) return 0; + assert(s->main_pid <= 0); + if (!s->pid_file) return -ENOENT; @@ -906,7 +958,6 @@ fail: return r; } - static int service_notify_sockets_dead(Service *s) { Iterator i; Set *set; @@ -916,7 +967,6 @@ static int service_notify_sockets_dead(Service *s) { assert(s); /* Notifies all our sockets when we die */ - if ((r = service_get_sockets(s, &set)) < 0) return r; @@ -955,10 +1005,7 @@ static void service_set_state(Service *s, ServiceState state) { 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 && @@ -970,11 +1017,7 @@ static void service_set_state(Service *s, ServiceState state) { 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; } @@ -989,8 +1032,13 @@ static void service_set_state(Service *s, ServiceState state) { state == SERVICE_AUTO_RESTART) service_notify_sockets_dead(s); + if (state != SERVICE_START_PRE && + state != SERVICE_START && + !(state == SERVICE_DEAD && UNIT(s)->meta.job)) + service_close_socket_fd(s); + if (old_state != state) - log_debug("%s changed %s → %s", unit_id(UNIT(s)), service_state_to_string(old_state), service_state_to_string(state)); + log_debug("%s changed %s → %s", UNIT(s)->meta.id, service_state_to_string(old_state), service_state_to_string(state)); unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]); } @@ -1069,14 +1117,19 @@ static int service_spawn( int r; int *fds = NULL; unsigned n_fds = 0; + char **argv; assert(s); assert(c); assert(_pid); - if (pass_fds) - if ((r = service_collect_fds(s, &fds, &n_fds)) < 0) + if (pass_fds) { + if (s->socket_fd >= 0) { + fds = &s->socket_fd; + n_fds = 1; + } else if ((r = service_collect_fds(s, &fds, &n_fds)) < 0) goto fail; + } if (timeout) { if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0) @@ -1084,20 +1137,36 @@ static int service_spawn( } else unit_unwatch_timer(UNIT(s), &s->timer_watch); - if ((r = exec_spawn(c, - &s->exec_context, - fds, n_fds, - apply_permissions, - apply_chroot, - UNIT(s)->meta.cgroup_bondings, - &pid)) < 0) + if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) { + r = -ENOMEM; goto fail; + } + + r = exec_spawn(c, + argv, + &s->exec_context, + fds, n_fds, + apply_permissions, + apply_chroot, + UNIT(s)->meta.manager->confirm_spawn, + UNIT(s)->meta.cgroup_bondings, + &pid); + + strv_free(argv); + if (r < 0) + goto fail; + + if (fds) { + if (s->socket_fd >= 0) + service_close_socket_fd(s); + else + free(fds); + } if ((r = unit_watch_pid(UNIT(s), pid)) < 0) /* FIXME: we need to do something here */ goto fail; - free(fds); *_pid = pid; return 0; @@ -1111,6 +1180,41 @@ 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); @@ -1132,7 +1236,7 @@ static void service_enter_dead(Service *s, bool success, bool allow_restart) { return; fail: - log_warning("%s failed to run install restart timer: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run install restart timer: %s", UNIT(s)->meta.id, strerror(-r)); service_enter_dead(s, false, false); } @@ -1145,7 +1249,9 @@ static void service_enter_stop_post(Service *s, bool success) { 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, @@ -1156,15 +1262,14 @@ static void service_enter_stop_post(Service *s, bool success) { 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(s)->meta.id, strerror(-r)); service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); } @@ -1177,10 +1282,8 @@ static void service_enter_signal(Service *s, ServiceState state, bool success) { 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) { @@ -1193,6 +1296,7 @@ static void service_enter_signal(Service *s, ServiceState state, bool success) { 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; @@ -1212,20 +1316,22 @@ static void service_enter_signal(Service *s, ServiceState state, bool success) { } } - 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)); + log_warning("%s failed to kill processes: %s", UNIT(s)->meta.id, 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); @@ -1238,7 +1344,9 @@ static void service_enter_stop(Service *s, bool success) { 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, @@ -1248,23 +1356,38 @@ static void service_enter_stop(Service *s, bool success) { &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; fail: - log_warning("%s failed to run stop executable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run stop executable: %s", UNIT(s)->meta.id, strerror(-r)); 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, @@ -1275,15 +1398,14 @@ static void service_enter_start_post(Service *s) { 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; fail: - log_warning("%s failed to run start-post executable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run start-post executable: %s", UNIT(s)->meta.id, strerror(-r)); service_enter_stop(s, false); } @@ -1296,6 +1418,11 @@ static void service_enter_start(Service *s) { 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, @@ -1305,14 +1432,13 @@ static void service_enter_start(Service *s) { &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) { @@ -1321,22 +1447,28 @@ static void service_enter_start(Service *s) { * 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"); return; fail: - log_warning("%s failed to run start exectuable: %s", unit_id(UNIT(s)), strerror(-r)); - service_enter_stop(s, false); + log_warning("%s failed to run start exectuable: %s", UNIT(s)->meta.id, strerror(-r)); + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); } static void service_enter_start_pre(Service *s) { @@ -1344,7 +1476,9 @@ 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, @@ -1354,15 +1488,14 @@ static void service_enter_start_pre(Service *s) { &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; fail: - log_warning("%s failed to run start-pre executable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run start-pre executable: %s", UNIT(s)->meta.id, strerror(-r)); service_enter_dead(s, false, true); } @@ -1370,16 +1503,17 @@ static void service_enter_restart(Service *s) { int r; assert(s); + service_enter_dead(s, true, false); + if ((r = manager_add_job(UNIT(s)->meta.manager, JOB_START, UNIT(s), JOB_FAIL, false, NULL)) < 0) goto fail; - log_debug("%s scheduled restart job.", unit_id(UNIT(s))); - service_enter_dead(s, true, false); + log_debug("%s scheduled restart job.", UNIT(s)->meta.id); return; fail: - log_warning("%s failed to schedule restart job: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to schedule restart job: %s", UNIT(s)->meta.id, strerror(-r)); service_enter_dead(s, false, false); } @@ -1388,7 +1522,9 @@ static void service_enter_reload(Service *s) { 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, @@ -1398,15 +1534,14 @@ static void service_enter_reload(Service *s) { &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; fail: - log_warning("%s failed to run reload executable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run reload executable: %s", UNIT(s)->meta.id, strerror(-r)); service_enter_stop(s, false); } @@ -1422,6 +1557,8 @@ static void service_run_next(Service *s, bool success) { s->control_command = s->control_command->command_next; + service_unwatch_control_pid(s); + if ((r = service_spawn(s, s->control_command, true, @@ -1434,10 +1571,12 @@ static void service_run_next(Service *s, bool success) { return; fail: - log_warning("%s failed to run spawn next executable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run spawn next executable: %s", UNIT(s)->meta.id, 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 @@ -1469,7 +1608,7 @@ static int service_start(Unit *u) { /* Make sure we don't enter a busy loop of some kind. */ if (!ratelimit_test(&s->ratelimit)) { - log_warning("%s start request repeated too quickly, refusing to start.", unit_id(u)); + log_warning("%s start request repeated too quickly, refusing to start.", u->meta.id); return -EAGAIN; } @@ -1506,7 +1645,7 @@ static int service_stop(Unit *u) { return 0; } - assert(s->state == SERVICE_RUNNING); + assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED); service_enter_stop(s, true); return 0; @@ -1517,7 +1656,7 @@ static int service_reload(Unit *u) { assert(s); - assert(s->state == SERVICE_RUNNING); + assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED); service_enter_reload(s); return 0; @@ -1537,34 +1676,10 @@ static UnitActiveState service_active_state(Unit *u) { 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; +static const char *service_sub_state_to_string(Unit *u) { + assert(u); - return cgroup_bonding_is_empty_list(UNIT(s)->meta.cgroup_bondings); + return service_state_to_string(SERVICE(u)->state); } static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { @@ -1587,7 +1702,7 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { s->exec_command[SERVICE_EXEC_START]->exec_status = s->main_exec_status; } - log_debug("%s: main process exited, code=%s, status=%i", unit_id(u), sigchld_code_to_string(code), status); + log_debug("%s: main process exited, code=%s, status=%i", u->meta.id, sigchld_code_to_string(code), status); /* The service exited, so the service is officially * gone. */ @@ -1608,11 +1723,11 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { 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: @@ -1634,24 +1749,24 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { 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", unit_id(u), sigchld_code_to_string(code), status); + log_debug("%s: control process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(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_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", u->meta.id, 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 */ - log_debug("%s got final SIGCHLD for state %s", unit_id(u), service_state_to_string(s->state)); + log_debug("%s got final SIGCHLD for state %s", u->meta.id, service_state_to_string(s->state)); switch (s->state) { @@ -1659,7 +1774,7 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { if (success) service_enter_start(s); else - service_enter_stop(s, false); + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); break; case SERVICE_START: @@ -1678,7 +1793,7 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { service_enter_start_post(s); } else - service_enter_stop(s, false); + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); break; @@ -1692,28 +1807,21 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { * executed. */ if ((r = service_load_pid_file(s)) < 0) - log_warning("%s: failed to load PID file %s: %s", unit_id(UNIT(s)), s->pid_file, strerror(-r)); + log_warning("%s: failed to load PID file %s: %s", UNIT(s)->meta.id, s->pid_file, strerror(-r)); } /* 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: @@ -1752,19 +1860,23 @@ static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) { case SERVICE_START_PRE: case SERVICE_START: + log_warning("%s operation timed out. Terminating.", u->meta.id); + 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)); + log_warning("%s operation timed out. Stopping.", u->meta.id); service_enter_stop(s, false); break; case SERVICE_STOP: - log_warning("%s stopping timed out. Terminating.", unit_id(u)); + log_warning("%s stopping timed out. Terminating.", u->meta.id); service_enter_signal(s, SERVICE_STOP_SIGTERM, false); break; case SERVICE_STOP_SIGTERM: - log_warning("%s stopping timed out. Killing.", unit_id(u)); + log_warning("%s stopping timed out. Killing.", u->meta.id); service_enter_signal(s, SERVICE_STOP_SIGKILL, false); break; @@ -1773,27 +1885,27 @@ static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) { * Must be something we cannot kill, so let's just be * weirded out and continue */ - log_warning("%s still around after SIGKILL. Ignoring.", unit_id(u)); + log_warning("%s still around after SIGKILL. Ignoring.", u->meta.id); service_enter_stop_post(s, false); break; case SERVICE_STOP_POST: - log_warning("%s stopping timed out (2). Terminating.", unit_id(u)); + log_warning("%s stopping timed out (2). Terminating.", u->meta.id); service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); break; case SERVICE_FINAL_SIGTERM: - log_warning("%s stopping timed out (2). Killing.", unit_id(u)); + log_warning("%s stopping timed out (2). Killing.", u->meta.id); service_enter_signal(s, SERVICE_FINAL_SIGKILL, false); break; case SERVICE_FINAL_SIGKILL: - log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", unit_id(u)); + log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", u->meta.id); service_enter_dead(s, false, true); break; case SERVICE_AUTO_RESTART: - log_debug("%s holdoff time over, scheduling restart.", unit_id(u)); + log_debug("%s holdoff time over, scheduling restart.", u->meta.id); service_enter_restart(s); break; @@ -1807,7 +1919,7 @@ static void service_cgroup_notify_event(Unit *u) { assert(u); - log_debug("%s: cgroup is empty", unit_id(u)); + log_debug("%s: cgroup is empty", u->meta.id); switch (s->state) { @@ -1818,10 +1930,7 @@ static void service_cgroup_notify_event(Unit *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: @@ -1893,10 +2002,10 @@ static int service_enumerate(Manager *m) { goto finish; } - if ((r = manager_load_unit(m, name, &service)) < 0) + if ((r = manager_load_unit(m, name, NULL, &service)) < 0) goto finish; - if ((r = manager_load_unit(m, rcnd_table[i+1], &runlevel)) < 0) + if ((r = manager_load_unit(m, rcnd_table[i+1], NULL, &runlevel)) < 0) goto finish; if (de->d_name[0] == 'S') { @@ -1937,12 +2046,34 @@ finish: return r; } +int service_set_socket_fd(Service *s, int fd) { + assert(s); + assert(fd >= 0); + + /* This is called by the socket code when instantiating a new + * service for a stream socket and the socket needs to be + * configured. */ + + if (UNIT(s)->meta.load_state != UNIT_LOADED) + return -EINVAL; + + if (s->socket_fd >= 0) + return -EBUSY; + + if (s->state != SERVICE_DEAD) + return -EAGAIN; + + s->socket_fd = fd; + return 0; +} + static const char* const service_state_table[_SERVICE_STATE_MAX] = { [SERVICE_DEAD] = "dead", [SERVICE_START_PRE] = "start-pre", [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", @@ -1959,7 +2090,7 @@ DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState); 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); @@ -1999,6 +2130,7 @@ const UnitVTable service_vtable = { .can_reload = service_can_reload, .active_state = service_active_state, + .sub_state_to_string = service_sub_state_to_string, .sigchld_event = service_sigchld_event, .timer_event = service_timer_event,