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 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED || s->state == SERVICE_AUTO_RESTART);
2441 /* Make sure we don't enter a busy loop of some kind. */
2442 r = service_start_limit_test(s);
2444 service_notify_sockets_dead(s, true);
2448 s->result = SERVICE_SUCCESS;
2449 s->reload_result = SERVICE_SUCCESS;
2450 s->main_pid_known = false;
2451 s->main_pid_alien = false;
2452 s->forbid_restart = false;
2454 service_enter_start_pre(s);
2458 static int service_stop(Unit *u) {
2459 Service *s = SERVICE(u);
2463 /* This is a user request, so don't do restarts on this
2465 s->forbid_restart = true;
2468 if (s->state == SERVICE_STOP ||
2469 s->state == SERVICE_STOP_SIGTERM ||
2470 s->state == SERVICE_STOP_SIGKILL ||
2471 s->state == SERVICE_STOP_POST ||
2472 s->state == SERVICE_FINAL_SIGTERM ||
2473 s->state == SERVICE_FINAL_SIGKILL)
2476 /* Don't allow a restart */
2477 if (s->state == SERVICE_AUTO_RESTART) {
2478 service_set_state(s, SERVICE_DEAD);
2482 /* If there's already something running we go directly into
2484 if (s->state == SERVICE_START_PRE ||
2485 s->state == SERVICE_START ||
2486 s->state == SERVICE_START_POST ||
2487 s->state == SERVICE_RELOAD) {
2488 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2492 assert(s->state == SERVICE_RUNNING ||
2493 s->state == SERVICE_EXITED);
2495 service_enter_stop(s, SERVICE_SUCCESS);
2499 static int service_reload(Unit *u) {
2500 Service *s = SERVICE(u);
2504 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2506 service_enter_reload(s);
2510 static bool service_can_reload(Unit *u) {
2511 Service *s = SERVICE(u);
2515 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2518 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2519 Service *s = SERVICE(u);
2525 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2526 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2527 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2529 if (s->control_pid > 0)
2530 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2532 if (s->main_pid_known && s->main_pid > 0)
2533 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2535 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2538 unit_serialize_item(u, f, "status-text", s->status_text);
2540 /* FIXME: There's a minor uncleanliness here: if there are
2541 * multiple commands attached here, we will start from the
2542 * first one again */
2543 if (s->control_command_id >= 0)
2544 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2546 if (s->socket_fd >= 0) {
2549 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2552 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2555 if (s->main_exec_status.pid > 0) {
2556 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2557 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2558 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2560 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2561 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2562 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2565 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2566 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2571 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2572 Service *s = SERVICE(u);
2579 if (streq(key, "state")) {
2582 if ((state = service_state_from_string(value)) < 0)
2583 log_debug("Failed to parse state value %s", value);
2585 s->deserialized_state = state;
2586 } else if (streq(key, "result")) {
2589 f = service_result_from_string(value);
2591 log_debug("Failed to parse result value %s", value);
2592 else if (f != SERVICE_SUCCESS)
2595 } else if (streq(key, "reload-result")) {
2598 f = service_result_from_string(value);
2600 log_debug("Failed to parse reload result value %s", value);
2601 else if (f != SERVICE_SUCCESS)
2602 s->reload_result = f;
2604 } else if (streq(key, "control-pid")) {
2607 if (parse_pid(value, &pid) < 0)
2608 log_debug("Failed to parse control-pid value %s", value);
2610 s->control_pid = pid;
2611 } else if (streq(key, "main-pid")) {
2614 if (parse_pid(value, &pid) < 0)
2615 log_debug("Failed to parse main-pid value %s", value);
2617 service_set_main_pid(s, (pid_t) pid);
2618 } else if (streq(key, "main-pid-known")) {
2621 if ((b = parse_boolean(value)) < 0)
2622 log_debug("Failed to parse main-pid-known value %s", value);
2624 s->main_pid_known = b;
2625 } else if (streq(key, "status-text")) {
2628 if ((t = strdup(value))) {
2629 free(s->status_text);
2633 } else if (streq(key, "control-command")) {
2634 ServiceExecCommand id;
2636 if ((id = service_exec_command_from_string(value)) < 0)
2637 log_debug("Failed to parse exec-command value %s", value);
2639 s->control_command_id = id;
2640 s->control_command = s->exec_command[id];
2642 } else if (streq(key, "socket-fd")) {
2645 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2646 log_debug("Failed to parse socket-fd value %s", value);
2649 if (s->socket_fd >= 0)
2650 close_nointr_nofail(s->socket_fd);
2651 s->socket_fd = fdset_remove(fds, fd);
2653 } else if (streq(key, "main-exec-status-pid")) {
2656 if (parse_pid(value, &pid) < 0)
2657 log_debug("Failed to parse main-exec-status-pid value %s", value);
2659 s->main_exec_status.pid = pid;
2660 } else if (streq(key, "main-exec-status-code")) {
2663 if (safe_atoi(value, &i) < 0)
2664 log_debug("Failed to parse main-exec-status-code value %s", value);
2666 s->main_exec_status.code = i;
2667 } else if (streq(key, "main-exec-status-status")) {
2670 if (safe_atoi(value, &i) < 0)
2671 log_debug("Failed to parse main-exec-status-status value %s", value);
2673 s->main_exec_status.status = i;
2674 } else if (streq(key, "main-exec-status-start"))
2675 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2676 else if (streq(key, "main-exec-status-exit"))
2677 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2678 else if (streq(key, "watchdog-timestamp"))
2679 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2681 log_debug("Unknown serialization key '%s'", key);
2686 static UnitActiveState service_active_state(Unit *u) {
2689 return state_translation_table[SERVICE(u)->state];
2692 static const char *service_sub_state_to_string(Unit *u) {
2695 return service_state_to_string(SERVICE(u)->state);
2698 static bool service_check_gc(Unit *u) {
2699 Service *s = SERVICE(u);
2703 /* Never clean up services that still have a process around,
2704 * even if the service is formally dead. */
2705 if (cgroup_good(s) > 0 ||
2706 main_pid_good(s) > 0 ||
2707 control_pid_good(s) > 0)
2710 #ifdef HAVE_SYSV_COMPAT
2718 static bool service_check_snapshot(Unit *u) {
2719 Service *s = SERVICE(u);
2723 return !s->got_socket_fd;
2726 static int service_retry_pid_file(Service *s) {
2729 assert(s->pid_file);
2730 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2732 r = service_load_pid_file(s, false);
2736 service_unwatch_pid_file(s);
2738 service_enter_running(s, SERVICE_SUCCESS);
2742 static int service_watch_pid_file(Service *s) {
2745 log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2746 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2750 /* the pidfile might have appeared just before we set the watch */
2751 service_retry_pid_file(s);
2755 log_error("Failed to set a watch for %s's PID file %s: %s",
2756 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2757 service_unwatch_pid_file(s);
2761 static int service_demand_pid_file(Service *s) {
2764 assert(s->pid_file);
2765 assert(!s->pid_file_pathspec);
2767 ps = new0(PathSpec, 1);
2771 ps->path = strdup(s->pid_file);
2777 path_kill_slashes(ps->path);
2779 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2780 * keep their PID file open all the time. */
2781 ps->type = PATH_MODIFIED;
2782 ps->inotify_fd = -1;
2784 s->pid_file_pathspec = ps;
2786 return service_watch_pid_file(s);
2789 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2790 Service *s = SERVICE(u);
2794 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2795 assert(s->pid_file_pathspec);
2796 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2798 log_debug("inotify event for %s", u->id);
2800 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2803 if (service_retry_pid_file(s) == 0)
2806 if (service_watch_pid_file(s) < 0)
2811 service_unwatch_pid_file(s);
2812 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2815 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2816 Service *s = SERVICE(u);
2822 if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2823 f = SERVICE_SUCCESS;
2824 else if (code == CLD_EXITED)
2825 f = SERVICE_FAILURE_EXIT_CODE;
2826 else if (code == CLD_KILLED)
2827 f = SERVICE_FAILURE_SIGNAL;
2828 else if (code == CLD_DUMPED)
2829 f = SERVICE_FAILURE_CORE_DUMP;
2831 assert_not_reached("Unknown code");
2833 if (s->main_pid == pid) {
2834 /* Forking services may occasionally move to a new PID.
2835 * As long as they update the PID file before exiting the old
2836 * PID, they're fine. */
2837 if (service_load_pid_file(s, false) == 0)
2841 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2843 /* If this is not a forking service than the main
2844 * process got started and hence we copy the exit
2845 * status so that it is recorded both as main and as
2846 * control process exit status */
2847 if (s->main_command) {
2848 s->main_command->exec_status = s->main_exec_status;
2850 if (s->main_command->ignore)
2851 f = SERVICE_SUCCESS;
2854 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2855 "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2857 if (f != SERVICE_SUCCESS)
2860 if (s->main_command &&
2861 s->main_command->command_next &&
2862 f == SERVICE_SUCCESS) {
2864 /* There is another command to *
2865 * execute, so let's do that. */
2867 log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2868 service_run_next_main(s);
2872 /* The service exited, so the service is officially
2874 s->main_command = NULL;
2878 case SERVICE_START_POST:
2879 case SERVICE_RELOAD:
2881 /* Need to wait until the operation is
2886 if (s->type == SERVICE_ONESHOT) {
2887 /* This was our main goal, so let's go on */
2888 if (f == SERVICE_SUCCESS)
2889 service_enter_start_post(s);
2891 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2894 assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2899 case SERVICE_RUNNING:
2900 service_enter_running(s, f);
2903 case SERVICE_STOP_SIGTERM:
2904 case SERVICE_STOP_SIGKILL:
2906 if (!control_pid_good(s))
2907 service_enter_stop_post(s, f);
2909 /* If there is still a control process, wait for that first */
2913 assert_not_reached("Uh, main process died at wrong time.");
2917 } else if (s->control_pid == pid) {
2921 if (s->control_command) {
2922 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2924 if (s->control_command->ignore)
2925 f = SERVICE_SUCCESS;
2928 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2929 "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2931 if (f != SERVICE_SUCCESS)
2934 /* Immediately get rid of the cgroup, so that the
2935 * kernel doesn't delay the cgroup empty messages for
2936 * the service cgroup any longer than necessary */
2937 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2939 if (s->control_command &&
2940 s->control_command->command_next &&
2941 f == SERVICE_SUCCESS) {
2943 /* There is another command to *
2944 * execute, so let's do that. */
2946 log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2947 service_run_next_control(s);
2950 /* No further commands for this step, so let's
2951 * figure out what to do next */
2953 s->control_command = NULL;
2954 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2956 log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2960 case SERVICE_START_PRE:
2961 if (f == SERVICE_SUCCESS)
2962 service_enter_start(s);
2964 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2968 assert(s->type == SERVICE_FORKING);
2970 if (f != SERVICE_SUCCESS) {
2971 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2976 bool has_start_post;
2979 /* Let's try to load the pid file here if we can.
2980 * The PID file might actually be created by a START_POST
2981 * script. In that case don't worry if the loading fails. */
2983 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2984 r = service_load_pid_file(s, !has_start_post);
2985 if (!has_start_post && r < 0) {
2986 r = service_demand_pid_file(s);
2987 if (r < 0 || !cgroup_good(s))
2988 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2992 service_search_main_pid(s);
2994 service_enter_start_post(s);
2997 case SERVICE_START_POST:
2998 if (f != SERVICE_SUCCESS) {
2999 service_enter_stop(s, f);
3006 r = service_load_pid_file(s, true);
3008 r = service_demand_pid_file(s);
3009 if (r < 0 || !cgroup_good(s))
3010 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3014 service_search_main_pid(s);
3016 service_enter_running(s, SERVICE_SUCCESS);
3019 case SERVICE_RELOAD:
3020 if (f == SERVICE_SUCCESS) {
3021 service_load_pid_file(s, true);
3022 service_search_main_pid(s);
3025 s->reload_result = f;
3026 service_enter_running(s, SERVICE_SUCCESS);
3030 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3033 case SERVICE_STOP_SIGTERM:
3034 case SERVICE_STOP_SIGKILL:
3035 if (main_pid_good(s) <= 0)
3036 service_enter_stop_post(s, f);
3038 /* If there is still a service
3039 * process around, wait until
3040 * that one quit, too */
3043 case SERVICE_STOP_POST:
3044 case SERVICE_FINAL_SIGTERM:
3045 case SERVICE_FINAL_SIGKILL:
3046 service_enter_dead(s, f, true);
3050 assert_not_reached("Uh, control process died at wrong time.");
3055 /* Notify clients about changed exit status */
3056 unit_add_to_dbus_queue(u);
3059 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3060 Service *s = SERVICE(u);
3063 assert(elapsed == 1);
3065 if (w == &s->watchdog_watch) {
3066 service_handle_watchdog(s);
3070 assert(w == &s->timer_watch);
3074 case SERVICE_START_PRE:
3076 log_warning("%s operation timed out. Terminating.", u->id);
3077 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3080 case SERVICE_START_POST:
3081 log_warning("%s operation timed out. Stopping.", u->id);
3082 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3085 case SERVICE_RELOAD:
3086 log_warning("%s operation timed out. Stopping.", u->id);
3087 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3088 service_enter_running(s, SERVICE_SUCCESS);
3092 log_warning("%s stopping timed out. Terminating.", u->id);
3093 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3096 case SERVICE_STOP_SIGTERM:
3097 if (s->exec_context.send_sigkill) {
3098 log_warning("%s stopping timed out. Killing.", u->id);
3099 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3101 log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3102 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3107 case SERVICE_STOP_SIGKILL:
3108 /* Uh, we sent a SIGKILL and it is still not gone?
3109 * Must be something we cannot kill, so let's just be
3110 * weirded out and continue */
3112 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3113 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3116 case SERVICE_STOP_POST:
3117 log_warning("%s stopping timed out (2). Terminating.", u->id);
3118 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3121 case SERVICE_FINAL_SIGTERM:
3122 if (s->exec_context.send_sigkill) {
3123 log_warning("%s stopping timed out (2). Killing.", u->id);
3124 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3126 log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3127 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3132 case SERVICE_FINAL_SIGKILL:
3133 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3134 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3137 case SERVICE_AUTO_RESTART:
3138 log_info("%s holdoff time over, scheduling restart.", u->id);
3139 service_enter_restart(s);
3143 assert_not_reached("Timeout at wrong time.");
3147 static void service_cgroup_notify_event(Unit *u) {
3148 Service *s = SERVICE(u);
3152 log_debug("%s: cgroup is empty", u->id);
3156 /* Waiting for SIGCHLD is usually more interesting,
3157 * because it includes return codes/signals. Which is
3158 * why we ignore the cgroup events for most cases,
3159 * except when we don't know pid which to expect the
3163 case SERVICE_START_POST:
3164 /* If we were hoping for the daemon to write its PID file,
3165 * we can give up now. */
3166 if (s->pid_file_pathspec) {
3167 log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3168 service_unwatch_pid_file(s);
3169 if (s->state == SERVICE_START)
3170 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3172 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3176 case SERVICE_RUNNING:
3177 /* service_enter_running() will figure out what to do */
3178 service_enter_running(s, SERVICE_SUCCESS);
3181 case SERVICE_STOP_SIGTERM:
3182 case SERVICE_STOP_SIGKILL:
3184 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3185 service_enter_stop_post(s, SERVICE_SUCCESS);
3189 case SERVICE_FINAL_SIGTERM:
3190 case SERVICE_FINAL_SIGKILL:
3191 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3192 service_enter_dead(s, SERVICE_SUCCESS, SERVICE_SUCCESS);
3201 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3202 Service *s = SERVICE(u);
3207 if (s->notify_access == NOTIFY_NONE) {
3208 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3209 u->id, (unsigned long) pid);
3213 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3214 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3215 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3219 log_debug("%s: Got message", u->id);
3221 /* Interpret MAINPID= */
3222 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3223 (s->state == SERVICE_START ||
3224 s->state == SERVICE_START_POST ||
3225 s->state == SERVICE_RUNNING ||
3226 s->state == SERVICE_RELOAD)) {
3228 if (parse_pid(e + 8, &pid) < 0)
3229 log_warning("Failed to parse notification message %s", e);
3231 log_debug("%s: got %s", u->id, e);
3232 service_set_main_pid(s, pid);
3236 /* Interpret READY= */
3237 if (s->type == SERVICE_NOTIFY &&
3238 s->state == SERVICE_START &&
3239 strv_find(tags, "READY=1")) {
3240 log_debug("%s: got READY=1", u->id);
3242 service_enter_start_post(s);
3245 /* Interpret STATUS= */
3246 e = strv_find_prefix(tags, "STATUS=");
3252 if (!utf8_is_valid(e+7)) {
3253 log_warning("Status message in notification is not UTF-8 clean.");
3259 log_error("Failed to allocate string.");
3263 log_debug("%s: got %s", u->id, e);
3265 free(s->status_text);
3268 free(s->status_text);
3269 s->status_text = NULL;
3273 if (strv_find(tags, "WATCHDOG=1")) {
3274 log_debug("%s: got WATCHDOG=1", u->id);
3275 service_reset_watchdog(s);
3278 /* Notify clients about changed status or main pid */
3279 unit_add_to_dbus_queue(u);
3282 #ifdef HAVE_SYSV_COMPAT
3285 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3289 if (!(f = fopen("/etc/insserv.conf", "re"))) {
3290 r = errno == ENOENT ? 0 : -errno;
3295 char l[LINE_MAX], *t;
3296 char **parsed = NULL;
3298 if (!fgets(l, sizeof(l), f)) {
3303 log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3308 if (*t != '$' && *t != '<')
3311 parsed = strv_split(t,WHITESPACE);
3312 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3313 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3316 if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3318 if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3320 char *dep = NULL, *name, **j;
3322 STRV_FOREACH (j, parsed+1) {
3331 if (sysv_translate_facility(name, NULL, &dep) < 0)
3334 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3349 static int service_enumerate(Manager *m) {
3353 char *path = NULL, *fpath = NULL, *name = NULL;
3354 Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3361 if (m->running_as != MANAGER_SYSTEM)
3364 zero(runlevel_services);
3366 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3367 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3371 path = join(*p, "/", rcnd_table[i].path, NULL);
3380 if (!(d = opendir(path))) {
3381 if (errno != ENOENT)
3382 log_warning("opendir() failed on %s: %s", path, strerror(errno));
3387 while ((de = readdir(d))) {
3390 if (ignore_file(de->d_name))
3393 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3396 if (strlen(de->d_name) < 4)
3399 a = undecchar(de->d_name[1]);
3400 b = undecchar(de->d_name[2]);
3406 fpath = join(path, "/", de->d_name, NULL);
3412 if (access(fpath, X_OK) < 0) {
3414 if (errno != ENOENT)
3415 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3421 if (!(name = sysv_translate_name(de->d_name + 3))) {
3426 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3427 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3431 if (de->d_name[0] == 'S') {
3433 if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3434 SERVICE(service)->sysv_start_priority_from_rcnd =
3435 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3437 SERVICE(service)->sysv_enabled = true;
3440 if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3443 if ((r = set_put(runlevel_services[i], service)) < 0)
3446 } else if (de->d_name[0] == 'K' &&
3447 (rcnd_table[i].type == RUNLEVEL_DOWN ||
3448 rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3450 if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3453 if ((r = set_put(shutdown_services, service)) < 0)
3459 /* Now we loaded all stubs and are aware of the lowest
3460 start-up priority for all services, not let's actually load
3461 the services, this will also tell us which services are
3462 actually native now */
3463 manager_dispatch_load_queue(m);
3465 /* If this is a native service, rely on native ways to pull in
3466 * a service, don't pull it in via sysv rcN.d links. */
3467 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3468 SET_FOREACH(service, runlevel_services[i], j) {
3469 service = unit_follow_merge(service);
3471 if (service->fragment_path)
3474 if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3478 /* We honour K links only for halt/reboot. For the normal
3479 * runlevels we assume the stop jobs will be implicitly added
3480 * by the core logic. Also, we don't really distinguish here
3481 * between the runlevels 0 and 6 and just add them to the
3482 * special shutdown target. On SUSE the boot.d/ runlevel is
3483 * also used for shutdown, so we add links for that too to the
3484 * shutdown target.*/
3485 SET_FOREACH(service, shutdown_services, j) {
3486 service = unit_follow_merge(service);
3488 if (service->fragment_path)
3491 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3498 sysv_facility_in_insserv_conf (m);
3506 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3507 set_free(runlevel_services[i]);
3508 set_free(shutdown_services);
3517 static void service_bus_name_owner_change(
3520 const char *old_owner,
3521 const char *new_owner) {
3523 Service *s = SERVICE(u);
3528 assert(streq(s->bus_name, name));
3529 assert(old_owner || new_owner);
3531 if (old_owner && new_owner)
3532 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3534 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3536 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3538 s->bus_name_good = !!new_owner;
3540 if (s->type == SERVICE_DBUS) {
3542 /* service_enter_running() will figure out what to
3544 if (s->state == SERVICE_RUNNING)
3545 service_enter_running(s, SERVICE_SUCCESS);
3546 else if (s->state == SERVICE_START && new_owner)
3547 service_enter_start_post(s);
3549 } else if (new_owner &&
3551 (s->state == SERVICE_START ||
3552 s->state == SERVICE_START_POST ||
3553 s->state == SERVICE_RUNNING ||
3554 s->state == SERVICE_RELOAD)) {
3556 /* Try to acquire PID from bus service */
3557 log_debug("Trying to acquire PID from D-Bus name...");
3559 bus_query_pid(u->manager, name);
3563 static void service_bus_query_pid_done(
3568 Service *s = SERVICE(u);
3573 log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3575 if (s->main_pid <= 0 &&
3576 (s->state == SERVICE_START ||
3577 s->state == SERVICE_START_POST ||
3578 s->state == SERVICE_RUNNING ||
3579 s->state == SERVICE_RELOAD))
3580 service_set_main_pid(s, pid);
3583 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3588 /* This is called by the socket code when instantiating a new
3589 * service for a stream socket and the socket needs to be
3592 if (UNIT(s)->load_state != UNIT_LOADED)
3595 if (s->socket_fd >= 0)
3598 if (s->state != SERVICE_DEAD)
3602 s->got_socket_fd = true;
3604 unit_ref_set(&s->accept_socket, UNIT(sock));
3606 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3609 static void service_reset_failed(Unit *u) {
3610 Service *s = SERVICE(u);
3614 if (s->state == SERVICE_FAILED)
3615 service_set_state(s, SERVICE_DEAD);
3617 s->result = SERVICE_SUCCESS;
3618 s->reload_result = SERVICE_SUCCESS;
3621 static bool service_need_daemon_reload(Unit *u) {
3622 Service *s = SERVICE(u);
3626 #ifdef HAVE_SYSV_COMPAT
3631 if (stat(s->sysv_path, &st) < 0)
3632 /* What, cannot access this anymore? */
3635 if (s->sysv_mtime > 0 &&
3636 timespec_load(&st.st_mtim) != s->sysv_mtime)
3644 static int service_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
3645 Service *s = SERVICE(u);
3647 Set *pid_set = NULL;
3651 if (s->main_pid <= 0 && who == KILL_MAIN) {
3652 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3656 if (s->control_pid <= 0 && who == KILL_CONTROL) {
3657 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3661 if (who == KILL_CONTROL || who == KILL_ALL)
3662 if (s->control_pid > 0)
3663 if (kill(s->control_pid, signo) < 0)
3666 if (who == KILL_MAIN || who == KILL_ALL)
3667 if (s->main_pid > 0)
3668 if (kill(s->main_pid, signo) < 0)
3671 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
3674 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
3677 /* Exclude the control/main pid from being killed via the cgroup */
3678 if (s->control_pid > 0)
3679 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
3684 if (s->main_pid > 0)
3685 if ((q = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0) {
3689 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
3691 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3702 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3703 [SERVICE_DEAD] = "dead",
3704 [SERVICE_START_PRE] = "start-pre",
3705 [SERVICE_START] = "start",
3706 [SERVICE_START_POST] = "start-post",
3707 [SERVICE_RUNNING] = "running",
3708 [SERVICE_EXITED] = "exited",
3709 [SERVICE_RELOAD] = "reload",
3710 [SERVICE_STOP] = "stop",
3711 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3712 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3713 [SERVICE_STOP_POST] = "stop-post",
3714 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3715 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3716 [SERVICE_FAILED] = "failed",
3717 [SERVICE_AUTO_RESTART] = "auto-restart",
3720 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3722 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3723 [SERVICE_RESTART_NO] = "no",
3724 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3725 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3726 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3727 [SERVICE_RESTART_ALWAYS] = "always"
3730 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3732 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3733 [SERVICE_SIMPLE] = "simple",
3734 [SERVICE_FORKING] = "forking",
3735 [SERVICE_ONESHOT] = "oneshot",
3736 [SERVICE_DBUS] = "dbus",
3737 [SERVICE_NOTIFY] = "notify",
3738 [SERVICE_IDLE] = "idle"
3741 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3743 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3744 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3745 [SERVICE_EXEC_START] = "ExecStart",
3746 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3747 [SERVICE_EXEC_RELOAD] = "ExecReload",
3748 [SERVICE_EXEC_STOP] = "ExecStop",
3749 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3752 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3754 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3755 [NOTIFY_NONE] = "none",
3756 [NOTIFY_MAIN] = "main",
3757 [NOTIFY_ALL] = "all"
3760 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3762 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3763 [SERVICE_SUCCESS] = "success",
3764 [SERVICE_FAILURE_RESOURCES] = "resources",
3765 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3766 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3767 [SERVICE_FAILURE_SIGNAL] = "signal",
3768 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3769 [SERVICE_FAILURE_WATCHDOG] = "watchdog"
3772 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3774 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3775 [SERVICE_START_LIMIT_NONE] = "none",
3776 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3777 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3778 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3780 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3782 const UnitVTable service_vtable = {
3783 .suffix = ".service",
3784 .object_size = sizeof(Service),
3790 .init = service_init,
3791 .done = service_done,
3792 .load = service_load,
3794 .coldplug = service_coldplug,
3796 .dump = service_dump,
3798 .start = service_start,
3799 .stop = service_stop,
3800 .reload = service_reload,
3802 .can_reload = service_can_reload,
3804 .kill = service_kill,
3806 .serialize = service_serialize,
3807 .deserialize_item = service_deserialize_item,
3809 .active_state = service_active_state,
3810 .sub_state_to_string = service_sub_state_to_string,
3812 .check_gc = service_check_gc,
3813 .check_snapshot = service_check_snapshot,
3815 .sigchld_event = service_sigchld_event,
3816 .timer_event = service_timer_event,
3817 .fd_event = service_fd_event,
3819 .reset_failed = service_reset_failed,
3821 .need_daemon_reload = service_need_daemon_reload,
3823 .cgroup_notify_empty = service_cgroup_notify_event,
3824 .notify_message = service_notify_message,
3826 .bus_name_owner_change = service_bus_name_owner_change,
3827 .bus_query_pid_done = service_bus_query_pid_done,
3829 .bus_interface = "org.freedesktop.systemd1.Service",
3830 .bus_message_handler = bus_service_message_handler,
3831 .bus_invalidating_properties = bus_service_invalidating_properties,
3833 #ifdef HAVE_SYSV_COMPAT
3834 .enumerate = service_enumerate,
3836 .status_message_formats = {
3837 .starting_stopping = {
3838 [0] = "Starting %s...",
3839 [1] = "Stopping %s...",
3841 .finished_start_job = {
3842 [JOB_DONE] = "Started %s.",
3843 [JOB_FAILED] = "Failed to start %s.",
3844 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3845 [JOB_TIMEOUT] = "Timed out starting %s.",
3847 .finished_stop_job = {
3848 [JOB_DONE] = "Stopped %s.",
3849 [JOB_FAILED] = "Stopped (with error) %s.",
3850 [JOB_TIMEOUT] = "Timed out stopping %s.",