-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
[SERVICE_STOP_POST] = UNIT_DEACTIVATING,
[SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
[SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
- [SERVICE_MAINTENANCE] = UNIT_MAINTENANCE,
+ [SERVICE_FAILED] = UNIT_FAILED,
[SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
};
"$time", SPECIAL_RTC_SET_TARGET,
/* Debian extensions */
+#ifdef TARGET_DEBIAN
"$mail-transport-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
+#endif
"$mail-transfer-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
- "$x-display-manager", SPECIAL_DISPLAY_MANAGER_SERVICE
+ "$x-display-manager", SPECIAL_DISPLAY_MANAGER_SERVICE,
+
+#ifdef TARGET_FEDORA
+ /* Fedora extensions, lacking the $ prefix */
+ "MTA", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
+ "smtpdaemon", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
+ "httpd", SPECIAL_HTTP_DAEMON_TARGET,
+#endif
};
unsigned i;
t[k-1] = 0;
}
- if (!(d = strdup(strstrip(t+12)))) {
+ if (!(d = strappend("LSB: ", strstrip(t+12)))) {
r = -ENOMEM;
goto finish;
}
if (unit_name_to_type(m) == UNIT_SERVICE)
r = unit_add_name(u, m);
- else if (s->sysv_enabled)
- r = unit_add_two_dependencies_by_name_inverse(u, UNIT_AFTER, UNIT_WANTS, m, NULL, true);
- else
- r = unit_add_dependency_by_name_inverse(u, UNIT_AFTER, m, NULL, true);
+ else {
+ r = unit_add_dependency_by_name(u, UNIT_BEFORE, m, NULL, true);
- free(m);
+ if (s->sysv_enabled) {
+ int k;
+
+ if ((k = unit_add_dependency_by_name_inverse(u, UNIT_WANTS, m, NULL, true)) < 0)
+ r = k;
+ }
+ }
if (r < 0)
- goto finish;
+ log_error("[%s:%u] Failed to add LSB Provides name %s, ignoring: %s", path, line, m, strerror(-r));
+
+ free(m);
}
} else if (startswith_no_case(t, "Required-Start:") ||
continue;
r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
- free(m);
if (r < 0)
- goto finish;
+ log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", path, line, m, strerror(-r));
+
+ free(m);
}
} else if (startswith_no_case(t, "Default-Start:")) {
char *k, *d;
state = LSB_DESCRIPTION;
- if (!(d = strdup(strstrip(t+12)))) {
+ if (!(d = strappend("LSB: ", strstrip(t+12)))) {
r = -ENOMEM;
goto finish;
}
state = LSB;
- if (!(d = strdup(strstrip(t+18)))) {
+ if (!(d = strappend("LSB: ", strstrip(t+18)))) {
r = -ENOMEM;
goto finish;
}
/* Special setting for all SysV services */
s->type = SERVICE_FORKING;
- s->valid_no_process = true;
+ s->remain_after_exit = true;
s->restart = SERVICE_ONCE;
- s->exec_context.std_output = s->meta.manager->sysv_console ? EXEC_OUTPUT_TTY : EXEC_OUTPUT_NULL;
+ s->exec_context.std_output =
+ (s->meta.manager->sysv_console || s->exec_context.std_input == EXEC_INPUT_TTY)
+ ? EXEC_OUTPUT_TTY : EXEC_OUTPUT_NULL;
s->exec_context.kill_mode = KILL_PROCESS_GROUP;
u->meta.load_state = UNIT_LOADED;
if (t == s->meta.id)
continue;
- if ((r == service_load_sysv_name(s, t)) < 0)
+ if ((r = service_load_sysv_name(s, t)) < 0)
return r;
if (s->meta.load_state != UNIT_STUB)
return 0;
}
-static int service_add_bus_name(Service *s) {
- char *n;
- int r;
-
- assert(s);
- assert(s->bus_name);
-
- if (asprintf(&n, "dbus-%s.service", s->bus_name) < 0)
- return 0;
-
- r = unit_merge_by_name(UNIT(s), n);
- free(n);
-
- return r;
-}
-
static int service_verify(Service *s) {
assert(s);
return -EINVAL;
}
- if (s->exec_command[SERVICE_EXEC_START]->command_next) {
- log_error("%s has more than one ExecStart setting. Refusing.", s->meta.id);
+ if (s->type != SERVICE_ONESHOT &&
+ s->exec_command[SERVICE_EXEC_START]->command_next) {
+ log_error("%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", s->meta.id);
return -EINVAL;
}
if ((r = sysv_fix_order(s)) < 0)
return r;
- if (s->bus_name) {
- if ((r = service_add_bus_name(s)) < 0)
- return r;
-
+ if (s->bus_name)
if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
return r;
- }
if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
s->notify_access = NOTIFY_MAIN;
"%sService State: %s\n"
"%sPermissionsStartOnly: %s\n"
"%sRootDirectoryStartOnly: %s\n"
- "%sValidNoProcess: %s\n"
+ "%sRemainAfterExit: %s\n"
"%sType: %s\n"
"%sRestart: %s\n"
"%sNotifyAccess: %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, yes_no(s->remain_after_exit),
prefix, service_type_to_string(s->type),
prefix, service_restart_to_string(s->restart),
prefix, notify_access_to_string(s->notify_access));
state == SERVICE_STOP_POST ||
state == SERVICE_FINAL_SIGTERM ||
state == SERVICE_FINAL_SIGKILL ||
- state == SERVICE_MAINTENANCE ||
+ state == SERVICE_FAILED ||
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_FINISH ||
+ s->type == SERVICE_ONESHOT ||
s->type == SERVICE_NOTIFY)) ||
s->deserialized_state == SERVICE_START_POST ||
s->deserialized_state == SERVICE_RUNNING ||
s->failure = true;
if (allow_restart &&
- s->allow_restart &&
+ !s->forbid_restart &&
(s->restart == SERVICE_RESTART_ALWAYS ||
(s->restart == SERVICE_RESTART_ON_SUCCESS && !s->failure))) {
service_set_state(s, SERVICE_AUTO_RESTART);
} else
- service_set_state(s, s->failure ? SERVICE_MAINTENANCE : SERVICE_DEAD);
+ service_set_state(s, s->failure ? SERVICE_FAILED : SERVICE_DEAD);
+
+ s->forbid_restart = false;
return;
static void service_enter_signal(Service *s, ServiceState state, bool success) {
int r;
- bool sent = false;
+ Set *pid_set = NULL;
+ bool wait_for_exit = false;
assert(s);
if (s->exec_context.kill_mode != KILL_NONE) {
int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
- if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
+ if (s->main_pid > 0) {
+ if (kill(s->exec_context.kill_mode == KILL_PROCESS_GROUP ?
+ -s->main_pid :
+ s->main_pid, sig) < 0 && errno != ESRCH)
- if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig)) < 0) {
- if (r != -EAGAIN && r != -ESRCH)
- goto fail;
- } else
- sent = true;
+ log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
+ else
+ wait_for_exit = true;
}
- if (!sent) {
- r = 0;
+ if (s->control_pid > 0) {
+ if (kill(s->exec_context.kill_mode == KILL_PROCESS_GROUP ?
+ -s->control_pid :
+ s->control_pid, sig) < 0 && errno != ESRCH)
- if (s->main_pid > 0) {
- if (kill(s->exec_context.kill_mode == KILL_PROCESS ? s->main_pid : -s->main_pid, sig) < 0 && errno != ESRCH)
- r = -errno;
- else
- sent = true;
- }
+ log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
+ else
+ wait_for_exit = true;
+ }
- if (s->control_pid > 0) {
- if (kill(s->exec_context.kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH)
- r = -errno;
- else
- sent = true;
- }
+ if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
- if (r < 0)
+ if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
+ r = -ENOMEM;
goto fail;
+ }
+
+ /* Exclude the main/control pids from being killed via the cgroup */
+ if (s->main_pid > 0)
+ if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
+ goto fail;
+
+ if (s->control_pid > 0)
+ if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
+ goto fail;
+
+ if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig, pid_set)) < 0) {
+ if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
+ log_warning("Failed to kill control group: %s", strerror(-r));
+ } else if (r > 0)
+ wait_for_exit = true;
+
+ set_free(pid_set);
}
}
- if (sent && (s->main_pid > 0 || s->control_pid > 0)) {
+ if (wait_for_exit) {
if (s->timeout_usec > 0)
if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
goto fail;
service_enter_stop_post(s, false);
else
service_enter_dead(s, false, true);
+
+ if (pid_set)
+ set_free(pid_set);
}
static void service_enter_stop(Service *s, bool success) {
if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
(s->bus_name_good || s->type != SERVICE_DBUS))
service_set_state(s, SERVICE_RUNNING);
- else if (s->valid_no_process)
+ else if (s->remain_after_exit)
service_set_state(s, SERVICE_EXITED);
else
service_enter_stop(s, true);
assert(s);
assert(s->exec_command[SERVICE_EXEC_START]);
- assert(!s->exec_command[SERVICE_EXEC_START]->command_next);
+ assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
if (s->type == SERVICE_FORKING)
service_unwatch_control_pid(s);
else
service_unwatch_main_pid(s);
+ s->control_command_id = SERVICE_EXEC_START;
+ s->control_command = s->exec_command[SERVICE_EXEC_START];
+
if ((r = service_spawn(s,
- s->exec_command[SERVICE_EXEC_START],
+ s->control_command,
s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY,
true,
true,
/* For forking services we wait until the start
* process exited. */
- s->control_command_id = SERVICE_EXEC_START;
- s->control_command = s->exec_command[SERVICE_EXEC_START];
-
s->control_pid = pid;
service_set_state(s, SERVICE_START);
- } else if (s->type == SERVICE_FINISH ||
+ } else if (s->type == SERVICE_ONESHOT ||
s->type == SERVICE_DBUS ||
s->type == SERVICE_NOTIFY) {
- /* For finishing services we wait until the start
+ /* For oneshot 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,
service_enter_dead(s, true, false);
- if ((r = manager_add_job(s->meta.manager, JOB_START, UNIT(s), JOB_FAIL, false, NULL, NULL)) < 0)
+ if ((r = manager_add_job(s->meta.manager, JOB_START, UNIT(s), JOB_FAIL, false, &error, NULL)) < 0)
goto fail;
log_debug("%s scheduled restart job.", s->meta.id);
service_enter_stop(s, false);
}
-static void service_run_next(Service *s, bool success) {
+static void service_run_next_control(Service *s, bool success) {
int r;
assert(s);
if (!success)
s->failure = true;
- s->control_command = s->control_command->command_next;
+ assert(s->control_command_id != SERVICE_EXEC_START);
+ s->control_command = s->control_command->command_next;
service_unwatch_control_pid(s);
if ((r = service_spawn(s,
return;
fail:
- log_warning("%s failed to run next task: %s", s->meta.id, strerror(-r));
+ log_warning("%s failed to run next control task: %s", s->meta.id, strerror(-r));
if (s->state == SERVICE_START_PRE)
service_enter_signal(s, SERVICE_FINAL_SIGTERM, false);
service_enter_stop(s, false);
}
+static void service_run_next_main(Service *s, bool success) {
+ pid_t pid;
+ int r;
+
+ assert(s);
+ assert(s->control_command);
+ assert(s->control_command->command_next);
+
+ if (!success)
+ s->failure = true;
+
+ assert(s->control_command_id == SERVICE_EXEC_START);
+ assert(s->type == SERVICE_ONESHOT);
+
+ s->control_command = s->control_command->command_next;
+ service_unwatch_main_pid(s);
+
+ if ((r = service_spawn(s,
+ s->control_command,
+ false,
+ true,
+ true,
+ true,
+ true,
+ s->notify_access != NOTIFY_NONE,
+ &pid)) < 0)
+ goto fail;
+
+ service_set_main_pid(s, pid);
+
+ return;
+
+fail:
+ log_warning("%s failed to run next main task: %s", s->meta.id, strerror(-r));
+ service_enter_stop(s, false);
+}
+
static int service_start(Unit *u) {
Service *s = SERVICE(u);
s->state == SERVICE_START_POST)
return 0;
- assert(s->state == SERVICE_DEAD || s->state == SERVICE_MAINTENANCE || s->state == SERVICE_AUTO_RESTART);
+ assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED || s->state == SERVICE_AUTO_RESTART);
/* Make sure we don't enter a busy loop of some kind. */
if (!ratelimit_test(&s->ratelimit)) {
s->failure = false;
s->main_pid_known = false;
- s->allow_restart = true;
+ s->forbid_restart = false;
service_enter_start_pre(s);
return 0;
/* This is a user request, so don't do restarts on this
* shutdown. */
- s->allow_restart = false;
+ s->forbid_restart = true;
/* Already on it */
if (s->state == SERVICE_STOP ||
static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
Service *s = SERVICE(u);
- int r;
assert(u);
assert(key);
} else if (streq(key, "control-pid")) {
pid_t pid;
- if ((r = parse_pid(value, &pid)) < 0)
+ if (parse_pid(value, &pid) < 0)
log_debug("Failed to parse control-pid value %s", value);
else
s->control_pid = pid;
} else if (streq(key, "main-pid")) {
pid_t pid;
- if ((r = parse_pid(value, &pid)) < 0)
+ if (parse_pid(value, &pid) < 0)
log_debug("Failed to parse main-pid value %s", value);
else
service_set_main_pid(s, (pid_t) pid);
} else if (streq(key, "main-exec-status-pid")) {
pid_t pid;
- if ((r = parse_pid(value, &pid)) < 0)
+ if (parse_pid(value, &pid) < 0)
log_debug("Failed to parse main-exec-status-pid value %s", value);
else
s->main_exec_status.pid = pid;
} else if (streq(key, "main-exec-status-code")) {
int i;
- if ((r = safe_atoi(value, &i)) < 0)
+ if (safe_atoi(value, &i) < 0)
log_debug("Failed to parse main-exec-status-code value %s", value);
else
s->main_exec_status.code = i;
} else if (streq(key, "main-exec-status-status")) {
int i;
- if ((r = safe_atoi(value, &i)) < 0)
+ if (safe_atoi(value, &i) < 0)
log_debug("Failed to parse main-exec-status-status value %s", value);
else
s->main_exec_status.status = i;
} else if (streq(key, "main-exec-status-start-realtime")) {
uint64_t k;
- if ((r = safe_atou64(value, &k)) < 0)
+ if (safe_atou64(value, &k) < 0)
log_debug("Failed to parse main-exec-status-start-realtime value %s", value);
else
s->main_exec_status.start_timestamp.realtime = (usec_t) k;
} else if (streq(key, "main-exec-status-start-monotonic")) {
uint64_t k;
- if ((r = safe_atou64(value, &k)) < 0)
+ if (safe_atou64(value, &k) < 0)
log_debug("Failed to parse main-exec-status-start-monotonic value %s", value);
else
s->main_exec_status.start_timestamp.monotonic = (usec_t) k;
} else if (streq(key, "main-exec-status-exit-realtime")) {
uint64_t k;
- if ((r = safe_atou64(value, &k)) < 0)
+ if (safe_atou64(value, &k) < 0)
log_debug("Failed to parse main-exec-status-exit-realtime value %s", value);
else
s->main_exec_status.exit_timestamp.realtime = (usec_t) k;
} else if (streq(key, "main-exec-status-exit-monotonic")) {
uint64_t k;
- if ((r = safe_atou64(value, &k)) < 0)
+ if (safe_atou64(value, &k) < 0)
log_debug("Failed to parse main-exec-status-exit-monotonic value %s", value);
else
s->main_exec_status.exit_timestamp.monotonic = (usec_t) k;
assert(s);
assert(pid >= 0);
- success = is_clean_exit(code, status);
+ if (s->sysv_path)
+ success = is_clean_exit_lsb(code, status);
+ else
+ success = is_clean_exit(code, status);
if (s->main_pid == pid) {
- exec_status_exit(&s->main_exec_status, pid, code, status);
s->main_pid = 0;
+ exec_status_exit(&s->main_exec_status, pid, code, status);
- if (s->type != SERVICE_FORKING) {
- assert(s->exec_command[SERVICE_EXEC_START]);
- s->exec_command[SERVICE_EXEC_START]->exec_status = s->main_exec_status;
+ if (s->type != SERVICE_FORKING && s->control_command) {
+ s->control_command->exec_status = s->main_exec_status;
- if (s->exec_command[SERVICE_EXEC_START]->ignore)
+ if (s->control_command->ignore)
success = true;
}
"%s: main process exited, code=%s, status=%i", u->meta.id, sigchld_code_to_string(code), status);
s->failure = s->failure || !success;
- /* The service exited, so the service is officially
- * gone. */
+ if (s->control_command &&
+ s->control_command->command_next &&
+ success) {
- switch (s->state) {
+ /* There is another command to *
+ * execute, so let's do that. */
- case SERVICE_START_POST:
- case SERVICE_RELOAD:
- case SERVICE_STOP:
- /* Need to wait until the operation is
- * done */
- break;
+ log_debug("%s running next main command for state %s", u->meta.id, service_state_to_string(s->state));
+ service_run_next_main(s, success);
- case SERVICE_START:
- 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);
+ } else {
+
+ /* The service exited, so the service is officially
+ * gone. */
+
+ s->control_command = NULL;
+ s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
+
+ switch (s->state) {
+
+ case SERVICE_START_POST:
+ case SERVICE_RELOAD:
+ case SERVICE_STOP:
+ /* Need to wait until the operation is
+ * done */
break;
- } else {
- assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
- /* Fall through */
- }
+ case SERVICE_START:
+ if (s->type == SERVICE_ONESHOT) {
+ /* 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);
- case SERVICE_RUNNING:
- service_enter_running(s, success);
- break;
+ /* Fall through */
+ }
+
+ case SERVICE_RUNNING:
+ service_enter_running(s, success);
+ break;
- case SERVICE_STOP_SIGTERM:
- case SERVICE_STOP_SIGKILL:
+ case SERVICE_STOP_SIGTERM:
+ case SERVICE_STOP_SIGKILL:
- if (!control_pid_good(s))
- service_enter_stop_post(s, success);
+ if (!control_pid_good(s))
+ service_enter_stop_post(s, success);
- /* If there is still a control process, wait for that first */
- break;
+ /* If there is still a control process, wait for that first */
+ break;
- default:
- assert_not_reached("Uh, main process died at wrong time.");
+ default:
+ assert_not_reached("Uh, main process died at wrong time.");
+ }
}
} else if (s->control_pid == pid) {
+ s->control_pid = 0;
+
if (s->control_command) {
exec_status_exit(&s->control_command->exec_status, pid, code, status);
success = true;
}
- s->control_pid = 0;
-
- log_full(success ? LOG_DEBUG : LOG_NOTICE,
+ log_full(success ? LOG_DEBUG : LOG_NOTICE,
"%s: control process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status);
s->failure = s->failure || !success;
- /* If we are shutting things down anyway we
- * don't care about failing commands. */
-
- if (s->control_command && s->control_command->command_next && success) {
+ 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);
+ log_debug("%s running next control command for state %s", u->meta.id, service_state_to_string(s->state));
+ service_run_next_control(s, success);
} else {
/* No further commands for this step, so let's
}
}
}
+
+ /* Notify clients about changed exit status */
+ unit_add_to_dbus_queue(u);
}
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 maintenance mode.", u->meta.id);
+ log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->meta.id);
service_enter_dead(s, false, true);
break;
service_enter_running(s, true);
break;
+ case SERVICE_STOP_SIGTERM:
+ case SERVICE_STOP_SIGKILL:
+ if (main_pid_good(s) <= 0 && !control_pid_good(s))
+ service_enter_stop_post(s, true);
+
+ break;
+
+ case SERVICE_FINAL_SIGTERM:
+ case SERVICE_FINAL_SIGKILL:
+ if (main_pid_good(s) <= 0 && !control_pid_good(s))
+ service_enter_dead(s, true, true);
+
+ break;
+
default:
;
}
}
}
+
+ /* Notify clients about changed status or main pid */
+ unit_add_to_dbus_queue(u);
}
static int service_enumerate(Manager *m) {
unsigned i;
DIR *d = NULL;
char *path = NULL, *fpath = NULL, *name = NULL;
+ Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
+ Unit *service;
+ Iterator j;
int r;
assert(m);
+ zero(runlevel_services);
+
STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
struct dirent *de;
}
while ((de = readdir(d))) {
- Unit *service;
int a, b;
if (ignore_file(de->d_name))
continue;
}
- if (de->d_name[0] == 'S' &&
- (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);
- SERVICE(service)->sysv_enabled = true;
- }
+ if (de->d_name[0] == 'S') {
- manager_dispatch_load_queue(m);
- service = unit_follow_merge(service);
+ if (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 this is a native service, rely
- * on native ways to pull in a
- * service, don't pull it in via sysv
- * rcN.d links. */
- if (service->meta.fragment_path)
- continue;
+ SERVICE(service)->sysv_enabled = true;
+ }
- if (de->d_name[0] == 'S') {
+ if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
+ goto finish;
- if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
+ if ((r = set_put(runlevel_services[i], service)) < 0)
goto finish;
} else if (de->d_name[0] == 'K' &&
(rcnd_table[i].type == RUNLEVEL_DOWN ||
rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
- /* 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. Also, we don't
- * really distuingish here
- * between the runlevels 0 and
- * 6 and just add them to the
- * 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 = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
+ if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
+ goto finish;
+
+ if ((r = set_put(shutdown_services, service)) < 0)
goto finish;
}
}
}
+ /* Now we loaded all stubs and are aware of the lowest
+ start-up priority for all services, not let's actually load
+ the services, this will also tell us which services are
+ actually native now */
+ manager_dispatch_load_queue(m);
+
+ /* If this is a native service, rely on native ways to pull in
+ * a service, don't pull it in via sysv rcN.d links. */
+ for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
+ SET_FOREACH(service, runlevel_services[i], j) {
+ service = unit_follow_merge(service);
+
+ if (service->meta.fragment_path)
+ continue;
+
+ if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
+ goto finish;
+ }
+
+ /* 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. Also, we don't really distuingish here
+ * between the runlevels 0 and 6 and just add them to the
+ * 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.*/
+ SET_FOREACH(service, shutdown_services, j) {
+ service = unit_follow_merge(service);
+
+ if (service->meta.fragment_path)
+ continue;
+
+ if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
+ goto finish;
+ }
+
r = 0;
finish:
free(fpath);
free(name);
+ for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
+ set_free(runlevel_services[i]);
+ set_free(shutdown_services);
+
if (d)
closedir(d);
return 0;
}
-static void service_reset_maintenance(Unit *u) {
+static void service_reset_failed(Unit *u) {
Service *s = SERVICE(u);
assert(s);
- if (s->state == SERVICE_MAINTENANCE)
+ if (s->state == SERVICE_FAILED)
service_set_state(s, SERVICE_DEAD);
s->failure = false;
[SERVICE_STOP_POST] = "stop-post",
[SERVICE_FINAL_SIGTERM] = "final-sigterm",
[SERVICE_FINAL_SIGKILL] = "final-sigkill",
- [SERVICE_MAINTENANCE] = "maintenance",
+ [SERVICE_FAILED] = "failed",
[SERVICE_AUTO_RESTART] = "auto-restart",
};
static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
[SERVICE_SIMPLE] = "simple",
[SERVICE_FORKING] = "forking",
- [SERVICE_FINISH] = "finish",
+ [SERVICE_ONESHOT] = "oneshot",
[SERVICE_DBUS] = "dbus",
[SERVICE_NOTIFY] = "notify"
};
.sigchld_event = service_sigchld_event,
.timer_event = service_timer_event,
- .reset_maintenance = service_reset_maintenance,
+ .reset_failed = service_reset_failed,
.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,
+ .bus_interface = "org.freedesktop.systemd1.Service",
.bus_message_handler = bus_service_message_handler,
+ .bus_invalidating_properties = bus_service_invalidating_properties,
.enumerate = service_enumerate
};
~ianmdlvl / elogind.git / blobdiff