X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=service.c;h=ec466181ee0cec35c8c84d5dfd1831ecd35a3238;hp=fda553d22580d12235529a252b13eb9b57027c4e;hb=db06e3b6a5254ec247de5bc1a1b6a8670c2f4b2b;hpb=f278026d21e2ded46f7f91152d60842525e74956 diff --git a/service.c b/service.c index fda553d22..ec466181e 100644 --- a/service.c +++ b/service.c @@ -30,28 +30,31 @@ #include "load-dropin.h" #include "log.h" #include "strv.h" +#include "unit-name.h" +#include "dbus-service.h" #define COMMENTS "#;\n" #define NEWLINES "\n\r" #define LINE_MAX 4096 static const char * const rcnd_table[] = { - "../rc0.d", SPECIAL_RUNLEVEL0_TARGET, - "../rc1.d", SPECIAL_RUNLEVEL1_TARGET, - "../rc2.d", SPECIAL_RUNLEVEL2_TARGET, - "../rc3.d", SPECIAL_RUNLEVEL3_TARGET, - "../rc4.d", SPECIAL_RUNLEVEL4_TARGET, - "../rc5.d", SPECIAL_RUNLEVEL5_TARGET, - "../rc6.d", SPECIAL_RUNLEVEL6_TARGET + "/rc0.d", SPECIAL_RUNLEVEL0_TARGET, + "/rc1.d", SPECIAL_RUNLEVEL1_TARGET, + "/rc2.d", SPECIAL_RUNLEVEL2_TARGET, + "/rc3.d", SPECIAL_RUNLEVEL3_TARGET, + "/rc4.d", SPECIAL_RUNLEVEL4_TARGET, + "/rc5.d", SPECIAL_RUNLEVEL5_TARGET, + "/rc6.d", SPECIAL_RUNLEVEL6_TARGET, + "/boot.d", SPECIAL_BASIC_TARGET }; - static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = { [SERVICE_DEAD] = UNIT_INACTIVE, [SERVICE_START_PRE] = UNIT_ACTIVATING, [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 +66,55 @@ static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = { [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING, }; +static void service_init(Unit *u) { + Service *s = SERVICE(u); + + assert(u); + assert(u->meta.load_state == UNIT_STUB); + + s->timeout_usec = DEFAULT_TIMEOUT_USEC; + s->restart_usec = DEFAULT_RESTART_USEC; + s->timer_watch.type = WATCH_INVALID; + s->sysv_start_priority = -1; + s->socket_fd = -1; + + exec_context_init(&s->exec_context); + + RATELIMIT_INIT(s->ratelimit, 10*USEC_PER_SEC, 5); + + s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID; +} + +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); @@ -74,22 +126,26 @@ static void service_done(Unit *u) { free(s->sysv_path); s->sysv_path = NULL; + free(s->sysv_runlevels); + s->sysv_runlevels = NULL; + exec_context_done(&s->exec_context); - exec_command_free_array(s->exec_command, _SERVICE_EXEC_MAX); + exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_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) { - 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; + if (s->bus_name) { + unit_unwatch_bus_name(UNIT(u), s->bus_name); + free(s->bus_name); + s->bus_name = NULL; } + service_close_socket_fd(s); + unit_unwatch_timer(u, &s->timer_watch); } @@ -154,7 +210,10 @@ static int sysv_chkconfig_order(Service *s) { if (t->sysv_start_priority < 0) continue; - if (s->sysv_has_lsb && t->sysv_has_lsb) + /* If both units have modern headers we don't care + * about the priorities */ + if ((!s->sysv_path || s->sysv_has_lsb) && + (!t->sysv_path || t->sysv_has_lsb)) continue; if (t->sysv_start_priority < s->sysv_start_priority) @@ -166,7 +225,7 @@ static int sysv_chkconfig_order(Service *s) { /* FIXME: Maybe we should compare the name here lexicographically? */ - if (!(r = unit_add_dependency(UNIT(s), d, UNIT(t))) < 0) + if (!(r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0) return r; } @@ -214,71 +273,12 @@ static int sysv_exec_commands(Service *s) { return 0; } -static int priority_from_rcd(Service *s, const char *init_script) { - char **p; - unsigned i; - - STRV_FOREACH(p, UNIT(s)->meta.manager->sysvinit_path) - for (i = 0; i < ELEMENTSOF(rcnd_table); i += 2) { - char *path; - DIR *d; - struct dirent *de; - - if (asprintf(&path, "%s/%s", *p, rcnd_table[i]) < 0) - return -ENOMEM; - - d = opendir(path); - free(path); - - if (!d) { - if (errno != ENOENT) - log_warning("opendir() failed on %s: %s", path, strerror(errno)); - - continue; - } - - while ((de = readdir(d))) { - int a, b; - - if (ignore_file(de->d_name)) - continue; - - if (de->d_name[0] != 'S') - continue; - - if (strlen(de->d_name) < 4) - continue; - - if (!streq(de->d_name + 3, init_script)) - continue; - - /* Yay, we found it! Now decode the priority */ - - a = undecchar(de->d_name[1]); - b = undecchar(de->d_name[2]); - - if (a < 0 || b < 0) - continue; - - 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))); - - closedir(d); - return 0; - } - - closedir(d); - } - - return 0; -} - -static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *new_state) { +static int service_load_sysv_path(Service *s, const char *path) { FILE *f; Unit *u; unsigned line = 0; int r; + bool normal_service; enum { NORMAL, DESCRIPTION, @@ -288,7 +288,6 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n assert(s); assert(path); - assert(new_state); u = UNIT(s); @@ -344,22 +343,37 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n if (startswith(t, "chkconfig:")) { int start_priority; + char runlevels[16], *k; state = NORMAL; - if (sscanf(t+10, "%*15s %i %*i", - &start_priority) != 1) { + if (sscanf(t+10, "%15s %i %*i", + runlevels, + &start_priority) != 2) { log_warning("[%s:%u] Failed to parse chkconfig line. Ignoring.", path, line); continue; } - if (start_priority < 0 || start_priority > 99) { + if (start_priority < 0 || start_priority > 99) log_warning("[%s:%u] Start priority out of range. Ignoring.", path, line); - continue; - } + else if (s->sysv_start_priority < 0) + s->sysv_start_priority = start_priority; - s->sysv_start_priority = start_priority; + char_array_0(runlevels); + k = delete_chars(runlevels, WHITESPACE "-"); + + if (k[0]) { + char *d; + + if (!(d = strdup(k))) { + r = -ENOMEM; + goto finish; + } + + free(s->sysv_runlevels); + s->sysv_runlevels = d; + } } else if (startswith(t, "description:")) { @@ -450,8 +464,8 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n 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, true)) >= 0) + r = unit_add_dependency_by_name(u, UNIT_BEFORE, m, NULL, true); } free(m); @@ -484,20 +498,28 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n if (r == 0) continue; - if (!(r = unit_add_dependency_by_name(u, UNIT_AFTER, m)) < 0) { - free(m); - goto finish; - } - - r = unit_add_dependency_by_name( - u, - startswith(t, "Required-Start:") ? UNIT_REQUIRES : UNIT_WANTS, - m); + r = unit_add_dependency_by_name(u, UNIT_AFTER, m, NULL, true); free(m); if (r < 0) goto finish; } + } else if (startswith(t, "Default-Start:")) { + char *k, *d; + + state = LSB; + + k = delete_chars(t+14, WHITESPACE "-"); + + if (k[0] != 0) { + if (!(d = strdup(k))) { + r = -ENOMEM; + goto finish; + } + + free(s->sysv_runlevels); + s->sysv_runlevels = d; + } } else if (startswith(t, "Description:")) { char *d; @@ -512,7 +534,8 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n free(u->meta.description); u->meta.description = d; - } else if (startswith(t, "Short-Description:") && !u->meta.description) { + } else if (startswith(t, "Short-Description:") && + !u->meta.description) { char *d; /* We use the short description only @@ -525,7 +548,6 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n goto finish; } - free(u->meta.description); u->meta.description = d; } else if (state == LSB_DESCRIPTION) { @@ -552,24 +574,35 @@ static int service_load_sysv_path(Service *s, const char *path, UnitLoadState *n * a priority for *all* init scripts here, since they are * 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)); + if (s->sysv_start_priority < 0) + log_warning("%s has neither a chkconfig header nor a directory link, cannot order unit!", u->meta.id); - if ((r = priority_from_rcd(s, file_name_from_path(path))) < 0) - goto finish; + if ((r = sysv_exec_commands(s)) < 0) + goto finish; + + normal_service = !s->sysv_runlevels || chars_intersect("12345", s->sysv_runlevels); + + if (normal_service) { + /* If there a runlevels configured for this service + * but none of the standard ones, then we assume this + * is some special kind of service (which might be + * needed for early boot) and don't create any links + * to it. */ - if (s->sysv_start_priority < 0) - log_warning("%s has neither a chkconfig header nor a directory link, cannot order unit!", unit_id(u)); + if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0 || + (r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_BASIC_TARGET, NULL, true)) < 0) + goto finish; } - if ((r = sysv_exec_commands(s)) < 0) - goto finish; + /* Special setting for all SysV services */ + s->valid_no_process = true; + s->kill_mode = KILL_PROCESS_GROUP; - if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_SYSINIT_SERVICE)) < 0 || - (r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_SYSINIT_SERVICE)) < 0) - goto finish; + /* Don't timeout special services during boot (like fsck) */ + if (s->sysv_runlevels && !normal_service) + s->timeout_usec = 0; - *new_state = UNIT_LOADED; + u->meta.load_state = UNIT_LOADED; r = 0; finish: @@ -580,7 +613,7 @@ finish: return r; } -static int service_load_sysv_name(Service *s, const char *name, UnitLoadState *new_state) { +static int service_load_sysv_name(Service *s, const char *name) { char **p; assert(s); @@ -596,26 +629,25 @@ static int service_load_sysv_name(Service *s, const char *name, UnitLoadState *n assert(endswith(path, ".service")); path[strlen(path)-8] = 0; - r = service_load_sysv_path(s, path, new_state); + r = service_load_sysv_path(s, path); free(path); if (r < 0) return r; - if (*new_state != UNIT_STUB) + if ((UNIT(s)->meta.load_state != UNIT_STUB)) break; } return 0; } -static int service_load_sysv(Service *s, UnitLoadState *new_state) { +static int service_load_sysv(Service *s) { const char *t; Iterator i; int r; assert(s); - assert(new_state); /* Load service data from SysV init scripts, preferably with * LSB headers ... */ @@ -623,64 +655,77 @@ static int service_load_sysv(Service *s, UnitLoadState *new_state) { if (strv_isempty(UNIT(s)->meta.manager->sysvinit_path)) return 0; - if ((t = unit_id(UNIT(s)))) - if ((r = service_load_sysv_name(s, t, new_state)) < 0) + if ((t = UNIT(s)->meta.id)) + if ((r = service_load_sysv_name(s, t)) < 0) return r; - if (*new_state == UNIT_STUB) + if (UNIT(s)->meta.load_state == UNIT_STUB) SET_FOREACH(t, UNIT(s)->meta.names, i) { - if ((r == service_load_sysv_name(s, t, new_state)) < 0) + if (t == UNIT(s)->meta.id) + continue; + + if ((r == service_load_sysv_name(s, t)) < 0) return r; - if (*new_state != UNIT_STUB) + if (UNIT(s)->meta.load_state != UNIT_STUB) break; } return 0; } -static int service_init(Unit *u, UnitLoadState *new_state) { +static int service_add_bus_name(Service *s) { + char *n; int r; - Service *s = SERVICE(u); assert(s); - assert(new_state); - assert(*new_state == UNIT_STUB); + assert(s->bus_name); - /* First, reset everything to the defaults, in case this is a - * reload */ + if (asprintf(&n, "dbus-%s.service", s->bus_name) < 0) + return 0; - s->type = 0; - s->restart = 0; + r = unit_merge_by_name(UNIT(s), n); + free(n); - s->timeout_usec = DEFAULT_TIMEOUT_USEC; - s->restart_usec = DEFAULT_RESTART_USEC; + return r; +} - exec_context_init(&s->exec_context); +static int service_verify(Service *s) { + assert(s); - s->timer_watch.type = WATCH_INVALID; + if (UNIT(s)->meta.load_state != UNIT_LOADED) + return 0; - s->state = SERVICE_DEAD; + if (!s->exec_command[SERVICE_EXEC_START]) { + log_error("%s lacks ExecStart setting. Refusing.", UNIT(s)->meta.id); + return -EINVAL; + } - s->sysv_start_priority = -1; - s->permissions_start_only = false; - s->root_directory_start_only = false; + if (s->type == SERVICE_DBUS && !s->bus_name) { + log_error("%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->meta.id); + return -EINVAL; + } + + return 0; +} - s->sysv_has_lsb = false; +static int service_load(Unit *u) { + int r; + Service *s = SERVICE(u); - RATELIMIT_INIT(s->ratelimit, 10*USEC_PER_SEC, 5); + assert(s); /* Load a .service file */ - if ((r = unit_load_fragment(u, new_state)) < 0) + if ((r = unit_load_fragment(u)) < 0) return r; /* Load a classic init script as a fallback, if we couldn't find anything */ - if (*new_state == UNIT_STUB) - if ((r = service_load_sysv(s, new_state)) < 0) + if (u->meta.load_state == UNIT_STUB) + if ((r = service_load_sysv(s)) < 0) return r; /* Still nothing found? Then let's give up */ - if (*new_state == UNIT_STUB) + if (u->meta.load_state == UNIT_STUB) return -ENOENT; /* We were able to load something, then let's add in the @@ -689,7 +734,7 @@ static int service_init(Unit *u, UnitLoadState *new_state) { return r; /* This is a new unit? Then let's add in some extras */ - if (*new_state == UNIT_LOADED) { + if (u->meta.load_state == UNIT_LOADED) { if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0) return r; @@ -698,9 +743,17 @@ static int service_init(Unit *u, UnitLoadState *new_state) { if ((r = sysv_chkconfig_order(s)) < 0) return r; + + if (s->bus_name) { + if ((r = service_add_bus_name(s)) < 0) + return r; + + if ((r = unit_watch_bus_name(u, s->bus_name)) < 0) + return r; + } } - return 0; + return service_verify(s); } static void service_dump(Unit *u, FILE *f, const char *prefix) { @@ -720,26 +773,45 @@ static void service_dump(Unit *u, FILE *f, const char *prefix) { "%sPermissionsStartOnly: %s\n" "%sRootDirectoryStartOnly: %s\n" "%sValidNoProcess: %s\n" + "%sKillMode: %s\n" "%sType: %s\n", prefix, service_state_to_string(s->state), prefix, yes_no(s->permissions_start_only), prefix, yes_no(s->root_directory_start_only), prefix, yes_no(s->valid_no_process), + prefix, kill_mode_to_string(s->kill_mode), prefix, service_type_to_string(s->type)); + if (s->control_pid > 0) + fprintf(f, + "%sControl PID: %llu\n", + prefix, (unsigned long long) s->control_pid); + + if (s->main_pid > 0) + fprintf(f, + "%sMain PID: %llu\n", + prefix, (unsigned long long) s->main_pid); + if (s->pid_file) fprintf(f, "%sPIDFile: %s\n", prefix, s->pid_file); + if (s->bus_name) + fprintf(f, + "%sBusName: %s\n" + "%sBus Name Good: %s\n", + prefix, s->bus_name, + prefix, yes_no(s->bus_name_good)); + exec_context_dump(&s->exec_context, f, prefix); - for (c = 0; c < _SERVICE_EXEC_MAX; c++) { + for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) { if (!s->exec_command[c]) continue; - fprintf(f, "%s→ %s:\n", + fprintf(f, "%s-> %s:\n", prefix, service_exec_command_to_string(c)); exec_command_dump_list(s->exec_command[c], f, prefix2); @@ -757,6 +829,9 @@ static void service_dump(Unit *u, FILE *f, const char *prefix) { "%sSysVStartPriority: %i\n", prefix, s->sysv_start_priority); + if (s->sysv_runlevels) + fprintf(f, "%sSysVRunLevels: %s\n", + prefix, s->sysv_runlevels); free(p2); } @@ -771,6 +846,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; @@ -785,7 +862,17 @@ static int service_load_pid_file(Service *s) { if ((unsigned long) (pid_t) p != p) return -ERANGE; - s->main_pid = p; + if (kill((pid_t) p, 0) < 0 && errno != EPERM) { + log_warning("PID %llu read from file %s does not exist. Your service or init script might be broken.", + (unsigned long long) p, s->pid_file); + return -ESRCH; + } + + if ((r = unit_watch_pid(UNIT(s), (pid_t) p)) < 0) + /* FIXME: we need to do something here */ + return r; + + s->main_pid = (pid_t) p; s->main_pid_known = true; return 0; @@ -822,7 +909,8 @@ static int service_get_sockets(Service *s, Set **_set) { p = manager_get_unit(UNIT(s)->meta.manager, k); free(k); - if (!p) continue; + if (!p) + continue; if ((r = set_put(set, p)) < 0) goto fail; @@ -836,8 +924,7 @@ fail: return r; } - -static int service_notify_sockets(Service *s) { +static int service_notify_sockets_dead(Service *s) { Iterator i; Set *set; Socket *sock; @@ -846,7 +933,6 @@ static int service_notify_sockets(Service *s) { assert(s); /* Notifies all our sockets when we die */ - if ((r = service_get_sockets(s, &set)) < 0) return r; @@ -885,10 +971,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 && @@ -899,19 +982,11 @@ static void service_set_state(Service *s, ServiceState state) { state != SERVICE_STOP_SIGKILL && 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; - } - - if (state != SERVICE_START_PRE && - state != SERVICE_START && - state != SERVICE_START_POST && - state != SERVICE_RELOAD && - state != SERVICE_STOP && - state != SERVICE_STOP_POST) + state != SERVICE_FINAL_SIGKILL) { + service_unwatch_control_pid(s); s->control_command = NULL; + s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID; + } if (state == SERVICE_DEAD || state == SERVICE_STOP || @@ -922,13 +997,83 @@ static void service_set_state(Service *s, ServiceState state) { state == SERVICE_FINAL_SIGKILL || state == SERVICE_MAINTAINANCE || state == SERVICE_AUTO_RESTART) - service_notify_sockets(s); + service_notify_sockets_dead(s); - log_debug("%s changed %s → %s", unit_id(UNIT(s)), service_state_to_string(old_state), service_state_to_string(state)); + 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(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]); } +static int service_coldplug(Unit *u) { + Service *s = SERVICE(u); + int r; + + assert(s); + assert(s->state == SERVICE_DEAD); + + if (s->deserialized_state != s->state) { + + if (s->deserialized_state == SERVICE_START_PRE || + s->deserialized_state == SERVICE_START || + s->deserialized_state == SERVICE_START_POST || + s->deserialized_state == SERVICE_RELOAD || + s->deserialized_state == SERVICE_STOP || + s->deserialized_state == SERVICE_STOP_SIGTERM || + s->deserialized_state == SERVICE_STOP_SIGKILL || + s->deserialized_state == SERVICE_STOP_POST || + s->deserialized_state == SERVICE_FINAL_SIGTERM || + s->deserialized_state == SERVICE_FINAL_SIGKILL || + s->deserialized_state == SERVICE_AUTO_RESTART) { + + if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_usec > 0) { + usec_t k; + + k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_usec; + + if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0) + return r; + } + } + + if ((s->deserialized_state == SERVICE_START && + (s->type == SERVICE_FORKING || + s->type == SERVICE_DBUS)) || + s->deserialized_state == SERVICE_START_POST || + s->deserialized_state == SERVICE_RUNNING || + s->deserialized_state == SERVICE_RELOAD || + s->deserialized_state == SERVICE_STOP || + s->deserialized_state == SERVICE_STOP_SIGTERM || + s->deserialized_state == SERVICE_STOP_SIGKILL) + if (s->main_pid > 0) + if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0) + return r; + + if (s->deserialized_state == SERVICE_START_PRE || + s->deserialized_state == SERVICE_START || + s->deserialized_state == SERVICE_START_POST || + s->deserialized_state == SERVICE_RELOAD || + s->deserialized_state == SERVICE_STOP || + s->deserialized_state == SERVICE_STOP_SIGTERM || + s->deserialized_state == SERVICE_STOP_SIGKILL || + s->deserialized_state == SERVICE_STOP_POST || + s->deserialized_state == SERVICE_FINAL_SIGTERM || + s->deserialized_state == SERVICE_FINAL_SIGKILL) + if (s->control_pid > 0) + if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0) + return r; + + service_set_state(s, s->deserialized_state); + } + + return 0; +} + static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) { Iterator i; int r; @@ -1003,35 +1148,56 @@ 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 (timeout && s->timeout_usec) { if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0) goto fail; } 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; @@ -1045,6 +1211,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); @@ -1053,6 +1254,7 @@ static void service_enter_dead(Service *s, bool success, bool allow_restart) { s->failure = true; if (allow_restart && + s->allow_restart && (s->restart == SERVICE_RESTART_ALWAYS || (s->restart == SERVICE_RESTART_ON_SUCCESS && !s->failure))) { @@ -1066,7 +1268,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); } @@ -1079,7 +1281,10 @@ 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); + + s->control_command_id = SERVICE_EXEC_STOP_POST; + if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) { if ((r = service_spawn(s, s->control_command, true, @@ -1090,15 +1295,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); } @@ -1111,44 +1315,57 @@ 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; + if (s->kill_mode != KILL_NONE) { + int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? SIGTERM : SIGKILL; - sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? SIGTERM : SIGKILL; + if (s->kill_mode == KILL_CONTROL_GROUP) { - r = 0; - if (s->main_pid > 0) { - if (kill(s->main_pid, sig) < 0 && errno != ESRCH) - r = -errno; - else + if ((r = cgroup_bonding_kill_list(UNIT(s)->meta.cgroup_bondings, sig)) < 0) { + if (r != -EAGAIN && r != -ESRCH) + goto fail; + } else sent = true; } - if (s->control_pid > 0) { - if (kill(s->control_pid, sig) < 0 && errno != ESRCH) - r = -errno; - else - sent = true; - } + if (!sent) { + r = 0; - if (r < 0) - goto fail; + if (s->main_pid > 0) { + if (kill(s->kill_mode == KILL_PROCESS ? s->main_pid : -s->main_pid, sig) < 0 && errno != ESRCH) + r = -errno; + else + sent = true; + } + + if (s->control_pid > 0) { + if (kill(s->kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH) + r = -errno; + else + sent = true; + } + + if (r < 0) + goto fail; + } } - service_set_state(s, state); + if (sent && (s->main_pid > 0 || s->control_pid > 0)) { + if (s->timeout_usec > 0) + 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); @@ -1161,7 +1378,10 @@ 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); + + s->control_command_id = SERVICE_EXEC_STOP; + if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) { if ((r = service_spawn(s, s->control_command, true, @@ -1171,23 +1391,41 @@ 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 && + (s->bus_name_good || s->type != SERVICE_DBUS)) + 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); + + s->control_command_id = SERVICE_EXEC_START_POST; + if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) { if ((r = service_spawn(s, s->control_command, true, @@ -1198,15 +1436,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); } @@ -1219,23 +1456,27 @@ 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, + s->type == SERVICE_FORKING || s->type == SERVICE_DBUS, true, true, true, &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) { @@ -1244,22 +1485,32 @@ static void service_enter_start(Service *s) { * process exited. */ s->control_pid = pid; + + s->control_command_id = SERVICE_EXEC_START; s->control_command = s->exec_command[SERVICE_EXEC_START]; - } else if (s->type == SERVICE_FINISH) { + service_set_state(s, SERVICE_START); + + } else if (s->type == SERVICE_FINISH || + s->type == SERVICE_DBUS) { /* For finishing services we wait until the start * process exited, too, but it is our main process. */ + /* For D-Bus services we know the main pid right away, + * but wait for the bus name to appear on the bus. */ + s->main_pid = pid; - s->control_command = s->exec_command[SERVICE_EXEC_START]; + s->main_pid_known = true; + + 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) { @@ -1267,7 +1518,10 @@ 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); + + s->control_command_id = SERVICE_EXEC_START_PRE; + if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) { if ((r = service_spawn(s, s->control_command, true, @@ -1277,15 +1531,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); } @@ -1293,16 +1546,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); } @@ -1311,7 +1565,10 @@ static void service_enter_reload(Service *s) { assert(s); - if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) + service_unwatch_control_pid(s); + + s->control_command_id = SERVICE_EXEC_RELOAD; + if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) { if ((r = service_spawn(s, s->control_command, true, @@ -1321,15 +1578,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); } @@ -1345,6 +1601,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, @@ -1357,10 +1615,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 @@ -1392,12 +1652,13 @@ 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; } s->failure = false; s->main_pid_known = false; + s->allow_restart = true; service_enter_start_pre(s); return 0; @@ -1408,18 +1669,32 @@ static int service_stop(Unit *u) { assert(s); + /* Cannot do this now */ if (s->state == SERVICE_START_PRE || s->state == SERVICE_START || s->state == SERVICE_START_POST || s->state == SERVICE_RELOAD) return -EAGAIN; + /* Already on it */ + 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 0; + if (s->state == SERVICE_AUTO_RESTART) { service_set_state(s, SERVICE_DEAD); return 0; } - assert(s->state == SERVICE_RUNNING); + assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED); + + /* This is a user request, so don't do restarts on this + * shutdown. */ + s->allow_restart = false; service_enter_stop(s, true); return 0; @@ -1430,7 +1705,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; @@ -1444,40 +1719,138 @@ static bool service_can_reload(Unit *u) { return !!s->exec_command[SERVICE_EXEC_RELOAD]; } -static UnitActiveState service_active_state(Unit *u) { +static int service_serialize(Unit *u, FILE *f, FDSet *fds) { + Service *s = SERVICE(u); + assert(u); + assert(f); + assert(fds); - return state_translation_table[SERVICE(u)->state]; + unit_serialize_item(u, f, "state", service_state_to_string(s->state)); + unit_serialize_item(u, f, "failure", yes_no(s->failure)); + + if (s->control_pid > 0) + unit_serialize_item_format(u, f, "control-pid", "%u", (unsigned) (s->control_pid)); + + if (s->main_pid > 0) + unit_serialize_item_format(u, f, "main-pid", "%u", (unsigned) (s->main_pid)); + + unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known)); + + /* There's a minor uncleanliness here: if there are multiple + * commands attached here, we will start from the first one + * again */ + if (s->control_command_id >= 0) + unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id)); + + if (s->socket_fd >= 0) { + int copy; + + if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0) + return copy; + + unit_serialize_item_format(u, f, "socket-fd", "%i", copy); + } + + return 0; } -static int main_pid_good(Service *s) { - assert(s); +static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) { + Service *s = SERVICE(u); + int r; - /* Returns 0 if the pid is dead, 1 if it is good, -1 if we - * don't know */ + assert(u); + assert(key); + assert(value); + assert(fds); - /* 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; + if (streq(key, "state")) { + ServiceState state; - /* We don't know the pid */ - return -EAGAIN; + if ((state = service_state_from_string(value)) < 0) + log_debug("Failed to parse state value %s", value); + else + s->deserialized_state = state; + } else if (streq(key, "failure")) { + int b; + + if ((b = parse_boolean(value)) < 0) + log_debug("Failed to parse failure value %s", value); + else + s->failure = b || s->failure; + } else if (streq(key, "control-pid")) { + unsigned pid; + + if ((r = safe_atou(value, &pid)) < 0 || pid <= 0) + log_debug("Failed to parse control-pid value %s", value); + else + s->control_pid = (pid_t) pid; + } else if (streq(key, "main-pid")) { + unsigned pid; + + if ((r = safe_atou(value, &pid)) < 0 || pid <= 0) + log_debug("Failed to parse main-pid value %s", value); + else + s->main_pid = (pid_t) pid; + } else if (streq(key, "main-pid-known")) { + int b; + + if ((b = parse_boolean(value)) < 0) + log_debug("Failed to parse main-pid-known value %s", value); + else + s->main_pid_known = b; + } else if (streq(key, "control-command")) { + ServiceExecCommand id; + + if ((id = service_exec_command_from_string(value)) < 0) + log_debug("Failed to parse exec-command value %s", value); + else { + s->control_command_id = id; + s->control_command = s->exec_command[id]; + } + } else if (streq(key, "socket-fd")) { + int fd; + + if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd)) + log_debug("Failed to parse socket-fd value %s", value); + else { + + if (s->socket_fd >= 0) + close_nointr_nofail(s->socket_fd); + s->socket_fd = fdset_remove(fds, fd); + } + } else + log_debug("Unknown serialization key '%s'", key); + + return 0; } -static bool control_pid_good(Service *s) { - assert(s); +static UnitActiveState service_active_state(Unit *u) { + assert(u); - return s->control_pid > 0; + return state_translation_table[SERVICE(u)->state]; } -static int cgroup_good(Service *s) { +static const char *service_sub_state_to_string(Unit *u) { + assert(u); + + return service_state_to_string(SERVICE(u)->state); +} + +static bool service_check_gc(Unit *u) { + Service *s = SERVICE(u); + assert(s); - if (s->valid_no_process) - return -EAGAIN; + return !!s->sysv_path; +} + +static bool service_check_snapshot(Unit *u) { + Service *s = SERVICE(u); - return cgroup_bonding_is_empty_list(UNIT(s)->meta.cgroup_bondings); + assert(s); + + return !s->got_socket_fd; } static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { @@ -1500,7 +1873,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. */ @@ -1521,11 +1894,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: @@ -1542,29 +1915,33 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { } } else if (s->control_pid == pid) { - assert(s->control_command); - exec_status_fill(&s->control_command->exec_status, pid, code, status); + if (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", 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 && 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)); + s->control_command = NULL; + s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID; + + log_debug("%s got final SIGCHLD for state %s", u->meta.id, service_state_to_string(s->state)); switch (s->state) { @@ -1572,7 +1949,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: @@ -1591,7 +1968,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; @@ -1605,28 +1982,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: @@ -1665,19 +2035,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; @@ -1686,27 +2060,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; @@ -1720,7 +2094,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) { @@ -1731,10 +2105,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: @@ -1751,7 +2122,7 @@ static int service_enumerate(Manager *m) { assert(m); - STRV_FOREACH(p, m->sysvinit_path) + STRV_FOREACH(p, m->sysvrcnd_path) for (i = 0; i < ELEMENTSOF(rcnd_table); i += 2) { struct dirent *de; @@ -1773,7 +2144,8 @@ static int service_enumerate(Manager *m) { } while ((de = readdir(d))) { - Unit *runlevel, *service; + Unit *service; + int a, b; if (ignore_file(de->d_name)) continue; @@ -1784,6 +2156,12 @@ static int service_enumerate(Manager *m) { if (strlen(de->d_name) < 4) continue; + a = undecchar(de->d_name[1]); + b = undecchar(de->d_name[2]); + + if (a < 0 || b < 0) + continue; + free(fpath); fpath = NULL; if (asprintf(&fpath, "%s/%s/%s", *p, rcnd_table[i], de->d_name) < 0) { @@ -1806,34 +2184,51 @@ static int service_enumerate(Manager *m) { goto finish; } - if ((r = manager_load_unit(m, name, &service)) < 0) + if ((r = manager_load_unit_prepare(m, name, NULL, &service)) < 0) goto finish; - if ((r = manager_load_unit(m, rcnd_table[i+1], &runlevel)) < 0) - goto finish; + if (de->d_name[0] == 'S') + SERVICE(service)->sysv_start_priority = a*10 + b; + + manager_dispatch_load_queue(m); + service = unit_follow_merge(service); if (de->d_name[0] == 'S') { - if ((r = unit_add_dependency(runlevel, UNIT_WANTS, service)) < 0) + Unit *runlevel_target; + + if ((r = manager_load_unit(m, rcnd_table[i+1], NULL, &runlevel_target)) < 0) + goto finish; + + if ((r = unit_add_dependency(runlevel_target, UNIT_WANTS, service, true)) < 0) goto finish; - if ((r = unit_add_dependency(runlevel, UNIT_AFTER, service)) < 0) + if ((r = unit_add_dependency(service, UNIT_BEFORE, runlevel_target, true)) < 0) goto finish; } else if (de->d_name[0] == 'K' && (streq(rcnd_table[i+1], SPECIAL_RUNLEVEL0_TARGET) || streq(rcnd_table[i+1], SPECIAL_RUNLEVEL6_TARGET))) { + Unit *shutdown_target; + /* We honour K links only for * halt/reboot. For the normal * runlevels we assume the * stop jobs will be * implicitly added by the - * core logic. */ + * core logic. Also, we don't + * really distuingish here + * between the runlevels 0 and + * 6 and just add them to the + * special shutdown target. */ - if ((r = unit_add_dependency(runlevel, UNIT_CONFLICTS, service)) < 0) + if ((r = manager_load_unit(m, SPECIAL_SHUTDOWN_TARGET, NULL, &shutdown_target)) < 0) goto finish; - if ((r = unit_add_dependency(runlevel, UNIT_BEFORE, service)) < 0) + if ((r = unit_add_dependency(service, UNIT_CONFLICTS, shutdown_target, true)) < 0) + goto finish; + + if ((r = unit_add_dependency(service, UNIT_BEFORE, shutdown_target, true)) < 0) goto finish; } } @@ -1850,12 +2245,101 @@ finish: return r; } +static void service_bus_name_owner_change( + Unit *u, + const char *name, + const char *old_owner, + const char *new_owner) { + + Service *s = SERVICE(u); + + assert(s); + assert(name); + + assert(streq(s->bus_name, name)); + assert(old_owner || new_owner); + + if (old_owner && new_owner) + log_debug("%s's D-Bus name %s changed owner from %s to %s", u->meta.id, name, old_owner, new_owner); + else if (old_owner) + log_debug("%s's D-Bus name %s no longer registered by %s", u->meta.id, name, old_owner); + else + log_debug("%s's D-Bus name %s now registered by %s", u->meta.id, name, new_owner); + + s->bus_name_good = !!new_owner; + + if (s->type == SERVICE_DBUS) { + + /* service_enter_running() will figure out what to + * do */ + if (s->state == SERVICE_RUNNING) + service_enter_running(s, true); + else if (s->state == SERVICE_START && new_owner) + service_enter_start_post(s); + + } else if (new_owner && + s->main_pid <= 0 && + (s->state == SERVICE_START || + s->state == SERVICE_START_POST || + s->state == SERVICE_RUNNING || + s->state == SERVICE_RELOAD)) { + + /* Try to acquire PID from bus service */ + log_debug("Trying to acquire PID from D-Bus name..."); + + bus_query_pid(u->meta.manager, name); + } +} + +static void service_bus_query_pid_done( + Unit *u, + const char *name, + pid_t pid) { + + Service *s = SERVICE(u); + + assert(s); + assert(name); + + log_debug("%s's D-Bus name %s is now owned by process %u", u->meta.id, name, (unsigned) pid); + + if (s->main_pid <= 0 && + (s->state == SERVICE_START || + s->state == SERVICE_START_POST || + s->state == SERVICE_RUNNING || + s->state == SERVICE_RELOAD)) + s->main_pid = pid; +} + +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; + s->got_socket_fd = true; + 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", @@ -1872,7 +2356,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); @@ -1880,12 +2364,13 @@ DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart); static const char* const service_type_table[_SERVICE_TYPE_MAX] = { [SERVICE_FORKING] = "forking", [SERVICE_SIMPLE] = "simple", - [SERVICE_FINISH] = "finish" + [SERVICE_FINISH] = "finish", + [SERVICE_DBUS] = "dbus" }; DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType); -static const char* const service_exec_command_table[_SERVICE_EXEC_MAX] = { +static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = { [SERVICE_EXEC_START_PRE] = "ExecStartPre", [SERVICE_EXEC_START] = "ExecStart", [SERVICE_EXEC_START_POST] = "ExecStartPost", @@ -1901,6 +2386,9 @@ const UnitVTable service_vtable = { .init = service_init, .done = service_done, + .load = service_load, + + .coldplug = service_coldplug, .dump = service_dump, @@ -1910,12 +2398,24 @@ const UnitVTable service_vtable = { .can_reload = service_can_reload, + .serialize = service_serialize, + .deserialize_item = service_deserialize_item, + .active_state = service_active_state, + .sub_state_to_string = service_sub_state_to_string, + + .check_gc = service_check_gc, + .check_snapshot = service_check_snapshot, .sigchld_event = service_sigchld_event, .timer_event = service_timer_event, .cgroup_notify_empty = service_cgroup_notify_event, + .bus_name_owner_change = service_bus_name_owner_change, + .bus_query_pid_done = service_bus_query_pid_done, + + .bus_message_handler = bus_service_message_handler, + .enumerate = service_enumerate };