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 free(s->status_text);
1703 s->status_text = NULL;
1704 s->status_errno = 0;
1706 service_enter_start_pre(s);
1710 static int service_stop(Unit *u) {
1711 Service *s = SERVICE(u);
1715 /* Don't create restart jobs from here. */
1716 s->forbid_restart = true;
1719 if (s->state == SERVICE_STOP ||
1720 s->state == SERVICE_STOP_SIGTERM ||
1721 s->state == SERVICE_STOP_SIGKILL ||
1722 s->state == SERVICE_STOP_POST ||
1723 s->state == SERVICE_FINAL_SIGTERM ||
1724 s->state == SERVICE_FINAL_SIGKILL)
1727 /* A restart will be scheduled or is in progress. */
1728 if (s->state == SERVICE_AUTO_RESTART) {
1729 service_set_state(s, SERVICE_DEAD);
1733 /* If there's already something running we go directly into
1735 if (s->state == SERVICE_START_PRE ||
1736 s->state == SERVICE_START ||
1737 s->state == SERVICE_START_POST ||
1738 s->state == SERVICE_RELOAD) {
1739 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1743 assert(s->state == SERVICE_RUNNING ||
1744 s->state == SERVICE_EXITED);
1746 service_enter_stop(s, SERVICE_SUCCESS);
1750 static int service_reload(Unit *u) {
1751 Service *s = SERVICE(u);
1755 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1757 service_enter_reload(s);
1761 _pure_ static bool service_can_reload(Unit *u) {
1762 Service *s = SERVICE(u);
1766 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1769 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1770 Service *s = SERVICE(u);
1776 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1777 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1778 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1780 if (s->control_pid > 0)
1781 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1784 if (s->main_pid_known && s->main_pid > 0)
1785 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1787 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1790 unit_serialize_item(u, f, "status-text", s->status_text);
1792 /* FIXME: There's a minor uncleanliness here: if there are
1793 * multiple commands attached here, we will start from the
1794 * first one again */
1795 if (s->control_command_id >= 0)
1796 unit_serialize_item(u, f, "control-command",
1797 service_exec_command_to_string(s->control_command_id));
1799 if (s->socket_fd >= 0) {
1802 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
1805 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1808 if (s->main_exec_status.pid > 0) {
1809 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
1810 s->main_exec_status.pid);
1811 dual_timestamp_serialize(f, "main-exec-status-start",
1812 &s->main_exec_status.start_timestamp);
1813 dual_timestamp_serialize(f, "main-exec-status-exit",
1814 &s->main_exec_status.exit_timestamp);
1816 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1817 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
1818 s->main_exec_status.code);
1819 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
1820 s->main_exec_status.status);
1823 if (dual_timestamp_is_set(&s->watchdog_timestamp))
1824 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
1826 if (s->forbid_restart)
1827 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
1832 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1833 Service *s = SERVICE(u);
1840 if (streq(key, "state")) {
1843 state = service_state_from_string(value);
1845 log_debug_unit(u->id, "Failed to parse state value %s", value);
1847 s->deserialized_state = state;
1848 } else if (streq(key, "result")) {
1851 f = service_result_from_string(value);
1853 log_debug_unit(u->id, "Failed to parse result value %s", value);
1854 else if (f != SERVICE_SUCCESS)
1857 } else if (streq(key, "reload-result")) {
1860 f = service_result_from_string(value);
1862 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
1863 else if (f != SERVICE_SUCCESS)
1864 s->reload_result = f;
1866 } else if (streq(key, "control-pid")) {
1869 if (parse_pid(value, &pid) < 0)
1870 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1872 s->control_pid = pid;
1873 } else if (streq(key, "main-pid")) {
1876 if (parse_pid(value, &pid) < 0)
1877 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
1879 service_set_main_pid(s, pid);
1880 unit_watch_pid(UNIT(s), pid);
1882 } else if (streq(key, "main-pid-known")) {
1885 b = parse_boolean(value);
1887 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
1889 s->main_pid_known = b;
1890 } else if (streq(key, "status-text")) {
1897 free(s->status_text);
1901 } else if (streq(key, "control-command")) {
1902 ServiceExecCommand id;
1904 id = service_exec_command_from_string(value);
1906 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1908 s->control_command_id = id;
1909 s->control_command = s->exec_command[id];
1911 } else if (streq(key, "socket-fd")) {
1914 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1915 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
1918 asynchronous_close(s->socket_fd);
1919 s->socket_fd = fdset_remove(fds, fd);
1921 } else if (streq(key, "main-exec-status-pid")) {
1924 if (parse_pid(value, &pid) < 0)
1925 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
1927 s->main_exec_status.pid = pid;
1928 } else if (streq(key, "main-exec-status-code")) {
1931 if (safe_atoi(value, &i) < 0)
1932 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
1934 s->main_exec_status.code = i;
1935 } else if (streq(key, "main-exec-status-status")) {
1938 if (safe_atoi(value, &i) < 0)
1939 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
1941 s->main_exec_status.status = i;
1942 } else if (streq(key, "main-exec-status-start"))
1943 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
1944 else if (streq(key, "main-exec-status-exit"))
1945 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
1946 else if (streq(key, "watchdog-timestamp"))
1947 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
1948 else if (streq(key, "forbid-restart")) {
1951 b = parse_boolean(value);
1953 log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
1955 s->forbid_restart = b;
1957 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
1962 _pure_ static UnitActiveState service_active_state(Unit *u) {
1963 const UnitActiveState *table;
1967 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1969 return table[SERVICE(u)->state];
1972 static const char *service_sub_state_to_string(Unit *u) {
1975 return service_state_to_string(SERVICE(u)->state);
1978 static bool service_check_gc(Unit *u) {
1979 Service *s = SERVICE(u);
1983 /* Never clean up services that still have a process around,
1984 * even if the service is formally dead. */
1985 if (cgroup_good(s) > 0 ||
1986 main_pid_good(s) > 0 ||
1987 control_pid_good(s) > 0)
1993 _pure_ static bool service_check_snapshot(Unit *u) {
1994 Service *s = SERVICE(u);
1998 return (s->socket_fd < 0);
2001 static int service_retry_pid_file(Service *s) {
2004 assert(s->pid_file);
2005 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2007 r = service_load_pid_file(s, false);
2011 service_unwatch_pid_file(s);
2013 service_enter_running(s, SERVICE_SUCCESS);
2017 static int service_watch_pid_file(Service *s) {
2020 log_debug_unit(UNIT(s)->id,
2021 "Setting watch for %s's PID file %s",
2022 UNIT(s)->id, s->pid_file_pathspec->path);
2023 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2027 /* the pidfile might have appeared just before we set the watch */
2028 log_debug_unit(UNIT(s)->id,
2029 "Trying to read %s's PID file %s in case it changed",
2030 UNIT(s)->id, s->pid_file_pathspec->path);
2031 service_retry_pid_file(s);
2035 log_error_unit(UNIT(s)->id,
2036 "Failed to set a watch for %s's PID file %s: %s",
2037 UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2038 service_unwatch_pid_file(s);
2042 static int service_demand_pid_file(Service *s) {
2045 assert(s->pid_file);
2046 assert(!s->pid_file_pathspec);
2048 ps = new0(PathSpec, 1);
2053 ps->path = strdup(s->pid_file);
2059 path_kill_slashes(ps->path);
2061 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2062 * keep their PID file open all the time. */
2063 ps->type = PATH_MODIFIED;
2064 ps->inotify_fd = -1;
2066 s->pid_file_pathspec = ps;
2068 return service_watch_pid_file(s);
2071 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2072 PathSpec *p = userdata;
2077 s = SERVICE(p->unit);
2081 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2082 assert(s->pid_file_pathspec);
2083 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2085 log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2087 if (path_spec_fd_event(p, events) < 0)
2090 if (service_retry_pid_file(s) == 0)
2093 if (service_watch_pid_file(s) < 0)
2099 service_unwatch_pid_file(s);
2100 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2104 static void service_notify_cgroup_empty_event(Unit *u) {
2105 Service *s = SERVICE(u);
2109 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
2113 /* Waiting for SIGCHLD is usually more interesting,
2114 * because it includes return codes/signals. Which is
2115 * why we ignore the cgroup events for most cases,
2116 * except when we don't know pid which to expect the
2120 case SERVICE_START_POST:
2121 /* If we were hoping for the daemon to write its PID file,
2122 * we can give up now. */
2123 if (s->pid_file_pathspec) {
2124 log_warning_unit(u->id,
2125 "%s never wrote its PID file. Failing.", UNIT(s)->id);
2126 service_unwatch_pid_file(s);
2127 if (s->state == SERVICE_START)
2128 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2130 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2134 case SERVICE_RUNNING:
2135 /* service_enter_running() will figure out what to do */
2136 service_enter_running(s, SERVICE_SUCCESS);
2139 case SERVICE_STOP_SIGTERM:
2140 case SERVICE_STOP_SIGKILL:
2142 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2143 service_enter_stop_post(s, SERVICE_SUCCESS);
2147 case SERVICE_STOP_POST:
2148 case SERVICE_FINAL_SIGTERM:
2149 case SERVICE_FINAL_SIGKILL:
2150 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2151 service_enter_dead(s, SERVICE_SUCCESS, true);
2160 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2161 Service *s = SERVICE(u);
2167 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2168 is_clean_exit_lsb(code, status, &s->success_status))
2169 f = SERVICE_SUCCESS;
2170 else if (code == CLD_EXITED)
2171 f = SERVICE_FAILURE_EXIT_CODE;
2172 else if (code == CLD_KILLED)
2173 f = SERVICE_FAILURE_SIGNAL;
2174 else if (code == CLD_DUMPED)
2175 f = SERVICE_FAILURE_CORE_DUMP;
2177 assert_not_reached("Unknown code");
2179 if (s->main_pid == pid) {
2180 /* Forking services may occasionally move to a new PID.
2181 * As long as they update the PID file before exiting the old
2182 * PID, they're fine. */
2183 if (service_load_pid_file(s, false) == 0)
2187 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2189 if (s->main_command) {
2190 /* If this is not a forking service than the
2191 * main process got started and hence we copy
2192 * the exit status so that it is recorded both
2193 * as main and as control process exit
2196 s->main_command->exec_status = s->main_exec_status;
2198 if (s->main_command->ignore)
2199 f = SERVICE_SUCCESS;
2200 } else if (s->exec_command[SERVICE_EXEC_START]) {
2202 /* If this is a forked process, then we should
2203 * ignore the return value if this was
2204 * configured for the starter process */
2206 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2207 f = SERVICE_SUCCESS;
2210 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2212 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2213 u->id, sigchld_code_to_string(code), status,
2214 strna(code == CLD_EXITED
2215 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2216 : signal_to_string(status)),
2217 "EXIT_CODE=%s", sigchld_code_to_string(code),
2218 "EXIT_STATUS=%i", status,
2221 if (f != SERVICE_SUCCESS)
2224 if (s->main_command &&
2225 s->main_command->command_next &&
2226 f == SERVICE_SUCCESS) {
2228 /* There is another command to *
2229 * execute, so let's do that. */
2231 log_debug_unit(u->id,
2232 "%s running next main command for state %s",
2233 u->id, service_state_to_string(s->state));
2234 service_run_next_main(s);
2238 /* The service exited, so the service is officially
2240 s->main_command = NULL;
2244 case SERVICE_START_POST:
2245 case SERVICE_RELOAD:
2247 /* Need to wait until the operation is
2252 if (s->type == SERVICE_ONESHOT) {
2253 /* This was our main goal, so let's go on */
2254 if (f == SERVICE_SUCCESS)
2255 service_enter_start_post(s);
2257 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2263 case SERVICE_RUNNING:
2264 service_enter_running(s, f);
2267 case SERVICE_STOP_SIGTERM:
2268 case SERVICE_STOP_SIGKILL:
2270 if (!control_pid_good(s))
2271 service_enter_stop_post(s, f);
2273 /* If there is still a control process, wait for that first */
2276 case SERVICE_STOP_POST:
2277 case SERVICE_FINAL_SIGTERM:
2278 case SERVICE_FINAL_SIGKILL:
2280 if (!control_pid_good(s))
2281 service_enter_dead(s, f, true);
2285 assert_not_reached("Uh, main process died at wrong time.");
2289 } else if (s->control_pid == pid) {
2292 if (s->control_command) {
2293 exec_status_exit(&s->control_command->exec_status,
2294 &s->exec_context, pid, code, status);
2296 if (s->control_command->ignore)
2297 f = SERVICE_SUCCESS;
2300 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
2301 "%s: control process exited, code=%s status=%i",
2302 u->id, sigchld_code_to_string(code), status);
2304 if (f != SERVICE_SUCCESS)
2307 /* Immediately get rid of the cgroup, so that the
2308 * kernel doesn't delay the cgroup empty messages for
2309 * the service cgroup any longer than necessary */
2310 service_kill_control_processes(s);
2312 if (s->control_command &&
2313 s->control_command->command_next &&
2314 f == SERVICE_SUCCESS) {
2316 /* There is another command to *
2317 * execute, so let's do that. */
2319 log_debug_unit(u->id,
2320 "%s running next control command for state %s",
2321 u->id, service_state_to_string(s->state));
2322 service_run_next_control(s);
2325 /* No further commands for this step, so let's
2326 * figure out what to do next */
2328 s->control_command = NULL;
2329 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2331 log_debug_unit(u->id,
2332 "%s got final SIGCHLD for state %s",
2333 u->id, service_state_to_string(s->state));
2337 case SERVICE_START_PRE:
2338 if (f == SERVICE_SUCCESS)
2339 service_enter_start(s);
2341 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2345 if (s->type != SERVICE_FORKING)
2346 /* Maybe spurious event due to a reload that changed the type? */
2349 if (f != SERVICE_SUCCESS) {
2350 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2355 bool has_start_post;
2358 /* Let's try to load the pid file here if we can.
2359 * The PID file might actually be created by a START_POST
2360 * script. In that case don't worry if the loading fails. */
2362 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2363 r = service_load_pid_file(s, !has_start_post);
2364 if (!has_start_post && r < 0) {
2365 r = service_demand_pid_file(s);
2366 if (r < 0 || !cgroup_good(s))
2367 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2371 service_search_main_pid(s);
2373 service_enter_start_post(s);
2376 case SERVICE_START_POST:
2377 if (f != SERVICE_SUCCESS) {
2378 service_enter_stop(s, f);
2385 r = service_load_pid_file(s, true);
2387 r = service_demand_pid_file(s);
2388 if (r < 0 || !cgroup_good(s))
2389 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2393 service_search_main_pid(s);
2395 service_enter_running(s, SERVICE_SUCCESS);
2398 case SERVICE_RELOAD:
2399 if (f == SERVICE_SUCCESS) {
2400 service_load_pid_file(s, true);
2401 service_search_main_pid(s);
2404 s->reload_result = f;
2405 service_enter_running(s, SERVICE_SUCCESS);
2409 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2412 case SERVICE_STOP_SIGTERM:
2413 case SERVICE_STOP_SIGKILL:
2414 if (main_pid_good(s) <= 0)
2415 service_enter_stop_post(s, f);
2417 /* If there is still a service
2418 * process around, wait until
2419 * that one quit, too */
2422 case SERVICE_STOP_POST:
2423 case SERVICE_FINAL_SIGTERM:
2424 case SERVICE_FINAL_SIGKILL:
2425 if (main_pid_good(s) <= 0)
2426 service_enter_dead(s, f, true);
2430 assert_not_reached("Uh, control process died at wrong time.");
2435 /* Notify clients about changed exit status */
2436 unit_add_to_dbus_queue(u);
2438 /* We got one SIGCHLD for the service, let's watch all
2439 * processes that are now running of the service, and watch
2440 * that. Among the PIDs we then watch will be children
2441 * reassigned to us, which hopefully allows us to identify
2442 * when all children are gone */
2443 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2444 unit_watch_all_pids(u);
2446 /* If the PID set is empty now, then let's finish this off */
2447 if (set_isempty(u->pids))
2448 service_notify_cgroup_empty_event(u);
2451 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2452 Service *s = SERVICE(userdata);
2455 assert(source == s->timer_event_source);
2459 case SERVICE_START_PRE:
2461 log_warning_unit(UNIT(s)->id,
2462 "%s %s operation timed out. Terminating.",
2464 s->state == SERVICE_START ? "start" : "start-pre");
2465 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2468 case SERVICE_START_POST:
2469 log_warning_unit(UNIT(s)->id,
2470 "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2471 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2474 case SERVICE_RELOAD:
2475 log_warning_unit(UNIT(s)->id,
2476 "%s reload operation timed out. Stopping.", UNIT(s)->id);
2477 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2478 service_enter_running(s, SERVICE_SUCCESS);
2482 log_warning_unit(UNIT(s)->id,
2483 "%s stopping timed out. Terminating.", UNIT(s)->id);
2484 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2487 case SERVICE_STOP_SIGTERM:
2488 if (s->kill_context.send_sigkill) {
2489 log_warning_unit(UNIT(s)->id,
2490 "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2491 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2493 log_warning_unit(UNIT(s)->id,
2494 "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2495 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2500 case SERVICE_STOP_SIGKILL:
2501 /* Uh, we sent a SIGKILL and it is still not gone?
2502 * Must be something we cannot kill, so let's just be
2503 * weirded out and continue */
2505 log_warning_unit(UNIT(s)->id,
2506 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2507 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2510 case SERVICE_STOP_POST:
2511 log_warning_unit(UNIT(s)->id,
2512 "%s stop-post timed out. Terminating.", UNIT(s)->id);
2513 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2516 case SERVICE_FINAL_SIGTERM:
2517 if (s->kill_context.send_sigkill) {
2518 log_warning_unit(UNIT(s)->id,
2519 "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2520 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2522 log_warning_unit(UNIT(s)->id,
2523 "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.",
2525 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2530 case SERVICE_FINAL_SIGKILL:
2531 log_warning_unit(UNIT(s)->id,
2532 "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2533 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2536 case SERVICE_AUTO_RESTART:
2537 log_info_unit(UNIT(s)->id,
2538 s->restart_usec > 0 ?
2539 "%s holdoff time over, scheduling restart." :
2540 "%s has no holdoff time, scheduling restart.",
2542 service_enter_restart(s);
2546 assert_not_reached("Timeout at wrong time.");
2552 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2553 Service *s = SERVICE(userdata);
2554 char t[FORMAT_TIMESPAN_MAX];
2557 assert(source == s->watchdog_event_source);
2559 log_error_unit(UNIT(s)->id,
2560 "%s watchdog timeout (limit %s)!",
2562 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2563 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
2568 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
2569 Service *s = SERVICE(u);
2571 bool notify_dbus = false;
2575 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s...)",
2576 u->id, pid, tags && *tags ? tags[0] : "(empty)");
2578 if (s->notify_access == NOTIFY_NONE) {
2579 log_warning_unit(u->id,
2580 "%s: Got notification message from PID "PID_FMT", but reception is disabled.",
2585 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2586 if (s->main_pid != 0)
2587 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);
2589 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);
2593 /* Interpret MAINPID= */
2594 e = strv_find_prefix(tags, "MAINPID=");
2595 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2596 if (parse_pid(e + 8, &pid) < 0)
2597 log_warning_unit(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2599 log_debug_unit(u->id, "%s: got %s", u->id, e);
2600 service_set_main_pid(s, pid);
2601 unit_watch_pid(UNIT(s), pid);
2606 /* Interpret READY= */
2607 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START && strv_find(tags, "READY=1")) {
2608 log_debug_unit(u->id, "%s: got READY=1", u->id);
2609 service_enter_start_post(s);
2613 /* Interpret STATUS= */
2614 e = strv_find_prefix(tags, "STATUS=");
2619 if (!utf8_is_valid(e+7)) {
2620 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
2624 log_debug_unit(u->id, "%s: got %s", u->id, e);
2635 if (!streq_ptr(s->status_text, t)) {
2636 free(s->status_text);
2643 /* Interpret ERRNO= */
2644 e = strv_find_prefix(tags, "ERRNO=");
2648 if (safe_atoi(e + 6, &status_errno) < 0 || status_errno < 0)
2649 log_warning_unit(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2651 log_debug_unit(u->id, "%s: got %s", u->id, e);
2653 if (s->status_errno != status_errno) {
2654 s->status_errno = status_errno;
2660 /* Interpret WATCHDOG= */
2661 if (strv_find(tags, "WATCHDOG=1")) {
2662 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
2663 service_reset_watchdog(s);
2666 /* Notify clients about changed status or main pid */
2668 unit_add_to_dbus_queue(u);
2671 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2672 Service *s = SERVICE(u);
2675 if (!s->timer_event_source)
2678 r = sd_event_source_get_time(s->timer_event_source, timeout);
2685 static void service_bus_name_owner_change(
2688 const char *old_owner,
2689 const char *new_owner) {
2691 Service *s = SERVICE(u);
2697 assert(streq(s->bus_name, name));
2698 assert(old_owner || new_owner);
2700 if (old_owner && new_owner)
2701 log_debug_unit(u->id,
2702 "%s's D-Bus name %s changed owner from %s to %s",
2703 u->id, name, old_owner, new_owner);
2705 log_debug_unit(u->id,
2706 "%s's D-Bus name %s no longer registered by %s",
2707 u->id, name, old_owner);
2709 log_debug_unit(u->id,
2710 "%s's D-Bus name %s now registered by %s",
2711 u->id, name, new_owner);
2713 s->bus_name_good = !!new_owner;
2715 if (s->type == SERVICE_DBUS) {
2717 /* service_enter_running() will figure out what to
2719 if (s->state == SERVICE_RUNNING)
2720 service_enter_running(s, SERVICE_SUCCESS);
2721 else if (s->state == SERVICE_START && new_owner)
2722 service_enter_start_post(s);
2724 } else if (new_owner &&
2726 (s->state == SERVICE_START ||
2727 s->state == SERVICE_START_POST ||
2728 s->state == SERVICE_RUNNING ||
2729 s->state == SERVICE_RELOAD)) {
2731 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2734 /* Try to acquire PID from bus service */
2736 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2738 r = sd_bus_creds_get_pid(creds, &pid);
2740 log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2742 service_set_main_pid(s, pid);
2743 unit_watch_pid(UNIT(s), pid);
2748 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
2749 _cleanup_free_ char *peer = NULL;
2755 /* This is called by the socket code when instantiating a new
2756 * service for a stream socket and the socket needs to be
2759 if (UNIT(s)->load_state != UNIT_LOADED)
2762 if (s->socket_fd >= 0)
2765 if (s->state != SERVICE_DEAD)
2768 if (getpeername_pretty(fd, &peer) >= 0) {
2770 if (UNIT(s)->description) {
2771 _cleanup_free_ char *a;
2773 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
2777 r = unit_set_description(UNIT(s), a);
2779 r = unit_set_description(UNIT(s), peer);
2787 unit_ref_set(&s->accept_socket, UNIT(sock));
2789 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
2792 static void service_reset_failed(Unit *u) {
2793 Service *s = SERVICE(u);
2797 if (s->state == SERVICE_FAILED)
2798 service_set_state(s, SERVICE_DEAD);
2800 s->result = SERVICE_SUCCESS;
2801 s->reload_result = SERVICE_SUCCESS;
2803 RATELIMIT_RESET(s->start_limit);
2806 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2807 Service *s = SERVICE(u);
2809 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
2812 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
2813 [SERVICE_DEAD] = "dead",
2814 [SERVICE_START_PRE] = "start-pre",
2815 [SERVICE_START] = "start",
2816 [SERVICE_START_POST] = "start-post",
2817 [SERVICE_RUNNING] = "running",
2818 [SERVICE_EXITED] = "exited",
2819 [SERVICE_RELOAD] = "reload",
2820 [SERVICE_STOP] = "stop",
2821 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
2822 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
2823 [SERVICE_STOP_POST] = "stop-post",
2824 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
2825 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
2826 [SERVICE_FAILED] = "failed",
2827 [SERVICE_AUTO_RESTART] = "auto-restart",
2830 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
2832 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
2833 [SERVICE_RESTART_NO] = "no",
2834 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
2835 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
2836 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
2837 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
2838 [SERVICE_RESTART_ON_ABORT] = "on-abort",
2839 [SERVICE_RESTART_ALWAYS] = "always",
2842 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
2844 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
2845 [SERVICE_SIMPLE] = "simple",
2846 [SERVICE_FORKING] = "forking",
2847 [SERVICE_ONESHOT] = "oneshot",
2848 [SERVICE_DBUS] = "dbus",
2849 [SERVICE_NOTIFY] = "notify",
2850 [SERVICE_IDLE] = "idle"
2853 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
2855 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
2856 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
2857 [SERVICE_EXEC_START] = "ExecStart",
2858 [SERVICE_EXEC_START_POST] = "ExecStartPost",
2859 [SERVICE_EXEC_RELOAD] = "ExecReload",
2860 [SERVICE_EXEC_STOP] = "ExecStop",
2861 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
2864 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
2866 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
2867 [NOTIFY_NONE] = "none",
2868 [NOTIFY_MAIN] = "main",
2869 [NOTIFY_ALL] = "all"
2872 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
2874 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
2875 [SERVICE_SUCCESS] = "success",
2876 [SERVICE_FAILURE_RESOURCES] = "resources",
2877 [SERVICE_FAILURE_TIMEOUT] = "timeout",
2878 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
2879 [SERVICE_FAILURE_SIGNAL] = "signal",
2880 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
2881 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
2882 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
2885 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
2887 static const char* const failure_action_table[_SERVICE_FAILURE_ACTION_MAX] = {
2888 [SERVICE_FAILURE_ACTION_NONE] = "none",
2889 [SERVICE_FAILURE_ACTION_REBOOT] = "reboot",
2890 [SERVICE_FAILURE_ACTION_REBOOT_FORCE] = "reboot-force",
2891 [SERVICE_FAILURE_ACTION_REBOOT_IMMEDIATE] = "reboot-immediate"
2893 DEFINE_STRING_TABLE_LOOKUP(failure_action, FailureAction);
2895 const UnitVTable service_vtable = {
2896 .object_size = sizeof(Service),
2897 .exec_context_offset = offsetof(Service, exec_context),
2898 .cgroup_context_offset = offsetof(Service, cgroup_context),
2899 .kill_context_offset = offsetof(Service, kill_context),
2900 .exec_runtime_offset = offsetof(Service, exec_runtime),
2906 .private_section = "Service",
2908 .init = service_init,
2909 .done = service_done,
2910 .load = service_load,
2912 .coldplug = service_coldplug,
2914 .dump = service_dump,
2916 .start = service_start,
2917 .stop = service_stop,
2918 .reload = service_reload,
2920 .can_reload = service_can_reload,
2922 .kill = service_kill,
2924 .serialize = service_serialize,
2925 .deserialize_item = service_deserialize_item,
2927 .active_state = service_active_state,
2928 .sub_state_to_string = service_sub_state_to_string,
2930 .check_gc = service_check_gc,
2931 .check_snapshot = service_check_snapshot,
2933 .sigchld_event = service_sigchld_event,
2935 .reset_failed = service_reset_failed,
2937 .notify_cgroup_empty = service_notify_cgroup_empty_event,
2938 .notify_message = service_notify_message,
2940 .bus_name_owner_change = service_bus_name_owner_change,
2942 .bus_interface = "org.freedesktop.systemd1.Service",
2943 .bus_vtable = bus_service_vtable,
2944 .bus_set_property = bus_service_set_property,
2945 .bus_commit_properties = bus_service_commit_properties,
2947 .get_timeout = service_get_timeout,
2948 .can_transient = true,
2950 .status_message_formats = {
2951 .starting_stopping = {
2952 [0] = "Starting %s...",
2953 [1] = "Stopping %s...",
2955 .finished_start_job = {
2956 [JOB_DONE] = "Started %s.",
2957 [JOB_FAILED] = "Failed to start %s.",
2958 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2959 [JOB_TIMEOUT] = "Timed out starting %s.",
2961 .finished_stop_job = {
2962 [JOB_DONE] = "Stopped %s.",
2963 [JOB_FAILED] = "Stopped (with error) %s.",
2964 [JOB_TIMEOUT] = "Timed out stopping %s.",