X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=service.c;h=0a70bb0a7c518168c6d7d01375b0930c10fe34e9;hp=67950d4e649d587cf7f77930c926eee2093da7d7;hb=ba8c0bef6bbb3f8cb92e0bf381fbe5a84584506f;hpb=47be870bd83fb3719dffc3ee9348a409ab762a14 diff --git a/service.c b/service.c index 67950d4e6..0a70bb0a7 100644 --- a/service.c +++ b/service.c @@ -21,12 +21,30 @@ #include #include +#include +#include #include "unit.h" #include "service.h" #include "load-fragment.h" #include "load-dropin.h" #include "log.h" +#include "strv.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, + "/boot.d", SPECIAL_BASIC_TARGET +}; static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = { [SERVICE_DEAD] = UNIT_INACTIVE, @@ -34,6 +52,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, @@ -45,6 +64,26 @@ 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_done(Unit *u) { Service *s = SERVICE(u); @@ -53,42 +92,618 @@ static void service_done(Unit *u) { free(s->pid_file); s->pid_file = NULL; + 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); + + unit_unwatch_timer(u, &s->timer_watch); +} + +static int sysv_translate_name(const char *name, char **_r) { + + static const char * const table[] = { + "$local_fs", SPECIAL_LOCAL_FS_TARGET, + "$network", SPECIAL_NETWORK_TARGET, + "$named", SPECIAL_NSS_LOOKUP_TARGET, + "$portmap", SPECIAL_RPCBIND_TARGET, + "$remote_fs", SPECIAL_REMOTE_FS_TARGET, + "$syslog", SPECIAL_SYSLOG_TARGET, + "$time", SPECIAL_RTC_SET_TARGET + }; + + unsigned i; + char *r; + + for (i = 0; i < ELEMENTSOF(table); i += 2) + if (streq(table[i], name)) { + if (!(r = strdup(table[i+1]))) + return -ENOMEM; + + goto finish; + } + + if (*name == '$') + return 0; + + if (asprintf(&r, "%s.service", name) < 0) + return -ENOMEM; + +finish: + + if (_r) + *_r = r; + + return 1; +} + +static int sysv_chkconfig_order(Service *s) { + Meta *other; + int r; + + assert(s); + + if (s->sysv_start_priority < 0) + return 0; + + /* For each pair of services where at least one lacks a LSB + * header, we use the start priority value to order things. */ + + LIST_FOREACH(units_per_type, other, UNIT(s)->meta.manager->units_per_type[UNIT_SERVICE]) { + Service *t; + UnitDependency d; + + t = (Service*) other; + + if (s == t) + continue; + + if (t->sysv_start_priority < 0) + continue; + + /* 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) + d = UNIT_AFTER; + else if (t->sysv_start_priority > s->sysv_start_priority) + d = UNIT_BEFORE; + else + continue; + + /* FIXME: Maybe we should compare the name here lexicographically? */ + + if (!(r = unit_add_dependency(UNIT(s), d, UNIT(t))) < 0) + return r; } - if (s->control_pid > 0) { - unit_unwatch_pid(u, s->control_pid); - s->control_pid = 0; + return 0; +} + +static ExecCommand *exec_command_new(const char *path, const char *arg1) { + ExecCommand *c; + + if (!(c = new0(ExecCommand, 1))) + return NULL; + + if (!(c->path = strdup(path))) { + free(c); + return NULL; } - unit_unwatch_timer(u, &s->timer_watch); + if (!(c->argv = strv_new(path, arg1, NULL))) { + free(c->path); + free(c); + return NULL; + } + + return c; +} + +static int sysv_exec_commands(Service *s) { + ExecCommand *c; + + assert(s); + assert(s->sysv_path); + + if (!(c = exec_command_new(s->sysv_path, "start"))) + return -ENOMEM; + exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c); + + if (!(c = exec_command_new(s->sysv_path, "stop"))) + return -ENOMEM; + exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c); + + if (!(c = exec_command_new(s->sysv_path, "reload"))) + return -ENOMEM; + exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c); + + return 0; +} + +static int priority_from_rcd(Service *s, const char *init_script) { + char **p; + unsigned i; + + STRV_FOREACH(p, UNIT(s)->meta.manager->sysvrcnd_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) { + FILE *f; + Unit *u; + unsigned line = 0; + int r; + enum { + NORMAL, + DESCRIPTION, + LSB, + LSB_DESCRIPTION + } state = NORMAL; + + assert(s); + assert(path); + + u = UNIT(s); + + if (!(f = fopen(path, "re"))) { + r = errno == ENOENT ? 0 : -errno; + goto finish; + } + + s->type = SERVICE_FORKING; + s->restart = SERVICE_ONCE; + + free(s->sysv_path); + if (!(s->sysv_path = strdup(path))) { + r = -ENOMEM; + goto finish; + } + + while (!feof(f)) { + char l[LINE_MAX], *t; + + if (!fgets(l, sizeof(l), f)) { + if (feof(f)) + break; + + r = -errno; + log_error("Failed to read configuration file '%s': %s", path, strerror(-r)); + goto finish; + } + + line++; + + t = strstrip(l); + if (*t != '#') + continue; + + if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) { + state = LSB; + s->sysv_has_lsb = true; + continue; + } + + if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) { + state = NORMAL; + continue; + } + + t++; + t += strspn(t, WHITESPACE); + + if (state == NORMAL) { + + /* Try to parse Red Hat style chkconfig headers */ + + if (startswith(t, "chkconfig:")) { + int start_priority; + char runlevels[16], *k; + + state = NORMAL; + + 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) + log_warning("[%s:%u] Start priority out of range. Ignoring.", path, line); + else + 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:")) { + + size_t k = strlen(t); + char *d; + + if (t[k-1] == '\\') { + state = DESCRIPTION; + t[k-1] = 0; + } + + if (!(d = strdup(strstrip(t+12)))) { + r = -ENOMEM; + goto finish; + } + + free(u->meta.description); + u->meta.description = d; + + } else if (startswith(t, "pidfile:")) { + + char *fn; + + state = NORMAL; + + fn = strstrip(t+8); + if (!path_is_absolute(fn)) { + log_warning("[%s:%u] PID file not absolute. Ignoring.", path, line); + continue; + } + + if (!(fn = strdup(fn))) { + r = -ENOMEM; + goto finish; + } + + free(s->pid_file); + s->pid_file = fn; + } + + } else if (state == DESCRIPTION) { + + /* Try to parse Red Hat style description + * continuation */ + + size_t k = strlen(t); + char *d; + + if (t[k-1] == '\\') + t[k-1] = 0; + else + state = NORMAL; + + assert(u->meta.description); + if (asprintf(&d, "%s %s", u->meta.description, strstrip(t)) < 0) { + r = -ENOMEM; + goto finish; + } + + free(u->meta.description); + u->meta.description = d; + + } else if (state == LSB || state == LSB_DESCRIPTION) { + + if (startswith(t, "Provides:")) { + char *i, *w; + size_t z; + + state = LSB; + + FOREACH_WORD(w, z, t+9, i) { + char *n, *m; + + if (!(n = strndup(w, z))) { + r = -ENOMEM; + goto finish; + } + + r = sysv_translate_name(n, &m); + free(n); + + if (r < 0) + goto finish; + + if (r == 0) + continue; + + 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); + } + + free(m); + + if (r < 0) + goto finish; + } + + } else if (startswith(t, "Required-Start:") || + startswith(t, "Should-Start:")) { + char *i, *w; + size_t z; + + state = LSB; + + FOREACH_WORD(w, z, strchr(t, ':')+1, i) { + char *n, *m; + + if (!(n = strndup(w, z))) { + r = -ENOMEM; + goto finish; + } + + r = sysv_translate_name(n, &m); + free(n); + + if (r < 0) + goto finish; + + if (r == 0) + continue; + + r = unit_add_dependency_by_name(u, UNIT_AFTER, m); + 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; + + state = LSB_DESCRIPTION; + + if (!(d = strdup(strstrip(t+12)))) { + r = -ENOMEM; + goto finish; + } + + free(u->meta.description); + u->meta.description = d; + + } else if (startswith(t, "Short-Description:") && + !u->meta.description) { + char *d; + + /* We use the short description only + * if no long description is set. */ + + state = LSB; + + if (!(d = strdup(strstrip(t+18)))) { + r = -ENOMEM; + goto finish; + } + + u->meta.description = d; + + } else if (state == LSB_DESCRIPTION) { + + if (startswith(l, "#\t") || startswith(l, "# ")) { + char *d; + + assert(u->meta.description); + if (asprintf(&d, "%s %s", u->meta.description, t) < 0) { + r = -ENOMEM; + goto finish; + } + + free(u->meta.description); + u->meta.description = d; + } else + state = LSB; + } + } + } + + /* If init scripts have no LSB header, then we enforce the + * ordering via the chkconfig priorities. We try to determine + * 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 ((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)); + } + + if ((r = sysv_exec_commands(s)) < 0) + goto finish; + + if (!s->sysv_runlevels || chars_intersect("12345", s->sysv_runlevels)) { + /* 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 ((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) + 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; + +finish: + + if (f) + fclose(f); + + return r; +} + +static int service_load_sysv_name(Service *s, const char *name) { + char **p; + + assert(s); + assert(name); + + STRV_FOREACH(p, UNIT(s)->meta.manager->sysvinit_path) { + char *path; + int r; + + if (asprintf(&path, "%s/%s", *p, name) < 0) + return -ENOMEM; + + assert(endswith(path, ".service")); + path[strlen(path)-8] = 0; + + r = service_load_sysv_path(s, path); + free(path); + + if (r < 0) + return r; + + if ((UNIT(s)->meta.load_state != UNIT_STUB)) + break; + } + + return 0; } static int service_load_sysv(Service *s) { + const char *t; + Iterator i; + int r; + assert(s); /* Load service data from SysV init scripts, preferably with * LSB headers ... */ - return -ENOENT; + 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)) < 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))) + continue; + + if ((r == service_load_sysv_name(s, t)) < 0) + return r; + + if (UNIT(s)->meta.load_state != UNIT_STUB) + break; + } + + return 0; } -static int service_init(Unit *u) { - int r; +static void service_init(Unit *u) { Service *s = SERVICE(u); - assert(s); - - /* First, reset everything to the defaults, in case this is a - * reload */ + assert(u); + assert(u->meta.load_state == UNIT_STUB); s->type = 0; s->restart = 0; @@ -102,28 +717,70 @@ static int service_init(Unit *u) { s->state = SERVICE_DEAD; + s->sysv_start_priority = -1; + s->permissions_start_only = false; + s->root_directory_start_only = false; + s->valid_no_process = false; + s->kill_mode = 0; + s->sysv_has_lsb = false; + s->main_pid = s->control_pid = 0; + s->main_pid_known = false; + s->failure = false; + 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_id(UNIT(s))); + return -EINVAL; + } + + return 0; +} + +static int service_load(Unit *u) { + int r; + Service *s = SERVICE(u); + + assert(s); /* Load a .service file */ - if ((r = unit_load_fragment(u)) < 0) { - service_done(u); + if ((r = unit_load_fragment(u)) < 0) return r; - } - /* Load a classic init script as a fallback, if we couldn*t find anything */ - if (r == 0) - if ((r = service_load_sysv(s)) <= 0) { - service_done(u); - return r < 0 ? r : -ENOENT; - } + /* Load a classic init script as a fallback, if we couldn't find anything */ + if (u->meta.load_state == UNIT_STUB) + if ((r = service_load_sysv(s)) < 0) + return r; - /* Load dropin directory data */ - if ((r = unit_load_dropin(u)) < 0) { - service_done(u); + /* Still nothing found? Then let's give up */ + if (u->meta.load_state == UNIT_STUB) + return -ENOENT; + + /* We were able to load something, then let's add in the + * dropin directories. */ + if ((r = unit_load_dropin(unit_follow_merge(u))) < 0) return r; + + /* This is a new unit? Then let's add in some extras */ + if (u->meta.load_state == UNIT_LOADED) { + if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0) + return r; + + if ((r = unit_add_default_cgroup(u)) < 0) + return r; + + if ((r = sysv_chkconfig_order(s)) < 0) + return r; } - return 0; + return service_verify(s); } static void service_dump(Unit *u, FILE *f, const char *prefix) { @@ -139,18 +796,37 @@ static void service_dump(Unit *u, FILE *f, const char *prefix) { prefix2 = p2 ? p2 : prefix; fprintf(f, - "%sService State: %s\n", - prefix, service_state_to_string(s->state)); + "%sService State: %s\n" + "%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); - 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; @@ -161,6 +837,22 @@ static void service_dump(Unit *u, FILE *f, const char *prefix) { exec_command_dump_list(s->exec_command[c], f, prefix2); } + if (s->sysv_path) + fprintf(f, + "%sSysV Init Script Path: %s\n" + "%sSysV Init Script has LSB Header: %s\n", + prefix, s->sysv_path, + prefix, yes_no(s->sysv_has_lsb)); + + if (s->sysv_start_priority >= 0) + fprintf(f, + "%sSysVStartPriority: %i\n", + prefix, s->sysv_start_priority); + + if (s->sysv_runlevels) + fprintf(f, "%sSysVRunLevels: %s\n", + prefix, s->sysv_runlevels); + free(p2); } @@ -174,6 +866,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; @@ -188,7 +882,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; @@ -240,7 +944,7 @@ fail: } -static int service_notify_sockets(Service *s) { +static int service_notify_sockets_dead(Service *s) { Iterator i; Set *set; Socket *sock; @@ -288,10 +992,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 && @@ -302,19 +1003,10 @@ 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; + } if (state == SERVICE_DEAD || state == SERVICE_STOP || @@ -325,9 +1017,10 @@ 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 (old_state != state) + log_debug("%s changed %s → %s", unit_id(UNIT(s)), service_state_to_string(old_state), service_state_to_string(state)); unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]); } @@ -393,7 +1086,15 @@ fail: return r; } -static int service_spawn(Service *s, ExecCommand *c, bool timeout, bool pass_fds, pid_t *_pid) { +static int service_spawn( + Service *s, + ExecCommand *c, + bool timeout, + bool pass_fds, + bool apply_permissions, + bool apply_chroot, + pid_t *_pid) { + pid_t pid; int r; int *fds = NULL; @@ -413,7 +1114,14 @@ static int service_spawn(Service *s, ExecCommand *c, bool timeout, bool pass_fds } else unit_unwatch_timer(UNIT(s), &s->timer_watch); - if ((r = exec_spawn(c, &s->exec_context, fds, n_fds, &pid)) < 0) + if ((r = exec_spawn(c, + &s->exec_context, + fds, n_fds, + apply_permissions, + apply_chroot, + UNIT(s)->meta.manager->confirm_spawn, + UNIT(s)->meta.cgroup_bondings, + &pid)) < 0) goto fail; if ((r = unit_watch_pid(UNIT(s), pid)) < 0) @@ -434,6 +1142,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); @@ -468,20 +1211,27 @@ 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])) - if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0) - goto fail; + 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, + false, + !s->permissions_start_only, + !s->root_directory_start_only, + &s->control_pid)) < 0) + goto fail; - service_set_state(s, SERVICE_STOP_POST); - if (!s->control_command) - service_enter_dead(s, true, true); + service_set_state(s, SERVICE_STOP_POST); + } else + service_enter_signal(s, SERVICE_FINAL_SIGTERM, true); return; fail: - log_warning("%s failed to run stop executable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run stop-post executable: %s", unit_id(UNIT(s)), strerror(-r)); service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); } @@ -494,33 +1244,48 @@ 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) { + 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; @@ -528,10 +1293,7 @@ static void service_enter_signal(Service *s, ServiceState state, bool success) { fail: log_warning("%s failed to kill processes: %s", unit_id(UNIT(s)), strerror(-r)); - if (sent) { - s->failure = true; - service_set_state(s, state); - } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL) + if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL) service_enter_stop_post(s, false); else service_enter_dead(s, false, true); @@ -544,13 +1306,20 @@ static void service_enter_stop(Service *s, bool success) { if (!success) s->failure = true; - if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) - if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0) - goto fail; + service_unwatch_control_pid(s); - service_set_state(s, SERVICE_STOP); + if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) { + if ((r = service_spawn(s, + s->control_command, + true, + false, + !s->permissions_start_only, + !s->root_directory_start_only, + &s->control_pid)) < 0) + goto fail; - if (!s->control_command) + service_set_state(s, SERVICE_STOP); + } else service_enter_signal(s, SERVICE_STOP_SIGTERM, true); return; @@ -560,19 +1329,40 @@ fail: 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])) - if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0) - goto fail; + 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, + false, + !s->permissions_start_only, + !s->root_directory_start_only, + &s->control_pid)) < 0) + 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; @@ -590,17 +1380,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 ((r = service_spawn(s, s->exec_command[SERVICE_EXEC_START], s->type == SERVICE_FORKING, true, &pid)) < 0) + 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, + 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) { @@ -609,14 +1409,20 @@ 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"); @@ -624,7 +1430,7 @@ static void service_enter_start(Service *s) { fail: log_warning("%s failed to run start exectuable: %s", unit_id(UNIT(s)), strerror(-r)); - service_enter_stop(s, false); + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); } static void service_enter_start_pre(Service *s) { @@ -632,13 +1438,20 @@ static void service_enter_start_pre(Service *s) { assert(s); - if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) - if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0) - goto fail; + service_unwatch_control_pid(s); - service_set_state(s, SERVICE_START_PRE); + if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) { + if ((r = service_spawn(s, + s->control_command, + true, + false, + !s->permissions_start_only, + !s->root_directory_start_only, + &s->control_pid)) < 0) + goto fail; - if (!s->control_command) + service_set_state(s, SERVICE_START_PRE); + } else service_enter_start(s); return; @@ -652,11 +1465,12 @@ 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); return; fail: @@ -670,14 +1484,21 @@ static void service_enter_reload(Service *s) { assert(s); - if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) - if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0) - goto fail; + service_unwatch_control_pid(s); - service_set_state(s, SERVICE_RELOAD); + if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) { + if ((r = service_spawn(s, + s->control_command, + true, + false, + !s->permissions_start_only, + !s->root_directory_start_only, + &s->control_pid)) < 0) + goto fail; - if (!s->control_command) - service_set_state(s, SERVICE_RUNNING); + service_set_state(s, SERVICE_RELOAD); + } else + service_enter_running(s, true); return; @@ -698,7 +1519,15 @@ static void service_run_next(Service *s, bool success) { s->control_command = s->control_command->command_next; - if ((r = service_spawn(s, s->control_command, true, false, &s->control_pid)) < 0) + service_unwatch_control_pid(s); + + if ((r = service_spawn(s, + s->control_command, + true, + false, + !s->permissions_start_only, + !s->root_directory_start_only, + &s->control_pid)) < 0) goto fail; return; @@ -706,8 +1535,10 @@ static void service_run_next(Service *s, bool success) { fail: log_warning("%s failed to run spawn next executable: %s", unit_id(UNIT(s)), strerror(-r)); - if (s->state == SERVICE_STOP) - service_enter_stop_post(s, false); + if (s->state == SERVICE_START_PRE) + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); + else if (s->state == SERVICE_STOP) + service_enter_signal(s, SERVICE_STOP_SIGTERM, false); else if (s->state == SERVICE_STOP_POST) service_enter_dead(s, false, true); else @@ -755,18 +1586,28 @@ 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); service_enter_stop(s, true); return 0; @@ -777,7 +1618,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; @@ -797,27 +1638,6 @@ 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 -1; -} - -static bool control_pid_good(Service *s) { - assert(s); - - return s->control_pid > 0; -} - static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { Service *s = SERVICE(u); bool success; @@ -838,7 +1658,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", unit_id(u), sigchld_code_to_string(code), status); /* The service exited, so the service is officially * gone. */ @@ -859,11 +1679,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: @@ -890,15 +1710,15 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int 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))) + if (s->control_command->command_next && success) { /* There is another command to * * execute, so let's do that. */ + log_debug("%s running next command for state %s", unit_id(u), service_state_to_string(s->state)); service_run_next(s, success); - else { + } else { /* No further commands for this step, so let's * figure out what to do next */ @@ -910,7 +1730,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: @@ -929,7 +1749,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; @@ -949,22 +1769,15 @@ static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) { /* 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 + 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: @@ -1003,6 +1816,10 @@ 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.", unit_id(u)); + service_enter_signal(s, SERVICE_FINAL_SIGTERM, false); + break; + case SERVICE_START_POST: case SERVICE_RELOAD: log_warning("%s operation timed out. Stopping.", unit_id(u)); @@ -1053,12 +1870,145 @@ static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) { } } +static void service_cgroup_notify_event(Unit *u) { + Service *s = SERVICE(u); + + assert(u); + + log_debug("%s: cgroup is empty", unit_id(u)); + + switch (s->state) { + + /* Waiting for SIGCHLD is usually more interesting, + * because it includes return codes/signals. Which is + * why we ignore the cgroup events for most cases, + * except when we don't know pid which to expect the + * SIGCHLD for. */ + + case SERVICE_RUNNING: + service_enter_running(s, true); + break; + + default: + ; + } +} + +static int service_enumerate(Manager *m) { + char **p; + unsigned i; + DIR *d = NULL; + char *path = NULL, *fpath = NULL, *name = NULL; + int r; + + assert(m); + + STRV_FOREACH(p, m->sysvrcnd_path) + for (i = 0; i < ELEMENTSOF(rcnd_table); i += 2) { + struct dirent *de; + + free(path); + path = NULL; + if (asprintf(&path, "%s/%s", *p, rcnd_table[i]) < 0) { + r = -ENOMEM; + goto finish; + } + + if (d) + closedir(d); + + if (!(d = opendir(path))) { + if (errno != ENOENT) + log_warning("opendir() failed on %s: %s", path, strerror(errno)); + + continue; + } + + while ((de = readdir(d))) { + Unit *runlevel, *service; + + if (ignore_file(de->d_name)) + continue; + + if (de->d_name[0] != 'S' && de->d_name[0] != 'K') + continue; + + if (strlen(de->d_name) < 4) + continue; + + free(fpath); + fpath = NULL; + if (asprintf(&fpath, "%s/%s/%s", *p, rcnd_table[i], de->d_name) < 0) { + r = -ENOMEM; + goto finish; + } + + if (access(fpath, X_OK) < 0) { + + if (errno != ENOENT) + log_warning("access() failed on %s: %s", fpath, strerror(errno)); + + continue; + } + + free(name); + name = NULL; + if (asprintf(&name, "%s.service", de->d_name+3) < 0) { + r = -ENOMEM; + goto finish; + } + + if ((r = manager_load_unit(m, name, &service)) < 0) + goto finish; + + if ((r = manager_load_unit(m, rcnd_table[i+1], &runlevel)) < 0) + goto finish; + + if (de->d_name[0] == 'S') { + if ((r = unit_add_dependency(runlevel, UNIT_WANTS, service)) < 0) + goto finish; + + if ((r = unit_add_dependency(runlevel, UNIT_AFTER, service)) < 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))) { + + /* 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. */ + + if ((r = unit_add_dependency(runlevel, UNIT_CONFLICTS, service)) < 0) + goto finish; + + if ((r = unit_add_dependency(runlevel, UNIT_BEFORE, service)) < 0) + goto finish; + } + } + } + + r = 0; + +finish: + free(path); + free(fpath); + free(name); + closedir(d); + + return r; +} + 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", @@ -1075,7 +2025,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); @@ -1088,7 +2038,7 @@ static const char* const service_type_table[_SERVICE_TYPE_MAX] = { 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", @@ -1103,6 +2053,7 @@ const UnitVTable service_vtable = { .suffix = ".service", .init = service_init, + .load = service_load, .done = service_done, .dump = service_dump, @@ -1117,4 +2068,8 @@ const UnitVTable service_vtable = { .sigchld_event = service_sigchld_event, .timer_event = service_timer_event, + + .cgroup_notify_empty = service_cgroup_notify_event, + + .enumerate = service_enumerate };