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>
34 #include "load-fragment.h"
35 #include "load-dropin.h"
38 #include "unit-name.h"
39 #include "unit-printf.h"
40 #include "dbus-service.h"
42 #include "exit-status.h"
44 #include "path-util.h"
49 #include "bus-error.h"
52 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
53 [SERVICE_DEAD] = UNIT_INACTIVE,
54 [SERVICE_START_PRE] = UNIT_ACTIVATING,
55 [SERVICE_START] = UNIT_ACTIVATING,
56 [SERVICE_START_POST] = UNIT_ACTIVATING,
57 [SERVICE_RUNNING] = UNIT_ACTIVE,
58 [SERVICE_EXITED] = UNIT_ACTIVE,
59 [SERVICE_RELOAD] = UNIT_RELOADING,
60 [SERVICE_STOP] = UNIT_DEACTIVATING,
61 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
62 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
63 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
64 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
65 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
66 [SERVICE_FAILED] = UNIT_FAILED,
67 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
70 /* For Type=idle we never want to delay any other jobs, hence we
71 * consider idle jobs active as soon as we start working on them */
72 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
73 [SERVICE_DEAD] = UNIT_INACTIVE,
74 [SERVICE_START_PRE] = UNIT_ACTIVE,
75 [SERVICE_START] = UNIT_ACTIVE,
76 [SERVICE_START_POST] = UNIT_ACTIVE,
77 [SERVICE_RUNNING] = UNIT_ACTIVE,
78 [SERVICE_EXITED] = UNIT_ACTIVE,
79 [SERVICE_RELOAD] = UNIT_RELOADING,
80 [SERVICE_STOP] = 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);
96 static void service_init(Unit *u) {
97 Service *s = SERVICE(u);
100 assert(u->load_state == UNIT_STUB);
102 s->timeout_start_usec = u->manager->default_timeout_start_usec;
103 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
104 s->restart_usec = u->manager->default_restart_usec;
105 s->type = _SERVICE_TYPE_INVALID;
107 s->guess_main_pid = true;
109 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
111 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
114 static void service_unwatch_control_pid(Service *s) {
117 if (s->control_pid <= 0)
120 unit_unwatch_pid(UNIT(s), s->control_pid);
124 static void service_unwatch_main_pid(Service *s) {
127 if (s->main_pid <= 0)
130 unit_unwatch_pid(UNIT(s), s->main_pid);
134 static void service_unwatch_pid_file(Service *s) {
135 if (!s->pid_file_pathspec)
138 log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s",
139 UNIT(s)->id, s->pid_file_pathspec->path);
140 path_spec_unwatch(s->pid_file_pathspec);
141 path_spec_done(s->pid_file_pathspec);
142 free(s->pid_file_pathspec);
143 s->pid_file_pathspec = NULL;
146 static int service_set_main_pid(Service *s, pid_t pid) {
157 if (s->main_pid == pid && s->main_pid_known)
160 if (s->main_pid != pid) {
161 service_unwatch_main_pid(s);
162 exec_status_start(&s->main_exec_status, pid);
166 s->main_pid_known = true;
168 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
169 log_warning_unit(UNIT(s)->id,
170 "%s: Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.",
173 s->main_pid_alien = true;
175 s->main_pid_alien = false;
180 static void service_close_socket_fd(Service *s) {
183 s->socket_fd = asynchronous_close(s->socket_fd);
186 static void service_connection_unref(Service *s) {
189 if (!UNIT_ISSET(s->accept_socket))
192 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
193 unit_ref_unset(&s->accept_socket);
196 static void service_stop_watchdog(Service *s) {
199 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
200 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
203 static void service_start_watchdog(Service *s) {
208 if (s->watchdog_usec <= 0)
211 if (s->watchdog_event_source) {
212 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
214 log_warning_unit(UNIT(s)->id, "%s failed to reset watchdog timer: %s", UNIT(s)->id, strerror(-r));
218 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
220 r = sd_event_add_time(
221 UNIT(s)->manager->event,
222 &s->watchdog_event_source,
224 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
225 service_dispatch_watchdog, s);
227 log_warning_unit(UNIT(s)->id, "%s failed to add watchdog timer: %s", UNIT(s)->id, strerror(-r));
231 /* Let's process everything else which might be a sign
232 * of living before we consider a service died. */
233 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
237 log_warning_unit(UNIT(s)->id, "%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
240 static void service_reset_watchdog(Service *s) {
243 dual_timestamp_get(&s->watchdog_timestamp);
244 service_start_watchdog(s);
247 static void service_done(Unit *u) {
248 Service *s = SERVICE(u);
255 free(s->status_text);
256 s->status_text = NULL;
259 s->reboot_arg = NULL;
261 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
262 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
263 s->control_command = NULL;
264 s->main_command = NULL;
266 exit_status_set_free(&s->restart_prevent_status);
267 exit_status_set_free(&s->restart_force_status);
268 exit_status_set_free(&s->success_status);
270 /* This will leak a process, but at least no memory or any of
272 service_unwatch_main_pid(s);
273 service_unwatch_control_pid(s);
274 service_unwatch_pid_file(s);
277 unit_unwatch_bus_name(u, s->bus_name);
282 service_close_socket_fd(s);
283 service_connection_unref(s);
285 unit_ref_unset(&s->accept_socket);
287 service_stop_watchdog(s);
289 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
292 static int service_arm_timer(Service *s, usec_t usec) {
297 if (s->timer_event_source) {
298 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
302 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
305 return sd_event_add_time(
306 UNIT(s)->manager->event,
307 &s->timer_event_source,
309 now(CLOCK_MONOTONIC) + usec, 0,
310 service_dispatch_timer, s);
313 static int service_verify(Service *s) {
316 if (UNIT(s)->load_state != UNIT_LOADED)
319 if (!s->exec_command[SERVICE_EXEC_START]) {
320 log_error_unit(UNIT(s)->id, "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
324 if (s->type != SERVICE_ONESHOT &&
325 s->exec_command[SERVICE_EXEC_START]->command_next) {
326 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);
330 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
331 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);
335 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
336 log_error_unit(UNIT(s)->id, "%s has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
340 if (s->type == SERVICE_DBUS && !s->bus_name) {
341 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);
345 if (s->bus_name && s->type != SERVICE_DBUS)
346 log_warning_unit(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
348 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
349 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
356 static int service_add_default_dependencies(Service *s) {
361 /* Add a number of automatic dependencies useful for the
362 * majority of services. */
364 /* First, pull in base system */
365 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
366 SPECIAL_BASIC_TARGET, NULL, true);
370 /* Second, activate normal shutdown */
371 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
372 SPECIAL_SHUTDOWN_TARGET, NULL, true);
376 static void service_fix_output(Service *s) {
379 /* If nothing has been explicitly configured, patch default
380 * output in. If input is socket/tty we avoid this however,
381 * since in that case we want output to default to the same
382 * place as we read input from. */
384 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
385 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
386 s->exec_context.std_input == EXEC_INPUT_NULL)
387 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
389 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
390 s->exec_context.std_input == EXEC_INPUT_NULL)
391 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
394 static int service_load(Unit *u) {
396 Service *s = SERVICE(u);
400 /* Load a .service file */
401 r = unit_load_fragment(u);
405 /* Still nothing found? Then let's give up */
406 if (u->load_state == UNIT_STUB)
409 /* This is a new unit? Then let's add in some extras */
410 if (u->load_state == UNIT_LOADED) {
412 /* We were able to load something, then let's add in
413 * the dropin directories. */
414 r = unit_load_dropin(u);
418 if (s->type == _SERVICE_TYPE_INVALID)
419 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
421 /* Oneshot services have disabled start timeout by default */
422 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
423 s->timeout_start_usec = 0;
425 service_fix_output(s);
427 r = unit_patch_contexts(u);
431 r = unit_add_exec_dependencies(u, &s->exec_context);
435 r = unit_add_default_slice(u, &s->cgroup_context);
439 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
440 s->notify_access = NOTIFY_MAIN;
442 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
443 s->notify_access = NOTIFY_MAIN;
446 r = unit_watch_bus_name(u, s->bus_name);
451 if (u->default_dependencies) {
452 r = service_add_default_dependencies(s);
459 return service_verify(s);
462 static void service_dump(Unit *u, FILE *f, const char *prefix) {
463 ServiceExecCommand c;
464 Service *s = SERVICE(u);
469 prefix = strempty(prefix);
470 prefix2 = strappenda(prefix, "\t");
473 "%sService State: %s\n"
475 "%sReload Result: %s\n"
476 "%sPermissionsStartOnly: %s\n"
477 "%sRootDirectoryStartOnly: %s\n"
478 "%sRemainAfterExit: %s\n"
479 "%sGuessMainPID: %s\n"
482 "%sNotifyAccess: %s\n",
483 prefix, service_state_to_string(s->state),
484 prefix, service_result_to_string(s->result),
485 prefix, service_result_to_string(s->reload_result),
486 prefix, yes_no(s->permissions_start_only),
487 prefix, yes_no(s->root_directory_start_only),
488 prefix, yes_no(s->remain_after_exit),
489 prefix, yes_no(s->guess_main_pid),
490 prefix, service_type_to_string(s->type),
491 prefix, service_restart_to_string(s->restart),
492 prefix, notify_access_to_string(s->notify_access));
494 if (s->control_pid > 0)
496 "%sControl PID: "PID_FMT"\n",
497 prefix, s->control_pid);
501 "%sMain PID: "PID_FMT"\n"
502 "%sMain PID Known: %s\n"
503 "%sMain PID Alien: %s\n",
505 prefix, yes_no(s->main_pid_known),
506 prefix, yes_no(s->main_pid_alien));
511 prefix, s->pid_file);
516 "%sBus Name Good: %s\n",
518 prefix, yes_no(s->bus_name_good));
520 kill_context_dump(&s->kill_context, f, prefix);
521 exec_context_dump(&s->exec_context, f, prefix);
523 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
525 if (!s->exec_command[c])
528 fprintf(f, "%s-> %s:\n",
529 prefix, service_exec_command_to_string(c));
531 exec_command_dump_list(s->exec_command[c], f, prefix2);
534 #ifdef HAVE_SYSV_COMPAT
535 if (s->sysv_start_priority >= 0)
537 "%sSysVStartPriority: %i\n",
538 prefix, s->sysv_start_priority);
542 fprintf(f, "%sStatus Text: %s\n",
543 prefix, s->status_text);
546 static int service_load_pid_file(Service *s, bool may_warn) {
547 _cleanup_free_ char *k = NULL;
556 r = read_one_line_file(s->pid_file, &k);
559 log_info_unit(UNIT(s)->id,
560 "PID file %s not readable (yet?) after %s.",
561 s->pid_file, service_state_to_string(s->state));
565 r = parse_pid(k, &pid);
568 log_info_unit(UNIT(s)->id,
569 "Failed to read PID from file %s: %s",
570 s->pid_file, strerror(-r));
574 if (!pid_is_alive(pid)) {
576 log_info_unit(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
581 if (s->main_pid_known) {
582 if (pid == s->main_pid)
585 log_debug_unit(UNIT(s)->id,
586 "Main PID changing: "PID_FMT" -> "PID_FMT,
588 service_unwatch_main_pid(s);
589 s->main_pid_known = false;
591 log_debug_unit(UNIT(s)->id,
592 "Main PID loaded: "PID_FMT, pid);
594 r = service_set_main_pid(s, pid);
598 r = unit_watch_pid(UNIT(s), pid);
600 /* FIXME: we need to do something here */
601 log_warning_unit(UNIT(s)->id,
602 "Failed to watch PID "PID_FMT" from service %s",
610 static int service_search_main_pid(Service *s) {
616 /* If we know it anyway, don't ever fallback to unreliable
618 if (s->main_pid_known)
621 if (!s->guess_main_pid)
624 assert(s->main_pid <= 0);
626 pid = unit_search_main_pid(UNIT(s));
630 log_debug_unit(UNIT(s)->id,
631 "Main PID guessed: "PID_FMT, pid);
632 r = service_set_main_pid(s, pid);
636 r = unit_watch_pid(UNIT(s), pid);
638 /* FIXME: we need to do something here */
639 log_warning_unit(UNIT(s)->id,
640 "Failed to watch PID "PID_FMT" from service %s",
645 static void service_set_state(Service *s, ServiceState state) {
646 ServiceState old_state;
647 const UnitActiveState *table;
651 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
653 old_state = s->state;
656 service_unwatch_pid_file(s);
659 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
661 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
663 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
664 SERVICE_AUTO_RESTART))
665 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
668 SERVICE_START, SERVICE_START_POST,
669 SERVICE_RUNNING, SERVICE_RELOAD,
670 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
672 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
673 service_unwatch_main_pid(s);
674 s->main_command = NULL;
678 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
680 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
682 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
683 service_unwatch_control_pid(s);
684 s->control_command = NULL;
685 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
688 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
689 unit_unwatch_all_pids(UNIT(s));
692 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
693 SERVICE_RUNNING, SERVICE_RELOAD,
694 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
695 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
696 !(state == SERVICE_DEAD && UNIT(s)->job)) {
697 service_close_socket_fd(s);
698 service_connection_unref(s);
701 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
702 service_stop_watchdog(s);
704 /* For the inactive states unit_notify() will trim the cgroup,
705 * but for exit we have to do that ourselves... */
706 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
707 unit_destroy_cgroup(UNIT(s));
709 /* For remain_after_exit services, let's see if we can "release" the
710 * hold on the console, since unit_notify() only does that in case of
712 if (state == SERVICE_EXITED && s->remain_after_exit &&
713 UNIT(s)->manager->n_on_console > 0) {
714 ExecContext *ec = unit_get_exec_context(UNIT(s));
715 if (ec && exec_context_may_touch_console(ec)) {
716 Manager *m = UNIT(s)->manager;
719 if (m->n_on_console == 0)
720 /* unset no_console_output flag, since the console is free */
721 m->no_console_output = false;
725 if (old_state != state)
726 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
728 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
729 s->reload_result = SERVICE_SUCCESS;
732 static int service_coldplug(Unit *u) {
733 Service *s = SERVICE(u);
737 assert(s->state == SERVICE_DEAD);
739 if (s->deserialized_state != s->state) {
741 if (IN_SET(s->deserialized_state,
742 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
744 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
746 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
750 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
752 /* For the start/stop timeouts 0 means off */
754 r = service_arm_timer(s, k);
760 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
762 /* The restart timeouts 0 means immediately */
763 r = service_arm_timer(s, s->restart_usec);
768 if (pid_is_unwaited(s->main_pid) &&
769 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
770 IN_SET(s->deserialized_state,
771 SERVICE_START, SERVICE_START_POST,
772 SERVICE_RUNNING, SERVICE_RELOAD,
773 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
775 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
776 r = unit_watch_pid(UNIT(s), s->main_pid);
781 if (pid_is_unwaited(s->control_pid) &&
782 IN_SET(s->deserialized_state,
783 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
785 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
787 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
788 r = unit_watch_pid(UNIT(s), s->control_pid);
793 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
794 unit_watch_all_pids(UNIT(s));
796 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
797 service_start_watchdog(s);
799 service_set_state(s, s->deserialized_state);
805 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
816 if (s->socket_fd >= 0)
819 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
824 if (u->type != UNIT_SOCKET)
829 r = socket_collect_fds(sock, &cfds, &cn_fds);
842 t = new(int, rn_fds+cn_fds);
849 memcpy(t, rfds, rn_fds * sizeof(int));
850 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
855 rn_fds = rn_fds+cn_fds;
870 static int service_spawn(
875 bool apply_permissions,
877 bool apply_tty_stdin,
878 bool set_notify_socket,
885 _cleanup_free_ int *fdsbuf = NULL;
886 unsigned n_fds = 0, n_env = 0;
887 _cleanup_strv_free_ char
888 **argv = NULL, **final_env = NULL, **our_env = NULL;
895 unit_realize_cgroup(UNIT(s));
897 r = unit_setup_exec_runtime(UNIT(s));
902 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
903 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
904 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
906 if (s->socket_fd >= 0) {
910 r = service_collect_fds(s, &fdsbuf, &n_fds);
918 if (timeout && s->timeout_start_usec > 0) {
919 r = service_arm_timer(s, s->timeout_start_usec);
923 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
925 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
929 our_env = new0(char*, 4);
935 if (set_notify_socket)
936 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
942 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
947 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
948 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
953 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
959 if (is_control && UNIT(s)->cgroup_path) {
960 path = strappenda(UNIT(s)->cgroup_path, "/control");
961 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
963 path = UNIT(s)->cgroup_path;
973 UNIT(s)->manager->confirm_spawn,
974 UNIT(s)->manager->cgroup_supported,
976 manager_get_runtime_prefix(UNIT(s)->manager),
979 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
985 r = unit_watch_pid(UNIT(s), pid);
987 /* FIXME: we need to do something here */
996 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1001 static int main_pid_good(Service *s) {
1004 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1007 /* If we know the pid file, then lets just check if it is
1009 if (s->main_pid_known) {
1011 /* If it's an alien child let's check if it is still
1013 if (s->main_pid_alien && s->main_pid > 0)
1014 return pid_is_alive(s->main_pid);
1016 /* .. otherwise assume we'll get a SIGCHLD for it,
1017 * which we really should wait for to collect exit
1018 * status and code */
1019 return s->main_pid > 0;
1022 /* We don't know the pid */
1026 _pure_ static int control_pid_good(Service *s) {
1029 return s->control_pid > 0;
1032 static int cgroup_good(Service *s) {
1037 if (!UNIT(s)->cgroup_path)
1040 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1047 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none);
1049 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1053 if (f != SERVICE_SUCCESS)
1056 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1058 if (s->result != SERVICE_SUCCESS)
1059 service_execute_action(s, s->failure_action, "failed", false);
1061 if (allow_restart &&
1062 !s->forbid_restart &&
1063 (s->restart == SERVICE_RESTART_ALWAYS ||
1064 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1065 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1066 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1067 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1068 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1069 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1070 (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)))) &&
1071 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
1072 (!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)))) {
1074 r = service_arm_timer(s, s->restart_usec);
1078 service_set_state(s, SERVICE_AUTO_RESTART);
1081 s->forbid_restart = false;
1083 /* We want fresh tmpdirs in case service is started again immediately */
1084 exec_runtime_destroy(s->exec_runtime);
1085 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1087 /* Also, remove the runtime directory in */
1088 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1090 /* Try to delete the pid file. At this point it will be
1091 * out-of-date, and some software might be confused by it, so
1092 * let's remove it. */
1094 unlink_noerrno(s->pid_file);
1099 log_warning_unit(UNIT(s)->id,
1100 "%s failed to run install restart timer: %s",
1101 UNIT(s)->id, strerror(-r));
1102 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1105 static void service_enter_stop_post(Service *s, ServiceResult f) {
1109 if (f != SERVICE_SUCCESS)
1112 service_unwatch_control_pid(s);
1113 unit_watch_all_pids(UNIT(s));
1115 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1116 if (s->control_command) {
1117 s->control_command_id = SERVICE_EXEC_STOP_POST;
1119 r = service_spawn(s,
1123 !s->permissions_start_only,
1124 !s->root_directory_start_only,
1132 service_set_state(s, SERVICE_STOP_POST);
1134 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1139 log_warning_unit(UNIT(s)->id,
1140 "%s failed to run 'stop-post' task: %s",
1141 UNIT(s)->id, strerror(-r));
1142 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1145 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1150 if (f != SERVICE_SUCCESS)
1153 unit_watch_all_pids(UNIT(s));
1155 r = unit_kill_context(
1158 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1167 if (s->timeout_stop_usec > 0) {
1168 r = service_arm_timer(s, s->timeout_stop_usec);
1173 service_set_state(s, state);
1174 } else if (state == SERVICE_STOP_SIGTERM)
1175 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1176 else if (state == SERVICE_STOP_SIGKILL)
1177 service_enter_stop_post(s, SERVICE_SUCCESS);
1178 else if (state == SERVICE_FINAL_SIGTERM)
1179 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1181 service_enter_dead(s, SERVICE_SUCCESS, true);
1186 log_warning_unit(UNIT(s)->id,
1187 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1189 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1190 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1192 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1195 static void service_enter_stop(Service *s, ServiceResult f) {
1200 if (f != SERVICE_SUCCESS)
1203 service_unwatch_control_pid(s);
1204 unit_watch_all_pids(UNIT(s));
1206 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1207 if (s->control_command) {
1208 s->control_command_id = SERVICE_EXEC_STOP;
1210 r = service_spawn(s,
1214 !s->permissions_start_only,
1215 !s->root_directory_start_only,
1223 service_set_state(s, SERVICE_STOP);
1225 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1230 log_warning_unit(UNIT(s)->id,
1231 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
1232 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1235 static void service_enter_running(Service *s, ServiceResult f) {
1236 int main_pid_ok, cgroup_ok;
1239 if (f != SERVICE_SUCCESS)
1242 main_pid_ok = main_pid_good(s);
1243 cgroup_ok = cgroup_good(s);
1245 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1246 (s->bus_name_good || s->type != SERVICE_DBUS))
1247 service_set_state(s, SERVICE_RUNNING);
1248 else if (s->remain_after_exit)
1249 service_set_state(s, SERVICE_EXITED);
1251 service_enter_stop(s, SERVICE_SUCCESS);
1254 static void service_enter_start_post(Service *s) {
1258 service_unwatch_control_pid(s);
1259 service_reset_watchdog(s);
1261 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1262 if (s->control_command) {
1263 s->control_command_id = SERVICE_EXEC_START_POST;
1265 r = service_spawn(s,
1269 !s->permissions_start_only,
1270 !s->root_directory_start_only,
1278 service_set_state(s, SERVICE_START_POST);
1280 service_enter_running(s, SERVICE_SUCCESS);
1285 log_warning_unit(UNIT(s)->id,
1286 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1287 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1290 static void service_kill_control_processes(Service *s) {
1293 if (!UNIT(s)->cgroup_path)
1296 p = strappenda(UNIT(s)->cgroup_path, "/control");
1297 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1300 static void service_enter_start(Service *s) {
1307 assert(s->exec_command[SERVICE_EXEC_START]);
1308 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
1310 service_unwatch_control_pid(s);
1311 service_unwatch_main_pid(s);
1313 /* We want to ensure that nobody leaks processes from
1314 * START_PRE here, so let's go on a killing spree, People
1315 * should not spawn long running processes from START_PRE. */
1316 service_kill_control_processes(s);
1318 if (s->type == SERVICE_FORKING) {
1319 s->control_command_id = SERVICE_EXEC_START;
1320 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1322 s->main_command = NULL;
1324 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1325 s->control_command = NULL;
1327 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1330 r = service_spawn(s,
1332 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
1333 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
1338 s->notify_access != NOTIFY_NONE,
1344 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1345 /* For simple services we immediately start
1346 * the START_POST binaries. */
1348 service_set_main_pid(s, pid);
1349 service_enter_start_post(s);
1351 } else if (s->type == SERVICE_FORKING) {
1353 /* For forking services we wait until the start
1354 * process exited. */
1356 s->control_pid = pid;
1357 service_set_state(s, SERVICE_START);
1359 } else if (s->type == SERVICE_ONESHOT ||
1360 s->type == SERVICE_DBUS ||
1361 s->type == SERVICE_NOTIFY) {
1363 /* For oneshot services we wait until the start
1364 * process exited, too, but it is our main process. */
1366 /* For D-Bus services we know the main pid right away,
1367 * but wait for the bus name to appear on the
1368 * bus. Notify services are similar. */
1370 service_set_main_pid(s, pid);
1371 service_set_state(s, SERVICE_START);
1373 assert_not_reached("Unknown service type");
1378 log_warning_unit(UNIT(s)->id,
1379 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
1380 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1383 static void service_enter_start_pre(Service *s) {
1388 service_unwatch_control_pid(s);
1390 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1391 if (s->control_command) {
1392 /* Before we start anything, let's clear up what might
1393 * be left from previous runs. */
1394 service_kill_control_processes(s);
1396 s->control_command_id = SERVICE_EXEC_START_PRE;
1398 r = service_spawn(s,
1402 !s->permissions_start_only,
1403 !s->root_directory_start_only,
1411 service_set_state(s, SERVICE_START_PRE);
1413 service_enter_start(s);
1418 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1419 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1422 static void service_enter_restart(Service *s) {
1423 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1428 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1429 /* Don't restart things if we are going down anyway */
1430 log_info_unit(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1432 r = service_arm_timer(s, s->restart_usec);
1439 /* Any units that are bound to this service must also be
1440 * restarted. We use JOB_RESTART (instead of the more obvious
1441 * JOB_START) here so that those dependency jobs will be added
1443 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1447 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1448 * it will be canceled as part of the service_stop() call that
1449 * is executed as part of JOB_RESTART. */
1451 log_debug_unit(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1455 log_warning_unit(UNIT(s)->id,
1456 "%s failed to schedule restart job: %s",
1457 UNIT(s)->id, bus_error_message(&error, -r));
1458 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1461 static void service_enter_reload(Service *s) {
1466 service_unwatch_control_pid(s);
1468 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1469 if (s->control_command) {
1470 s->control_command_id = SERVICE_EXEC_RELOAD;
1472 r = service_spawn(s,
1476 !s->permissions_start_only,
1477 !s->root_directory_start_only,
1485 service_set_state(s, SERVICE_RELOAD);
1487 service_enter_running(s, SERVICE_SUCCESS);
1492 log_warning_unit(UNIT(s)->id,
1493 "%s failed to run 'reload' task: %s",
1494 UNIT(s)->id, strerror(-r));
1495 s->reload_result = SERVICE_FAILURE_RESOURCES;
1496 service_enter_running(s, SERVICE_SUCCESS);
1499 static void service_run_next_control(Service *s) {
1503 assert(s->control_command);
1504 assert(s->control_command->command_next);
1506 assert(s->control_command_id != SERVICE_EXEC_START);
1508 s->control_command = s->control_command->command_next;
1509 service_unwatch_control_pid(s);
1511 r = service_spawn(s,
1515 !s->permissions_start_only,
1516 !s->root_directory_start_only,
1517 s->control_command_id == SERVICE_EXEC_START_PRE ||
1518 s->control_command_id == SERVICE_EXEC_STOP_POST,
1528 log_warning_unit(UNIT(s)->id,
1529 "%s failed to run next control task: %s",
1530 UNIT(s)->id, strerror(-r));
1532 if (s->state == SERVICE_START_PRE)
1533 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1534 else if (s->state == SERVICE_STOP)
1535 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1536 else if (s->state == SERVICE_STOP_POST)
1537 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1538 else if (s->state == SERVICE_RELOAD) {
1539 s->reload_result = SERVICE_FAILURE_RESOURCES;
1540 service_enter_running(s, SERVICE_SUCCESS);
1542 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1545 static void service_run_next_main(Service *s) {
1550 assert(s->main_command);
1551 assert(s->main_command->command_next);
1552 assert(s->type == SERVICE_ONESHOT);
1554 s->main_command = s->main_command->command_next;
1555 service_unwatch_main_pid(s);
1557 r = service_spawn(s,
1564 s->notify_access != NOTIFY_NONE,
1570 service_set_main_pid(s, pid);
1575 log_warning_unit(UNIT(s)->id,
1576 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
1577 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1580 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none) {
1583 if (action == SERVICE_FAILURE_ACTION_REBOOT ||
1584 action == SERVICE_FAILURE_ACTION_REBOOT_FORCE)
1585 update_reboot_param_file(s->reboot_arg);
1589 case SERVICE_FAILURE_ACTION_NONE:
1590 if (log_action_none)
1591 log_warning_unit(UNIT(s)->id,
1592 "%s %s, refusing to start.", UNIT(s)->id, reason);
1595 case SERVICE_FAILURE_ACTION_REBOOT: {
1596 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1599 log_warning_unit(UNIT(s)->id,
1600 "%s %s, rebooting.", UNIT(s)->id, reason);
1602 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
1603 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
1604 true, &error, NULL);
1606 log_error_unit(UNIT(s)->id,
1607 "Failed to reboot: %s.", bus_error_message(&error, r));
1612 case SERVICE_FAILURE_ACTION_REBOOT_FORCE:
1613 log_warning_unit(UNIT(s)->id,
1614 "%s %s, forcibly rebooting.", UNIT(s)->id, reason);
1615 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
1618 case SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE:
1619 log_warning_unit(UNIT(s)->id,
1620 "%s %s, rebooting immediately.", UNIT(s)->id, reason);
1622 if (s->reboot_arg) {
1623 log_info("Rebooting with argument '%s'.", s->reboot_arg);
1624 syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
1625 LINUX_REBOOT_CMD_RESTART2, s->reboot_arg);
1628 log_info("Rebooting.");
1629 reboot(RB_AUTOBOOT);
1633 log_error_unit(UNIT(s)->id,
1634 "failure action=%i", action);
1635 assert_not_reached("Unknown FailureAction.");
1641 static int service_start_limit_test(Service *s) {
1644 if (ratelimit_test(&s->start_limit))
1647 return service_execute_action(s, s->start_limit_action, "start request repeated too quickly", true);
1650 static int service_start(Unit *u) {
1651 Service *s = SERVICE(u);
1656 /* We cannot fulfill this request right now, try again later
1658 if (s->state == SERVICE_STOP ||
1659 s->state == SERVICE_STOP_SIGTERM ||
1660 s->state == SERVICE_STOP_SIGKILL ||
1661 s->state == SERVICE_STOP_POST ||
1662 s->state == SERVICE_FINAL_SIGTERM ||
1663 s->state == SERVICE_FINAL_SIGKILL)
1666 /* Already on it! */
1667 if (s->state == SERVICE_START_PRE ||
1668 s->state == SERVICE_START ||
1669 s->state == SERVICE_START_POST)
1672 /* A service that will be restarted must be stopped first to
1673 * trigger BindsTo and/or OnFailure dependencies. If a user
1674 * does not want to wait for the holdoff time to elapse, the
1675 * service should be manually restarted, not started. We
1676 * simply return EAGAIN here, so that any start jobs stay
1677 * queued, and assume that the auto restart timer will
1678 * eventually trigger the restart. */
1679 if (s->state == SERVICE_AUTO_RESTART)
1682 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1684 /* Make sure we don't enter a busy loop of some kind. */
1685 r = service_start_limit_test(s);
1687 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1691 s->result = SERVICE_SUCCESS;
1692 s->reload_result = SERVICE_SUCCESS;
1693 s->main_pid_known = false;
1694 s->main_pid_alien = false;
1695 s->forbid_restart = false;
1697 free(s->status_text);
1698 s->status_text = NULL;
1699 s->status_errno = 0;
1701 service_enter_start_pre(s);
1705 static int service_stop(Unit *u) {
1706 Service *s = SERVICE(u);
1710 /* Don't create restart jobs from here. */
1711 s->forbid_restart = true;
1714 if (s->state == SERVICE_STOP ||
1715 s->state == SERVICE_STOP_SIGTERM ||
1716 s->state == SERVICE_STOP_SIGKILL ||
1717 s->state == SERVICE_STOP_POST ||
1718 s->state == SERVICE_FINAL_SIGTERM ||
1719 s->state == SERVICE_FINAL_SIGKILL)
1722 /* A restart will be scheduled or is in progress. */
1723 if (s->state == SERVICE_AUTO_RESTART) {
1724 service_set_state(s, SERVICE_DEAD);
1728 /* If there's already something running we go directly into
1730 if (s->state == SERVICE_START_PRE ||
1731 s->state == SERVICE_START ||
1732 s->state == SERVICE_START_POST ||
1733 s->state == SERVICE_RELOAD) {
1734 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1738 assert(s->state == SERVICE_RUNNING ||
1739 s->state == SERVICE_EXITED);
1741 service_enter_stop(s, SERVICE_SUCCESS);
1745 static int service_reload(Unit *u) {
1746 Service *s = SERVICE(u);
1750 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1752 service_enter_reload(s);
1756 _pure_ static bool service_can_reload(Unit *u) {
1757 Service *s = SERVICE(u);
1761 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1764 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1765 Service *s = SERVICE(u);
1771 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1772 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1773 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1775 if (s->control_pid > 0)
1776 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1779 if (s->main_pid_known && s->main_pid > 0)
1780 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1782 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1785 unit_serialize_item(u, f, "status-text", s->status_text);
1787 /* FIXME: There's a minor uncleanliness here: if there are
1788 * multiple commands attached here, we will start from the
1789 * first one again */
1790 if (s->control_command_id >= 0)
1791 unit_serialize_item(u, f, "control-command",
1792 service_exec_command_to_string(s->control_command_id));
1794 if (s->socket_fd >= 0) {
1797 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
1800 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1803 if (s->main_exec_status.pid > 0) {
1804 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
1805 s->main_exec_status.pid);
1806 dual_timestamp_serialize(f, "main-exec-status-start",
1807 &s->main_exec_status.start_timestamp);
1808 dual_timestamp_serialize(f, "main-exec-status-exit",
1809 &s->main_exec_status.exit_timestamp);
1811 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1812 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
1813 s->main_exec_status.code);
1814 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
1815 s->main_exec_status.status);
1818 if (dual_timestamp_is_set(&s->watchdog_timestamp))
1819 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
1821 if (s->forbid_restart)
1822 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
1827 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1828 Service *s = SERVICE(u);
1835 if (streq(key, "state")) {
1838 state = service_state_from_string(value);
1840 log_debug_unit(u->id, "Failed to parse state value %s", value);
1842 s->deserialized_state = state;
1843 } else if (streq(key, "result")) {
1846 f = service_result_from_string(value);
1848 log_debug_unit(u->id, "Failed to parse result value %s", value);
1849 else if (f != SERVICE_SUCCESS)
1852 } else if (streq(key, "reload-result")) {
1855 f = service_result_from_string(value);
1857 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
1858 else if (f != SERVICE_SUCCESS)
1859 s->reload_result = f;
1861 } else if (streq(key, "control-pid")) {
1864 if (parse_pid(value, &pid) < 0)
1865 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1867 s->control_pid = pid;
1868 } else if (streq(key, "main-pid")) {
1871 if (parse_pid(value, &pid) < 0)
1872 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
1874 service_set_main_pid(s, pid);
1875 unit_watch_pid(UNIT(s), pid);
1877 } else if (streq(key, "main-pid-known")) {
1880 b = parse_boolean(value);
1882 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
1884 s->main_pid_known = b;
1885 } else if (streq(key, "status-text")) {
1892 free(s->status_text);
1896 } else if (streq(key, "control-command")) {
1897 ServiceExecCommand id;
1899 id = service_exec_command_from_string(value);
1901 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1903 s->control_command_id = id;
1904 s->control_command = s->exec_command[id];
1906 } else if (streq(key, "socket-fd")) {
1909 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1910 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
1913 asynchronous_close(s->socket_fd);
1914 s->socket_fd = fdset_remove(fds, fd);
1916 } else if (streq(key, "main-exec-status-pid")) {
1919 if (parse_pid(value, &pid) < 0)
1920 log_debug_unit(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_debug_unit(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_debug_unit(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_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
1950 s->forbid_restart = b;
1952 log_debug_unit(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_debug_unit(UNIT(s)->id,
2016 "Setting watch for %s's PID file %s",
2017 UNIT(s)->id, s->pid_file_pathspec->path);
2018 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2022 /* the pidfile might have appeared just before we set the watch */
2023 log_debug_unit(UNIT(s)->id,
2024 "Trying to read %s's PID file %s in case it changed",
2025 UNIT(s)->id, s->pid_file_pathspec->path);
2026 service_retry_pid_file(s);
2030 log_error_unit(UNIT(s)->id,
2031 "Failed to set a watch for %s's PID file %s: %s",
2032 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2033 service_unwatch_pid_file(s);
2037 static int service_demand_pid_file(Service *s) {
2040 assert(s->pid_file);
2041 assert(!s->pid_file_pathspec);
2043 ps = new0(PathSpec, 1);
2048 ps->path = strdup(s->pid_file);
2054 path_kill_slashes(ps->path);
2056 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2057 * keep their PID file open all the time. */
2058 ps->type = PATH_MODIFIED;
2059 ps->inotify_fd = -1;
2061 s->pid_file_pathspec = ps;
2063 return service_watch_pid_file(s);
2066 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2067 PathSpec *p = userdata;
2072 s = SERVICE(p->unit);
2076 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2077 assert(s->pid_file_pathspec);
2078 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2080 log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2082 if (path_spec_fd_event(p, events) < 0)
2085 if (service_retry_pid_file(s) == 0)
2088 if (service_watch_pid_file(s) < 0)
2094 service_unwatch_pid_file(s);
2095 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2099 static void service_notify_cgroup_empty_event(Unit *u) {
2100 Service *s = SERVICE(u);
2104 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
2108 /* Waiting for SIGCHLD is usually more interesting,
2109 * because it includes return codes/signals. Which is
2110 * why we ignore the cgroup events for most cases,
2111 * except when we don't know pid which to expect the
2115 case SERVICE_START_POST:
2116 /* If we were hoping for the daemon to write its PID file,
2117 * we can give up now. */
2118 if (s->pid_file_pathspec) {
2119 log_warning_unit(u->id,
2120 "%s never wrote its PID file. Failing.", UNIT(s)->id);
2121 service_unwatch_pid_file(s);
2122 if (s->state == SERVICE_START)
2123 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2125 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2129 case SERVICE_RUNNING:
2130 /* service_enter_running() will figure out what to do */
2131 service_enter_running(s, SERVICE_SUCCESS);
2134 case SERVICE_STOP_SIGTERM:
2135 case SERVICE_STOP_SIGKILL:
2137 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2138 service_enter_stop_post(s, SERVICE_SUCCESS);
2142 case SERVICE_STOP_POST:
2143 case SERVICE_FINAL_SIGTERM:
2144 case SERVICE_FINAL_SIGKILL:
2145 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2146 service_enter_dead(s, SERVICE_SUCCESS, true);
2155 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2156 Service *s = SERVICE(u);
2162 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2163 is_clean_exit_lsb(code, status, &s->success_status))
2164 f = SERVICE_SUCCESS;
2165 else if (code == CLD_EXITED)
2166 f = SERVICE_FAILURE_EXIT_CODE;
2167 else if (code == CLD_KILLED)
2168 f = SERVICE_FAILURE_SIGNAL;
2169 else if (code == CLD_DUMPED)
2170 f = SERVICE_FAILURE_CORE_DUMP;
2172 assert_not_reached("Unknown code");
2174 if (s->main_pid == pid) {
2175 /* Forking services may occasionally move to a new PID.
2176 * As long as they update the PID file before exiting the old
2177 * PID, they're fine. */
2178 if (service_load_pid_file(s, false) == 0)
2182 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2184 if (s->main_command) {
2185 /* If this is not a forking service than the
2186 * main process got started and hence we copy
2187 * the exit status so that it is recorded both
2188 * as main and as control process exit
2191 s->main_command->exec_status = s->main_exec_status;
2193 if (s->main_command->ignore)
2194 f = SERVICE_SUCCESS;
2195 } else if (s->exec_command[SERVICE_EXEC_START]) {
2197 /* If this is a forked process, then we should
2198 * ignore the return value if this was
2199 * configured for the starter process */
2201 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2202 f = SERVICE_SUCCESS;
2205 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2207 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2208 u->id, sigchld_code_to_string(code), status,
2209 strna(code == CLD_EXITED
2210 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2211 : signal_to_string(status)),
2212 "EXIT_CODE=%s", sigchld_code_to_string(code),
2213 "EXIT_STATUS=%i", status,
2216 if (f != SERVICE_SUCCESS)
2219 if (s->main_command &&
2220 s->main_command->command_next &&
2221 f == SERVICE_SUCCESS) {
2223 /* There is another command to *
2224 * execute, so let's do that. */
2226 log_debug_unit(u->id,
2227 "%s running next main command for state %s",
2228 u->id, service_state_to_string(s->state));
2229 service_run_next_main(s);
2233 /* The service exited, so the service is officially
2235 s->main_command = NULL;
2239 case SERVICE_START_POST:
2240 case SERVICE_RELOAD:
2242 /* Need to wait until the operation is
2247 if (s->type == SERVICE_ONESHOT) {
2248 /* This was our main goal, so let's go on */
2249 if (f == SERVICE_SUCCESS)
2250 service_enter_start_post(s);
2252 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2258 case SERVICE_RUNNING:
2259 service_enter_running(s, f);
2262 case SERVICE_STOP_SIGTERM:
2263 case SERVICE_STOP_SIGKILL:
2265 if (!control_pid_good(s))
2266 service_enter_stop_post(s, f);
2268 /* If there is still a control process, wait for that first */
2271 case SERVICE_STOP_POST:
2272 case SERVICE_FINAL_SIGTERM:
2273 case SERVICE_FINAL_SIGKILL:
2275 if (!control_pid_good(s))
2276 service_enter_dead(s, f, true);
2280 assert_not_reached("Uh, main process died at wrong time.");
2284 } else if (s->control_pid == pid) {
2287 if (s->control_command) {
2288 exec_status_exit(&s->control_command->exec_status,
2289 &s->exec_context, pid, code, status);
2291 if (s->control_command->ignore)
2292 f = SERVICE_SUCCESS;
2295 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
2296 "%s: control process exited, code=%s status=%i",
2297 u->id, sigchld_code_to_string(code), status);
2299 if (f != SERVICE_SUCCESS)
2302 /* Immediately get rid of the cgroup, so that the
2303 * kernel doesn't delay the cgroup empty messages for
2304 * the service cgroup any longer than necessary */
2305 service_kill_control_processes(s);
2307 if (s->control_command &&
2308 s->control_command->command_next &&
2309 f == SERVICE_SUCCESS) {
2311 /* There is another command to *
2312 * execute, so let's do that. */
2314 log_debug_unit(u->id,
2315 "%s running next control command for state %s",
2316 u->id, service_state_to_string(s->state));
2317 service_run_next_control(s);
2320 /* No further commands for this step, so let's
2321 * figure out what to do next */
2323 s->control_command = NULL;
2324 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2326 log_debug_unit(u->id,
2327 "%s got final SIGCHLD for state %s",
2328 u->id, service_state_to_string(s->state));
2332 case SERVICE_START_PRE:
2333 if (f == SERVICE_SUCCESS)
2334 service_enter_start(s);
2336 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2340 if (s->type != SERVICE_FORKING)
2341 /* Maybe spurious event due to a reload that changed the type? */
2344 if (f != SERVICE_SUCCESS) {
2345 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2350 bool has_start_post;
2353 /* Let's try to load the pid file here if we can.
2354 * The PID file might actually be created by a START_POST
2355 * script. In that case don't worry if the loading fails. */
2357 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2358 r = service_load_pid_file(s, !has_start_post);
2359 if (!has_start_post && r < 0) {
2360 r = service_demand_pid_file(s);
2361 if (r < 0 || !cgroup_good(s))
2362 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2366 service_search_main_pid(s);
2368 service_enter_start_post(s);
2371 case SERVICE_START_POST:
2372 if (f != SERVICE_SUCCESS) {
2373 service_enter_stop(s, f);
2380 r = service_load_pid_file(s, true);
2382 r = service_demand_pid_file(s);
2383 if (r < 0 || !cgroup_good(s))
2384 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2388 service_search_main_pid(s);
2390 service_enter_running(s, SERVICE_SUCCESS);
2393 case SERVICE_RELOAD:
2394 if (f == SERVICE_SUCCESS) {
2395 service_load_pid_file(s, true);
2396 service_search_main_pid(s);
2399 s->reload_result = f;
2400 service_enter_running(s, SERVICE_SUCCESS);
2404 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2407 case SERVICE_STOP_SIGTERM:
2408 case SERVICE_STOP_SIGKILL:
2409 if (main_pid_good(s) <= 0)
2410 service_enter_stop_post(s, f);
2412 /* If there is still a service
2413 * process around, wait until
2414 * that one quit, too */
2417 case SERVICE_STOP_POST:
2418 case SERVICE_FINAL_SIGTERM:
2419 case SERVICE_FINAL_SIGKILL:
2420 if (main_pid_good(s) <= 0)
2421 service_enter_dead(s, f, true);
2425 assert_not_reached("Uh, control process died at wrong time.");
2430 /* Notify clients about changed exit status */
2431 unit_add_to_dbus_queue(u);
2433 /* We got one SIGCHLD for the service, let's watch all
2434 * processes that are now running of the service, and watch
2435 * that. Among the PIDs we then watch will be children
2436 * reassigned to us, which hopefully allows us to identify
2437 * when all children are gone */
2438 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2439 unit_watch_all_pids(u);
2441 /* If the PID set is empty now, then let's finish this off */
2442 if (set_isempty(u->pids))
2443 service_notify_cgroup_empty_event(u);
2446 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2447 Service *s = SERVICE(userdata);
2450 assert(source == s->timer_event_source);
2454 case SERVICE_START_PRE:
2456 log_warning_unit(UNIT(s)->id,
2457 "%s %s operation timed out. Terminating.",
2459 s->state == SERVICE_START ? "start" : "start-pre");
2460 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2463 case SERVICE_START_POST:
2464 log_warning_unit(UNIT(s)->id,
2465 "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2466 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2469 case SERVICE_RELOAD:
2470 log_warning_unit(UNIT(s)->id,
2471 "%s reload operation timed out. Stopping.", UNIT(s)->id);
2472 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2473 service_enter_running(s, SERVICE_SUCCESS);
2477 log_warning_unit(UNIT(s)->id,
2478 "%s stopping timed out. Terminating.", UNIT(s)->id);
2479 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2482 case SERVICE_STOP_SIGTERM:
2483 if (s->kill_context.send_sigkill) {
2484 log_warning_unit(UNIT(s)->id,
2485 "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2486 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2488 log_warning_unit(UNIT(s)->id,
2489 "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2490 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2495 case SERVICE_STOP_SIGKILL:
2496 /* Uh, we sent a SIGKILL and it is still not gone?
2497 * Must be something we cannot kill, so let's just be
2498 * weirded out and continue */
2500 log_warning_unit(UNIT(s)->id,
2501 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2502 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2505 case SERVICE_STOP_POST:
2506 log_warning_unit(UNIT(s)->id,
2507 "%s stop-post timed out. Terminating.", UNIT(s)->id);
2508 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2511 case SERVICE_FINAL_SIGTERM:
2512 if (s->kill_context.send_sigkill) {
2513 log_warning_unit(UNIT(s)->id,
2514 "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2515 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2517 log_warning_unit(UNIT(s)->id,
2518 "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.",
2520 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2525 case SERVICE_FINAL_SIGKILL:
2526 log_warning_unit(UNIT(s)->id,
2527 "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2528 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2531 case SERVICE_AUTO_RESTART:
2532 log_info_unit(UNIT(s)->id,
2533 s->restart_usec > 0 ?
2534 "%s holdoff time over, scheduling restart." :
2535 "%s has no holdoff time, scheduling restart.",
2537 service_enter_restart(s);
2541 assert_not_reached("Timeout at wrong time.");
2547 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2548 Service *s = SERVICE(userdata);
2549 char t[FORMAT_TIMESPAN_MAX];
2552 assert(source == s->watchdog_event_source);
2554 log_error_unit(UNIT(s)->id,
2555 "%s watchdog timeout (limit %s)!",
2557 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2558 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
2563 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
2564 Service *s = SERVICE(u);
2566 bool notify_dbus = false;
2570 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s...)",
2571 u->id, pid, tags && *tags ? tags[0] : "(empty)");
2573 if (s->notify_access == NOTIFY_NONE) {
2574 log_warning_unit(u->id,
2575 "%s: Got notification message from PID "PID_FMT", but reception is disabled.",
2580 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2581 if (s->main_pid != 0)
2582 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);
2584 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);
2588 /* Interpret MAINPID= */
2589 e = strv_find_prefix(tags, "MAINPID=");
2590 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2591 if (parse_pid(e + 8, &pid) < 0)
2592 log_warning_unit(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2594 log_debug_unit(u->id, "%s: got %s", u->id, e);
2595 service_set_main_pid(s, pid);
2596 unit_watch_pid(UNIT(s), pid);
2601 /* Interpret READY= */
2602 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START && strv_find(tags, "READY=1")) {
2603 log_debug_unit(u->id, "%s: got READY=1", u->id);
2604 service_enter_start_post(s);
2608 /* Interpret STATUS= */
2609 e = strv_find_prefix(tags, "STATUS=");
2614 if (!utf8_is_valid(e+7)) {
2615 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
2619 log_debug_unit(u->id, "%s: got %s", u->id, e);
2630 if (!streq_ptr(s->status_text, t)) {
2631 free(s->status_text);
2638 /* Interpret ERRNO= */
2639 e = strv_find_prefix(tags, "ERRNO=");
2643 if (safe_atoi(e + 6, &status_errno) < 0 || status_errno < 0)
2644 log_warning_unit(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2646 log_debug_unit(u->id, "%s: got %s", u->id, e);
2648 if (s->status_errno != status_errno) {
2649 s->status_errno = status_errno;
2655 /* Interpret WATCHDOG= */
2656 if (strv_find(tags, "WATCHDOG=1")) {
2657 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
2658 service_reset_watchdog(s);
2661 /* Notify clients about changed status or main pid */
2663 unit_add_to_dbus_queue(u);
2666 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2667 Service *s = SERVICE(u);
2670 if (!s->timer_event_source)
2673 r = sd_event_source_get_time(s->timer_event_source, timeout);
2680 static void service_bus_name_owner_change(
2683 const char *old_owner,
2684 const char *new_owner) {
2686 Service *s = SERVICE(u);
2692 assert(streq(s->bus_name, name));
2693 assert(old_owner || new_owner);
2695 if (old_owner && new_owner)
2696 log_debug_unit(u->id,
2697 "%s's D-Bus name %s changed owner from %s to %s",
2698 u->id, name, old_owner, new_owner);
2700 log_debug_unit(u->id,
2701 "%s's D-Bus name %s no longer registered by %s",
2702 u->id, name, old_owner);
2704 log_debug_unit(u->id,
2705 "%s's D-Bus name %s now registered by %s",
2706 u->id, name, new_owner);
2708 s->bus_name_good = !!new_owner;
2710 if (s->type == SERVICE_DBUS) {
2712 /* service_enter_running() will figure out what to
2714 if (s->state == SERVICE_RUNNING)
2715 service_enter_running(s, SERVICE_SUCCESS);
2716 else if (s->state == SERVICE_START && new_owner)
2717 service_enter_start_post(s);
2719 } else if (new_owner &&
2721 (s->state == SERVICE_START ||
2722 s->state == SERVICE_START_POST ||
2723 s->state == SERVICE_RUNNING ||
2724 s->state == SERVICE_RELOAD)) {
2726 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2729 /* Try to acquire PID from bus service */
2731 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2733 r = sd_bus_creds_get_pid(creds, &pid);
2735 log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2737 service_set_main_pid(s, pid);
2738 unit_watch_pid(UNIT(s), pid);
2743 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
2744 _cleanup_free_ char *peer = NULL;
2750 /* This is called by the socket code when instantiating a new
2751 * service for a stream socket and the socket needs to be
2754 if (UNIT(s)->load_state != UNIT_LOADED)
2757 if (s->socket_fd >= 0)
2760 if (s->state != SERVICE_DEAD)
2763 if (getpeername_pretty(fd, &peer) >= 0) {
2765 if (UNIT(s)->description) {
2766 _cleanup_free_ char *a;
2768 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
2772 r = unit_set_description(UNIT(s), a);
2774 r = unit_set_description(UNIT(s), peer);
2782 unit_ref_set(&s->accept_socket, UNIT(sock));
2784 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
2787 static void service_reset_failed(Unit *u) {
2788 Service *s = SERVICE(u);
2792 if (s->state == SERVICE_FAILED)
2793 service_set_state(s, SERVICE_DEAD);
2795 s->result = SERVICE_SUCCESS;
2796 s->reload_result = SERVICE_SUCCESS;
2798 RATELIMIT_RESET(s->start_limit);
2801 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2802 Service *s = SERVICE(u);
2804 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
2807 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
2808 [SERVICE_DEAD] = "dead",
2809 [SERVICE_START_PRE] = "start-pre",
2810 [SERVICE_START] = "start",
2811 [SERVICE_START_POST] = "start-post",
2812 [SERVICE_RUNNING] = "running",
2813 [SERVICE_EXITED] = "exited",
2814 [SERVICE_RELOAD] = "reload",
2815 [SERVICE_STOP] = "stop",
2816 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
2817 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
2818 [SERVICE_STOP_POST] = "stop-post",
2819 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
2820 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
2821 [SERVICE_FAILED] = "failed",
2822 [SERVICE_AUTO_RESTART] = "auto-restart",
2825 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
2827 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
2828 [SERVICE_RESTART_NO] = "no",
2829 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
2830 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
2831 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
2832 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
2833 [SERVICE_RESTART_ON_ABORT] = "on-abort",
2834 [SERVICE_RESTART_ALWAYS] = "always",
2837 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
2839 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
2840 [SERVICE_SIMPLE] = "simple",
2841 [SERVICE_FORKING] = "forking",
2842 [SERVICE_ONESHOT] = "oneshot",
2843 [SERVICE_DBUS] = "dbus",
2844 [SERVICE_NOTIFY] = "notify",
2845 [SERVICE_IDLE] = "idle"
2848 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
2850 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
2851 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
2852 [SERVICE_EXEC_START] = "ExecStart",
2853 [SERVICE_EXEC_START_POST] = "ExecStartPost",
2854 [SERVICE_EXEC_RELOAD] = "ExecReload",
2855 [SERVICE_EXEC_STOP] = "ExecStop",
2856 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
2859 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
2861 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
2862 [NOTIFY_NONE] = "none",
2863 [NOTIFY_MAIN] = "main",
2864 [NOTIFY_ALL] = "all"
2867 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
2869 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
2870 [SERVICE_SUCCESS] = "success",
2871 [SERVICE_FAILURE_RESOURCES] = "resources",
2872 [SERVICE_FAILURE_TIMEOUT] = "timeout",
2873 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
2874 [SERVICE_FAILURE_SIGNAL] = "signal",
2875 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
2876 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
2877 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
2880 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
2882 static const char* const failure_action_table[_SERVICE_FAILURE_ACTION_MAX] = {
2883 [SERVICE_FAILURE_ACTION_NONE] = "none",
2884 [SERVICE_FAILURE_ACTION_REBOOT] = "reboot",
2885 [SERVICE_FAILURE_ACTION_REBOOT_FORCE] = "reboot-force",
2886 [SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE] = "reboot-immediate"
2888 DEFINE_STRING_TABLE_LOOKUP(failure_action, FailureAction);
2890 const UnitVTable service_vtable = {
2891 .object_size = sizeof(Service),
2892 .exec_context_offset = offsetof(Service, exec_context),
2893 .cgroup_context_offset = offsetof(Service, cgroup_context),
2894 .kill_context_offset = offsetof(Service, kill_context),
2895 .exec_runtime_offset = offsetof(Service, exec_runtime),
2901 .private_section = "Service",
2903 .init = service_init,
2904 .done = service_done,
2905 .load = service_load,
2907 .coldplug = service_coldplug,
2909 .dump = service_dump,
2911 .start = service_start,
2912 .stop = service_stop,
2913 .reload = service_reload,
2915 .can_reload = service_can_reload,
2917 .kill = service_kill,
2919 .serialize = service_serialize,
2920 .deserialize_item = service_deserialize_item,
2922 .active_state = service_active_state,
2923 .sub_state_to_string = service_sub_state_to_string,
2925 .check_gc = service_check_gc,
2926 .check_snapshot = service_check_snapshot,
2928 .sigchld_event = service_sigchld_event,
2930 .reset_failed = service_reset_failed,
2932 .notify_cgroup_empty = service_notify_cgroup_empty_event,
2933 .notify_message = service_notify_message,
2935 .bus_name_owner_change = service_bus_name_owner_change,
2937 .bus_interface = "org.freedesktop.systemd1.Service",
2938 .bus_vtable = bus_service_vtable,
2939 .bus_set_property = bus_service_set_property,
2940 .bus_commit_properties = bus_service_commit_properties,
2942 .get_timeout = service_get_timeout,
2943 .can_transient = true,
2945 .status_message_formats = {
2946 .starting_stopping = {
2947 [0] = "Starting %s...",
2948 [1] = "Stopping %s...",
2950 .finished_start_job = {
2951 [JOB_DONE] = "Started %s.",
2952 [JOB_FAILED] = "Failed to start %s.",
2953 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2954 [JOB_TIMEOUT] = "Timed out starting %s.",
2956 .finished_stop_job = {
2957 [JOB_DONE] = "Stopped %s.",
2958 [JOB_FAILED] = "Stopped (with error) %s.",
2959 [JOB_TIMEOUT] = "Timed out stopping %s.",