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 if (s->socket_fd < 0)
186 s->socket_fd = asynchronous_close(s->socket_fd);
189 static void service_connection_unref(Service *s) {
192 if (!UNIT_ISSET(s->accept_socket))
195 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
196 unit_ref_unset(&s->accept_socket);
199 static void service_stop_watchdog(Service *s) {
202 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
203 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
206 static void service_start_watchdog(Service *s) {
211 if (s->watchdog_usec <= 0)
214 if (s->watchdog_event_source) {
215 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
217 log_warning_unit(UNIT(s)->id, "%s failed to reset watchdog timer: %s", UNIT(s)->id, strerror(-r));
221 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
223 r = sd_event_add_time(
224 UNIT(s)->manager->event,
225 &s->watchdog_event_source,
227 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
228 service_dispatch_watchdog, s);
230 log_warning_unit(UNIT(s)->id, "%s failed to add watchdog timer: %s", UNIT(s)->id, strerror(-r));
234 /* Let's process everything else which might be a sign
235 * of living before we consider a service died. */
236 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
240 log_warning_unit(UNIT(s)->id, "%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
243 static void service_reset_watchdog(Service *s) {
246 dual_timestamp_get(&s->watchdog_timestamp);
247 service_start_watchdog(s);
250 static void service_done(Unit *u) {
251 Service *s = SERVICE(u);
258 free(s->status_text);
259 s->status_text = NULL;
262 s->reboot_arg = NULL;
264 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
265 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
266 s->control_command = NULL;
267 s->main_command = NULL;
269 exit_status_set_free(&s->restart_prevent_status);
270 exit_status_set_free(&s->restart_force_status);
271 exit_status_set_free(&s->success_status);
273 /* This will leak a process, but at least no memory or any of
275 service_unwatch_main_pid(s);
276 service_unwatch_control_pid(s);
277 service_unwatch_pid_file(s);
280 unit_unwatch_bus_name(u, s->bus_name);
285 service_close_socket_fd(s);
286 service_connection_unref(s);
288 unit_ref_unset(&s->accept_socket);
290 service_stop_watchdog(s);
292 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
295 static int service_arm_timer(Service *s, usec_t usec) {
300 if (s->timer_event_source) {
301 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
305 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
308 return sd_event_add_time(
309 UNIT(s)->manager->event,
310 &s->timer_event_source,
312 now(CLOCK_MONOTONIC) + usec, 0,
313 service_dispatch_timer, s);
316 static int service_verify(Service *s) {
319 if (UNIT(s)->load_state != UNIT_LOADED)
322 if (!s->exec_command[SERVICE_EXEC_START]) {
323 log_error_unit(UNIT(s)->id, "%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
327 if (s->type != SERVICE_ONESHOT &&
328 s->exec_command[SERVICE_EXEC_START]->command_next) {
329 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);
333 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
334 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);
338 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
339 log_error_unit(UNIT(s)->id, "%s has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
343 if (s->type == SERVICE_DBUS && !s->bus_name) {
344 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);
348 if (s->bus_name && s->type != SERVICE_DBUS)
349 log_warning_unit(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
351 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
352 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
359 static int service_add_default_dependencies(Service *s) {
364 /* Add a number of automatic dependencies useful for the
365 * majority of services. */
367 /* First, pull in base system */
368 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES,
369 SPECIAL_BASIC_TARGET, NULL, true);
373 /* Second, activate normal shutdown */
374 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS,
375 SPECIAL_SHUTDOWN_TARGET, NULL, true);
379 static void service_fix_output(Service *s) {
382 /* If nothing has been explicitly configured, patch default
383 * output in. If input is socket/tty we avoid this however,
384 * since in that case we want output to default to the same
385 * place as we read input from. */
387 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
388 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
389 s->exec_context.std_input == EXEC_INPUT_NULL)
390 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
392 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
393 s->exec_context.std_input == EXEC_INPUT_NULL)
394 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
397 static int service_load(Unit *u) {
399 Service *s = SERVICE(u);
403 /* Load a .service file */
404 r = unit_load_fragment(u);
408 /* Still nothing found? Then let's give up */
409 if (u->load_state == UNIT_STUB)
412 /* This is a new unit? Then let's add in some extras */
413 if (u->load_state == UNIT_LOADED) {
415 /* We were able to load something, then let's add in
416 * the dropin directories. */
417 r = unit_load_dropin(u);
421 if (s->type == _SERVICE_TYPE_INVALID)
422 s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
424 /* Oneshot services have disabled start timeout by default */
425 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
426 s->timeout_start_usec = 0;
428 service_fix_output(s);
430 r = unit_patch_contexts(u);
434 r = unit_add_exec_dependencies(u, &s->exec_context);
438 r = unit_add_default_slice(u, &s->cgroup_context);
442 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
443 s->notify_access = NOTIFY_MAIN;
445 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
446 s->notify_access = NOTIFY_MAIN;
449 r = unit_watch_bus_name(u, s->bus_name);
454 if (u->default_dependencies) {
455 r = service_add_default_dependencies(s);
462 return service_verify(s);
465 static void service_dump(Unit *u, FILE *f, const char *prefix) {
467 ServiceExecCommand c;
468 Service *s = SERVICE(u);
470 _cleanup_free_ char *p2 = NULL;
474 p2 = strappend(prefix, "\t");
475 prefix2 = p2 ? p2 : prefix;
478 "%sService State: %s\n"
480 "%sReload Result: %s\n"
481 "%sPermissionsStartOnly: %s\n"
482 "%sRootDirectoryStartOnly: %s\n"
483 "%sRemainAfterExit: %s\n"
484 "%sGuessMainPID: %s\n"
487 "%sNotifyAccess: %s\n",
488 prefix, service_state_to_string(s->state),
489 prefix, service_result_to_string(s->result),
490 prefix, service_result_to_string(s->reload_result),
491 prefix, yes_no(s->permissions_start_only),
492 prefix, yes_no(s->root_directory_start_only),
493 prefix, yes_no(s->remain_after_exit),
494 prefix, yes_no(s->guess_main_pid),
495 prefix, service_type_to_string(s->type),
496 prefix, service_restart_to_string(s->restart),
497 prefix, notify_access_to_string(s->notify_access));
499 if (s->control_pid > 0)
501 "%sControl PID: "PID_FMT"\n",
502 prefix, s->control_pid);
506 "%sMain PID: "PID_FMT"\n"
507 "%sMain PID Known: %s\n"
508 "%sMain PID Alien: %s\n",
510 prefix, yes_no(s->main_pid_known),
511 prefix, yes_no(s->main_pid_alien));
516 prefix, s->pid_file);
521 "%sBus Name Good: %s\n",
523 prefix, yes_no(s->bus_name_good));
525 kill_context_dump(&s->kill_context, f, prefix);
526 exec_context_dump(&s->exec_context, f, prefix);
528 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
530 if (!s->exec_command[c])
533 fprintf(f, "%s-> %s:\n",
534 prefix, service_exec_command_to_string(c));
536 exec_command_dump_list(s->exec_command[c], f, prefix2);
539 #ifdef HAVE_SYSV_COMPAT
540 if (s->sysv_start_priority >= 0)
542 "%sSysVStartPriority: %i\n",
543 prefix, s->sysv_start_priority);
547 fprintf(f, "%sStatus Text: %s\n",
548 prefix, s->status_text);
551 static int service_load_pid_file(Service *s, bool may_warn) {
552 _cleanup_free_ char *k = NULL;
561 r = read_one_line_file(s->pid_file, &k);
564 log_info_unit(UNIT(s)->id,
565 "PID file %s not readable (yet?) after %s.",
566 s->pid_file, service_state_to_string(s->state));
570 r = parse_pid(k, &pid);
573 log_info_unit(UNIT(s)->id,
574 "Failed to read PID from file %s: %s",
575 s->pid_file, strerror(-r));
579 if (!pid_is_alive(pid)) {
581 log_info_unit(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
586 if (s->main_pid_known) {
587 if (pid == s->main_pid)
590 log_debug_unit(UNIT(s)->id,
591 "Main PID changing: "PID_FMT" -> "PID_FMT,
593 service_unwatch_main_pid(s);
594 s->main_pid_known = false;
596 log_debug_unit(UNIT(s)->id,
597 "Main PID loaded: "PID_FMT, pid);
599 r = service_set_main_pid(s, pid);
603 r = unit_watch_pid(UNIT(s), pid);
605 /* FIXME: we need to do something here */
606 log_warning_unit(UNIT(s)->id,
607 "Failed to watch PID "PID_FMT" from service %s",
615 static int service_search_main_pid(Service *s) {
621 /* If we know it anyway, don't ever fallback to unreliable
623 if (s->main_pid_known)
626 if (!s->guess_main_pid)
629 assert(s->main_pid <= 0);
631 pid = unit_search_main_pid(UNIT(s));
635 log_debug_unit(UNIT(s)->id,
636 "Main PID guessed: "PID_FMT, pid);
637 r = service_set_main_pid(s, pid);
641 r = unit_watch_pid(UNIT(s), pid);
643 /* FIXME: we need to do something here */
644 log_warning_unit(UNIT(s)->id,
645 "Failed to watch PID "PID_FMT" from service %s",
650 static void service_set_state(Service *s, ServiceState state) {
651 ServiceState old_state;
652 const UnitActiveState *table;
656 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
658 old_state = s->state;
661 service_unwatch_pid_file(s);
664 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
666 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
668 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
669 SERVICE_AUTO_RESTART))
670 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
673 SERVICE_START, SERVICE_START_POST,
674 SERVICE_RUNNING, SERVICE_RELOAD,
675 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
677 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
678 service_unwatch_main_pid(s);
679 s->main_command = NULL;
683 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
685 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
687 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
688 service_unwatch_control_pid(s);
689 s->control_command = NULL;
690 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
693 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
694 unit_unwatch_all_pids(UNIT(s));
697 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
698 SERVICE_RUNNING, SERVICE_RELOAD,
699 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
700 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
701 !(state == SERVICE_DEAD && UNIT(s)->job)) {
702 service_close_socket_fd(s);
703 service_connection_unref(s);
706 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
707 service_stop_watchdog(s);
709 /* For the inactive states unit_notify() will trim the cgroup,
710 * but for exit we have to do that ourselves... */
711 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
712 unit_destroy_cgroup(UNIT(s));
714 /* For remain_after_exit services, let's see if we can "release" the
715 * hold on the console, since unit_notify() only does that in case of
717 if (state == SERVICE_EXITED && s->remain_after_exit &&
718 UNIT(s)->manager->n_on_console > 0) {
719 ExecContext *ec = unit_get_exec_context(UNIT(s));
720 if (ec && exec_context_may_touch_console(ec)) {
721 Manager *m = UNIT(s)->manager;
724 if (m->n_on_console == 0)
725 /* unset no_console_output flag, since the console is free */
726 m->no_console_output = false;
730 if (old_state != state)
731 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
733 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
734 s->reload_result = SERVICE_SUCCESS;
737 static int service_coldplug(Unit *u) {
738 Service *s = SERVICE(u);
742 assert(s->state == SERVICE_DEAD);
744 if (s->deserialized_state != s->state) {
746 if (IN_SET(s->deserialized_state,
747 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
749 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
751 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
755 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
757 /* For the start/stop timeouts 0 means off */
759 r = service_arm_timer(s, k);
765 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
767 /* The restart timeouts 0 means immediately */
768 r = service_arm_timer(s, s->restart_usec);
773 if (pid_is_unwaited(s->main_pid) &&
774 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
775 IN_SET(s->deserialized_state,
776 SERVICE_START, SERVICE_START_POST,
777 SERVICE_RUNNING, SERVICE_RELOAD,
778 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
780 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
781 r = unit_watch_pid(UNIT(s), s->main_pid);
786 if (pid_is_unwaited(s->control_pid) &&
787 IN_SET(s->deserialized_state,
788 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
790 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
792 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
793 r = unit_watch_pid(UNIT(s), s->control_pid);
798 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
799 unit_watch_all_pids(UNIT(s));
801 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
802 service_start_watchdog(s);
804 service_set_state(s, s->deserialized_state);
810 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
821 if (s->socket_fd >= 0)
824 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
829 if (u->type != UNIT_SOCKET)
834 r = socket_collect_fds(sock, &cfds, &cn_fds);
847 t = new(int, rn_fds+cn_fds);
854 memcpy(t, rfds, rn_fds * sizeof(int));
855 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
860 rn_fds = rn_fds+cn_fds;
875 static int service_spawn(
880 bool apply_permissions,
882 bool apply_tty_stdin,
883 bool set_notify_socket,
890 _cleanup_free_ int *fdsbuf = NULL;
891 unsigned n_fds = 0, n_env = 0;
892 _cleanup_strv_free_ char
893 **argv = NULL, **final_env = NULL, **our_env = NULL;
900 unit_realize_cgroup(UNIT(s));
902 r = unit_setup_exec_runtime(UNIT(s));
907 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
908 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
909 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
911 if (s->socket_fd >= 0) {
915 r = service_collect_fds(s, &fdsbuf, &n_fds);
923 if (timeout && s->timeout_start_usec > 0) {
924 r = service_arm_timer(s, s->timeout_start_usec);
928 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
930 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
934 our_env = new0(char*, 4);
940 if (set_notify_socket)
941 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
947 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
952 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
953 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
958 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
964 if (is_control && UNIT(s)->cgroup_path) {
965 path = strappenda(UNIT(s)->cgroup_path, "/control");
966 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
968 path = UNIT(s)->cgroup_path;
978 UNIT(s)->manager->confirm_spawn,
979 UNIT(s)->manager->cgroup_supported,
981 manager_get_runtime_prefix(UNIT(s)->manager),
984 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
990 r = unit_watch_pid(UNIT(s), pid);
992 /* FIXME: we need to do something here */
1001 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1006 static int main_pid_good(Service *s) {
1009 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1012 /* If we know the pid file, then lets just check if it is
1014 if (s->main_pid_known) {
1016 /* If it's an alien child let's check if it is still
1018 if (s->main_pid_alien && s->main_pid > 0)
1019 return pid_is_alive(s->main_pid);
1021 /* .. otherwise assume we'll get a SIGCHLD for it,
1022 * which we really should wait for to collect exit
1023 * status and code */
1024 return s->main_pid > 0;
1027 /* We don't know the pid */
1031 _pure_ static int control_pid_good(Service *s) {
1034 return s->control_pid > 0;
1037 static int cgroup_good(Service *s) {
1042 if (!UNIT(s)->cgroup_path)
1045 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1052 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none);
1054 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1058 if (f != SERVICE_SUCCESS)
1061 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1063 if (s->result != SERVICE_SUCCESS)
1064 service_execute_action(s, s->failure_action, "failed", false);
1066 if (allow_restart &&
1067 !s->forbid_restart &&
1068 (s->restart == SERVICE_RESTART_ALWAYS ||
1069 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1070 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1071 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1072 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1073 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1074 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1075 (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)))) &&
1076 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
1077 (!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)))) {
1079 r = service_arm_timer(s, s->restart_usec);
1083 service_set_state(s, SERVICE_AUTO_RESTART);
1086 s->forbid_restart = false;
1088 /* We want fresh tmpdirs in case service is started again immediately */
1089 exec_runtime_destroy(s->exec_runtime);
1090 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1092 /* Also, remove the runtime directory in */
1093 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1095 /* Try to delete the pid file. At this point it will be
1096 * out-of-date, and some software might be confused by it, so
1097 * let's remove it. */
1099 unlink_noerrno(s->pid_file);
1104 log_warning_unit(UNIT(s)->id,
1105 "%s failed to run install restart timer: %s",
1106 UNIT(s)->id, strerror(-r));
1107 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1110 static void service_enter_stop_post(Service *s, ServiceResult f) {
1114 if (f != SERVICE_SUCCESS)
1117 service_unwatch_control_pid(s);
1118 unit_watch_all_pids(UNIT(s));
1120 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1121 if (s->control_command) {
1122 s->control_command_id = SERVICE_EXEC_STOP_POST;
1124 r = service_spawn(s,
1128 !s->permissions_start_only,
1129 !s->root_directory_start_only,
1137 service_set_state(s, SERVICE_STOP_POST);
1139 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1144 log_warning_unit(UNIT(s)->id,
1145 "%s failed to run 'stop-post' task: %s",
1146 UNIT(s)->id, strerror(-r));
1147 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1150 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1155 if (f != SERVICE_SUCCESS)
1158 unit_watch_all_pids(UNIT(s));
1160 r = unit_kill_context(
1163 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1172 if (s->timeout_stop_usec > 0) {
1173 r = service_arm_timer(s, s->timeout_stop_usec);
1178 service_set_state(s, state);
1179 } else if (state == SERVICE_STOP_SIGTERM)
1180 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1181 else if (state == SERVICE_STOP_SIGKILL)
1182 service_enter_stop_post(s, SERVICE_SUCCESS);
1183 else if (state == SERVICE_FINAL_SIGTERM)
1184 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1186 service_enter_dead(s, SERVICE_SUCCESS, true);
1191 log_warning_unit(UNIT(s)->id,
1192 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1194 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1195 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1197 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1200 static void service_enter_stop(Service *s, ServiceResult f) {
1205 if (f != SERVICE_SUCCESS)
1208 service_unwatch_control_pid(s);
1209 unit_watch_all_pids(UNIT(s));
1211 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1212 if (s->control_command) {
1213 s->control_command_id = SERVICE_EXEC_STOP;
1215 r = service_spawn(s,
1219 !s->permissions_start_only,
1220 !s->root_directory_start_only,
1228 service_set_state(s, SERVICE_STOP);
1230 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1235 log_warning_unit(UNIT(s)->id,
1236 "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
1237 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1240 static void service_enter_running(Service *s, ServiceResult f) {
1241 int main_pid_ok, cgroup_ok;
1244 if (f != SERVICE_SUCCESS)
1247 main_pid_ok = main_pid_good(s);
1248 cgroup_ok = cgroup_good(s);
1250 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1251 (s->bus_name_good || s->type != SERVICE_DBUS))
1252 service_set_state(s, SERVICE_RUNNING);
1253 else if (s->remain_after_exit)
1254 service_set_state(s, SERVICE_EXITED);
1256 service_enter_stop(s, SERVICE_SUCCESS);
1259 static void service_enter_start_post(Service *s) {
1263 service_unwatch_control_pid(s);
1264 service_reset_watchdog(s);
1266 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1267 if (s->control_command) {
1268 s->control_command_id = SERVICE_EXEC_START_POST;
1270 r = service_spawn(s,
1274 !s->permissions_start_only,
1275 !s->root_directory_start_only,
1283 service_set_state(s, SERVICE_START_POST);
1285 service_enter_running(s, SERVICE_SUCCESS);
1290 log_warning_unit(UNIT(s)->id,
1291 "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1292 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1295 static void service_kill_control_processes(Service *s) {
1298 if (!UNIT(s)->cgroup_path)
1301 p = strappenda(UNIT(s)->cgroup_path, "/control");
1302 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1305 static void service_enter_start(Service *s) {
1312 assert(s->exec_command[SERVICE_EXEC_START]);
1313 assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
1315 service_unwatch_control_pid(s);
1316 service_unwatch_main_pid(s);
1318 /* We want to ensure that nobody leaks processes from
1319 * START_PRE here, so let's go on a killing spree, People
1320 * should not spawn long running processes from START_PRE. */
1321 service_kill_control_processes(s);
1323 if (s->type == SERVICE_FORKING) {
1324 s->control_command_id = SERVICE_EXEC_START;
1325 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1327 s->main_command = NULL;
1329 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1330 s->control_command = NULL;
1332 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1335 r = service_spawn(s,
1337 s->type == SERVICE_FORKING || s->type == SERVICE_DBUS ||
1338 s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
1343 s->notify_access != NOTIFY_NONE,
1349 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1350 /* For simple services we immediately start
1351 * the START_POST binaries. */
1353 service_set_main_pid(s, pid);
1354 service_enter_start_post(s);
1356 } else if (s->type == SERVICE_FORKING) {
1358 /* For forking services we wait until the start
1359 * process exited. */
1361 s->control_pid = pid;
1362 service_set_state(s, SERVICE_START);
1364 } else if (s->type == SERVICE_ONESHOT ||
1365 s->type == SERVICE_DBUS ||
1366 s->type == SERVICE_NOTIFY) {
1368 /* For oneshot services we wait until the start
1369 * process exited, too, but it is our main process. */
1371 /* For D-Bus services we know the main pid right away,
1372 * but wait for the bus name to appear on the
1373 * bus. Notify services are similar. */
1375 service_set_main_pid(s, pid);
1376 service_set_state(s, SERVICE_START);
1378 assert_not_reached("Unknown service type");
1383 log_warning_unit(UNIT(s)->id,
1384 "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
1385 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1388 static void service_enter_start_pre(Service *s) {
1393 service_unwatch_control_pid(s);
1395 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1396 if (s->control_command) {
1397 /* Before we start anything, let's clear up what might
1398 * be left from previous runs. */
1399 service_kill_control_processes(s);
1401 s->control_command_id = SERVICE_EXEC_START_PRE;
1403 r = service_spawn(s,
1407 !s->permissions_start_only,
1408 !s->root_directory_start_only,
1416 service_set_state(s, SERVICE_START_PRE);
1418 service_enter_start(s);
1423 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1424 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1427 static void service_enter_restart(Service *s) {
1428 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1433 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1434 /* Don't restart things if we are going down anyway */
1435 log_info_unit(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1437 r = service_arm_timer(s, s->restart_usec);
1444 /* Any units that are bound to this service must also be
1445 * restarted. We use JOB_RESTART (instead of the more obvious
1446 * JOB_START) here so that those dependency jobs will be added
1448 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1452 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1453 * it will be canceled as part of the service_stop() call that
1454 * is executed as part of JOB_RESTART. */
1456 log_debug_unit(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1460 log_warning_unit(UNIT(s)->id,
1461 "%s failed to schedule restart job: %s",
1462 UNIT(s)->id, bus_error_message(&error, -r));
1463 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1466 static void service_enter_reload(Service *s) {
1471 service_unwatch_control_pid(s);
1473 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1474 if (s->control_command) {
1475 s->control_command_id = SERVICE_EXEC_RELOAD;
1477 r = service_spawn(s,
1481 !s->permissions_start_only,
1482 !s->root_directory_start_only,
1490 service_set_state(s, SERVICE_RELOAD);
1492 service_enter_running(s, SERVICE_SUCCESS);
1497 log_warning_unit(UNIT(s)->id,
1498 "%s failed to run 'reload' task: %s",
1499 UNIT(s)->id, strerror(-r));
1500 s->reload_result = SERVICE_FAILURE_RESOURCES;
1501 service_enter_running(s, SERVICE_SUCCESS);
1504 static void service_run_next_control(Service *s) {
1508 assert(s->control_command);
1509 assert(s->control_command->command_next);
1511 assert(s->control_command_id != SERVICE_EXEC_START);
1513 s->control_command = s->control_command->command_next;
1514 service_unwatch_control_pid(s);
1516 r = service_spawn(s,
1520 !s->permissions_start_only,
1521 !s->root_directory_start_only,
1522 s->control_command_id == SERVICE_EXEC_START_PRE ||
1523 s->control_command_id == SERVICE_EXEC_STOP_POST,
1533 log_warning_unit(UNIT(s)->id,
1534 "%s failed to run next control task: %s",
1535 UNIT(s)->id, strerror(-r));
1537 if (s->state == SERVICE_START_PRE)
1538 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1539 else if (s->state == SERVICE_STOP)
1540 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1541 else if (s->state == SERVICE_STOP_POST)
1542 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1543 else if (s->state == SERVICE_RELOAD) {
1544 s->reload_result = SERVICE_FAILURE_RESOURCES;
1545 service_enter_running(s, SERVICE_SUCCESS);
1547 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1550 static void service_run_next_main(Service *s) {
1555 assert(s->main_command);
1556 assert(s->main_command->command_next);
1557 assert(s->type == SERVICE_ONESHOT);
1559 s->main_command = s->main_command->command_next;
1560 service_unwatch_main_pid(s);
1562 r = service_spawn(s,
1569 s->notify_access != NOTIFY_NONE,
1575 service_set_main_pid(s, pid);
1580 log_warning_unit(UNIT(s)->id,
1581 "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
1582 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1585 static int service_execute_action(Service *s, FailureAction action, const char *reason, bool log_action_none) {
1588 if (action == SERVICE_FAILURE_ACTION_REBOOT ||
1589 action == SERVICE_FAILURE_ACTION_REBOOT_FORCE)
1590 update_reboot_param_file(s->reboot_arg);
1594 case SERVICE_FAILURE_ACTION_NONE:
1595 if (log_action_none)
1596 log_warning_unit(UNIT(s)->id,
1597 "%s %s, refusing to start.", UNIT(s)->id, reason);
1600 case SERVICE_FAILURE_ACTION_REBOOT: {
1601 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1604 log_warning_unit(UNIT(s)->id,
1605 "%s %s, rebooting.", UNIT(s)->id, reason);
1607 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START,
1608 SPECIAL_REBOOT_TARGET, JOB_REPLACE,
1609 true, &error, NULL);
1611 log_error_unit(UNIT(s)->id,
1612 "Failed to reboot: %s.", bus_error_message(&error, r));
1617 case SERVICE_FAILURE_ACTION_REBOOT_FORCE:
1618 log_warning_unit(UNIT(s)->id,
1619 "%s %s, forcibly rebooting.", UNIT(s)->id, reason);
1620 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
1623 case SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE:
1624 log_warning_unit(UNIT(s)->id,
1625 "%s %s, rebooting immediately.", UNIT(s)->id, reason);
1627 if (s->reboot_arg) {
1628 log_info("Rebooting with argument '%s'.", s->reboot_arg);
1629 syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
1630 LINUX_REBOOT_CMD_RESTART2, s->reboot_arg);
1633 log_info("Rebooting.");
1634 reboot(RB_AUTOBOOT);
1638 log_error_unit(UNIT(s)->id,
1639 "failure action=%i", action);
1640 assert_not_reached("Unknown FailureAction.");
1646 static int service_start_limit_test(Service *s) {
1649 if (ratelimit_test(&s->start_limit))
1652 return service_execute_action(s, s->start_limit_action, "start request repeated too quickly", true);
1655 static int service_start(Unit *u) {
1656 Service *s = SERVICE(u);
1661 /* We cannot fulfill this request right now, try again later
1663 if (s->state == SERVICE_STOP ||
1664 s->state == SERVICE_STOP_SIGTERM ||
1665 s->state == SERVICE_STOP_SIGKILL ||
1666 s->state == SERVICE_STOP_POST ||
1667 s->state == SERVICE_FINAL_SIGTERM ||
1668 s->state == SERVICE_FINAL_SIGKILL)
1671 /* Already on it! */
1672 if (s->state == SERVICE_START_PRE ||
1673 s->state == SERVICE_START ||
1674 s->state == SERVICE_START_POST)
1677 /* A service that will be restarted must be stopped first to
1678 * trigger BindsTo and/or OnFailure dependencies. If a user
1679 * does not want to wait for the holdoff time to elapse, the
1680 * service should be manually restarted, not started. We
1681 * simply return EAGAIN here, so that any start jobs stay
1682 * queued, and assume that the auto restart timer will
1683 * eventually trigger the restart. */
1684 if (s->state == SERVICE_AUTO_RESTART)
1687 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1689 /* Make sure we don't enter a busy loop of some kind. */
1690 r = service_start_limit_test(s);
1692 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1696 s->result = SERVICE_SUCCESS;
1697 s->reload_result = SERVICE_SUCCESS;
1698 s->main_pid_known = false;
1699 s->main_pid_alien = false;
1700 s->forbid_restart = false;
1702 service_enter_start_pre(s);
1706 static int service_stop(Unit *u) {
1707 Service *s = SERVICE(u);
1711 /* Don't create restart jobs from here. */
1712 s->forbid_restart = true;
1715 if (s->state == SERVICE_STOP ||
1716 s->state == SERVICE_STOP_SIGTERM ||
1717 s->state == SERVICE_STOP_SIGKILL ||
1718 s->state == SERVICE_STOP_POST ||
1719 s->state == SERVICE_FINAL_SIGTERM ||
1720 s->state == SERVICE_FINAL_SIGKILL)
1723 /* A restart will be scheduled or is in progress. */
1724 if (s->state == SERVICE_AUTO_RESTART) {
1725 service_set_state(s, SERVICE_DEAD);
1729 /* If there's already something running we go directly into
1731 if (s->state == SERVICE_START_PRE ||
1732 s->state == SERVICE_START ||
1733 s->state == SERVICE_START_POST ||
1734 s->state == SERVICE_RELOAD) {
1735 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1739 assert(s->state == SERVICE_RUNNING ||
1740 s->state == SERVICE_EXITED);
1742 service_enter_stop(s, SERVICE_SUCCESS);
1746 static int service_reload(Unit *u) {
1747 Service *s = SERVICE(u);
1751 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1753 service_enter_reload(s);
1757 _pure_ static bool service_can_reload(Unit *u) {
1758 Service *s = SERVICE(u);
1762 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1765 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1766 Service *s = SERVICE(u);
1772 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1773 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1774 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1776 if (s->control_pid > 0)
1777 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1780 if (s->main_pid_known && s->main_pid > 0)
1781 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1783 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1786 unit_serialize_item(u, f, "status-text", s->status_text);
1788 /* FIXME: There's a minor uncleanliness here: if there are
1789 * multiple commands attached here, we will start from the
1790 * first one again */
1791 if (s->control_command_id >= 0)
1792 unit_serialize_item(u, f, "control-command",
1793 service_exec_command_to_string(s->control_command_id));
1795 if (s->socket_fd >= 0) {
1798 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
1801 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1804 if (s->main_exec_status.pid > 0) {
1805 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
1806 s->main_exec_status.pid);
1807 dual_timestamp_serialize(f, "main-exec-status-start",
1808 &s->main_exec_status.start_timestamp);
1809 dual_timestamp_serialize(f, "main-exec-status-exit",
1810 &s->main_exec_status.exit_timestamp);
1812 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1813 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
1814 s->main_exec_status.code);
1815 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
1816 s->main_exec_status.status);
1819 if (dual_timestamp_is_set(&s->watchdog_timestamp))
1820 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
1822 if (s->forbid_restart)
1823 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
1828 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1829 Service *s = SERVICE(u);
1836 if (streq(key, "state")) {
1839 state = service_state_from_string(value);
1841 log_debug_unit(u->id, "Failed to parse state value %s", value);
1843 s->deserialized_state = state;
1844 } else if (streq(key, "result")) {
1847 f = service_result_from_string(value);
1849 log_debug_unit(u->id, "Failed to parse result value %s", value);
1850 else if (f != SERVICE_SUCCESS)
1853 } else if (streq(key, "reload-result")) {
1856 f = service_result_from_string(value);
1858 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
1859 else if (f != SERVICE_SUCCESS)
1860 s->reload_result = f;
1862 } else if (streq(key, "control-pid")) {
1865 if (parse_pid(value, &pid) < 0)
1866 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1868 s->control_pid = pid;
1869 } else if (streq(key, "main-pid")) {
1872 if (parse_pid(value, &pid) < 0)
1873 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
1875 service_set_main_pid(s, pid);
1876 unit_watch_pid(UNIT(s), pid);
1878 } else if (streq(key, "main-pid-known")) {
1881 b = parse_boolean(value);
1883 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
1885 s->main_pid_known = b;
1886 } else if (streq(key, "status-text")) {
1893 free(s->status_text);
1897 } else if (streq(key, "control-command")) {
1898 ServiceExecCommand id;
1900 id = service_exec_command_from_string(value);
1902 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1904 s->control_command_id = id;
1905 s->control_command = s->exec_command[id];
1907 } else if (streq(key, "socket-fd")) {
1910 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1911 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
1914 asynchronous_close(s->socket_fd);
1915 s->socket_fd = fdset_remove(fds, fd);
1917 } else if (streq(key, "main-exec-status-pid")) {
1920 if (parse_pid(value, &pid) < 0)
1921 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
1923 s->main_exec_status.pid = pid;
1924 } else if (streq(key, "main-exec-status-code")) {
1927 if (safe_atoi(value, &i) < 0)
1928 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
1930 s->main_exec_status.code = i;
1931 } else if (streq(key, "main-exec-status-status")) {
1934 if (safe_atoi(value, &i) < 0)
1935 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
1937 s->main_exec_status.status = i;
1938 } else if (streq(key, "main-exec-status-start"))
1939 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
1940 else if (streq(key, "main-exec-status-exit"))
1941 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
1942 else if (streq(key, "watchdog-timestamp"))
1943 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
1944 else if (streq(key, "forbid-restart")) {
1947 b = parse_boolean(value);
1949 log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
1951 s->forbid_restart = b;
1953 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
1958 _pure_ static UnitActiveState service_active_state(Unit *u) {
1959 const UnitActiveState *table;
1963 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1965 return table[SERVICE(u)->state];
1968 static const char *service_sub_state_to_string(Unit *u) {
1971 return service_state_to_string(SERVICE(u)->state);
1974 static bool service_check_gc(Unit *u) {
1975 Service *s = SERVICE(u);
1979 /* Never clean up services that still have a process around,
1980 * even if the service is formally dead. */
1981 if (cgroup_good(s) > 0 ||
1982 main_pid_good(s) > 0 ||
1983 control_pid_good(s) > 0)
1989 _pure_ static bool service_check_snapshot(Unit *u) {
1990 Service *s = SERVICE(u);
1994 return (s->socket_fd < 0);
1997 static int service_retry_pid_file(Service *s) {
2000 assert(s->pid_file);
2001 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2003 r = service_load_pid_file(s, false);
2007 service_unwatch_pid_file(s);
2009 service_enter_running(s, SERVICE_SUCCESS);
2013 static int service_watch_pid_file(Service *s) {
2016 log_debug_unit(UNIT(s)->id,
2017 "Setting watch for %s's PID file %s",
2018 UNIT(s)->id, s->pid_file_pathspec->path);
2019 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2023 /* the pidfile might have appeared just before we set the watch */
2024 log_debug_unit(UNIT(s)->id,
2025 "Trying to read %s's PID file %s in case it changed",
2026 UNIT(s)->id, s->pid_file_pathspec->path);
2027 service_retry_pid_file(s);
2031 log_error_unit(UNIT(s)->id,
2032 "Failed to set a watch for %s's PID file %s: %s",
2033 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2034 service_unwatch_pid_file(s);
2038 static int service_demand_pid_file(Service *s) {
2041 assert(s->pid_file);
2042 assert(!s->pid_file_pathspec);
2044 ps = new0(PathSpec, 1);
2049 ps->path = strdup(s->pid_file);
2055 path_kill_slashes(ps->path);
2057 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2058 * keep their PID file open all the time. */
2059 ps->type = PATH_MODIFIED;
2060 ps->inotify_fd = -1;
2062 s->pid_file_pathspec = ps;
2064 return service_watch_pid_file(s);
2067 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2068 PathSpec *p = userdata;
2073 s = SERVICE(p->unit);
2077 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2078 assert(s->pid_file_pathspec);
2079 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2081 log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2083 if (path_spec_fd_event(p, events) < 0)
2086 if (service_retry_pid_file(s) == 0)
2089 if (service_watch_pid_file(s) < 0)
2095 service_unwatch_pid_file(s);
2096 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2100 static void service_notify_cgroup_empty_event(Unit *u) {
2101 Service *s = SERVICE(u);
2105 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
2109 /* Waiting for SIGCHLD is usually more interesting,
2110 * because it includes return codes/signals. Which is
2111 * why we ignore the cgroup events for most cases,
2112 * except when we don't know pid which to expect the
2116 case SERVICE_START_POST:
2117 /* If we were hoping for the daemon to write its PID file,
2118 * we can give up now. */
2119 if (s->pid_file_pathspec) {
2120 log_warning_unit(u->id,
2121 "%s never wrote its PID file. Failing.", UNIT(s)->id);
2122 service_unwatch_pid_file(s);
2123 if (s->state == SERVICE_START)
2124 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2126 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2130 case SERVICE_RUNNING:
2131 /* service_enter_running() will figure out what to do */
2132 service_enter_running(s, SERVICE_SUCCESS);
2135 case SERVICE_STOP_SIGTERM:
2136 case SERVICE_STOP_SIGKILL:
2138 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2139 service_enter_stop_post(s, SERVICE_SUCCESS);
2143 case SERVICE_STOP_POST:
2144 case SERVICE_FINAL_SIGTERM:
2145 case SERVICE_FINAL_SIGKILL:
2146 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2147 service_enter_dead(s, SERVICE_SUCCESS, true);
2156 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2157 Service *s = SERVICE(u);
2163 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2164 is_clean_exit_lsb(code, status, &s->success_status))
2165 f = SERVICE_SUCCESS;
2166 else if (code == CLD_EXITED)
2167 f = SERVICE_FAILURE_EXIT_CODE;
2168 else if (code == CLD_KILLED)
2169 f = SERVICE_FAILURE_SIGNAL;
2170 else if (code == CLD_DUMPED)
2171 f = SERVICE_FAILURE_CORE_DUMP;
2173 assert_not_reached("Unknown code");
2175 if (s->main_pid == pid) {
2176 /* Forking services may occasionally move to a new PID.
2177 * As long as they update the PID file before exiting the old
2178 * PID, they're fine. */
2179 if (service_load_pid_file(s, false) == 0)
2183 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2185 if (s->main_command) {
2186 /* If this is not a forking service than the
2187 * main process got started and hence we copy
2188 * the exit status so that it is recorded both
2189 * as main and as control process exit
2192 s->main_command->exec_status = s->main_exec_status;
2194 if (s->main_command->ignore)
2195 f = SERVICE_SUCCESS;
2196 } else if (s->exec_command[SERVICE_EXEC_START]) {
2198 /* If this is a forked process, then we should
2199 * ignore the return value if this was
2200 * configured for the starter process */
2202 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2203 f = SERVICE_SUCCESS;
2206 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2208 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2209 u->id, sigchld_code_to_string(code), status,
2210 strna(code == CLD_EXITED
2211 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2212 : signal_to_string(status)),
2213 "EXIT_CODE=%s", sigchld_code_to_string(code),
2214 "EXIT_STATUS=%i", status,
2217 if (f != SERVICE_SUCCESS)
2220 if (s->main_command &&
2221 s->main_command->command_next &&
2222 f == SERVICE_SUCCESS) {
2224 /* There is another command to *
2225 * execute, so let's do that. */
2227 log_debug_unit(u->id,
2228 "%s running next main command for state %s",
2229 u->id, service_state_to_string(s->state));
2230 service_run_next_main(s);
2234 /* The service exited, so the service is officially
2236 s->main_command = NULL;
2240 case SERVICE_START_POST:
2241 case SERVICE_RELOAD:
2243 /* Need to wait until the operation is
2248 if (s->type == SERVICE_ONESHOT) {
2249 /* This was our main goal, so let's go on */
2250 if (f == SERVICE_SUCCESS)
2251 service_enter_start_post(s);
2253 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2259 case SERVICE_RUNNING:
2260 service_enter_running(s, f);
2263 case SERVICE_STOP_SIGTERM:
2264 case SERVICE_STOP_SIGKILL:
2266 if (!control_pid_good(s))
2267 service_enter_stop_post(s, f);
2269 /* If there is still a control process, wait for that first */
2272 case SERVICE_STOP_POST:
2273 case SERVICE_FINAL_SIGTERM:
2274 case SERVICE_FINAL_SIGKILL:
2276 if (!control_pid_good(s))
2277 service_enter_dead(s, f, true);
2281 assert_not_reached("Uh, main process died at wrong time.");
2285 } else if (s->control_pid == pid) {
2288 if (s->control_command) {
2289 exec_status_exit(&s->control_command->exec_status,
2290 &s->exec_context, pid, code, status);
2292 if (s->control_command->ignore)
2293 f = SERVICE_SUCCESS;
2296 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
2297 "%s: control process exited, code=%s status=%i",
2298 u->id, sigchld_code_to_string(code), status);
2300 if (f != SERVICE_SUCCESS)
2303 /* Immediately get rid of the cgroup, so that the
2304 * kernel doesn't delay the cgroup empty messages for
2305 * the service cgroup any longer than necessary */
2306 service_kill_control_processes(s);
2308 if (s->control_command &&
2309 s->control_command->command_next &&
2310 f == SERVICE_SUCCESS) {
2312 /* There is another command to *
2313 * execute, so let's do that. */
2315 log_debug_unit(u->id,
2316 "%s running next control command for state %s",
2317 u->id, service_state_to_string(s->state));
2318 service_run_next_control(s);
2321 /* No further commands for this step, so let's
2322 * figure out what to do next */
2324 s->control_command = NULL;
2325 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2327 log_debug_unit(u->id,
2328 "%s got final SIGCHLD for state %s",
2329 u->id, service_state_to_string(s->state));
2333 case SERVICE_START_PRE:
2334 if (f == SERVICE_SUCCESS)
2335 service_enter_start(s);
2337 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2341 if (s->type != SERVICE_FORKING)
2342 /* Maybe spurious event due to a reload that changed the type? */
2345 if (f != SERVICE_SUCCESS) {
2346 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2351 bool has_start_post;
2354 /* Let's try to load the pid file here if we can.
2355 * The PID file might actually be created by a START_POST
2356 * script. In that case don't worry if the loading fails. */
2358 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2359 r = service_load_pid_file(s, !has_start_post);
2360 if (!has_start_post && r < 0) {
2361 r = service_demand_pid_file(s);
2362 if (r < 0 || !cgroup_good(s))
2363 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2367 service_search_main_pid(s);
2369 service_enter_start_post(s);
2372 case SERVICE_START_POST:
2373 if (f != SERVICE_SUCCESS) {
2374 service_enter_stop(s, f);
2381 r = service_load_pid_file(s, true);
2383 r = service_demand_pid_file(s);
2384 if (r < 0 || !cgroup_good(s))
2385 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2389 service_search_main_pid(s);
2391 service_enter_running(s, SERVICE_SUCCESS);
2394 case SERVICE_RELOAD:
2395 if (f == SERVICE_SUCCESS) {
2396 service_load_pid_file(s, true);
2397 service_search_main_pid(s);
2400 s->reload_result = f;
2401 service_enter_running(s, SERVICE_SUCCESS);
2405 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2408 case SERVICE_STOP_SIGTERM:
2409 case SERVICE_STOP_SIGKILL:
2410 if (main_pid_good(s) <= 0)
2411 service_enter_stop_post(s, f);
2413 /* If there is still a service
2414 * process around, wait until
2415 * that one quit, too */
2418 case SERVICE_STOP_POST:
2419 case SERVICE_FINAL_SIGTERM:
2420 case SERVICE_FINAL_SIGKILL:
2421 if (main_pid_good(s) <= 0)
2422 service_enter_dead(s, f, true);
2426 assert_not_reached("Uh, control process died at wrong time.");
2431 /* Notify clients about changed exit status */
2432 unit_add_to_dbus_queue(u);
2434 /* We got one SIGCHLD for the service, let's watch all
2435 * processes that are now running of the service, and watch
2436 * that. Among the PIDs we then watch will be children
2437 * reassigned to us, which hopefully allows us to identify
2438 * when all children are gone */
2439 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2440 unit_watch_all_pids(u);
2442 /* If the PID set is empty now, then let's finish this off */
2443 if (set_isempty(u->pids))
2444 service_notify_cgroup_empty_event(u);
2447 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2448 Service *s = SERVICE(userdata);
2451 assert(source == s->timer_event_source);
2455 case SERVICE_START_PRE:
2457 log_warning_unit(UNIT(s)->id,
2458 "%s %s operation timed out. Terminating.",
2460 s->state == SERVICE_START ? "start" : "start-pre");
2461 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2464 case SERVICE_START_POST:
2465 log_warning_unit(UNIT(s)->id,
2466 "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2467 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2470 case SERVICE_RELOAD:
2471 log_warning_unit(UNIT(s)->id,
2472 "%s reload operation timed out. Stopping.", UNIT(s)->id);
2473 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2474 service_enter_running(s, SERVICE_SUCCESS);
2478 log_warning_unit(UNIT(s)->id,
2479 "%s stopping timed out. Terminating.", UNIT(s)->id);
2480 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2483 case SERVICE_STOP_SIGTERM:
2484 if (s->kill_context.send_sigkill) {
2485 log_warning_unit(UNIT(s)->id,
2486 "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2487 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2489 log_warning_unit(UNIT(s)->id,
2490 "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2491 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2496 case SERVICE_STOP_SIGKILL:
2497 /* Uh, we sent a SIGKILL and it is still not gone?
2498 * Must be something we cannot kill, so let's just be
2499 * weirded out and continue */
2501 log_warning_unit(UNIT(s)->id,
2502 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2503 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2506 case SERVICE_STOP_POST:
2507 log_warning_unit(UNIT(s)->id,
2508 "%s stop-post timed out. Terminating.", UNIT(s)->id);
2509 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2512 case SERVICE_FINAL_SIGTERM:
2513 if (s->kill_context.send_sigkill) {
2514 log_warning_unit(UNIT(s)->id,
2515 "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2516 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2518 log_warning_unit(UNIT(s)->id,
2519 "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.",
2521 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2526 case SERVICE_FINAL_SIGKILL:
2527 log_warning_unit(UNIT(s)->id,
2528 "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2529 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2532 case SERVICE_AUTO_RESTART:
2533 log_info_unit(UNIT(s)->id,
2534 s->restart_usec > 0 ?
2535 "%s holdoff time over, scheduling restart." :
2536 "%s has no holdoff time, scheduling restart.",
2538 service_enter_restart(s);
2542 assert_not_reached("Timeout at wrong time.");
2548 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2549 Service *s = SERVICE(userdata);
2552 assert(source == s->watchdog_event_source);
2554 log_error_unit(UNIT(s)->id, "%s watchdog timeout!", UNIT(s)->id);
2555 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
2560 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
2561 Service *s = SERVICE(u);
2563 bool notify_dbus = false;
2567 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s...)",
2568 u->id, pid, tags && *tags ? tags[0] : "(empty)");
2570 if (s->notify_access == NOTIFY_NONE) {
2571 log_warning_unit(u->id,
2572 "%s: Got notification message from PID "PID_FMT", but reception is disabled.",
2577 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2579 if (s->main_pid != 0)
2580 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);
2582 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);
2586 /* Interpret MAINPID= */
2587 if ((e = strv_find_prefix(tags, "MAINPID=")) &&
2588 (s->state == SERVICE_START ||
2589 s->state == SERVICE_START_POST ||
2590 s->state == SERVICE_RUNNING ||
2591 s->state == SERVICE_RELOAD)) {
2593 if (parse_pid(e + 8, &pid) < 0)
2594 log_warning_unit(u->id, "Failed to parse notification message %s", e);
2596 log_debug_unit(u->id, "%s: got %s", u->id, e);
2597 service_set_main_pid(s, pid);
2598 unit_watch_pid(UNIT(s), pid);
2603 /* Interpret READY= */
2604 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START && strv_find(tags, "READY=1")) {
2605 log_debug_unit(u->id, "%s: got READY=1", u->id);
2606 service_enter_start_post(s);
2610 /* Interpret STATUS= */
2611 e = strv_find_prefix(tags, "STATUS=");
2616 if (!utf8_is_valid(e+7)) {
2617 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
2621 log_debug_unit(u->id, "%s: got %s", u->id, e);
2632 if (!streq_ptr(s->status_text, t)) {
2633 free(s->status_text);
2640 /* Interpret WATCHDOG= */
2641 if (strv_find(tags, "WATCHDOG=1")) {
2642 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
2643 service_reset_watchdog(s);
2646 /* Notify clients about changed status or main pid */
2648 unit_add_to_dbus_queue(u);
2651 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2652 Service *s = SERVICE(u);
2655 if (!s->timer_event_source)
2658 r = sd_event_source_get_time(s->timer_event_source, timeout);
2665 static void service_bus_name_owner_change(
2668 const char *old_owner,
2669 const char *new_owner) {
2671 Service *s = SERVICE(u);
2677 assert(streq(s->bus_name, name));
2678 assert(old_owner || new_owner);
2680 if (old_owner && new_owner)
2681 log_debug_unit(u->id,
2682 "%s's D-Bus name %s changed owner from %s to %s",
2683 u->id, name, old_owner, new_owner);
2685 log_debug_unit(u->id,
2686 "%s's D-Bus name %s no longer registered by %s",
2687 u->id, name, old_owner);
2689 log_debug_unit(u->id,
2690 "%s's D-Bus name %s now registered by %s",
2691 u->id, name, new_owner);
2693 s->bus_name_good = !!new_owner;
2695 if (s->type == SERVICE_DBUS) {
2697 /* service_enter_running() will figure out what to
2699 if (s->state == SERVICE_RUNNING)
2700 service_enter_running(s, SERVICE_SUCCESS);
2701 else if (s->state == SERVICE_START && new_owner)
2702 service_enter_start_post(s);
2704 } else if (new_owner &&
2706 (s->state == SERVICE_START ||
2707 s->state == SERVICE_START_POST ||
2708 s->state == SERVICE_RUNNING ||
2709 s->state == SERVICE_RELOAD)) {
2711 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2714 /* Try to acquire PID from bus service */
2716 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2718 r = sd_bus_creds_get_pid(creds, &pid);
2720 log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2722 service_set_main_pid(s, pid);
2723 unit_watch_pid(UNIT(s), pid);
2728 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
2729 _cleanup_free_ char *peer = NULL;
2735 /* This is called by the socket code when instantiating a new
2736 * service for a stream socket and the socket needs to be
2739 if (UNIT(s)->load_state != UNIT_LOADED)
2742 if (s->socket_fd >= 0)
2745 if (s->state != SERVICE_DEAD)
2748 if (getpeername_pretty(fd, &peer) >= 0) {
2750 if (UNIT(s)->description) {
2751 _cleanup_free_ char *a;
2753 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
2757 r = unit_set_description(UNIT(s), a);
2759 r = unit_set_description(UNIT(s), peer);
2767 unit_ref_set(&s->accept_socket, UNIT(sock));
2769 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
2772 static void service_reset_failed(Unit *u) {
2773 Service *s = SERVICE(u);
2777 if (s->state == SERVICE_FAILED)
2778 service_set_state(s, SERVICE_DEAD);
2780 s->result = SERVICE_SUCCESS;
2781 s->reload_result = SERVICE_SUCCESS;
2783 RATELIMIT_RESET(s->start_limit);
2786 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2787 Service *s = SERVICE(u);
2789 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
2792 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
2793 [SERVICE_DEAD] = "dead",
2794 [SERVICE_START_PRE] = "start-pre",
2795 [SERVICE_START] = "start",
2796 [SERVICE_START_POST] = "start-post",
2797 [SERVICE_RUNNING] = "running",
2798 [SERVICE_EXITED] = "exited",
2799 [SERVICE_RELOAD] = "reload",
2800 [SERVICE_STOP] = "stop",
2801 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
2802 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
2803 [SERVICE_STOP_POST] = "stop-post",
2804 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
2805 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
2806 [SERVICE_FAILED] = "failed",
2807 [SERVICE_AUTO_RESTART] = "auto-restart",
2810 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
2812 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
2813 [SERVICE_RESTART_NO] = "no",
2814 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
2815 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
2816 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
2817 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
2818 [SERVICE_RESTART_ON_ABORT] = "on-abort",
2819 [SERVICE_RESTART_ALWAYS] = "always",
2822 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
2824 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
2825 [SERVICE_SIMPLE] = "simple",
2826 [SERVICE_FORKING] = "forking",
2827 [SERVICE_ONESHOT] = "oneshot",
2828 [SERVICE_DBUS] = "dbus",
2829 [SERVICE_NOTIFY] = "notify",
2830 [SERVICE_IDLE] = "idle"
2833 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
2835 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
2836 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
2837 [SERVICE_EXEC_START] = "ExecStart",
2838 [SERVICE_EXEC_START_POST] = "ExecStartPost",
2839 [SERVICE_EXEC_RELOAD] = "ExecReload",
2840 [SERVICE_EXEC_STOP] = "ExecStop",
2841 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
2844 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
2846 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
2847 [NOTIFY_NONE] = "none",
2848 [NOTIFY_MAIN] = "main",
2849 [NOTIFY_ALL] = "all"
2852 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
2854 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
2855 [SERVICE_SUCCESS] = "success",
2856 [SERVICE_FAILURE_RESOURCES] = "resources",
2857 [SERVICE_FAILURE_TIMEOUT] = "timeout",
2858 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
2859 [SERVICE_FAILURE_SIGNAL] = "signal",
2860 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
2861 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
2862 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
2865 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
2867 static const char* const failure_action_table[_SERVICE_FAILURE_ACTION_MAX] = {
2868 [SERVICE_FAILURE_ACTION_NONE] = "none",
2869 [SERVICE_FAILURE_ACTION_REBOOT] = "reboot",
2870 [SERVICE_FAILURE_ACTION_REBOOT_FORCE] = "reboot-force",
2871 [SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE] = "reboot-immediate"
2873 DEFINE_STRING_TABLE_LOOKUP(failure_action, FailureAction);
2875 const UnitVTable service_vtable = {
2876 .object_size = sizeof(Service),
2877 .exec_context_offset = offsetof(Service, exec_context),
2878 .cgroup_context_offset = offsetof(Service, cgroup_context),
2879 .kill_context_offset = offsetof(Service, kill_context),
2880 .exec_runtime_offset = offsetof(Service, exec_runtime),
2886 .private_section = "Service",
2888 .init = service_init,
2889 .done = service_done,
2890 .load = service_load,
2892 .coldplug = service_coldplug,
2894 .dump = service_dump,
2896 .start = service_start,
2897 .stop = service_stop,
2898 .reload = service_reload,
2900 .can_reload = service_can_reload,
2902 .kill = service_kill,
2904 .serialize = service_serialize,
2905 .deserialize_item = service_deserialize_item,
2907 .active_state = service_active_state,
2908 .sub_state_to_string = service_sub_state_to_string,
2910 .check_gc = service_check_gc,
2911 .check_snapshot = service_check_snapshot,
2913 .sigchld_event = service_sigchld_event,
2915 .reset_failed = service_reset_failed,
2917 .notify_cgroup_empty = service_notify_cgroup_empty_event,
2918 .notify_message = service_notify_message,
2920 .bus_name_owner_change = service_bus_name_owner_change,
2922 .bus_interface = "org.freedesktop.systemd1.Service",
2923 .bus_vtable = bus_service_vtable,
2924 .bus_set_property = bus_service_set_property,
2925 .bus_commit_properties = bus_service_commit_properties,
2927 .get_timeout = service_get_timeout,
2928 .can_transient = true,
2930 .status_message_formats = {
2931 .starting_stopping = {
2932 [0] = "Starting %s...",
2933 [1] = "Stopping %s...",
2935 .finished_start_job = {
2936 [JOB_DONE] = "Started %s.",
2937 [JOB_FAILED] = "Failed to start %s.",
2938 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2939 [JOB_TIMEOUT] = "Timed out starting %s.",
2941 .finished_stop_job = {
2942 [JOB_DONE] = "Stopped %s.",
2943 [JOB_FAILED] = "Stopped (with error) %s.",
2944 [JOB_TIMEOUT] = "Timed out stopping %s.",