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>
27 #include <linux/reboot.h>
28 #include <sys/syscall.h>
33 #include "load-fragment.h"
34 #include "load-dropin.h"
37 #include "unit-name.h"
38 #include "unit-printf.h"
39 #include "dbus-service.h"
41 #include "exit-status.h"
43 #include "path-util.h"
48 #include "bus-error.h"
51 #ifdef HAVE_SYSV_COMPAT
53 #define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
55 typedef enum RunlevelType {
63 const RunlevelType type;
65 /* Standard SysV runlevels for start-up */
66 { "rc1.d", SPECIAL_RESCUE_TARGET, RUNLEVEL_UP },
67 { "rc2.d", SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
68 { "rc3.d", SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
69 { "rc4.d", SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
70 { "rc5.d", SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
72 /* Standard SysV runlevels for shutdown */
73 { "rc0.d", SPECIAL_POWEROFF_TARGET, RUNLEVEL_DOWN },
74 { "rc6.d", SPECIAL_REBOOT_TARGET, RUNLEVEL_DOWN }
76 /* Note that the order here matters, as we read the
77 directories in this order, and we want to make sure that
78 sysv_start_priority is known when we first load the
79 unit. And that value we only know from S links. Hence
80 UP must be read before DOWN */
83 #define RUNLEVELS_UP "12345"
86 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
87 [SERVICE_DEAD] = UNIT_INACTIVE,
88 [SERVICE_START_PRE] = UNIT_ACTIVATING,
89 [SERVICE_START] = UNIT_ACTIVATING,
90 [SERVICE_START_POST] = UNIT_ACTIVATING,
91 [SERVICE_RUNNING] = UNIT_ACTIVE,
92 [SERVICE_EXITED] = UNIT_ACTIVE,
93 [SERVICE_RELOAD] = UNIT_RELOADING,
94 [SERVICE_STOP] = UNIT_DEACTIVATING,
95 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
96 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
97 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
98 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
99 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
100 [SERVICE_FAILED] = UNIT_FAILED,
101 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
104 /* For Type=idle we never want to delay any other jobs, hence we
105 * consider idle jobs active as soon as we start working on them */
106 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
107 [SERVICE_DEAD] = UNIT_INACTIVE,
108 [SERVICE_START_PRE] = UNIT_ACTIVE,
109 [SERVICE_START] = UNIT_ACTIVE,
110 [SERVICE_START_POST] = UNIT_ACTIVE,
111 [SERVICE_RUNNING] = UNIT_ACTIVE,
112 [SERVICE_EXITED] = UNIT_ACTIVE,
113 [SERVICE_RELOAD] = UNIT_RELOADING,
114 [SERVICE_STOP] = UNIT_DEACTIVATING,
115 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
116 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
117 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
118 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
119 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
120 [SERVICE_FAILED] = UNIT_FAILED,
121 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
124 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
125 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
126 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
128 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
130 static void service_init(Unit *u) {
131 Service *s = SERVICE(u);
134 assert(u->load_state == UNIT_STUB);
136 s->timeout_start_usec = u->manager->default_timeout_start_usec;
137 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
138 s->restart_usec = u->manager->default_restart_usec;
139 s->type = _SERVICE_TYPE_INVALID;
141 #ifdef HAVE_SYSV_COMPAT
142 s->sysv_start_priority = -1;
143 s->sysv_start_priority_from_rcnd = -1;
146 s->guess_main_pid = true;
148 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
150 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
153 static void service_unwatch_control_pid(Service *s) {
156 if (s->control_pid <= 0)
159 unit_unwatch_pid(UNIT(s), s->control_pid);
163 static void service_unwatch_main_pid(Service *s) {
166 if (s->main_pid <= 0)
169 unit_unwatch_pid(UNIT(s), s->main_pid);
173 static void service_unwatch_pid_file(Service *s) {
174 if (!s->pid_file_pathspec)
177 log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s",
178 UNIT(s)->id, s->pid_file_pathspec->path);
179 path_spec_unwatch(s->pid_file_pathspec);
180 path_spec_done(s->pid_file_pathspec);
181 free(s->pid_file_pathspec);
182 s->pid_file_pathspec = NULL;
185 static int service_set_main_pid(Service *s, pid_t pid) {
196 if (s->main_pid == pid && s->main_pid_known)
199 if (s->main_pid != pid) {
200 service_unwatch_main_pid(s);
201 exec_status_start(&s->main_exec_status, pid);
205 s->main_pid_known = true;
207 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
208 log_warning_unit(UNIT(s)->id,
209 "%s: Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.",
212 s->main_pid_alien = true;
214 s->main_pid_alien = false;
219 static void service_close_socket_fd(Service *s) {
222 if (s->socket_fd < 0)
225 s->socket_fd = safe_close(s->socket_fd);
228 static void service_connection_unref(Service *s) {
231 if (!UNIT_ISSET(s->accept_socket))
234 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
235 unit_ref_unset(&s->accept_socket);
238 static void service_stop_watchdog(Service *s) {
241 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
242 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
245 static void service_start_watchdog(Service *s) {
250 if (s->watchdog_usec <= 0)
253 if (s->watchdog_event_source) {
254 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
256 log_warning_unit(UNIT(s)->id, "%s failed to reset watchdog timer: %s", UNIT(s)->id, strerror(-r));
260 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
262 r = sd_event_add_time(
263 UNIT(s)->manager->event,
264 &s->watchdog_event_source,
266 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
267 service_dispatch_watchdog, s);
269 log_warning_unit(UNIT(s)->id, "%s failed to add watchdog timer: %s", UNIT(s)->id, strerror(-r));
273 /* Let's process everything else which might be a sign
274 * of living before we consider a service died. */
275 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
279 log_warning_unit(UNIT(s)->id, "%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
282 static void service_reset_watchdog(Service *s) {
285 dual_timestamp_get(&s->watchdog_timestamp);
286 service_start_watchdog(s);
289 static void service_done(Unit *u) {
290 Service *s = SERVICE(u);
297 #ifdef HAVE_SYSV_COMPAT
298 free(s->sysv_runlevels);
299 s->sysv_runlevels = NULL;
302 free(s->status_text);
303 s->status_text = NULL;
306 s->reboot_arg = NULL;
308 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
309 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
310 s->control_command = NULL;
311 s->main_command = NULL;
313 set_free(s->restart_ignore_status.code);
314 s->restart_ignore_status.code = NULL;
315 set_free(s->restart_ignore_status.signal);
316 s->restart_ignore_status.signal = NULL;
318 set_free(s->success_status.code);
319 s->success_status.code = NULL;
320 set_free(s->success_status.signal);
321 s->success_status.signal = NULL;
323 /* This will leak a process, but at least no memory or any of
325 service_unwatch_main_pid(s);
326 service_unwatch_control_pid(s);
327 service_unwatch_pid_file(s);
330 unit_unwatch_bus_name(u, s->bus_name);
335 service_close_socket_fd(s);
336 service_connection_unref(s);
338 unit_ref_unset(&s->accept_socket);
340 service_stop_watchdog(s);
342 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
345 static int service_arm_timer(Service *s, usec_t usec) {
350 if (s->timer_event_source) {
351 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
355 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
358 return sd_event_add_time(
359 UNIT(s)->manager->event,
360 &s->timer_event_source,
362 now(CLOCK_MONOTONIC) + usec, 0,
363 service_dispatch_timer, s);
366 #ifdef HAVE_SYSV_COMPAT
367 static char *sysv_translate_name(const char *name) {
370 r = new(char, strlen(name) + strlen(".service") + 1);
374 if (endswith(name, ".sh"))
375 /* Drop .sh suffix */
376 strcpy(stpcpy(r, name) - 3, ".service");
378 /* Normal init script name */
379 strcpy(stpcpy(r, name), ".service");
384 static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
386 /* We silently ignore the $ prefix here. According to the LSB
387 * spec it simply indicates whether something is a
388 * standardized name or a distribution-specific one. Since we
389 * just follow what already exists and do not introduce new
390 * uses or names we don't care who introduced a new name. */
392 static const char * const table[] = {
393 /* LSB defined facilities */
395 "network", SPECIAL_NETWORK_ONLINE_TARGET,
396 "named", SPECIAL_NSS_LOOKUP_TARGET,
397 "portmap", SPECIAL_RPCBIND_TARGET,
398 "remote_fs", SPECIAL_REMOTE_FS_TARGET,
400 "time", SPECIAL_TIME_SYNC_TARGET,
410 n = *name == '$' ? name + 1 : name;
412 for (i = 0; i < ELEMENTSOF(table); i += 2) {
414 if (!streq(table[i], n))
420 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, const bool supports_reload) {
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 if (supports_reload) {
547 c = exec_command_new(UNIT(s)->source_path, "reload");
550 exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
556 static bool usage_contains_reload(const char *line) {
557 return (strcasestr(line, "{reload|") ||
558 strcasestr(line, "{reload}") ||
559 strcasestr(line, "{reload\"") ||
560 strcasestr(line, "|reload|") ||
561 strcasestr(line, "|reload}") ||
562 strcasestr(line, "|reload\""));
565 static int service_load_sysv_path(Service *s, const char *path) {
577 char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
579 bool supports_reload = false;
586 f = fopen(path, "re");
588 r = errno == ENOENT ? 0 : -errno;
592 if (fstat(fileno(f), &st) < 0) {
597 free(u->source_path);
598 u->source_path = strdup(path);
599 if (!u->source_path) {
603 u->source_mtime = timespec_load(&st.st_mtim);
605 if (null_or_empty(&st)) {
606 u->load_state = UNIT_MASKED;
614 char l[LINE_MAX], *t;
616 if (!fgets(l, sizeof(l), f)) {
621 log_error_unit(u->id,
622 "Failed to read configuration file '%s': %s",
631 /* Try to figure out whether this init script supports
632 * the reload operation. This heuristic looks for
633 * "Usage" lines which include the reload option. */
634 if ( state == USAGE_CONTINUATION ||
635 (state == NORMAL && strcasestr(t, "usage"))) {
636 if (usage_contains_reload(t)) {
637 supports_reload = true;
639 } else if (t[strlen(t)-1] == '\\')
640 state = USAGE_CONTINUATION;
648 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
650 s->sysv_has_lsb = true;
654 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
660 t += strspn(t, WHITESPACE);
662 if (state == NORMAL) {
664 /* Try to parse Red Hat style chkconfig headers */
666 if (startswith_no_case(t, "chkconfig:")) {
668 char runlevels[16], *k;
672 if (sscanf(t+10, "%15s %i %*i", runlevels, &start_priority) != 2) {
673 log_warning_unit(u->id, "[%s:%u] Failed to parse chkconfig line. Ignoring.", path, line);
677 /* A start priority gathered from the
678 * symlink farms is preferred over the
679 * data from the LSB header. */
680 if (start_priority < 0 || start_priority > 99)
681 log_warning_unit(u->id, "[%s:%u] Start priority out of range. Ignoring.", path, line);
683 log_debug_unit(u->id, "[%s:%u] Ignoring start priority set in the chkconfig file.", path, line);
685 char_array_0(runlevels);
686 k = delete_chars(runlevels, WHITESPACE "-");
696 free(s->sysv_runlevels);
697 s->sysv_runlevels = d;
700 } else if (startswith_no_case(t, "description:")) {
702 size_t k = strlen(t);
706 if (t[k-1] == '\\') {
711 if ((j = strstrip(t+12)) && *j) {
712 if (!(d = strdup(j))) {
719 free(chkconfig_description);
720 chkconfig_description = d;
722 } else if (startswith_no_case(t, "pidfile:")) {
729 if (!path_is_absolute(fn)) {
730 log_warning_unit(u->id,
731 "[%s:%u] PID file not absolute. Ignoring.",
736 if (!(fn = strdup(fn))) {
745 } else if (state == DESCRIPTION) {
747 /* Try to parse Red Hat style description
750 size_t k = strlen(t);
758 if ((j = strstrip(t)) && *j) {
761 if (chkconfig_description)
762 d = strjoin(chkconfig_description, " ", j, NULL);
771 free(chkconfig_description);
772 chkconfig_description = d;
775 } else if (state == LSB || state == LSB_DESCRIPTION) {
777 if (startswith_no_case(t, "Provides:")) {
783 FOREACH_WORD_QUOTED(w, z, t+9, i) {
786 if (!(n = strndup(w, z))) {
791 r = sysv_translate_facility(n, basename(path), &m);
800 if (unit_name_to_type(m) == UNIT_SERVICE)
801 r = unit_merge_by_name(u, m);
808 * indication that the
810 * now available. This
813 * targets do NOT pull
816 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
819 log_error_unit(u->id,
820 "[%s:%u] Failed to add LSB Provides name %s, ignoring: %s",
821 path, line, m, strerror(-r));
826 } else if (startswith_no_case(t, "Required-Start:") ||
827 startswith_no_case(t, "Should-Start:") ||
828 startswith_no_case(t, "X-Start-Before:") ||
829 startswith_no_case(t, "X-Start-After:")) {
835 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
839 if (!(n = strndup(w, z))) {
844 r = sysv_translate_facility(n, basename(path), &m);
846 log_error_unit(u->id,
847 "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
848 path, line, n, strerror(-r));
858 is_before = startswith_no_case(t, "X-Start-Before:");
860 if (streq(m, SPECIAL_NETWORK_ONLINE_TARGET) && !is_before)
861 /* the network-online target is special, as it needs to be actively pulled in */
862 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, m, NULL, true);
864 r = unit_add_dependency_by_name(u, is_before ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
867 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
868 path, line, m, strerror(-r));
872 } else if (startswith_no_case(t, "Default-Start:")) {
877 k = delete_chars(t+14, WHITESPACE "-");
880 if (!(d = strdup(k))) {
885 free(s->sysv_runlevels);
886 s->sysv_runlevels = d;
889 } else if (startswith_no_case(t, "Description:")) {
892 state = LSB_DESCRIPTION;
894 if ((j = strstrip(t+12)) && *j) {
895 if (!(d = strdup(j))) {
902 free(long_description);
903 long_description = d;
905 } else if (startswith_no_case(t, "Short-Description:")) {
910 if ((j = strstrip(t+18)) && *j) {
911 if (!(d = strdup(j))) {
918 free(short_description);
919 short_description = d;
921 } else if (state == LSB_DESCRIPTION) {
923 if (startswith(l, "#\t") || startswith(l, "# ")) {
926 if ((j = strstrip(t)) && *j) {
929 if (long_description)
930 d = strjoin(long_description, " ", t, NULL);
939 free(long_description);
940 long_description = d;
949 if ((r = sysv_exec_commands(s, supports_reload)) < 0)
952 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
953 /* If there a runlevels configured for this service
954 * but none of the standard ones, then we assume this
955 * is some special kind of service (which might be
956 * needed for early boot) and don't create any links
959 UNIT(s)->default_dependencies = false;
961 /* Don't timeout special services during boot (like fsck) */
962 s->timeout_start_usec = 0;
963 s->timeout_stop_usec = 0;
965 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
966 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
969 /* Special setting for all SysV services */
970 s->type = SERVICE_FORKING;
971 s->remain_after_exit = !s->pid_file;
972 s->guess_main_pid = false;
973 s->restart = SERVICE_RESTART_NO;
974 s->exec_context.ignore_sigpipe = false;
975 s->kill_context.kill_mode = KILL_PROCESS;
977 /* We use the long description only if
978 * no short description is set. */
980 if (short_description)
981 description = short_description;
982 else if (chkconfig_description)
983 description = chkconfig_description;
984 else if (long_description)
985 description = long_description;
992 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
1000 /* Initialize the start priority from what has been set in the
1001 * /etc/rcN.d/ hierarchies if we load the unit file as SysV
1003 if (s->sysv_start_priority_from_rcnd >= 0)
1004 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
1006 u->load_state = UNIT_LOADED;
1014 free(short_description);
1015 free(long_description);
1016 free(chkconfig_description);
1021 static int service_load_sysv_name(Service *s, const char *name) {
1027 /* For SysV services we strip the *.sh suffixes. */
1028 if (endswith(name, ".sh.service"))
1031 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
1035 path = strjoin(*p, "/", name, NULL);
1039 assert(endswith(path, ".service"));
1040 path[strlen(path)-8] = 0;
1042 r = service_load_sysv_path(s, path);
1044 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1045 /* Try *.sh source'able init scripts */
1046 strcat(path, ".sh");
1047 r = service_load_sysv_path(s, path);
1054 if (UNIT(s)->load_state != UNIT_STUB)
1061 static int service_load_sysv(Service *s) {
1068 /* Load service data from SysV init scripts, preferably with
1069 * LSB headers ... */
1071 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1074 if ((t = UNIT(s)->id))
1075 if ((r = service_load_sysv_name(s, t)) < 0)
1078 if (UNIT(s)->load_state == UNIT_STUB)
1079 SET_FOREACH(t, UNIT(s)->names, i) {
1080 if (t == UNIT(s)->id)
1083 if ((r = service_load_sysv_name(s, t)) < 0)
1086 if (UNIT(s)->load_state != UNIT_STUB)
1094 static int service_verify(Service *s) {
1097 if (UNIT(s)->load_state != UNIT_LOADED)
1100 if (!s->exec_command[SERVICE_EXEC_START]) {
1101 log_error_unit(UNIT(s)->id, "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1105 if (s->type != SERVICE_ONESHOT &&
1106 s->exec_command[SERVICE_EXEC_START]->command_next) {
1107 log_error_unit(UNIT(s)->id, "%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1111 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
1112 log_error_unit(UNIT(s)->id, "%s has Restart setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1116 if (s->type == SERVICE_DBUS && !s->bus_name) {
1117 log_error_unit(UNIT(s)->id, "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1121 if (s->bus_name && s->type != SERVICE_DBUS)
1122 log_warning_unit(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1124 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
1125 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
1132 static int service_add_default_dependencies(Service *s) {
1137 /* Add a number of automatic dependencies useful for the
1138 * majority of services. */
1140 /* First, pull in base system */
1141 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1142 SPECIAL_BASIC_TARGET, NULL, true);
1146 /* Second, activate normal shutdown */
1147 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1148 SPECIAL_SHUTDOWN_TARGET, NULL, true);
1152 static void service_fix_output(Service *s) {
1155 /* If nothing has been explicitly configured, patch default
1156 * output in. If input is socket/tty we avoid this however,
1157 * since in that case we want output to default to the same
1158 * place as we read input from. */
1160 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1161 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1162 s->exec_context.std_input == EXEC_INPUT_NULL)
1163 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1165 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1166 s->exec_context.std_input == EXEC_INPUT_NULL)
1167 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1170 static int service_load(Unit *u) {
1172 Service *s = SERVICE(u);
1176 /* Load a .service file */
1177 r = unit_load_fragment(u);
1181 #ifdef HAVE_SYSV_COMPAT
1182 /* Load a classic init script as a fallback, if we couldn't find anything */
1183 if (u->load_state == UNIT_STUB) {
1184 r = service_load_sysv(s);
1190 /* Still nothing found? Then let's give up */
1191 if (u->load_state == UNIT_STUB)
1194 /* This is a new unit? Then let's add in some extras */
1195 if (u->load_state == UNIT_LOADED) {
1197 /* We were able to load something, then let's add in
1198 * the dropin directories. */
1199 r = unit_load_dropin(u);
1203 if (s->type == _SERVICE_TYPE_INVALID)
1204 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1206 /* Oneshot services have disabled start timeout by default */
1207 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1208 s->timeout_start_usec = 0;
1210 service_fix_output(s);
1212 r = unit_patch_contexts(u);
1216 r = unit_add_exec_dependencies(u, &s->exec_context);
1220 r = unit_add_default_slice(u, &s->cgroup_context);
1224 #ifdef HAVE_SYSV_COMPAT
1225 r = sysv_fix_order(s);
1230 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1231 s->notify_access = NOTIFY_MAIN;
1233 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1234 s->notify_access = NOTIFY_MAIN;
1237 r = unit_watch_bus_name(u, s->bus_name);
1242 if (u->default_dependencies) {
1243 r = service_add_default_dependencies(s);
1249 return service_verify(s);
1252 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1254 ServiceExecCommand c;
1255 Service *s = SERVICE(u);
1256 const char *prefix2;
1257 _cleanup_free_ char *p2 = NULL;
1261 p2 = strappend(prefix, "\t");
1262 prefix2 = p2 ? p2 : prefix;
1265 "%sService State: %s\n"
1267 "%sReload Result: %s\n"
1268 "%sPermissionsStartOnly: %s\n"
1269 "%sRootDirectoryStartOnly: %s\n"
1270 "%sRemainAfterExit: %s\n"
1271 "%sGuessMainPID: %s\n"
1274 "%sNotifyAccess: %s\n",
1275 prefix, service_state_to_string(s->state),
1276 prefix, service_result_to_string(s->result),
1277 prefix, service_result_to_string(s->reload_result),
1278 prefix, yes_no(s->permissions_start_only),
1279 prefix, yes_no(s->root_directory_start_only),
1280 prefix, yes_no(s->remain_after_exit),
1281 prefix, yes_no(s->guess_main_pid),
1282 prefix, service_type_to_string(s->type),
1283 prefix, service_restart_to_string(s->restart),
1284 prefix, notify_access_to_string(s->notify_access));
1286 if (s->control_pid > 0)
1288 "%sControl PID: "PID_FMT"\n",
1289 prefix, s->control_pid);
1291 if (s->main_pid > 0)
1293 "%sMain PID: "PID_FMT"\n"
1294 "%sMain PID Known: %s\n"
1295 "%sMain PID Alien: %s\n",
1296 prefix, s->main_pid,
1297 prefix, yes_no(s->main_pid_known),
1298 prefix, yes_no(s->main_pid_alien));
1303 prefix, s->pid_file);
1308 "%sBus Name Good: %s\n",
1309 prefix, s->bus_name,
1310 prefix, yes_no(s->bus_name_good));
1312 kill_context_dump(&s->kill_context, f, prefix);
1313 exec_context_dump(&s->exec_context, f, prefix);
1315 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1317 if (!s->exec_command[c])
1320 fprintf(f, "%s-> %s:\n",
1321 prefix, service_exec_command_to_string(c));
1323 exec_command_dump_list(s->exec_command[c], f, prefix2);
1326 #ifdef HAVE_SYSV_COMPAT
1329 "%sSysV Init Script has LSB Header: %s\n"
1330 "%sSysVEnabled: %s\n",
1331 prefix, yes_no(s->sysv_has_lsb),
1332 prefix, yes_no(s->sysv_enabled));
1334 if (s->sysv_start_priority >= 0)
1336 "%sSysVStartPriority: %i\n",
1337 prefix, s->sysv_start_priority);
1339 if (s->sysv_runlevels)
1340 fprintf(f, "%sSysVRunLevels: %s\n",
1341 prefix, s->sysv_runlevels);
1345 fprintf(f, "%sStatus Text: %s\n",
1346 prefix, s->status_text);
1349 static int service_load_pid_file(Service *s, bool may_warn) {
1350 _cleanup_free_ char *k = NULL;
1359 r = read_one_line_file(s->pid_file, &k);
1362 log_info_unit(UNIT(s)->id,
1363 "PID file %s not readable (yet?) after %s.",
1364 s->pid_file, service_state_to_string(s->state));
1368 r = parse_pid(k, &pid);
1371 log_info_unit(UNIT(s)->id,
1372 "Failed to read PID from file %s: %s",
1373 s->pid_file, strerror(-r));
1377 if (!pid_is_alive(pid)) {
1379 log_info_unit(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
1384 if (s->main_pid_known) {
1385 if (pid == s->main_pid)
1388 log_debug_unit(UNIT(s)->id,
1389 "Main PID changing: "PID_FMT" -> "PID_FMT,
1391 service_unwatch_main_pid(s);
1392 s->main_pid_known = false;
1394 log_debug_unit(UNIT(s)->id,
1395 "Main PID loaded: "PID_FMT, pid);
1397 r = service_set_main_pid(s, pid);
1401 r = unit_watch_pid(UNIT(s), pid);
1403 /* FIXME: we need to do something here */
1404 log_warning_unit(UNIT(s)->id,
1405 "Failed to watch PID "PID_FMT" from service %s",
1413 static int service_search_main_pid(Service *s) {
1419 /* If we know it anyway, don't ever fallback to unreliable
1421 if (s->main_pid_known)
1424 if (!s->guess_main_pid)
1427 assert(s->main_pid <= 0);
1429 pid = unit_search_main_pid(UNIT(s));
1433 log_debug_unit(UNIT(s)->id,
1434 "Main PID guessed: "PID_FMT, pid);
1435 r = service_set_main_pid(s, pid);
1439 r = unit_watch_pid(UNIT(s), pid);
1441 /* FIXME: we need to do something here */
1442 log_warning_unit(UNIT(s)->id,
1443 "Failed to watch PID "PID_FMT" from service %s",
1448 static void service_set_state(Service *s, ServiceState state) {
1449 ServiceState old_state;
1450 const UnitActiveState *table;
1454 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1456 old_state = s->state;
1459 service_unwatch_pid_file(s);
1462 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1464 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1466 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1467 SERVICE_AUTO_RESTART))
1468 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1471 SERVICE_START, SERVICE_START_POST,
1472 SERVICE_RUNNING, SERVICE_RELOAD,
1473 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1475 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1476 service_unwatch_main_pid(s);
1477 s->main_command = NULL;
1481 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1483 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1485 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1486 service_unwatch_control_pid(s);
1487 s->control_command = NULL;
1488 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1491 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1492 unit_unwatch_all_pids(UNIT(s));
1495 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1496 SERVICE_RUNNING, SERVICE_RELOAD,
1497 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1498 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1499 !(state == SERVICE_DEAD && UNIT(s)->job)) {
1500 service_close_socket_fd(s);
1501 service_connection_unref(s);
1504 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1505 service_stop_watchdog(s);
1507 /* For the inactive states unit_notify() will trim the cgroup,
1508 * but for exit we have to do that ourselves... */
1509 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1510 unit_destroy_cgroup(UNIT(s));
1512 /* For remain_after_exit services, let's see if we can "release" the
1513 * hold on the console, since unit_notify() only does that in case of
1514 * change of state */
1515 if (state == SERVICE_EXITED && s->remain_after_exit &&
1516 UNIT(s)->manager->n_on_console > 0) {
1517 ExecContext *ec = unit_get_exec_context(UNIT(s));
1518 if (ec && exec_context_may_touch_console(ec)) {
1519 Manager *m = UNIT(s)->manager;
1522 if (m->n_on_console == 0)
1523 /* unset no_console_output flag, since the console is free */
1524 m->no_console_output = false;
1528 if (old_state != state)
1529 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1531 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1532 s->reload_result = SERVICE_SUCCESS;
1535 static int service_coldplug(Unit *u) {
1536 Service *s = SERVICE(u);
1540 assert(s->state == SERVICE_DEAD);
1542 if (s->deserialized_state != s->state) {
1544 if (IN_SET(s->deserialized_state,
1545 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1547 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1549 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1553 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
1555 /* For the start/stop timeouts 0 means off */
1557 r = service_arm_timer(s, k);
1563 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
1565 /* The restart timeouts 0 means immediately */
1566 r = service_arm_timer(s, s->restart_usec);
1571 if (pid_is_unwaited(s->main_pid) &&
1572 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
1573 IN_SET(s->deserialized_state,
1574 SERVICE_START, SERVICE_START_POST,
1575 SERVICE_RUNNING, SERVICE_RELOAD,
1576 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1578 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
1579 r = unit_watch_pid(UNIT(s), s->main_pid);
1584 if (pid_is_unwaited(s->control_pid) &&
1585 IN_SET(s->deserialized_state,
1586 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1588 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1590 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1591 r = unit_watch_pid(UNIT(s), s->control_pid);
1596 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1597 unit_watch_all_pids(UNIT(s));
1599 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1600 service_start_watchdog(s);
1602 service_set_state(s, s->deserialized_state);
1608 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1612 unsigned rn_fds = 0;
1619 if (s->socket_fd >= 0)
1622 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1627 if (u->type != UNIT_SOCKET)
1632 r = socket_collect_fds(sock, &cfds, &cn_fds);
1645 t = new(int, rn_fds+cn_fds);
1652 memcpy(t, rfds, rn_fds * sizeof(int));
1653 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1658 rn_fds = rn_fds+cn_fds;
1673 static int service_spawn(
1678 bool apply_permissions,
1680 bool apply_tty_stdin,
1681 bool set_notify_socket,
1688 _cleanup_free_ int *fdsbuf = NULL;
1689 unsigned n_fds = 0, n_env = 0;
1690 _cleanup_strv_free_ char
1691 **argv = NULL, **final_env = NULL, **our_env = NULL;
1698 unit_realize_cgroup(UNIT(s));
1700 r = unit_setup_exec_runtime(UNIT(s));
1705 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1706 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1707 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1709 if (s->socket_fd >= 0) {
1710 fds = &s->socket_fd;
1713 r = service_collect_fds(s, &fdsbuf, &n_fds);
1721 if (timeout && s->timeout_start_usec > 0) {
1722 r = service_arm_timer(s, s->timeout_start_usec);
1726 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1728 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1732 our_env = new0(char*, 4);
1738 if (set_notify_socket)
1739 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1744 if (s->main_pid > 0)
1745 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
1750 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1751 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
1756 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1762 if (is_control && UNIT(s)->cgroup_path) {
1763 path = strappenda(UNIT(s)->cgroup_path, "/control");
1764 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1766 path = UNIT(s)->cgroup_path;
1776 UNIT(s)->manager->confirm_spawn,
1777 UNIT(s)->manager->cgroup_supported,
1779 manager_get_runtime_prefix(UNIT(s)->manager),
1782 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1788 r = unit_watch_pid(UNIT(s), pid);
1790 /* FIXME: we need to do something here */
1799 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1804 static int main_pid_good(Service *s) {
1807 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1810 /* If we know the pid file, then lets just check if it is
1812 if (s->main_pid_known) {
1814 /* If it's an alien child let's check if it is still
1816 if (s->main_pid_alien && s->main_pid > 0)
1817 return pid_is_alive(s->main_pid);
1819 /* .. otherwise assume we'll get a SIGCHLD for it,
1820 * which we really should wait for to collect exit
1821 * status and code */
1822 return s->main_pid > 0;
1825 /* We don't know the pid */
1829 _pure_ static int control_pid_good(Service *s) {
1832 return s->control_pid > 0;
1835 static int cgroup_good(Service *s) {
1840 if (!UNIT(s)->cgroup_path)
1843 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1850 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none);
1852 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1856 if (f != SERVICE_SUCCESS)
1859 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1861 if (s->result != SERVICE_SUCCESS)
1862 service_execute_action(s, s->failure_action, "failed", false);
1864 if (allow_restart &&
1865 !s->forbid_restart &&
1866 (s->restart == SERVICE_RESTART_ALWAYS ||
1867 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1868 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1869 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1870 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1871 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1872 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1873 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1874 (s->result != SERVICE_FAILURE_SIGNAL ||
1875 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1877 r = service_arm_timer(s, s->restart_usec);
1881 service_set_state(s, SERVICE_AUTO_RESTART);
1884 s->forbid_restart = false;
1886 /* We want fresh tmpdirs in case service is started again immediately */
1887 exec_runtime_destroy(s->exec_runtime);
1888 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1890 /* Also, remove the runtime directory in */
1891 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1893 /* Try to delete the pid file. At this point it will be
1894 * out-of-date, and some software might be confused by it, so
1895 * let's remove it. */
1897 unlink_noerrno(s->pid_file);
1902 log_warning_unit(UNIT(s)->id,
1903 "%s failed to run install restart timer: %s",
1904 UNIT(s)->id, strerror(-r));
1905 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1908 static void service_enter_stop_post(Service *s, ServiceResult f) {
1912 if (f != SERVICE_SUCCESS)
1915 service_unwatch_control_pid(s);
1916 unit_watch_all_pids(UNIT(s));
1918 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1919 if (s->control_command) {
1920 s->control_command_id = SERVICE_EXEC_STOP_POST;
1922 r = service_spawn(s,
1926 !s->permissions_start_only,
1927 !s->root_directory_start_only,
1935 service_set_state(s, SERVICE_STOP_POST);
1937 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1942 log_warning_unit(UNIT(s)->id,
1943 "%s failed to run 'stop-post' task: %s",
1944 UNIT(s)->id, strerror(-r));
1945 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1948 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1953 if (f != SERVICE_SUCCESS)
1956 unit_watch_all_pids(UNIT(s));
1958 r = unit_kill_context(
1961 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1970 if (s->timeout_stop_usec > 0) {
1971 r = service_arm_timer(s, s->timeout_stop_usec);
1976 service_set_state(s, state);
1977 } else if (state == SERVICE_STOP_SIGTERM)
1978 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1979 else if (state == SERVICE_STOP_SIGKILL)
1980 service_enter_stop_post(s, SERVICE_SUCCESS);
1981 else if (state == SERVICE_FINAL_SIGTERM)
1982 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1984 service_enter_dead(s, SERVICE_SUCCESS, true);
1989 log_warning_unit(UNIT(s)->id,
1990 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1992 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1993 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1995 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1998 static void service_enter_stop(Service *s, ServiceResult f) {
2003 if (f != SERVICE_SUCCESS)
2006 service_unwatch_control_pid(s);
2007 unit_watch_all_pids(UNIT(s));
2009 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2010 if (s->control_command) {
2011 s->control_command_id = SERVICE_EXEC_STOP;
2013 r = service_spawn(s,
2017 !s->permissions_start_only,
2018 !s->root_directory_start_only,
2026 service_set_state(s, SERVICE_STOP);
2028 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2033 log_warning_unit(UNIT(s)->id,
2034 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2035 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2038 static void service_enter_running(Service *s, ServiceResult f) {
2039 int main_pid_ok, cgroup_ok;
2042 if (f != SERVICE_SUCCESS)
2045 main_pid_ok = main_pid_good(s);
2046 cgroup_ok = cgroup_good(s);
2048 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2049 (s->bus_name_good || s->type != SERVICE_DBUS))
2050 service_set_state(s, SERVICE_RUNNING);
2051 else if (s->remain_after_exit)
2052 service_set_state(s, SERVICE_EXITED);
2054 service_enter_stop(s, SERVICE_SUCCESS);
2057 static void service_enter_start_post(Service *s) {
2061 service_unwatch_control_pid(s);
2062 service_reset_watchdog(s);
2064 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2065 if (s->control_command) {
2066 s->control_command_id = SERVICE_EXEC_START_POST;
2068 r = service_spawn(s,
2072 !s->permissions_start_only,
2073 !s->root_directory_start_only,
2081 service_set_state(s, SERVICE_START_POST);
2083 service_enter_running(s, SERVICE_SUCCESS);
2088 log_warning_unit(UNIT(s)->id,
2089 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2090 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2093 static void service_kill_control_processes(Service *s) {
2096 if (!UNIT(s)->cgroup_path)
2099 p = strappenda(UNIT(s)->cgroup_path, "/control");
2100 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2103 static void service_enter_start(Service *s) {
2110 assert(s->exec_command[SERVICE_EXEC_START]);
2111 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2113 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 service_kill_control_processes(s);
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 ||
2136 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2141 s->notify_access != NOTIFY_NONE,
2147 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2148 /* For simple services we immediately start
2149 * the START_POST binaries. */
2151 service_set_main_pid(s, pid);
2152 service_enter_start_post(s);
2154 } else if (s->type == SERVICE_FORKING) {
2156 /* For forking services we wait until the start
2157 * process exited. */
2159 s->control_pid = pid;
2160 service_set_state(s, SERVICE_START);
2162 } else if (s->type == SERVICE_ONESHOT ||
2163 s->type == SERVICE_DBUS ||
2164 s->type == SERVICE_NOTIFY) {
2166 /* For oneshot services we wait until the start
2167 * process exited, too, but it is our main process. */
2169 /* For D-Bus services we know the main pid right away,
2170 * but wait for the bus name to appear on the
2171 * bus. Notify services are similar. */
2173 service_set_main_pid(s, pid);
2174 service_set_state(s, SERVICE_START);
2176 assert_not_reached("Unknown service type");
2181 log_warning_unit(UNIT(s)->id,
2182 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2183 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2186 static void service_enter_start_pre(Service *s) {
2191 service_unwatch_control_pid(s);
2193 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2194 if (s->control_command) {
2195 /* Before we start anything, let's clear up what might
2196 * be left from previous runs. */
2197 service_kill_control_processes(s);
2199 s->control_command_id = SERVICE_EXEC_START_PRE;
2201 r = service_spawn(s,
2205 !s->permissions_start_only,
2206 !s->root_directory_start_only,
2214 service_set_state(s, SERVICE_START_PRE);
2216 service_enter_start(s);
2221 log_warning_unit(UNIT(s)->id,
2222 "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2223 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2226 static void service_enter_restart(Service *s) {
2227 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2232 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2233 /* Don't restart things if we are going down anyway */
2234 log_info_unit(UNIT(s)->id,
2235 "Stop job pending for unit, delaying automatic restart.");
2237 r = service_arm_timer(s, s->restart_usec);
2244 /* Any units that are bound to this service must also be
2245 * restarted. We use JOB_RESTART (instead of the more obvious
2246 * JOB_START) here so that those dependency jobs will be added
2248 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2252 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2253 * it will be canceled as part of the service_stop() call that
2254 * is executed as part of JOB_RESTART. */
2256 log_debug_unit(UNIT(s)->id,
2257 "%s scheduled restart job.", UNIT(s)->id);
2261 log_warning_unit(UNIT(s)->id,
2262 "%s failed to schedule restart job: %s",
2263 UNIT(s)->id, bus_error_message(&error, -r));
2264 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2267 static void service_enter_reload(Service *s) {
2272 service_unwatch_control_pid(s);
2274 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2275 if (s->control_command) {
2276 s->control_command_id = SERVICE_EXEC_RELOAD;
2278 r = service_spawn(s,
2282 !s->permissions_start_only,
2283 !s->root_directory_start_only,
2291 service_set_state(s, SERVICE_RELOAD);
2293 service_enter_running(s, SERVICE_SUCCESS);
2298 log_warning_unit(UNIT(s)->id,
2299 "%s failed to run 'reload' task: %s",
2300 UNIT(s)->id, strerror(-r));
2301 s->reload_result = SERVICE_FAILURE_RESOURCES;
2302 service_enter_running(s, SERVICE_SUCCESS);
2305 static void service_run_next_control(Service *s) {
2309 assert(s->control_command);
2310 assert(s->control_command->command_next);
2312 assert(s->control_command_id != SERVICE_EXEC_START);
2314 s->control_command = s->control_command->command_next;
2315 service_unwatch_control_pid(s);
2317 r = service_spawn(s,
2321 !s->permissions_start_only,
2322 !s->root_directory_start_only,
2323 s->control_command_id == SERVICE_EXEC_START_PRE ||
2324 s->control_command_id == SERVICE_EXEC_STOP_POST,
2334 log_warning_unit(UNIT(s)->id,
2335 "%s failed to run next control task: %s",
2336 UNIT(s)->id, strerror(-r));
2338 if (s->state == SERVICE_START_PRE)
2339 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2340 else if (s->state == SERVICE_STOP)
2341 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2342 else if (s->state == SERVICE_STOP_POST)
2343 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2344 else if (s->state == SERVICE_RELOAD) {
2345 s->reload_result = SERVICE_FAILURE_RESOURCES;
2346 service_enter_running(s, SERVICE_SUCCESS);
2348 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2351 static void service_run_next_main(Service *s) {
2356 assert(s->main_command);
2357 assert(s->main_command->command_next);
2358 assert(s->type == SERVICE_ONESHOT);
2360 s->main_command = s->main_command->command_next;
2361 service_unwatch_main_pid(s);
2363 r = service_spawn(s,
2370 s->notify_access != NOTIFY_NONE,
2376 service_set_main_pid(s, pid);
2381 log_warning_unit(UNIT(s)->id,
2382 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2383 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2386 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none) {
2389 if (action == SERVICE_FAILURE_ACTION_REBOOT ||
2390 action == SERVICE_FAILURE_ACTION_REBOOT_FORCE)
2391 update_reboot_param_file(s->reboot_arg);
2395 case SERVICE_FAILURE_ACTION_NONE:
2396 if (log_action_none)
2397 log_warning_unit(UNIT(s)->id,
2398 "%s %s, refusing to start.", UNIT(s)->id, reason);
2401 case SERVICE_FAILURE_ACTION_REBOOT: {
2402 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2405 log_warning_unit(UNIT(s)->id,
2406 "%s %s, rebooting.", UNIT(s)->id, reason);
2408 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2409 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2410 true, &error, NULL);
2412 log_error_unit(UNIT(s)->id,
2413 "Failed to reboot: %s.", bus_error_message(&error, r));
2418 case SERVICE_FAILURE_ACTION_REBOOT_FORCE:
2419 log_warning_unit(UNIT(s)->id,
2420 "%s %s, forcibly rebooting.", UNIT(s)->id, reason);
2421 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2424 case SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE:
2425 log_warning_unit(UNIT(s)->id,
2426 "%s %s, rebooting immediately.", UNIT(s)->id, reason);
2428 if (s->reboot_arg) {
2429 log_info("Rebooting with argument '%s'.", s->reboot_arg);
2430 syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
2431 LINUX_REBOOT_CMD_RESTART2, s->reboot_arg);
2434 log_info("Rebooting.");
2435 reboot(RB_AUTOBOOT);
2439 log_error_unit(UNIT(s)->id,
2440 "failure action=%i", action);
2441 assert_not_reached("Unknown FailureAction.");
2447 static int service_start_limit_test(Service *s) {
2450 if (ratelimit_test(&s->start_limit))
2453 return service_execute_action(s, s->start_limit_action, "start request repeated too quickly", true);
2456 static int service_start(Unit *u) {
2457 Service *s = SERVICE(u);
2462 /* We cannot fulfill this request right now, try again later
2464 if (s->state == SERVICE_STOP ||
2465 s->state == SERVICE_STOP_SIGTERM ||
2466 s->state == SERVICE_STOP_SIGKILL ||
2467 s->state == SERVICE_STOP_POST ||
2468 s->state == SERVICE_FINAL_SIGTERM ||
2469 s->state == SERVICE_FINAL_SIGKILL)
2472 /* Already on it! */
2473 if (s->state == SERVICE_START_PRE ||
2474 s->state == SERVICE_START ||
2475 s->state == SERVICE_START_POST)
2478 /* A service that will be restarted must be stopped first to
2479 * trigger BindsTo and/or OnFailure dependencies. If a user
2480 * does not want to wait for the holdoff time to elapse, the
2481 * service should be manually restarted, not started. We
2482 * simply return EAGAIN here, so that any start jobs stay
2483 * queued, and assume that the auto restart timer will
2484 * eventually trigger the restart. */
2485 if (s->state == SERVICE_AUTO_RESTART)
2488 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2490 /* Make sure we don't enter a busy loop of some kind. */
2491 r = service_start_limit_test(s);
2493 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2497 s->result = SERVICE_SUCCESS;
2498 s->reload_result = SERVICE_SUCCESS;
2499 s->main_pid_known = false;
2500 s->main_pid_alien = false;
2501 s->forbid_restart = false;
2503 service_enter_start_pre(s);
2507 static int service_stop(Unit *u) {
2508 Service *s = SERVICE(u);
2512 /* Don't create restart jobs from here. */
2513 s->forbid_restart = true;
2516 if (s->state == SERVICE_STOP ||
2517 s->state == SERVICE_STOP_SIGTERM ||
2518 s->state == SERVICE_STOP_SIGKILL ||
2519 s->state == SERVICE_STOP_POST ||
2520 s->state == SERVICE_FINAL_SIGTERM ||
2521 s->state == SERVICE_FINAL_SIGKILL)
2524 /* A restart will be scheduled or is in progress. */
2525 if (s->state == SERVICE_AUTO_RESTART) {
2526 service_set_state(s, SERVICE_DEAD);
2530 /* If there's already something running we go directly into
2532 if (s->state == SERVICE_START_PRE ||
2533 s->state == SERVICE_START ||
2534 s->state == SERVICE_START_POST ||
2535 s->state == SERVICE_RELOAD) {
2536 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2540 assert(s->state == SERVICE_RUNNING ||
2541 s->state == SERVICE_EXITED);
2543 service_enter_stop(s, SERVICE_SUCCESS);
2547 static int service_reload(Unit *u) {
2548 Service *s = SERVICE(u);
2552 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2554 service_enter_reload(s);
2558 _pure_ static bool service_can_reload(Unit *u) {
2559 Service *s = SERVICE(u);
2563 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2566 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2567 Service *s = SERVICE(u);
2573 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2574 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2575 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2577 if (s->control_pid > 0)
2578 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
2581 if (s->main_pid_known && s->main_pid > 0)
2582 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
2584 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2587 unit_serialize_item(u, f, "status-text", s->status_text);
2589 /* FIXME: There's a minor uncleanliness here: if there are
2590 * multiple commands attached here, we will start from the
2591 * first one again */
2592 if (s->control_command_id >= 0)
2593 unit_serialize_item(u, f, "control-command",
2594 service_exec_command_to_string(s->control_command_id));
2596 if (s->socket_fd >= 0) {
2599 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2602 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2605 if (s->main_exec_status.pid > 0) {
2606 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
2607 s->main_exec_status.pid);
2608 dual_timestamp_serialize(f, "main-exec-status-start",
2609 &s->main_exec_status.start_timestamp);
2610 dual_timestamp_serialize(f, "main-exec-status-exit",
2611 &s->main_exec_status.exit_timestamp);
2613 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2614 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2615 s->main_exec_status.code);
2616 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2617 s->main_exec_status.status);
2620 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2621 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2623 if (s->forbid_restart)
2624 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2629 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2630 Service *s = SERVICE(u);
2637 if (streq(key, "state")) {
2640 state = service_state_from_string(value);
2642 log_debug_unit(u->id, "Failed to parse state value %s", value);
2644 s->deserialized_state = state;
2645 } else if (streq(key, "result")) {
2648 f = service_result_from_string(value);
2650 log_debug_unit(u->id, "Failed to parse result value %s", value);
2651 else if (f != SERVICE_SUCCESS)
2654 } else if (streq(key, "reload-result")) {
2657 f = service_result_from_string(value);
2659 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
2660 else if (f != SERVICE_SUCCESS)
2661 s->reload_result = f;
2663 } else if (streq(key, "control-pid")) {
2666 if (parse_pid(value, &pid) < 0)
2667 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
2669 s->control_pid = pid;
2670 } else if (streq(key, "main-pid")) {
2673 if (parse_pid(value, &pid) < 0)
2674 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
2676 service_set_main_pid(s, pid);
2677 unit_watch_pid(UNIT(s), pid);
2679 } else if (streq(key, "main-pid-known")) {
2682 b = parse_boolean(value);
2684 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
2686 s->main_pid_known = b;
2687 } else if (streq(key, "status-text")) {
2694 free(s->status_text);
2698 } else if (streq(key, "control-command")) {
2699 ServiceExecCommand id;
2701 id = service_exec_command_from_string(value);
2703 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2705 s->control_command_id = id;
2706 s->control_command = s->exec_command[id];
2708 } else if (streq(key, "socket-fd")) {
2711 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2712 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
2715 safe_close(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_unit(u->id, "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_unit(u->id, "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_unit(u->id, "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);
2745 else if (streq(key, "forbid-restart")) {
2748 b = parse_boolean(value);
2750 log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
2752 s->forbid_restart = b;
2754 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
2759 _pure_ static UnitActiveState service_active_state(Unit *u) {
2760 const UnitActiveState *table;
2764 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2766 return table[SERVICE(u)->state];
2769 static const char *service_sub_state_to_string(Unit *u) {
2772 return service_state_to_string(SERVICE(u)->state);
2775 static bool service_check_gc(Unit *u) {
2776 Service *s = SERVICE(u);
2780 /* Never clean up services that still have a process around,
2781 * even if the service is formally dead. */
2782 if (cgroup_good(s) > 0 ||
2783 main_pid_good(s) > 0 ||
2784 control_pid_good(s) > 0)
2787 #ifdef HAVE_SYSV_COMPAT
2795 _pure_ static bool service_check_snapshot(Unit *u) {
2796 Service *s = SERVICE(u);
2800 return (s->socket_fd < 0);
2803 static int service_retry_pid_file(Service *s) {
2806 assert(s->pid_file);
2807 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2809 r = service_load_pid_file(s, false);
2813 service_unwatch_pid_file(s);
2815 service_enter_running(s, SERVICE_SUCCESS);
2819 static int service_watch_pid_file(Service *s) {
2822 log_debug_unit(UNIT(s)->id,
2823 "Setting watch for %s's PID file %s",
2824 UNIT(s)->id, s->pid_file_pathspec->path);
2825 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2829 /* the pidfile might have appeared just before we set the watch */
2830 log_debug_unit(UNIT(s)->id,
2831 "Trying to read %s's PID file %s in case it changed",
2832 UNIT(s)->id, s->pid_file_pathspec->path);
2833 service_retry_pid_file(s);
2837 log_error_unit(UNIT(s)->id,
2838 "Failed to set a watch for %s's PID file %s: %s",
2839 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2840 service_unwatch_pid_file(s);
2844 static int service_demand_pid_file(Service *s) {
2847 assert(s->pid_file);
2848 assert(!s->pid_file_pathspec);
2850 ps = new0(PathSpec, 1);
2855 ps->path = strdup(s->pid_file);
2861 path_kill_slashes(ps->path);
2863 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2864 * keep their PID file open all the time. */
2865 ps->type = PATH_MODIFIED;
2866 ps->inotify_fd = -1;
2868 s->pid_file_pathspec = ps;
2870 return service_watch_pid_file(s);
2873 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2874 PathSpec *p = userdata;
2879 s = SERVICE(p->unit);
2883 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2884 assert(s->pid_file_pathspec);
2885 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2887 log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2889 if (path_spec_fd_event(p, events) < 0)
2892 if (service_retry_pid_file(s) == 0)
2895 if (service_watch_pid_file(s) < 0)
2901 service_unwatch_pid_file(s);
2902 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2906 static void service_notify_cgroup_empty_event(Unit *u) {
2907 Service *s = SERVICE(u);
2911 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
2915 /* Waiting for SIGCHLD is usually more interesting,
2916 * because it includes return codes/signals. Which is
2917 * why we ignore the cgroup events for most cases,
2918 * except when we don't know pid which to expect the
2922 case SERVICE_START_POST:
2923 /* If we were hoping for the daemon to write its PID file,
2924 * we can give up now. */
2925 if (s->pid_file_pathspec) {
2926 log_warning_unit(u->id,
2927 "%s never wrote its PID file. Failing.", UNIT(s)->id);
2928 service_unwatch_pid_file(s);
2929 if (s->state == SERVICE_START)
2930 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2932 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2936 case SERVICE_RUNNING:
2937 /* service_enter_running() will figure out what to do */
2938 service_enter_running(s, SERVICE_SUCCESS);
2941 case SERVICE_STOP_SIGTERM:
2942 case SERVICE_STOP_SIGKILL:
2944 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2945 service_enter_stop_post(s, SERVICE_SUCCESS);
2949 case SERVICE_STOP_POST:
2950 case SERVICE_FINAL_SIGTERM:
2951 case SERVICE_FINAL_SIGKILL:
2952 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2953 service_enter_dead(s, SERVICE_SUCCESS, true);
2962 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2963 Service *s = SERVICE(u);
2969 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2970 is_clean_exit_lsb(code, status, &s->success_status))
2971 f = SERVICE_SUCCESS;
2972 else if (code == CLD_EXITED)
2973 f = SERVICE_FAILURE_EXIT_CODE;
2974 else if (code == CLD_KILLED)
2975 f = SERVICE_FAILURE_SIGNAL;
2976 else if (code == CLD_DUMPED)
2977 f = SERVICE_FAILURE_CORE_DUMP;
2979 assert_not_reached("Unknown code");
2981 if (s->main_pid == pid) {
2982 /* Forking services may occasionally move to a new PID.
2983 * As long as they update the PID file before exiting the old
2984 * PID, they're fine. */
2985 if (service_load_pid_file(s, false) == 0)
2989 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2991 if (s->main_command) {
2992 /* If this is not a forking service than the
2993 * main process got started and hence we copy
2994 * the exit status so that it is recorded both
2995 * as main and as control process exit
2998 s->main_command->exec_status = s->main_exec_status;
3000 if (s->main_command->ignore)
3001 f = SERVICE_SUCCESS;
3002 } else if (s->exec_command[SERVICE_EXEC_START]) {
3004 /* If this is a forked process, then we should
3005 * ignore the return value if this was
3006 * configured for the starter process */
3008 if (s->exec_command[SERVICE_EXEC_START]->ignore)
3009 f = SERVICE_SUCCESS;
3012 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
3014 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
3015 u->id, sigchld_code_to_string(code), status,
3016 strna(code == CLD_EXITED
3017 ? exit_status_to_string(status, EXIT_STATUS_FULL)
3018 : signal_to_string(status)),
3019 "EXIT_CODE=%s", sigchld_code_to_string(code),
3020 "EXIT_STATUS=%i", status,
3023 if (f != SERVICE_SUCCESS)
3026 if (s->main_command &&
3027 s->main_command->command_next &&
3028 f == SERVICE_SUCCESS) {
3030 /* There is another command to *
3031 * execute, so let's do that. */
3033 log_debug_unit(u->id,
3034 "%s running next main command for state %s",
3035 u->id, service_state_to_string(s->state));
3036 service_run_next_main(s);
3040 /* The service exited, so the service is officially
3042 s->main_command = NULL;
3046 case SERVICE_START_POST:
3047 case SERVICE_RELOAD:
3049 /* Need to wait until the operation is
3054 if (s->type == SERVICE_ONESHOT) {
3055 /* This was our main goal, so let's go on */
3056 if (f == SERVICE_SUCCESS)
3057 service_enter_start_post(s);
3059 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3065 case SERVICE_RUNNING:
3066 service_enter_running(s, f);
3069 case SERVICE_STOP_SIGTERM:
3070 case SERVICE_STOP_SIGKILL:
3072 if (!control_pid_good(s))
3073 service_enter_stop_post(s, f);
3075 /* If there is still a control process, wait for that first */
3078 case SERVICE_STOP_POST:
3079 case SERVICE_FINAL_SIGTERM:
3080 case SERVICE_FINAL_SIGKILL:
3082 if (!control_pid_good(s))
3083 service_enter_dead(s, f, true);
3087 assert_not_reached("Uh, main process died at wrong time.");
3091 } else if (s->control_pid == pid) {
3094 if (s->control_command) {
3095 exec_status_exit(&s->control_command->exec_status,
3096 &s->exec_context, pid, code, status);
3098 if (s->control_command->ignore)
3099 f = SERVICE_SUCCESS;
3102 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3103 "%s: control process exited, code=%s status=%i",
3104 u->id, sigchld_code_to_string(code), status);
3106 if (f != SERVICE_SUCCESS)
3109 /* Immediately get rid of the cgroup, so that the
3110 * kernel doesn't delay the cgroup empty messages for
3111 * the service cgroup any longer than necessary */
3112 service_kill_control_processes(s);
3114 if (s->control_command &&
3115 s->control_command->command_next &&
3116 f == SERVICE_SUCCESS) {
3118 /* There is another command to *
3119 * execute, so let's do that. */
3121 log_debug_unit(u->id,
3122 "%s running next control command for state %s",
3123 u->id, service_state_to_string(s->state));
3124 service_run_next_control(s);
3127 /* No further commands for this step, so let's
3128 * figure out what to do next */
3130 s->control_command = NULL;
3131 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3133 log_debug_unit(u->id,
3134 "%s got final SIGCHLD for state %s",
3135 u->id, service_state_to_string(s->state));
3139 case SERVICE_START_PRE:
3140 if (f == SERVICE_SUCCESS)
3141 service_enter_start(s);
3143 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3147 if (s->type != SERVICE_FORKING)
3148 /* Maybe spurious event due to a reload that changed the type? */
3151 if (f != SERVICE_SUCCESS) {
3152 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3157 bool has_start_post;
3160 /* Let's try to load the pid file here if we can.
3161 * The PID file might actually be created by a START_POST
3162 * script. In that case don't worry if the loading fails. */
3164 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3165 r = service_load_pid_file(s, !has_start_post);
3166 if (!has_start_post && r < 0) {
3167 r = service_demand_pid_file(s);
3168 if (r < 0 || !cgroup_good(s))
3169 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3173 service_search_main_pid(s);
3175 service_enter_start_post(s);
3178 case SERVICE_START_POST:
3179 if (f != SERVICE_SUCCESS) {
3180 service_enter_stop(s, f);
3187 r = service_load_pid_file(s, true);
3189 r = service_demand_pid_file(s);
3190 if (r < 0 || !cgroup_good(s))
3191 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3195 service_search_main_pid(s);
3197 service_enter_running(s, SERVICE_SUCCESS);
3200 case SERVICE_RELOAD:
3201 if (f == SERVICE_SUCCESS) {
3202 service_load_pid_file(s, true);
3203 service_search_main_pid(s);
3206 s->reload_result = f;
3207 service_enter_running(s, SERVICE_SUCCESS);
3211 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3214 case SERVICE_STOP_SIGTERM:
3215 case SERVICE_STOP_SIGKILL:
3216 if (main_pid_good(s) <= 0)
3217 service_enter_stop_post(s, f);
3219 /* If there is still a service
3220 * process around, wait until
3221 * that one quit, too */
3224 case SERVICE_STOP_POST:
3225 case SERVICE_FINAL_SIGTERM:
3226 case SERVICE_FINAL_SIGKILL:
3227 if (main_pid_good(s) <= 0)
3228 service_enter_dead(s, f, true);
3232 assert_not_reached("Uh, control process died at wrong time.");
3237 /* Notify clients about changed exit status */
3238 unit_add_to_dbus_queue(u);
3240 /* We got one SIGCHLD for the service, let's watch all
3241 * processes that are now running of the service, and watch
3242 * that. Among the PIDs we then watch will be children
3243 * reassigned to us, which hopefully allows us to identify
3244 * when all children are gone */
3245 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
3246 unit_watch_all_pids(u);
3248 /* If the PID set is empty now, then let's finish this off */
3249 if (set_isempty(u->pids))
3250 service_notify_cgroup_empty_event(u);
3253 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3254 Service *s = SERVICE(userdata);
3257 assert(source == s->timer_event_source);
3261 case SERVICE_START_PRE:
3263 log_warning_unit(UNIT(s)->id,
3264 "%s %s operation timed out. Terminating.",
3266 s->state == SERVICE_START ? "start" : "start-pre");
3267 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3270 case SERVICE_START_POST:
3271 log_warning_unit(UNIT(s)->id,
3272 "%s start-post operation timed out. Stopping.", UNIT(s)->id);
3273 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3276 case SERVICE_RELOAD:
3277 log_warning_unit(UNIT(s)->id,
3278 "%s reload operation timed out. Stopping.", UNIT(s)->id);
3279 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3280 service_enter_running(s, SERVICE_SUCCESS);
3284 log_warning_unit(UNIT(s)->id,
3285 "%s stopping timed out. Terminating.", UNIT(s)->id);
3286 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3289 case SERVICE_STOP_SIGTERM:
3290 if (s->kill_context.send_sigkill) {
3291 log_warning_unit(UNIT(s)->id,
3292 "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
3293 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3295 log_warning_unit(UNIT(s)->id,
3296 "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
3297 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3302 case SERVICE_STOP_SIGKILL:
3303 /* Uh, we sent a SIGKILL and it is still not gone?
3304 * Must be something we cannot kill, so let's just be
3305 * weirded out and continue */
3307 log_warning_unit(UNIT(s)->id,
3308 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
3309 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3312 case SERVICE_STOP_POST:
3313 log_warning_unit(UNIT(s)->id,
3314 "%s stop-post timed out. Terminating.", UNIT(s)->id);
3315 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3318 case SERVICE_FINAL_SIGTERM:
3319 if (s->kill_context.send_sigkill) {
3320 log_warning_unit(UNIT(s)->id,
3321 "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
3322 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3324 log_warning_unit(UNIT(s)->id,
3325 "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.",
3327 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3332 case SERVICE_FINAL_SIGKILL:
3333 log_warning_unit(UNIT(s)->id,
3334 "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
3335 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3338 case SERVICE_AUTO_RESTART:
3339 log_info_unit(UNIT(s)->id,
3340 s->restart_usec > 0 ?
3341 "%s holdoff time over, scheduling restart." :
3342 "%s has no holdoff time, scheduling restart.",
3344 service_enter_restart(s);
3348 assert_not_reached("Timeout at wrong time.");
3354 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3355 Service *s = SERVICE(userdata);
3358 assert(source == s->watchdog_event_source);
3360 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
3361 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
3366 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3367 Service *s = SERVICE(u);
3369 bool notify_dbus = false;
3373 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s...)",
3374 u->id, pid, tags && *tags ? tags[0] : "(empty)");
3376 if (s->notify_access == NOTIFY_NONE) {
3377 log_warning_unit(u->id,
3378 "%s: Got notification message from PID "PID_FMT", but reception is disabled.",
3383 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3385 if (s->main_pid != 0)
3386 log_warning_unit(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, u->id, pid, s->main_pid);
3388 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", u->id, pid);
3392 /* Interpret MAINPID= */
3393 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3394 (s->state == SERVICE_START ||
3395 s->state == SERVICE_START_POST ||
3396 s->state == SERVICE_RUNNING ||
3397 s->state == SERVICE_RELOAD)) {
3399 if (parse_pid(e + 8, &pid) < 0)
3400 log_warning_unit(u->id, "Failed to parse notification message %s", e);
3402 log_debug_unit(u->id, "%s: got %s", u->id, e);
3403 service_set_main_pid(s, pid);
3404 unit_watch_pid(UNIT(s), pid);
3409 /* Interpret READY= */
3410 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START && strv_find(tags, "READY=1")) {
3411 log_debug_unit(u->id, "%s: got READY=1", u->id);
3412 service_enter_start_post(s);
3416 /* Interpret STATUS= */
3417 e = strv_find_prefix(tags, "STATUS=");
3422 if (!utf8_is_valid(e+7)) {
3423 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
3427 log_debug_unit(u->id, "%s: got %s", u->id, e);
3438 if (!streq_ptr(s->status_text, t)) {
3439 free(s->status_text);
3446 /* Interpret WATCHDOG= */
3447 if (strv_find(tags, "WATCHDOG=1")) {
3448 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
3449 service_reset_watchdog(s);
3452 /* Notify clients about changed status or main pid */
3454 unit_add_to_dbus_queue(u);
3457 static int service_get_timeout(Unit *u, uint64_t *timeout) {
3458 Service *s = SERVICE(u);
3461 if (!s->timer_event_source)
3464 r = sd_event_source_get_time(s->timer_event_source, timeout);
3471 #ifdef HAVE_SYSV_COMPAT
3473 static int service_enumerate(Manager *m) {
3476 _cleanup_closedir_ DIR *d = NULL;
3477 _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
3478 Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
3479 _cleanup_set_free_ Set *shutdown_services = NULL;
3486 if (m->running_as != SYSTEMD_SYSTEM)
3489 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3490 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3494 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3505 if (errno != ENOENT)
3506 log_warning("opendir(%s) failed: %m", path);
3511 while ((de = readdir(d))) {
3514 if (ignore_file(de->d_name))
3517 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3520 if (strlen(de->d_name) < 4)
3523 a = undecchar(de->d_name[1]);
3524 b = undecchar(de->d_name[2]);
3530 fpath = strjoin(path, "/", de->d_name, NULL);
3536 if (access(fpath, X_OK) < 0) {
3538 if (errno != ENOENT)
3539 log_warning("access() failed on %s: %m", fpath);
3545 name = sysv_translate_name(de->d_name + 3);
3551 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3553 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3557 if (de->d_name[0] == 'S') {
3559 if (rcnd_table[i].type == RUNLEVEL_UP) {
3560 SERVICE(service)->sysv_start_priority_from_rcnd =
3561 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3563 SERVICE(service)->sysv_enabled = true;
3566 r = set_ensure_allocated(&runlevel_services[i],
3567 trivial_hash_func, trivial_compare_func);
3571 r = set_put(runlevel_services[i], service);
3575 } else if (de->d_name[0] == 'K' &&
3576 (rcnd_table[i].type == RUNLEVEL_DOWN)) {
3578 r = set_ensure_allocated(&shutdown_services,
3579 trivial_hash_func, trivial_compare_func);
3583 r = set_put(shutdown_services, service);
3590 /* Now we loaded all stubs and are aware of the lowest
3591 start-up priority for all services, not let's actually load
3592 the services, this will also tell us which services are
3593 actually native now */
3594 manager_dispatch_load_queue(m);
3596 /* If this is a native service, rely on native ways to pull in
3597 * a service, don't pull it in via sysv rcN.d links. */
3598 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3599 SET_FOREACH(service, runlevel_services[i], j) {
3600 service = unit_follow_merge(service);
3602 if (service->fragment_path)
3605 r = unit_add_two_dependencies_by_name_inverse(
3606 service, UNIT_AFTER, UNIT_WANTS,
3607 rcnd_table[i].target, NULL, true);
3612 /* We honour K links only for halt/reboot. For the normal
3613 * runlevels we assume the stop jobs will be implicitly added
3614 * by the core logic. Also, we don't really distinguish here
3615 * between the runlevels 0 and 6 and just add them to the
3616 * special shutdown target. */
3617 SET_FOREACH(service, shutdown_services, j) {
3618 service = unit_follow_merge(service);
3620 if (service->fragment_path)
3623 r = unit_add_two_dependencies_by_name(
3624 service, UNIT_BEFORE, UNIT_CONFLICTS,
3625 SPECIAL_SHUTDOWN_TARGET, NULL, true);
3634 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3635 set_free(runlevel_services[i]);
3641 static void service_bus_name_owner_change(
3644 const char *old_owner,
3645 const char *new_owner) {
3647 Service *s = SERVICE(u);
3653 assert(streq(s->bus_name, name));
3654 assert(old_owner || new_owner);
3656 if (old_owner && new_owner)
3657 log_debug_unit(u->id,
3658 "%s's D-Bus name %s changed owner from %s to %s",
3659 u->id, name, old_owner, new_owner);
3661 log_debug_unit(u->id,
3662 "%s's D-Bus name %s no longer registered by %s",
3663 u->id, name, old_owner);
3665 log_debug_unit(u->id,
3666 "%s's D-Bus name %s now registered by %s",
3667 u->id, name, new_owner);
3669 s->bus_name_good = !!new_owner;
3671 if (s->type == SERVICE_DBUS) {
3673 /* service_enter_running() will figure out what to
3675 if (s->state == SERVICE_RUNNING)
3676 service_enter_running(s, SERVICE_SUCCESS);
3677 else if (s->state == SERVICE_START && new_owner)
3678 service_enter_start_post(s);
3680 } else if (new_owner &&
3682 (s->state == SERVICE_START ||
3683 s->state == SERVICE_START_POST ||
3684 s->state == SERVICE_RUNNING ||
3685 s->state == SERVICE_RELOAD)) {
3687 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
3690 /* Try to acquire PID from bus service */
3692 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
3694 r = sd_bus_creds_get_pid(creds, &pid);
3696 log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3698 service_set_main_pid(s, pid);
3699 unit_watch_pid(UNIT(s), pid);
3704 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3705 _cleanup_free_ char *peer = NULL;
3711 /* This is called by the socket code when instantiating a new
3712 * service for a stream socket and the socket needs to be
3715 if (UNIT(s)->load_state != UNIT_LOADED)
3718 if (s->socket_fd >= 0)
3721 if (s->state != SERVICE_DEAD)
3724 if (getpeername_pretty(fd, &peer) >= 0) {
3726 if (UNIT(s)->description) {
3727 _cleanup_free_ char *a;
3729 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3733 r = unit_set_description(UNIT(s), a);
3735 r = unit_set_description(UNIT(s), peer);
3743 unit_ref_set(&s->accept_socket, UNIT(sock));
3745 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3748 static void service_reset_failed(Unit *u) {
3749 Service *s = SERVICE(u);
3753 if (s->state == SERVICE_FAILED)
3754 service_set_state(s, SERVICE_DEAD);
3756 s->result = SERVICE_SUCCESS;
3757 s->reload_result = SERVICE_SUCCESS;
3759 RATELIMIT_RESET(s->start_limit);
3762 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3763 Service *s = SERVICE(u);
3765 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3768 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3769 [SERVICE_DEAD] = "dead",
3770 [SERVICE_START_PRE] = "start-pre",
3771 [SERVICE_START] = "start",
3772 [SERVICE_START_POST] = "start-post",
3773 [SERVICE_RUNNING] = "running",
3774 [SERVICE_EXITED] = "exited",
3775 [SERVICE_RELOAD] = "reload",
3776 [SERVICE_STOP] = "stop",
3777 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3778 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3779 [SERVICE_STOP_POST] = "stop-post",
3780 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3781 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3782 [SERVICE_FAILED] = "failed",
3783 [SERVICE_AUTO_RESTART] = "auto-restart",
3786 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3788 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3789 [SERVICE_RESTART_NO] = "no",
3790 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3791 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3792 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3793 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3794 [SERVICE_RESTART_ALWAYS] = "always"
3797 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3799 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3800 [SERVICE_SIMPLE] = "simple",
3801 [SERVICE_FORKING] = "forking",
3802 [SERVICE_ONESHOT] = "oneshot",
3803 [SERVICE_DBUS] = "dbus",
3804 [SERVICE_NOTIFY] = "notify",
3805 [SERVICE_IDLE] = "idle"
3808 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3810 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3811 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3812 [SERVICE_EXEC_START] = "ExecStart",
3813 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3814 [SERVICE_EXEC_RELOAD] = "ExecReload",
3815 [SERVICE_EXEC_STOP] = "ExecStop",
3816 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3819 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3821 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3822 [NOTIFY_NONE] = "none",
3823 [NOTIFY_MAIN] = "main",
3824 [NOTIFY_ALL] = "all"
3827 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3829 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3830 [SERVICE_SUCCESS] = "success",
3831 [SERVICE_FAILURE_RESOURCES] = "resources",
3832 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3833 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3834 [SERVICE_FAILURE_SIGNAL] = "signal",
3835 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3836 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3837 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3840 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3842 static const char* const failure_action_table[_SERVICE_FAILURE_ACTION_MAX] = {
3843 [SERVICE_FAILURE_ACTION_NONE] = "none",
3844 [SERVICE_FAILURE_ACTION_REBOOT] = "reboot",
3845 [SERVICE_FAILURE_ACTION_REBOOT_FORCE] = "reboot-force",
3846 [SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE] = "reboot-immediate"
3848 DEFINE_STRING_TABLE_LOOKUP(failure_action, FailureAction);
3850 const UnitVTable service_vtable = {
3851 .object_size = sizeof(Service),
3852 .exec_context_offset = offsetof(Service, exec_context),
3853 .cgroup_context_offset = offsetof(Service, cgroup_context),
3854 .kill_context_offset = offsetof(Service, kill_context),
3855 .exec_runtime_offset = offsetof(Service, exec_runtime),
3861 .private_section = "Service",
3863 .init = service_init,
3864 .done = service_done,
3865 .load = service_load,
3867 .coldplug = service_coldplug,
3869 .dump = service_dump,
3871 .start = service_start,
3872 .stop = service_stop,
3873 .reload = service_reload,
3875 .can_reload = service_can_reload,
3877 .kill = service_kill,
3879 .serialize = service_serialize,
3880 .deserialize_item = service_deserialize_item,
3882 .active_state = service_active_state,
3883 .sub_state_to_string = service_sub_state_to_string,
3885 .check_gc = service_check_gc,
3886 .check_snapshot = service_check_snapshot,
3888 .sigchld_event = service_sigchld_event,
3890 .reset_failed = service_reset_failed,
3892 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3893 .notify_message = service_notify_message,
3895 .bus_name_owner_change = service_bus_name_owner_change,
3897 .bus_interface = "org.freedesktop.systemd1.Service",
3898 .bus_vtable = bus_service_vtable,
3899 .bus_set_property = bus_service_set_property,
3900 .bus_commit_properties = bus_service_commit_properties,
3902 .get_timeout = service_get_timeout,
3904 #ifdef HAVE_SYSV_COMPAT
3905 .enumerate = service_enumerate,
3908 .can_transient = true,
3910 .status_message_formats = {
3911 .starting_stopping = {
3912 [0] = "Starting %s...",
3913 [1] = "Stopping %s...",
3915 .finished_start_job = {
3916 [JOB_DONE] = "Started %s.",
3917 [JOB_FAILED] = "Failed to start %s.",
3918 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3919 [JOB_TIMEOUT] = "Timed out starting %s.",
3921 .finished_stop_job = {
3922 [JOB_DONE] = "Stopped %s.",
3923 [JOB_FAILED] = "Stopped (with error) %s.",
3924 [JOB_TIMEOUT] = "Timed out stopping %s.",