1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
26 #include <sys/reboot.h>
31 #include "load-fragment.h"
32 #include "load-dropin.h"
35 #include "unit-name.h"
36 #include "dbus-service.h"
38 #include "bus-errors.h"
39 #include "exit-status.h"
41 #include "path-util.h"
45 #ifdef HAVE_SYSV_COMPAT
47 #define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
49 typedef enum RunlevelType {
58 const RunlevelType type;
60 /* Standard SysV runlevels for start-up */
61 { "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
62 { "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
63 { "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
64 { "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
65 { "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
68 /* SUSE style boot.d */
69 { "boot.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
72 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
73 /* Debian style rcS.d */
74 { "rcS.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
77 /* Standard SysV runlevels for shutdown */
78 { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
79 { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
81 /* Note that the order here matters, as we read the
82 directories in this order, and we want to make sure that
83 sysv_start_priority is known when we first load the
84 unit. And that value we only know from S links. Hence
85 UP/SYSINIT must be read before DOWN */
88 #define RUNLEVELS_UP "12345"
89 /* #define RUNLEVELS_DOWN "06" */
90 #define RUNLEVELS_BOOT "bBsS"
93 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
94 [SERVICE_DEAD] = UNIT_INACTIVE,
95 [SERVICE_START_PRE] = UNIT_ACTIVATING,
96 [SERVICE_START] = UNIT_ACTIVATING,
97 [SERVICE_START_POST] = UNIT_ACTIVATING,
98 [SERVICE_RUNNING] = UNIT_ACTIVE,
99 [SERVICE_EXITED] = UNIT_ACTIVE,
100 [SERVICE_RELOAD] = UNIT_RELOADING,
101 [SERVICE_STOP] = UNIT_DEACTIVATING,
102 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
103 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
104 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
105 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
106 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
107 [SERVICE_FAILED] = UNIT_FAILED,
108 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
111 static void service_init(Unit *u) {
112 Service *s = SERVICE(u);
116 assert(u->load_state == UNIT_STUB);
118 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
119 s->restart_usec = DEFAULT_RESTART_USEC;
120 s->type = _SERVICE_TYPE_INVALID;
122 s->watchdog_watch.type = WATCH_INVALID;
124 s->timer_watch.type = WATCH_INVALID;
125 #ifdef HAVE_SYSV_COMPAT
126 s->sysv_start_priority = -1;
127 s->sysv_start_priority_from_rcnd = -1;
130 s->guess_main_pid = true;
132 exec_context_init(&s->exec_context);
133 for (i = 0; i < RLIMIT_NLIMITS; i++)
134 if (UNIT(s)->manager->rlimit[i])
135 s->exec_context.rlimit[i] = newdup(struct rlimit, UNIT(s)->manager->rlimit[i], 1);
137 RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
139 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
142 static void service_unwatch_control_pid(Service *s) {
145 if (s->control_pid <= 0)
148 unit_unwatch_pid(UNIT(s), s->control_pid);
152 static void service_unwatch_main_pid(Service *s) {
155 if (s->main_pid <= 0)
158 unit_unwatch_pid(UNIT(s), s->main_pid);
162 static void service_unwatch_pid_file(Service *s) {
163 if (!s->pid_file_pathspec)
166 log_debug("Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
167 path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
168 path_spec_done(s->pid_file_pathspec);
169 free(s->pid_file_pathspec);
170 s->pid_file_pathspec = NULL;
173 static int service_set_main_pid(Service *s, pid_t pid) {
185 s->main_pid_known = true;
187 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
188 log_warning("%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
189 UNIT(s)->id, (unsigned long) pid);
191 s->main_pid_alien = true;
193 s->main_pid_alien = false;
195 exec_status_start(&s->main_exec_status, pid);
200 static void service_close_socket_fd(Service *s) {
203 if (s->socket_fd < 0)
206 close_nointr_nofail(s->socket_fd);
210 static void service_connection_unref(Service *s) {
213 if (!UNIT_DEREF(s->accept_socket))
216 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
217 unit_ref_unset(&s->accept_socket);
220 static void service_stop_watchdog(Service *s) {
223 unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
224 s->watchdog_timestamp.realtime = 0;
225 s->watchdog_timestamp.monotonic = 0;
228 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart);
230 static void service_handle_watchdog(Service *s) {
236 if (s->watchdog_usec == 0)
239 offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
240 if (offset >= s->watchdog_usec) {
241 log_error("%s watchdog timeout!", UNIT(s)->id);
242 service_enter_dead(s, SERVICE_FAILURE_WATCHDOG, true);
246 r = unit_watch_timer(UNIT(s), s->watchdog_usec - offset, &s->watchdog_watch);
248 log_warning("%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
251 static void service_reset_watchdog(Service *s) {
254 dual_timestamp_get(&s->watchdog_timestamp);
255 service_handle_watchdog(s);
258 static void service_done(Unit *u) {
259 Service *s = SERVICE(u);
266 #ifdef HAVE_SYSV_COMPAT
270 free(s->sysv_runlevels);
271 s->sysv_runlevels = NULL;
274 free(s->status_text);
275 s->status_text = NULL;
277 exec_context_done(&s->exec_context);
278 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
279 s->control_command = NULL;
280 s->main_command = NULL;
282 /* This will leak a process, but at least no memory or any of
284 service_unwatch_main_pid(s);
285 service_unwatch_control_pid(s);
286 service_unwatch_pid_file(s);
289 unit_unwatch_bus_name(u, s->bus_name);
294 service_close_socket_fd(s);
295 service_connection_unref(s);
297 unit_ref_unset(&s->accept_socket);
299 service_stop_watchdog(s);
301 unit_unwatch_timer(u, &s->timer_watch);
304 #ifdef HAVE_SYSV_COMPAT
305 static char *sysv_translate_name(const char *name) {
308 if (!(r = new(char, strlen(name) + sizeof(".service"))))
311 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
312 if (endswith(name, ".sh"))
313 /* Drop Debian-style .sh suffix */
314 strcpy(stpcpy(r, name) - 3, ".service");
317 if (startswith(name, "boot."))
318 /* Drop SuSE-style boot. prefix */
319 strcpy(stpcpy(r, name + 5), ".service");
321 #ifdef TARGET_FRUGALWARE
322 if (startswith(name, "rc."))
323 /* Drop Frugalware-style rc. prefix */
324 strcpy(stpcpy(r, name + 3), ".service");
327 /* Normal init scripts */
328 strcpy(stpcpy(r, name), ".service");
333 static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
335 /* We silently ignore the $ prefix here. According to the LSB
336 * spec it simply indicates whether something is a
337 * standardized name or a distribution-specific one. Since we
338 * just follow what already exists and do not introduce new
339 * uses or names we don't care who introduced a new name. */
341 static const char * const table[] = {
342 /* LSB defined facilities */
343 "local_fs", SPECIAL_LOCAL_FS_TARGET,
344 #if defined(TARGET_MANDRIVA) || defined(TARGET_MAGEIA)
346 /* Due to unfortunate name selection in Mandriva,
347 * $network is provided by network-up which is ordered
348 * after network which actually starts interfaces.
349 * To break the loop, just ignore it */
350 "network", SPECIAL_NETWORK_TARGET,
352 "named", SPECIAL_NSS_LOOKUP_TARGET,
353 "portmap", SPECIAL_RPCBIND_TARGET,
354 "remote_fs", SPECIAL_REMOTE_FS_TARGET,
355 "syslog", SPECIAL_SYSLOG_TARGET,
356 "time", SPECIAL_TIME_SYNC_TARGET,
358 /* common extensions */
359 "mail-transfer-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
360 "x-display-manager", SPECIAL_DISPLAY_MANAGER_SERVICE,
363 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
364 "mail-transport-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
368 "MTA", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
369 "smtpdaemon", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
370 "httpd", SPECIAL_HTTP_DAEMON_TARGET,
374 "smtp", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
385 n = *name == '$' ? name + 1 : name;
387 for (i = 0; i < ELEMENTSOF(table); i += 2) {
389 if (!streq(table[i], n))
395 if (!(r = strdup(table[i+1])))
401 /* If we don't know this name, fallback heuristics to figure
402 * out whether something is a target or a service alias. */
405 if (!unit_prefix_is_valid(n))
408 /* Facilities starting with $ are most likely targets */
409 r = unit_name_build(n, NULL, ".target");
410 } else if (filename && streq(name, filename))
411 /* Names equaling the file name of the services are redundant */
414 /* Everything else we assume to be normal service names */
415 r = sysv_translate_name(n);
426 static int sysv_fix_order(Service *s) {
432 if (s->sysv_start_priority < 0)
435 /* For each pair of services where at least one lacks a LSB
436 * header, we use the start priority value to order things. */
438 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
441 bool special_s, special_t;
448 if (UNIT(t)->load_state != UNIT_LOADED)
451 if (t->sysv_start_priority < 0)
454 /* If both units have modern headers we don't care
455 * about the priorities */
456 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
457 (UNIT(t)->fragment_path || t->sysv_has_lsb))
460 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
461 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
463 if (special_t && !special_s)
465 else if (special_s && !special_t)
467 else if (t->sysv_start_priority < s->sysv_start_priority)
469 else if (t->sysv_start_priority > s->sysv_start_priority)
474 /* FIXME: Maybe we should compare the name here lexicographically? */
476 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
483 static ExecCommand *exec_command_new(const char *path, const char *arg1) {
486 if (!(c = new0(ExecCommand, 1)))
489 if (!(c->path = strdup(path))) {
494 if (!(c->argv = strv_new(path, arg1, NULL))) {
503 static int sysv_exec_commands(Service *s) {
507 assert(s->sysv_path);
509 if (!(c = exec_command_new(s->sysv_path, "start")))
511 exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
513 if (!(c = exec_command_new(s->sysv_path, "stop")))
515 exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
517 if (!(c = exec_command_new(s->sysv_path, "reload")))
519 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
524 static int service_load_sysv_path(Service *s, const char *path) {
535 char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
543 if (!(f = fopen(path, "re"))) {
544 r = errno == ENOENT ? 0 : -errno;
549 if (fstat(fileno(f), &st) < 0) {
555 if (!(s->sysv_path = strdup(path))) {
560 s->sysv_mtime = timespec_load(&st.st_mtim);
562 if (null_or_empty(&st)) {
563 u->load_state = UNIT_MASKED;
569 char l[LINE_MAX], *t;
571 if (!fgets(l, sizeof(l), f)) {
576 log_error("Failed to read configuration file '%s': %s", path, strerror(-r));
586 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
588 s->sysv_has_lsb = true;
592 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
598 t += strspn(t, WHITESPACE);
600 if (state == NORMAL) {
602 /* Try to parse Red Hat style chkconfig headers */
604 if (startswith_no_case(t, "chkconfig:")) {
606 char runlevels[16], *k;
610 if (sscanf(t+10, "%15s %i %*i",
612 &start_priority) != 2) {
614 log_warning("[%s:%u] Failed to parse chkconfig line. Ignoring.", path, line);
618 /* A start priority gathered from the
619 * symlink farms is preferred over the
620 * data from the LSB header. */
621 if (start_priority < 0 || start_priority > 99)
622 log_warning("[%s:%u] Start priority out of range. Ignoring.", path, line);
624 s->sysv_start_priority = start_priority;
626 char_array_0(runlevels);
627 k = delete_chars(runlevels, WHITESPACE "-");
632 if (!(d = strdup(k))) {
637 free(s->sysv_runlevels);
638 s->sysv_runlevels = d;
641 } else if (startswith_no_case(t, "description:")) {
643 size_t k = strlen(t);
647 if (t[k-1] == '\\') {
652 if ((j = strstrip(t+12)) && *j) {
653 if (!(d = strdup(j))) {
660 free(chkconfig_description);
661 chkconfig_description = d;
663 } else if (startswith_no_case(t, "pidfile:")) {
670 if (!path_is_absolute(fn)) {
671 log_warning("[%s:%u] PID file not absolute. Ignoring.", path, line);
675 if (!(fn = strdup(fn))) {
684 } else if (state == DESCRIPTION) {
686 /* Try to parse Red Hat style description
689 size_t k = strlen(t);
697 if ((j = strstrip(t)) && *j) {
700 if (chkconfig_description)
701 d = join(chkconfig_description, " ", j, NULL);
710 free(chkconfig_description);
711 chkconfig_description = d;
714 } else if (state == LSB || state == LSB_DESCRIPTION) {
716 if (startswith_no_case(t, "Provides:")) {
722 FOREACH_WORD_QUOTED(w, z, t+9, i) {
725 if (!(n = strndup(w, z))) {
730 r = sysv_translate_facility(n, path_get_file_name(path), &m);
739 if (unit_name_to_type(m) == UNIT_SERVICE)
740 r = unit_add_name(u, m);
747 * indication that the
749 * now available. This
752 * targets do NOT pull
755 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
758 log_error("[%s:%u] Failed to add LSB Provides name %s, ignoring: %s", path, line, m, strerror(-r));
763 } else if (startswith_no_case(t, "Required-Start:") ||
764 startswith_no_case(t, "Should-Start:") ||
765 startswith_no_case(t, "X-Start-Before:") ||
766 startswith_no_case(t, "X-Start-After:")) {
772 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
775 if (!(n = strndup(w, z))) {
780 r = sysv_translate_facility(n, path_get_file_name(path), &m);
783 log_error("[%s:%u] Failed to translate LSB dependency %s, ignoring: %s", path, line, n, strerror(-r));
793 r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
796 log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", path, line, m, strerror(-r));
800 } else if (startswith_no_case(t, "Default-Start:")) {
805 k = delete_chars(t+14, WHITESPACE "-");
808 if (!(d = strdup(k))) {
813 free(s->sysv_runlevels);
814 s->sysv_runlevels = d;
817 } else if (startswith_no_case(t, "Description:")) {
820 state = LSB_DESCRIPTION;
822 if ((j = strstrip(t+12)) && *j) {
823 if (!(d = strdup(j))) {
830 free(long_description);
831 long_description = d;
833 } else if (startswith_no_case(t, "Short-Description:")) {
838 if ((j = strstrip(t+18)) && *j) {
839 if (!(d = strdup(j))) {
846 free(short_description);
847 short_description = d;
849 } else if (state == LSB_DESCRIPTION) {
851 if (startswith(l, "#\t") || startswith(l, "# ")) {
854 if ((j = strstrip(t)) && *j) {
857 if (long_description)
858 d = join(long_description, " ", t, NULL);
867 free(long_description);
868 long_description = d;
877 if ((r = sysv_exec_commands(s)) < 0)
879 if (s->sysv_runlevels &&
880 chars_intersect(RUNLEVELS_BOOT, s->sysv_runlevels) &&
881 chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
882 /* Service has both boot and "up" runlevels
883 configured. Kill the "up" ones. */
884 delete_chars(s->sysv_runlevels, RUNLEVELS_UP);
887 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
888 /* If there a runlevels configured for this service
889 * but none of the standard ones, then we assume this
890 * is some special kind of service (which might be
891 * needed for early boot) and don't create any links
894 UNIT(s)->default_dependencies = false;
896 /* Don't timeout special services during boot (like fsck) */
899 s->timeout_usec = DEFAULT_SYSV_TIMEOUT_USEC;
901 /* Special setting for all SysV services */
902 s->type = SERVICE_FORKING;
903 s->remain_after_exit = !s->pid_file;
904 s->guess_main_pid = false;
905 s->restart = SERVICE_RESTART_NO;
906 s->exec_context.ignore_sigpipe = false;
908 if (UNIT(s)->manager->sysv_console)
909 s->exec_context.std_output = EXEC_OUTPUT_JOURNAL_AND_CONSOLE;
911 s->exec_context.kill_mode = KILL_PROCESS;
913 /* We use the long description only if
914 * no short description is set. */
916 if (short_description)
917 description = short_description;
918 else if (chkconfig_description)
919 description = chkconfig_description;
920 else if (long_description)
921 description = long_description;
928 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
936 /* The priority that has been set in /etc/rcN.d/ hierarchies
937 * takes precedence over what is stored as default in the LSB
939 if (s->sysv_start_priority_from_rcnd >= 0)
940 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
942 u->load_state = UNIT_LOADED;
950 free(short_description);
951 free(long_description);
952 free(chkconfig_description);
957 static int service_load_sysv_name(Service *s, const char *name) {
963 /* For SysV services we strip the boot.*, rc.* and *.sh
964 * prefixes/suffixes. */
965 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
966 if (endswith(name, ".sh.service"))
971 if (startswith(name, "boot."))
975 #ifdef TARGET_FRUGALWARE
976 if (startswith(name, "rc."))
980 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
984 path = join(*p, "/", name, NULL);
988 assert(endswith(path, ".service"));
989 path[strlen(path)-8] = 0;
991 r = service_load_sysv_path(s, path);
993 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
994 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
995 /* Try Debian style *.sh source'able init scripts */
997 r = service_load_sysv_path(s, path);
1003 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1004 /* Try SUSE style boot.* init scripts */
1006 path = join(*p, "/boot.", name, NULL);
1010 /* Drop .service suffix */
1011 path[strlen(path)-8] = 0;
1012 r = service_load_sysv_path(s, path);
1017 #ifdef TARGET_FRUGALWARE
1018 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1019 /* Try Frugalware style rc.* init scripts */
1021 path = join(*p, "/rc.", name, NULL);
1025 /* Drop .service suffix */
1026 path[strlen(path)-8] = 0;
1027 r = service_load_sysv_path(s, path);
1035 if ((UNIT(s)->load_state != UNIT_STUB))
1042 static int service_load_sysv(Service *s) {
1049 /* Load service data from SysV init scripts, preferably with
1050 * LSB headers ... */
1052 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1055 if ((t = UNIT(s)->id))
1056 if ((r = service_load_sysv_name(s, t)) < 0)
1059 if (UNIT(s)->load_state == UNIT_STUB)
1060 SET_FOREACH(t, UNIT(s)->names, i) {
1061 if (t == UNIT(s)->id)
1064 if ((r = service_load_sysv_name(s, t)) < 0)
1067 if (UNIT(s)->load_state != UNIT_STUB)
1075 static int fsck_fix_order(Service *s) {
1081 if (s->fsck_passno <= 0)
1084 /* For each pair of services where both have an fsck priority
1085 * we order things based on it. */
1087 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
1096 if (UNIT(t)->load_state != UNIT_LOADED)
1099 if (t->fsck_passno <= 0)
1102 if (t->fsck_passno < s->fsck_passno)
1104 else if (t->fsck_passno > s->fsck_passno)
1109 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
1116 static int service_verify(Service *s) {
1119 if (UNIT(s)->load_state != UNIT_LOADED)
1122 if (!s->exec_command[SERVICE_EXEC_START]) {
1123 log_error("%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1127 if (s->type != SERVICE_ONESHOT &&
1128 s->exec_command[SERVICE_EXEC_START]->command_next) {
1129 log_error("%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1133 if (s->type == SERVICE_ONESHOT &&
1134 s->exec_command[SERVICE_EXEC_RELOAD]) {
1135 log_error("%s has an ExecReload setting, which is not allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1139 if (s->type == SERVICE_DBUS && !s->bus_name) {
1140 log_error("%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1144 if (s->bus_name && s->type != SERVICE_DBUS)
1145 log_warning("%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1147 if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
1148 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1155 static int service_add_default_dependencies(Service *s) {
1160 /* Add a number of automatic dependencies useful for the
1161 * majority of services. */
1163 /* First, pull in base system */
1164 if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
1166 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
1169 } else if (UNIT(s)->manager->running_as == MANAGER_USER) {
1171 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
1175 /* Second, activate normal shutdown */
1176 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
1179 static void service_fix_output(Service *s) {
1182 /* If nothing has been explicitly configured, patch default
1183 * output in. If input is socket/tty we avoid this however,
1184 * since in that case we want output to default to the same
1185 * place as we read input from. */
1187 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1188 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1189 s->exec_context.std_input == EXEC_INPUT_NULL)
1190 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1192 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1193 s->exec_context.std_input == EXEC_INPUT_NULL)
1194 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1197 static int service_load(Unit *u) {
1199 Service *s = SERVICE(u);
1203 /* Load a .service file */
1204 if ((r = unit_load_fragment(u)) < 0)
1207 #ifdef HAVE_SYSV_COMPAT
1208 /* Load a classic init script as a fallback, if we couldn't find anything */
1209 if (u->load_state == UNIT_STUB)
1210 if ((r = service_load_sysv(s)) < 0)
1214 /* Still nothing found? Then let's give up */
1215 if (u->load_state == UNIT_STUB)
1218 /* We were able to load something, then let's add in the
1219 * dropin directories. */
1220 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
1223 /* This is a new unit? Then let's add in some extras */
1224 if (u->load_state == UNIT_LOADED) {
1225 if (s->type == _SERVICE_TYPE_INVALID)
1226 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1228 service_fix_output(s);
1230 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
1233 if ((r = unit_add_default_cgroups(u)) < 0)
1236 #ifdef HAVE_SYSV_COMPAT
1237 if ((r = sysv_fix_order(s)) < 0)
1241 if ((r = fsck_fix_order(s)) < 0)
1245 if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1248 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1249 s->notify_access = NOTIFY_MAIN;
1251 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1252 s->notify_access = NOTIFY_MAIN;
1254 if (s->type == SERVICE_DBUS || s->bus_name)
1255 if ((r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true)) < 0)
1258 if (UNIT(s)->default_dependencies)
1259 if ((r = service_add_default_dependencies(s)) < 0)
1263 return service_verify(s);
1266 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1268 ServiceExecCommand c;
1269 Service *s = SERVICE(u);
1270 const char *prefix2;
1275 p2 = strappend(prefix, "\t");
1276 prefix2 = p2 ? p2 : prefix;
1279 "%sService State: %s\n"
1281 "%sReload Result: %s\n"
1282 "%sPermissionsStartOnly: %s\n"
1283 "%sRootDirectoryStartOnly: %s\n"
1284 "%sRemainAfterExit: %s\n"
1285 "%sGuessMainPID: %s\n"
1288 "%sNotifyAccess: %s\n",
1289 prefix, service_state_to_string(s->state),
1290 prefix, service_result_to_string(s->result),
1291 prefix, service_result_to_string(s->reload_result),
1292 prefix, yes_no(s->permissions_start_only),
1293 prefix, yes_no(s->root_directory_start_only),
1294 prefix, yes_no(s->remain_after_exit),
1295 prefix, yes_no(s->guess_main_pid),
1296 prefix, service_type_to_string(s->type),
1297 prefix, service_restart_to_string(s->restart),
1298 prefix, notify_access_to_string(s->notify_access));
1300 if (s->control_pid > 0)
1302 "%sControl PID: %lu\n",
1303 prefix, (unsigned long) s->control_pid);
1305 if (s->main_pid > 0)
1308 "%sMain PID Known: %s\n"
1309 "%sMain PID Alien: %s\n",
1310 prefix, (unsigned long) s->main_pid,
1311 prefix, yes_no(s->main_pid_known),
1312 prefix, yes_no(s->main_pid_alien));
1317 prefix, s->pid_file);
1322 "%sBus Name Good: %s\n",
1323 prefix, s->bus_name,
1324 prefix, yes_no(s->bus_name_good));
1326 exec_context_dump(&s->exec_context, f, prefix);
1328 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1330 if (!s->exec_command[c])
1333 fprintf(f, "%s-> %s:\n",
1334 prefix, service_exec_command_to_string(c));
1336 exec_command_dump_list(s->exec_command[c], f, prefix2);
1339 #ifdef HAVE_SYSV_COMPAT
1342 "%sSysV Init Script Path: %s\n"
1343 "%sSysV Init Script has LSB Header: %s\n"
1344 "%sSysVEnabled: %s\n",
1345 prefix, s->sysv_path,
1346 prefix, yes_no(s->sysv_has_lsb),
1347 prefix, yes_no(s->sysv_enabled));
1349 if (s->sysv_start_priority >= 0)
1351 "%sSysVStartPriority: %i\n",
1352 prefix, s->sysv_start_priority);
1354 if (s->sysv_runlevels)
1355 fprintf(f, "%sSysVRunLevels: %s\n",
1356 prefix, s->sysv_runlevels);
1359 if (s->fsck_passno > 0)
1361 "%sFsckPassNo: %i\n",
1362 prefix, s->fsck_passno);
1365 fprintf(f, "%sStatus Text: %s\n",
1366 prefix, s->status_text);
1371 static int service_load_pid_file(Service *s, bool may_warn) {
1381 if ((r = read_one_line_file(s->pid_file, &k)) < 0) {
1383 log_info("PID file %s not readable (yet?) after %s.",
1384 s->pid_file, service_state_to_string(s->state));
1388 r = parse_pid(k, &pid);
1394 if (kill(pid, 0) < 0 && errno != EPERM) {
1396 log_info("PID %lu read from file %s does not exist.",
1397 (unsigned long) pid, s->pid_file);
1401 if (s->main_pid_known) {
1402 if (pid == s->main_pid)
1405 log_debug("Main PID changing: %lu -> %lu",
1406 (unsigned long) s->main_pid, (unsigned long) pid);
1407 service_unwatch_main_pid(s);
1408 s->main_pid_known = false;
1410 log_debug("Main PID loaded: %lu", (unsigned long) pid);
1412 if ((r = service_set_main_pid(s, pid)) < 0)
1415 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1416 /* FIXME: we need to do something here */
1422 static int service_search_main_pid(Service *s) {
1428 /* If we know it anyway, don't ever fallback to unreliable
1430 if (s->main_pid_known)
1433 if (!s->guess_main_pid)
1436 assert(s->main_pid <= 0);
1438 if ((pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings)) <= 0)
1441 log_debug("Main PID guessed: %lu", (unsigned long) pid);
1442 if ((r = service_set_main_pid(s, pid)) < 0)
1445 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1446 /* FIXME: we need to do something here */
1452 static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1458 /* Notifies all our sockets when we die */
1460 if (s->socket_fd >= 0)
1463 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1464 if (u->type == UNIT_SOCKET)
1465 socket_notify_service_dead(SOCKET(u), failed_permanent);
1470 static void service_set_state(Service *s, ServiceState state) {
1471 ServiceState old_state;
1474 old_state = s->state;
1477 service_unwatch_pid_file(s);
1479 if (state != SERVICE_START_PRE &&
1480 state != SERVICE_START &&
1481 state != SERVICE_START_POST &&
1482 state != SERVICE_RELOAD &&
1483 state != SERVICE_STOP &&
1484 state != SERVICE_STOP_SIGTERM &&
1485 state != SERVICE_STOP_SIGKILL &&
1486 state != SERVICE_STOP_POST &&
1487 state != SERVICE_FINAL_SIGTERM &&
1488 state != SERVICE_FINAL_SIGKILL &&
1489 state != SERVICE_AUTO_RESTART)
1490 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1492 if (state != SERVICE_START &&
1493 state != SERVICE_START_POST &&
1494 state != SERVICE_RUNNING &&
1495 state != SERVICE_RELOAD &&
1496 state != SERVICE_STOP &&
1497 state != SERVICE_STOP_SIGTERM &&
1498 state != SERVICE_STOP_SIGKILL) {
1499 service_unwatch_main_pid(s);
1500 s->main_command = NULL;
1503 if (state != SERVICE_START_PRE &&
1504 state != SERVICE_START &&
1505 state != SERVICE_START_POST &&
1506 state != SERVICE_RELOAD &&
1507 state != SERVICE_STOP &&
1508 state != SERVICE_STOP_SIGTERM &&
1509 state != SERVICE_STOP_SIGKILL &&
1510 state != SERVICE_STOP_POST &&
1511 state != SERVICE_FINAL_SIGTERM &&
1512 state != SERVICE_FINAL_SIGKILL) {
1513 service_unwatch_control_pid(s);
1514 s->control_command = NULL;
1515 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1518 if (state == SERVICE_DEAD ||
1519 state == SERVICE_STOP ||
1520 state == SERVICE_STOP_SIGTERM ||
1521 state == SERVICE_STOP_SIGKILL ||
1522 state == SERVICE_STOP_POST ||
1523 state == SERVICE_FINAL_SIGTERM ||
1524 state == SERVICE_FINAL_SIGKILL ||
1525 state == SERVICE_FAILED ||
1526 state == SERVICE_AUTO_RESTART)
1527 service_notify_sockets_dead(s, false);
1529 if (state != SERVICE_START_PRE &&
1530 state != SERVICE_START &&
1531 state != SERVICE_START_POST &&
1532 state != SERVICE_RUNNING &&
1533 state != SERVICE_RELOAD &&
1534 state != SERVICE_STOP &&
1535 state != SERVICE_STOP_SIGTERM &&
1536 state != SERVICE_STOP_SIGKILL &&
1537 state != SERVICE_STOP_POST &&
1538 state != SERVICE_FINAL_SIGTERM &&
1539 state != SERVICE_FINAL_SIGKILL &&
1540 !(state == SERVICE_DEAD && UNIT(s)->job)) {
1541 service_close_socket_fd(s);
1542 service_connection_unref(s);
1545 if (state == SERVICE_STOP)
1546 service_stop_watchdog(s);
1548 /* For the inactive states unit_notify() will trim the cgroup,
1549 * but for exit we have to do that ourselves... */
1550 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1551 cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
1553 if (old_state != state)
1554 log_debug("%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1556 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], s->reload_result == SERVICE_SUCCESS);
1557 s->reload_result = SERVICE_SUCCESS;
1560 static int service_coldplug(Unit *u) {
1561 Service *s = SERVICE(u);
1565 assert(s->state == SERVICE_DEAD);
1567 if (s->deserialized_state != s->state) {
1569 if (s->deserialized_state == SERVICE_START_PRE ||
1570 s->deserialized_state == SERVICE_START ||
1571 s->deserialized_state == SERVICE_START_POST ||
1572 s->deserialized_state == SERVICE_RELOAD ||
1573 s->deserialized_state == SERVICE_STOP ||
1574 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1575 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1576 s->deserialized_state == SERVICE_STOP_POST ||
1577 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1578 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1579 s->deserialized_state == SERVICE_AUTO_RESTART) {
1581 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_usec > 0) {
1584 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_usec;
1586 if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0)
1591 if ((s->deserialized_state == SERVICE_START &&
1592 (s->type == SERVICE_FORKING ||
1593 s->type == SERVICE_DBUS ||
1594 s->type == SERVICE_ONESHOT ||
1595 s->type == SERVICE_NOTIFY)) ||
1596 s->deserialized_state == SERVICE_START_POST ||
1597 s->deserialized_state == SERVICE_RUNNING ||
1598 s->deserialized_state == SERVICE_RELOAD ||
1599 s->deserialized_state == SERVICE_STOP ||
1600 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1601 s->deserialized_state == SERVICE_STOP_SIGKILL)
1602 if (s->main_pid > 0)
1603 if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0)
1606 if (s->deserialized_state == SERVICE_START_PRE ||
1607 s->deserialized_state == SERVICE_START ||
1608 s->deserialized_state == SERVICE_START_POST ||
1609 s->deserialized_state == SERVICE_RELOAD ||
1610 s->deserialized_state == SERVICE_STOP ||
1611 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1612 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1613 s->deserialized_state == SERVICE_STOP_POST ||
1614 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1615 s->deserialized_state == SERVICE_FINAL_SIGKILL)
1616 if (s->control_pid > 0)
1617 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1620 if (s->deserialized_state == SERVICE_START_POST ||
1621 s->deserialized_state == SERVICE_RUNNING)
1622 service_handle_watchdog(s);
1624 service_set_state(s, s->deserialized_state);
1629 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1633 unsigned rn_fds = 0;
1640 if (s->socket_fd >= 0)
1643 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1648 if (u->type != UNIT_SOCKET)
1653 if ((r = socket_collect_fds(sock, &cfds, &cn_fds)) < 0)
1665 if (!(t = new(int, rn_fds+cn_fds))) {
1671 memcpy(t, rfds, rn_fds * sizeof(int));
1672 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1677 rn_fds = rn_fds+cn_fds;
1692 static int service_spawn(
1697 bool apply_permissions,
1699 bool apply_tty_stdin,
1700 bool set_notify_socket,
1706 int *fds = NULL, *fdsbuf = NULL;
1707 unsigned n_fds = 0, n_env = 0;
1708 char **argv = NULL, **final_env = NULL, **our_env = NULL;
1715 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1716 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1717 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1719 if (s->socket_fd >= 0) {
1720 fds = &s->socket_fd;
1723 if ((r = service_collect_fds(s, &fdsbuf, &n_fds)) < 0)
1730 if (timeout && s->timeout_usec) {
1731 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1734 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1736 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1741 if (!(our_env = new0(char*, 4))) {
1746 if (set_notify_socket)
1747 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1752 if (s->main_pid > 0)
1753 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1758 if (s->watchdog_usec > 0)
1759 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1764 if (!(final_env = strv_env_merge(2,
1765 UNIT(s)->manager->environment,
1780 UNIT(s)->manager->confirm_spawn,
1781 UNIT(s)->cgroup_bondings,
1782 UNIT(s)->cgroup_attributes,
1783 is_control ? "control" : NULL,
1784 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1791 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1792 /* FIXME: we need to do something here */
1798 strv_free(final_env);
1808 strv_free(final_env);
1811 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1816 static int main_pid_good(Service *s) {
1819 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1822 /* If we know the pid file, then lets just check if it is
1824 if (s->main_pid_known) {
1826 /* If it's an alien child let's check if it is still
1828 if (s->main_pid_alien)
1829 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1831 /* .. otherwise assume we'll get a SIGCHLD for it,
1832 * which we really should wait for to collect exit
1833 * status and code */
1834 return s->main_pid > 0;
1837 /* We don't know the pid */
1841 static int control_pid_good(Service *s) {
1844 return s->control_pid > 0;
1847 static int cgroup_good(Service *s) {
1852 if ((r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings)) < 0)
1858 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1862 if (f != SERVICE_SUCCESS)
1865 if (allow_restart &&
1866 !s->forbid_restart &&
1867 (s->restart == SERVICE_RESTART_ALWAYS ||
1868 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1869 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1870 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1871 s->result == SERVICE_FAILURE_CORE_DUMP)))) {
1873 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
1877 service_set_state(s, SERVICE_AUTO_RESTART);
1879 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1881 s->forbid_restart = false;
1886 log_warning("%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1887 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1890 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
1892 static void service_enter_stop_post(Service *s, ServiceResult f) {
1896 if (f != SERVICE_SUCCESS)
1899 service_unwatch_control_pid(s);
1901 if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
1902 s->control_command_id = SERVICE_EXEC_STOP_POST;
1904 r = service_spawn(s,
1908 !s->permissions_start_only,
1909 !s->root_directory_start_only,
1918 service_set_state(s, SERVICE_STOP_POST);
1920 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1925 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1926 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1929 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1931 Set *pid_set = NULL;
1932 bool wait_for_exit = false;
1936 if (f != SERVICE_SUCCESS)
1939 if (s->exec_context.kill_mode != KILL_NONE) {
1940 int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1942 if (s->main_pid > 0) {
1943 if (kill_and_sigcont(s->main_pid, sig) < 0 && errno != ESRCH)
1944 log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
1946 wait_for_exit = !s->main_pid_alien;
1949 if (s->control_pid > 0) {
1950 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1951 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1953 wait_for_exit = true;
1956 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1958 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1963 /* Exclude the main/control pids from being killed via the cgroup */
1964 if (s->main_pid > 0)
1965 if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
1968 if (s->control_pid > 0)
1969 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1972 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1974 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1975 log_warning("Failed to kill control group: %s", strerror(-r));
1977 wait_for_exit = true;
1984 if (wait_for_exit) {
1985 if (s->timeout_usec > 0)
1986 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1989 service_set_state(s, state);
1990 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1991 service_enter_stop_post(s, SERVICE_SUCCESS);
1993 service_enter_dead(s, SERVICE_SUCCESS, true);
1998 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
2000 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2001 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
2003 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2009 static void service_enter_stop(Service *s, ServiceResult f) {
2014 if (f != SERVICE_SUCCESS)
2017 service_unwatch_control_pid(s);
2019 if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
2020 s->control_command_id = SERVICE_EXEC_STOP;
2022 r = service_spawn(s,
2026 !s->permissions_start_only,
2027 !s->root_directory_start_only,
2035 service_set_state(s, SERVICE_STOP);
2037 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2042 log_warning("%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2043 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2046 static void service_enter_running(Service *s, ServiceResult f) {
2047 int main_pid_ok, cgroup_ok;
2050 if (f != SERVICE_SUCCESS)
2053 main_pid_ok = main_pid_good(s);
2054 cgroup_ok = cgroup_good(s);
2056 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2057 (s->bus_name_good || s->type != SERVICE_DBUS))
2058 service_set_state(s, SERVICE_RUNNING);
2059 else if (s->remain_after_exit)
2060 service_set_state(s, SERVICE_EXITED);
2062 service_enter_stop(s, SERVICE_SUCCESS);
2065 static void service_enter_start_post(Service *s) {
2069 service_unwatch_control_pid(s);
2071 if (s->watchdog_usec > 0)
2072 service_reset_watchdog(s);
2074 if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
2075 s->control_command_id = SERVICE_EXEC_START_POST;
2077 r = service_spawn(s,
2081 !s->permissions_start_only,
2082 !s->root_directory_start_only,
2090 service_set_state(s, SERVICE_START_POST);
2092 service_enter_running(s, SERVICE_SUCCESS);
2097 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2098 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2101 static void service_enter_start(Service *s) {
2108 assert(s->exec_command[SERVICE_EXEC_START]);
2109 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2111 if (s->type == SERVICE_FORKING)
2112 service_unwatch_control_pid(s);
2114 service_unwatch_main_pid(s);
2116 /* We want to ensure that nobody leaks processes from
2117 * START_PRE here, so let's go on a killing spree, People
2118 * should not spawn long running processes from START_PRE. */
2119 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2121 if (s->type == SERVICE_FORKING) {
2122 s->control_command_id = SERVICE_EXEC_START;
2123 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2125 s->main_command = NULL;
2127 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2128 s->control_command = NULL;
2130 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2133 r = service_spawn(s,
2135 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY,
2140 s->notify_access != NOTIFY_NONE,
2146 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2147 /* For simple services we immediately start
2148 * the START_POST binaries. */
2150 service_set_main_pid(s, pid);
2151 service_enter_start_post(s);
2153 } else if (s->type == SERVICE_FORKING) {
2155 /* For forking services we wait until the start
2156 * process exited. */
2158 s->control_pid = pid;
2159 service_set_state(s, SERVICE_START);
2161 } else if (s->type == SERVICE_ONESHOT ||
2162 s->type == SERVICE_DBUS ||
2163 s->type == SERVICE_NOTIFY) {
2165 /* For oneshot services we wait until the start
2166 * process exited, too, but it is our main process. */
2168 /* For D-Bus services we know the main pid right away,
2169 * but wait for the bus name to appear on the
2170 * bus. Notify services are similar. */
2172 service_set_main_pid(s, pid);
2173 service_set_state(s, SERVICE_START);
2175 assert_not_reached("Unknown service type");
2180 log_warning("%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2181 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2184 static void service_enter_start_pre(Service *s) {
2189 service_unwatch_control_pid(s);
2191 if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
2193 /* Before we start anything, let's clear up what might
2194 * be left from previous runs. */
2195 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2197 s->control_command_id = SERVICE_EXEC_START_PRE;
2199 r = service_spawn(s,
2203 !s->permissions_start_only,
2204 !s->root_directory_start_only,
2212 service_set_state(s, SERVICE_START_PRE);
2214 service_enter_start(s);
2219 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2220 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2223 static void service_enter_restart(Service *s) {
2228 dbus_error_init(&error);
2231 log_info("Job pending for unit, delaying automatic restart.");
2233 if ((r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch)) < 0)
2239 /* Any units that are bound to this service must also be
2240 * restarted. We use JOB_RESTART (instead of the more obvious
2241 * JOB_START) here so that those dependency jobs will be added
2243 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2247 log_debug("%s scheduled restart job.", UNIT(s)->id);
2251 log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2252 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2254 dbus_error_free(&error);
2257 static void service_enter_reload(Service *s) {
2262 service_unwatch_control_pid(s);
2264 if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2265 s->control_command_id = SERVICE_EXEC_RELOAD;
2267 r = service_spawn(s,
2271 !s->permissions_start_only,
2272 !s->root_directory_start_only,
2280 service_set_state(s, SERVICE_RELOAD);
2282 service_enter_running(s, SERVICE_SUCCESS);
2287 log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2288 s->reload_result = SERVICE_FAILURE_RESOURCES;
2289 service_enter_running(s, SERVICE_SUCCESS);
2292 static void service_run_next_control(Service *s) {
2296 assert(s->control_command);
2297 assert(s->control_command->command_next);
2299 assert(s->control_command_id != SERVICE_EXEC_START);
2301 s->control_command = s->control_command->command_next;
2302 service_unwatch_control_pid(s);
2304 r = service_spawn(s,
2308 !s->permissions_start_only,
2309 !s->root_directory_start_only,
2310 s->control_command_id == SERVICE_EXEC_START_PRE ||
2311 s->control_command_id == SERVICE_EXEC_STOP_POST,
2321 log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2323 if (s->state == SERVICE_START_PRE)
2324 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2325 else if (s->state == SERVICE_STOP)
2326 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2327 else if (s->state == SERVICE_STOP_POST)
2328 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2329 else if (s->state == SERVICE_RELOAD) {
2330 s->reload_result = SERVICE_FAILURE_RESOURCES;
2331 service_enter_running(s, SERVICE_SUCCESS);
2333 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2336 static void service_run_next_main(Service *s) {
2341 assert(s->main_command);
2342 assert(s->main_command->command_next);
2343 assert(s->type == SERVICE_ONESHOT);
2345 s->main_command = s->main_command->command_next;
2346 service_unwatch_main_pid(s);
2348 r = service_spawn(s,
2355 s->notify_access != NOTIFY_NONE,
2361 service_set_main_pid(s, pid);
2366 log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2367 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2370 static int service_start_limit_test(Service *s) {
2373 if (ratelimit_test(&s->start_limit))
2376 switch (s->start_limit_action) {
2378 case SERVICE_START_LIMIT_NONE:
2379 log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2382 case SERVICE_START_LIMIT_REBOOT: {
2386 dbus_error_init(&error);
2388 log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2390 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2392 log_error("Failed to reboot: %s.", bus_error(&error, r));
2393 dbus_error_free(&error);
2399 case SERVICE_START_LIMIT_REBOOT_FORCE:
2400 log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2401 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2404 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2405 log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2406 reboot(RB_AUTOBOOT);
2410 log_error("start limit action=%i", s->start_limit_action);
2411 assert_not_reached("Unknown StartLimitAction.");
2417 static int service_start(Unit *u) {
2418 Service *s = SERVICE(u);
2423 /* We cannot fulfill this request right now, try again later
2425 if (s->state == SERVICE_STOP ||
2426 s->state == SERVICE_STOP_SIGTERM ||
2427 s->state == SERVICE_STOP_SIGKILL ||
2428 s->state == SERVICE_STOP_POST ||
2429 s->state == SERVICE_FINAL_SIGTERM ||
2430 s->state == SERVICE_FINAL_SIGKILL)
2433 /* Already on it! */
2434 if (s->state == SERVICE_START_PRE ||
2435 s->state == SERVICE_START ||
2436 s->state == SERVICE_START_POST)
2439 /* A service that will be restarted must be stopped first to
2440 * trigger BindTo and/or OnFailure dependencies. If a user
2441 * does not want to wait for the holdoff time to elapse, the
2442 * service should be manually restarted, not started. */
2443 if (s->state == SERVICE_AUTO_RESTART) {
2444 log_warning("%s automatic restart is pending, must be stopped before issuing start request.", UNIT(s)->id);
2448 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2450 /* Make sure we don't enter a busy loop of some kind. */
2451 r = service_start_limit_test(s);
2453 service_notify_sockets_dead(s, true);
2457 s->result = SERVICE_SUCCESS;
2458 s->reload_result = SERVICE_SUCCESS;
2459 s->main_pid_known = false;
2460 s->main_pid_alien = false;
2461 s->forbid_restart = false;
2463 service_enter_start_pre(s);
2467 static int service_stop(Unit *u) {
2468 Service *s = SERVICE(u);
2472 /* Don't create restart jobs from here. */
2473 s->forbid_restart = true;
2476 if (s->state == SERVICE_STOP ||
2477 s->state == SERVICE_STOP_SIGTERM ||
2478 s->state == SERVICE_STOP_SIGKILL ||
2479 s->state == SERVICE_STOP_POST ||
2480 s->state == SERVICE_FINAL_SIGTERM ||
2481 s->state == SERVICE_FINAL_SIGKILL)
2484 /* A restart will be scheduled or is in progress. */
2485 if (s->state == SERVICE_AUTO_RESTART) {
2486 service_enter_dead(s, SERVICE_SUCCESS, false);
2490 /* If there's already something running we go directly into
2492 if (s->state == SERVICE_START_PRE ||
2493 s->state == SERVICE_START ||
2494 s->state == SERVICE_START_POST ||
2495 s->state == SERVICE_RELOAD) {
2496 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2500 assert(s->state == SERVICE_RUNNING ||
2501 s->state == SERVICE_EXITED);
2503 service_enter_stop(s, SERVICE_SUCCESS);
2507 static int service_reload(Unit *u) {
2508 Service *s = SERVICE(u);
2512 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2514 service_enter_reload(s);
2518 static bool service_can_reload(Unit *u) {
2519 Service *s = SERVICE(u);
2523 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2526 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2527 Service *s = SERVICE(u);
2533 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2534 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2535 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2537 if (s->control_pid > 0)
2538 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2540 if (s->main_pid_known && s->main_pid > 0)
2541 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2543 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2546 unit_serialize_item(u, f, "status-text", s->status_text);
2548 /* FIXME: There's a minor uncleanliness here: if there are
2549 * multiple commands attached here, we will start from the
2550 * first one again */
2551 if (s->control_command_id >= 0)
2552 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2554 if (s->socket_fd >= 0) {
2557 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2560 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2563 if (s->main_exec_status.pid > 0) {
2564 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2565 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2566 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2568 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2569 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2570 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2573 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2574 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2579 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2580 Service *s = SERVICE(u);
2587 if (streq(key, "state")) {
2590 if ((state = service_state_from_string(value)) < 0)
2591 log_debug("Failed to parse state value %s", value);
2593 s->deserialized_state = state;
2594 } else if (streq(key, "result")) {
2597 f = service_result_from_string(value);
2599 log_debug("Failed to parse result value %s", value);
2600 else if (f != SERVICE_SUCCESS)
2603 } else if (streq(key, "reload-result")) {
2606 f = service_result_from_string(value);
2608 log_debug("Failed to parse reload result value %s", value);
2609 else if (f != SERVICE_SUCCESS)
2610 s->reload_result = f;
2612 } else if (streq(key, "control-pid")) {
2615 if (parse_pid(value, &pid) < 0)
2616 log_debug("Failed to parse control-pid value %s", value);
2618 s->control_pid = pid;
2619 } else if (streq(key, "main-pid")) {
2622 if (parse_pid(value, &pid) < 0)
2623 log_debug("Failed to parse main-pid value %s", value);
2625 service_set_main_pid(s, (pid_t) pid);
2626 } else if (streq(key, "main-pid-known")) {
2629 if ((b = parse_boolean(value)) < 0)
2630 log_debug("Failed to parse main-pid-known value %s", value);
2632 s->main_pid_known = b;
2633 } else if (streq(key, "status-text")) {
2636 if ((t = strdup(value))) {
2637 free(s->status_text);
2641 } else if (streq(key, "control-command")) {
2642 ServiceExecCommand id;
2644 if ((id = service_exec_command_from_string(value)) < 0)
2645 log_debug("Failed to parse exec-command value %s", value);
2647 s->control_command_id = id;
2648 s->control_command = s->exec_command[id];
2650 } else if (streq(key, "socket-fd")) {
2653 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2654 log_debug("Failed to parse socket-fd value %s", value);
2657 if (s->socket_fd >= 0)
2658 close_nointr_nofail(s->socket_fd);
2659 s->socket_fd = fdset_remove(fds, fd);
2661 } else if (streq(key, "main-exec-status-pid")) {
2664 if (parse_pid(value, &pid) < 0)
2665 log_debug("Failed to parse main-exec-status-pid value %s", value);
2667 s->main_exec_status.pid = pid;
2668 } else if (streq(key, "main-exec-status-code")) {
2671 if (safe_atoi(value, &i) < 0)
2672 log_debug("Failed to parse main-exec-status-code value %s", value);
2674 s->main_exec_status.code = i;
2675 } else if (streq(key, "main-exec-status-status")) {
2678 if (safe_atoi(value, &i) < 0)
2679 log_debug("Failed to parse main-exec-status-status value %s", value);
2681 s->main_exec_status.status = i;
2682 } else if (streq(key, "main-exec-status-start"))
2683 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2684 else if (streq(key, "main-exec-status-exit"))
2685 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2686 else if (streq(key, "watchdog-timestamp"))
2687 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2689 log_debug("Unknown serialization key '%s'", key);
2694 static UnitActiveState service_active_state(Unit *u) {
2697 return state_translation_table[SERVICE(u)->state];
2700 static const char *service_sub_state_to_string(Unit *u) {
2703 return service_state_to_string(SERVICE(u)->state);
2706 static bool service_check_gc(Unit *u) {
2707 Service *s = SERVICE(u);
2711 /* Never clean up services that still have a process around,
2712 * even if the service is formally dead. */
2713 if (cgroup_good(s) > 0 ||
2714 main_pid_good(s) > 0 ||
2715 control_pid_good(s) > 0)
2718 #ifdef HAVE_SYSV_COMPAT
2726 static bool service_check_snapshot(Unit *u) {
2727 Service *s = SERVICE(u);
2731 return !s->got_socket_fd;
2734 static int service_retry_pid_file(Service *s) {
2737 assert(s->pid_file);
2738 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2740 r = service_load_pid_file(s, false);
2744 service_unwatch_pid_file(s);
2746 service_enter_running(s, SERVICE_SUCCESS);
2750 static int service_watch_pid_file(Service *s) {
2753 log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2754 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2758 /* the pidfile might have appeared just before we set the watch */
2759 service_retry_pid_file(s);
2763 log_error("Failed to set a watch for %s's PID file %s: %s",
2764 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2765 service_unwatch_pid_file(s);
2769 static int service_demand_pid_file(Service *s) {
2772 assert(s->pid_file);
2773 assert(!s->pid_file_pathspec);
2775 ps = new0(PathSpec, 1);
2779 ps->path = strdup(s->pid_file);
2785 path_kill_slashes(ps->path);
2787 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2788 * keep their PID file open all the time. */
2789 ps->type = PATH_MODIFIED;
2790 ps->inotify_fd = -1;
2792 s->pid_file_pathspec = ps;
2794 return service_watch_pid_file(s);
2797 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2798 Service *s = SERVICE(u);
2802 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2803 assert(s->pid_file_pathspec);
2804 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2806 log_debug("inotify event for %s", u->id);
2808 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2811 if (service_retry_pid_file(s) == 0)
2814 if (service_watch_pid_file(s) < 0)
2819 service_unwatch_pid_file(s);
2820 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2823 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2824 Service *s = SERVICE(u);
2830 if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2831 f = SERVICE_SUCCESS;
2832 else if (code == CLD_EXITED)
2833 f = SERVICE_FAILURE_EXIT_CODE;
2834 else if (code == CLD_KILLED)
2835 f = SERVICE_FAILURE_SIGNAL;
2836 else if (code == CLD_DUMPED)
2837 f = SERVICE_FAILURE_CORE_DUMP;
2839 assert_not_reached("Unknown code");
2841 if (s->main_pid == pid) {
2842 /* Forking services may occasionally move to a new PID.
2843 * As long as they update the PID file before exiting the old
2844 * PID, they're fine. */
2845 if (service_load_pid_file(s, false) == 0)
2849 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2851 /* If this is not a forking service than the main
2852 * process got started and hence we copy the exit
2853 * status so that it is recorded both as main and as
2854 * control process exit status */
2855 if (s->main_command) {
2856 s->main_command->exec_status = s->main_exec_status;
2858 if (s->main_command->ignore)
2859 f = SERVICE_SUCCESS;
2862 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2863 "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2865 if (f != SERVICE_SUCCESS)
2868 if (s->main_command &&
2869 s->main_command->command_next &&
2870 f == SERVICE_SUCCESS) {
2872 /* There is another command to *
2873 * execute, so let's do that. */
2875 log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2876 service_run_next_main(s);
2880 /* The service exited, so the service is officially
2882 s->main_command = NULL;
2886 case SERVICE_START_POST:
2887 case SERVICE_RELOAD:
2889 /* Need to wait until the operation is
2894 if (s->type == SERVICE_ONESHOT) {
2895 /* This was our main goal, so let's go on */
2896 if (f == SERVICE_SUCCESS)
2897 service_enter_start_post(s);
2899 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2902 assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2907 case SERVICE_RUNNING:
2908 service_enter_running(s, f);
2911 case SERVICE_STOP_SIGTERM:
2912 case SERVICE_STOP_SIGKILL:
2914 if (!control_pid_good(s))
2915 service_enter_stop_post(s, f);
2917 /* If there is still a control process, wait for that first */
2921 assert_not_reached("Uh, main process died at wrong time.");
2925 } else if (s->control_pid == pid) {
2929 if (s->control_command) {
2930 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2932 if (s->control_command->ignore)
2933 f = SERVICE_SUCCESS;
2936 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2937 "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2939 if (f != SERVICE_SUCCESS)
2942 /* Immediately get rid of the cgroup, so that the
2943 * kernel doesn't delay the cgroup empty messages for
2944 * the service cgroup any longer than necessary */
2945 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2947 if (s->control_command &&
2948 s->control_command->command_next &&
2949 f == SERVICE_SUCCESS) {
2951 /* There is another command to *
2952 * execute, so let's do that. */
2954 log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2955 service_run_next_control(s);
2958 /* No further commands for this step, so let's
2959 * figure out what to do next */
2961 s->control_command = NULL;
2962 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2964 log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2968 case SERVICE_START_PRE:
2969 if (f == SERVICE_SUCCESS)
2970 service_enter_start(s);
2972 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2976 assert(s->type == SERVICE_FORKING);
2978 if (f != SERVICE_SUCCESS) {
2979 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2984 bool has_start_post;
2987 /* Let's try to load the pid file here if we can.
2988 * The PID file might actually be created by a START_POST
2989 * script. In that case don't worry if the loading fails. */
2991 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2992 r = service_load_pid_file(s, !has_start_post);
2993 if (!has_start_post && r < 0) {
2994 r = service_demand_pid_file(s);
2995 if (r < 0 || !cgroup_good(s))
2996 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3000 service_search_main_pid(s);
3002 service_enter_start_post(s);
3005 case SERVICE_START_POST:
3006 if (f != SERVICE_SUCCESS) {
3007 service_enter_stop(s, f);
3014 r = service_load_pid_file(s, true);
3016 r = service_demand_pid_file(s);
3017 if (r < 0 || !cgroup_good(s))
3018 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3022 service_search_main_pid(s);
3024 service_enter_running(s, SERVICE_SUCCESS);
3027 case SERVICE_RELOAD:
3028 if (f == SERVICE_SUCCESS) {
3029 service_load_pid_file(s, true);
3030 service_search_main_pid(s);
3033 s->reload_result = f;
3034 service_enter_running(s, SERVICE_SUCCESS);
3038 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3041 case SERVICE_STOP_SIGTERM:
3042 case SERVICE_STOP_SIGKILL:
3043 if (main_pid_good(s) <= 0)
3044 service_enter_stop_post(s, f);
3046 /* If there is still a service
3047 * process around, wait until
3048 * that one quit, too */
3051 case SERVICE_STOP_POST:
3052 case SERVICE_FINAL_SIGTERM:
3053 case SERVICE_FINAL_SIGKILL:
3054 service_enter_dead(s, f, true);
3058 assert_not_reached("Uh, control process died at wrong time.");
3063 /* Notify clients about changed exit status */
3064 unit_add_to_dbus_queue(u);
3067 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3068 Service *s = SERVICE(u);
3071 assert(elapsed == 1);
3073 if (w == &s->watchdog_watch) {
3074 service_handle_watchdog(s);
3078 assert(w == &s->timer_watch);
3082 case SERVICE_START_PRE:
3084 log_warning("%s operation timed out. Terminating.", u->id);
3085 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3088 case SERVICE_START_POST:
3089 log_warning("%s operation timed out. Stopping.", u->id);
3090 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3093 case SERVICE_RELOAD:
3094 log_warning("%s operation timed out. Stopping.", u->id);
3095 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3096 service_enter_running(s, SERVICE_SUCCESS);
3100 log_warning("%s stopping timed out. Terminating.", u->id);
3101 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3104 case SERVICE_STOP_SIGTERM:
3105 if (s->exec_context.send_sigkill) {
3106 log_warning("%s stopping timed out. Killing.", u->id);
3107 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3109 log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3110 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3115 case SERVICE_STOP_SIGKILL:
3116 /* Uh, we sent a SIGKILL and it is still not gone?
3117 * Must be something we cannot kill, so let's just be
3118 * weirded out and continue */
3120 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3121 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3124 case SERVICE_STOP_POST:
3125 log_warning("%s stopping timed out (2). Terminating.", u->id);
3126 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3129 case SERVICE_FINAL_SIGTERM:
3130 if (s->exec_context.send_sigkill) {
3131 log_warning("%s stopping timed out (2). Killing.", u->id);
3132 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3134 log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3135 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3140 case SERVICE_FINAL_SIGKILL:
3141 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3142 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3145 case SERVICE_AUTO_RESTART:
3146 log_info("%s holdoff time over, scheduling restart.", u->id);
3147 service_enter_restart(s);
3151 assert_not_reached("Timeout at wrong time.");
3155 static void service_cgroup_notify_event(Unit *u) {
3156 Service *s = SERVICE(u);
3160 log_debug("%s: cgroup is empty", u->id);
3164 /* Waiting for SIGCHLD is usually more interesting,
3165 * because it includes return codes/signals. Which is
3166 * why we ignore the cgroup events for most cases,
3167 * except when we don't know pid which to expect the
3171 case SERVICE_START_POST:
3172 /* If we were hoping for the daemon to write its PID file,
3173 * we can give up now. */
3174 if (s->pid_file_pathspec) {
3175 log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3176 service_unwatch_pid_file(s);
3177 if (s->state == SERVICE_START)
3178 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3180 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3184 case SERVICE_RUNNING:
3185 /* service_enter_running() will figure out what to do */
3186 service_enter_running(s, SERVICE_SUCCESS);
3189 case SERVICE_STOP_SIGTERM:
3190 case SERVICE_STOP_SIGKILL:
3192 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3193 service_enter_stop_post(s, SERVICE_SUCCESS);
3197 case SERVICE_FINAL_SIGTERM:
3198 case SERVICE_FINAL_SIGKILL:
3199 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3200 service_enter_dead(s, SERVICE_SUCCESS, SERVICE_SUCCESS);
3209 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3210 Service *s = SERVICE(u);
3215 if (s->notify_access == NOTIFY_NONE) {
3216 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3217 u->id, (unsigned long) pid);
3221 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3222 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3223 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3227 log_debug("%s: Got message", u->id);
3229 /* Interpret MAINPID= */
3230 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3231 (s->state == SERVICE_START ||
3232 s->state == SERVICE_START_POST ||
3233 s->state == SERVICE_RUNNING ||
3234 s->state == SERVICE_RELOAD)) {
3236 if (parse_pid(e + 8, &pid) < 0)
3237 log_warning("Failed to parse notification message %s", e);
3239 log_debug("%s: got %s", u->id, e);
3240 service_set_main_pid(s, pid);
3244 /* Interpret READY= */
3245 if (s->type == SERVICE_NOTIFY &&
3246 s->state == SERVICE_START &&
3247 strv_find(tags, "READY=1")) {
3248 log_debug("%s: got READY=1", u->id);
3250 service_enter_start_post(s);
3253 /* Interpret STATUS= */
3254 e = strv_find_prefix(tags, "STATUS=");
3260 if (!utf8_is_valid(e+7)) {
3261 log_warning("Status message in notification is not UTF-8 clean.");
3267 log_error("Failed to allocate string.");
3271 log_debug("%s: got %s", u->id, e);
3273 free(s->status_text);
3276 free(s->status_text);
3277 s->status_text = NULL;
3281 if (strv_find(tags, "WATCHDOG=1")) {
3282 log_debug("%s: got WATCHDOG=1", u->id);
3283 service_reset_watchdog(s);
3286 /* Notify clients about changed status or main pid */
3287 unit_add_to_dbus_queue(u);
3290 #ifdef HAVE_SYSV_COMPAT
3293 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3297 if (!(f = fopen("/etc/insserv.conf", "re"))) {
3298 r = errno == ENOENT ? 0 : -errno;
3303 char l[LINE_MAX], *t;
3304 char **parsed = NULL;
3306 if (!fgets(l, sizeof(l), f)) {
3311 log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3316 if (*t != '$' && *t != '<')
3319 parsed = strv_split(t,WHITESPACE);
3320 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3321 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3324 if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3326 if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3328 char *dep = NULL, *name, **j;
3330 STRV_FOREACH (j, parsed+1) {
3339 if (sysv_translate_facility(name, NULL, &dep) < 0)
3342 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3357 static int service_enumerate(Manager *m) {
3361 char *path = NULL, *fpath = NULL, *name = NULL;
3362 Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3369 if (m->running_as != MANAGER_SYSTEM)
3372 zero(runlevel_services);
3374 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3375 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3379 path = join(*p, "/", rcnd_table[i].path, NULL);
3388 if (!(d = opendir(path))) {
3389 if (errno != ENOENT)
3390 log_warning("opendir() failed on %s: %s", path, strerror(errno));
3395 while ((de = readdir(d))) {
3398 if (ignore_file(de->d_name))
3401 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3404 if (strlen(de->d_name) < 4)
3407 a = undecchar(de->d_name[1]);
3408 b = undecchar(de->d_name[2]);
3414 fpath = join(path, "/", de->d_name, NULL);
3420 if (access(fpath, X_OK) < 0) {
3422 if (errno != ENOENT)
3423 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3429 if (!(name = sysv_translate_name(de->d_name + 3))) {
3434 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3435 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3439 if (de->d_name[0] == 'S') {
3441 if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3442 SERVICE(service)->sysv_start_priority_from_rcnd =
3443 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3445 SERVICE(service)->sysv_enabled = true;
3448 if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3451 if ((r = set_put(runlevel_services[i], service)) < 0)
3454 } else if (de->d_name[0] == 'K' &&
3455 (rcnd_table[i].type == RUNLEVEL_DOWN ||
3456 rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3458 if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3461 if ((r = set_put(shutdown_services, service)) < 0)
3467 /* Now we loaded all stubs and are aware of the lowest
3468 start-up priority for all services, not let's actually load
3469 the services, this will also tell us which services are
3470 actually native now */
3471 manager_dispatch_load_queue(m);
3473 /* If this is a native service, rely on native ways to pull in
3474 * a service, don't pull it in via sysv rcN.d links. */
3475 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3476 SET_FOREACH(service, runlevel_services[i], j) {
3477 service = unit_follow_merge(service);
3479 if (service->fragment_path)
3482 if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3486 /* We honour K links only for halt/reboot. For the normal
3487 * runlevels we assume the stop jobs will be implicitly added
3488 * by the core logic. Also, we don't really distinguish here
3489 * between the runlevels 0 and 6 and just add them to the
3490 * special shutdown target. On SUSE the boot.d/ runlevel is
3491 * also used for shutdown, so we add links for that too to the
3492 * shutdown target.*/
3493 SET_FOREACH(service, shutdown_services, j) {
3494 service = unit_follow_merge(service);
3496 if (service->fragment_path)
3499 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3506 sysv_facility_in_insserv_conf (m);
3514 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3515 set_free(runlevel_services[i]);
3516 set_free(shutdown_services);
3525 static void service_bus_name_owner_change(
3528 const char *old_owner,
3529 const char *new_owner) {
3531 Service *s = SERVICE(u);
3536 assert(streq(s->bus_name, name));
3537 assert(old_owner || new_owner);
3539 if (old_owner && new_owner)
3540 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3542 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3544 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3546 s->bus_name_good = !!new_owner;
3548 if (s->type == SERVICE_DBUS) {
3550 /* service_enter_running() will figure out what to
3552 if (s->state == SERVICE_RUNNING)
3553 service_enter_running(s, SERVICE_SUCCESS);
3554 else if (s->state == SERVICE_START && new_owner)
3555 service_enter_start_post(s);
3557 } else if (new_owner &&
3559 (s->state == SERVICE_START ||
3560 s->state == SERVICE_START_POST ||
3561 s->state == SERVICE_RUNNING ||
3562 s->state == SERVICE_RELOAD)) {
3564 /* Try to acquire PID from bus service */
3565 log_debug("Trying to acquire PID from D-Bus name...");
3567 bus_query_pid(u->manager, name);
3571 static void service_bus_query_pid_done(
3576 Service *s = SERVICE(u);
3581 log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3583 if (s->main_pid <= 0 &&
3584 (s->state == SERVICE_START ||
3585 s->state == SERVICE_START_POST ||
3586 s->state == SERVICE_RUNNING ||
3587 s->state == SERVICE_RELOAD))
3588 service_set_main_pid(s, pid);
3591 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3596 /* This is called by the socket code when instantiating a new
3597 * service for a stream socket and the socket needs to be
3600 if (UNIT(s)->load_state != UNIT_LOADED)
3603 if (s->socket_fd >= 0)
3606 if (s->state != SERVICE_DEAD)
3610 s->got_socket_fd = true;
3612 unit_ref_set(&s->accept_socket, UNIT(sock));
3614 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3617 static void service_reset_failed(Unit *u) {
3618 Service *s = SERVICE(u);
3622 if (s->state == SERVICE_FAILED)
3623 service_set_state(s, SERVICE_DEAD);
3625 s->result = SERVICE_SUCCESS;
3626 s->reload_result = SERVICE_SUCCESS;
3629 static bool service_need_daemon_reload(Unit *u) {
3630 Service *s = SERVICE(u);
3634 #ifdef HAVE_SYSV_COMPAT
3639 if (stat(s->sysv_path, &st) < 0)
3640 /* What, cannot access this anymore? */
3643 if (s->sysv_mtime > 0 &&
3644 timespec_load(&st.st_mtim) != s->sysv_mtime)
3652 static int service_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
3653 Service *s = SERVICE(u);
3655 Set *pid_set = NULL;
3659 if (s->main_pid <= 0 && who == KILL_MAIN) {
3660 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3664 if (s->control_pid <= 0 && who == KILL_CONTROL) {
3665 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3669 if (who == KILL_CONTROL || who == KILL_ALL)
3670 if (s->control_pid > 0)
3671 if (kill(s->control_pid, signo) < 0)
3674 if (who == KILL_MAIN || who == KILL_ALL)
3675 if (s->main_pid > 0)
3676 if (kill(s->main_pid, signo) < 0)
3679 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
3682 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
3685 /* Exclude the control/main pid from being killed via the cgroup */
3686 if (s->control_pid > 0)
3687 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
3692 if (s->main_pid > 0)
3693 if ((q = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0) {
3697 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
3699 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3710 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3711 [SERVICE_DEAD] = "dead",
3712 [SERVICE_START_PRE] = "start-pre",
3713 [SERVICE_START] = "start",
3714 [SERVICE_START_POST] = "start-post",
3715 [SERVICE_RUNNING] = "running",
3716 [SERVICE_EXITED] = "exited",
3717 [SERVICE_RELOAD] = "reload",
3718 [SERVICE_STOP] = "stop",
3719 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3720 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3721 [SERVICE_STOP_POST] = "stop-post",
3722 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3723 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3724 [SERVICE_FAILED] = "failed",
3725 [SERVICE_AUTO_RESTART] = "auto-restart",
3728 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3730 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3731 [SERVICE_RESTART_NO] = "no",
3732 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3733 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3734 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3735 [SERVICE_RESTART_ALWAYS] = "always"
3738 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3740 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3741 [SERVICE_SIMPLE] = "simple",
3742 [SERVICE_FORKING] = "forking",
3743 [SERVICE_ONESHOT] = "oneshot",
3744 [SERVICE_DBUS] = "dbus",
3745 [SERVICE_NOTIFY] = "notify",
3746 [SERVICE_IDLE] = "idle"
3749 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3751 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3752 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3753 [SERVICE_EXEC_START] = "ExecStart",
3754 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3755 [SERVICE_EXEC_RELOAD] = "ExecReload",
3756 [SERVICE_EXEC_STOP] = "ExecStop",
3757 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3760 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3762 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3763 [NOTIFY_NONE] = "none",
3764 [NOTIFY_MAIN] = "main",
3765 [NOTIFY_ALL] = "all"
3768 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3770 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3771 [SERVICE_SUCCESS] = "success",
3772 [SERVICE_FAILURE_RESOURCES] = "resources",
3773 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3774 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3775 [SERVICE_FAILURE_SIGNAL] = "signal",
3776 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3777 [SERVICE_FAILURE_WATCHDOG] = "watchdog"
3780 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3782 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3783 [SERVICE_START_LIMIT_NONE] = "none",
3784 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3785 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3786 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3788 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3790 const UnitVTable service_vtable = {
3791 .suffix = ".service",
3792 .object_size = sizeof(Service),
3798 .init = service_init,
3799 .done = service_done,
3800 .load = service_load,
3802 .coldplug = service_coldplug,
3804 .dump = service_dump,
3806 .start = service_start,
3807 .stop = service_stop,
3808 .reload = service_reload,
3810 .can_reload = service_can_reload,
3812 .kill = service_kill,
3814 .serialize = service_serialize,
3815 .deserialize_item = service_deserialize_item,
3817 .active_state = service_active_state,
3818 .sub_state_to_string = service_sub_state_to_string,
3820 .check_gc = service_check_gc,
3821 .check_snapshot = service_check_snapshot,
3823 .sigchld_event = service_sigchld_event,
3824 .timer_event = service_timer_event,
3825 .fd_event = service_fd_event,
3827 .reset_failed = service_reset_failed,
3829 .need_daemon_reload = service_need_daemon_reload,
3831 .cgroup_notify_empty = service_cgroup_notify_event,
3832 .notify_message = service_notify_message,
3834 .bus_name_owner_change = service_bus_name_owner_change,
3835 .bus_query_pid_done = service_bus_query_pid_done,
3837 .bus_interface = "org.freedesktop.systemd1.Service",
3838 .bus_message_handler = bus_service_message_handler,
3839 .bus_invalidating_properties = bus_service_invalidating_properties,
3841 #ifdef HAVE_SYSV_COMPAT
3842 .enumerate = service_enumerate,
3844 .status_message_formats = {
3845 .starting_stopping = {
3846 [0] = "Starting %s...",
3847 [1] = "Stopping %s...",
3849 .finished_start_job = {
3850 [JOB_DONE] = "Started %s.",
3851 [JOB_FAILED] = "Failed to start %s.",
3852 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3853 [JOB_TIMEOUT] = "Timed out starting %s.",
3855 .finished_stop_job = {
3856 [JOB_DONE] = "Stopped %s.",
3857 [JOB_FAILED] = "Stopped (with error) %s.",
3858 [JOB_TIMEOUT] = "Timed out stopping %s.",