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/>.
31 #include "load-fragment.h"
32 #include "load-dropin.h"
35 #include "unit-name.h"
36 #include "unit-printf.h"
37 #include "dbus-service.h"
39 #include "exit-status.h"
41 #include "path-util.h"
46 #include "bus-error.h"
48 #include "bus-kernel.h"
50 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
51 [SERVICE_DEAD] = UNIT_INACTIVE,
52 [SERVICE_START_PRE] = UNIT_ACTIVATING,
53 [SERVICE_START] = UNIT_ACTIVATING,
54 [SERVICE_START_POST] = UNIT_ACTIVATING,
55 [SERVICE_RUNNING] = UNIT_ACTIVE,
56 [SERVICE_EXITED] = UNIT_ACTIVE,
57 [SERVICE_RELOAD] = UNIT_RELOADING,
58 [SERVICE_STOP] = UNIT_DEACTIVATING,
59 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
60 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
61 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
62 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
63 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
64 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
65 [SERVICE_FAILED] = UNIT_FAILED,
66 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
69 /* For Type=idle we never want to delay any other jobs, hence we
70 * consider idle jobs active as soon as we start working on them */
71 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
72 [SERVICE_DEAD] = UNIT_INACTIVE,
73 [SERVICE_START_PRE] = UNIT_ACTIVE,
74 [SERVICE_START] = UNIT_ACTIVE,
75 [SERVICE_START_POST] = UNIT_ACTIVE,
76 [SERVICE_RUNNING] = UNIT_ACTIVE,
77 [SERVICE_EXITED] = UNIT_ACTIVE,
78 [SERVICE_RELOAD] = UNIT_RELOADING,
79 [SERVICE_STOP] = UNIT_DEACTIVATING,
80 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
81 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
82 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
83 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
84 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
85 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
86 [SERVICE_FAILED] = UNIT_FAILED,
87 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
90 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
91 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
92 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
94 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
95 static void service_enter_reload_by_notify(Service *s);
97 static void service_init(Unit *u) {
98 Service *s = SERVICE(u);
101 assert(u->load_state == UNIT_STUB);
103 s->timeout_start_usec = u->manager->default_timeout_start_usec;
104 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
105 s->restart_usec = u->manager->default_restart_usec;
106 s->type = _SERVICE_TYPE_INVALID;
108 s->bus_endpoint_fd = -1;
109 s->guess_main_pid = true;
111 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
113 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
116 static void service_unwatch_control_pid(Service *s) {
119 if (s->control_pid <= 0)
122 unit_unwatch_pid(UNIT(s), s->control_pid);
126 static void service_unwatch_main_pid(Service *s) {
129 if (s->main_pid <= 0)
132 unit_unwatch_pid(UNIT(s), s->main_pid);
136 static void service_unwatch_pid_file(Service *s) {
137 if (!s->pid_file_pathspec)
140 log_unit_debug(UNIT(s)->id, "Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
141 path_spec_unwatch(s->pid_file_pathspec);
142 path_spec_done(s->pid_file_pathspec);
143 free(s->pid_file_pathspec);
144 s->pid_file_pathspec = NULL;
147 static int service_set_main_pid(Service *s, pid_t pid) {
158 if (s->main_pid == pid && s->main_pid_known)
161 if (s->main_pid != pid) {
162 service_unwatch_main_pid(s);
163 exec_status_start(&s->main_exec_status, pid);
167 s->main_pid_known = true;
169 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
170 log_unit_warning(UNIT(s)->id, "%s: Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", UNIT(s)->id, pid);
171 s->main_pid_alien = true;
173 s->main_pid_alien = false;
178 static void service_close_socket_fd(Service *s) {
181 s->socket_fd = asynchronous_close(s->socket_fd);
184 static void service_connection_unref(Service *s) {
187 if (!UNIT_ISSET(s->accept_socket))
190 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
191 unit_ref_unset(&s->accept_socket);
194 static void service_stop_watchdog(Service *s) {
197 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
198 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
201 static void service_start_watchdog(Service *s) {
206 if (s->watchdog_usec <= 0)
209 if (s->watchdog_event_source) {
210 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
212 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to reset watchdog timer: %m", UNIT(s)->id);
216 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
218 r = sd_event_add_time(
219 UNIT(s)->manager->event,
220 &s->watchdog_event_source,
222 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
223 service_dispatch_watchdog, s);
225 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to add watchdog timer: %m", UNIT(s)->id);
229 /* Let's process everything else which might be a sign
230 * of living before we consider a service died. */
231 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
235 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to install watchdog timer: %m", UNIT(s)->id);
238 static void service_reset_watchdog(Service *s) {
241 dual_timestamp_get(&s->watchdog_timestamp);
242 service_start_watchdog(s);
245 static void service_done(Unit *u) {
246 Service *s = SERVICE(u);
253 free(s->status_text);
254 s->status_text = NULL;
257 s->reboot_arg = NULL;
259 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
260 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
261 s->control_command = NULL;
262 s->main_command = NULL;
264 exit_status_set_free(&s->restart_prevent_status);
265 exit_status_set_free(&s->restart_force_status);
266 exit_status_set_free(&s->success_status);
268 /* This will leak a process, but at least no memory or any of
270 service_unwatch_main_pid(s);
271 service_unwatch_control_pid(s);
272 service_unwatch_pid_file(s);
275 unit_unwatch_bus_name(u, s->bus_name);
280 s->bus_endpoint_fd = safe_close(s->bus_endpoint_fd);
281 service_close_socket_fd(s);
282 service_connection_unref(s);
284 unit_ref_unset(&s->accept_socket);
286 service_stop_watchdog(s);
288 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
291 static int service_arm_timer(Service *s, usec_t usec) {
296 if (s->timer_event_source) {
297 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
301 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
304 return sd_event_add_time(
305 UNIT(s)->manager->event,
306 &s->timer_event_source,
308 now(CLOCK_MONOTONIC) + usec, 0,
309 service_dispatch_timer, s);
312 static int service_verify(Service *s) {
315 if (UNIT(s)->load_state != UNIT_LOADED)
318 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]) {
319 log_unit_error(UNIT(s)->id, "%s lacks both ExecStart= and ExecStop= setting. Refusing.", UNIT(s)->id);
323 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
324 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
328 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START]) {
329 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.", UNIT(s)->id);
333 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
334 log_unit_error(UNIT(s)->id, "%s has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
338 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
339 log_unit_error(UNIT(s)->id, "%s has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
343 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
344 log_unit_error(UNIT(s)->id, "%s has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
348 if (s->type == SERVICE_DBUS && !s->bus_name) {
349 log_unit_error(UNIT(s)->id, "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
353 if (s->bus_name && s->type != SERVICE_DBUS)
354 log_unit_warning(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
356 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
357 log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
364 static int service_add_default_dependencies(Service *s) {
369 /* Add a number of automatic dependencies useful for the
370 * majority of services. */
372 /* First, pull in base system */
373 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true);
377 /* Second, activate normal shutdown */
378 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
382 static void service_fix_output(Service *s) {
385 /* If nothing has been explicitly configured, patch default
386 * output in. If input is socket/tty we avoid this however,
387 * since in that case we want output to default to the same
388 * place as we read input from. */
390 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
391 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
392 s->exec_context.std_input == EXEC_INPUT_NULL)
393 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
395 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
396 s->exec_context.std_input == EXEC_INPUT_NULL)
397 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
400 static int service_load(Unit *u) {
401 Service *s = SERVICE(u);
406 /* Load a .service file */
407 r = unit_load_fragment(u);
411 /* Still nothing found? Then let's give up */
412 if (u->load_state == UNIT_STUB)
415 /* This is a new unit? Then let's add in some extras */
416 if (u->load_state == UNIT_LOADED) {
418 /* We were able to load something, then let's add in
419 * the dropin directories. */
420 r = unit_load_dropin(u);
424 if (s->type == _SERVICE_TYPE_INVALID) {
425 /* Figure out a type automatically */
427 s->type = SERVICE_DBUS;
428 else if (s->exec_command[SERVICE_EXEC_START])
429 s->type = SERVICE_SIMPLE;
431 s->type = SERVICE_ONESHOT;
434 /* Oneshot services have disabled start timeout by default */
435 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
436 s->timeout_start_usec = 0;
438 service_fix_output(s);
440 r = unit_patch_contexts(u);
444 r = unit_add_exec_dependencies(u, &s->exec_context);
448 r = unit_add_default_slice(u, &s->cgroup_context);
452 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
453 s->notify_access = NOTIFY_MAIN;
455 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
456 s->notify_access = NOTIFY_MAIN;
459 r = unit_watch_bus_name(u, s->bus_name);
464 if (u->default_dependencies) {
465 r = service_add_default_dependencies(s);
472 return service_verify(s);
475 static void service_dump(Unit *u, FILE *f, const char *prefix) {
476 ServiceExecCommand c;
477 Service *s = SERVICE(u);
482 prefix = strempty(prefix);
483 prefix2 = strappenda(prefix, "\t");
486 "%sService State: %s\n"
488 "%sReload Result: %s\n"
489 "%sPermissionsStartOnly: %s\n"
490 "%sRootDirectoryStartOnly: %s\n"
491 "%sRemainAfterExit: %s\n"
492 "%sGuessMainPID: %s\n"
495 "%sNotifyAccess: %s\n"
496 "%sNotifyState: %s\n",
497 prefix, service_state_to_string(s->state),
498 prefix, service_result_to_string(s->result),
499 prefix, service_result_to_string(s->reload_result),
500 prefix, yes_no(s->permissions_start_only),
501 prefix, yes_no(s->root_directory_start_only),
502 prefix, yes_no(s->remain_after_exit),
503 prefix, yes_no(s->guess_main_pid),
504 prefix, service_type_to_string(s->type),
505 prefix, service_restart_to_string(s->restart),
506 prefix, notify_access_to_string(s->notify_access),
507 prefix, notify_state_to_string(s->notify_state));
509 if (s->control_pid > 0)
511 "%sControl PID: "PID_FMT"\n",
512 prefix, s->control_pid);
516 "%sMain PID: "PID_FMT"\n"
517 "%sMain PID Known: %s\n"
518 "%sMain PID Alien: %s\n",
520 prefix, yes_no(s->main_pid_known),
521 prefix, yes_no(s->main_pid_alien));
526 prefix, s->pid_file);
531 "%sBus Name Good: %s\n",
533 prefix, yes_no(s->bus_name_good));
535 kill_context_dump(&s->kill_context, f, prefix);
536 exec_context_dump(&s->exec_context, f, prefix);
538 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
540 if (!s->exec_command[c])
543 fprintf(f, "%s-> %s:\n",
544 prefix, service_exec_command_to_string(c));
546 exec_command_dump_list(s->exec_command[c], f, prefix2);
550 fprintf(f, "%sStatus Text: %s\n",
551 prefix, s->status_text);
554 static int service_load_pid_file(Service *s, bool may_warn) {
555 _cleanup_free_ char *k = NULL;
564 r = read_one_line_file(s->pid_file, &k);
567 log_unit_info(UNIT(s)->id, "PID file %s not readable (yet?) after %s.", s->pid_file, service_state_to_string(s->state));
571 r = parse_pid(k, &pid);
574 log_unit_info_errno(UNIT(s)->id, r, "Failed to read PID from file %s: %m", s->pid_file);
578 if (!pid_is_alive(pid)) {
580 log_unit_info(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
584 if (s->main_pid_known) {
585 if (pid == s->main_pid)
588 log_unit_debug(UNIT(s)->id, "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
590 service_unwatch_main_pid(s);
591 s->main_pid_known = false;
593 log_unit_debug(UNIT(s)->id, "Main PID loaded: "PID_FMT, pid);
595 r = service_set_main_pid(s, pid);
599 r = unit_watch_pid(UNIT(s), pid);
601 /* FIXME: we need to do something here */
602 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
609 static int service_search_main_pid(Service *s) {
615 /* If we know it anyway, don't ever fallback to unreliable
617 if (s->main_pid_known)
620 if (!s->guess_main_pid)
623 assert(s->main_pid <= 0);
625 pid = unit_search_main_pid(UNIT(s));
629 log_unit_debug(UNIT(s)->id, "Main PID guessed: "PID_FMT, pid);
630 r = service_set_main_pid(s, pid);
634 r = unit_watch_pid(UNIT(s), pid);
636 /* FIXME: we need to do something here */
637 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
644 static void service_set_state(Service *s, ServiceState state) {
645 ServiceState old_state;
646 const UnitActiveState *table;
650 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
652 old_state = s->state;
655 service_unwatch_pid_file(s);
658 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
660 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
661 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
662 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
663 SERVICE_AUTO_RESTART))
664 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
667 SERVICE_START, SERVICE_START_POST,
668 SERVICE_RUNNING, SERVICE_RELOAD,
669 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
670 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
671 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
672 service_unwatch_main_pid(s);
673 s->main_command = NULL;
677 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
679 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
680 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
681 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
682 service_unwatch_control_pid(s);
683 s->control_command = NULL;
684 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
687 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
688 unit_unwatch_all_pids(UNIT(s));
691 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
692 SERVICE_RUNNING, SERVICE_RELOAD,
693 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
694 SERVICE_STOP_SIGABRT, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
695 !(state == SERVICE_DEAD && UNIT(s)->job)) {
696 service_close_socket_fd(s);
697 service_connection_unref(s);
700 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
701 service_stop_watchdog(s);
703 /* For the inactive states unit_notify() will trim the cgroup,
704 * but for exit we have to do that ourselves... */
705 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
706 unit_destroy_cgroup_if_empty(UNIT(s));
708 /* For remain_after_exit services, let's see if we can "release" the
709 * hold on the console, since unit_notify() only does that in case of
711 if (state == SERVICE_EXITED &&
712 s->remain_after_exit &&
713 UNIT(s)->manager->n_on_console > 0) {
717 ec = unit_get_exec_context(UNIT(s));
718 if (ec && exec_context_may_touch_console(ec)) {
719 Manager *m = UNIT(s)->manager;
722 if (m->n_on_console == 0)
723 /* unset no_console_output flag, since the console is free */
724 m->no_console_output = false;
728 if (old_state != state)
729 log_unit_debug(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
731 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
732 s->reload_result = SERVICE_SUCCESS;
735 static int service_coldplug(Unit *u) {
736 Service *s = SERVICE(u);
740 assert(s->state == SERVICE_DEAD);
742 if (s->deserialized_state != s->state) {
744 if (IN_SET(s->deserialized_state,
745 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
747 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
748 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
749 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
753 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
755 /* For the start/stop timeouts 0 means off */
757 r = service_arm_timer(s, k);
763 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
765 /* The restart timeouts 0 means immediately */
766 r = service_arm_timer(s, s->restart_usec);
771 if (pid_is_unwaited(s->main_pid) &&
772 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
773 IN_SET(s->deserialized_state,
774 SERVICE_START, SERVICE_START_POST,
775 SERVICE_RUNNING, SERVICE_RELOAD,
776 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
777 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
778 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
779 r = unit_watch_pid(UNIT(s), s->main_pid);
784 if (pid_is_unwaited(s->control_pid) &&
785 IN_SET(s->deserialized_state,
786 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
788 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
789 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
790 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
791 r = unit_watch_pid(UNIT(s), s->control_pid);
796 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
797 unit_watch_all_pids(UNIT(s));
799 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
800 service_start_watchdog(s);
802 service_set_state(s, s->deserialized_state);
808 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
819 if (s->socket_fd >= 0)
822 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
827 if (u->type != UNIT_SOCKET)
832 r = socket_collect_fds(sock, &cfds, &cn_fds);
845 t = new(int, rn_fds+cn_fds);
852 memcpy(t, rfds, rn_fds * sizeof(int));
853 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
858 rn_fds = rn_fds+cn_fds;
873 static int service_spawn(
878 bool apply_permissions,
880 bool apply_tty_stdin,
887 _cleanup_free_ int *fdsbuf = NULL;
888 unsigned n_fds = 0, n_env = 0;
889 _cleanup_free_ char *bus_endpoint_path = NULL;
890 _cleanup_strv_free_ char
891 **argv = NULL, **final_env = NULL, **our_env = NULL;
893 ExecParameters exec_params = {
894 .apply_permissions = apply_permissions,
895 .apply_chroot = apply_chroot,
896 .apply_tty_stdin = apply_tty_stdin,
897 .bus_endpoint_fd = -1,
898 .selinux_context_net = s->socket_fd_selinux_context_net
905 unit_realize_cgroup(UNIT(s));
907 r = unit_setup_exec_runtime(UNIT(s));
912 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
913 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
914 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
916 if (s->socket_fd >= 0) {
920 r = service_collect_fds(s, &fdsbuf, &n_fds);
929 r = service_arm_timer(s, timeout);
933 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
935 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
939 our_env = new0(char*, 4);
945 if (is_control ? s->notify_access == NOTIFY_ALL : s->notify_access != NOTIFY_NONE)
946 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
952 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
957 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
958 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
963 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
969 if (is_control && UNIT(s)->cgroup_path) {
970 path = strappenda(UNIT(s)->cgroup_path, "/control");
971 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
973 path = UNIT(s)->cgroup_path;
976 if (s->exec_context.bus_endpoint) {
977 r = bus_kernel_create_endpoint(UNIT(s)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user",
978 UNIT(s)->id, &bus_endpoint_path);
982 /* Pass the fd to the exec_params so that the child process can upload the policy.
983 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
984 * as the service is running. */
985 exec_params.bus_endpoint_fd = s->bus_endpoint_fd = r;
989 exec_params.argv = argv;
990 exec_params.fds = fds;
991 exec_params.n_fds = n_fds;
992 exec_params.environment = final_env;
993 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
994 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
995 exec_params.cgroup_path = path;
996 exec_params.cgroup_delegate = s->cgroup_context.delegate;
997 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
998 exec_params.unit_id = UNIT(s)->id;
999 exec_params.watchdog_usec = s->watchdog_usec;
1000 exec_params.bus_endpoint_path = bus_endpoint_path;
1001 if (s->type == SERVICE_IDLE)
1002 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1012 r = unit_watch_pid(UNIT(s), pid);
1014 /* FIXME: we need to do something here */
1023 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1028 static int main_pid_good(Service *s) {
1031 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1034 /* If we know the pid file, then lets just check if it is
1036 if (s->main_pid_known) {
1038 /* If it's an alien child let's check if it is still
1040 if (s->main_pid_alien && s->main_pid > 0)
1041 return pid_is_alive(s->main_pid);
1043 /* .. otherwise assume we'll get a SIGCHLD for it,
1044 * which we really should wait for to collect exit
1045 * status and code */
1046 return s->main_pid > 0;
1049 /* We don't know the pid */
1053 _pure_ static int control_pid_good(Service *s) {
1056 return s->control_pid > 0;
1059 static int cgroup_good(Service *s) {
1064 if (!UNIT(s)->cgroup_path)
1067 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1074 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1078 if (f != SERVICE_SUCCESS)
1081 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1083 if (s->result != SERVICE_SUCCESS) {
1084 log_unit_warning(UNIT(s)->id, "%s failed.", UNIT(s)->id);
1085 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1088 if (allow_restart &&
1089 !s->forbid_restart &&
1090 (s->restart == SERVICE_RESTART_ALWAYS ||
1091 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1092 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1093 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1094 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1095 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1096 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1097 (IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) && set_contains(s->restart_force_status.signal, INT_TO_PTR(s->main_exec_status.status)))) &&
1098 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
1099 (!IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) || !set_contains(s->restart_prevent_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1101 r = service_arm_timer(s, s->restart_usec);
1105 service_set_state(s, SERVICE_AUTO_RESTART);
1108 s->forbid_restart = false;
1110 /* We want fresh tmpdirs in case service is started again immediately */
1111 exec_runtime_destroy(s->exec_runtime);
1112 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1114 /* Also, remove the runtime directory in */
1115 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1117 /* Try to delete the pid file. At this point it will be
1118 * out-of-date, and some software might be confused by it, so
1119 * let's remove it. */
1121 unlink_noerrno(s->pid_file);
1126 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run install restart timer: %m", UNIT(s)->id);
1127 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1130 static void service_enter_stop_post(Service *s, ServiceResult f) {
1134 if (f != SERVICE_SUCCESS)
1137 service_unwatch_control_pid(s);
1138 unit_watch_all_pids(UNIT(s));
1140 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1141 if (s->control_command) {
1142 s->control_command_id = SERVICE_EXEC_STOP_POST;
1144 r = service_spawn(s,
1146 s->timeout_stop_usec,
1148 !s->permissions_start_only,
1149 !s->root_directory_start_only,
1156 service_set_state(s, SERVICE_STOP_POST);
1158 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1163 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop-post' task: %m", UNIT(s)->id);
1164 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1167 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1172 if (f != SERVICE_SUCCESS)
1175 unit_watch_all_pids(UNIT(s));
1177 r = unit_kill_context(
1180 (state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM && state != SERVICE_STOP_SIGABRT) ?
1181 KILL_KILL : (state == SERVICE_STOP_SIGABRT ? KILL_ABORT : KILL_TERMINATE),
1190 if (s->timeout_stop_usec > 0) {
1191 r = service_arm_timer(s, s->timeout_stop_usec);
1196 service_set_state(s, state);
1197 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGABRT)
1198 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1199 else if (state == SERVICE_STOP_SIGKILL)
1200 service_enter_stop_post(s, SERVICE_SUCCESS);
1201 else if (state == SERVICE_FINAL_SIGTERM)
1202 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1204 service_enter_dead(s, SERVICE_SUCCESS, true);
1209 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
1211 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL ||
1212 state == SERVICE_STOP_SIGABRT)
1213 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1215 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1218 static void service_enter_stop_by_notify(Service *s) {
1221 unit_watch_all_pids(UNIT(s));
1223 if (s->timeout_stop_usec > 0)
1224 service_arm_timer(s, s->timeout_stop_usec);
1226 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1227 service_set_state(s, SERVICE_STOP_SIGTERM);
1230 static void service_enter_stop(Service *s, ServiceResult f) {
1235 if (f != SERVICE_SUCCESS)
1238 service_unwatch_control_pid(s);
1239 unit_watch_all_pids(UNIT(s));
1241 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1242 if (s->control_command) {
1243 s->control_command_id = SERVICE_EXEC_STOP;
1245 r = service_spawn(s,
1247 s->timeout_stop_usec,
1249 !s->permissions_start_only,
1250 !s->root_directory_start_only,
1257 service_set_state(s, SERVICE_STOP);
1259 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1264 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop' task: %m", UNIT(s)->id);
1265 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1268 static void service_enter_running(Service *s, ServiceResult f) {
1269 int main_pid_ok, cgroup_ok;
1272 if (f != SERVICE_SUCCESS)
1275 main_pid_ok = main_pid_good(s);
1276 cgroup_ok = cgroup_good(s);
1278 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1279 (s->bus_name_good || s->type != SERVICE_DBUS)) {
1281 /* If there are any queued up sd_notify()
1282 * notifications, process them now */
1283 if (s->notify_state == NOTIFY_RELOADING)
1284 service_enter_reload_by_notify(s);
1285 else if (s->notify_state == NOTIFY_STOPPING)
1286 service_enter_stop_by_notify(s);
1288 service_set_state(s, SERVICE_RUNNING);
1290 } else if (s->remain_after_exit)
1291 service_set_state(s, SERVICE_EXITED);
1293 service_enter_stop(s, SERVICE_SUCCESS);
1296 static void service_enter_start_post(Service *s) {
1300 service_unwatch_control_pid(s);
1301 service_reset_watchdog(s);
1303 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1304 if (s->control_command) {
1305 s->control_command_id = SERVICE_EXEC_START_POST;
1307 r = service_spawn(s,
1309 s->timeout_start_usec,
1311 !s->permissions_start_only,
1312 !s->root_directory_start_only,
1319 service_set_state(s, SERVICE_START_POST);
1321 service_enter_running(s, SERVICE_SUCCESS);
1326 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-post' task: %m", UNIT(s)->id);
1327 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1330 static void service_kill_control_processes(Service *s) {
1333 if (!UNIT(s)->cgroup_path)
1336 p = strappenda(UNIT(s)->cgroup_path, "/control");
1337 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1340 static void service_enter_start(Service *s) {
1347 service_unwatch_control_pid(s);
1348 service_unwatch_main_pid(s);
1350 /* We want to ensure that nobody leaks processes from
1351 * START_PRE here, so let's go on a killing spree, People
1352 * should not spawn long running processes from START_PRE. */
1353 service_kill_control_processes(s);
1355 if (s->type == SERVICE_FORKING) {
1356 s->control_command_id = SERVICE_EXEC_START;
1357 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1359 s->main_command = NULL;
1361 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1362 s->control_command = NULL;
1364 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1368 assert(s->type == SERVICE_ONESHOT);
1369 service_enter_start_post(s);
1373 r = service_spawn(s,
1375 IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_ONESHOT) ? s->timeout_start_usec : 0,
1385 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1386 /* For simple services we immediately start
1387 * the START_POST binaries. */
1389 service_set_main_pid(s, pid);
1390 service_enter_start_post(s);
1392 } else if (s->type == SERVICE_FORKING) {
1394 /* For forking services we wait until the start
1395 * process exited. */
1397 s->control_pid = pid;
1398 service_set_state(s, SERVICE_START);
1400 } else if (s->type == SERVICE_ONESHOT ||
1401 s->type == SERVICE_DBUS ||
1402 s->type == SERVICE_NOTIFY) {
1404 /* For oneshot services we wait until the start
1405 * process exited, too, but it is our main process. */
1407 /* For D-Bus services we know the main pid right away,
1408 * but wait for the bus name to appear on the
1409 * bus. Notify services are similar. */
1411 service_set_main_pid(s, pid);
1412 service_set_state(s, SERVICE_START);
1414 assert_not_reached("Unknown service type");
1419 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start' task: %m", UNIT(s)->id);
1420 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1423 static void service_enter_start_pre(Service *s) {
1428 service_unwatch_control_pid(s);
1430 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1431 if (s->control_command) {
1432 /* Before we start anything, let's clear up what might
1433 * be left from previous runs. */
1434 service_kill_control_processes(s);
1436 s->control_command_id = SERVICE_EXEC_START_PRE;
1438 r = service_spawn(s,
1440 s->timeout_start_usec,
1442 !s->permissions_start_only,
1443 !s->root_directory_start_only,
1450 service_set_state(s, SERVICE_START_PRE);
1452 service_enter_start(s);
1457 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-pre' task: %m", UNIT(s)->id);
1458 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1461 static void service_enter_restart(Service *s) {
1462 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1467 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1468 /* Don't restart things if we are going down anyway */
1469 log_unit_info(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1471 r = service_arm_timer(s, s->restart_usec);
1478 /* Any units that are bound to this service must also be
1479 * restarted. We use JOB_RESTART (instead of the more obvious
1480 * JOB_START) here so that those dependency jobs will be added
1482 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1486 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1487 * it will be canceled as part of the service_stop() call that
1488 * is executed as part of JOB_RESTART. */
1490 log_unit_debug(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1494 log_unit_warning(UNIT(s)->id, "%s failed to schedule restart job: %s", UNIT(s)->id, bus_error_message(&error, -r));
1495 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1498 static void service_enter_reload_by_notify(Service *s) {
1501 if (s->timeout_start_usec > 0)
1502 service_arm_timer(s, s->timeout_start_usec);
1504 service_set_state(s, SERVICE_RELOAD);
1507 static void service_enter_reload(Service *s) {
1512 service_unwatch_control_pid(s);
1514 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1515 if (s->control_command) {
1516 s->control_command_id = SERVICE_EXEC_RELOAD;
1518 r = service_spawn(s,
1520 s->timeout_start_usec,
1522 !s->permissions_start_only,
1523 !s->root_directory_start_only,
1530 service_set_state(s, SERVICE_RELOAD);
1532 service_enter_running(s, SERVICE_SUCCESS);
1537 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'reload' task: %m", UNIT(s)->id);
1538 s->reload_result = SERVICE_FAILURE_RESOURCES;
1539 service_enter_running(s, SERVICE_SUCCESS);
1542 static void service_run_next_control(Service *s) {
1546 assert(s->control_command);
1547 assert(s->control_command->command_next);
1549 assert(s->control_command_id != SERVICE_EXEC_START);
1551 s->control_command = s->control_command->command_next;
1552 service_unwatch_control_pid(s);
1554 r = service_spawn(s,
1556 IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec,
1558 !s->permissions_start_only,
1559 !s->root_directory_start_only,
1560 s->control_command_id == SERVICE_EXEC_START_PRE ||
1561 s->control_command_id == SERVICE_EXEC_STOP_POST,
1570 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next control task: %m", UNIT(s)->id);
1572 if (s->state == SERVICE_START_PRE)
1573 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1574 else if (s->state == SERVICE_STOP)
1575 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1576 else if (s->state == SERVICE_STOP_POST)
1577 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1578 else if (s->state == SERVICE_RELOAD) {
1579 s->reload_result = SERVICE_FAILURE_RESOURCES;
1580 service_enter_running(s, SERVICE_SUCCESS);
1582 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1585 static void service_run_next_main(Service *s) {
1590 assert(s->main_command);
1591 assert(s->main_command->command_next);
1592 assert(s->type == SERVICE_ONESHOT);
1594 s->main_command = s->main_command->command_next;
1595 service_unwatch_main_pid(s);
1597 r = service_spawn(s,
1599 s->timeout_start_usec,
1609 service_set_main_pid(s, pid);
1614 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next main task: %m", UNIT(s)->id);
1615 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1618 static int service_start_limit_test(Service *s) {
1621 if (ratelimit_test(&s->start_limit))
1624 log_unit_warning(UNIT(s)->id, "start request repeated too quickly for %s", UNIT(s)->id);
1626 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
1629 static int service_start(Unit *u) {
1630 Service *s = SERVICE(u);
1635 /* We cannot fulfill this request right now, try again later
1637 if (s->state == SERVICE_STOP ||
1638 s->state == SERVICE_STOP_SIGABRT ||
1639 s->state == SERVICE_STOP_SIGTERM ||
1640 s->state == SERVICE_STOP_SIGKILL ||
1641 s->state == SERVICE_STOP_POST ||
1642 s->state == SERVICE_FINAL_SIGTERM ||
1643 s->state == SERVICE_FINAL_SIGKILL)
1646 /* Already on it! */
1647 if (s->state == SERVICE_START_PRE ||
1648 s->state == SERVICE_START ||
1649 s->state == SERVICE_START_POST)
1652 /* A service that will be restarted must be stopped first to
1653 * trigger BindsTo and/or OnFailure dependencies. If a user
1654 * does not want to wait for the holdoff time to elapse, the
1655 * service should be manually restarted, not started. We
1656 * simply return EAGAIN here, so that any start jobs stay
1657 * queued, and assume that the auto restart timer will
1658 * eventually trigger the restart. */
1659 if (s->state == SERVICE_AUTO_RESTART)
1662 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1664 /* Make sure we don't enter a busy loop of some kind. */
1665 r = service_start_limit_test(s);
1667 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1671 s->result = SERVICE_SUCCESS;
1672 s->reload_result = SERVICE_SUCCESS;
1673 s->main_pid_known = false;
1674 s->main_pid_alien = false;
1675 s->forbid_restart = false;
1677 free(s->status_text);
1678 s->status_text = NULL;
1679 s->status_errno = 0;
1681 s->notify_state = NOTIFY_UNKNOWN;
1683 service_enter_start_pre(s);
1687 static int service_stop(Unit *u) {
1688 Service *s = SERVICE(u);
1692 /* Don't create restart jobs from here. */
1693 s->forbid_restart = true;
1696 if (s->state == SERVICE_STOP ||
1697 s->state == SERVICE_STOP_SIGABRT ||
1698 s->state == SERVICE_STOP_SIGTERM ||
1699 s->state == SERVICE_STOP_SIGKILL ||
1700 s->state == SERVICE_STOP_POST ||
1701 s->state == SERVICE_FINAL_SIGTERM ||
1702 s->state == SERVICE_FINAL_SIGKILL)
1705 /* A restart will be scheduled or is in progress. */
1706 if (s->state == SERVICE_AUTO_RESTART) {
1707 service_set_state(s, SERVICE_DEAD);
1711 /* If there's already something running we go directly into
1713 if (s->state == SERVICE_START_PRE ||
1714 s->state == SERVICE_START ||
1715 s->state == SERVICE_START_POST ||
1716 s->state == SERVICE_RELOAD) {
1717 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1721 assert(s->state == SERVICE_RUNNING ||
1722 s->state == SERVICE_EXITED);
1724 service_enter_stop(s, SERVICE_SUCCESS);
1728 static int service_reload(Unit *u) {
1729 Service *s = SERVICE(u);
1733 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1735 service_enter_reload(s);
1739 _pure_ static bool service_can_reload(Unit *u) {
1740 Service *s = SERVICE(u);
1744 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1747 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1748 Service *s = SERVICE(u);
1754 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1755 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1756 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1758 if (s->control_pid > 0)
1759 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1762 if (s->main_pid_known && s->main_pid > 0)
1763 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1765 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1768 unit_serialize_item(u, f, "status-text", s->status_text);
1770 /* FIXME: There's a minor uncleanliness here: if there are
1771 * multiple commands attached here, we will start from the
1772 * first one again */
1773 if (s->control_command_id >= 0)
1774 unit_serialize_item(u, f, "control-command",
1775 service_exec_command_to_string(s->control_command_id));
1777 if (s->socket_fd >= 0) {
1780 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
1783 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1786 if (s->bus_endpoint_fd >= 0) {
1789 if ((copy = fdset_put_dup(fds, s->bus_endpoint_fd)) < 0)
1792 unit_serialize_item_format(u, f, "endpoint-fd", "%i", copy);
1795 if (s->main_exec_status.pid > 0) {
1796 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
1797 s->main_exec_status.pid);
1798 dual_timestamp_serialize(f, "main-exec-status-start",
1799 &s->main_exec_status.start_timestamp);
1800 dual_timestamp_serialize(f, "main-exec-status-exit",
1801 &s->main_exec_status.exit_timestamp);
1803 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1804 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
1805 s->main_exec_status.code);
1806 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
1807 s->main_exec_status.status);
1810 if (dual_timestamp_is_set(&s->watchdog_timestamp))
1811 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
1813 if (s->forbid_restart)
1814 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
1819 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1820 Service *s = SERVICE(u);
1827 if (streq(key, "state")) {
1830 state = service_state_from_string(value);
1832 log_unit_debug(u->id, "Failed to parse state value %s", value);
1834 s->deserialized_state = state;
1835 } else if (streq(key, "result")) {
1838 f = service_result_from_string(value);
1840 log_unit_debug(u->id, "Failed to parse result value %s", value);
1841 else if (f != SERVICE_SUCCESS)
1844 } else if (streq(key, "reload-result")) {
1847 f = service_result_from_string(value);
1849 log_unit_debug(u->id, "Failed to parse reload result value %s", value);
1850 else if (f != SERVICE_SUCCESS)
1851 s->reload_result = f;
1853 } else if (streq(key, "control-pid")) {
1856 if (parse_pid(value, &pid) < 0)
1857 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
1859 s->control_pid = pid;
1860 } else if (streq(key, "main-pid")) {
1863 if (parse_pid(value, &pid) < 0)
1864 log_unit_debug(u->id, "Failed to parse main-pid value %s", value);
1866 service_set_main_pid(s, pid);
1867 unit_watch_pid(UNIT(s), pid);
1869 } else if (streq(key, "main-pid-known")) {
1872 b = parse_boolean(value);
1874 log_unit_debug(u->id, "Failed to parse main-pid-known value %s", value);
1876 s->main_pid_known = b;
1877 } else if (streq(key, "status-text")) {
1884 free(s->status_text);
1888 } else if (streq(key, "control-command")) {
1889 ServiceExecCommand id;
1891 id = service_exec_command_from_string(value);
1893 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
1895 s->control_command_id = id;
1896 s->control_command = s->exec_command[id];
1898 } else if (streq(key, "socket-fd")) {
1901 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1902 log_unit_debug(u->id, "Failed to parse socket-fd value %s", value);
1904 asynchronous_close(s->socket_fd);
1905 s->socket_fd = fdset_remove(fds, fd);
1907 } else if (streq(key, "endpoint-fd")) {
1910 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1911 log_unit_debug(u->id, "Failed to parse endpoint-fd value %s", value);
1913 safe_close(s->bus_endpoint_fd);
1914 s->bus_endpoint_fd = fdset_remove(fds, fd);
1916 } else if (streq(key, "main-exec-status-pid")) {
1919 if (parse_pid(value, &pid) < 0)
1920 log_unit_debug(u->id, "Failed to parse main-exec-status-pid value %s", value);
1922 s->main_exec_status.pid = pid;
1923 } else if (streq(key, "main-exec-status-code")) {
1926 if (safe_atoi(value, &i) < 0)
1927 log_unit_debug(u->id, "Failed to parse main-exec-status-code value %s", value);
1929 s->main_exec_status.code = i;
1930 } else if (streq(key, "main-exec-status-status")) {
1933 if (safe_atoi(value, &i) < 0)
1934 log_unit_debug(u->id, "Failed to parse main-exec-status-status value %s", value);
1936 s->main_exec_status.status = i;
1937 } else if (streq(key, "main-exec-status-start"))
1938 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
1939 else if (streq(key, "main-exec-status-exit"))
1940 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
1941 else if (streq(key, "watchdog-timestamp"))
1942 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
1943 else if (streq(key, "forbid-restart")) {
1946 b = parse_boolean(value);
1948 log_unit_debug(u->id, "Failed to parse forbid-restart value %s", value);
1950 s->forbid_restart = b;
1952 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
1957 _pure_ static UnitActiveState service_active_state(Unit *u) {
1958 const UnitActiveState *table;
1962 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1964 return table[SERVICE(u)->state];
1967 static const char *service_sub_state_to_string(Unit *u) {
1970 return service_state_to_string(SERVICE(u)->state);
1973 static bool service_check_gc(Unit *u) {
1974 Service *s = SERVICE(u);
1978 /* Never clean up services that still have a process around,
1979 * even if the service is formally dead. */
1980 if (cgroup_good(s) > 0 ||
1981 main_pid_good(s) > 0 ||
1982 control_pid_good(s) > 0)
1988 _pure_ static bool service_check_snapshot(Unit *u) {
1989 Service *s = SERVICE(u);
1993 return s->socket_fd < 0;
1996 static int service_retry_pid_file(Service *s) {
1999 assert(s->pid_file);
2000 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2002 r = service_load_pid_file(s, false);
2006 service_unwatch_pid_file(s);
2008 service_enter_running(s, SERVICE_SUCCESS);
2012 static int service_watch_pid_file(Service *s) {
2015 log_unit_debug(UNIT(s)->id, "Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2017 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2021 /* the pidfile might have appeared just before we set the watch */
2022 log_unit_debug(UNIT(s)->id, "Trying to read %s's PID file %s in case it changed", UNIT(s)->id, s->pid_file_pathspec->path);
2023 service_retry_pid_file(s);
2027 log_unit_error_errno(UNIT(s)->id, r, "Failed to set a watch for %s's PID file %s: %m", UNIT(s)->id, s->pid_file_pathspec->path);
2028 service_unwatch_pid_file(s);
2032 static int service_demand_pid_file(Service *s) {
2035 assert(s->pid_file);
2036 assert(!s->pid_file_pathspec);
2038 ps = new0(PathSpec, 1);
2043 ps->path = strdup(s->pid_file);
2049 path_kill_slashes(ps->path);
2051 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2052 * keep their PID file open all the time. */
2053 ps->type = PATH_MODIFIED;
2054 ps->inotify_fd = -1;
2056 s->pid_file_pathspec = ps;
2058 return service_watch_pid_file(s);
2061 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2062 PathSpec *p = userdata;
2067 s = SERVICE(p->unit);
2071 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2072 assert(s->pid_file_pathspec);
2073 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2075 log_unit_debug(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2077 if (path_spec_fd_event(p, events) < 0)
2080 if (service_retry_pid_file(s) == 0)
2083 if (service_watch_pid_file(s) < 0)
2089 service_unwatch_pid_file(s);
2090 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2094 static void service_notify_cgroup_empty_event(Unit *u) {
2095 Service *s = SERVICE(u);
2099 log_unit_debug(u->id, "%s: cgroup is empty", u->id);
2103 /* Waiting for SIGCHLD is usually more interesting,
2104 * because it includes return codes/signals. Which is
2105 * why we ignore the cgroup events for most cases,
2106 * except when we don't know pid which to expect the
2110 case SERVICE_START_POST:
2111 /* If we were hoping for the daemon to write its PID file,
2112 * we can give up now. */
2113 if (s->pid_file_pathspec) {
2114 log_unit_warning(u->id, "%s never wrote its PID file. Failing.", UNIT(s)->id);
2116 service_unwatch_pid_file(s);
2117 if (s->state == SERVICE_START)
2118 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2120 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2124 case SERVICE_RUNNING:
2125 /* service_enter_running() will figure out what to do */
2126 service_enter_running(s, SERVICE_SUCCESS);
2129 case SERVICE_STOP_SIGABRT:
2130 case SERVICE_STOP_SIGTERM:
2131 case SERVICE_STOP_SIGKILL:
2133 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2134 service_enter_stop_post(s, SERVICE_SUCCESS);
2138 case SERVICE_STOP_POST:
2139 case SERVICE_FINAL_SIGTERM:
2140 case SERVICE_FINAL_SIGKILL:
2141 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2142 service_enter_dead(s, SERVICE_SUCCESS, true);
2151 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2152 Service *s = SERVICE(u);
2158 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2159 is_clean_exit_lsb(code, status, &s->success_status))
2160 f = SERVICE_SUCCESS;
2161 else if (code == CLD_EXITED)
2162 f = SERVICE_FAILURE_EXIT_CODE;
2163 else if (code == CLD_KILLED)
2164 f = SERVICE_FAILURE_SIGNAL;
2165 else if (code == CLD_DUMPED)
2166 f = SERVICE_FAILURE_CORE_DUMP;
2168 assert_not_reached("Unknown code");
2170 if (s->main_pid == pid) {
2171 /* Forking services may occasionally move to a new PID.
2172 * As long as they update the PID file before exiting the old
2173 * PID, they're fine. */
2174 if (service_load_pid_file(s, false) == 0)
2178 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2180 if (s->main_command) {
2181 /* If this is not a forking service than the
2182 * main process got started and hence we copy
2183 * the exit status so that it is recorded both
2184 * as main and as control process exit
2187 s->main_command->exec_status = s->main_exec_status;
2189 if (s->main_command->ignore)
2190 f = SERVICE_SUCCESS;
2191 } else if (s->exec_command[SERVICE_EXEC_START]) {
2193 /* If this is a forked process, then we should
2194 * ignore the return value if this was
2195 * configured for the starter process */
2197 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2198 f = SERVICE_SUCCESS;
2201 log_unit_struct(u->id,
2202 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2203 LOG_MESSAGE("%s: main process exited, code=%s, status=%i/%s",
2204 u->id, sigchld_code_to_string(code), status,
2205 strna(code == CLD_EXITED
2206 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2207 : signal_to_string(status))),
2208 "EXIT_CODE=%s", sigchld_code_to_string(code),
2209 "EXIT_STATUS=%i", status,
2212 if (f != SERVICE_SUCCESS)
2215 if (s->main_command &&
2216 s->main_command->command_next &&
2217 f == SERVICE_SUCCESS) {
2219 /* There is another command to *
2220 * execute, so let's do that. */
2222 log_unit_debug(u->id, "%s running next main command for state %s", u->id, service_state_to_string(s->state));
2223 service_run_next_main(s);
2227 /* The service exited, so the service is officially
2229 s->main_command = NULL;
2233 case SERVICE_START_POST:
2234 case SERVICE_RELOAD:
2236 /* Need to wait until the operation is
2241 if (s->type == SERVICE_ONESHOT) {
2242 /* This was our main goal, so let's go on */
2243 if (f == SERVICE_SUCCESS)
2244 service_enter_start_post(s);
2246 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2252 case SERVICE_RUNNING:
2253 service_enter_running(s, f);
2256 case SERVICE_STOP_SIGABRT:
2257 case SERVICE_STOP_SIGTERM:
2258 case SERVICE_STOP_SIGKILL:
2260 if (!control_pid_good(s))
2261 service_enter_stop_post(s, f);
2263 /* If there is still a control process, wait for that first */
2266 case SERVICE_STOP_POST:
2267 case SERVICE_FINAL_SIGTERM:
2268 case SERVICE_FINAL_SIGKILL:
2270 if (!control_pid_good(s))
2271 service_enter_dead(s, f, true);
2275 assert_not_reached("Uh, main process died at wrong time.");
2279 } else if (s->control_pid == pid) {
2282 if (s->control_command) {
2283 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2285 if (s->control_command->ignore)
2286 f = SERVICE_SUCCESS;
2289 log_unit_full(u->id,
2290 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2291 "%s: control process exited, code=%s status=%i",
2292 u->id, sigchld_code_to_string(code), status);
2294 if (f != SERVICE_SUCCESS)
2297 /* Immediately get rid of the cgroup, so that the
2298 * kernel doesn't delay the cgroup empty messages for
2299 * the service cgroup any longer than necessary */
2300 service_kill_control_processes(s);
2302 if (s->control_command &&
2303 s->control_command->command_next &&
2304 f == SERVICE_SUCCESS) {
2306 /* There is another command to *
2307 * execute, so let's do that. */
2309 log_unit_debug(u->id, "%s running next control command for state %s", u->id, service_state_to_string(s->state));
2310 service_run_next_control(s);
2313 /* No further commands for this step, so let's
2314 * figure out what to do next */
2316 s->control_command = NULL;
2317 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2319 log_unit_debug(u->id, "%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2323 case SERVICE_START_PRE:
2324 if (f == SERVICE_SUCCESS)
2325 service_enter_start(s);
2327 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2331 if (s->type != SERVICE_FORKING)
2332 /* Maybe spurious event due to a reload that changed the type? */
2335 if (f != SERVICE_SUCCESS) {
2336 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2341 bool has_start_post;
2344 /* Let's try to load the pid file here if we can.
2345 * The PID file might actually be created by a START_POST
2346 * script. In that case don't worry if the loading fails. */
2348 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2349 r = service_load_pid_file(s, !has_start_post);
2350 if (!has_start_post && r < 0) {
2351 r = service_demand_pid_file(s);
2352 if (r < 0 || !cgroup_good(s))
2353 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2357 service_search_main_pid(s);
2359 service_enter_start_post(s);
2362 case SERVICE_START_POST:
2363 if (f != SERVICE_SUCCESS) {
2364 service_enter_stop(s, f);
2371 r = service_load_pid_file(s, true);
2373 r = service_demand_pid_file(s);
2374 if (r < 0 || !cgroup_good(s))
2375 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2379 service_search_main_pid(s);
2381 service_enter_running(s, SERVICE_SUCCESS);
2384 case SERVICE_RELOAD:
2385 if (f == SERVICE_SUCCESS) {
2386 service_load_pid_file(s, true);
2387 service_search_main_pid(s);
2390 s->reload_result = f;
2391 service_enter_running(s, SERVICE_SUCCESS);
2395 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2398 case SERVICE_STOP_SIGABRT:
2399 case SERVICE_STOP_SIGTERM:
2400 case SERVICE_STOP_SIGKILL:
2401 if (main_pid_good(s) <= 0)
2402 service_enter_stop_post(s, f);
2404 /* If there is still a service
2405 * process around, wait until
2406 * that one quit, too */
2409 case SERVICE_STOP_POST:
2410 case SERVICE_FINAL_SIGTERM:
2411 case SERVICE_FINAL_SIGKILL:
2412 if (main_pid_good(s) <= 0)
2413 service_enter_dead(s, f, true);
2417 assert_not_reached("Uh, control process died at wrong time.");
2422 /* Notify clients about changed exit status */
2423 unit_add_to_dbus_queue(u);
2425 /* We got one SIGCHLD for the service, let's watch all
2426 * processes that are now running of the service, and watch
2427 * that. Among the PIDs we then watch will be children
2428 * reassigned to us, which hopefully allows us to identify
2429 * when all children are gone */
2430 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2431 unit_watch_all_pids(u);
2433 /* If the PID set is empty now, then let's finish this off */
2434 if (set_isempty(u->pids))
2435 service_notify_cgroup_empty_event(u);
2438 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2439 Service *s = SERVICE(userdata);
2442 assert(source == s->timer_event_source);
2446 case SERVICE_START_PRE:
2448 log_unit_warning(UNIT(s)->id, "%s %s operation timed out. Terminating.", UNIT(s)->id, s->state == SERVICE_START ? "start" : "start-pre");
2449 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2452 case SERVICE_START_POST:
2453 log_unit_warning(UNIT(s)->id, "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2454 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2457 case SERVICE_RELOAD:
2458 log_unit_warning(UNIT(s)->id, "%s reload operation timed out. Stopping.", UNIT(s)->id);
2459 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2460 service_enter_running(s, SERVICE_SUCCESS);
2464 log_unit_warning(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
2465 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2468 case SERVICE_STOP_SIGABRT:
2469 log_unit_warning(UNIT(s)->id,
2470 "%s stop-sigabrt timed out. Terminating.", UNIT(s)->id);
2471 service_enter_signal(s, SERVICE_STOP_SIGTERM, s->result);
2474 case SERVICE_STOP_SIGTERM:
2475 if (s->kill_context.send_sigkill) {
2476 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2477 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2479 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2480 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2485 case SERVICE_STOP_SIGKILL:
2486 /* Uh, we sent a SIGKILL and it is still not gone?
2487 * Must be something we cannot kill, so let's just be
2488 * weirded out and continue */
2490 log_unit_warning(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2491 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2494 case SERVICE_STOP_POST:
2495 log_unit_warning(UNIT(s)->id, "%s stop-post timed out. Terminating.", UNIT(s)->id);
2496 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2499 case SERVICE_FINAL_SIGTERM:
2500 if (s->kill_context.send_sigkill) {
2501 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2502 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2504 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.", UNIT(s)->id);
2505 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2510 case SERVICE_FINAL_SIGKILL:
2511 log_unit_warning(UNIT(s)->id, "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2512 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2515 case SERVICE_AUTO_RESTART:
2516 log_unit_info(UNIT(s)->id,
2517 s->restart_usec > 0 ?
2518 "%s holdoff time over, scheduling restart." :
2519 "%s has no holdoff time, scheduling restart.",
2521 service_enter_restart(s);
2525 assert_not_reached("Timeout at wrong time.");
2531 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2532 Service *s = SERVICE(userdata);
2533 char t[FORMAT_TIMESPAN_MAX];
2536 assert(source == s->watchdog_event_source);
2538 log_unit_error(UNIT(s)->id, "%s watchdog timeout (limit %s)!", UNIT(s)->id,
2539 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2541 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
2546 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
2547 Service *s = SERVICE(u);
2548 _cleanup_free_ char *cc = NULL;
2549 bool notify_dbus = false;
2554 cc = strv_join(tags, ", ");
2555 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT" (%s)",
2556 u->id, pid, isempty(cc) ? "n/a" : cc);
2558 if (s->notify_access == NOTIFY_NONE) {
2559 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception is disabled.", u->id, pid);
2563 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2564 if (s->main_pid != 0)
2565 log_unit_warning(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);
2567 log_unit_debug(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);
2571 /* Interpret MAINPID= */
2572 e = strv_find_startswith(tags, "MAINPID=");
2573 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2574 if (parse_pid(e, &pid) < 0)
2575 log_unit_warning(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2577 log_unit_debug(u->id, "%s: got MAINPID=%s", u->id, e);
2579 service_set_main_pid(s, pid);
2580 unit_watch_pid(UNIT(s), pid);
2585 /* Interpret RELOADING= */
2586 if (strv_find(tags, "RELOADING=1")) {
2588 log_unit_debug(u->id, "%s: got RELOADING=1", u->id);
2589 s->notify_state = NOTIFY_RELOADING;
2591 if (s->state == SERVICE_RUNNING)
2592 service_enter_reload_by_notify(s);
2597 /* Interpret READY= */
2598 if (strv_find(tags, "READY=1")) {
2600 log_unit_debug(u->id, "%s: got READY=1", u->id);
2601 s->notify_state = NOTIFY_READY;
2603 /* Type=notify services inform us about completed
2604 * initialization with READY=1 */
2605 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
2606 service_enter_start_post(s);
2608 /* Sending READY=1 while we are reloading informs us
2609 * that the reloading is complete */
2610 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
2611 service_enter_running(s, SERVICE_SUCCESS);
2616 /* Interpret STOPPING= */
2617 if (strv_find(tags, "STOPPING=1")) {
2619 log_unit_debug(u->id, "%s: got STOPPING=1", u->id);
2620 s->notify_state = NOTIFY_STOPPING;
2622 if (s->state == SERVICE_RUNNING)
2623 service_enter_stop_by_notify(s);
2628 /* Interpret STATUS= */
2629 e = strv_find_startswith(tags, "STATUS=");
2631 _cleanup_free_ char *t = NULL;
2634 if (!utf8_is_valid(e))
2635 log_unit_warning(u->id, "Status message in notification is not UTF-8 clean.");
2637 log_unit_debug(u->id, "%s: got STATUS=%s", u->id, e);
2645 if (!streq_ptr(s->status_text, t)) {
2647 free(s->status_text);
2655 /* Interpret ERRNO= */
2656 e = strv_find_startswith(tags, "ERRNO=");
2660 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
2661 log_unit_warning(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2663 log_unit_debug(u->id, "%s: got ERRNO=%s", u->id, e);
2665 if (s->status_errno != status_errno) {
2666 s->status_errno = status_errno;
2672 /* Interpret WATCHDOG= */
2673 if (strv_find(tags, "WATCHDOG=1")) {
2674 log_unit_debug(u->id, "%s: got WATCHDOG=1", u->id);
2675 service_reset_watchdog(s);
2678 /* Notify clients about changed status or main pid */
2680 unit_add_to_dbus_queue(u);
2683 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2684 Service *s = SERVICE(u);
2687 if (!s->timer_event_source)
2690 r = sd_event_source_get_time(s->timer_event_source, timeout);
2697 static void service_bus_name_owner_change(
2700 const char *old_owner,
2701 const char *new_owner) {
2703 Service *s = SERVICE(u);
2709 assert(streq(s->bus_name, name));
2710 assert(old_owner || new_owner);
2712 if (old_owner && new_owner)
2713 log_unit_debug(u->id, "%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
2715 log_unit_debug(u->id, "%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
2717 log_unit_debug(u->id, "%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
2719 s->bus_name_good = !!new_owner;
2721 if (s->type == SERVICE_DBUS) {
2723 /* service_enter_running() will figure out what to
2725 if (s->state == SERVICE_RUNNING)
2726 service_enter_running(s, SERVICE_SUCCESS);
2727 else if (s->state == SERVICE_START && new_owner)
2728 service_enter_start_post(s);
2730 } else if (new_owner &&
2732 (s->state == SERVICE_START ||
2733 s->state == SERVICE_START_POST ||
2734 s->state == SERVICE_RUNNING ||
2735 s->state == SERVICE_RELOAD)) {
2737 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2740 /* Try to acquire PID from bus service */
2742 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2744 r = sd_bus_creds_get_pid(creds, &pid);
2746 log_unit_debug(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2748 service_set_main_pid(s, pid);
2749 unit_watch_pid(UNIT(s), pid);
2754 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
2755 _cleanup_free_ char *peer = NULL;
2761 /* This is called by the socket code when instantiating a new
2762 * service for a stream socket and the socket needs to be
2765 if (UNIT(s)->load_state != UNIT_LOADED)
2768 if (s->socket_fd >= 0)
2771 if (s->state != SERVICE_DEAD)
2774 if (getpeername_pretty(fd, &peer) >= 0) {
2776 if (UNIT(s)->description) {
2777 _cleanup_free_ char *a;
2779 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
2783 r = unit_set_description(UNIT(s), a);
2785 r = unit_set_description(UNIT(s), peer);
2792 s->socket_fd_selinux_context_net = selinux_context_net;
2794 unit_ref_set(&s->accept_socket, UNIT(sock));
2796 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
2799 static void service_reset_failed(Unit *u) {
2800 Service *s = SERVICE(u);
2804 if (s->state == SERVICE_FAILED)
2805 service_set_state(s, SERVICE_DEAD);
2807 s->result = SERVICE_SUCCESS;
2808 s->reload_result = SERVICE_SUCCESS;
2810 RATELIMIT_RESET(s->start_limit);
2813 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2814 Service *s = SERVICE(u);
2816 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
2819 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
2820 [SERVICE_DEAD] = "dead",
2821 [SERVICE_START_PRE] = "start-pre",
2822 [SERVICE_START] = "start",
2823 [SERVICE_START_POST] = "start-post",
2824 [SERVICE_RUNNING] = "running",
2825 [SERVICE_EXITED] = "exited",
2826 [SERVICE_RELOAD] = "reload",
2827 [SERVICE_STOP] = "stop",
2828 [SERVICE_STOP_SIGABRT] = "stop-sigabrt",
2829 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
2830 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
2831 [SERVICE_STOP_POST] = "stop-post",
2832 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
2833 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
2834 [SERVICE_FAILED] = "failed",
2835 [SERVICE_AUTO_RESTART] = "auto-restart",
2838 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
2840 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
2841 [SERVICE_RESTART_NO] = "no",
2842 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
2843 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
2844 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
2845 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
2846 [SERVICE_RESTART_ON_ABORT] = "on-abort",
2847 [SERVICE_RESTART_ALWAYS] = "always",
2850 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
2852 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
2853 [SERVICE_SIMPLE] = "simple",
2854 [SERVICE_FORKING] = "forking",
2855 [SERVICE_ONESHOT] = "oneshot",
2856 [SERVICE_DBUS] = "dbus",
2857 [SERVICE_NOTIFY] = "notify",
2858 [SERVICE_IDLE] = "idle"
2861 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
2863 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
2864 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
2865 [SERVICE_EXEC_START] = "ExecStart",
2866 [SERVICE_EXEC_START_POST] = "ExecStartPost",
2867 [SERVICE_EXEC_RELOAD] = "ExecReload",
2868 [SERVICE_EXEC_STOP] = "ExecStop",
2869 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
2872 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
2874 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
2875 [NOTIFY_NONE] = "none",
2876 [NOTIFY_MAIN] = "main",
2877 [NOTIFY_ALL] = "all"
2880 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
2882 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
2883 [NOTIFY_UNKNOWN] = "unknown",
2884 [NOTIFY_READY] = "ready",
2885 [NOTIFY_RELOADING] = "reloading",
2886 [NOTIFY_STOPPING] = "stopping",
2889 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
2891 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
2892 [SERVICE_SUCCESS] = "success",
2893 [SERVICE_FAILURE_RESOURCES] = "resources",
2894 [SERVICE_FAILURE_TIMEOUT] = "timeout",
2895 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
2896 [SERVICE_FAILURE_SIGNAL] = "signal",
2897 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
2898 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
2899 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
2902 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
2904 const UnitVTable service_vtable = {
2905 .object_size = sizeof(Service),
2906 .exec_context_offset = offsetof(Service, exec_context),
2907 .cgroup_context_offset = offsetof(Service, cgroup_context),
2908 .kill_context_offset = offsetof(Service, kill_context),
2909 .exec_runtime_offset = offsetof(Service, exec_runtime),
2915 .private_section = "Service",
2917 .init = service_init,
2918 .done = service_done,
2919 .load = service_load,
2921 .coldplug = service_coldplug,
2923 .dump = service_dump,
2925 .start = service_start,
2926 .stop = service_stop,
2927 .reload = service_reload,
2929 .can_reload = service_can_reload,
2931 .kill = service_kill,
2933 .serialize = service_serialize,
2934 .deserialize_item = service_deserialize_item,
2936 .active_state = service_active_state,
2937 .sub_state_to_string = service_sub_state_to_string,
2939 .check_gc = service_check_gc,
2940 .check_snapshot = service_check_snapshot,
2942 .sigchld_event = service_sigchld_event,
2944 .reset_failed = service_reset_failed,
2946 .notify_cgroup_empty = service_notify_cgroup_empty_event,
2947 .notify_message = service_notify_message,
2949 .bus_name_owner_change = service_bus_name_owner_change,
2951 .bus_interface = "org.freedesktop.systemd1.Service",
2952 .bus_vtable = bus_service_vtable,
2953 .bus_set_property = bus_service_set_property,
2954 .bus_commit_properties = bus_service_commit_properties,
2956 .get_timeout = service_get_timeout,
2957 .can_transient = true,
2959 .status_message_formats = {
2960 .starting_stopping = {
2961 [0] = "Starting %s...",
2962 [1] = "Stopping %s...",
2964 .finished_start_job = {
2965 [JOB_DONE] = "Started %s.",
2966 [JOB_FAILED] = "Failed to start %s.",
2967 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2968 [JOB_TIMEOUT] = "Timed out starting %s.",
2970 .finished_stop_job = {
2971 [JOB_DONE] = "Stopped %s.",
2972 [JOB_FAILED] = "Stopped (with error) %s.",
2973 [JOB_TIMEOUT] = "Timed out stopping %s.",