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 "unit-printf.h"
37 #include "dbus-service.h"
39 #include "bus-errors.h"
40 #include "exit-status.h"
42 #include "path-util.h"
46 #ifdef HAVE_SYSV_COMPAT
48 #define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
50 typedef enum RunlevelType {
59 const RunlevelType type;
61 /* Standard SysV runlevels for start-up */
62 { "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
63 { "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
64 { "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
65 { "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
66 { "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
69 /* SUSE style boot.d */
70 { "boot.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
73 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
74 /* Debian style rcS.d */
75 { "rcS.d", SPECIAL_SYSINIT_TARGET, RUNLEVEL_SYSINIT },
78 /* Standard SysV runlevels for shutdown */
79 { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
80 { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
82 /* Note that the order here matters, as we read the
83 directories in this order, and we want to make sure that
84 sysv_start_priority is known when we first load the
85 unit. And that value we only know from S links. Hence
86 UP/SYSINIT must be read before DOWN */
89 #define RUNLEVELS_UP "12345"
90 /* #define RUNLEVELS_DOWN "06" */
91 #define RUNLEVELS_BOOT "bBsS"
94 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
95 [SERVICE_DEAD] = UNIT_INACTIVE,
96 [SERVICE_START_PRE] = UNIT_ACTIVATING,
97 [SERVICE_START] = UNIT_ACTIVATING,
98 [SERVICE_START_POST] = UNIT_ACTIVATING,
99 [SERVICE_RUNNING] = UNIT_ACTIVE,
100 [SERVICE_EXITED] = UNIT_ACTIVE,
101 [SERVICE_RELOAD] = UNIT_RELOADING,
102 [SERVICE_STOP] = UNIT_DEACTIVATING,
103 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
104 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
105 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
106 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
107 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
108 [SERVICE_FAILED] = UNIT_FAILED,
109 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
112 /* For Type=idle we never want to delay any other jobs, hence we
113 * consider idle jobs active as soon as we start working on them */
114 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
115 [SERVICE_DEAD] = UNIT_INACTIVE,
116 [SERVICE_START_PRE] = UNIT_ACTIVE,
117 [SERVICE_START] = UNIT_ACTIVE,
118 [SERVICE_START_POST] = UNIT_ACTIVE,
119 [SERVICE_RUNNING] = UNIT_ACTIVE,
120 [SERVICE_EXITED] = UNIT_ACTIVE,
121 [SERVICE_RELOAD] = UNIT_RELOADING,
122 [SERVICE_STOP] = UNIT_DEACTIVATING,
123 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
124 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
125 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
126 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
127 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
128 [SERVICE_FAILED] = UNIT_FAILED,
129 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
132 static void service_init(Unit *u) {
133 Service *s = SERVICE(u);
136 assert(u->load_state == UNIT_STUB);
138 s->timeout_start_usec = DEFAULT_TIMEOUT_USEC;
139 s->timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
140 s->restart_usec = DEFAULT_RESTART_USEC;
141 s->type = _SERVICE_TYPE_INVALID;
143 s->watchdog_watch.type = WATCH_INVALID;
145 s->timer_watch.type = WATCH_INVALID;
146 #ifdef HAVE_SYSV_COMPAT
147 s->sysv_start_priority = -1;
148 s->sysv_start_priority_from_rcnd = -1;
151 s->guess_main_pid = true;
153 exec_context_init(&s->exec_context);
154 kill_context_init(&s->kill_context);
156 RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
158 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
161 static void service_unwatch_control_pid(Service *s) {
164 if (s->control_pid <= 0)
167 unit_unwatch_pid(UNIT(s), s->control_pid);
171 static void service_unwatch_main_pid(Service *s) {
174 if (s->main_pid <= 0)
177 unit_unwatch_pid(UNIT(s), s->main_pid);
181 static void service_unwatch_pid_file(Service *s) {
182 if (!s->pid_file_pathspec)
185 log_debug("Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
186 path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
187 path_spec_done(s->pid_file_pathspec);
188 free(s->pid_file_pathspec);
189 s->pid_file_pathspec = NULL;
192 static int service_set_main_pid(Service *s, pid_t pid) {
204 s->main_pid_known = true;
206 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
207 log_warning("%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
208 UNIT(s)->id, (unsigned long) pid);
210 s->main_pid_alien = true;
212 s->main_pid_alien = false;
214 exec_status_start(&s->main_exec_status, pid);
219 static void service_close_socket_fd(Service *s) {
222 if (s->socket_fd < 0)
225 close_nointr_nofail(s->socket_fd);
229 static void service_connection_unref(Service *s) {
232 if (!UNIT_DEREF(s->accept_socket))
235 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
236 unit_ref_unset(&s->accept_socket);
239 static void service_stop_watchdog(Service *s) {
242 unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
243 s->watchdog_timestamp.realtime = 0;
244 s->watchdog_timestamp.monotonic = 0;
247 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart);
249 static void service_handle_watchdog(Service *s) {
255 if (s->watchdog_usec == 0)
258 offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
259 if (offset >= s->watchdog_usec) {
260 log_error("%s watchdog timeout!", UNIT(s)->id);
261 service_enter_dead(s, SERVICE_FAILURE_WATCHDOG, true);
265 r = unit_watch_timer(UNIT(s), s->watchdog_usec - offset, &s->watchdog_watch);
267 log_warning("%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
270 static void service_reset_watchdog(Service *s) {
273 dual_timestamp_get(&s->watchdog_timestamp);
274 service_handle_watchdog(s);
277 static void service_done(Unit *u) {
278 Service *s = SERVICE(u);
285 #ifdef HAVE_SYSV_COMPAT
286 free(s->sysv_runlevels);
287 s->sysv_runlevels = NULL;
290 free(s->status_text);
291 s->status_text = NULL;
293 exec_context_done(&s->exec_context);
294 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
295 s->control_command = NULL;
296 s->main_command = NULL;
298 set_free(s->restart_ignore_status.code);
299 s->restart_ignore_status.code = NULL;
300 set_free(s->restart_ignore_status.signal);
301 s->restart_ignore_status.signal = NULL;
303 set_free(s->success_status.code);
304 s->success_status.code = NULL;
305 set_free(s->success_status.signal);
306 s->success_status.signal = NULL;
308 /* This will leak a process, but at least no memory or any of
310 service_unwatch_main_pid(s);
311 service_unwatch_control_pid(s);
312 service_unwatch_pid_file(s);
315 unit_unwatch_bus_name(u, s->bus_name);
320 service_close_socket_fd(s);
321 service_connection_unref(s);
323 unit_ref_unset(&s->accept_socket);
325 service_stop_watchdog(s);
327 unit_unwatch_timer(u, &s->timer_watch);
330 #ifdef HAVE_SYSV_COMPAT
331 static char *sysv_translate_name(const char *name) {
334 if (!(r = new(char, strlen(name) + sizeof(".service"))))
337 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
338 if (endswith(name, ".sh"))
339 /* Drop Debian-style .sh suffix */
340 strcpy(stpcpy(r, name) - 3, ".service");
343 if (startswith(name, "boot."))
344 /* Drop SuSE-style boot. prefix */
345 strcpy(stpcpy(r, name + 5), ".service");
347 #ifdef TARGET_FRUGALWARE
348 if (startswith(name, "rc."))
349 /* Drop Frugalware-style rc. prefix */
350 strcpy(stpcpy(r, name + 3), ".service");
353 /* Normal init scripts */
354 strcpy(stpcpy(r, name), ".service");
359 static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
361 /* We silently ignore the $ prefix here. According to the LSB
362 * spec it simply indicates whether something is a
363 * standardized name or a distribution-specific one. Since we
364 * just follow what already exists and do not introduce new
365 * uses or names we don't care who introduced a new name. */
367 static const char * const table[] = {
368 /* LSB defined facilities */
369 "local_fs", SPECIAL_LOCAL_FS_TARGET,
370 #if defined(TARGET_MANDRIVA) || defined(TARGET_MAGEIA)
372 /* Due to unfortunate name selection in Mandriva,
373 * $network is provided by network-up which is ordered
374 * after network which actually starts interfaces.
375 * To break the loop, just ignore it */
376 "network", SPECIAL_NETWORK_TARGET,
378 "named", SPECIAL_NSS_LOOKUP_TARGET,
379 "portmap", SPECIAL_RPCBIND_TARGET,
380 "remote_fs", SPECIAL_REMOTE_FS_TARGET,
381 "syslog", SPECIAL_SYSLOG_TARGET,
382 "time", SPECIAL_TIME_SYNC_TARGET,
384 /* common extensions */
385 "mail-transfer-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
386 "x-display-manager", SPECIAL_DISPLAY_MANAGER_SERVICE,
389 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
390 "mail-transport-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
394 "MTA", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
395 "smtpdaemon", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
396 "httpd", SPECIAL_HTTP_DAEMON_TARGET,
400 "smtp", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
411 n = *name == '$' ? name + 1 : name;
413 for (i = 0; i < ELEMENTSOF(table); i += 2) {
415 if (!streq(table[i], n))
421 if (!(r = strdup(table[i+1])))
427 /* If we don't know this name, fallback heuristics to figure
428 * out whether something is a target or a service alias. */
431 if (!unit_prefix_is_valid(n))
434 /* Facilities starting with $ are most likely targets */
435 r = unit_name_build(n, NULL, ".target");
436 } else if (filename && streq(name, filename))
437 /* Names equaling the file name of the services are redundant */
440 /* Everything else we assume to be normal service names */
441 r = sysv_translate_name(n);
452 static int sysv_fix_order(Service *s) {
458 if (s->sysv_start_priority < 0)
461 /* For each pair of services where at least one lacks a LSB
462 * header, we use the start priority value to order things. */
464 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
467 bool special_s, special_t;
474 if (UNIT(t)->load_state != UNIT_LOADED)
477 if (t->sysv_start_priority < 0)
480 /* If both units have modern headers we don't care
481 * about the priorities */
482 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
483 (UNIT(t)->fragment_path || t->sysv_has_lsb))
486 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
487 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
489 if (special_t && !special_s)
491 else if (special_s && !special_t)
493 else if (t->sysv_start_priority < s->sysv_start_priority)
495 else if (t->sysv_start_priority > s->sysv_start_priority)
500 /* FIXME: Maybe we should compare the name here lexicographically? */
502 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
509 static ExecCommand *exec_command_new(const char *path, const char *arg1) {
512 if (!(c = new0(ExecCommand, 1)))
515 if (!(c->path = strdup(path))) {
520 if (!(c->argv = strv_new(path, arg1, NULL))) {
529 static int sysv_exec_commands(Service *s) {
534 assert(UNIT(s)->source_path);
536 c = exec_command_new(UNIT(s)->source_path, "start");
539 exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
541 c = exec_command_new(UNIT(s)->source_path, "stop");
544 exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
546 c = exec_command_new(UNIT(s)->source_path, "reload");
549 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
554 static int service_load_sysv_path(Service *s, const char *path) {
565 char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
573 f = fopen(path, "re");
575 r = errno == ENOENT ? 0 : -errno;
579 if (fstat(fileno(f), &st) < 0) {
584 free(u->source_path);
585 u->source_path = strdup(path);
586 if (!u->source_path) {
590 u->source_mtime = timespec_load(&st.st_mtim);
592 if (null_or_empty(&st)) {
593 u->load_state = UNIT_MASKED;
601 char l[LINE_MAX], *t;
603 if (!fgets(l, sizeof(l), f)) {
608 log_error("Failed to read configuration file '%s': %s", path, strerror(-r));
618 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
620 s->sysv_has_lsb = true;
624 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
630 t += strspn(t, WHITESPACE);
632 if (state == NORMAL) {
634 /* Try to parse Red Hat style chkconfig headers */
636 if (startswith_no_case(t, "chkconfig:")) {
638 char runlevels[16], *k;
642 if (sscanf(t+10, "%15s %i %*i",
644 &start_priority) != 2) {
646 log_warning("[%s:%u] Failed to parse chkconfig line. Ignoring.", path, line);
650 /* A start priority gathered from the
651 * symlink farms is preferred over the
652 * data from the LSB header. */
653 if (start_priority < 0 || start_priority > 99)
654 log_warning("[%s:%u] Start priority out of range. Ignoring.", path, line);
656 s->sysv_start_priority = start_priority;
658 char_array_0(runlevels);
659 k = delete_chars(runlevels, WHITESPACE "-");
664 if (!(d = strdup(k))) {
669 free(s->sysv_runlevels);
670 s->sysv_runlevels = d;
673 } else if (startswith_no_case(t, "description:")) {
675 size_t k = strlen(t);
679 if (t[k-1] == '\\') {
684 if ((j = strstrip(t+12)) && *j) {
685 if (!(d = strdup(j))) {
692 free(chkconfig_description);
693 chkconfig_description = d;
695 } else if (startswith_no_case(t, "pidfile:")) {
702 if (!path_is_absolute(fn)) {
703 log_warning("[%s:%u] PID file not absolute. Ignoring.", path, line);
707 if (!(fn = strdup(fn))) {
716 } else if (state == DESCRIPTION) {
718 /* Try to parse Red Hat style description
721 size_t k = strlen(t);
729 if ((j = strstrip(t)) && *j) {
732 if (chkconfig_description)
733 d = strjoin(chkconfig_description, " ", j, NULL);
742 free(chkconfig_description);
743 chkconfig_description = d;
746 } else if (state == LSB || state == LSB_DESCRIPTION) {
748 if (startswith_no_case(t, "Provides:")) {
754 FOREACH_WORD_QUOTED(w, z, t+9, i) {
757 if (!(n = strndup(w, z))) {
762 r = sysv_translate_facility(n, path_get_file_name(path), &m);
771 if (unit_name_to_type(m) == UNIT_SERVICE)
772 r = unit_add_name(u, m);
779 * indication that the
781 * now available. This
784 * targets do NOT pull
787 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
790 log_error("[%s:%u] Failed to add LSB Provides name %s, ignoring: %s", path, line, m, strerror(-r));
795 } else if (startswith_no_case(t, "Required-Start:") ||
796 startswith_no_case(t, "Should-Start:") ||
797 startswith_no_case(t, "X-Start-Before:") ||
798 startswith_no_case(t, "X-Start-After:")) {
804 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
807 if (!(n = strndup(w, z))) {
812 r = sysv_translate_facility(n, path_get_file_name(path), &m);
815 log_error("[%s:%u] Failed to translate LSB dependency %s, ignoring: %s", path, line, n, strerror(-r));
825 r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
828 log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", path, line, m, strerror(-r));
832 } else if (startswith_no_case(t, "Default-Start:")) {
837 k = delete_chars(t+14, WHITESPACE "-");
840 if (!(d = strdup(k))) {
845 free(s->sysv_runlevels);
846 s->sysv_runlevels = d;
849 } else if (startswith_no_case(t, "Description:")) {
852 state = LSB_DESCRIPTION;
854 if ((j = strstrip(t+12)) && *j) {
855 if (!(d = strdup(j))) {
862 free(long_description);
863 long_description = d;
865 } else if (startswith_no_case(t, "Short-Description:")) {
870 if ((j = strstrip(t+18)) && *j) {
871 if (!(d = strdup(j))) {
878 free(short_description);
879 short_description = d;
881 } else if (state == LSB_DESCRIPTION) {
883 if (startswith(l, "#\t") || startswith(l, "# ")) {
886 if ((j = strstrip(t)) && *j) {
889 if (long_description)
890 d = strjoin(long_description, " ", t, NULL);
899 free(long_description);
900 long_description = d;
909 if ((r = sysv_exec_commands(s)) < 0)
911 if (s->sysv_runlevels &&
912 chars_intersect(RUNLEVELS_BOOT, s->sysv_runlevels) &&
913 chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
914 /* Service has both boot and "up" runlevels
915 configured. Kill the "up" ones. */
916 delete_chars(s->sysv_runlevels, RUNLEVELS_UP);
919 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
920 /* If there a runlevels configured for this service
921 * but none of the standard ones, then we assume this
922 * is some special kind of service (which might be
923 * needed for early boot) and don't create any links
926 UNIT(s)->default_dependencies = false;
928 /* Don't timeout special services during boot (like fsck) */
929 s->timeout_start_usec = 0;
930 s->timeout_stop_usec = 0;
932 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
933 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
936 /* Special setting for all SysV services */
937 s->type = SERVICE_FORKING;
938 s->remain_after_exit = !s->pid_file;
939 s->guess_main_pid = false;
940 s->restart = SERVICE_RESTART_NO;
941 s->exec_context.ignore_sigpipe = false;
942 s->kill_context.kill_mode = KILL_PROCESS;
944 /* We use the long description only if
945 * no short description is set. */
947 if (short_description)
948 description = short_description;
949 else if (chkconfig_description)
950 description = chkconfig_description;
951 else if (long_description)
952 description = long_description;
959 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
967 /* The priority that has been set in /etc/rcN.d/ hierarchies
968 * takes precedence over what is stored as default in the LSB
970 if (s->sysv_start_priority_from_rcnd >= 0)
971 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
973 u->load_state = UNIT_LOADED;
981 free(short_description);
982 free(long_description);
983 free(chkconfig_description);
988 static int service_load_sysv_name(Service *s, const char *name) {
994 /* For SysV services we strip the boot.*, rc.* and *.sh
995 * prefixes/suffixes. */
996 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
997 if (endswith(name, ".sh.service"))
1002 if (startswith(name, "boot."))
1006 #ifdef TARGET_FRUGALWARE
1007 if (startswith(name, "rc."))
1011 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
1015 path = strjoin(*p, "/", name, NULL);
1019 assert(endswith(path, ".service"));
1020 path[strlen(path)-8] = 0;
1022 r = service_load_sysv_path(s, path);
1024 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
1025 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1026 /* Try Debian style *.sh source'able init scripts */
1027 strcat(path, ".sh");
1028 r = service_load_sysv_path(s, path);
1034 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1035 /* Try SUSE style boot.* init scripts */
1037 path = strjoin(*p, "/boot.", name, NULL);
1041 /* Drop .service suffix */
1042 path[strlen(path)-8] = 0;
1043 r = service_load_sysv_path(s, path);
1048 #ifdef TARGET_FRUGALWARE
1049 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1050 /* Try Frugalware style rc.* init scripts */
1052 path = strjoin(*p, "/rc.", name, NULL);
1056 /* Drop .service suffix */
1057 path[strlen(path)-8] = 0;
1058 r = service_load_sysv_path(s, path);
1066 if ((UNIT(s)->load_state != UNIT_STUB))
1073 static int service_load_sysv(Service *s) {
1080 /* Load service data from SysV init scripts, preferably with
1081 * LSB headers ... */
1083 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1086 if ((t = UNIT(s)->id))
1087 if ((r = service_load_sysv_name(s, t)) < 0)
1090 if (UNIT(s)->load_state == UNIT_STUB)
1091 SET_FOREACH(t, UNIT(s)->names, i) {
1092 if (t == UNIT(s)->id)
1095 if ((r = service_load_sysv_name(s, t)) < 0)
1098 if (UNIT(s)->load_state != UNIT_STUB)
1106 static int fsck_fix_order(Service *s) {
1112 if (s->fsck_passno <= 0)
1115 /* For each pair of services where both have an fsck priority
1116 * we order things based on it. */
1118 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
1127 if (UNIT(t)->load_state != UNIT_LOADED)
1130 if (t->fsck_passno <= 0)
1133 if (t->fsck_passno < s->fsck_passno)
1135 else if (t->fsck_passno > s->fsck_passno)
1140 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
1147 static int service_verify(Service *s) {
1150 if (UNIT(s)->load_state != UNIT_LOADED)
1153 if (!s->exec_command[SERVICE_EXEC_START]) {
1154 log_error("%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1158 if (s->type != SERVICE_ONESHOT &&
1159 s->exec_command[SERVICE_EXEC_START]->command_next) {
1160 log_error("%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1164 if (s->type == SERVICE_ONESHOT &&
1165 s->exec_command[SERVICE_EXEC_RELOAD]) {
1166 log_error("%s has an ExecReload setting, which is not allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1170 if (s->type == SERVICE_DBUS && !s->bus_name) {
1171 log_error("%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1175 if (s->bus_name && s->type != SERVICE_DBUS)
1176 log_warning("%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1178 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
1179 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1186 static int service_add_default_dependencies(Service *s) {
1191 /* Add a number of automatic dependencies useful for the
1192 * majority of services. */
1194 /* First, pull in base system */
1195 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
1197 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
1200 } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
1202 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
1206 /* Second, activate normal shutdown */
1207 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
1210 static void service_fix_output(Service *s) {
1213 /* If nothing has been explicitly configured, patch default
1214 * output in. If input is socket/tty we avoid this however,
1215 * since in that case we want output to default to the same
1216 * place as we read input from. */
1218 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1219 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1220 s->exec_context.std_input == EXEC_INPUT_NULL)
1221 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1223 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1224 s->exec_context.std_input == EXEC_INPUT_NULL)
1225 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1228 static int service_load(Unit *u) {
1230 Service *s = SERVICE(u);
1234 /* Load a .service file */
1235 if ((r = unit_load_fragment(u)) < 0)
1238 #ifdef HAVE_SYSV_COMPAT
1239 /* Load a classic init script as a fallback, if we couldn't find anything */
1240 if (u->load_state == UNIT_STUB)
1241 if ((r = service_load_sysv(s)) < 0)
1245 /* Still nothing found? Then let's give up */
1246 if (u->load_state == UNIT_STUB)
1249 /* We were able to load something, then let's add in the
1250 * dropin directories. */
1251 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
1254 /* This is a new unit? Then let's add in some extras */
1255 if (u->load_state == UNIT_LOADED) {
1256 if (s->type == _SERVICE_TYPE_INVALID)
1257 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1259 /* Oneshot services have disabled start timeout by default */
1260 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1261 s->timeout_start_usec = 0;
1263 service_fix_output(s);
1265 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
1268 if ((r = unit_add_default_cgroups(u)) < 0)
1271 #ifdef HAVE_SYSV_COMPAT
1272 if ((r = sysv_fix_order(s)) < 0)
1276 if ((r = fsck_fix_order(s)) < 0)
1280 if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1283 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1284 s->notify_access = NOTIFY_MAIN;
1286 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1287 s->notify_access = NOTIFY_MAIN;
1289 if (s->type == SERVICE_DBUS || s->bus_name)
1290 if ((r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true)) < 0)
1293 if (UNIT(s)->default_dependencies)
1294 if ((r = service_add_default_dependencies(s)) < 0)
1297 r = unit_exec_context_defaults(u, &s->exec_context);
1302 return service_verify(s);
1305 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1307 ServiceExecCommand c;
1308 Service *s = SERVICE(u);
1309 const char *prefix2;
1314 p2 = strappend(prefix, "\t");
1315 prefix2 = p2 ? p2 : prefix;
1318 "%sService State: %s\n"
1320 "%sReload Result: %s\n"
1321 "%sPermissionsStartOnly: %s\n"
1322 "%sRootDirectoryStartOnly: %s\n"
1323 "%sRemainAfterExit: %s\n"
1324 "%sGuessMainPID: %s\n"
1327 "%sNotifyAccess: %s\n",
1328 prefix, service_state_to_string(s->state),
1329 prefix, service_result_to_string(s->result),
1330 prefix, service_result_to_string(s->reload_result),
1331 prefix, yes_no(s->permissions_start_only),
1332 prefix, yes_no(s->root_directory_start_only),
1333 prefix, yes_no(s->remain_after_exit),
1334 prefix, yes_no(s->guess_main_pid),
1335 prefix, service_type_to_string(s->type),
1336 prefix, service_restart_to_string(s->restart),
1337 prefix, notify_access_to_string(s->notify_access));
1339 if (s->control_pid > 0)
1341 "%sControl PID: %lu\n",
1342 prefix, (unsigned long) s->control_pid);
1344 if (s->main_pid > 0)
1347 "%sMain PID Known: %s\n"
1348 "%sMain PID Alien: %s\n",
1349 prefix, (unsigned long) s->main_pid,
1350 prefix, yes_no(s->main_pid_known),
1351 prefix, yes_no(s->main_pid_alien));
1356 prefix, s->pid_file);
1361 "%sBus Name Good: %s\n",
1362 prefix, s->bus_name,
1363 prefix, yes_no(s->bus_name_good));
1365 kill_context_dump(&s->kill_context, f, prefix);
1366 exec_context_dump(&s->exec_context, f, prefix);
1368 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1370 if (!s->exec_command[c])
1373 fprintf(f, "%s-> %s:\n",
1374 prefix, service_exec_command_to_string(c));
1376 exec_command_dump_list(s->exec_command[c], f, prefix2);
1379 #ifdef HAVE_SYSV_COMPAT
1382 "%sSysV Init Script has LSB Header: %s\n"
1383 "%sSysVEnabled: %s\n",
1384 prefix, yes_no(s->sysv_has_lsb),
1385 prefix, yes_no(s->sysv_enabled));
1387 if (s->sysv_start_priority >= 0)
1389 "%sSysVStartPriority: %i\n",
1390 prefix, s->sysv_start_priority);
1392 if (s->sysv_runlevels)
1393 fprintf(f, "%sSysVRunLevels: %s\n",
1394 prefix, s->sysv_runlevels);
1397 if (s->fsck_passno > 0)
1399 "%sFsckPassNo: %i\n",
1400 prefix, s->fsck_passno);
1403 fprintf(f, "%sStatus Text: %s\n",
1404 prefix, s->status_text);
1409 static int service_load_pid_file(Service *s, bool may_warn) {
1419 if ((r = read_one_line_file(s->pid_file, &k)) < 0) {
1421 log_info("PID file %s not readable (yet?) after %s.",
1422 s->pid_file, service_state_to_string(s->state));
1426 r = parse_pid(k, &pid);
1432 if (kill(pid, 0) < 0 && errno != EPERM) {
1434 log_info("PID %lu read from file %s does not exist.",
1435 (unsigned long) pid, s->pid_file);
1439 if (s->main_pid_known) {
1440 if (pid == s->main_pid)
1443 log_debug("Main PID changing: %lu -> %lu",
1444 (unsigned long) s->main_pid, (unsigned long) pid);
1445 service_unwatch_main_pid(s);
1446 s->main_pid_known = false;
1448 log_debug("Main PID loaded: %lu", (unsigned long) pid);
1450 if ((r = service_set_main_pid(s, pid)) < 0)
1453 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1454 /* FIXME: we need to do something here */
1460 static int service_search_main_pid(Service *s) {
1466 /* If we know it anyway, don't ever fallback to unreliable
1468 if (s->main_pid_known)
1471 if (!s->guess_main_pid)
1474 assert(s->main_pid <= 0);
1476 if ((pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings)) <= 0)
1479 log_debug("Main PID guessed: %lu", (unsigned long) pid);
1480 if ((r = service_set_main_pid(s, pid)) < 0)
1483 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1484 /* FIXME: we need to do something here */
1490 static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1496 /* Notifies all our sockets when we die */
1498 if (s->socket_fd >= 0)
1501 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1502 if (u->type == UNIT_SOCKET)
1503 socket_notify_service_dead(SOCKET(u), failed_permanent);
1508 static void service_set_state(Service *s, ServiceState state) {
1509 ServiceState old_state;
1510 const UnitActiveState *table;
1513 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1515 old_state = s->state;
1518 service_unwatch_pid_file(s);
1520 if (state != SERVICE_START_PRE &&
1521 state != SERVICE_START &&
1522 state != SERVICE_START_POST &&
1523 state != SERVICE_RELOAD &&
1524 state != SERVICE_STOP &&
1525 state != SERVICE_STOP_SIGTERM &&
1526 state != SERVICE_STOP_SIGKILL &&
1527 state != SERVICE_STOP_POST &&
1528 state != SERVICE_FINAL_SIGTERM &&
1529 state != SERVICE_FINAL_SIGKILL &&
1530 state != SERVICE_AUTO_RESTART)
1531 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1533 if (state != SERVICE_START &&
1534 state != SERVICE_START_POST &&
1535 state != SERVICE_RUNNING &&
1536 state != SERVICE_RELOAD &&
1537 state != SERVICE_STOP &&
1538 state != SERVICE_STOP_SIGTERM &&
1539 state != SERVICE_STOP_SIGKILL) {
1540 service_unwatch_main_pid(s);
1541 s->main_command = NULL;
1544 if (state != SERVICE_START_PRE &&
1545 state != SERVICE_START &&
1546 state != SERVICE_START_POST &&
1547 state != SERVICE_RELOAD &&
1548 state != SERVICE_STOP &&
1549 state != SERVICE_STOP_SIGTERM &&
1550 state != SERVICE_STOP_SIGKILL &&
1551 state != SERVICE_STOP_POST &&
1552 state != SERVICE_FINAL_SIGTERM &&
1553 state != SERVICE_FINAL_SIGKILL) {
1554 service_unwatch_control_pid(s);
1555 s->control_command = NULL;
1556 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1559 if (state == SERVICE_DEAD ||
1560 state == SERVICE_STOP ||
1561 state == SERVICE_STOP_SIGTERM ||
1562 state == SERVICE_STOP_SIGKILL ||
1563 state == SERVICE_STOP_POST ||
1564 state == SERVICE_FINAL_SIGTERM ||
1565 state == SERVICE_FINAL_SIGKILL ||
1566 state == SERVICE_FAILED ||
1567 state == SERVICE_AUTO_RESTART)
1568 service_notify_sockets_dead(s, false);
1570 if (state != SERVICE_START_PRE &&
1571 state != SERVICE_START &&
1572 state != SERVICE_START_POST &&
1573 state != SERVICE_RUNNING &&
1574 state != SERVICE_RELOAD &&
1575 state != SERVICE_STOP &&
1576 state != SERVICE_STOP_SIGTERM &&
1577 state != SERVICE_STOP_SIGKILL &&
1578 state != SERVICE_STOP_POST &&
1579 state != SERVICE_FINAL_SIGTERM &&
1580 state != SERVICE_FINAL_SIGKILL &&
1581 !(state == SERVICE_DEAD && UNIT(s)->job)) {
1582 service_close_socket_fd(s);
1583 service_connection_unref(s);
1586 if (state == SERVICE_STOP)
1587 service_stop_watchdog(s);
1589 /* For the inactive states unit_notify() will trim the cgroup,
1590 * but for exit we have to do that ourselves... */
1591 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1592 cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
1594 if (old_state != state)
1595 log_debug("%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1597 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1598 s->reload_result = SERVICE_SUCCESS;
1601 static int service_coldplug(Unit *u) {
1602 Service *s = SERVICE(u);
1606 assert(s->state == SERVICE_DEAD);
1608 if (s->deserialized_state != s->state) {
1610 if (s->deserialized_state == SERVICE_START_PRE ||
1611 s->deserialized_state == SERVICE_START ||
1612 s->deserialized_state == SERVICE_START_POST ||
1613 s->deserialized_state == SERVICE_RELOAD ||
1614 s->deserialized_state == SERVICE_STOP ||
1615 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1616 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1617 s->deserialized_state == SERVICE_STOP_POST ||
1618 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1619 s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1620 s->deserialized_state == SERVICE_AUTO_RESTART) {
1621 if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
1624 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
1626 if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0)
1631 if ((s->deserialized_state == SERVICE_START &&
1632 (s->type == SERVICE_FORKING ||
1633 s->type == SERVICE_DBUS ||
1634 s->type == SERVICE_ONESHOT ||
1635 s->type == SERVICE_NOTIFY)) ||
1636 s->deserialized_state == SERVICE_START_POST ||
1637 s->deserialized_state == SERVICE_RUNNING ||
1638 s->deserialized_state == SERVICE_RELOAD ||
1639 s->deserialized_state == SERVICE_STOP ||
1640 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1641 s->deserialized_state == SERVICE_STOP_SIGKILL)
1642 if (s->main_pid > 0)
1643 if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0)
1646 if (s->deserialized_state == SERVICE_START_PRE ||
1647 s->deserialized_state == SERVICE_START ||
1648 s->deserialized_state == SERVICE_START_POST ||
1649 s->deserialized_state == SERVICE_RELOAD ||
1650 s->deserialized_state == SERVICE_STOP ||
1651 s->deserialized_state == SERVICE_STOP_SIGTERM ||
1652 s->deserialized_state == SERVICE_STOP_SIGKILL ||
1653 s->deserialized_state == SERVICE_STOP_POST ||
1654 s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1655 s->deserialized_state == SERVICE_FINAL_SIGKILL)
1656 if (s->control_pid > 0)
1657 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1660 if (s->deserialized_state == SERVICE_START_POST ||
1661 s->deserialized_state == SERVICE_RUNNING)
1662 service_handle_watchdog(s);
1664 service_set_state(s, s->deserialized_state);
1669 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1673 unsigned rn_fds = 0;
1680 if (s->socket_fd >= 0)
1683 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1688 if (u->type != UNIT_SOCKET)
1693 if ((r = socket_collect_fds(sock, &cfds, &cn_fds)) < 0)
1705 if (!(t = new(int, rn_fds+cn_fds))) {
1711 memcpy(t, rfds, rn_fds * sizeof(int));
1712 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1717 rn_fds = rn_fds+cn_fds;
1732 static int service_spawn(
1737 bool apply_permissions,
1739 bool apply_tty_stdin,
1740 bool set_notify_socket,
1746 int *fds = NULL, *fdsbuf = NULL;
1747 unsigned n_fds = 0, n_env = 0;
1748 char **argv = NULL, **final_env = NULL, **our_env = NULL;
1755 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1756 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1757 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1759 if (s->socket_fd >= 0) {
1760 fds = &s->socket_fd;
1763 if ((r = service_collect_fds(s, &fdsbuf, &n_fds)) < 0)
1770 if (timeout && s->timeout_start_usec) {
1771 r = unit_watch_timer(UNIT(s), s->timeout_start_usec, &s->timer_watch);
1775 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1777 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1782 if (!(our_env = new0(char*, 4))) {
1787 if (set_notify_socket)
1788 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1793 if (s->main_pid > 0)
1794 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1799 if (s->watchdog_usec > 0)
1800 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1805 if (!(final_env = strv_env_merge(2,
1806 UNIT(s)->manager->environment,
1821 UNIT(s)->manager->confirm_spawn,
1822 UNIT(s)->cgroup_bondings,
1823 UNIT(s)->cgroup_attributes,
1824 is_control ? "control" : NULL,
1826 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1832 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1833 /* FIXME: we need to do something here */
1839 strv_free(final_env);
1849 strv_free(final_env);
1852 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1857 static int main_pid_good(Service *s) {
1860 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1863 /* If we know the pid file, then lets just check if it is
1865 if (s->main_pid_known) {
1867 /* If it's an alien child let's check if it is still
1869 if (s->main_pid_alien)
1870 return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1872 /* .. otherwise assume we'll get a SIGCHLD for it,
1873 * which we really should wait for to collect exit
1874 * status and code */
1875 return s->main_pid > 0;
1878 /* We don't know the pid */
1882 static int control_pid_good(Service *s) {
1885 return s->control_pid > 0;
1888 static int cgroup_good(Service *s) {
1893 if ((r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings)) < 0)
1899 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1903 if (f != SERVICE_SUCCESS)
1906 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1908 if (allow_restart &&
1909 !s->forbid_restart &&
1910 (s->restart == SERVICE_RESTART_ALWAYS ||
1911 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1912 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1913 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1914 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1915 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1916 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1917 (s->result != SERVICE_FAILURE_SIGNAL ||
1918 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1921 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
1925 service_set_state(s, SERVICE_AUTO_RESTART);
1928 s->forbid_restart = false;
1933 log_warning("%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1934 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1937 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
1939 static void service_enter_stop_post(Service *s, ServiceResult f) {
1943 if (f != SERVICE_SUCCESS)
1946 service_unwatch_control_pid(s);
1948 if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
1949 s->control_command_id = SERVICE_EXEC_STOP_POST;
1951 r = service_spawn(s,
1955 !s->permissions_start_only,
1956 !s->root_directory_start_only,
1965 service_set_state(s, SERVICE_STOP_POST);
1967 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1972 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1973 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1976 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1978 Set *pid_set = NULL;
1979 bool wait_for_exit = false;
1983 if (f != SERVICE_SUCCESS)
1986 if (s->kill_context.kill_mode != KILL_NONE) {
1987 int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1989 if (s->main_pid > 0) {
1990 if (kill_and_sigcont(s->main_pid, sig) < 0 && errno != ESRCH)
1991 log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
1993 wait_for_exit = !s->main_pid_alien;
1996 if (s->control_pid > 0) {
1997 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1998 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
2000 wait_for_exit = true;
2003 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
2005 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2011 /* Exclude the main/control pids from being killed via the cgroup */
2012 if (s->main_pid > 0)
2013 if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
2016 if (s->control_pid > 0)
2017 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
2020 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
2022 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2023 log_warning("Failed to kill control group: %s", strerror(-r));
2025 wait_for_exit = true;
2032 if (wait_for_exit) {
2033 if (s->timeout_stop_usec > 0) {
2034 r = unit_watch_timer(UNIT(s), s->timeout_stop_usec, &s->timer_watch);
2039 service_set_state(s, state);
2040 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2041 service_enter_stop_post(s, SERVICE_SUCCESS);
2043 service_enter_dead(s, SERVICE_SUCCESS, true);
2048 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
2050 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2051 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
2053 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2059 static void service_enter_stop(Service *s, ServiceResult f) {
2064 if (f != SERVICE_SUCCESS)
2067 service_unwatch_control_pid(s);
2069 if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
2070 s->control_command_id = SERVICE_EXEC_STOP;
2072 r = service_spawn(s,
2076 !s->permissions_start_only,
2077 !s->root_directory_start_only,
2085 service_set_state(s, SERVICE_STOP);
2087 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2092 log_warning("%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2093 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2096 static void service_enter_running(Service *s, ServiceResult f) {
2097 int main_pid_ok, cgroup_ok;
2100 if (f != SERVICE_SUCCESS)
2103 main_pid_ok = main_pid_good(s);
2104 cgroup_ok = cgroup_good(s);
2106 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2107 (s->bus_name_good || s->type != SERVICE_DBUS))
2108 service_set_state(s, SERVICE_RUNNING);
2109 else if (s->remain_after_exit)
2110 service_set_state(s, SERVICE_EXITED);
2112 service_enter_stop(s, SERVICE_SUCCESS);
2115 static void service_enter_start_post(Service *s) {
2119 service_unwatch_control_pid(s);
2121 if (s->watchdog_usec > 0)
2122 service_reset_watchdog(s);
2124 if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
2125 s->control_command_id = SERVICE_EXEC_START_POST;
2127 r = service_spawn(s,
2131 !s->permissions_start_only,
2132 !s->root_directory_start_only,
2140 service_set_state(s, SERVICE_START_POST);
2142 service_enter_running(s, SERVICE_SUCCESS);
2147 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2148 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2151 static void service_enter_start(Service *s) {
2158 assert(s->exec_command[SERVICE_EXEC_START]);
2159 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2161 if (s->type == SERVICE_FORKING)
2162 service_unwatch_control_pid(s);
2164 service_unwatch_main_pid(s);
2166 /* We want to ensure that nobody leaks processes from
2167 * START_PRE here, so let's go on a killing spree, People
2168 * should not spawn long running processes from START_PRE. */
2169 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2171 if (s->type == SERVICE_FORKING) {
2172 s->control_command_id = SERVICE_EXEC_START;
2173 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2175 s->main_command = NULL;
2177 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2178 s->control_command = NULL;
2180 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2183 r = service_spawn(s,
2185 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2190 s->notify_access != NOTIFY_NONE,
2196 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2197 /* For simple services we immediately start
2198 * the START_POST binaries. */
2200 service_set_main_pid(s, pid);
2201 service_enter_start_post(s);
2203 } else if (s->type == SERVICE_FORKING) {
2205 /* For forking services we wait until the start
2206 * process exited. */
2208 s->control_pid = pid;
2209 service_set_state(s, SERVICE_START);
2211 } else if (s->type == SERVICE_ONESHOT ||
2212 s->type == SERVICE_DBUS ||
2213 s->type == SERVICE_NOTIFY) {
2215 /* For oneshot services we wait until the start
2216 * process exited, too, but it is our main process. */
2218 /* For D-Bus services we know the main pid right away,
2219 * but wait for the bus name to appear on the
2220 * bus. Notify services are similar. */
2222 service_set_main_pid(s, pid);
2223 service_set_state(s, SERVICE_START);
2225 assert_not_reached("Unknown service type");
2230 log_warning("%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2231 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2234 static void service_enter_start_pre(Service *s) {
2239 service_unwatch_control_pid(s);
2241 if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
2243 /* Before we start anything, let's clear up what might
2244 * be left from previous runs. */
2245 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2247 s->control_command_id = SERVICE_EXEC_START_PRE;
2249 r = service_spawn(s,
2253 !s->permissions_start_only,
2254 !s->root_directory_start_only,
2262 service_set_state(s, SERVICE_START_PRE);
2264 service_enter_start(s);
2269 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2270 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2273 static void service_enter_restart(Service *s) {
2278 dbus_error_init(&error);
2280 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2281 /* Don't restart things if we are going down anyway */
2282 log_info("Stop job pending for unit, delaying automatic restart.");
2284 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
2291 /* Any units that are bound to this service must also be
2292 * restarted. We use JOB_RESTART (instead of the more obvious
2293 * JOB_START) here so that those dependency jobs will be added
2295 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2299 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2300 * it will be canceled as part of the service_stop() call that
2301 * is executed as part of JOB_RESTART. */
2303 log_debug("%s scheduled restart job.", UNIT(s)->id);
2307 log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2308 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2310 dbus_error_free(&error);
2313 static void service_enter_reload(Service *s) {
2318 service_unwatch_control_pid(s);
2320 if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2321 s->control_command_id = SERVICE_EXEC_RELOAD;
2323 r = service_spawn(s,
2327 !s->permissions_start_only,
2328 !s->root_directory_start_only,
2336 service_set_state(s, SERVICE_RELOAD);
2338 service_enter_running(s, SERVICE_SUCCESS);
2343 log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2344 s->reload_result = SERVICE_FAILURE_RESOURCES;
2345 service_enter_running(s, SERVICE_SUCCESS);
2348 static void service_run_next_control(Service *s) {
2352 assert(s->control_command);
2353 assert(s->control_command->command_next);
2355 assert(s->control_command_id != SERVICE_EXEC_START);
2357 s->control_command = s->control_command->command_next;
2358 service_unwatch_control_pid(s);
2360 r = service_spawn(s,
2364 !s->permissions_start_only,
2365 !s->root_directory_start_only,
2366 s->control_command_id == SERVICE_EXEC_START_PRE ||
2367 s->control_command_id == SERVICE_EXEC_STOP_POST,
2377 log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2379 if (s->state == SERVICE_START_PRE)
2380 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2381 else if (s->state == SERVICE_STOP)
2382 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2383 else if (s->state == SERVICE_STOP_POST)
2384 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2385 else if (s->state == SERVICE_RELOAD) {
2386 s->reload_result = SERVICE_FAILURE_RESOURCES;
2387 service_enter_running(s, SERVICE_SUCCESS);
2389 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2392 static void service_run_next_main(Service *s) {
2397 assert(s->main_command);
2398 assert(s->main_command->command_next);
2399 assert(s->type == SERVICE_ONESHOT);
2401 s->main_command = s->main_command->command_next;
2402 service_unwatch_main_pid(s);
2404 r = service_spawn(s,
2411 s->notify_access != NOTIFY_NONE,
2417 service_set_main_pid(s, pid);
2422 log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2423 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2426 static int service_start_limit_test(Service *s) {
2429 if (ratelimit_test(&s->start_limit))
2432 switch (s->start_limit_action) {
2434 case SERVICE_START_LIMIT_NONE:
2435 log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2438 case SERVICE_START_LIMIT_REBOOT: {
2442 dbus_error_init(&error);
2444 log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2446 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2448 log_error("Failed to reboot: %s.", bus_error(&error, r));
2449 dbus_error_free(&error);
2455 case SERVICE_START_LIMIT_REBOOT_FORCE:
2456 log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2457 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2460 case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2461 log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2462 reboot(RB_AUTOBOOT);
2466 log_error("start limit action=%i", s->start_limit_action);
2467 assert_not_reached("Unknown StartLimitAction.");
2473 static int service_start(Unit *u) {
2474 Service *s = SERVICE(u);
2479 /* We cannot fulfill this request right now, try again later
2481 if (s->state == SERVICE_STOP ||
2482 s->state == SERVICE_STOP_SIGTERM ||
2483 s->state == SERVICE_STOP_SIGKILL ||
2484 s->state == SERVICE_STOP_POST ||
2485 s->state == SERVICE_FINAL_SIGTERM ||
2486 s->state == SERVICE_FINAL_SIGKILL)
2489 /* Already on it! */
2490 if (s->state == SERVICE_START_PRE ||
2491 s->state == SERVICE_START ||
2492 s->state == SERVICE_START_POST)
2495 /* A service that will be restarted must be stopped first to
2496 * trigger BindsTo and/or OnFailure dependencies. If a user
2497 * does not want to wait for the holdoff time to elapse, the
2498 * service should be manually restarted, not started. We
2499 * simply return EAGAIN here, so that any start jobs stay
2500 * queued, and assume that the auto restart timer will
2501 * eventually trigger the restart. */
2502 if (s->state == SERVICE_AUTO_RESTART)
2505 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2507 /* Make sure we don't enter a busy loop of some kind. */
2508 r = service_start_limit_test(s);
2510 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2514 s->result = SERVICE_SUCCESS;
2515 s->reload_result = SERVICE_SUCCESS;
2516 s->main_pid_known = false;
2517 s->main_pid_alien = false;
2518 s->forbid_restart = false;
2520 service_enter_start_pre(s);
2524 static int service_stop(Unit *u) {
2525 Service *s = SERVICE(u);
2529 /* Don't create restart jobs from here. */
2530 s->forbid_restart = true;
2533 if (s->state == SERVICE_STOP ||
2534 s->state == SERVICE_STOP_SIGTERM ||
2535 s->state == SERVICE_STOP_SIGKILL ||
2536 s->state == SERVICE_STOP_POST ||
2537 s->state == SERVICE_FINAL_SIGTERM ||
2538 s->state == SERVICE_FINAL_SIGKILL)
2541 /* A restart will be scheduled or is in progress. */
2542 if (s->state == SERVICE_AUTO_RESTART) {
2543 service_set_state(s, SERVICE_DEAD);
2547 /* If there's already something running we go directly into
2549 if (s->state == SERVICE_START_PRE ||
2550 s->state == SERVICE_START ||
2551 s->state == SERVICE_START_POST ||
2552 s->state == SERVICE_RELOAD) {
2553 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2557 assert(s->state == SERVICE_RUNNING ||
2558 s->state == SERVICE_EXITED);
2560 service_enter_stop(s, SERVICE_SUCCESS);
2564 static int service_reload(Unit *u) {
2565 Service *s = SERVICE(u);
2569 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2571 service_enter_reload(s);
2575 static bool service_can_reload(Unit *u) {
2576 Service *s = SERVICE(u);
2580 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2583 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2584 Service *s = SERVICE(u);
2590 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2591 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2592 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2594 if (s->control_pid > 0)
2595 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2597 if (s->main_pid_known && s->main_pid > 0)
2598 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2600 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2603 unit_serialize_item(u, f, "status-text", s->status_text);
2605 /* FIXME: There's a minor uncleanliness here: if there are
2606 * multiple commands attached here, we will start from the
2607 * first one again */
2608 if (s->control_command_id >= 0)
2609 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2611 if (s->socket_fd >= 0) {
2614 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2617 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2620 if (s->main_exec_status.pid > 0) {
2621 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2622 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2623 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2625 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2626 unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2627 unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2630 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2631 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2636 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2637 Service *s = SERVICE(u);
2644 if (streq(key, "state")) {
2647 if ((state = service_state_from_string(value)) < 0)
2648 log_debug("Failed to parse state value %s", value);
2650 s->deserialized_state = state;
2651 } else if (streq(key, "result")) {
2654 f = service_result_from_string(value);
2656 log_debug("Failed to parse result value %s", value);
2657 else if (f != SERVICE_SUCCESS)
2660 } else if (streq(key, "reload-result")) {
2663 f = service_result_from_string(value);
2665 log_debug("Failed to parse reload result value %s", value);
2666 else if (f != SERVICE_SUCCESS)
2667 s->reload_result = f;
2669 } else if (streq(key, "control-pid")) {
2672 if (parse_pid(value, &pid) < 0)
2673 log_debug("Failed to parse control-pid value %s", value);
2675 s->control_pid = pid;
2676 } else if (streq(key, "main-pid")) {
2679 if (parse_pid(value, &pid) < 0)
2680 log_debug("Failed to parse main-pid value %s", value);
2682 service_set_main_pid(s, (pid_t) pid);
2683 } else if (streq(key, "main-pid-known")) {
2686 if ((b = parse_boolean(value)) < 0)
2687 log_debug("Failed to parse main-pid-known value %s", value);
2689 s->main_pid_known = b;
2690 } else if (streq(key, "status-text")) {
2693 if ((t = strdup(value))) {
2694 free(s->status_text);
2698 } else if (streq(key, "control-command")) {
2699 ServiceExecCommand id;
2701 if ((id = service_exec_command_from_string(value)) < 0)
2702 log_debug("Failed to parse exec-command value %s", value);
2704 s->control_command_id = id;
2705 s->control_command = s->exec_command[id];
2707 } else if (streq(key, "socket-fd")) {
2710 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2711 log_debug("Failed to parse socket-fd value %s", value);
2714 if (s->socket_fd >= 0)
2715 close_nointr_nofail(s->socket_fd);
2716 s->socket_fd = fdset_remove(fds, fd);
2718 } else if (streq(key, "main-exec-status-pid")) {
2721 if (parse_pid(value, &pid) < 0)
2722 log_debug("Failed to parse main-exec-status-pid value %s", value);
2724 s->main_exec_status.pid = pid;
2725 } else if (streq(key, "main-exec-status-code")) {
2728 if (safe_atoi(value, &i) < 0)
2729 log_debug("Failed to parse main-exec-status-code value %s", value);
2731 s->main_exec_status.code = i;
2732 } else if (streq(key, "main-exec-status-status")) {
2735 if (safe_atoi(value, &i) < 0)
2736 log_debug("Failed to parse main-exec-status-status value %s", value);
2738 s->main_exec_status.status = i;
2739 } else if (streq(key, "main-exec-status-start"))
2740 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2741 else if (streq(key, "main-exec-status-exit"))
2742 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2743 else if (streq(key, "watchdog-timestamp"))
2744 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2746 log_debug("Unknown serialization key '%s'", key);
2751 static UnitActiveState service_active_state(Unit *u) {
2752 const UnitActiveState *table;
2756 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2758 return table[SERVICE(u)->state];
2761 static const char *service_sub_state_to_string(Unit *u) {
2764 return service_state_to_string(SERVICE(u)->state);
2767 static bool service_check_gc(Unit *u) {
2768 Service *s = SERVICE(u);
2772 /* Never clean up services that still have a process around,
2773 * even if the service is formally dead. */
2774 if (cgroup_good(s) > 0 ||
2775 main_pid_good(s) > 0 ||
2776 control_pid_good(s) > 0)
2779 #ifdef HAVE_SYSV_COMPAT
2787 static bool service_check_snapshot(Unit *u) {
2788 Service *s = SERVICE(u);
2792 return !s->got_socket_fd;
2795 static int service_retry_pid_file(Service *s) {
2798 assert(s->pid_file);
2799 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2801 r = service_load_pid_file(s, false);
2805 service_unwatch_pid_file(s);
2807 service_enter_running(s, SERVICE_SUCCESS);
2811 static int service_watch_pid_file(Service *s) {
2814 log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2815 r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2819 /* the pidfile might have appeared just before we set the watch */
2820 service_retry_pid_file(s);
2824 log_error("Failed to set a watch for %s's PID file %s: %s",
2825 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2826 service_unwatch_pid_file(s);
2830 static int service_demand_pid_file(Service *s) {
2833 assert(s->pid_file);
2834 assert(!s->pid_file_pathspec);
2836 ps = new0(PathSpec, 1);
2840 ps->path = strdup(s->pid_file);
2846 path_kill_slashes(ps->path);
2848 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2849 * keep their PID file open all the time. */
2850 ps->type = PATH_MODIFIED;
2851 ps->inotify_fd = -1;
2853 s->pid_file_pathspec = ps;
2855 return service_watch_pid_file(s);
2858 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2859 Service *s = SERVICE(u);
2863 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2864 assert(s->pid_file_pathspec);
2865 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2867 log_debug("inotify event for %s", u->id);
2869 if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2872 if (service_retry_pid_file(s) == 0)
2875 if (service_watch_pid_file(s) < 0)
2880 service_unwatch_pid_file(s);
2881 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2884 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2885 Service *s = SERVICE(u);
2891 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2892 is_clean_exit_lsb(code, status, &s->success_status))
2893 f = SERVICE_SUCCESS;
2894 else if (code == CLD_EXITED)
2895 f = SERVICE_FAILURE_EXIT_CODE;
2896 else if (code == CLD_KILLED)
2897 f = SERVICE_FAILURE_SIGNAL;
2898 else if (code == CLD_DUMPED)
2899 f = SERVICE_FAILURE_CORE_DUMP;
2901 assert_not_reached("Unknown code");
2903 if (s->main_pid == pid) {
2904 /* Forking services may occasionally move to a new PID.
2905 * As long as they update the PID file before exiting the old
2906 * PID, they're fine. */
2907 if (service_load_pid_file(s, false) == 0)
2911 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2913 /* If this is not a forking service than the main
2914 * process got started and hence we copy the exit
2915 * status so that it is recorded both as main and as
2916 * control process exit status */
2917 if (s->main_command) {
2918 s->main_command->exec_status = s->main_exec_status;
2920 if (s->main_command->ignore)
2921 f = SERVICE_SUCCESS;
2924 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2925 "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2927 if (f != SERVICE_SUCCESS)
2930 if (s->main_command &&
2931 s->main_command->command_next &&
2932 f == SERVICE_SUCCESS) {
2934 /* There is another command to *
2935 * execute, so let's do that. */
2937 log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2938 service_run_next_main(s);
2942 /* The service exited, so the service is officially
2944 s->main_command = NULL;
2948 case SERVICE_START_POST:
2949 case SERVICE_RELOAD:
2951 /* Need to wait until the operation is
2956 if (s->type == SERVICE_ONESHOT) {
2957 /* This was our main goal, so let's go on */
2958 if (f == SERVICE_SUCCESS)
2959 service_enter_start_post(s);
2961 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2967 case SERVICE_RUNNING:
2968 service_enter_running(s, f);
2971 case SERVICE_STOP_SIGTERM:
2972 case SERVICE_STOP_SIGKILL:
2974 if (!control_pid_good(s))
2975 service_enter_stop_post(s, f);
2977 /* If there is still a control process, wait for that first */
2981 assert_not_reached("Uh, main process died at wrong time.");
2985 } else if (s->control_pid == pid) {
2989 if (s->control_command) {
2990 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2992 if (s->control_command->ignore)
2993 f = SERVICE_SUCCESS;
2996 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2997 "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2999 if (f != SERVICE_SUCCESS)
3002 /* Immediately get rid of the cgroup, so that the
3003 * kernel doesn't delay the cgroup empty messages for
3004 * the service cgroup any longer than necessary */
3005 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
3007 if (s->control_command &&
3008 s->control_command->command_next &&
3009 f == SERVICE_SUCCESS) {
3011 /* There is another command to *
3012 * execute, so let's do that. */
3014 log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
3015 service_run_next_control(s);
3018 /* No further commands for this step, so let's
3019 * figure out what to do next */
3021 s->control_command = NULL;
3022 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3024 log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
3028 case SERVICE_START_PRE:
3029 if (f == SERVICE_SUCCESS)
3030 service_enter_start(s);
3032 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3036 if (s->type != SERVICE_FORKING)
3037 /* Maybe spurious event due to a reload that changed the type? */
3040 if (f != SERVICE_SUCCESS) {
3041 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3046 bool has_start_post;
3049 /* Let's try to load the pid file here if we can.
3050 * The PID file might actually be created by a START_POST
3051 * script. In that case don't worry if the loading fails. */
3053 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3054 r = service_load_pid_file(s, !has_start_post);
3055 if (!has_start_post && r < 0) {
3056 r = service_demand_pid_file(s);
3057 if (r < 0 || !cgroup_good(s))
3058 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3062 service_search_main_pid(s);
3064 service_enter_start_post(s);
3067 case SERVICE_START_POST:
3068 if (f != SERVICE_SUCCESS) {
3069 service_enter_stop(s, f);
3076 r = service_load_pid_file(s, true);
3078 r = service_demand_pid_file(s);
3079 if (r < 0 || !cgroup_good(s))
3080 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3084 service_search_main_pid(s);
3086 service_enter_running(s, SERVICE_SUCCESS);
3089 case SERVICE_RELOAD:
3090 if (f == SERVICE_SUCCESS) {
3091 service_load_pid_file(s, true);
3092 service_search_main_pid(s);
3095 s->reload_result = f;
3096 service_enter_running(s, SERVICE_SUCCESS);
3100 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3103 case SERVICE_STOP_SIGTERM:
3104 case SERVICE_STOP_SIGKILL:
3105 if (main_pid_good(s) <= 0)
3106 service_enter_stop_post(s, f);
3108 /* If there is still a service
3109 * process around, wait until
3110 * that one quit, too */
3113 case SERVICE_STOP_POST:
3114 case SERVICE_FINAL_SIGTERM:
3115 case SERVICE_FINAL_SIGKILL:
3116 service_enter_dead(s, f, true);
3120 assert_not_reached("Uh, control process died at wrong time.");
3125 /* Notify clients about changed exit status */
3126 unit_add_to_dbus_queue(u);
3129 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3130 Service *s = SERVICE(u);
3133 assert(elapsed == 1);
3135 if (w == &s->watchdog_watch) {
3136 service_handle_watchdog(s);
3140 assert(w == &s->timer_watch);
3144 case SERVICE_START_PRE:
3146 log_warning("%s operation timed out. Terminating.", u->id);
3147 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3150 case SERVICE_START_POST:
3151 log_warning("%s operation timed out. Stopping.", u->id);
3152 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3155 case SERVICE_RELOAD:
3156 log_warning("%s operation timed out. Stopping.", u->id);
3157 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3158 service_enter_running(s, SERVICE_SUCCESS);
3162 log_warning("%s stopping timed out. Terminating.", u->id);
3163 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3166 case SERVICE_STOP_SIGTERM:
3167 if (s->kill_context.send_sigkill) {
3168 log_warning("%s stopping timed out. Killing.", u->id);
3169 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3171 log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3172 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3177 case SERVICE_STOP_SIGKILL:
3178 /* Uh, we sent a SIGKILL and it is still not gone?
3179 * Must be something we cannot kill, so let's just be
3180 * weirded out and continue */
3182 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3183 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3186 case SERVICE_STOP_POST:
3187 log_warning("%s stopping timed out (2). Terminating.", u->id);
3188 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3191 case SERVICE_FINAL_SIGTERM:
3192 if (s->kill_context.send_sigkill) {
3193 log_warning("%s stopping timed out (2). Killing.", u->id);
3194 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3196 log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3197 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3202 case SERVICE_FINAL_SIGKILL:
3203 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3204 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3207 case SERVICE_AUTO_RESTART:
3208 log_info("%s holdoff time over, scheduling restart.", u->id);
3209 service_enter_restart(s);
3213 assert_not_reached("Timeout at wrong time.");
3217 static void service_cgroup_notify_event(Unit *u) {
3218 Service *s = SERVICE(u);
3222 log_debug("%s: cgroup is empty", u->id);
3226 /* Waiting for SIGCHLD is usually more interesting,
3227 * because it includes return codes/signals. Which is
3228 * why we ignore the cgroup events for most cases,
3229 * except when we don't know pid which to expect the
3233 case SERVICE_START_POST:
3234 /* If we were hoping for the daemon to write its PID file,
3235 * we can give up now. */
3236 if (s->pid_file_pathspec) {
3237 log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3238 service_unwatch_pid_file(s);
3239 if (s->state == SERVICE_START)
3240 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3242 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3246 case SERVICE_RUNNING:
3247 /* service_enter_running() will figure out what to do */
3248 service_enter_running(s, SERVICE_SUCCESS);
3251 case SERVICE_STOP_SIGTERM:
3252 case SERVICE_STOP_SIGKILL:
3254 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3255 service_enter_stop_post(s, SERVICE_SUCCESS);
3259 case SERVICE_FINAL_SIGTERM:
3260 case SERVICE_FINAL_SIGKILL:
3261 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3262 service_enter_dead(s, SERVICE_SUCCESS, true);
3271 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3272 Service *s = SERVICE(u);
3277 if (s->notify_access == NOTIFY_NONE) {
3278 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3279 u->id, (unsigned long) pid);
3283 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3284 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3285 u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3289 log_debug("%s: Got message", u->id);
3291 /* Interpret MAINPID= */
3292 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3293 (s->state == SERVICE_START ||
3294 s->state == SERVICE_START_POST ||
3295 s->state == SERVICE_RUNNING ||
3296 s->state == SERVICE_RELOAD)) {
3298 if (parse_pid(e + 8, &pid) < 0)
3299 log_warning("Failed to parse notification message %s", e);
3301 log_debug("%s: got %s", u->id, e);
3302 service_set_main_pid(s, pid);
3306 /* Interpret READY= */
3307 if (s->type == SERVICE_NOTIFY &&
3308 s->state == SERVICE_START &&
3309 strv_find(tags, "READY=1")) {
3310 log_debug("%s: got READY=1", u->id);
3312 service_enter_start_post(s);
3315 /* Interpret STATUS= */
3316 e = strv_find_prefix(tags, "STATUS=");
3322 if (!utf8_is_valid(e+7)) {
3323 log_warning("Status message in notification is not UTF-8 clean.");
3329 log_error("Failed to allocate string.");
3333 log_debug("%s: got %s", u->id, e);
3335 free(s->status_text);
3338 free(s->status_text);
3339 s->status_text = NULL;
3343 if (strv_find(tags, "WATCHDOG=1")) {
3344 log_debug("%s: got WATCHDOG=1", u->id);
3345 service_reset_watchdog(s);
3348 /* Notify clients about changed status or main pid */
3349 unit_add_to_dbus_queue(u);
3352 #ifdef HAVE_SYSV_COMPAT
3355 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3359 if (!(f = fopen("/etc/insserv.conf", "re"))) {
3360 r = errno == ENOENT ? 0 : -errno;
3365 char l[LINE_MAX], *t;
3366 char **parsed = NULL;
3368 if (!fgets(l, sizeof(l), f)) {
3373 log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3378 if (*t != '$' && *t != '<')
3381 parsed = strv_split(t,WHITESPACE);
3382 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3383 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3386 if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3388 if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3390 char *dep = NULL, *name, **j;
3392 STRV_FOREACH (j, parsed+1) {
3401 if (sysv_translate_facility(name, NULL, &dep) < 0)
3404 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3419 static int service_enumerate(Manager *m) {
3423 char *path = NULL, *fpath = NULL, *name = NULL;
3424 Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3431 if (m->running_as != SYSTEMD_SYSTEM)
3434 zero(runlevel_services);
3436 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3437 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3441 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3450 if (!(d = opendir(path))) {
3451 if (errno != ENOENT)
3452 log_warning("opendir() failed on %s: %s", path, strerror(errno));
3457 while ((de = readdir(d))) {
3460 if (ignore_file(de->d_name))
3463 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3466 if (strlen(de->d_name) < 4)
3469 a = undecchar(de->d_name[1]);
3470 b = undecchar(de->d_name[2]);
3476 fpath = strjoin(path, "/", de->d_name, NULL);
3482 if (access(fpath, X_OK) < 0) {
3484 if (errno != ENOENT)
3485 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3491 if (!(name = sysv_translate_name(de->d_name + 3))) {
3496 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3497 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3501 if (de->d_name[0] == 'S') {
3503 if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3504 SERVICE(service)->sysv_start_priority_from_rcnd =
3505 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3507 SERVICE(service)->sysv_enabled = true;
3510 if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3513 if ((r = set_put(runlevel_services[i], service)) < 0)
3516 } else if (de->d_name[0] == 'K' &&
3517 (rcnd_table[i].type == RUNLEVEL_DOWN ||
3518 rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3520 if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3523 if ((r = set_put(shutdown_services, service)) < 0)
3529 /* Now we loaded all stubs and are aware of the lowest
3530 start-up priority for all services, not let's actually load
3531 the services, this will also tell us which services are
3532 actually native now */
3533 manager_dispatch_load_queue(m);
3535 /* If this is a native service, rely on native ways to pull in
3536 * a service, don't pull it in via sysv rcN.d links. */
3537 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3538 SET_FOREACH(service, runlevel_services[i], j) {
3539 service = unit_follow_merge(service);
3541 if (service->fragment_path)
3544 if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3548 /* We honour K links only for halt/reboot. For the normal
3549 * runlevels we assume the stop jobs will be implicitly added
3550 * by the core logic. Also, we don't really distinguish here
3551 * between the runlevels 0 and 6 and just add them to the
3552 * special shutdown target. On SUSE the boot.d/ runlevel is
3553 * also used for shutdown, so we add links for that too to the
3554 * shutdown target.*/
3555 SET_FOREACH(service, shutdown_services, j) {
3556 service = unit_follow_merge(service);
3558 if (service->fragment_path)
3561 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3568 sysv_facility_in_insserv_conf (m);
3576 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3577 set_free(runlevel_services[i]);
3578 set_free(shutdown_services);
3587 static void service_bus_name_owner_change(
3590 const char *old_owner,
3591 const char *new_owner) {
3593 Service *s = SERVICE(u);
3598 assert(streq(s->bus_name, name));
3599 assert(old_owner || new_owner);
3601 if (old_owner && new_owner)
3602 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3604 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3606 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3608 s->bus_name_good = !!new_owner;
3610 if (s->type == SERVICE_DBUS) {
3612 /* service_enter_running() will figure out what to
3614 if (s->state == SERVICE_RUNNING)
3615 service_enter_running(s, SERVICE_SUCCESS);
3616 else if (s->state == SERVICE_START && new_owner)
3617 service_enter_start_post(s);
3619 } else if (new_owner &&
3621 (s->state == SERVICE_START ||
3622 s->state == SERVICE_START_POST ||
3623 s->state == SERVICE_RUNNING ||
3624 s->state == SERVICE_RELOAD)) {
3626 /* Try to acquire PID from bus service */
3627 log_debug("Trying to acquire PID from D-Bus name...");
3629 bus_query_pid(u->manager, name);
3633 static void service_bus_query_pid_done(
3638 Service *s = SERVICE(u);
3643 log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3645 if (s->main_pid <= 0 &&
3646 (s->state == SERVICE_START ||
3647 s->state == SERVICE_START_POST ||
3648 s->state == SERVICE_RUNNING ||
3649 s->state == SERVICE_RELOAD))
3650 service_set_main_pid(s, pid);
3653 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3658 /* This is called by the socket code when instantiating a new
3659 * service for a stream socket and the socket needs to be
3662 if (UNIT(s)->load_state != UNIT_LOADED)
3665 if (s->socket_fd >= 0)
3668 if (s->state != SERVICE_DEAD)
3672 s->got_socket_fd = true;
3674 unit_ref_set(&s->accept_socket, UNIT(sock));
3676 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3679 static void service_reset_failed(Unit *u) {
3680 Service *s = SERVICE(u);
3684 if (s->state == SERVICE_FAILED)
3685 service_set_state(s, SERVICE_DEAD);
3687 s->result = SERVICE_SUCCESS;
3688 s->reload_result = SERVICE_SUCCESS;
3690 RATELIMIT_RESET(s->start_limit);
3693 static int service_kill(Unit *u, KillWho who, int signo, DBusError *error) {
3694 Service *s = SERVICE(u);
3696 Set *pid_set = NULL;
3700 if (s->main_pid <= 0 && who == KILL_MAIN) {
3701 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3705 if (s->control_pid <= 0 && who == KILL_CONTROL) {
3706 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3710 if (who == KILL_CONTROL || who == KILL_ALL)
3711 if (s->control_pid > 0)
3712 if (kill(s->control_pid, signo) < 0)
3715 if (who == KILL_MAIN || who == KILL_ALL)
3716 if (s->main_pid > 0)
3717 if (kill(s->main_pid, signo) < 0)
3720 if (who == KILL_ALL) {
3723 pid_set = set_new(trivial_hash_func, trivial_compare_func);
3727 /* Exclude the control/main pid from being killed via the cgroup */
3728 if (s->control_pid > 0) {
3729 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
3736 if (s->main_pid > 0) {
3737 q = set_put(pid_set, LONG_TO_PTR(s->main_pid));
3744 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
3745 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3756 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3757 [SERVICE_DEAD] = "dead",
3758 [SERVICE_START_PRE] = "start-pre",
3759 [SERVICE_START] = "start",
3760 [SERVICE_START_POST] = "start-post",
3761 [SERVICE_RUNNING] = "running",
3762 [SERVICE_EXITED] = "exited",
3763 [SERVICE_RELOAD] = "reload",
3764 [SERVICE_STOP] = "stop",
3765 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3766 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3767 [SERVICE_STOP_POST] = "stop-post",
3768 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3769 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3770 [SERVICE_FAILED] = "failed",
3771 [SERVICE_AUTO_RESTART] = "auto-restart",
3774 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3776 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3777 [SERVICE_RESTART_NO] = "no",
3778 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3779 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3780 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3781 [SERVICE_RESTART_ALWAYS] = "always"
3784 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3786 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3787 [SERVICE_SIMPLE] = "simple",
3788 [SERVICE_FORKING] = "forking",
3789 [SERVICE_ONESHOT] = "oneshot",
3790 [SERVICE_DBUS] = "dbus",
3791 [SERVICE_NOTIFY] = "notify",
3792 [SERVICE_IDLE] = "idle"
3795 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3797 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3798 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3799 [SERVICE_EXEC_START] = "ExecStart",
3800 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3801 [SERVICE_EXEC_RELOAD] = "ExecReload",
3802 [SERVICE_EXEC_STOP] = "ExecStop",
3803 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3806 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3808 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3809 [NOTIFY_NONE] = "none",
3810 [NOTIFY_MAIN] = "main",
3811 [NOTIFY_ALL] = "all"
3814 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3816 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3817 [SERVICE_SUCCESS] = "success",
3818 [SERVICE_FAILURE_RESOURCES] = "resources",
3819 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3820 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3821 [SERVICE_FAILURE_SIGNAL] = "signal",
3822 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3823 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3824 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3827 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3829 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3830 [SERVICE_START_LIMIT_NONE] = "none",
3831 [SERVICE_START_LIMIT_REBOOT] = "reboot",
3832 [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3833 [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3835 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3837 const UnitVTable service_vtable = {
3838 .object_size = sizeof(Service),
3839 .exec_context_offset = offsetof(Service, exec_context),
3846 .init = service_init,
3847 .done = service_done,
3848 .load = service_load,
3850 .coldplug = service_coldplug,
3852 .dump = service_dump,
3854 .start = service_start,
3855 .stop = service_stop,
3856 .reload = service_reload,
3858 .can_reload = service_can_reload,
3860 .kill = service_kill,
3862 .serialize = service_serialize,
3863 .deserialize_item = service_deserialize_item,
3865 .active_state = service_active_state,
3866 .sub_state_to_string = service_sub_state_to_string,
3868 .check_gc = service_check_gc,
3869 .check_snapshot = service_check_snapshot,
3871 .sigchld_event = service_sigchld_event,
3872 .timer_event = service_timer_event,
3873 .fd_event = service_fd_event,
3875 .reset_failed = service_reset_failed,
3877 .cgroup_notify_empty = service_cgroup_notify_event,
3878 .notify_message = service_notify_message,
3880 .bus_name_owner_change = service_bus_name_owner_change,
3881 .bus_query_pid_done = service_bus_query_pid_done,
3883 .bus_interface = "org.freedesktop.systemd1.Service",
3884 .bus_message_handler = bus_service_message_handler,
3885 .bus_invalidating_properties = bus_service_invalidating_properties,
3887 #ifdef HAVE_SYSV_COMPAT
3888 .enumerate = service_enumerate,
3890 .status_message_formats = {
3891 .starting_stopping = {
3892 [0] = "Starting %s...",
3893 [1] = "Stopping %s...",
3895 .finished_start_job = {
3896 [JOB_DONE] = "Started %s.",
3897 [JOB_FAILED] = "Failed to start %s.",
3898 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3899 [JOB_TIMEOUT] = "Timed out starting %s.",
3901 .finished_stop_job = {
3902 [JOB_DONE] = "Stopped %s.",
3903 [JOB_FAILED] = "Stopped (with error) %s.",
3904 [JOB_TIMEOUT] = "Timed out stopping %s.",