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)
2237 /* Any units that are bound to this service must also be
2238 * restarted. We use JOB_RESTART (instead of the more obvious
2239 * JOB_START) here so that those dependency jobs will be added
2241 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2245 log_debug("%s scheduled restart job.", UNIT(s)->id);
2249 log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2250 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2252 dbus_error_free(&error);
2255 static void service_enter_reload(Service *s) {
2260 service_unwatch_control_pid(s);
2262 if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2263 s->control_command_id = SERVICE_EXEC_RELOAD;
2265 r = service_spawn(s,
2269 !s->permissions_start_only,
2270 !s->root_directory_start_only,
2278 service_set_state(s, SERVICE_RELOAD);
2280 service_enter_running(s, SERVICE_SUCCESS);
2285 log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2286 s->reload_result = SERVICE_FAILURE_RESOURCES;
2287 service_enter_running(s, SERVICE_SUCCESS);
2290 static void service_run_next_control(Service *s) {
2294 assert(s->control_command);
2295 assert(s->control_command->command_next);
2297 assert(s->control_command_id != SERVICE_EXEC_START);
2299 s->control_command = s->control_command->command_next;
2300 service_unwatch_control_pid(s);
2302 r = service_spawn(s,
2306 !s->permissions_start_only,
2307 !s->root_directory_start_only,
2308 s->control_command_id == SERVICE_EXEC_START_PRE ||
2309 s->control_command_id == SERVICE_EXEC_STOP_POST,
2319 log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2321 if (s->state == SERVICE_START_PRE)
2322 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2323 else if (s->state == SERVICE_STOP)
2324 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2325 else if (s->state == SERVICE_STOP_POST)
2326 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2327 else if (s->state == SERVICE_RELOAD) {
2328 s->reload_result = SERVICE_FAILURE_RESOURCES;
2329 service_enter_running(s, SERVICE_SUCCESS);
2331 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2334 static void service_run_next_main(Service *s) {
2339 assert(s->main_command);
2340 assert(s->main_command->command_next);
2341 assert(s->type == SERVICE_ONESHOT);
2343 s->main_command = s->main_command->command_next;
2344 service_unwatch_main_pid(s);
2346 r = service_spawn(s,
2353 s->notify_access != NOTIFY_NONE,
2359 service_set_main_pid(s, pid);
2364 log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2365 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2368 static int service_start_limit_test(Service *s) {
2371 if (ratelimit_test(&s->start_limit))
2374 switch (s->start_limit_action) {
2376 case SERVICE_START_LIMIT_NONE:
2377 log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2380 case SERVICE_START_LIMIT_REBOOT: {
2384 dbus_error_init(&error);
2386 log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2388 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2390 log_error("Failed to reboot: %s.", bus_error(&error, r));
2391 dbus_error_free(&error);
2397 case SERVICE_START_LIMIT_REBOOT_FORCE:
2398 log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2399 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2402 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2403 log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2404 reboot(RB_AUTOBOOT);
2408 log_error("start limit action=%i", s->start_limit_action);
2409 assert_not_reached("Unknown StartLimitAction.");
2415 static int service_start(Unit *u) {
2416 Service *s = SERVICE(u);
2421 /* We cannot fulfill this request right now, try again later
2423 if (s->state == SERVICE_STOP ||
2424 s->state == SERVICE_STOP_SIGTERM ||
2425 s->state == SERVICE_STOP_SIGKILL ||
2426 s->state == SERVICE_STOP_POST ||
2427 s->state == SERVICE_FINAL_SIGTERM ||
2428 s->state == SERVICE_FINAL_SIGKILL)
2431 /* Already on it! */
2432 if (s->state == SERVICE_START_PRE ||
2433 s->state == SERVICE_START ||
2434 s->state == SERVICE_START_POST)
2437 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED || s->state == SERVICE_AUTO_RESTART);
2439 /* Make sure we don't enter a busy loop of some kind. */
2440 r = service_start_limit_test(s);
2442 service_notify_sockets_dead(s, true);
2446 s->result = SERVICE_SUCCESS;
2447 s->reload_result = SERVICE_SUCCESS;
2448 s->main_pid_known = false;
2449 s->main_pid_alien = false;
2450 s->forbid_restart = false;
2452 service_enter_start_pre(s);
2456 static int service_stop(Unit *u) {
2457 Service *s = SERVICE(u);
2461 /* This is a user request, so don't do restarts on this
2463 s->forbid_restart = true;
2466 if (s->state == SERVICE_STOP ||
2467 s->state == SERVICE_STOP_SIGTERM ||
2468 s->state == SERVICE_STOP_SIGKILL ||
2469 s->state == SERVICE_STOP_POST ||
2470 s->state == SERVICE_FINAL_SIGTERM ||
2471 s->state == SERVICE_FINAL_SIGKILL)
2474 /* Don't allow a restart */
2475 if (s->state == SERVICE_AUTO_RESTART) {
2476 service_set_state(s, SERVICE_DEAD);
2480 /* If there's already something running we go directly into
2482 if (s->state == SERVICE_START_PRE ||
2483 s->state == SERVICE_START ||
2484 s->state == SERVICE_START_POST ||
2485 s->state == SERVICE_RELOAD) {
2486 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2490 assert(s->state == SERVICE_RUNNING ||
2491 s->state == SERVICE_EXITED);
2493 service_enter_stop(s, SERVICE_SUCCESS);
2497 static int service_reload(Unit *u) {
2498 Service *s = SERVICE(u);
2502 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2504 service_enter_reload(s);
2508 static bool service_can_reload(Unit *u) {
2509 Service *s = SERVICE(u);
2513 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2516 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2517 Service *s = SERVICE(u);
2523 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2524 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2525 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2527 if (s->control_pid > 0)
2528 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2530 if (s->main_pid_known && s->main_pid > 0)
2531 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2533 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2536 unit_serialize_item(u, f, "status-text", s->status_text);
2538 /* FIXME: There's a minor uncleanliness here: if there are
2539 * multiple commands attached here, we will start from the
2540 * first one again */
2541 if (s->control_command_id >= 0)
2542 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2544 if (s->socket_fd >= 0) {
2547 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2550 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2553 if (s->main_exec_status.pid > 0) {
2554 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2555 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2556 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2558 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2559 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2560 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2563 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2564 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2569 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2570 Service *s = SERVICE(u);
2577 if (streq(key, "state")) {
2580 if ((state = service_state_from_string(value)) < 0)
2581 log_debug("Failed to parse state value %s", value);
2583 s->deserialized_state = state;
2584 } else if (streq(key, "result")) {
2587 f = service_result_from_string(value);
2589 log_debug("Failed to parse result value %s", value);
2590 else if (f != SERVICE_SUCCESS)
2593 } else if (streq(key, "reload-result")) {
2596 f = service_result_from_string(value);
2598 log_debug("Failed to parse reload result value %s", value);
2599 else if (f != SERVICE_SUCCESS)
2600 s->reload_result = f;
2602 } else if (streq(key, "control-pid")) {
2605 if (parse_pid(value, &pid) < 0)
2606 log_debug("Failed to parse control-pid value %s", value);
2608 s->control_pid = pid;
2609 } else if (streq(key, "main-pid")) {
2612 if (parse_pid(value, &pid) < 0)
2613 log_debug("Failed to parse main-pid value %s", value);
2615 service_set_main_pid(s, (pid_t) pid);
2616 } else if (streq(key, "main-pid-known")) {
2619 if ((b = parse_boolean(value)) < 0)
2620 log_debug("Failed to parse main-pid-known value %s", value);
2622 s->main_pid_known = b;
2623 } else if (streq(key, "status-text")) {
2626 if ((t = strdup(value))) {
2627 free(s->status_text);
2631 } else if (streq(key, "control-command")) {
2632 ServiceExecCommand id;
2634 if ((id = service_exec_command_from_string(value)) < 0)
2635 log_debug("Failed to parse exec-command value %s", value);
2637 s->control_command_id = id;
2638 s->control_command = s->exec_command[id];
2640 } else if (streq(key, "socket-fd")) {
2643 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2644 log_debug("Failed to parse socket-fd value %s", value);
2647 if (s->socket_fd >= 0)
2648 close_nointr_nofail(s->socket_fd);
2649 s->socket_fd = fdset_remove(fds, fd);
2651 } else if (streq(key, "main-exec-status-pid")) {
2654 if (parse_pid(value, &pid) < 0)
2655 log_debug("Failed to parse main-exec-status-pid value %s", value);
2657 s->main_exec_status.pid = pid;
2658 } else if (streq(key, "main-exec-status-code")) {
2661 if (safe_atoi(value, &i) < 0)
2662 log_debug("Failed to parse main-exec-status-code value %s", value);
2664 s->main_exec_status.code = i;
2665 } else if (streq(key, "main-exec-status-status")) {
2668 if (safe_atoi(value, &i) < 0)
2669 log_debug("Failed to parse main-exec-status-status value %s", value);
2671 s->main_exec_status.status = i;
2672 } else if (streq(key, "main-exec-status-start"))
2673 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2674 else if (streq(key, "main-exec-status-exit"))
2675 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2676 else if (streq(key, "watchdog-timestamp"))
2677 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2679 log_debug("Unknown serialization key '%s'", key);
2684 static UnitActiveState service_active_state(Unit *u) {
2687 return state_translation_table[SERVICE(u)->state];
2690 static const char *service_sub_state_to_string(Unit *u) {
2693 return service_state_to_string(SERVICE(u)->state);
2696 static bool service_check_gc(Unit *u) {
2697 Service *s = SERVICE(u);
2701 /* Never clean up services that still have a process around,
2702 * even if the service is formally dead. */
2703 if (cgroup_good(s) > 0 ||
2704 main_pid_good(s) > 0 ||
2705 control_pid_good(s) > 0)
2708 #ifdef HAVE_SYSV_COMPAT
2716 static bool service_check_snapshot(Unit *u) {
2717 Service *s = SERVICE(u);
2721 return !s->got_socket_fd;
2724 static int service_retry_pid_file(Service *s) {
2727 assert(s->pid_file);
2728 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2730 r = service_load_pid_file(s, false);
2734 service_unwatch_pid_file(s);
2736 service_enter_running(s, SERVICE_SUCCESS);
2740 static int service_watch_pid_file(Service *s) {
2743 log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2744 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2748 /* the pidfile might have appeared just before we set the watch */
2749 service_retry_pid_file(s);
2753 log_error("Failed to set a watch for %s's PID file %s: %s",
2754 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2755 service_unwatch_pid_file(s);
2759 static int service_demand_pid_file(Service *s) {
2762 assert(s->pid_file);
2763 assert(!s->pid_file_pathspec);
2765 ps = new0(PathSpec, 1);
2769 ps->path = strdup(s->pid_file);
2775 path_kill_slashes(ps->path);
2777 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2778 * keep their PID file open all the time. */
2779 ps->type = PATH_MODIFIED;
2780 ps->inotify_fd = -1;
2782 s->pid_file_pathspec = ps;
2784 return service_watch_pid_file(s);
2787 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2788 Service *s = SERVICE(u);
2792 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2793 assert(s->pid_file_pathspec);
2794 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2796 log_debug("inotify event for %s", u->id);
2798 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2801 if (service_retry_pid_file(s) == 0)
2804 if (service_watch_pid_file(s) < 0)
2809 service_unwatch_pid_file(s);
2810 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2813 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2814 Service *s = SERVICE(u);
2820 if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2821 f = SERVICE_SUCCESS;
2822 else if (code == CLD_EXITED)
2823 f = SERVICE_FAILURE_EXIT_CODE;
2824 else if (code == CLD_KILLED)
2825 f = SERVICE_FAILURE_SIGNAL;
2826 else if (code == CLD_DUMPED)
2827 f = SERVICE_FAILURE_CORE_DUMP;
2829 assert_not_reached("Unknown code");
2831 if (s->main_pid == pid) {
2832 /* Forking services may occasionally move to a new PID.
2833 * As long as they update the PID file before exiting the old
2834 * PID, they're fine. */
2835 if (service_load_pid_file(s, false) == 0)
2839 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2841 /* If this is not a forking service than the main
2842 * process got started and hence we copy the exit
2843 * status so that it is recorded both as main and as
2844 * control process exit status */
2845 if (s->main_command) {
2846 s->main_command->exec_status = s->main_exec_status;
2848 if (s->main_command->ignore)
2849 f = SERVICE_SUCCESS;
2852 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2853 "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2855 if (f != SERVICE_SUCCESS)
2858 if (s->main_command &&
2859 s->main_command->command_next &&
2860 f == SERVICE_SUCCESS) {
2862 /* There is another command to *
2863 * execute, so let's do that. */
2865 log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2866 service_run_next_main(s);
2870 /* The service exited, so the service is officially
2872 s->main_command = NULL;
2876 case SERVICE_START_POST:
2877 case SERVICE_RELOAD:
2879 /* Need to wait until the operation is
2884 if (s->type == SERVICE_ONESHOT) {
2885 /* This was our main goal, so let's go on */
2886 if (f == SERVICE_SUCCESS)
2887 service_enter_start_post(s);
2889 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2892 assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2897 case SERVICE_RUNNING:
2898 service_enter_running(s, f);
2901 case SERVICE_STOP_SIGTERM:
2902 case SERVICE_STOP_SIGKILL:
2904 if (!control_pid_good(s))
2905 service_enter_stop_post(s, f);
2907 /* If there is still a control process, wait for that first */
2911 assert_not_reached("Uh, main process died at wrong time.");
2915 } else if (s->control_pid == pid) {
2919 if (s->control_command) {
2920 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2922 if (s->control_command->ignore)
2923 f = SERVICE_SUCCESS;
2926 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2927 "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2929 if (f != SERVICE_SUCCESS)
2932 /* Immediately get rid of the cgroup, so that the
2933 * kernel doesn't delay the cgroup empty messages for
2934 * the service cgroup any longer than necessary */
2935 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2937 if (s->control_command &&
2938 s->control_command->command_next &&
2939 f == SERVICE_SUCCESS) {
2941 /* There is another command to *
2942 * execute, so let's do that. */
2944 log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2945 service_run_next_control(s);
2948 /* No further commands for this step, so let's
2949 * figure out what to do next */
2951 s->control_command = NULL;
2952 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2954 log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2958 case SERVICE_START_PRE:
2959 if (f == SERVICE_SUCCESS)
2960 service_enter_start(s);
2962 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2966 assert(s->type == SERVICE_FORKING);
2968 if (f != SERVICE_SUCCESS) {
2969 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2974 bool has_start_post;
2977 /* Let's try to load the pid file here if we can.
2978 * The PID file might actually be created by a START_POST
2979 * script. In that case don't worry if the loading fails. */
2981 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2982 r = service_load_pid_file(s, !has_start_post);
2983 if (!has_start_post && r < 0) {
2984 r = service_demand_pid_file(s);
2985 if (r < 0 || !cgroup_good(s))
2986 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2990 service_search_main_pid(s);
2992 service_enter_start_post(s);
2995 case SERVICE_START_POST:
2996 if (f != SERVICE_SUCCESS) {
2997 service_enter_stop(s, f);
3004 r = service_load_pid_file(s, true);
3006 r = service_demand_pid_file(s);
3007 if (r < 0 || !cgroup_good(s))
3008 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3012 service_search_main_pid(s);
3014 service_enter_running(s, SERVICE_SUCCESS);
3017 case SERVICE_RELOAD:
3018 if (f == SERVICE_SUCCESS) {
3019 service_load_pid_file(s, true);
3020 service_search_main_pid(s);
3023 s->reload_result = f;
3024 service_enter_running(s, SERVICE_SUCCESS);
3028 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3031 case SERVICE_STOP_SIGTERM:
3032 case SERVICE_STOP_SIGKILL:
3033 if (main_pid_good(s) <= 0)
3034 service_enter_stop_post(s, f);
3036 /* If there is still a service
3037 * process around, wait until
3038 * that one quit, too */
3041 case SERVICE_STOP_POST:
3042 case SERVICE_FINAL_SIGTERM:
3043 case SERVICE_FINAL_SIGKILL:
3044 service_enter_dead(s, f, true);
3048 assert_not_reached("Uh, control process died at wrong time.");
3053 /* Notify clients about changed exit status */
3054 unit_add_to_dbus_queue(u);
3057 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3058 Service *s = SERVICE(u);
3061 assert(elapsed == 1);
3063 if (w == &s->watchdog_watch) {
3064 service_handle_watchdog(s);
3068 assert(w == &s->timer_watch);
3072 case SERVICE_START_PRE:
3074 log_warning("%s operation timed out. Terminating.", u->id);
3075 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3078 case SERVICE_START_POST:
3079 log_warning("%s operation timed out. Stopping.", u->id);
3080 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3083 case SERVICE_RELOAD:
3084 log_warning("%s operation timed out. Stopping.", u->id);
3085 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3086 service_enter_running(s, SERVICE_SUCCESS);
3090 log_warning("%s stopping timed out. Terminating.", u->id);
3091 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3094 case SERVICE_STOP_SIGTERM:
3095 if (s->exec_context.send_sigkill) {
3096 log_warning("%s stopping timed out. Killing.", u->id);
3097 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3099 log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3100 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3105 case SERVICE_STOP_SIGKILL:
3106 /* Uh, we sent a SIGKILL and it is still not gone?
3107 * Must be something we cannot kill, so let's just be
3108 * weirded out and continue */
3110 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3111 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3114 case SERVICE_STOP_POST:
3115 log_warning("%s stopping timed out (2). Terminating.", u->id);
3116 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3119 case SERVICE_FINAL_SIGTERM:
3120 if (s->exec_context.send_sigkill) {
3121 log_warning("%s stopping timed out (2). Killing.", u->id);
3122 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3124 log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3125 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3130 case SERVICE_FINAL_SIGKILL:
3131 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3132 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3135 case SERVICE_AUTO_RESTART:
3136 log_info("%s holdoff time over, scheduling restart.", u->id);
3137 service_enter_restart(s);
3141 assert_not_reached("Timeout at wrong time.");
3145 static void service_cgroup_notify_event(Unit *u) {
3146 Service *s = SERVICE(u);
3150 log_debug("%s: cgroup is empty", u->id);
3154 /* Waiting for SIGCHLD is usually more interesting,
3155 * because it includes return codes/signals. Which is
3156 * why we ignore the cgroup events for most cases,
3157 * except when we don't know pid which to expect the
3161 case SERVICE_START_POST:
3162 /* If we were hoping for the daemon to write its PID file,
3163 * we can give up now. */
3164 if (s->pid_file_pathspec) {
3165 log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3166 service_unwatch_pid_file(s);
3167 if (s->state == SERVICE_START)
3168 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3170 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3174 case SERVICE_RUNNING:
3175 /* service_enter_running() will figure out what to do */
3176 service_enter_running(s, SERVICE_SUCCESS);
3179 case SERVICE_STOP_SIGTERM:
3180 case SERVICE_STOP_SIGKILL:
3182 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3183 service_enter_stop_post(s, SERVICE_SUCCESS);
3187 case SERVICE_FINAL_SIGTERM:
3188 case SERVICE_FINAL_SIGKILL:
3189 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3190 service_enter_dead(s, SERVICE_SUCCESS, SERVICE_SUCCESS);
3199 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3200 Service *s = SERVICE(u);
3205 if (s->notify_access == NOTIFY_NONE) {
3206 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3207 u->id, (unsigned long) pid);
3211 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3212 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3213 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3217 log_debug("%s: Got message", u->id);
3219 /* Interpret MAINPID= */
3220 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3221 (s->state == SERVICE_START ||
3222 s->state == SERVICE_START_POST ||
3223 s->state == SERVICE_RUNNING ||
3224 s->state == SERVICE_RELOAD)) {
3226 if (parse_pid(e + 8, &pid) < 0)
3227 log_warning("Failed to parse notification message %s", e);
3229 log_debug("%s: got %s", u->id, e);
3230 service_set_main_pid(s, pid);
3234 /* Interpret READY= */
3235 if (s->type == SERVICE_NOTIFY &&
3236 s->state == SERVICE_START &&
3237 strv_find(tags, "READY=1")) {
3238 log_debug("%s: got READY=1", u->id);
3240 service_enter_start_post(s);
3243 /* Interpret STATUS= */
3244 e = strv_find_prefix(tags, "STATUS=");
3250 if (!utf8_is_valid(e+7)) {
3251 log_warning("Status message in notification is not UTF-8 clean.");
3257 log_error("Failed to allocate string.");
3261 log_debug("%s: got %s", u->id, e);
3263 free(s->status_text);
3266 free(s->status_text);
3267 s->status_text = NULL;
3271 if (strv_find(tags, "WATCHDOG=1")) {
3272 log_debug("%s: got WATCHDOG=1", u->id);
3273 service_reset_watchdog(s);
3276 /* Notify clients about changed status or main pid */
3277 unit_add_to_dbus_queue(u);
3280 #ifdef HAVE_SYSV_COMPAT
3283 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3287 if (!(f = fopen("/etc/insserv.conf", "re"))) {
3288 r = errno == ENOENT ? 0 : -errno;
3293 char l[LINE_MAX], *t;
3294 char **parsed = NULL;
3296 if (!fgets(l, sizeof(l), f)) {
3301 log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3306 if (*t != '$' && *t != '<')
3309 parsed = strv_split(t,WHITESPACE);
3310 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3311 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3314 if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3316 if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3318 char *dep = NULL, *name, **j;
3320 STRV_FOREACH (j, parsed+1) {
3329 if (sysv_translate_facility(name, NULL, &dep) < 0)
3332 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3347 static int service_enumerate(Manager *m) {
3351 char *path = NULL, *fpath = NULL, *name = NULL;
3352 Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3359 if (m->running_as != MANAGER_SYSTEM)
3362 zero(runlevel_services);
3364 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3365 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3369 path = join(*p, "/", rcnd_table[i].path, NULL);
3378 if (!(d = opendir(path))) {
3379 if (errno != ENOENT)
3380 log_warning("opendir() failed on %s: %s", path, strerror(errno));
3385 while ((de = readdir(d))) {
3388 if (ignore_file(de->d_name))
3391 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3394 if (strlen(de->d_name) < 4)
3397 a = undecchar(de->d_name[1]);
3398 b = undecchar(de->d_name[2]);
3404 fpath = join(path, "/", de->d_name, NULL);
3410 if (access(fpath, X_OK) < 0) {
3412 if (errno != ENOENT)
3413 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3419 if (!(name = sysv_translate_name(de->d_name + 3))) {
3424 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3425 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3429 if (de->d_name[0] == 'S') {
3431 if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3432 SERVICE(service)->sysv_start_priority_from_rcnd =
3433 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3435 SERVICE(service)->sysv_enabled = true;
3438 if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3441 if ((r = set_put(runlevel_services[i], service)) < 0)
3444 } else if (de->d_name[0] == 'K' &&
3445 (rcnd_table[i].type == RUNLEVEL_DOWN ||
3446 rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3448 if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3451 if ((r = set_put(shutdown_services, service)) < 0)
3457 /* Now we loaded all stubs and are aware of the lowest
3458 start-up priority for all services, not let's actually load
3459 the services, this will also tell us which services are
3460 actually native now */
3461 manager_dispatch_load_queue(m);
3463 /* If this is a native service, rely on native ways to pull in
3464 * a service, don't pull it in via sysv rcN.d links. */
3465 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3466 SET_FOREACH(service, runlevel_services[i], j) {
3467 service = unit_follow_merge(service);
3469 if (service->fragment_path)
3472 if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3476 /* We honour K links only for halt/reboot. For the normal
3477 * runlevels we assume the stop jobs will be implicitly added
3478 * by the core logic. Also, we don't really distinguish here
3479 * between the runlevels 0 and 6 and just add them to the
3480 * special shutdown target. On SUSE the boot.d/ runlevel is
3481 * also used for shutdown, so we add links for that too to the
3482 * shutdown target.*/
3483 SET_FOREACH(service, shutdown_services, j) {
3484 service = unit_follow_merge(service);
3486 if (service->fragment_path)
3489 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3496 sysv_facility_in_insserv_conf (m);
3504 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3505 set_free(runlevel_services[i]);
3506 set_free(shutdown_services);
3515 static void service_bus_name_owner_change(
3518 const char *old_owner,
3519 const char *new_owner) {
3521 Service *s = SERVICE(u);
3526 assert(streq(s->bus_name, name));
3527 assert(old_owner || new_owner);
3529 if (old_owner && new_owner)
3530 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3532 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3534 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3536 s->bus_name_good = !!new_owner;
3538 if (s->type == SERVICE_DBUS) {
3540 /* service_enter_running() will figure out what to
3542 if (s->state == SERVICE_RUNNING)
3543 service_enter_running(s, SERVICE_SUCCESS);
3544 else if (s->state == SERVICE_START && new_owner)
3545 service_enter_start_post(s);
3547 } else if (new_owner &&
3549 (s->state == SERVICE_START ||
3550 s->state == SERVICE_START_POST ||
3551 s->state == SERVICE_RUNNING ||
3552 s->state == SERVICE_RELOAD)) {
3554 /* Try to acquire PID from bus service */
3555 log_debug("Trying to acquire PID from D-Bus name...");
3557 bus_query_pid(u->manager, name);
3561 static void service_bus_query_pid_done(
3566 Service *s = SERVICE(u);
3571 log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3573 if (s->main_pid <= 0 &&
3574 (s->state == SERVICE_START ||
3575 s->state == SERVICE_START_POST ||
3576 s->state == SERVICE_RUNNING ||
3577 s->state == SERVICE_RELOAD))
3578 service_set_main_pid(s, pid);
3581 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3586 /* This is called by the socket code when instantiating a new
3587 * service for a stream socket and the socket needs to be
3590 if (UNIT(s)->load_state != UNIT_LOADED)
3593 if (s->socket_fd >= 0)
3596 if (s->state != SERVICE_DEAD)
3600 s->got_socket_fd = true;
3602 unit_ref_set(&s->accept_socket, UNIT(sock));
3604 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3607 static void service_reset_failed(Unit *u) {
3608 Service *s = SERVICE(u);
3612 if (s->state == SERVICE_FAILED)
3613 service_set_state(s, SERVICE_DEAD);
3615 s->result = SERVICE_SUCCESS;
3616 s->reload_result = SERVICE_SUCCESS;
3619 static bool service_need_daemon_reload(Unit *u) {
3620 Service *s = SERVICE(u);
3624 #ifdef HAVE_SYSV_COMPAT
3629 if (stat(s->sysv_path, &st) < 0)
3630 /* What, cannot access this anymore? */
3633 if (s->sysv_mtime > 0 &&
3634 timespec_load(&st.st_mtim) != s->sysv_mtime)
3642 static int service_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
3643 Service *s = SERVICE(u);
3645 Set *pid_set = NULL;
3649 if (s->main_pid <= 0 && who == KILL_MAIN) {
3650 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3654 if (s->control_pid <= 0 && who == KILL_CONTROL) {
3655 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3659 if (who == KILL_CONTROL || who == KILL_ALL)
3660 if (s->control_pid > 0)
3661 if (kill(s->control_pid, signo) < 0)
3664 if (who == KILL_MAIN || who == KILL_ALL)
3665 if (s->main_pid > 0)
3666 if (kill(s->main_pid, signo) < 0)
3669 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
3672 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
3675 /* Exclude the control/main pid from being killed via the cgroup */
3676 if (s->control_pid > 0)
3677 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
3682 if (s->main_pid > 0)
3683 if ((q = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0) {
3687 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
3689 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3700 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3701 [SERVICE_DEAD] = "dead",
3702 [SERVICE_START_PRE] = "start-pre",
3703 [SERVICE_START] = "start",
3704 [SERVICE_START_POST] = "start-post",
3705 [SERVICE_RUNNING] = "running",
3706 [SERVICE_EXITED] = "exited",
3707 [SERVICE_RELOAD] = "reload",
3708 [SERVICE_STOP] = "stop",
3709 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3710 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3711 [SERVICE_STOP_POST] = "stop-post",
3712 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3713 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3714 [SERVICE_FAILED] = "failed",
3715 [SERVICE_AUTO_RESTART] = "auto-restart",
3718 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3720 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3721 [SERVICE_RESTART_NO] = "no",
3722 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3723 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3724 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3725 [SERVICE_RESTART_ALWAYS] = "always"
3728 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3730 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3731 [SERVICE_SIMPLE] = "simple",
3732 [SERVICE_FORKING] = "forking",
3733 [SERVICE_ONESHOT] = "oneshot",
3734 [SERVICE_DBUS] = "dbus",
3735 [SERVICE_NOTIFY] = "notify",
3736 [SERVICE_IDLE] = "idle"
3739 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3741 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3742 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3743 [SERVICE_EXEC_START] = "ExecStart",
3744 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3745 [SERVICE_EXEC_RELOAD] = "ExecReload",
3746 [SERVICE_EXEC_STOP] = "ExecStop",
3747 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3750 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3752 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3753 [NOTIFY_NONE] = "none",
3754 [NOTIFY_MAIN] = "main",
3755 [NOTIFY_ALL] = "all"
3758 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3760 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3761 [SERVICE_SUCCESS] = "success",
3762 [SERVICE_FAILURE_RESOURCES] = "resources",
3763 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3764 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3765 [SERVICE_FAILURE_SIGNAL] = "signal",
3766 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3767 [SERVICE_FAILURE_WATCHDOG] = "watchdog"
3770 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3772 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3773 [SERVICE_START_LIMIT_NONE] = "none",
3774 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3775 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3776 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3778 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3780 const UnitVTable service_vtable = {
3781 .suffix = ".service",
3782 .object_size = sizeof(Service),
3788 .init = service_init,
3789 .done = service_done,
3790 .load = service_load,
3792 .coldplug = service_coldplug,
3794 .dump = service_dump,
3796 .start = service_start,
3797 .stop = service_stop,
3798 .reload = service_reload,
3800 .can_reload = service_can_reload,
3802 .kill = service_kill,
3804 .serialize = service_serialize,
3805 .deserialize_item = service_deserialize_item,
3807 .active_state = service_active_state,
3808 .sub_state_to_string = service_sub_state_to_string,
3810 .check_gc = service_check_gc,
3811 .check_snapshot = service_check_snapshot,
3813 .sigchld_event = service_sigchld_event,
3814 .timer_event = service_timer_event,
3815 .fd_event = service_fd_event,
3817 .reset_failed = service_reset_failed,
3819 .need_daemon_reload = service_need_daemon_reload,
3821 .cgroup_notify_empty = service_cgroup_notify_event,
3822 .notify_message = service_notify_message,
3824 .bus_name_owner_change = service_bus_name_owner_change,
3825 .bus_query_pid_done = service_bus_query_pid_done,
3827 .bus_interface = "org.freedesktop.systemd1.Service",
3828 .bus_message_handler = bus_service_message_handler,
3829 .bus_invalidating_properties = bus_service_invalidating_properties,
3831 #ifdef HAVE_SYSV_COMPAT
3832 .enumerate = service_enumerate,
3834 .status_message_formats = {
3835 .starting_stopping = {
3836 [0] = "Starting %s...",
3837 [1] = "Stopping %s...",
3839 .finished_start_job = {
3840 [JOB_DONE] = "Started %s.",
3841 [JOB_FAILED] = "Failed to start %s.",
3842 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3843 [JOB_TIMEOUT] = "Timed out starting %s.",
3845 .finished_stop_job = {
3846 [JOB_DONE] = "Stopped %s.",
3847 [JOB_FAILED] = "Stopped (with error) %s.",
3848 [JOB_TIMEOUT] = "Timed out stopping %s.",