-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
#include "unit-name.h"
#include "dbus-service.h"
#include "special.h"
+#include "bus-errors.h"
#define COMMENTS "#;\n"
#define NEWLINES "\n\r"
-#define LINE_MAX 4096
typedef enum RunlevelType {
RUNLEVEL_UP,
const char *target;
const RunlevelType type;
} rcnd_table[] = {
- /* Standard SysV runlevels */
- { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
+ /* Standard SysV runlevels for start-up */
{ "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
{ "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
{ "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
{ "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
{ "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
- { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN },
+#ifdef TARGET_SUSE
/* SUSE style boot.d */
{ "boot.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
+#endif
+#ifdef TARGET_DEBIAN
/* Debian style rcS.d */
{ "rcS.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
+#endif
+
+ /* Standard SysV runlevels for shutdown */
+ { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
+ { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
+
+ /* Note that the order here matters, as we read the
+ directories in this order, and we want to make sure that
+ sysv_start_priority is known when we first load the
+ unit. And that value we only know from S links. Hence
+ UP/SYSINIT must be read before DOWN */
};
#define RUNLEVELS_UP "12345"
[SERVICE_START_POST] = UNIT_ACTIVATING,
[SERVICE_RUNNING] = UNIT_ACTIVE,
[SERVICE_EXITED] = UNIT_ACTIVE,
- [SERVICE_RELOAD] = UNIT_ACTIVE_RELOADING,
+ [SERVICE_RELOAD] = UNIT_RELOADING,
[SERVICE_STOP] = UNIT_DEACTIVATING,
[SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
[SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
[SERVICE_STOP_POST] = UNIT_DEACTIVATING,
[SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
[SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
- [SERVICE_MAINTENANCE] = UNIT_INACTIVE,
- [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING,
+ [SERVICE_MAINTENANCE] = UNIT_MAINTENANCE,
+ [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
};
static void service_init(Unit *u) {
s->main_pid = pid;
s->main_pid_known = true;
+ exec_status_start(&s->main_exec_status, pid);
+
return 0;
}
LIST_FOREACH(units_per_type, other, s->meta.manager->units_per_type[UNIT_SERVICE]) {
Service *t;
UnitDependency d;
+ bool special_s, special_t;
t = (Service*) other;
(!t->sysv_path || t->sysv_has_lsb))
continue;
- if (t->sysv_start_priority < s->sysv_start_priority)
+ special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
+ special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
+
+ if (special_t && !special_s)
+ d = UNIT_AFTER;
+ else if (special_s && !special_t)
+ d = UNIT_BEFORE;
+ else 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;
s->sysv_runlevels = d;
}
- } else if (startswith_no_case(t, "description:")) {
+ } else if (startswith_no_case(t, "description:") &&
+ !u->meta.description) {
size_t k = strlen(t);
char *d;
state = LSB;
- FOREACH_WORD(w, z, t+9, i) {
+ FOREACH_WORD_QUOTED(w, z, t+9, i) {
char *n, *m;
if (!(n = strndup(w, z))) {
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, NULL, true)) >= 0)
- r = unit_add_dependency_by_name(u, UNIT_BEFORE, m, NULL, true);
- }
+ 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);
free(m);
state = LSB;
- FOREACH_WORD(w, z, strchr(t, ':')+1, i) {
+ FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
char *n, *m;
if (!(n = strndup(w, z))) {
s->sysv_runlevels = d;
}
- } else if (startswith_no_case(t, "Description:")) {
+ } else if (startswith_no_case(t, "Description:") &&
+ !u->meta.description) {
char *d;
+ /* We use the long description only if
+ * no short description is set. */
+
state = LSB_DESCRIPTION;
if (!(d = strdup(strstrip(t+12)))) {
free(u->meta.description);
u->meta.description = d;
- } else if (startswith_no_case(t, "Short-Description:") &&
- !u->meta.description) {
+ } else if (startswith_no_case(t, "Short-Description:")) {
char *d;
- /* We use the short description only
- * if no long description is set. */
-
state = LSB;
if (!(d = strdup(strstrip(t+18)))) {
goto finish;
}
+ free(u->meta.description);
u->meta.description = d;
} else if (startswith_no_case(t, "X-Interactive:")) {
if ((r = sysv_exec_commands(s)) < 0)
goto finish;
- if (!s->sysv_runlevels || chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
+ if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, 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, NULL, true)) < 0 ||
- (r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
- goto finish;
+ s->meta.default_dependencies = false;
- } else
/* Don't timeout special services during boot (like fsck) */
s->timeout_usec = 0;
+ }
/* Special setting for all SysV services */
s->type = SERVICE_FORKING;
s->valid_no_process = true;
- s->kill_mode = KILL_PROCESS_GROUP;
s->restart = SERVICE_ONCE;
+ s->exec_context.std_output = s->meta.manager->sysv_console ? EXEC_OUTPUT_TTY : EXEC_OUTPUT_NULL;
+ s->exec_context.kill_mode = KILL_PROCESS_GROUP;
u->meta.load_state = UNIT_LOADED;
r = 0;
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 -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 (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);
+ log_error("%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", s->meta.id);
+ return -EINVAL;
+ }
+
+ if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
+ log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", s->meta.id);
return -EINVAL;
}
return 0;
}
+static int service_add_default_dependencies(Service *s) {
+ int r;
+
+ assert(s);
+
+ /* Add a number of automatic dependencies useful for the
+ * majority of services. */
+
+ /* First, pull in base system */
+ if (s->meta.manager->running_as == MANAGER_SYSTEM) {
+
+ if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
+ return r;
+
+ } else if (s->meta.manager->running_as == MANAGER_SESSION) {
+
+ if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
+ return r;
+ }
+
+ /* Second, activate normal shutdown */
+ return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTED_BY, SPECIAL_SHUTDOWN_TARGET, NULL, true);
+}
+
static int service_load(Unit *u) {
int r;
Service *s = SERVICE(u);
return r;
if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
- return r;
+ return r;
}
if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
s->notify_access = NOTIFY_MAIN;
+
+ if (s->type == SERVICE_DBUS || s->bus_name)
+ if ((r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_TARGET, NULL, true)) < 0)
+ return r;
+
+ if (s->meta.default_dependencies)
+ if ((r = service_add_default_dependencies(s)) < 0)
+ return r;
}
return service_verify(s);
"%sPermissionsStartOnly: %s\n"
"%sRootDirectoryStartOnly: %s\n"
"%sValidNoProcess: %s\n"
- "%sKillMode: %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, kill_mode_to_string(s->kill_mode),
prefix, service_type_to_string(s->type),
+ prefix, service_restart_to_string(s->restart),
prefix, notify_access_to_string(s->notify_access));
if (s->control_pid > 0)
if (s->sysv_start_priority >= 0)
fprintf(f,
- "%sSysVStartPriority: %i\n",
- prefix, s->sysv_start_priority);
+ "%sSysVStartPriority: %i\n"
+ "%sSysVEnabled: %s\n",
+ prefix, s->sysv_start_priority,
+ prefix, yes_no(s->sysv_enabled));
if (s->sysv_runlevels)
fprintf(f, "%sSysVRunLevels: %s\n",
service_connection_unref(s);
}
+ /* For the inactive states unit_notify() will trim the cgroup,
+ * but for exit we have to do that ourselves... */
+ if (state == SERVICE_EXITED)
+ cgroup_bonding_trim_list(s->meta.cgroup_bondings, true);
+
if (old_state != state)
log_debug("%s changed %s -> %s", s->meta.id, service_state_to_string(old_state), service_state_to_string(state));
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 ||
bool pass_fds,
bool apply_permissions,
bool apply_chroot,
+ bool apply_tty_stdin,
bool set_notify_socket,
pid_t *_pid) {
pid_t pid;
int r;
int *fds = NULL, *fdsbuf = NULL;
- unsigned n_fds = 0;
- char **argv = NULL, **env = NULL;
+ unsigned n_fds = 0, n_env = 0;
+ char **argv = NULL, **final_env = NULL, **our_env = NULL;
assert(s);
assert(c);
goto fail;
}
- if (set_notify_socket) {
- char *t;
+ if (!(our_env = new0(char*, 3))) {
+ r = -ENOMEM;
+ goto fail;
+ }
- if (asprintf(&t, "NOTIFY_SOCKET=@%s", s->meta.manager->notify_socket) < 0) {
+ if (set_notify_socket)
+ if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=@%s", s->meta.manager->notify_socket) < 0) {
r = -ENOMEM;
goto fail;
}
- env = strv_env_set(s->meta.manager->environment, t);
- free(t);
-
- if (!env) {
+ if (s->main_pid > 0)
+ if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
r = -ENOMEM;
goto fail;
}
- } else
- env = s->meta.manager->environment;
+
+ if (!(final_env = strv_env_merge(2,
+ s->meta.manager->environment,
+ our_env,
+ NULL))) {
+ r = -ENOMEM;
+ goto fail;
+ }
r = exec_spawn(c,
argv,
&s->exec_context,
fds, n_fds,
- env,
+ final_env,
apply_permissions,
apply_chroot,
+ apply_tty_stdin,
s->meta.manager->confirm_spawn,
s->meta.cgroup_bondings,
&pid);
- strv_free(argv);
- argv = NULL;
-
- if (set_notify_socket)
- strv_free(env);
- env = NULL;
-
if (r < 0)
goto fail;
- if (fdsbuf)
- free(fdsbuf);
if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
/* FIXME: we need to do something here */
goto fail;
+ free(fdsbuf);
+ strv_free(argv);
+ strv_free(our_env);
+ strv_free(final_env);
+
*_pid = pid;
return 0;
fail:
- free(fds);
-
+ free(fdsbuf);
strv_free(argv);
-
- if (set_notify_socket)
- strv_free(env);
+ strv_free(our_env);
+ strv_free(final_env);
if (timeout)
unit_unwatch_timer(UNIT(s), &s->timer_watch);
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))) {
} else
service_set_state(s, s->failure ? SERVICE_MAINTENANCE : SERVICE_DEAD);
+ s->forbid_restart = false;
+
return;
fail:
false,
!s->permissions_start_only,
!s->root_directory_start_only,
+ true,
false,
&s->control_pid)) < 0)
goto fail;
if (!success)
s->failure = true;
- if (s->kill_mode != KILL_NONE) {
- int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
+ 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->kill_mode == KILL_CONTROL_GROUP) {
+ if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig)) < 0) {
if (r != -EAGAIN && r != -ESRCH)
r = 0;
if (s->main_pid > 0) {
- if (kill(s->kill_mode == KILL_PROCESS ? s->main_pid : -s->main_pid, sig) < 0 && errno != ESRCH)
+ if (kill(s->exec_context.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)
+ if (kill(s->exec_context.kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH)
r = -errno;
else
sent = true;
!s->permissions_start_only,
!s->root_directory_start_only,
false,
+ false,
&s->control_pid)) < 0)
goto fail;
}
static void service_enter_running(Service *s, bool success) {
+ int main_pid_ok, cgroup_ok;
assert(s);
if (!success)
s->failure = true;
- if (main_pid_good(s) != 0 &&
- cgroup_good(s) != 0 &&
+ main_pid_ok = main_pid_good(s);
+ cgroup_ok = cgroup_good(s);
+
+ 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)
!s->permissions_start_only,
!s->root_directory_start_only,
false,
+ false,
&s->control_pid)) < 0)
goto fail;
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,
true,
+ true,
s->notify_access != NOTIFY_NONE,
&pid)) < 0)
goto fail;
/* 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,
false,
!s->permissions_start_only,
!s->root_directory_start_only,
+ true,
false,
&s->control_pid)) < 0)
goto fail;
static void service_enter_restart(Service *s) {
int r;
+ DBusError error;
+
assert(s);
+ dbus_error_init(&error);
service_enter_dead(s, true, false);
- if ((r = manager_add_job(s->meta.manager, JOB_START, UNIT(s), JOB_FAIL, false, NULL)) < 0)
+ if ((r = manager_add_job(s->meta.manager, JOB_START, UNIT(s), JOB_FAIL, false, NULL, NULL)) < 0)
goto fail;
log_debug("%s scheduled restart job.", s->meta.id);
return;
fail:
-
- log_warning("%s failed to schedule restart job: %s", s->meta.id, strerror(-r));
+ log_warning("%s failed to schedule restart job: %s", s->meta.id, bus_error(&error, -r));
service_enter_dead(s, false, false);
+
+ dbus_error_free(&error);
}
static void service_enter_reload(Service *s) {
!s->permissions_start_only,
!s->root_directory_start_only,
false,
+ false,
&s->control_pid)) < 0)
goto fail;
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,
false,
!s->permissions_start_only,
!s->root_directory_start_only,
+ s->control_command_id == SERVICE_EXEC_START_PRE ||
+ s->control_command_id == SERVICE_EXEC_STOP_POST,
false,
&s->control_pid)) < 0)
goto fail;
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);
return -ECANCELED;
}
+ if ((s->exec_context.std_input == EXEC_INPUT_SOCKET ||
+ s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
+ s->exec_context.std_error == EXEC_OUTPUT_SOCKET) &&
+ s->socket_fd < 0) {
+ log_warning("%s can only be started with a per-connection socket.", u->meta.id);
+ return -EINVAL;
+ }
+
s->failure = false;
s->main_pid_known = false;
- s->allow_restart = true;
+ s->forbid_restart = false;
service_enter_start_pre(s);
return 0;
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;
+ /* This is a user request, so don't do restarts on this
+ * shutdown. */
+ s->forbid_restart = true;
/* Already on it */
if (s->state == SERVICE_STOP ||
s->state == SERVICE_FINAL_SIGKILL)
return 0;
+ /* Don't allow a restart */
if (s->state == SERVICE_AUTO_RESTART) {
service_set_state(s, SERVICE_DEAD);
return 0;
}
- assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
+ /* If there's already something running we go directly into
+ * kill mode. */
+ if (s->state == SERVICE_START_PRE ||
+ s->state == SERVICE_START ||
+ s->state == SERVICE_START_POST ||
+ s->state == SERVICE_RELOAD) {
+ service_enter_signal(s, SERVICE_STOP_SIGTERM, true);
+ return 0;
+ }
- /* This is a user request, so don't do restarts on this
- * shutdown. */
- s->allow_restart = false;
+ assert(s->state == SERVICE_RUNNING ||
+ s->state == SERVICE_EXITED);
service_enter_stop(s, true);
return 0;
unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
+ if (s->status_text)
+ unit_serialize_item(u, f, "status-text", s->status_text);
+
/* There's a minor uncleanliness here: if there are multiple
* commands attached here, we will start from the first one
* again */
unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
}
+ if (s->main_exec_status.pid > 0) {
+ unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
+
+ if (s->main_exec_status.start_timestamp.realtime > 0) {
+ unit_serialize_item_format(u, f, "main-exec-status-start-realtime",
+ "%llu", (unsigned long long) s->main_exec_status.start_timestamp.realtime);
+
+ unit_serialize_item_format(u, f, "main-exec-status-start-monotonic",
+ "%llu", (unsigned long long) s->main_exec_status.start_timestamp.monotonic);
+ }
+
+ if (s->main_exec_status.exit_timestamp.realtime > 0) {
+ unit_serialize_item_format(u, f, "main-exec-status-exit-realtime",
+ "%llu", (unsigned long long) s->main_exec_status.exit_timestamp.realtime);
+ unit_serialize_item_format(u, f, "main-exec-status-exit-monotonic",
+ "%llu", (unsigned long long) s->main_exec_status.exit_timestamp.monotonic);
+
+ unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
+ unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
+ }
+ }
+
return 0;
}
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);
log_debug("Failed to parse main-pid-known value %s", value);
else
s->main_pid_known = b;
+ } else if (streq(key, "status-text")) {
+ char *t;
+
+ if ((t = strdup(value))) {
+ free(s->status_text);
+ s->status_text = t;
+ }
+
} else if (streq(key, "control-command")) {
ServiceExecCommand id;
close_nointr_nofail(s->socket_fd);
s->socket_fd = fdset_remove(fds, fd);
}
+ } else if (streq(key, "main-exec-status-pid")) {
+ pid_t pid;
+
+ 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 (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 (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 (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 (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 (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 (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;
} else
log_debug("Unknown serialization key '%s'", key);
assert(pid >= 0);
success = is_clean_exit(code, status);
- s->failure = s->failure || !success;
if (s->main_pid == pid) {
- exec_status_fill(&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 && s->control_command) {
+ s->control_command->exec_status = s->main_exec_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->control_command->ignore)
+ success = true;
}
- log_debug("%s: main process exited, code=%s, status=%i", u->meta.id, sigchld_code_to_string(code), status);
+ log_full(success ? LOG_DEBUG : LOG_NOTICE,
+ "%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);
+
+ /* Fall through */
+ }
- case SERVICE_RUNNING:
- service_enter_running(s, success);
- break;
+ 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) {
- 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", u->meta.id, sigchld_code_to_string(code), status);
+ if (s->control_command) {
+ exec_status_exit(&s->control_command->exec_status, pid, code, status);
- /* If we are shutting things down anyway we
- * don't care about failing commands. */
+ if (s->control_command->ignore)
+ success = true;
+ }
- if (s->control_command && s->control_command->command_next && success) {
+ 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 (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
break;
case SERVICE_AUTO_RESTART:
- log_debug("%s holdoff time over, scheduling restart.", u->meta.id);
+ log_info("%s holdoff time over, scheduling restart.", u->meta.id);
service_enter_restart(s);
break;
s->state == SERVICE_RELOAD)) {
if (parse_pid(e + 8, &pid) < 0)
- log_warning("Failed to parse %s", e);
+ log_warning("Failed to parse notification message %s", e);
else {
log_debug("%s: got %s", u->meta.id, e);
service_set_main_pid(s, pid);
if ((e = strv_find_prefix(tags, "STATUS="))) {
char *t;
- if (!(t = strdup(e+7))) {
- log_error("Failed to allocate string.");
- return;
- }
+ if (e[7]) {
+ if (!(t = strdup(e+7))) {
+ log_error("Failed to allocate string.");
+ return;
+ }
- log_debug("%s: got %s", u->meta.id, e);
+ log_debug("%s: got %s", u->meta.id, e);
+
+ free(s->status_text);
+ s->status_text = t;
+ } else {
+ free(s->status_text);
+ s->status_text = NULL;
+ }
- free(s->status_text);
- s->status_text = t;
}
}
goto finish;
}
- if ((r = manager_load_unit_prepare(m, name, NULL, &service)) < 0) {
+ if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
continue;
}
if (de->d_name[0] == 'S' &&
- (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT))
+ (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;
+ }
manager_dispatch_load_queue(m);
service = unit_follow_merge(service);
- if (de->d_name[0] == 'S') {
- Unit *runlevel_target;
-
- if ((r = manager_load_unit(m, rcnd_table[i].target, NULL, &runlevel_target)) < 0)
- goto finish;
+ /* 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;
- if ((r = unit_add_dependency(runlevel_target, UNIT_WANTS, service, true)) < 0)
- goto finish;
+ if (de->d_name[0] == 'S') {
- if ((r = unit_add_dependency(service, UNIT_BEFORE, runlevel_target, true)) < 0)
+ if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
goto finish;
} 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
* halt/reboot. For the normal
* too to the shutdown
* target.*/
- if ((r = manager_load_unit(m, SPECIAL_SHUTDOWN_TARGET, NULL, &shutdown_target)) < 0)
- goto finish;
-
- 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)
+ if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
goto finish;
}
}
return 0;
}
+static void service_reset_maintenance(Unit *u) {
+ Service *s = SERVICE(u);
+
+ assert(s);
+
+ if (s->state == SERVICE_MAINTENANCE)
+ service_set_state(s, SERVICE_DEAD);
+
+ s->failure = false;
+}
+
static const char* const service_state_table[_SERVICE_STATE_MAX] = {
[SERVICE_DEAD] = "dead",
[SERVICE_START_PRE] = "start-pre",
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_FORKING] = "forking",
+ [SERVICE_ONESHOT] = "oneshot",
[SERVICE_DBUS] = "dbus",
[SERVICE_NOTIFY] = "notify"
};
const UnitVTable service_vtable = {
.suffix = ".service",
+ .show_status = true,
.init = service_init,
.done = service_done,
.sigchld_event = service_sigchld_event,
.timer_event = service_timer_event,
+ .reset_maintenance = service_reset_maintenance,
+
.cgroup_notify_empty = service_cgroup_notify_event,
.notify_message = service_notify_message,