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) {
838 if (!(n = strndup(w, z))) {
843 r = sysv_translate_facility(n, basename(path), &m);
845 log_error_unit(u->id,
846 "[%s:%u] Failed to translate LSB dependency %s, ignoring: %s",
847 path, line, n, strerror(-r));
857 if (streq(m, SPECIAL_NETWORK_ONLINE_TARGET) && !startswith_no_case(t, "X-Start-Before:"))
858 /* the network-online target is special, as it needs to be actively pulled in */
859 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, m, NULL, true);
861 r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
864 log_error_unit(u->id, "[%s:%u] Failed to add dependency on %s, ignoring: %s",
865 path, line, m, strerror(-r));
869 } else if (startswith_no_case(t, "Default-Start:")) {
874 k = delete_chars(t+14, WHITESPACE "-");
877 if (!(d = strdup(k))) {
882 free(s->sysv_runlevels);
883 s->sysv_runlevels = d;
886 } else if (startswith_no_case(t, "Description:")) {
889 state = LSB_DESCRIPTION;
891 if ((j = strstrip(t+12)) && *j) {
892 if (!(d = strdup(j))) {
899 free(long_description);
900 long_description = d;
902 } else if (startswith_no_case(t, "Short-Description:")) {
907 if ((j = strstrip(t+18)) && *j) {
908 if (!(d = strdup(j))) {
915 free(short_description);
916 short_description = d;
918 } else if (state == LSB_DESCRIPTION) {
920 if (startswith(l, "#\t") || startswith(l, "# ")) {
923 if ((j = strstrip(t)) && *j) {
926 if (long_description)
927 d = strjoin(long_description, " ", t, NULL);
936 free(long_description);
937 long_description = d;
946 if ((r = sysv_exec_commands(s, supports_reload)) < 0)
949 if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
950 /* If there a runlevels configured for this service
951 * but none of the standard ones, then we assume this
952 * is some special kind of service (which might be
953 * needed for early boot) and don't create any links
956 UNIT(s)->default_dependencies = false;
958 /* Don't timeout special services during boot (like fsck) */
959 s->timeout_start_usec = 0;
960 s->timeout_stop_usec = 0;
962 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
963 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
966 /* Special setting for all SysV services */
967 s->type = SERVICE_FORKING;
968 s->remain_after_exit = !s->pid_file;
969 s->guess_main_pid = false;
970 s->restart = SERVICE_RESTART_NO;
971 s->exec_context.ignore_sigpipe = false;
972 s->kill_context.kill_mode = KILL_PROCESS;
974 /* We use the long description only if
975 * no short description is set. */
977 if (short_description)
978 description = short_description;
979 else if (chkconfig_description)
980 description = chkconfig_description;
981 else if (long_description)
982 description = long_description;
989 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
997 /* Initialize the start priority from what has been set in the
998 * /etc/rcN.d/ hierarchies if we load the unit file as SysV
1000 if (s->sysv_start_priority_from_rcnd >= 0)
1001 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
1003 u->load_state = UNIT_LOADED;
1011 free(short_description);
1012 free(long_description);
1013 free(chkconfig_description);
1018 static int service_load_sysv_name(Service *s, const char *name) {
1024 /* For SysV services we strip the *.sh suffixes. */
1025 if (endswith(name, ".sh.service"))
1028 STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
1032 path = strjoin(*p, "/", name, NULL);
1036 assert(endswith(path, ".service"));
1037 path[strlen(path)-8] = 0;
1039 r = service_load_sysv_path(s, path);
1041 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1042 /* Try *.sh source'able init scripts */
1043 strcat(path, ".sh");
1044 r = service_load_sysv_path(s, path);
1051 if (UNIT(s)->load_state != UNIT_STUB)
1058 static int service_load_sysv(Service *s) {
1065 /* Load service data from SysV init scripts, preferably with
1066 * LSB headers ... */
1068 if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1071 if ((t = UNIT(s)->id))
1072 if ((r = service_load_sysv_name(s, t)) < 0)
1075 if (UNIT(s)->load_state == UNIT_STUB)
1076 SET_FOREACH(t, UNIT(s)->names, i) {
1077 if (t == UNIT(s)->id)
1080 if ((r = service_load_sysv_name(s, t)) < 0)
1083 if (UNIT(s)->load_state != UNIT_STUB)
1091 static int service_verify(Service *s) {
1094 if (UNIT(s)->load_state != UNIT_LOADED)
1097 if (!s->exec_command[SERVICE_EXEC_START]) {
1098 log_error_unit(UNIT(s)->id, "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1102 if (s->type != SERVICE_ONESHOT &&
1103 s->exec_command[SERVICE_EXEC_START]->command_next) {
1104 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);
1108 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
1109 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);
1113 if (s->type == SERVICE_DBUS && !s->bus_name) {
1114 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);
1118 if (s->bus_name && s->type != SERVICE_DBUS)
1119 log_warning_unit(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1121 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
1122 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
1129 static int service_add_default_dependencies(Service *s) {
1134 /* Add a number of automatic dependencies useful for the
1135 * majority of services. */
1137 /* First, pull in base system */
1138 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
1139 SPECIAL_BASIC_TARGET, NULL, true);
1143 /* Second, activate normal shutdown */
1144 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
1145 SPECIAL_SHUTDOWN_TARGET, NULL, true);
1149 static void service_fix_output(Service *s) {
1152 /* If nothing has been explicitly configured, patch default
1153 * output in. If input is socket/tty we avoid this however,
1154 * since in that case we want output to default to the same
1155 * place as we read input from. */
1157 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1158 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1159 s->exec_context.std_input == EXEC_INPUT_NULL)
1160 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1162 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1163 s->exec_context.std_input == EXEC_INPUT_NULL)
1164 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1167 static int service_load(Unit *u) {
1169 Service *s = SERVICE(u);
1173 /* Load a .service file */
1174 r = unit_load_fragment(u);
1178 #ifdef HAVE_SYSV_COMPAT
1179 /* Load a classic init script as a fallback, if we couldn't find anything */
1180 if (u->load_state == UNIT_STUB) {
1181 r = service_load_sysv(s);
1187 /* Still nothing found? Then let's give up */
1188 if (u->load_state == UNIT_STUB)
1191 /* This is a new unit? Then let's add in some extras */
1192 if (u->load_state == UNIT_LOADED) {
1194 /* We were able to load something, then let's add in
1195 * the dropin directories. */
1196 r = unit_load_dropin(u);
1200 if (s->type == _SERVICE_TYPE_INVALID)
1201 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1203 /* Oneshot services have disabled start timeout by default */
1204 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1205 s->timeout_start_usec = 0;
1207 service_fix_output(s);
1209 r = unit_patch_contexts(u);
1213 r = unit_add_exec_dependencies(u, &s->exec_context);
1217 r = unit_add_default_slice(u, &s->cgroup_context);
1221 #ifdef HAVE_SYSV_COMPAT
1222 r = sysv_fix_order(s);
1227 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1228 s->notify_access = NOTIFY_MAIN;
1230 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1231 s->notify_access = NOTIFY_MAIN;
1234 r = unit_watch_bus_name(u, s->bus_name);
1239 if (u->default_dependencies) {
1240 r = service_add_default_dependencies(s);
1246 return service_verify(s);
1249 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1251 ServiceExecCommand c;
1252 Service *s = SERVICE(u);
1253 const char *prefix2;
1254 _cleanup_free_ char *p2 = NULL;
1258 p2 = strappend(prefix, "\t");
1259 prefix2 = p2 ? p2 : prefix;
1262 "%sService State: %s\n"
1264 "%sReload Result: %s\n"
1265 "%sPermissionsStartOnly: %s\n"
1266 "%sRootDirectoryStartOnly: %s\n"
1267 "%sRemainAfterExit: %s\n"
1268 "%sGuessMainPID: %s\n"
1271 "%sNotifyAccess: %s\n",
1272 prefix, service_state_to_string(s->state),
1273 prefix, service_result_to_string(s->result),
1274 prefix, service_result_to_string(s->reload_result),
1275 prefix, yes_no(s->permissions_start_only),
1276 prefix, yes_no(s->root_directory_start_only),
1277 prefix, yes_no(s->remain_after_exit),
1278 prefix, yes_no(s->guess_main_pid),
1279 prefix, service_type_to_string(s->type),
1280 prefix, service_restart_to_string(s->restart),
1281 prefix, notify_access_to_string(s->notify_access));
1283 if (s->control_pid > 0)
1285 "%sControl PID: "PID_FMT"\n",
1286 prefix, s->control_pid);
1288 if (s->main_pid > 0)
1290 "%sMain PID: "PID_FMT"\n"
1291 "%sMain PID Known: %s\n"
1292 "%sMain PID Alien: %s\n",
1293 prefix, s->main_pid,
1294 prefix, yes_no(s->main_pid_known),
1295 prefix, yes_no(s->main_pid_alien));
1300 prefix, s->pid_file);
1305 "%sBus Name Good: %s\n",
1306 prefix, s->bus_name,
1307 prefix, yes_no(s->bus_name_good));
1309 kill_context_dump(&s->kill_context, f, prefix);
1310 exec_context_dump(&s->exec_context, f, prefix);
1312 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1314 if (!s->exec_command[c])
1317 fprintf(f, "%s-> %s:\n",
1318 prefix, service_exec_command_to_string(c));
1320 exec_command_dump_list(s->exec_command[c], f, prefix2);
1323 #ifdef HAVE_SYSV_COMPAT
1326 "%sSysV Init Script has LSB Header: %s\n"
1327 "%sSysVEnabled: %s\n",
1328 prefix, yes_no(s->sysv_has_lsb),
1329 prefix, yes_no(s->sysv_enabled));
1331 if (s->sysv_start_priority >= 0)
1333 "%sSysVStartPriority: %i\n",
1334 prefix, s->sysv_start_priority);
1336 if (s->sysv_runlevels)
1337 fprintf(f, "%sSysVRunLevels: %s\n",
1338 prefix, s->sysv_runlevels);
1342 fprintf(f, "%sStatus Text: %s\n",
1343 prefix, s->status_text);
1346 static int service_load_pid_file(Service *s, bool may_warn) {
1347 _cleanup_free_ char *k = NULL;
1356 r = read_one_line_file(s->pid_file, &k);
1359 log_info_unit(UNIT(s)->id,
1360 "PID file %s not readable (yet?) after %s.",
1361 s->pid_file, service_state_to_string(s->state));
1365 r = parse_pid(k, &pid);
1368 log_info_unit(UNIT(s)->id,
1369 "Failed to read PID from file %s: %s",
1370 s->pid_file, strerror(-r));
1374 if (!pid_is_alive(pid)) {
1376 log_info_unit(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
1381 if (s->main_pid_known) {
1382 if (pid == s->main_pid)
1385 log_debug_unit(UNIT(s)->id,
1386 "Main PID changing: "PID_FMT" -> "PID_FMT,
1388 service_unwatch_main_pid(s);
1389 s->main_pid_known = false;
1391 log_debug_unit(UNIT(s)->id,
1392 "Main PID loaded: "PID_FMT, pid);
1394 r = service_set_main_pid(s, pid);
1398 r = unit_watch_pid(UNIT(s), pid);
1400 /* FIXME: we need to do something here */
1401 log_warning_unit(UNIT(s)->id,
1402 "Failed to watch PID "PID_FMT" from service %s",
1410 static int service_search_main_pid(Service *s) {
1416 /* If we know it anyway, don't ever fallback to unreliable
1418 if (s->main_pid_known)
1421 if (!s->guess_main_pid)
1424 assert(s->main_pid <= 0);
1426 pid = unit_search_main_pid(UNIT(s));
1430 log_debug_unit(UNIT(s)->id,
1431 "Main PID guessed: "PID_FMT, pid);
1432 r = service_set_main_pid(s, pid);
1436 r = unit_watch_pid(UNIT(s), pid);
1438 /* FIXME: we need to do something here */
1439 log_warning_unit(UNIT(s)->id,
1440 "Failed to watch PID "PID_FMT" from service %s",
1445 static void service_set_state(Service *s, ServiceState state) {
1446 ServiceState old_state;
1447 const UnitActiveState *table;
1451 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1453 old_state = s->state;
1456 service_unwatch_pid_file(s);
1459 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1461 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1463 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
1464 SERVICE_AUTO_RESTART))
1465 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1468 SERVICE_START, SERVICE_START_POST,
1469 SERVICE_RUNNING, SERVICE_RELOAD,
1470 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1472 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1473 service_unwatch_main_pid(s);
1474 s->main_command = NULL;
1478 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1480 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1482 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1483 service_unwatch_control_pid(s);
1484 s->control_command = NULL;
1485 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1488 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1489 unit_unwatch_all_pids(UNIT(s));
1492 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1493 SERVICE_RUNNING, SERVICE_RELOAD,
1494 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
1495 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
1496 !(state == SERVICE_DEAD && UNIT(s)->job)) {
1497 service_close_socket_fd(s);
1498 service_connection_unref(s);
1501 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1502 service_stop_watchdog(s);
1504 /* For the inactive states unit_notify() will trim the cgroup,
1505 * but for exit we have to do that ourselves... */
1506 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1507 unit_destroy_cgroup(UNIT(s));
1509 /* For remain_after_exit services, let's see if we can "release" the
1510 * hold on the console, since unit_notify() only does that in case of
1511 * change of state */
1512 if (state == SERVICE_EXITED && s->remain_after_exit &&
1513 UNIT(s)->manager->n_on_console > 0) {
1514 ExecContext *ec = unit_get_exec_context(UNIT(s));
1515 if (ec && exec_context_may_touch_console(ec)) {
1516 Manager *m = UNIT(s)->manager;
1519 if (m->n_on_console == 0)
1520 /* unset no_console_output flag, since the console is free */
1521 m->no_console_output = false;
1525 if (old_state != state)
1526 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1528 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1529 s->reload_result = SERVICE_SUCCESS;
1532 static int service_coldplug(Unit *u) {
1533 Service *s = SERVICE(u);
1537 assert(s->state == SERVICE_DEAD);
1539 if (s->deserialized_state != s->state) {
1541 if (IN_SET(s->deserialized_state,
1542 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1544 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1546 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1550 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
1552 /* For the start/stop timeouts 0 means off */
1554 r = service_arm_timer(s, k);
1560 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
1562 /* The restart timeouts 0 means immediately */
1563 r = service_arm_timer(s, s->restart_usec);
1568 if (pid_is_unwaited(s->main_pid) &&
1569 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
1570 IN_SET(s->deserialized_state,
1571 SERVICE_START, SERVICE_START_POST,
1572 SERVICE_RUNNING, SERVICE_RELOAD,
1573 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1575 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
1576 r = unit_watch_pid(UNIT(s), s->main_pid);
1581 if (pid_is_unwaited(s->control_pid) &&
1582 IN_SET(s->deserialized_state,
1583 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
1585 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
1587 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
1588 r = unit_watch_pid(UNIT(s), s->control_pid);
1593 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
1594 unit_watch_all_pids(UNIT(s));
1596 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
1597 service_start_watchdog(s);
1599 service_set_state(s, s->deserialized_state);
1605 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1609 unsigned rn_fds = 0;
1616 if (s->socket_fd >= 0)
1619 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1624 if (u->type != UNIT_SOCKET)
1629 r = socket_collect_fds(sock, &cfds, &cn_fds);
1642 t = new(int, rn_fds+cn_fds);
1649 memcpy(t, rfds, rn_fds * sizeof(int));
1650 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1655 rn_fds = rn_fds+cn_fds;
1670 static int service_spawn(
1675 bool apply_permissions,
1677 bool apply_tty_stdin,
1678 bool set_notify_socket,
1685 _cleanup_free_ int *fdsbuf = NULL;
1686 unsigned n_fds = 0, n_env = 0;
1687 _cleanup_strv_free_ char
1688 **argv = NULL, **final_env = NULL, **our_env = NULL;
1695 unit_realize_cgroup(UNIT(s));
1697 r = unit_setup_exec_runtime(UNIT(s));
1702 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1703 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1704 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1706 if (s->socket_fd >= 0) {
1707 fds = &s->socket_fd;
1710 r = service_collect_fds(s, &fdsbuf, &n_fds);
1718 if (timeout && s->timeout_start_usec > 0) {
1719 r = service_arm_timer(s, s->timeout_start_usec);
1723 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1725 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1729 our_env = new0(char*, 4);
1735 if (set_notify_socket)
1736 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1741 if (s->main_pid > 0)
1742 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
1747 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1748 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
1753 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1759 if (is_control && UNIT(s)->cgroup_path) {
1760 path = strappenda(UNIT(s)->cgroup_path, "/control");
1761 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1763 path = UNIT(s)->cgroup_path;
1773 UNIT(s)->manager->confirm_spawn,
1774 UNIT(s)->manager->cgroup_supported,
1776 manager_get_runtime_prefix(UNIT(s)->manager),
1779 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1785 r = unit_watch_pid(UNIT(s), pid);
1787 /* FIXME: we need to do something here */
1796 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1801 static int main_pid_good(Service *s) {
1804 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1807 /* If we know the pid file, then lets just check if it is
1809 if (s->main_pid_known) {
1811 /* If it's an alien child let's check if it is still
1813 if (s->main_pid_alien && s->main_pid > 0)
1814 return pid_is_alive(s->main_pid);
1816 /* .. otherwise assume we'll get a SIGCHLD for it,
1817 * which we really should wait for to collect exit
1818 * status and code */
1819 return s->main_pid > 0;
1822 /* We don't know the pid */
1826 _pure_ static int control_pid_good(Service *s) {
1829 return s->control_pid > 0;
1832 static int cgroup_good(Service *s) {
1837 if (!UNIT(s)->cgroup_path)
1840 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1847 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none);
1849 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1853 if (f != SERVICE_SUCCESS)
1856 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1858 if (s->result != SERVICE_SUCCESS)
1859 service_execute_action(s, s->failure_action, "failed", false);
1861 if (allow_restart &&
1862 !s->forbid_restart &&
1863 (s->restart == SERVICE_RESTART_ALWAYS ||
1864 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1865 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1866 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1867 (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1868 s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1869 (s->result != SERVICE_FAILURE_EXIT_CODE ||
1870 !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1871 (s->result != SERVICE_FAILURE_SIGNAL ||
1872 !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1874 r = service_arm_timer(s, s->restart_usec);
1878 service_set_state(s, SERVICE_AUTO_RESTART);
1881 s->forbid_restart = false;
1883 /* We want fresh tmpdirs in case service is started again immediately */
1884 exec_runtime_destroy(s->exec_runtime);
1885 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1887 /* Also, remove the runtime directory in */
1888 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1890 /* Try to delete the pid file. At this point it will be
1891 * out-of-date, and some software might be confused by it, so
1892 * let's remove it. */
1894 unlink_noerrno(s->pid_file);
1899 log_warning_unit(UNIT(s)->id,
1900 "%s failed to run install restart timer: %s",
1901 UNIT(s)->id, strerror(-r));
1902 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1905 static void service_enter_stop_post(Service *s, ServiceResult f) {
1909 if (f != SERVICE_SUCCESS)
1912 service_unwatch_control_pid(s);
1913 unit_watch_all_pids(UNIT(s));
1915 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1916 if (s->control_command) {
1917 s->control_command_id = SERVICE_EXEC_STOP_POST;
1919 r = service_spawn(s,
1923 !s->permissions_start_only,
1924 !s->root_directory_start_only,
1932 service_set_state(s, SERVICE_STOP_POST);
1934 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1939 log_warning_unit(UNIT(s)->id,
1940 "%s failed to run 'stop-post' task: %s",
1941 UNIT(s)->id, strerror(-r));
1942 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1945 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1950 if (f != SERVICE_SUCCESS)
1953 unit_watch_all_pids(UNIT(s));
1955 r = unit_kill_context(
1958 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1967 if (s->timeout_stop_usec > 0) {
1968 r = service_arm_timer(s, s->timeout_stop_usec);
1973 service_set_state(s, state);
1974 } else if (state == SERVICE_STOP_SIGTERM)
1975 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1976 else if (state == SERVICE_STOP_SIGKILL)
1977 service_enter_stop_post(s, SERVICE_SUCCESS);
1978 else if (state == SERVICE_FINAL_SIGTERM)
1979 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1981 service_enter_dead(s, SERVICE_SUCCESS, true);
1986 log_warning_unit(UNIT(s)->id,
1987 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1989 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1990 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1992 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1995 static void service_enter_stop(Service *s, ServiceResult f) {
2000 if (f != SERVICE_SUCCESS)
2003 service_unwatch_control_pid(s);
2004 unit_watch_all_pids(UNIT(s));
2006 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
2007 if (s->control_command) {
2008 s->control_command_id = SERVICE_EXEC_STOP;
2010 r = service_spawn(s,
2014 !s->permissions_start_only,
2015 !s->root_directory_start_only,
2023 service_set_state(s, SERVICE_STOP);
2025 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2030 log_warning_unit(UNIT(s)->id,
2031 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2032 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2035 static void service_enter_running(Service *s, ServiceResult f) {
2036 int main_pid_ok, cgroup_ok;
2039 if (f != SERVICE_SUCCESS)
2042 main_pid_ok = main_pid_good(s);
2043 cgroup_ok = cgroup_good(s);
2045 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2046 (s->bus_name_good || s->type != SERVICE_DBUS))
2047 service_set_state(s, SERVICE_RUNNING);
2048 else if (s->remain_after_exit)
2049 service_set_state(s, SERVICE_EXITED);
2051 service_enter_stop(s, SERVICE_SUCCESS);
2054 static void service_enter_start_post(Service *s) {
2058 service_unwatch_control_pid(s);
2059 service_reset_watchdog(s);
2061 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
2062 if (s->control_command) {
2063 s->control_command_id = SERVICE_EXEC_START_POST;
2065 r = service_spawn(s,
2069 !s->permissions_start_only,
2070 !s->root_directory_start_only,
2078 service_set_state(s, SERVICE_START_POST);
2080 service_enter_running(s, SERVICE_SUCCESS);
2085 log_warning_unit(UNIT(s)->id,
2086 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2087 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2090 static void service_kill_control_processes(Service *s) {
2093 if (!UNIT(s)->cgroup_path)
2096 p = strappenda(UNIT(s)->cgroup_path, "/control");
2097 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
2100 static void service_enter_start(Service *s) {
2107 assert(s->exec_command[SERVICE_EXEC_START]);
2108 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2110 service_unwatch_control_pid(s);
2111 service_unwatch_main_pid(s);
2113 /* We want to ensure that nobody leaks processes from
2114 * START_PRE here, so let's go on a killing spree, People
2115 * should not spawn long running processes from START_PRE. */
2116 service_kill_control_processes(s);
2118 if (s->type == SERVICE_FORKING) {
2119 s->control_command_id = SERVICE_EXEC_START;
2120 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2122 s->main_command = NULL;
2124 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2125 s->control_command = NULL;
2127 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2130 r = service_spawn(s,
2132 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
2133 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2138 s->notify_access != NOTIFY_NONE,
2144 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2145 /* For simple services we immediately start
2146 * the START_POST binaries. */
2148 service_set_main_pid(s, pid);
2149 service_enter_start_post(s);
2151 } else if (s->type == SERVICE_FORKING) {
2153 /* For forking services we wait until the start
2154 * process exited. */
2156 s->control_pid = pid;
2157 service_set_state(s, SERVICE_START);
2159 } else if (s->type == SERVICE_ONESHOT ||
2160 s->type == SERVICE_DBUS ||
2161 s->type == SERVICE_NOTIFY) {
2163 /* For oneshot services we wait until the start
2164 * process exited, too, but it is our main process. */
2166 /* For D-Bus services we know the main pid right away,
2167 * but wait for the bus name to appear on the
2168 * bus. Notify services are similar. */
2170 service_set_main_pid(s, pid);
2171 service_set_state(s, SERVICE_START);
2173 assert_not_reached("Unknown service type");
2178 log_warning_unit(UNIT(s)->id,
2179 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2180 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2183 static void service_enter_start_pre(Service *s) {
2188 service_unwatch_control_pid(s);
2190 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
2191 if (s->control_command) {
2192 /* Before we start anything, let's clear up what might
2193 * be left from previous runs. */
2194 service_kill_control_processes(s);
2196 s->control_command_id = SERVICE_EXEC_START_PRE;
2198 r = service_spawn(s,
2202 !s->permissions_start_only,
2203 !s->root_directory_start_only,
2211 service_set_state(s, SERVICE_START_PRE);
2213 service_enter_start(s);
2218 log_warning_unit(UNIT(s)->id,
2219 "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2220 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2223 static void service_enter_restart(Service *s) {
2224 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2229 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2230 /* Don't restart things if we are going down anyway */
2231 log_info_unit(UNIT(s)->id,
2232 "Stop job pending for unit, delaying automatic restart.");
2234 r = service_arm_timer(s, s->restart_usec);
2241 /* Any units that are bound to this service must also be
2242 * restarted. We use JOB_RESTART (instead of the more obvious
2243 * JOB_START) here so that those dependency jobs will be added
2245 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2249 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2250 * it will be canceled as part of the service_stop() call that
2251 * is executed as part of JOB_RESTART. */
2253 log_debug_unit(UNIT(s)->id,
2254 "%s scheduled restart job.", UNIT(s)->id);
2258 log_warning_unit(UNIT(s)->id,
2259 "%s failed to schedule restart job: %s",
2260 UNIT(s)->id, bus_error_message(&error, -r));
2261 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2264 static void service_enter_reload(Service *s) {
2269 service_unwatch_control_pid(s);
2271 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
2272 if (s->control_command) {
2273 s->control_command_id = SERVICE_EXEC_RELOAD;
2275 r = service_spawn(s,
2279 !s->permissions_start_only,
2280 !s->root_directory_start_only,
2288 service_set_state(s, SERVICE_RELOAD);
2290 service_enter_running(s, SERVICE_SUCCESS);
2295 log_warning_unit(UNIT(s)->id,
2296 "%s failed to run 'reload' task: %s",
2297 UNIT(s)->id, strerror(-r));
2298 s->reload_result = SERVICE_FAILURE_RESOURCES;
2299 service_enter_running(s, SERVICE_SUCCESS);
2302 static void service_run_next_control(Service *s) {
2306 assert(s->control_command);
2307 assert(s->control_command->command_next);
2309 assert(s->control_command_id != SERVICE_EXEC_START);
2311 s->control_command = s->control_command->command_next;
2312 service_unwatch_control_pid(s);
2314 r = service_spawn(s,
2318 !s->permissions_start_only,
2319 !s->root_directory_start_only,
2320 s->control_command_id == SERVICE_EXEC_START_PRE ||
2321 s->control_command_id == SERVICE_EXEC_STOP_POST,
2331 log_warning_unit(UNIT(s)->id,
2332 "%s failed to run next control task: %s",
2333 UNIT(s)->id, strerror(-r));
2335 if (s->state == SERVICE_START_PRE)
2336 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2337 else if (s->state == SERVICE_STOP)
2338 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2339 else if (s->state == SERVICE_STOP_POST)
2340 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2341 else if (s->state == SERVICE_RELOAD) {
2342 s->reload_result = SERVICE_FAILURE_RESOURCES;
2343 service_enter_running(s, SERVICE_SUCCESS);
2345 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2348 static void service_run_next_main(Service *s) {
2353 assert(s->main_command);
2354 assert(s->main_command->command_next);
2355 assert(s->type == SERVICE_ONESHOT);
2357 s->main_command = s->main_command->command_next;
2358 service_unwatch_main_pid(s);
2360 r = service_spawn(s,
2367 s->notify_access != NOTIFY_NONE,
2373 service_set_main_pid(s, pid);
2378 log_warning_unit(UNIT(s)->id,
2379 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2380 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2383 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none) {
2386 if (action == SERVICE_FAILURE_ACTION_REBOOT ||
2387 action == SERVICE_FAILURE_ACTION_REBOOT_FORCE)
2388 update_reboot_param_file(s->reboot_arg);
2392 case SERVICE_FAILURE_ACTION_NONE:
2393 if (log_action_none)
2394 log_warning_unit(UNIT(s)->id,
2395 "%s %s, refusing to start.", UNIT(s)->id, reason);
2398 case SERVICE_FAILURE_ACTION_REBOOT: {
2399 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2402 log_warning_unit(UNIT(s)->id,
2403 "%s %s, rebooting.", UNIT(s)->id, reason);
2405 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
2406 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
2407 true, &error, NULL);
2409 log_error_unit(UNIT(s)->id,
2410 "Failed to reboot: %s.", bus_error_message(&error, r));
2415 case SERVICE_FAILURE_ACTION_REBOOT_FORCE:
2416 log_warning_unit(UNIT(s)->id,
2417 "%s %s, forcibly rebooting.", UNIT(s)->id, reason);
2418 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2421 case SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE:
2422 log_warning_unit(UNIT(s)->id,
2423 "%s %s, rebooting immediately.", UNIT(s)->id, reason);
2425 if (s->reboot_arg) {
2426 log_info("Rebooting with argument '%s'.", s->reboot_arg);
2427 syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
2428 LINUX_REBOOT_CMD_RESTART2, s->reboot_arg);
2431 log_info("Rebooting.");
2432 reboot(RB_AUTOBOOT);
2436 log_error_unit(UNIT(s)->id,
2437 "failure action=%i", action);
2438 assert_not_reached("Unknown FailureAction.");
2444 static int service_start_limit_test(Service *s) {
2447 if (ratelimit_test(&s->start_limit))
2450 return service_execute_action(s, s->start_limit_action, "start request repeated too quickly", true);
2453 static int service_start(Unit *u) {
2454 Service *s = SERVICE(u);
2459 /* We cannot fulfill this request right now, try again later
2461 if (s->state == SERVICE_STOP ||
2462 s->state == SERVICE_STOP_SIGTERM ||
2463 s->state == SERVICE_STOP_SIGKILL ||
2464 s->state == SERVICE_STOP_POST ||
2465 s->state == SERVICE_FINAL_SIGTERM ||
2466 s->state == SERVICE_FINAL_SIGKILL)
2469 /* Already on it! */
2470 if (s->state == SERVICE_START_PRE ||
2471 s->state == SERVICE_START ||
2472 s->state == SERVICE_START_POST)
2475 /* A service that will be restarted must be stopped first to
2476 * trigger BindsTo and/or OnFailure dependencies. If a user
2477 * does not want to wait for the holdoff time to elapse, the
2478 * service should be manually restarted, not started. We
2479 * simply return EAGAIN here, so that any start jobs stay
2480 * queued, and assume that the auto restart timer will
2481 * eventually trigger the restart. */
2482 if (s->state == SERVICE_AUTO_RESTART)
2485 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2487 /* Make sure we don't enter a busy loop of some kind. */
2488 r = service_start_limit_test(s);
2490 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2494 s->result = SERVICE_SUCCESS;
2495 s->reload_result = SERVICE_SUCCESS;
2496 s->main_pid_known = false;
2497 s->main_pid_alien = false;
2498 s->forbid_restart = false;
2500 service_enter_start_pre(s);
2504 static int service_stop(Unit *u) {
2505 Service *s = SERVICE(u);
2509 /* Don't create restart jobs from here. */
2510 s->forbid_restart = true;
2513 if (s->state == SERVICE_STOP ||
2514 s->state == SERVICE_STOP_SIGTERM ||
2515 s->state == SERVICE_STOP_SIGKILL ||
2516 s->state == SERVICE_STOP_POST ||
2517 s->state == SERVICE_FINAL_SIGTERM ||
2518 s->state == SERVICE_FINAL_SIGKILL)
2521 /* A restart will be scheduled or is in progress. */
2522 if (s->state == SERVICE_AUTO_RESTART) {
2523 service_set_state(s, SERVICE_DEAD);
2527 /* If there's already something running we go directly into
2529 if (s->state == SERVICE_START_PRE ||
2530 s->state == SERVICE_START ||
2531 s->state == SERVICE_START_POST ||
2532 s->state == SERVICE_RELOAD) {
2533 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2537 assert(s->state == SERVICE_RUNNING ||
2538 s->state == SERVICE_EXITED);
2540 service_enter_stop(s, SERVICE_SUCCESS);
2544 static int service_reload(Unit *u) {
2545 Service *s = SERVICE(u);
2549 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2551 service_enter_reload(s);
2555 _pure_ static bool service_can_reload(Unit *u) {
2556 Service *s = SERVICE(u);
2560 return !!s->exec_command[SERVICE_EXEC_RELOAD];
2563 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2564 Service *s = SERVICE(u);
2570 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2571 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2572 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2574 if (s->control_pid > 0)
2575 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
2578 if (s->main_pid_known && s->main_pid > 0)
2579 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
2581 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2584 unit_serialize_item(u, f, "status-text", s->status_text);
2586 /* FIXME: There's a minor uncleanliness here: if there are
2587 * multiple commands attached here, we will start from the
2588 * first one again */
2589 if (s->control_command_id >= 0)
2590 unit_serialize_item(u, f, "control-command",
2591 service_exec_command_to_string(s->control_command_id));
2593 if (s->socket_fd >= 0) {
2596 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2599 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2602 if (s->main_exec_status.pid > 0) {
2603 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
2604 s->main_exec_status.pid);
2605 dual_timestamp_serialize(f, "main-exec-status-start",
2606 &s->main_exec_status.start_timestamp);
2607 dual_timestamp_serialize(f, "main-exec-status-exit",
2608 &s->main_exec_status.exit_timestamp);
2610 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2611 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2612 s->main_exec_status.code);
2613 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2614 s->main_exec_status.status);
2617 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2618 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2620 if (s->forbid_restart)
2621 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2626 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2627 Service *s = SERVICE(u);
2634 if (streq(key, "state")) {
2637 state = service_state_from_string(value);
2639 log_debug_unit(u->id, "Failed to parse state value %s", value);
2641 s->deserialized_state = state;
2642 } else if (streq(key, "result")) {
2645 f = service_result_from_string(value);
2647 log_debug_unit(u->id, "Failed to parse result value %s", value);
2648 else if (f != SERVICE_SUCCESS)
2651 } else if (streq(key, "reload-result")) {
2654 f = service_result_from_string(value);
2656 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
2657 else if (f != SERVICE_SUCCESS)
2658 s->reload_result = f;
2660 } else if (streq(key, "control-pid")) {
2663 if (parse_pid(value, &pid) < 0)
2664 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
2666 s->control_pid = pid;
2667 } else if (streq(key, "main-pid")) {
2670 if (parse_pid(value, &pid) < 0)
2671 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
2673 service_set_main_pid(s, pid);
2674 unit_watch_pid(UNIT(s), pid);
2676 } else if (streq(key, "main-pid-known")) {
2679 b = parse_boolean(value);
2681 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
2683 s->main_pid_known = b;
2684 } else if (streq(key, "status-text")) {
2691 free(s->status_text);
2695 } else if (streq(key, "control-command")) {
2696 ServiceExecCommand id;
2698 id = service_exec_command_from_string(value);
2700 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2702 s->control_command_id = id;
2703 s->control_command = s->exec_command[id];
2705 } else if (streq(key, "socket-fd")) {
2708 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2709 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
2712 safe_close(s->socket_fd);
2713 s->socket_fd = fdset_remove(fds, fd);
2715 } else if (streq(key, "main-exec-status-pid")) {
2718 if (parse_pid(value, &pid) < 0)
2719 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
2721 s->main_exec_status.pid = pid;
2722 } else if (streq(key, "main-exec-status-code")) {
2725 if (safe_atoi(value, &i) < 0)
2726 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
2728 s->main_exec_status.code = i;
2729 } else if (streq(key, "main-exec-status-status")) {
2732 if (safe_atoi(value, &i) < 0)
2733 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
2735 s->main_exec_status.status = i;
2736 } else if (streq(key, "main-exec-status-start"))
2737 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2738 else if (streq(key, "main-exec-status-exit"))
2739 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2740 else if (streq(key, "watchdog-timestamp"))
2741 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2742 else if (streq(key, "forbid-restart")) {
2745 b = parse_boolean(value);
2747 log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
2749 s->forbid_restart = b;
2751 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
2756 _pure_ static UnitActiveState service_active_state(Unit *u) {
2757 const UnitActiveState *table;
2761 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2763 return table[SERVICE(u)->state];
2766 static const char *service_sub_state_to_string(Unit *u) {
2769 return service_state_to_string(SERVICE(u)->state);
2772 static bool service_check_gc(Unit *u) {
2773 Service *s = SERVICE(u);
2777 /* Never clean up services that still have a process around,
2778 * even if the service is formally dead. */
2779 if (cgroup_good(s) > 0 ||
2780 main_pid_good(s) > 0 ||
2781 control_pid_good(s) > 0)
2784 #ifdef HAVE_SYSV_COMPAT
2792 _pure_ static bool service_check_snapshot(Unit *u) {
2793 Service *s = SERVICE(u);
2797 return (s->socket_fd < 0);
2800 static int service_retry_pid_file(Service *s) {
2803 assert(s->pid_file);
2804 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2806 r = service_load_pid_file(s, false);
2810 service_unwatch_pid_file(s);
2812 service_enter_running(s, SERVICE_SUCCESS);
2816 static int service_watch_pid_file(Service *s) {
2819 log_debug_unit(UNIT(s)->id,
2820 "Setting watch for %s's PID file %s",
2821 UNIT(s)->id, s->pid_file_pathspec->path);
2822 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2826 /* the pidfile might have appeared just before we set the watch */
2827 log_debug_unit(UNIT(s)->id,
2828 "Trying to read %s's PID file %s in case it changed",
2829 UNIT(s)->id, s->pid_file_pathspec->path);
2830 service_retry_pid_file(s);
2834 log_error_unit(UNIT(s)->id,
2835 "Failed to set a watch for %s's PID file %s: %s",
2836 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2837 service_unwatch_pid_file(s);
2841 static int service_demand_pid_file(Service *s) {
2844 assert(s->pid_file);
2845 assert(!s->pid_file_pathspec);
2847 ps = new0(PathSpec, 1);
2852 ps->path = strdup(s->pid_file);
2858 path_kill_slashes(ps->path);
2860 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2861 * keep their PID file open all the time. */
2862 ps->type = PATH_MODIFIED;
2863 ps->inotify_fd = -1;
2865 s->pid_file_pathspec = ps;
2867 return service_watch_pid_file(s);
2870 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2871 PathSpec *p = userdata;
2876 s = SERVICE(p->unit);
2880 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2881 assert(s->pid_file_pathspec);
2882 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2884 log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2886 if (path_spec_fd_event(p, events) < 0)
2889 if (service_retry_pid_file(s) == 0)
2892 if (service_watch_pid_file(s) < 0)
2898 service_unwatch_pid_file(s);
2899 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2903 static void service_notify_cgroup_empty_event(Unit *u) {
2904 Service *s = SERVICE(u);
2908 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
2912 /* Waiting for SIGCHLD is usually more interesting,
2913 * because it includes return codes/signals. Which is
2914 * why we ignore the cgroup events for most cases,
2915 * except when we don't know pid which to expect the
2919 case SERVICE_START_POST:
2920 /* If we were hoping for the daemon to write its PID file,
2921 * we can give up now. */
2922 if (s->pid_file_pathspec) {
2923 log_warning_unit(u->id,
2924 "%s never wrote its PID file. Failing.", UNIT(s)->id);
2925 service_unwatch_pid_file(s);
2926 if (s->state == SERVICE_START)
2927 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2929 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2933 case SERVICE_RUNNING:
2934 /* service_enter_running() will figure out what to do */
2935 service_enter_running(s, SERVICE_SUCCESS);
2938 case SERVICE_STOP_SIGTERM:
2939 case SERVICE_STOP_SIGKILL:
2941 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2942 service_enter_stop_post(s, SERVICE_SUCCESS);
2946 case SERVICE_STOP_POST:
2947 case SERVICE_FINAL_SIGTERM:
2948 case SERVICE_FINAL_SIGKILL:
2949 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2950 service_enter_dead(s, SERVICE_SUCCESS, true);
2959 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2960 Service *s = SERVICE(u);
2966 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2967 is_clean_exit_lsb(code, status, &s->success_status))
2968 f = SERVICE_SUCCESS;
2969 else if (code == CLD_EXITED)
2970 f = SERVICE_FAILURE_EXIT_CODE;
2971 else if (code == CLD_KILLED)
2972 f = SERVICE_FAILURE_SIGNAL;
2973 else if (code == CLD_DUMPED)
2974 f = SERVICE_FAILURE_CORE_DUMP;
2976 assert_not_reached("Unknown code");
2978 if (s->main_pid == pid) {
2979 /* Forking services may occasionally move to a new PID.
2980 * As long as they update the PID file before exiting the old
2981 * PID, they're fine. */
2982 if (service_load_pid_file(s, false) == 0)
2986 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2988 if (s->main_command) {
2989 /* If this is not a forking service than the
2990 * main process got started and hence we copy
2991 * the exit status so that it is recorded both
2992 * as main and as control process exit
2995 s->main_command->exec_status = s->main_exec_status;
2997 if (s->main_command->ignore)
2998 f = SERVICE_SUCCESS;
2999 } else if (s->exec_command[SERVICE_EXEC_START]) {
3001 /* If this is a forked process, then we should
3002 * ignore the return value if this was
3003 * configured for the starter process */
3005 if (s->exec_command[SERVICE_EXEC_START]->ignore)
3006 f = SERVICE_SUCCESS;
3009 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
3011 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
3012 u->id, sigchld_code_to_string(code), status,
3013 strna(code == CLD_EXITED
3014 ? exit_status_to_string(status, EXIT_STATUS_FULL)
3015 : signal_to_string(status)),
3016 "EXIT_CODE=%s", sigchld_code_to_string(code),
3017 "EXIT_STATUS=%i", status,
3020 if (f != SERVICE_SUCCESS)
3023 if (s->main_command &&
3024 s->main_command->command_next &&
3025 f == SERVICE_SUCCESS) {
3027 /* There is another command to *
3028 * execute, so let's do that. */
3030 log_debug_unit(u->id,
3031 "%s running next main command for state %s",
3032 u->id, service_state_to_string(s->state));
3033 service_run_next_main(s);
3037 /* The service exited, so the service is officially
3039 s->main_command = NULL;
3043 case SERVICE_START_POST:
3044 case SERVICE_RELOAD:
3046 /* Need to wait until the operation is
3051 if (s->type == SERVICE_ONESHOT) {
3052 /* This was our main goal, so let's go on */
3053 if (f == SERVICE_SUCCESS)
3054 service_enter_start_post(s);
3056 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3062 case SERVICE_RUNNING:
3063 service_enter_running(s, f);
3066 case SERVICE_STOP_SIGTERM:
3067 case SERVICE_STOP_SIGKILL:
3069 if (!control_pid_good(s))
3070 service_enter_stop_post(s, f);
3072 /* If there is still a control process, wait for that first */
3075 case SERVICE_STOP_POST:
3076 case SERVICE_FINAL_SIGTERM:
3077 case SERVICE_FINAL_SIGKILL:
3079 if (!control_pid_good(s))
3080 service_enter_dead(s, f, true);
3084 assert_not_reached("Uh, main process died at wrong time.");
3088 } else if (s->control_pid == pid) {
3091 if (s->control_command) {
3092 exec_status_exit(&s->control_command->exec_status,
3093 &s->exec_context, pid, code, status);
3095 if (s->control_command->ignore)
3096 f = SERVICE_SUCCESS;
3099 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
3100 "%s: control process exited, code=%s status=%i",
3101 u->id, sigchld_code_to_string(code), status);
3103 if (f != SERVICE_SUCCESS)
3106 /* Immediately get rid of the cgroup, so that the
3107 * kernel doesn't delay the cgroup empty messages for
3108 * the service cgroup any longer than necessary */
3109 service_kill_control_processes(s);
3111 if (s->control_command &&
3112 s->control_command->command_next &&
3113 f == SERVICE_SUCCESS) {
3115 /* There is another command to *
3116 * execute, so let's do that. */
3118 log_debug_unit(u->id,
3119 "%s running next control command for state %s",
3120 u->id, service_state_to_string(s->state));
3121 service_run_next_control(s);
3124 /* No further commands for this step, so let's
3125 * figure out what to do next */
3127 s->control_command = NULL;
3128 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3130 log_debug_unit(u->id,
3131 "%s got final SIGCHLD for state %s",
3132 u->id, service_state_to_string(s->state));
3136 case SERVICE_START_PRE:
3137 if (f == SERVICE_SUCCESS)
3138 service_enter_start(s);
3140 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3144 if (s->type != SERVICE_FORKING)
3145 /* Maybe spurious event due to a reload that changed the type? */
3148 if (f != SERVICE_SUCCESS) {
3149 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3154 bool has_start_post;
3157 /* Let's try to load the pid file here if we can.
3158 * The PID file might actually be created by a START_POST
3159 * script. In that case don't worry if the loading fails. */
3161 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3162 r = service_load_pid_file(s, !has_start_post);
3163 if (!has_start_post && r < 0) {
3164 r = service_demand_pid_file(s);
3165 if (r < 0 || !cgroup_good(s))
3166 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3170 service_search_main_pid(s);
3172 service_enter_start_post(s);
3175 case SERVICE_START_POST:
3176 if (f != SERVICE_SUCCESS) {
3177 service_enter_stop(s, f);
3184 r = service_load_pid_file(s, true);
3186 r = service_demand_pid_file(s);
3187 if (r < 0 || !cgroup_good(s))
3188 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3192 service_search_main_pid(s);
3194 service_enter_running(s, SERVICE_SUCCESS);
3197 case SERVICE_RELOAD:
3198 if (f == SERVICE_SUCCESS) {
3199 service_load_pid_file(s, true);
3200 service_search_main_pid(s);
3203 s->reload_result = f;
3204 service_enter_running(s, SERVICE_SUCCESS);
3208 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3211 case SERVICE_STOP_SIGTERM:
3212 case SERVICE_STOP_SIGKILL:
3213 if (main_pid_good(s) <= 0)
3214 service_enter_stop_post(s, f);
3216 /* If there is still a service
3217 * process around, wait until
3218 * that one quit, too */
3221 case SERVICE_STOP_POST:
3222 case SERVICE_FINAL_SIGTERM:
3223 case SERVICE_FINAL_SIGKILL:
3224 if (main_pid_good(s) <= 0)
3225 service_enter_dead(s, f, true);
3229 assert_not_reached("Uh, control process died at wrong time.");
3234 /* Notify clients about changed exit status */
3235 unit_add_to_dbus_queue(u);
3237 /* We got one SIGCHLD for the service, let's watch all
3238 * processes that are now running of the service, and watch
3239 * that. Among the PIDs we then watch will be children
3240 * reassigned to us, which hopefully allows us to identify
3241 * when all children are gone */
3242 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
3243 unit_watch_all_pids(u);
3245 /* If the PID set is empty now, then let's finish this off */
3246 if (set_isempty(u->pids))
3247 service_notify_cgroup_empty_event(u);
3250 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3251 Service *s = SERVICE(userdata);
3254 assert(source == s->timer_event_source);
3258 case SERVICE_START_PRE:
3260 log_warning_unit(UNIT(s)->id,
3261 "%s %s operation timed out. Terminating.",
3263 s->state == SERVICE_START ? "start" : "start-pre");
3264 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3267 case SERVICE_START_POST:
3268 log_warning_unit(UNIT(s)->id,
3269 "%s start-post operation timed out. Stopping.", UNIT(s)->id);
3270 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3273 case SERVICE_RELOAD:
3274 log_warning_unit(UNIT(s)->id,
3275 "%s reload operation timed out. Stopping.", UNIT(s)->id);
3276 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3277 service_enter_running(s, SERVICE_SUCCESS);
3281 log_warning_unit(UNIT(s)->id,
3282 "%s stopping timed out. Terminating.", UNIT(s)->id);
3283 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3286 case SERVICE_STOP_SIGTERM:
3287 if (s->kill_context.send_sigkill) {
3288 log_warning_unit(UNIT(s)->id,
3289 "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
3290 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3292 log_warning_unit(UNIT(s)->id,
3293 "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
3294 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3299 case SERVICE_STOP_SIGKILL:
3300 /* Uh, we sent a SIGKILL and it is still not gone?
3301 * Must be something we cannot kill, so let's just be
3302 * weirded out and continue */
3304 log_warning_unit(UNIT(s)->id,
3305 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
3306 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3309 case SERVICE_STOP_POST:
3310 log_warning_unit(UNIT(s)->id,
3311 "%s stop-post timed out. Terminating.", UNIT(s)->id);
3312 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3315 case SERVICE_FINAL_SIGTERM:
3316 if (s->kill_context.send_sigkill) {
3317 log_warning_unit(UNIT(s)->id,
3318 "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
3319 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3321 log_warning_unit(UNIT(s)->id,
3322 "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.",
3324 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3329 case SERVICE_FINAL_SIGKILL:
3330 log_warning_unit(UNIT(s)->id,
3331 "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
3332 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3335 case SERVICE_AUTO_RESTART:
3336 log_info_unit(UNIT(s)->id,
3337 s->restart_usec > 0 ?
3338 "%s holdoff time over, scheduling restart." :
3339 "%s has no holdoff time, scheduling restart.",
3341 service_enter_restart(s);
3345 assert_not_reached("Timeout at wrong time.");
3351 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
3352 Service *s = SERVICE(userdata);
3355 assert(source == s->watchdog_event_source);
3357 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
3358 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
3363 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3364 Service *s = SERVICE(u);
3366 bool notify_dbus = false;
3370 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s...)",
3371 u->id, pid, tags && *tags ? tags[0] : "(empty)");
3373 if (s->notify_access == NOTIFY_NONE) {
3374 log_warning_unit(u->id,
3375 "%s: Got notification message from PID "PID_FMT", but reception is disabled.",
3380 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3382 if (s->main_pid != 0)
3383 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);
3385 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);
3389 /* Interpret MAINPID= */
3390 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3391 (s->state == SERVICE_START ||
3392 s->state == SERVICE_START_POST ||
3393 s->state == SERVICE_RUNNING ||
3394 s->state == SERVICE_RELOAD)) {
3396 if (parse_pid(e + 8, &pid) < 0)
3397 log_warning_unit(u->id, "Failed to parse notification message %s", e);
3399 log_debug_unit(u->id, "%s: got %s", u->id, e);
3400 service_set_main_pid(s, pid);
3401 unit_watch_pid(UNIT(s), pid);
3406 /* Interpret READY= */
3407 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START && strv_find(tags, "READY=1")) {
3408 log_debug_unit(u->id, "%s: got READY=1", u->id);
3409 service_enter_start_post(s);
3413 /* Interpret STATUS= */
3414 e = strv_find_prefix(tags, "STATUS=");
3419 if (!utf8_is_valid(e+7)) {
3420 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
3424 log_debug_unit(u->id, "%s: got %s", u->id, e);
3435 if (!streq_ptr(s->status_text, t)) {
3436 free(s->status_text);
3443 /* Interpret WATCHDOG= */
3444 if (strv_find(tags, "WATCHDOG=1")) {
3445 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
3446 service_reset_watchdog(s);
3449 /* Notify clients about changed status or main pid */
3451 unit_add_to_dbus_queue(u);
3454 static int service_get_timeout(Unit *u, uint64_t *timeout) {
3455 Service *s = SERVICE(u);
3458 if (!s->timer_event_source)
3461 r = sd_event_source_get_time(s->timer_event_source, timeout);
3468 #ifdef HAVE_SYSV_COMPAT
3470 static int service_enumerate(Manager *m) {
3473 _cleanup_closedir_ DIR *d = NULL;
3474 _cleanup_free_ char *path = NULL, *fpath = NULL, *name = NULL;
3475 Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
3476 _cleanup_set_free_ Set *shutdown_services = NULL;
3483 if (m->running_as != SYSTEMD_SYSTEM)
3486 STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3487 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3491 path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3502 if (errno != ENOENT)
3503 log_warning("opendir(%s) failed: %m", path);
3508 while ((de = readdir(d))) {
3511 if (ignore_file(de->d_name))
3514 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3517 if (strlen(de->d_name) < 4)
3520 a = undecchar(de->d_name[1]);
3521 b = undecchar(de->d_name[2]);
3527 fpath = strjoin(path, "/", de->d_name, NULL);
3533 if (access(fpath, X_OK) < 0) {
3535 if (errno != ENOENT)
3536 log_warning("access() failed on %s: %m", fpath);
3542 name = sysv_translate_name(de->d_name + 3);
3548 r = manager_load_unit_prepare(m, name, NULL, NULL, &service);
3550 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3554 if (de->d_name[0] == 'S') {
3556 if (rcnd_table[i].type == RUNLEVEL_UP) {
3557 SERVICE(service)->sysv_start_priority_from_rcnd =
3558 MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3560 SERVICE(service)->sysv_enabled = true;
3563 r = set_ensure_allocated(&runlevel_services[i],
3564 trivial_hash_func, trivial_compare_func);
3568 r = set_put(runlevel_services[i], service);
3572 } else if (de->d_name[0] == 'K' &&
3573 (rcnd_table[i].type == RUNLEVEL_DOWN)) {
3575 r = set_ensure_allocated(&shutdown_services,
3576 trivial_hash_func, trivial_compare_func);
3580 r = set_put(shutdown_services, service);
3587 /* Now we loaded all stubs and are aware of the lowest
3588 start-up priority for all services, not let's actually load
3589 the services, this will also tell us which services are
3590 actually native now */
3591 manager_dispatch_load_queue(m);
3593 /* If this is a native service, rely on native ways to pull in
3594 * a service, don't pull it in via sysv rcN.d links. */
3595 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3596 SET_FOREACH(service, runlevel_services[i], j) {
3597 service = unit_follow_merge(service);
3599 if (service->fragment_path)
3602 r = unit_add_two_dependencies_by_name_inverse(
3603 service, UNIT_AFTER, UNIT_WANTS,
3604 rcnd_table[i].target, NULL, true);
3609 /* We honour K links only for halt/reboot. For the normal
3610 * runlevels we assume the stop jobs will be implicitly added
3611 * by the core logic. Also, we don't really distinguish here
3612 * between the runlevels 0 and 6 and just add them to the
3613 * special shutdown target. */
3614 SET_FOREACH(service, shutdown_services, j) {
3615 service = unit_follow_merge(service);
3617 if (service->fragment_path)
3620 r = unit_add_two_dependencies_by_name(
3621 service, UNIT_BEFORE, UNIT_CONFLICTS,
3622 SPECIAL_SHUTDOWN_TARGET, NULL, true);
3631 for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3632 set_free(runlevel_services[i]);
3638 static void service_bus_name_owner_change(
3641 const char *old_owner,
3642 const char *new_owner) {
3644 Service *s = SERVICE(u);
3650 assert(streq(s->bus_name, name));
3651 assert(old_owner || new_owner);
3653 if (old_owner && new_owner)
3654 log_debug_unit(u->id,
3655 "%s's D-Bus name %s changed owner from %s to %s",
3656 u->id, name, old_owner, new_owner);
3658 log_debug_unit(u->id,
3659 "%s's D-Bus name %s no longer registered by %s",
3660 u->id, name, old_owner);
3662 log_debug_unit(u->id,
3663 "%s's D-Bus name %s now registered by %s",
3664 u->id, name, new_owner);
3666 s->bus_name_good = !!new_owner;
3668 if (s->type == SERVICE_DBUS) {
3670 /* service_enter_running() will figure out what to
3672 if (s->state == SERVICE_RUNNING)
3673 service_enter_running(s, SERVICE_SUCCESS);
3674 else if (s->state == SERVICE_START && new_owner)
3675 service_enter_start_post(s);
3677 } else if (new_owner &&
3679 (s->state == SERVICE_START ||
3680 s->state == SERVICE_START_POST ||
3681 s->state == SERVICE_RUNNING ||
3682 s->state == SERVICE_RELOAD)) {
3684 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
3687 /* Try to acquire PID from bus service */
3689 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
3691 r = sd_bus_creds_get_pid(creds, &pid);
3693 log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3695 service_set_main_pid(s, pid);
3696 unit_watch_pid(UNIT(s), pid);
3701 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3702 _cleanup_free_ char *peer = NULL;
3708 /* This is called by the socket code when instantiating a new
3709 * service for a stream socket and the socket needs to be
3712 if (UNIT(s)->load_state != UNIT_LOADED)
3715 if (s->socket_fd >= 0)
3718 if (s->state != SERVICE_DEAD)
3721 if (getpeername_pretty(fd, &peer) >= 0) {
3723 if (UNIT(s)->description) {
3724 _cleanup_free_ char *a;
3726 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3730 r = unit_set_description(UNIT(s), a);
3732 r = unit_set_description(UNIT(s), peer);
3740 unit_ref_set(&s->accept_socket, UNIT(sock));
3742 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3745 static void service_reset_failed(Unit *u) {
3746 Service *s = SERVICE(u);
3750 if (s->state == SERVICE_FAILED)
3751 service_set_state(s, SERVICE_DEAD);
3753 s->result = SERVICE_SUCCESS;
3754 s->reload_result = SERVICE_SUCCESS;
3756 RATELIMIT_RESET(s->start_limit);
3759 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3760 Service *s = SERVICE(u);
3762 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3765 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3766 [SERVICE_DEAD] = "dead",
3767 [SERVICE_START_PRE] = "start-pre",
3768 [SERVICE_START] = "start",
3769 [SERVICE_START_POST] = "start-post",
3770 [SERVICE_RUNNING] = "running",
3771 [SERVICE_EXITED] = "exited",
3772 [SERVICE_RELOAD] = "reload",
3773 [SERVICE_STOP] = "stop",
3774 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3775 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3776 [SERVICE_STOP_POST] = "stop-post",
3777 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3778 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3779 [SERVICE_FAILED] = "failed",
3780 [SERVICE_AUTO_RESTART] = "auto-restart",
3783 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3785 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3786 [SERVICE_RESTART_NO] = "no",
3787 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3788 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3789 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3790 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3791 [SERVICE_RESTART_ALWAYS] = "always"
3794 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3796 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3797 [SERVICE_SIMPLE] = "simple",
3798 [SERVICE_FORKING] = "forking",
3799 [SERVICE_ONESHOT] = "oneshot",
3800 [SERVICE_DBUS] = "dbus",
3801 [SERVICE_NOTIFY] = "notify",
3802 [SERVICE_IDLE] = "idle"
3805 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3807 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3808 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3809 [SERVICE_EXEC_START] = "ExecStart",
3810 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3811 [SERVICE_EXEC_RELOAD] = "ExecReload",
3812 [SERVICE_EXEC_STOP] = "ExecStop",
3813 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3816 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3818 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3819 [NOTIFY_NONE] = "none",
3820 [NOTIFY_MAIN] = "main",
3821 [NOTIFY_ALL] = "all"
3824 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3826 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3827 [SERVICE_SUCCESS] = "success",
3828 [SERVICE_FAILURE_RESOURCES] = "resources",
3829 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3830 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3831 [SERVICE_FAILURE_SIGNAL] = "signal",
3832 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3833 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3834 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3837 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3839 static const char* const failure_action_table[_SERVICE_FAILURE_ACTION_MAX] = {
3840 [SERVICE_FAILURE_ACTION_NONE] = "none",
3841 [SERVICE_FAILURE_ACTION_REBOOT] = "reboot",
3842 [SERVICE_FAILURE_ACTION_REBOOT_FORCE] = "reboot-force",
3843 [SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE] = "reboot-immediate"
3845 DEFINE_STRING_TABLE_LOOKUP(failure_action, FailureAction);
3847 const UnitVTable service_vtable = {
3848 .object_size = sizeof(Service),
3849 .exec_context_offset = offsetof(Service, exec_context),
3850 .cgroup_context_offset = offsetof(Service, cgroup_context),
3851 .kill_context_offset = offsetof(Service, kill_context),
3852 .exec_runtime_offset = offsetof(Service, exec_runtime),
3858 .private_section = "Service",
3860 .init = service_init,
3861 .done = service_done,
3862 .load = service_load,
3864 .coldplug = service_coldplug,
3866 .dump = service_dump,
3868 .start = service_start,
3869 .stop = service_stop,
3870 .reload = service_reload,
3872 .can_reload = service_can_reload,
3874 .kill = service_kill,
3876 .serialize = service_serialize,
3877 .deserialize_item = service_deserialize_item,
3879 .active_state = service_active_state,
3880 .sub_state_to_string = service_sub_state_to_string,
3882 .check_gc = service_check_gc,
3883 .check_snapshot = service_check_snapshot,
3885 .sigchld_event = service_sigchld_event,
3887 .reset_failed = service_reset_failed,
3889 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3890 .notify_message = service_notify_message,
3892 .bus_name_owner_change = service_bus_name_owner_change,
3894 .bus_interface = "org.freedesktop.systemd1.Service",
3895 .bus_vtable = bus_service_vtable,
3896 .bus_set_property = bus_service_set_property,
3897 .bus_commit_properties = bus_service_commit_properties,
3899 .get_timeout = service_get_timeout,
3901 #ifdef HAVE_SYSV_COMPAT
3902 .enumerate = service_enumerate,
3905 .can_transient = true,
3907 .status_message_formats = {
3908 .starting_stopping = {
3909 [0] = "Starting %s...",
3910 [1] = "Stopping %s...",
3912 .finished_start_job = {
3913 [JOB_DONE] = "Started %s.",
3914 [JOB_FAILED] = "Failed to start %s.",
3915 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3916 [JOB_TIMEOUT] = "Timed out starting %s.",
3918 .finished_stop_job = {
3919 [JOB_DONE] = "Stopped %s.",
3920 [JOB_FAILED] = "Stopped (with error) %s.",
3921 [JOB_TIMEOUT] = "Timed out stopping %s.",