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 /* Don't create restart jobs from here. */
2464 s->forbid_restart = true;
2467 if (s->state == SERVICE_STOP ||
2468 s->state == SERVICE_STOP_SIGTERM ||
2469 s->state == SERVICE_STOP_SIGKILL ||
2470 s->state == SERVICE_STOP_POST ||
2471 s->state == SERVICE_FINAL_SIGTERM ||
2472 s->state == SERVICE_FINAL_SIGKILL)
2475 /* A restart will be scheduled or is in progress. */
2476 if (s->state == SERVICE_AUTO_RESTART) {
2477 service_enter_dead(s, SERVICE_SUCCESS, false);
2481 /* If there's already something running we go directly into
2483 if (s->state == SERVICE_START_PRE ||
2484 s->state == SERVICE_START ||
2485 s->state == SERVICE_START_POST ||
2486 s->state == SERVICE_RELOAD) {
2487 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2491 assert(s->state == SERVICE_RUNNING ||
2492 s->state == SERVICE_EXITED);
2494 service_enter_stop(s, SERVICE_SUCCESS);
2498 static int service_reload(Unit *u) {
2499 Service *s = SERVICE(u);
2503 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2505 service_enter_reload(s);
2509 static bool service_can_reload(Unit *u) {
2510 Service *s = SERVICE(u);
2514 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2517 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2518 Service *s = SERVICE(u);
2524 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2525 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2526 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2528 if (s->control_pid > 0)
2529 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2531 if (s->main_pid_known && s->main_pid > 0)
2532 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2534 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2537 unit_serialize_item(u, f, "status-text", s->status_text);
2539 /* FIXME: There's a minor uncleanliness here: if there are
2540 * multiple commands attached here, we will start from the
2541 * first one again */
2542 if (s->control_command_id >= 0)
2543 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2545 if (s->socket_fd >= 0) {
2548 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2551 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2554 if (s->main_exec_status.pid > 0) {
2555 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2556 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2557 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2559 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2560 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2561 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2564 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2565 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2570 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2571 Service *s = SERVICE(u);
2578 if (streq(key, "state")) {
2581 if ((state = service_state_from_string(value)) < 0)
2582 log_debug("Failed to parse state value %s", value);
2584 s->deserialized_state = state;
2585 } else if (streq(key, "result")) {
2588 f = service_result_from_string(value);
2590 log_debug("Failed to parse result value %s", value);
2591 else if (f != SERVICE_SUCCESS)
2594 } else if (streq(key, "reload-result")) {
2597 f = service_result_from_string(value);
2599 log_debug("Failed to parse reload result value %s", value);
2600 else if (f != SERVICE_SUCCESS)
2601 s->reload_result = f;
2603 } else if (streq(key, "control-pid")) {
2606 if (parse_pid(value, &pid) < 0)
2607 log_debug("Failed to parse control-pid value %s", value);
2609 s->control_pid = pid;
2610 } else if (streq(key, "main-pid")) {
2613 if (parse_pid(value, &pid) < 0)
2614 log_debug("Failed to parse main-pid value %s", value);
2616 service_set_main_pid(s, (pid_t) pid);
2617 } else if (streq(key, "main-pid-known")) {
2620 if ((b = parse_boolean(value)) < 0)
2621 log_debug("Failed to parse main-pid-known value %s", value);
2623 s->main_pid_known = b;
2624 } else if (streq(key, "status-text")) {
2627 if ((t = strdup(value))) {
2628 free(s->status_text);
2632 } else if (streq(key, "control-command")) {
2633 ServiceExecCommand id;
2635 if ((id = service_exec_command_from_string(value)) < 0)
2636 log_debug("Failed to parse exec-command value %s", value);
2638 s->control_command_id = id;
2639 s->control_command = s->exec_command[id];
2641 } else if (streq(key, "socket-fd")) {
2644 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2645 log_debug("Failed to parse socket-fd value %s", value);
2648 if (s->socket_fd >= 0)
2649 close_nointr_nofail(s->socket_fd);
2650 s->socket_fd = fdset_remove(fds, fd);
2652 } else if (streq(key, "main-exec-status-pid")) {
2655 if (parse_pid(value, &pid) < 0)
2656 log_debug("Failed to parse main-exec-status-pid value %s", value);
2658 s->main_exec_status.pid = pid;
2659 } else if (streq(key, "main-exec-status-code")) {
2662 if (safe_atoi(value, &i) < 0)
2663 log_debug("Failed to parse main-exec-status-code value %s", value);
2665 s->main_exec_status.code = i;
2666 } else if (streq(key, "main-exec-status-status")) {
2669 if (safe_atoi(value, &i) < 0)
2670 log_debug("Failed to parse main-exec-status-status value %s", value);
2672 s->main_exec_status.status = i;
2673 } else if (streq(key, "main-exec-status-start"))
2674 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2675 else if (streq(key, "main-exec-status-exit"))
2676 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2677 else if (streq(key, "watchdog-timestamp"))
2678 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2680 log_debug("Unknown serialization key '%s'", key);
2685 static UnitActiveState service_active_state(Unit *u) {
2688 return state_translation_table[SERVICE(u)->state];
2691 static const char *service_sub_state_to_string(Unit *u) {
2694 return service_state_to_string(SERVICE(u)->state);
2697 static bool service_check_gc(Unit *u) {
2698 Service *s = SERVICE(u);
2702 /* Never clean up services that still have a process around,
2703 * even if the service is formally dead. */
2704 if (cgroup_good(s) > 0 ||
2705 main_pid_good(s) > 0 ||
2706 control_pid_good(s) > 0)
2709 #ifdef HAVE_SYSV_COMPAT
2717 static bool service_check_snapshot(Unit *u) {
2718 Service *s = SERVICE(u);
2722 return !s->got_socket_fd;
2725 static int service_retry_pid_file(Service *s) {
2728 assert(s->pid_file);
2729 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2731 r = service_load_pid_file(s, false);
2735 service_unwatch_pid_file(s);
2737 service_enter_running(s, SERVICE_SUCCESS);
2741 static int service_watch_pid_file(Service *s) {
2744 log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2745 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2749 /* the pidfile might have appeared just before we set the watch */
2750 service_retry_pid_file(s);
2754 log_error("Failed to set a watch for %s's PID file %s: %s",
2755 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2756 service_unwatch_pid_file(s);
2760 static int service_demand_pid_file(Service *s) {
2763 assert(s->pid_file);
2764 assert(!s->pid_file_pathspec);
2766 ps = new0(PathSpec, 1);
2770 ps->path = strdup(s->pid_file);
2776 path_kill_slashes(ps->path);
2778 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2779 * keep their PID file open all the time. */
2780 ps->type = PATH_MODIFIED;
2781 ps->inotify_fd = -1;
2783 s->pid_file_pathspec = ps;
2785 return service_watch_pid_file(s);
2788 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2789 Service *s = SERVICE(u);
2793 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2794 assert(s->pid_file_pathspec);
2795 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2797 log_debug("inotify event for %s", u->id);
2799 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2802 if (service_retry_pid_file(s) == 0)
2805 if (service_watch_pid_file(s) < 0)
2810 service_unwatch_pid_file(s);
2811 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2814 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2815 Service *s = SERVICE(u);
2821 if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2822 f = SERVICE_SUCCESS;
2823 else if (code == CLD_EXITED)
2824 f = SERVICE_FAILURE_EXIT_CODE;
2825 else if (code == CLD_KILLED)
2826 f = SERVICE_FAILURE_SIGNAL;
2827 else if (code == CLD_DUMPED)
2828 f = SERVICE_FAILURE_CORE_DUMP;
2830 assert_not_reached("Unknown code");
2832 if (s->main_pid == pid) {
2833 /* Forking services may occasionally move to a new PID.
2834 * As long as they update the PID file before exiting the old
2835 * PID, they're fine. */
2836 if (service_load_pid_file(s, false) == 0)
2840 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2842 /* If this is not a forking service than the main
2843 * process got started and hence we copy the exit
2844 * status so that it is recorded both as main and as
2845 * control process exit status */
2846 if (s->main_command) {
2847 s->main_command->exec_status = s->main_exec_status;
2849 if (s->main_command->ignore)
2850 f = SERVICE_SUCCESS;
2853 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2854 "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2856 if (f != SERVICE_SUCCESS)
2859 if (s->main_command &&
2860 s->main_command->command_next &&
2861 f == SERVICE_SUCCESS) {
2863 /* There is another command to *
2864 * execute, so let's do that. */
2866 log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2867 service_run_next_main(s);
2871 /* The service exited, so the service is officially
2873 s->main_command = NULL;
2877 case SERVICE_START_POST:
2878 case SERVICE_RELOAD:
2880 /* Need to wait until the operation is
2885 if (s->type == SERVICE_ONESHOT) {
2886 /* This was our main goal, so let's go on */
2887 if (f == SERVICE_SUCCESS)
2888 service_enter_start_post(s);
2890 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2893 assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2898 case SERVICE_RUNNING:
2899 service_enter_running(s, f);
2902 case SERVICE_STOP_SIGTERM:
2903 case SERVICE_STOP_SIGKILL:
2905 if (!control_pid_good(s))
2906 service_enter_stop_post(s, f);
2908 /* If there is still a control process, wait for that first */
2912 assert_not_reached("Uh, main process died at wrong time.");
2916 } else if (s->control_pid == pid) {
2920 if (s->control_command) {
2921 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2923 if (s->control_command->ignore)
2924 f = SERVICE_SUCCESS;
2927 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2928 "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2930 if (f != SERVICE_SUCCESS)
2933 /* Immediately get rid of the cgroup, so that the
2934 * kernel doesn't delay the cgroup empty messages for
2935 * the service cgroup any longer than necessary */
2936 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2938 if (s->control_command &&
2939 s->control_command->command_next &&
2940 f == SERVICE_SUCCESS) {
2942 /* There is another command to *
2943 * execute, so let's do that. */
2945 log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2946 service_run_next_control(s);
2949 /* No further commands for this step, so let's
2950 * figure out what to do next */
2952 s->control_command = NULL;
2953 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2955 log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2959 case SERVICE_START_PRE:
2960 if (f == SERVICE_SUCCESS)
2961 service_enter_start(s);
2963 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2967 assert(s->type == SERVICE_FORKING);
2969 if (f != SERVICE_SUCCESS) {
2970 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2975 bool has_start_post;
2978 /* Let's try to load the pid file here if we can.
2979 * The PID file might actually be created by a START_POST
2980 * script. In that case don't worry if the loading fails. */
2982 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2983 r = service_load_pid_file(s, !has_start_post);
2984 if (!has_start_post && r < 0) {
2985 r = service_demand_pid_file(s);
2986 if (r < 0 || !cgroup_good(s))
2987 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2991 service_search_main_pid(s);
2993 service_enter_start_post(s);
2996 case SERVICE_START_POST:
2997 if (f != SERVICE_SUCCESS) {
2998 service_enter_stop(s, f);
3005 r = service_load_pid_file(s, true);
3007 r = service_demand_pid_file(s);
3008 if (r < 0 || !cgroup_good(s))
3009 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3013 service_search_main_pid(s);
3015 service_enter_running(s, SERVICE_SUCCESS);
3018 case SERVICE_RELOAD:
3019 if (f == SERVICE_SUCCESS) {
3020 service_load_pid_file(s, true);
3021 service_search_main_pid(s);
3024 s->reload_result = f;
3025 service_enter_running(s, SERVICE_SUCCESS);
3029 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3032 case SERVICE_STOP_SIGTERM:
3033 case SERVICE_STOP_SIGKILL:
3034 if (main_pid_good(s) <= 0)
3035 service_enter_stop_post(s, f);
3037 /* If there is still a service
3038 * process around, wait until
3039 * that one quit, too */
3042 case SERVICE_STOP_POST:
3043 case SERVICE_FINAL_SIGTERM:
3044 case SERVICE_FINAL_SIGKILL:
3045 service_enter_dead(s, f, true);
3049 assert_not_reached("Uh, control process died at wrong time.");
3054 /* Notify clients about changed exit status */
3055 unit_add_to_dbus_queue(u);
3058 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3059 Service *s = SERVICE(u);
3062 assert(elapsed == 1);
3064 if (w == &s->watchdog_watch) {
3065 service_handle_watchdog(s);
3069 assert(w == &s->timer_watch);
3073 case SERVICE_START_PRE:
3075 log_warning("%s operation timed out. Terminating.", u->id);
3076 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3079 case SERVICE_START_POST:
3080 log_warning("%s operation timed out. Stopping.", u->id);
3081 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3084 case SERVICE_RELOAD:
3085 log_warning("%s operation timed out. Stopping.", u->id);
3086 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3087 service_enter_running(s, SERVICE_SUCCESS);
3091 log_warning("%s stopping timed out. Terminating.", u->id);
3092 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3095 case SERVICE_STOP_SIGTERM:
3096 if (s->exec_context.send_sigkill) {
3097 log_warning("%s stopping timed out. Killing.", u->id);
3098 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3100 log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3101 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3106 case SERVICE_STOP_SIGKILL:
3107 /* Uh, we sent a SIGKILL and it is still not gone?
3108 * Must be something we cannot kill, so let's just be
3109 * weirded out and continue */
3111 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3112 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3115 case SERVICE_STOP_POST:
3116 log_warning("%s stopping timed out (2). Terminating.", u->id);
3117 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3120 case SERVICE_FINAL_SIGTERM:
3121 if (s->exec_context.send_sigkill) {
3122 log_warning("%s stopping timed out (2). Killing.", u->id);
3123 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3125 log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3126 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3131 case SERVICE_FINAL_SIGKILL:
3132 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3133 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3136 case SERVICE_AUTO_RESTART:
3137 log_info("%s holdoff time over, scheduling restart.", u->id);
3138 service_enter_restart(s);
3142 assert_not_reached("Timeout at wrong time.");
3146 static void service_cgroup_notify_event(Unit *u) {
3147 Service *s = SERVICE(u);
3151 log_debug("%s: cgroup is empty", u->id);
3155 /* Waiting for SIGCHLD is usually more interesting,
3156 * because it includes return codes/signals. Which is
3157 * why we ignore the cgroup events for most cases,
3158 * except when we don't know pid which to expect the
3162 case SERVICE_START_POST:
3163 /* If we were hoping for the daemon to write its PID file,
3164 * we can give up now. */
3165 if (s->pid_file_pathspec) {
3166 log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3167 service_unwatch_pid_file(s);
3168 if (s->state == SERVICE_START)
3169 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3171 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3175 case SERVICE_RUNNING:
3176 /* service_enter_running() will figure out what to do */
3177 service_enter_running(s, SERVICE_SUCCESS);
3180 case SERVICE_STOP_SIGTERM:
3181 case SERVICE_STOP_SIGKILL:
3183 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3184 service_enter_stop_post(s, SERVICE_SUCCESS);
3188 case SERVICE_FINAL_SIGTERM:
3189 case SERVICE_FINAL_SIGKILL:
3190 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3191 service_enter_dead(s, SERVICE_SUCCESS, SERVICE_SUCCESS);
3200 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3201 Service *s = SERVICE(u);
3206 if (s->notify_access == NOTIFY_NONE) {
3207 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3208 u->id, (unsigned long) pid);
3212 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3213 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3214 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3218 log_debug("%s: Got message", u->id);
3220 /* Interpret MAINPID= */
3221 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3222 (s->state == SERVICE_START ||
3223 s->state == SERVICE_START_POST ||
3224 s->state == SERVICE_RUNNING ||
3225 s->state == SERVICE_RELOAD)) {
3227 if (parse_pid(e + 8, &pid) < 0)
3228 log_warning("Failed to parse notification message %s", e);
3230 log_debug("%s: got %s", u->id, e);
3231 service_set_main_pid(s, pid);
3235 /* Interpret READY= */
3236 if (s->type == SERVICE_NOTIFY &&
3237 s->state == SERVICE_START &&
3238 strv_find(tags, "READY=1")) {
3239 log_debug("%s: got READY=1", u->id);
3241 service_enter_start_post(s);
3244 /* Interpret STATUS= */
3245 e = strv_find_prefix(tags, "STATUS=");
3251 if (!utf8_is_valid(e+7)) {
3252 log_warning("Status message in notification is not UTF-8 clean.");
3258 log_error("Failed to allocate string.");
3262 log_debug("%s: got %s", u->id, e);
3264 free(s->status_text);
3267 free(s->status_text);
3268 s->status_text = NULL;
3272 if (strv_find(tags, "WATCHDOG=1")) {
3273 log_debug("%s: got WATCHDOG=1", u->id);
3274 service_reset_watchdog(s);
3277 /* Notify clients about changed status or main pid */
3278 unit_add_to_dbus_queue(u);
3281 #ifdef HAVE_SYSV_COMPAT
3284 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3288 if (!(f = fopen("/etc/insserv.conf", "re"))) {
3289 r = errno == ENOENT ? 0 : -errno;
3294 char l[LINE_MAX], *t;
3295 char **parsed = NULL;
3297 if (!fgets(l, sizeof(l), f)) {
3302 log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3307 if (*t != '$' && *t != '<')
3310 parsed = strv_split(t,WHITESPACE);
3311 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3312 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3315 if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3317 if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3319 char *dep = NULL, *name, **j;
3321 STRV_FOREACH (j, parsed+1) {
3330 if (sysv_translate_facility(name, NULL, &dep) < 0)
3333 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3348 static int service_enumerate(Manager *m) {
3352 char *path = NULL, *fpath = NULL, *name = NULL;
3353 Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3360 if (m->running_as != MANAGER_SYSTEM)
3363 zero(runlevel_services);
3365 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3366 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3370 path = join(*p, "/", rcnd_table[i].path, NULL);
3379 if (!(d = opendir(path))) {
3380 if (errno != ENOENT)
3381 log_warning("opendir() failed on %s: %s", path, strerror(errno));
3386 while ((de = readdir(d))) {
3389 if (ignore_file(de->d_name))
3392 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3395 if (strlen(de->d_name) < 4)
3398 a = undecchar(de->d_name[1]);
3399 b = undecchar(de->d_name[2]);
3405 fpath = join(path, "/", de->d_name, NULL);
3411 if (access(fpath, X_OK) < 0) {
3413 if (errno != ENOENT)
3414 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3420 if (!(name = sysv_translate_name(de->d_name + 3))) {
3425 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3426 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3430 if (de->d_name[0] == 'S') {
3432 if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3433 SERVICE(service)->sysv_start_priority_from_rcnd =
3434 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3436 SERVICE(service)->sysv_enabled = true;
3439 if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3442 if ((r = set_put(runlevel_services[i], service)) < 0)
3445 } else if (de->d_name[0] == 'K' &&
3446 (rcnd_table[i].type == RUNLEVEL_DOWN ||
3447 rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3449 if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3452 if ((r = set_put(shutdown_services, service)) < 0)
3458 /* Now we loaded all stubs and are aware of the lowest
3459 start-up priority for all services, not let's actually load
3460 the services, this will also tell us which services are
3461 actually native now */
3462 manager_dispatch_load_queue(m);
3464 /* If this is a native service, rely on native ways to pull in
3465 * a service, don't pull it in via sysv rcN.d links. */
3466 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3467 SET_FOREACH(service, runlevel_services[i], j) {
3468 service = unit_follow_merge(service);
3470 if (service->fragment_path)
3473 if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3477 /* We honour K links only for halt/reboot. For the normal
3478 * runlevels we assume the stop jobs will be implicitly added
3479 * by the core logic. Also, we don't really distinguish here
3480 * between the runlevels 0 and 6 and just add them to the
3481 * special shutdown target. On SUSE the boot.d/ runlevel is
3482 * also used for shutdown, so we add links for that too to the
3483 * shutdown target.*/
3484 SET_FOREACH(service, shutdown_services, j) {
3485 service = unit_follow_merge(service);
3487 if (service->fragment_path)
3490 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3497 sysv_facility_in_insserv_conf (m);
3505 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3506 set_free(runlevel_services[i]);
3507 set_free(shutdown_services);
3516 static void service_bus_name_owner_change(
3519 const char *old_owner,
3520 const char *new_owner) {
3522 Service *s = SERVICE(u);
3527 assert(streq(s->bus_name, name));
3528 assert(old_owner || new_owner);
3530 if (old_owner && new_owner)
3531 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3533 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3535 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3537 s->bus_name_good = !!new_owner;
3539 if (s->type == SERVICE_DBUS) {
3541 /* service_enter_running() will figure out what to
3543 if (s->state == SERVICE_RUNNING)
3544 service_enter_running(s, SERVICE_SUCCESS);
3545 else if (s->state == SERVICE_START && new_owner)
3546 service_enter_start_post(s);
3548 } else if (new_owner &&
3550 (s->state == SERVICE_START ||
3551 s->state == SERVICE_START_POST ||
3552 s->state == SERVICE_RUNNING ||
3553 s->state == SERVICE_RELOAD)) {
3555 /* Try to acquire PID from bus service */
3556 log_debug("Trying to acquire PID from D-Bus name...");
3558 bus_query_pid(u->manager, name);
3562 static void service_bus_query_pid_done(
3567 Service *s = SERVICE(u);
3572 log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3574 if (s->main_pid <= 0 &&
3575 (s->state == SERVICE_START ||
3576 s->state == SERVICE_START_POST ||
3577 s->state == SERVICE_RUNNING ||
3578 s->state == SERVICE_RELOAD))
3579 service_set_main_pid(s, pid);
3582 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3587 /* This is called by the socket code when instantiating a new
3588 * service for a stream socket and the socket needs to be
3591 if (UNIT(s)->load_state != UNIT_LOADED)
3594 if (s->socket_fd >= 0)
3597 if (s->state != SERVICE_DEAD)
3601 s->got_socket_fd = true;
3603 unit_ref_set(&s->accept_socket, UNIT(sock));
3605 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3608 static void service_reset_failed(Unit *u) {
3609 Service *s = SERVICE(u);
3613 if (s->state == SERVICE_FAILED)
3614 service_set_state(s, SERVICE_DEAD);
3616 s->result = SERVICE_SUCCESS;
3617 s->reload_result = SERVICE_SUCCESS;
3620 static bool service_need_daemon_reload(Unit *u) {
3621 Service *s = SERVICE(u);
3625 #ifdef HAVE_SYSV_COMPAT
3630 if (stat(s->sysv_path, &st) < 0)
3631 /* What, cannot access this anymore? */
3634 if (s->sysv_mtime > 0 &&
3635 timespec_load(&st.st_mtim) != s->sysv_mtime)
3643 static int service_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
3644 Service *s = SERVICE(u);
3646 Set *pid_set = NULL;
3650 if (s->main_pid <= 0 && who == KILL_MAIN) {
3651 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3655 if (s->control_pid <= 0 && who == KILL_CONTROL) {
3656 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3660 if (who == KILL_CONTROL || who == KILL_ALL)
3661 if (s->control_pid > 0)
3662 if (kill(s->control_pid, signo) < 0)
3665 if (who == KILL_MAIN || who == KILL_ALL)
3666 if (s->main_pid > 0)
3667 if (kill(s->main_pid, signo) < 0)
3670 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
3673 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
3676 /* Exclude the control/main pid from being killed via the cgroup */
3677 if (s->control_pid > 0)
3678 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
3683 if (s->main_pid > 0)
3684 if ((q = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0) {
3688 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
3690 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3701 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3702 [SERVICE_DEAD] = "dead",
3703 [SERVICE_START_PRE] = "start-pre",
3704 [SERVICE_START] = "start",
3705 [SERVICE_START_POST] = "start-post",
3706 [SERVICE_RUNNING] = "running",
3707 [SERVICE_EXITED] = "exited",
3708 [SERVICE_RELOAD] = "reload",
3709 [SERVICE_STOP] = "stop",
3710 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3711 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3712 [SERVICE_STOP_POST] = "stop-post",
3713 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3714 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3715 [SERVICE_FAILED] = "failed",
3716 [SERVICE_AUTO_RESTART] = "auto-restart",
3719 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3721 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3722 [SERVICE_RESTART_NO] = "no",
3723 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3724 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3725 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3726 [SERVICE_RESTART_ALWAYS] = "always"
3729 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3731 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3732 [SERVICE_SIMPLE] = "simple",
3733 [SERVICE_FORKING] = "forking",
3734 [SERVICE_ONESHOT] = "oneshot",
3735 [SERVICE_DBUS] = "dbus",
3736 [SERVICE_NOTIFY] = "notify",
3737 [SERVICE_IDLE] = "idle"
3740 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3742 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3743 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3744 [SERVICE_EXEC_START] = "ExecStart",
3745 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3746 [SERVICE_EXEC_RELOAD] = "ExecReload",
3747 [SERVICE_EXEC_STOP] = "ExecStop",
3748 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3751 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3753 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3754 [NOTIFY_NONE] = "none",
3755 [NOTIFY_MAIN] = "main",
3756 [NOTIFY_ALL] = "all"
3759 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3761 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3762 [SERVICE_SUCCESS] = "success",
3763 [SERVICE_FAILURE_RESOURCES] = "resources",
3764 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3765 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3766 [SERVICE_FAILURE_SIGNAL] = "signal",
3767 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3768 [SERVICE_FAILURE_WATCHDOG] = "watchdog"
3771 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3773 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3774 [SERVICE_START_LIMIT_NONE] = "none",
3775 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3776 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3777 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3779 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3781 const UnitVTable service_vtable = {
3782 .suffix = ".service",
3783 .object_size = sizeof(Service),
3789 .init = service_init,
3790 .done = service_done,
3791 .load = service_load,
3793 .coldplug = service_coldplug,
3795 .dump = service_dump,
3797 .start = service_start,
3798 .stop = service_stop,
3799 .reload = service_reload,
3801 .can_reload = service_can_reload,
3803 .kill = service_kill,
3805 .serialize = service_serialize,
3806 .deserialize_item = service_deserialize_item,
3808 .active_state = service_active_state,
3809 .sub_state_to_string = service_sub_state_to_string,
3811 .check_gc = service_check_gc,
3812 .check_snapshot = service_check_snapshot,
3814 .sigchld_event = service_sigchld_event,
3815 .timer_event = service_timer_event,
3816 .fd_event = service_fd_event,
3818 .reset_failed = service_reset_failed,
3820 .need_daemon_reload = service_need_daemon_reload,
3822 .cgroup_notify_empty = service_cgroup_notify_event,
3823 .notify_message = service_notify_message,
3825 .bus_name_owner_change = service_bus_name_owner_change,
3826 .bus_query_pid_done = service_bus_query_pid_done,
3828 .bus_interface = "org.freedesktop.systemd1.Service",
3829 .bus_message_handler = bus_service_message_handler,
3830 .bus_invalidating_properties = bus_service_invalidating_properties,
3832 #ifdef HAVE_SYSV_COMPAT
3833 .enumerate = service_enumerate,
3835 .status_message_formats = {
3836 .starting_stopping = {
3837 [0] = "Starting %s...",
3838 [1] = "Stopping %s...",
3840 .finished_start_job = {
3841 [JOB_DONE] = "Started %s.",
3842 [JOB_FAILED] = "Failed to start %s.",
3843 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3844 [JOB_TIMEOUT] = "Timed out starting %s.",
3846 .finished_stop_job = {
3847 [JOB_DONE] = "Stopped %s.",
3848 [JOB_FAILED] = "Stopped (with error) %s.",
3849 [JOB_TIMEOUT] = "Timed out stopping %s.",