typedef enum RunlevelType {
RUNLEVEL_UP,
RUNLEVEL_DOWN,
- RUNLEVEL_BASIC
+ RUNLEVEL_SYSINIT
} RunlevelType;
static const struct {
{ "rc6.d", SPECIAL_RUNLEVEL6_TARGET, RUNLEVEL_DOWN },
/* SUSE style boot.d */
- { "boot.d", SPECIAL_BASIC_TARGET, RUNLEVEL_BASIC },
+ { "boot.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
/* Debian style rcS.d */
- { "rcS.d", SPECIAL_BASIC_TARGET, RUNLEVEL_BASIC },
+ { "rcS.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
};
#define RUNLEVELS_UP "12345"
[SERVICE_STOP_POST] = UNIT_DEACTIVATING,
[SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
[SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
- [SERVICE_MAINTAINANCE] = UNIT_INACTIVE,
+ [SERVICE_MAINTENANCE] = UNIT_INACTIVE,
[SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
};
free(s->sysv_runlevels);
s->sysv_runlevels = NULL;
+ free(s->status_text);
+ s->status_text = NULL;
+
exec_context_done(&s->exec_context);
exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
s->control_command = NULL;
endswith(name, ".sh.service"))
return -ENOENT;
- STRV_FOREACH(p, UNIT(s)->meta.manager->sysvinit_path) {
+ STRV_FOREACH(p, UNIT(s)->meta.manager->lookup_paths.sysvinit_path) {
char *path;
int r;
/* Load service data from SysV init scripts, preferably with
* LSB headers ... */
- if (strv_isempty(UNIT(s)->meta.manager->sysvinit_path))
+ if (strv_isempty(UNIT(s)->meta.manager->lookup_paths.sysvinit_path))
return 0;
if ((t = UNIT(s)->meta.id))
fprintf(f, "%sSysVRunLevels: %s\n",
prefix, s->sysv_runlevels);
+ if (s->status_text)
+ fprintf(f, "%sStatus Text: %s\n",
+ prefix, s->status_text);
+
free(p2);
}
if ((unsigned long) (pid_t) p != p)
return -ERANGE;
+ if (p <= 1)
+ return -ERANGE;
+
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);
state == SERVICE_STOP_POST ||
state == SERVICE_FINAL_SIGTERM ||
state == SERVICE_FINAL_SIGKILL ||
- state == SERVICE_MAINTAINANCE ||
+ state == SERVICE_MAINTENANCE ||
state == SERVICE_AUTO_RESTART)
service_notify_sockets_dead(s);
if ((s->deserialized_state == SERVICE_START &&
(s->type == SERVICE_FORKING ||
- s->type == SERVICE_DBUS)) ||
+ s->type == SERVICE_DBUS ||
+ s->type == SERVICE_FINISH ||
+ s->type == SERVICE_NOTIFY)) ||
s->deserialized_state == SERVICE_START_POST ||
s->deserialized_state == SERVICE_RUNNING ||
s->deserialized_state == SERVICE_RELOAD ||
service_set_state(s, SERVICE_AUTO_RESTART);
} else
- service_set_state(s, s->failure ? SERVICE_MAINTAINANCE : SERVICE_DEAD);
+ service_set_state(s, s->failure ? SERVICE_MAINTENANCE : SERVICE_DEAD);
return;
return;
fail:
- log_warning("%s failed to run stop-post executable: %s", UNIT(s)->meta.id, strerror(-r));
+ log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->meta.id, strerror(-r));
service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
}
return;
fail:
- log_warning("%s failed to run stop executable: %s", UNIT(s)->meta.id, strerror(-r));
+ log_warning("%s failed to run 'stop' task: %s", UNIT(s)->meta.id, strerror(-r));
service_enter_signal(s, SERVICE_STOP_SIGTERM, false);
}
return;
fail:
- log_warning("%s failed to run start-post executable: %s", UNIT(s)->meta.id, strerror(-r));
+ log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->meta.id, strerror(-r));
service_enter_stop(s, false);
}
if ((r = service_spawn(s,
s->exec_command[SERVICE_EXEC_START],
- s->type == SERVICE_FORKING || s->type == SERVICE_DBUS,
+ s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY,
true,
true,
true,
service_set_state(s, SERVICE_START);
} else if (s->type == SERVICE_FINISH ||
- s->type == SERVICE_DBUS) {
+ s->type == SERVICE_DBUS ||
+ s->type == SERVICE_NOTIFY) {
/* 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. */
+ * but wait for the bus name to appear on the
+ * bus. Notify services are similar. */
s->main_pid = pid;
s->main_pid_known = true;
return;
fail:
- log_warning("%s failed to run start exectuable: %s", UNIT(s)->meta.id, strerror(-r));
+ log_warning("%s failed to run 'start' task: %s", UNIT(s)->meta.id, strerror(-r));
service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
}
return;
fail:
- log_warning("%s failed to run start-pre executable: %s", UNIT(s)->meta.id, strerror(-r));
+ log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->meta.id, strerror(-r));
service_enter_dead(s, false, true);
}
return;
fail:
- log_warning("%s failed to run reload executable: %s", UNIT(s)->meta.id, strerror(-r));
+ log_warning("%s failed to run 'reload' task: %s", UNIT(s)->meta.id, strerror(-r));
service_enter_stop(s, false);
}
return;
fail:
- log_warning("%s failed to run spawn next executable: %s", UNIT(s)->meta.id, strerror(-r));
+ log_warning("%s failed to run spawn next task: %s", UNIT(s)->meta.id, strerror(-r));
if (s->state == SERVICE_START_PRE)
service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
s->state == SERVICE_START_POST)
return 0;
- assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTAINANCE || s->state == SERVICE_AUTO_RESTART);
+ assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTENANCE || s->state == SERVICE_AUTO_RESTART);
/* Make sure we don't enter a busy loop of some kind. */
if (!ratelimit_test(&s->ratelimit)) {
exec_status_fill(&s->main_exec_status, pid, code, status);
s->main_pid = 0;
- if (s->type == SERVICE_SIMPLE || s->type == SERVICE_FINISH) {
+ if (s->type != SERVICE_FORKING) {
assert(s->exec_command[SERVICE_EXEC_START]);
s->exec_command[SERVICE_EXEC_START]->exec_status = s->main_exec_status;
}
break;
case SERVICE_START:
- assert(s->type == SERVICE_FINISH);
+ if (s->type == SERVICE_FINISH) {
+ /* This was our main goal, so let's go on */
+ if (success)
+ service_enter_start_post(s);
+ else
+ service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
+ break;
+ } else {
+ assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
- /* This was our main goal, so let's go on */
- if (success)
- service_enter_start_post(s);
- else
- service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
- break;
+ /* Fall through */
+ }
case SERVICE_RUNNING:
service_enter_running(s, success);
assert_not_reached("Uh, control process died at wrong time.");
}
}
- } else
- assert_not_reached("Got SIGCHLD for unkown PID");
+ }
}
static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
break;
case SERVICE_FINAL_SIGKILL:
- log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", u->meta.id);
+ log_warning("%s still around after SIGKILL (2). Entering maintenance mode.", u->meta.id);
service_enter_dead(s, false, true);
break;
}
}
+static void service_notify_message(Unit *u, char **tags) {
+ Service *s = SERVICE(u);
+ const char *e;
+
+ assert(u);
+
+ log_debug("%s: Got message", u->meta.id);
+
+ /* Interpret MAINPID= */
+ if ((e = strv_find_prefix(tags, "MAINPID=")) &&
+ (s->state == SERVICE_START ||
+ s->state == SERVICE_START_POST ||
+ s->state == SERVICE_RUNNING ||
+ s->state == SERVICE_RELOAD)) {
+ unsigned long pid;
+
+ if (safe_atolu(e + 8, &pid) < 0 ||
+ (unsigned long) (pid_t) pid != pid ||
+ pid <= 1)
+ log_warning("Failed to parse %s", e);
+ else {
+ log_debug("%s: got %s", u->meta.id, e);
+ s->main_pid = (pid_t) pid;
+ }
+ }
+
+ /* Interpret READY= */
+ if (s->type == SERVICE_NOTIFY &&
+ s->state == SERVICE_START &&
+ strv_find(tags, "READY=1")) {
+ log_debug("%s: got READY=1", u->meta.id);
+
+ service_enter_start_post(s);
+ }
+
+ /* Interpret STATUS= */
+ if ((e = strv_find_prefix(tags, "STATUS="))) {
+ char *t;
+
+ if (!(t = strdup(e+7))) {
+ log_error("Failed to allocate string.");
+ return;
+ }
+
+ log_debug("%s: got %s", u->meta.id, e);
+
+ free(s->status_text);
+ s->status_text = t;
+ }
+}
+
static int service_enumerate(Manager *m) {
char **p;
unsigned i;
assert(m);
- STRV_FOREACH(p, m->sysvrcnd_path)
+ STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
struct dirent *de;
}
if (de->d_name[0] == 'S' &&
- (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_BASIC))
+ (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT))
SERVICE(service)->sysv_start_priority =
MAX(a*10 + b, SERVICE(service)->sysv_start_priority);
if ((r = unit_add_dependency(service, UNIT_BEFORE, runlevel_target, true)) < 0)
goto finish;
- } else if (de->d_name[0] == 'K' && rcnd_table[i].type == RUNLEVEL_DOWN) {
+ } else if (de->d_name[0] == 'K' &&
+ (rcnd_table[i].type == RUNLEVEL_DOWN ||
+ rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
Unit *shutdown_target;
/* We honour K links only for
* really distuingish here
* between the runlevels 0 and
* 6 and just add them to the
- * special shutdown target. */
+ * special shutdown target. On
+ * SUSE the boot.d/ runlevel
+ * is also used for shutdown,
+ * so we add links for that
+ * too to the shutdown
+ * target.*/
if ((r = manager_load_unit(m, SPECIAL_SHUTDOWN_TARGET, NULL, &shutdown_target)) < 0)
goto finish;
[SERVICE_STOP_POST] = "stop-post",
[SERVICE_FINAL_SIGTERM] = "final-sigterm",
[SERVICE_FINAL_SIGKILL] = "final-sigkill",
- [SERVICE_MAINTAINANCE] = "maintainance",
+ [SERVICE_MAINTENANCE] = "maintenance",
[SERVICE_AUTO_RESTART] = "auto-restart",
};
[SERVICE_FORKING] = "forking",
[SERVICE_SIMPLE] = "simple",
[SERVICE_FINISH] = "finish",
- [SERVICE_DBUS] = "dbus"
+ [SERVICE_DBUS] = "dbus",
+ [SERVICE_NOTIFY] = "notify"
};
DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
.timer_event = service_timer_event,
.cgroup_notify_empty = service_cgroup_notify_event,
+ .notify_message = service_notify_message,
.bus_name_owner_change = service_bus_name_owner_change,
.bus_query_pid_done = service_bus_query_pid_done,
~ianmdlvl / elogind.git / blobdiff