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/>.
30 #include "load-fragment.h"
31 #include "load-dropin.h"
34 #include "unit-name.h"
35 #include "unit-printf.h"
36 #include "dbus-service.h"
38 #include "exit-status.h"
40 #include "path-util.h"
45 #include "bus-error.h"
47 #include "bus-kernel.h"
49 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
50 [SERVICE_DEAD] = UNIT_INACTIVE,
51 [SERVICE_START_PRE] = UNIT_ACTIVATING,
52 [SERVICE_START] = UNIT_ACTIVATING,
53 [SERVICE_START_POST] = UNIT_ACTIVATING,
54 [SERVICE_RUNNING] = UNIT_ACTIVE,
55 [SERVICE_EXITED] = UNIT_ACTIVE,
56 [SERVICE_RELOAD] = UNIT_RELOADING,
57 [SERVICE_STOP] = UNIT_DEACTIVATING,
58 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
59 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
60 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
61 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
62 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
63 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
64 [SERVICE_FAILED] = UNIT_FAILED,
65 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
68 /* For Type=idle we never want to delay any other jobs, hence we
69 * consider idle jobs active as soon as we start working on them */
70 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
71 [SERVICE_DEAD] = UNIT_INACTIVE,
72 [SERVICE_START_PRE] = UNIT_ACTIVE,
73 [SERVICE_START] = UNIT_ACTIVE,
74 [SERVICE_START_POST] = UNIT_ACTIVE,
75 [SERVICE_RUNNING] = UNIT_ACTIVE,
76 [SERVICE_EXITED] = UNIT_ACTIVE,
77 [SERVICE_RELOAD] = UNIT_RELOADING,
78 [SERVICE_STOP] = UNIT_DEACTIVATING,
79 [SERVICE_STOP_SIGABRT] = UNIT_DEACTIVATING,
80 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
81 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
82 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
83 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
84 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
85 [SERVICE_FAILED] = UNIT_FAILED,
86 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
89 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
90 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
91 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
93 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
94 static void service_enter_reload_by_notify(Service *s);
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->bus_endpoint_fd = -1;
108 s->guess_main_pid = true;
110 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
112 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
115 static void service_unwatch_control_pid(Service *s) {
118 if (s->control_pid <= 0)
121 unit_unwatch_pid(UNIT(s), s->control_pid);
125 static void service_unwatch_main_pid(Service *s) {
128 if (s->main_pid <= 0)
131 unit_unwatch_pid(UNIT(s), s->main_pid);
135 static void service_unwatch_pid_file(Service *s) {
136 if (!s->pid_file_pathspec)
139 log_unit_debug(UNIT(s)->id, "Stopping watch for %s's PID file %s", 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_unit_warning(UNIT(s)->id, "%s: Supervising process "PID_FMT" which is not our child. We'll most likely not notice when it exits.", UNIT(s)->id, pid);
170 s->main_pid_alien = true;
172 s->main_pid_alien = false;
177 static void service_close_socket_fd(Service *s) {
180 s->socket_fd = asynchronous_close(s->socket_fd);
183 static void service_connection_unref(Service *s) {
186 if (!UNIT_ISSET(s->accept_socket))
189 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
190 unit_ref_unset(&s->accept_socket);
193 static void service_stop_watchdog(Service *s) {
196 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
197 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
200 static void service_start_watchdog(Service *s) {
205 if (s->watchdog_usec <= 0)
208 if (s->watchdog_event_source) {
209 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
211 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to reset watchdog timer: %m", UNIT(s)->id);
215 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
217 r = sd_event_add_time(
218 UNIT(s)->manager->event,
219 &s->watchdog_event_source,
221 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
222 service_dispatch_watchdog, s);
224 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to add watchdog timer: %m", UNIT(s)->id);
228 /* Let's process everything else which might be a sign
229 * of living before we consider a service died. */
230 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
234 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to install watchdog timer: %m", UNIT(s)->id);
237 static void service_reset_watchdog(Service *s) {
240 dual_timestamp_get(&s->watchdog_timestamp);
241 service_start_watchdog(s);
244 static void service_fd_store_unlink(ServiceFDStore *fs) {
250 assert(fs->service->n_fd_store > 0);
251 LIST_REMOVE(fd_store, fs->service->fd_store, fs);
252 fs->service->n_fd_store--;
255 if (fs->event_source) {
256 sd_event_source_set_enabled(fs->event_source, SD_EVENT_OFF);
257 sd_event_source_unref(fs->event_source);
264 static void service_release_resources(Unit *u) {
265 Service *s = SERVICE(u);
272 log_debug("Releasing all resources for %s", u->id);
275 service_fd_store_unlink(s->fd_store);
277 assert(s->n_fd_store == 0);
280 static void service_done(Unit *u) {
281 Service *s = SERVICE(u);
288 free(s->status_text);
289 s->status_text = NULL;
292 s->reboot_arg = NULL;
294 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
295 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
296 s->control_command = NULL;
297 s->main_command = NULL;
299 exit_status_set_free(&s->restart_prevent_status);
300 exit_status_set_free(&s->restart_force_status);
301 exit_status_set_free(&s->success_status);
303 /* This will leak a process, but at least no memory or any of
305 service_unwatch_main_pid(s);
306 service_unwatch_control_pid(s);
307 service_unwatch_pid_file(s);
310 unit_unwatch_bus_name(u, s->bus_name);
315 s->bus_endpoint_fd = safe_close(s->bus_endpoint_fd);
316 service_close_socket_fd(s);
317 service_connection_unref(s);
319 unit_ref_unset(&s->accept_socket);
321 service_stop_watchdog(s);
323 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
325 service_release_resources(u);
328 static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
329 ServiceFDStore *fs = userdata;
334 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
335 service_fd_store_unlink(fs);
339 static int service_add_fd_store(Service *s, int fd) {
346 if (s->n_fd_store >= s->n_fd_store_max)
349 LIST_FOREACH(fd_store, fs, s->fd_store) {
350 r = same_fd(fs->fd, fd);
354 /* Already included */
360 fs = new0(ServiceFDStore, 1);
367 r = sd_event_add_io(UNIT(s)->manager->event, &fs->event_source, fd, 0, on_fd_store_io, fs);
373 LIST_PREPEND(fd_store, s->fd_store, fs);
379 static int service_add_fd_store_set(Service *s, FDSet *fds) {
384 if (fdset_size(fds) <= 0)
387 while (s->n_fd_store < s->n_fd_store_max) {
388 _cleanup_close_ int fd = -1;
390 fd = fdset_steal_first(fds);
394 r = service_add_fd_store(s, fd);
396 return log_unit_error_errno(UNIT(s)->id, r, "%s: Couldn't add fd to fd store: %m", UNIT(s)->id);
399 log_unit_debug(UNIT(s)->id, "%s: added fd to fd store.", UNIT(s)->id);
404 if (fdset_size(fds) > 0)
405 log_unit_warning(UNIT(s)->id, "%s: tried to store more fds than FDStoreMax=%u allows, closing remaining.", UNIT(s)->id, s->n_fd_store_max);
410 static int service_arm_timer(Service *s, usec_t usec) {
415 if (s->timer_event_source) {
416 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
420 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
423 return sd_event_add_time(
424 UNIT(s)->manager->event,
425 &s->timer_event_source,
427 now(CLOCK_MONOTONIC) + usec, 0,
428 service_dispatch_timer, s);
431 static int service_verify(Service *s) {
434 if (UNIT(s)->load_state != UNIT_LOADED)
437 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]) {
438 log_unit_error(UNIT(s)->id, "%s lacks both ExecStart= and ExecStop= setting. Refusing.", UNIT(s)->id);
442 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
443 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
447 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START]) {
448 log_unit_error(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.", UNIT(s)->id);
452 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
453 log_unit_error(UNIT(s)->id, "%s has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
457 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
458 log_unit_error(UNIT(s)->id, "%s has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
462 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
463 log_unit_error(UNIT(s)->id, "%s has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
467 if (s->type == SERVICE_DBUS && !s->bus_name) {
468 log_unit_error(UNIT(s)->id, "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
472 if (s->bus_name && s->type != SERVICE_DBUS)
473 log_unit_warning(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
475 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
476 log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
483 static int service_add_default_dependencies(Service *s) {
488 /* Add a number of automatic dependencies useful for the
489 * majority of services. */
491 /* First, pull in base system */
492 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true);
496 /* Second, activate normal shutdown */
497 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
500 static void service_fix_output(Service *s) {
503 /* If nothing has been explicitly configured, patch default
504 * output in. If input is socket/tty we avoid this however,
505 * since in that case we want output to default to the same
506 * place as we read input from. */
508 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
509 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
510 s->exec_context.std_input == EXEC_INPUT_NULL)
511 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
513 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
514 s->exec_context.std_input == EXEC_INPUT_NULL)
515 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
518 static int service_add_extras(Service *s) {
523 if (s->type == _SERVICE_TYPE_INVALID) {
524 /* Figure out a type automatically */
526 s->type = SERVICE_DBUS;
527 else if (s->exec_command[SERVICE_EXEC_START])
528 s->type = SERVICE_SIMPLE;
530 s->type = SERVICE_ONESHOT;
533 /* Oneshot services have disabled start timeout by default */
534 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
535 s->timeout_start_usec = 0;
537 service_fix_output(s);
539 r = unit_patch_contexts(UNIT(s));
543 r = unit_add_exec_dependencies(UNIT(s), &s->exec_context);
547 r = unit_add_default_slice(UNIT(s), &s->cgroup_context);
551 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
552 s->notify_access = NOTIFY_MAIN;
554 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
555 s->notify_access = NOTIFY_MAIN;
561 n = strjoina(s->bus_name, ".busname");
562 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, n, NULL, true);
567 r = unit_watch_bus_name(UNIT(s), s->bus_name);
572 if (UNIT(s)->default_dependencies) {
573 r = service_add_default_dependencies(s);
581 static int service_load(Unit *u) {
582 Service *s = SERVICE(u);
587 /* Load a .service file */
588 r = unit_load_fragment(u);
592 /* Still nothing found? Then let's give up */
593 if (u->load_state == UNIT_STUB)
596 /* This is a new unit? Then let's add in some extras */
597 if (u->load_state == UNIT_LOADED) {
599 /* We were able to load something, then let's add in
600 * the dropin directories. */
601 r = unit_load_dropin(u);
605 /* This is a new unit? Then let's add in some
607 r = service_add_extras(s);
612 return service_verify(s);
615 static void service_dump(Unit *u, FILE *f, const char *prefix) {
616 ServiceExecCommand c;
617 Service *s = SERVICE(u);
622 prefix = strempty(prefix);
623 prefix2 = strjoina(prefix, "\t");
626 "%sService State: %s\n"
628 "%sReload Result: %s\n"
629 "%sPermissionsStartOnly: %s\n"
630 "%sRootDirectoryStartOnly: %s\n"
631 "%sRemainAfterExit: %s\n"
632 "%sGuessMainPID: %s\n"
635 "%sNotifyAccess: %s\n"
636 "%sNotifyState: %s\n",
637 prefix, service_state_to_string(s->state),
638 prefix, service_result_to_string(s->result),
639 prefix, service_result_to_string(s->reload_result),
640 prefix, yes_no(s->permissions_start_only),
641 prefix, yes_no(s->root_directory_start_only),
642 prefix, yes_no(s->remain_after_exit),
643 prefix, yes_no(s->guess_main_pid),
644 prefix, service_type_to_string(s->type),
645 prefix, service_restart_to_string(s->restart),
646 prefix, notify_access_to_string(s->notify_access),
647 prefix, notify_state_to_string(s->notify_state));
649 if (s->control_pid > 0)
651 "%sControl PID: "PID_FMT"\n",
652 prefix, s->control_pid);
656 "%sMain PID: "PID_FMT"\n"
657 "%sMain PID Known: %s\n"
658 "%sMain PID Alien: %s\n",
660 prefix, yes_no(s->main_pid_known),
661 prefix, yes_no(s->main_pid_alien));
666 prefix, s->pid_file);
671 "%sBus Name Good: %s\n",
673 prefix, yes_no(s->bus_name_good));
675 kill_context_dump(&s->kill_context, f, prefix);
676 exec_context_dump(&s->exec_context, f, prefix);
678 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
680 if (!s->exec_command[c])
683 fprintf(f, "%s-> %s:\n",
684 prefix, service_exec_command_to_string(c));
686 exec_command_dump_list(s->exec_command[c], f, prefix2);
690 fprintf(f, "%sStatus Text: %s\n",
691 prefix, s->status_text);
693 if (s->n_fd_store_max > 0) {
695 "%sFile Descriptor Store Max: %u\n"
696 "%sFile Descriptor Store Current: %u\n",
697 prefix, s->n_fd_store_max,
698 prefix, s->n_fd_store);
702 static int service_load_pid_file(Service *s, bool may_warn) {
703 _cleanup_free_ char *k = NULL;
712 r = read_one_line_file(s->pid_file, &k);
715 log_unit_info(UNIT(s)->id, "PID file %s not readable (yet?) after %s.", s->pid_file, service_state_to_string(s->state));
719 r = parse_pid(k, &pid);
722 log_unit_info_errno(UNIT(s)->id, r, "Failed to read PID from file %s: %m", s->pid_file);
726 if (!pid_is_alive(pid)) {
728 log_unit_info(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
732 if (s->main_pid_known) {
733 if (pid == s->main_pid)
736 log_unit_debug(UNIT(s)->id, "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
738 service_unwatch_main_pid(s);
739 s->main_pid_known = false;
741 log_unit_debug(UNIT(s)->id, "Main PID loaded: "PID_FMT, pid);
743 r = service_set_main_pid(s, pid);
747 r = unit_watch_pid(UNIT(s), pid);
749 /* FIXME: we need to do something here */
750 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
757 static int service_search_main_pid(Service *s) {
763 /* If we know it anyway, don't ever fallback to unreliable
765 if (s->main_pid_known)
768 if (!s->guess_main_pid)
771 assert(s->main_pid <= 0);
773 pid = unit_search_main_pid(UNIT(s));
777 log_unit_debug(UNIT(s)->id, "Main PID guessed: "PID_FMT, pid);
778 r = service_set_main_pid(s, pid);
782 r = unit_watch_pid(UNIT(s), pid);
784 /* FIXME: we need to do something here */
785 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
792 static void service_set_state(Service *s, ServiceState state) {
793 ServiceState old_state;
794 const UnitActiveState *table;
798 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
800 old_state = s->state;
803 service_unwatch_pid_file(s);
806 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
808 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
809 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
810 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
811 SERVICE_AUTO_RESTART))
812 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
815 SERVICE_START, SERVICE_START_POST,
816 SERVICE_RUNNING, SERVICE_RELOAD,
817 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
818 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
819 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
820 service_unwatch_main_pid(s);
821 s->main_command = NULL;
825 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
827 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
828 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
829 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
830 service_unwatch_control_pid(s);
831 s->control_command = NULL;
832 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
835 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
836 unit_unwatch_all_pids(UNIT(s));
839 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
840 SERVICE_RUNNING, SERVICE_RELOAD,
841 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
842 SERVICE_STOP_SIGABRT, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
843 !(state == SERVICE_DEAD && UNIT(s)->job)) {
844 service_close_socket_fd(s);
845 service_connection_unref(s);
848 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
849 service_stop_watchdog(s);
851 /* For the inactive states unit_notify() will trim the cgroup,
852 * but for exit we have to do that ourselves... */
853 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
854 unit_destroy_cgroup_if_empty(UNIT(s));
856 /* For remain_after_exit services, let's see if we can "release" the
857 * hold on the console, since unit_notify() only does that in case of
859 if (state == SERVICE_EXITED &&
860 s->remain_after_exit &&
861 UNIT(s)->manager->n_on_console > 0) {
865 ec = unit_get_exec_context(UNIT(s));
866 if (ec && exec_context_may_touch_console(ec)) {
867 Manager *m = UNIT(s)->manager;
870 if (m->n_on_console == 0)
871 /* unset no_console_output flag, since the console is free */
872 m->no_console_output = false;
876 if (old_state != state)
877 log_unit_debug(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
879 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
880 s->reload_result = SERVICE_SUCCESS;
883 static int service_coldplug(Unit *u, Hashmap *deferred_work) {
884 Service *s = SERVICE(u);
888 assert(s->state == SERVICE_DEAD);
890 if (s->deserialized_state != s->state) {
892 if (IN_SET(s->deserialized_state,
893 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
895 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
896 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
897 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
901 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
903 /* For the start/stop timeouts 0 means off */
905 r = service_arm_timer(s, k);
911 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
913 /* The restart timeouts 0 means immediately */
914 r = service_arm_timer(s, s->restart_usec);
919 if (pid_is_unwaited(s->main_pid) &&
920 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
921 IN_SET(s->deserialized_state,
922 SERVICE_START, SERVICE_START_POST,
923 SERVICE_RUNNING, SERVICE_RELOAD,
924 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
925 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
926 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
927 r = unit_watch_pid(UNIT(s), s->main_pid);
932 if (pid_is_unwaited(s->control_pid) &&
933 IN_SET(s->deserialized_state,
934 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
936 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
937 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
938 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
939 r = unit_watch_pid(UNIT(s), s->control_pid);
944 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
945 unit_watch_all_pids(UNIT(s));
947 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
948 service_start_watchdog(s);
950 service_set_state(s, s->deserialized_state);
956 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
957 _cleanup_free_ int *rfds = NULL;
967 if (s->socket_fd >= 0)
970 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
975 if (u->type != UNIT_SOCKET)
980 r = socket_collect_fds(sock, &cfds, &cn_fds);
995 t = realloc(rfds, (rn_fds + cn_fds) * sizeof(int));
1001 memcpy(t + rn_fds, cfds, cn_fds * sizeof(int));
1010 if (s->n_fd_store > 0) {
1014 t = realloc(rfds, (rn_fds + s->n_fd_store) * sizeof(int));
1019 LIST_FOREACH(fd_store, fs, s->fd_store)
1020 rfds[rn_fds++] = fs->fd;
1030 static int service_spawn(
1035 bool apply_permissions,
1037 bool apply_tty_stdin,
1044 _cleanup_free_ int *fdsbuf = NULL;
1045 unsigned n_fds = 0, n_env = 0;
1046 _cleanup_free_ char *bus_endpoint_path = NULL;
1047 _cleanup_strv_free_ char
1048 **argv = NULL, **final_env = NULL, **our_env = NULL;
1050 ExecParameters exec_params = {
1051 .apply_permissions = apply_permissions,
1052 .apply_chroot = apply_chroot,
1053 .apply_tty_stdin = apply_tty_stdin,
1054 .bus_endpoint_fd = -1,
1055 .selinux_context_net = s->socket_fd_selinux_context_net
1062 (void) unit_realize_cgroup(UNIT(s));
1063 if (s->reset_cpu_usage) {
1064 (void) unit_reset_cpu_usage(UNIT(s));
1065 s->reset_cpu_usage = false;
1068 r = unit_setup_exec_runtime(UNIT(s));
1073 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1074 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1075 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1077 if (s->socket_fd >= 0) {
1078 fds = &s->socket_fd;
1081 r = service_collect_fds(s, &fdsbuf, &n_fds);
1090 r = service_arm_timer(s, timeout);
1094 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1096 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1100 our_env = new0(char*, 6);
1106 if (is_control ? s->notify_access == NOTIFY_ALL : s->notify_access != NOTIFY_NONE)
1107 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1112 if (s->main_pid > 0)
1113 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
1118 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1119 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
1124 if (UNIT_DEREF(s->accept_socket)) {
1125 union sockaddr_union sa;
1126 socklen_t salen = sizeof(sa);
1128 r = getpeername(s->socket_fd, &sa.sa, &salen);
1134 if (IN_SET(sa.sa.sa_family, AF_INET, AF_INET6)) {
1135 _cleanup_free_ char *addr = NULL;
1139 r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1143 t = strappend("REMOTE_ADDR=", addr);
1148 our_env[n_env++] = t;
1150 port = sockaddr_port(&sa.sa);
1156 if (asprintf(&t, "REMOTE_PORT=%u", port) < 0) {
1160 our_env[n_env++] = t;
1164 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1170 if (is_control && UNIT(s)->cgroup_path) {
1171 path = strjoina(UNIT(s)->cgroup_path, "/control");
1172 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1174 path = UNIT(s)->cgroup_path;
1177 if (s->exec_context.bus_endpoint) {
1178 r = bus_kernel_create_endpoint(UNIT(s)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user",
1179 UNIT(s)->id, &bus_endpoint_path);
1183 /* Pass the fd to the exec_params so that the child process can upload the policy.
1184 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1185 * as the service is running. */
1186 exec_params.bus_endpoint_fd = s->bus_endpoint_fd = r;
1190 exec_params.argv = argv;
1191 exec_params.fds = fds;
1192 exec_params.n_fds = n_fds;
1193 exec_params.environment = final_env;
1194 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
1195 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
1196 exec_params.cgroup_path = path;
1197 exec_params.cgroup_delegate = s->cgroup_context.delegate;
1198 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
1199 exec_params.unit_id = UNIT(s)->id;
1200 exec_params.watchdog_usec = s->watchdog_usec;
1201 exec_params.bus_endpoint_path = bus_endpoint_path;
1202 if (s->type == SERVICE_IDLE)
1203 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1213 r = unit_watch_pid(UNIT(s), pid);
1215 /* FIXME: we need to do something here */
1224 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1229 static int main_pid_good(Service *s) {
1232 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1235 /* If we know the pid file, then lets just check if it is
1237 if (s->main_pid_known) {
1239 /* If it's an alien child let's check if it is still
1241 if (s->main_pid_alien && s->main_pid > 0)
1242 return pid_is_alive(s->main_pid);
1244 /* .. otherwise assume we'll get a SIGCHLD for it,
1245 * which we really should wait for to collect exit
1246 * status and code */
1247 return s->main_pid > 0;
1250 /* We don't know the pid */
1254 _pure_ static int control_pid_good(Service *s) {
1257 return s->control_pid > 0;
1260 static int cgroup_good(Service *s) {
1265 if (!UNIT(s)->cgroup_path)
1268 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1275 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1279 if (f != SERVICE_SUCCESS)
1282 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1284 if (s->result != SERVICE_SUCCESS) {
1285 log_unit_warning(UNIT(s)->id, "%s failed.", UNIT(s)->id);
1286 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1289 if (allow_restart &&
1290 !s->forbid_restart &&
1291 (s->restart == SERVICE_RESTART_ALWAYS ||
1292 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1293 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1294 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1295 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1296 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1297 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1298 (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)))) &&
1299 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
1300 (!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)))) {
1302 r = service_arm_timer(s, s->restart_usec);
1306 service_set_state(s, SERVICE_AUTO_RESTART);
1309 s->forbid_restart = false;
1311 /* We want fresh tmpdirs in case service is started again immediately */
1312 exec_runtime_destroy(s->exec_runtime);
1313 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1315 /* Also, remove the runtime directory in */
1316 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1318 /* Try to delete the pid file. At this point it will be
1319 * out-of-date, and some software might be confused by it, so
1320 * let's remove it. */
1322 unlink_noerrno(s->pid_file);
1327 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run install restart timer: %m", UNIT(s)->id);
1328 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1331 static void service_enter_stop_post(Service *s, ServiceResult f) {
1335 if (f != SERVICE_SUCCESS)
1338 service_unwatch_control_pid(s);
1339 unit_watch_all_pids(UNIT(s));
1341 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1342 if (s->control_command) {
1343 s->control_command_id = SERVICE_EXEC_STOP_POST;
1345 r = service_spawn(s,
1347 s->timeout_stop_usec,
1349 !s->permissions_start_only,
1350 !s->root_directory_start_only,
1357 service_set_state(s, SERVICE_STOP_POST);
1359 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1364 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop-post' task: %m", UNIT(s)->id);
1365 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1368 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1373 if (f != SERVICE_SUCCESS)
1376 unit_watch_all_pids(UNIT(s));
1378 r = unit_kill_context(
1381 (state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM && state != SERVICE_STOP_SIGABRT) ?
1382 KILL_KILL : (state == SERVICE_STOP_SIGABRT ? KILL_ABORT : KILL_TERMINATE),
1391 if (s->timeout_stop_usec > 0) {
1392 r = service_arm_timer(s, s->timeout_stop_usec);
1397 service_set_state(s, state);
1398 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGABRT)
1399 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1400 else if (state == SERVICE_STOP_SIGKILL)
1401 service_enter_stop_post(s, SERVICE_SUCCESS);
1402 else if (state == SERVICE_FINAL_SIGTERM)
1403 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1405 service_enter_dead(s, SERVICE_SUCCESS, true);
1410 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
1412 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL ||
1413 state == SERVICE_STOP_SIGABRT)
1414 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1416 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1419 static void service_enter_stop_by_notify(Service *s) {
1422 unit_watch_all_pids(UNIT(s));
1424 if (s->timeout_stop_usec > 0)
1425 service_arm_timer(s, s->timeout_stop_usec);
1427 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1428 service_set_state(s, SERVICE_STOP_SIGTERM);
1431 static void service_enter_stop(Service *s, ServiceResult f) {
1436 if (f != SERVICE_SUCCESS)
1439 service_unwatch_control_pid(s);
1440 unit_watch_all_pids(UNIT(s));
1442 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1443 if (s->control_command) {
1444 s->control_command_id = SERVICE_EXEC_STOP;
1446 r = service_spawn(s,
1448 s->timeout_stop_usec,
1450 !s->permissions_start_only,
1451 !s->root_directory_start_only,
1458 service_set_state(s, SERVICE_STOP);
1460 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1465 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop' task: %m", UNIT(s)->id);
1466 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1469 static void service_enter_running(Service *s, ServiceResult f) {
1470 int main_pid_ok, cgroup_ok;
1473 if (f != SERVICE_SUCCESS)
1476 main_pid_ok = main_pid_good(s);
1477 cgroup_ok = cgroup_good(s);
1479 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1480 (s->bus_name_good || s->type != SERVICE_DBUS)) {
1482 /* If there are any queued up sd_notify()
1483 * notifications, process them now */
1484 if (s->notify_state == NOTIFY_RELOADING)
1485 service_enter_reload_by_notify(s);
1486 else if (s->notify_state == NOTIFY_STOPPING)
1487 service_enter_stop_by_notify(s);
1489 service_set_state(s, SERVICE_RUNNING);
1491 } else if (s->remain_after_exit)
1492 service_set_state(s, SERVICE_EXITED);
1494 service_enter_stop(s, SERVICE_SUCCESS);
1497 static void service_enter_start_post(Service *s) {
1501 service_unwatch_control_pid(s);
1502 service_reset_watchdog(s);
1504 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1505 if (s->control_command) {
1506 s->control_command_id = SERVICE_EXEC_START_POST;
1508 r = service_spawn(s,
1510 s->timeout_start_usec,
1512 !s->permissions_start_only,
1513 !s->root_directory_start_only,
1520 service_set_state(s, SERVICE_START_POST);
1522 service_enter_running(s, SERVICE_SUCCESS);
1527 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-post' task: %m", UNIT(s)->id);
1528 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1531 static void service_kill_control_processes(Service *s) {
1534 if (!UNIT(s)->cgroup_path)
1537 p = strjoina(UNIT(s)->cgroup_path, "/control");
1538 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1541 static void service_enter_start(Service *s) {
1548 service_unwatch_control_pid(s);
1549 service_unwatch_main_pid(s);
1551 /* We want to ensure that nobody leaks processes from
1552 * START_PRE here, so let's go on a killing spree, People
1553 * should not spawn long running processes from START_PRE. */
1554 service_kill_control_processes(s);
1556 if (s->type == SERVICE_FORKING) {
1557 s->control_command_id = SERVICE_EXEC_START;
1558 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1560 s->main_command = NULL;
1562 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1563 s->control_command = NULL;
1565 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1569 assert(s->type == SERVICE_ONESHOT);
1570 service_enter_start_post(s);
1574 r = service_spawn(s,
1576 IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_ONESHOT) ? s->timeout_start_usec : 0,
1586 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1587 /* For simple services we immediately start
1588 * the START_POST binaries. */
1590 service_set_main_pid(s, pid);
1591 service_enter_start_post(s);
1593 } else if (s->type == SERVICE_FORKING) {
1595 /* For forking services we wait until the start
1596 * process exited. */
1598 s->control_pid = pid;
1599 service_set_state(s, SERVICE_START);
1601 } else if (s->type == SERVICE_ONESHOT ||
1602 s->type == SERVICE_DBUS ||
1603 s->type == SERVICE_NOTIFY) {
1605 /* For oneshot services we wait until the start
1606 * process exited, too, but it is our main process. */
1608 /* For D-Bus services we know the main pid right away,
1609 * but wait for the bus name to appear on the
1610 * bus. Notify services are similar. */
1612 service_set_main_pid(s, pid);
1613 service_set_state(s, SERVICE_START);
1615 assert_not_reached("Unknown service type");
1620 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start' task: %m", UNIT(s)->id);
1621 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1624 static void service_enter_start_pre(Service *s) {
1629 service_unwatch_control_pid(s);
1631 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1632 if (s->control_command) {
1633 /* Before we start anything, let's clear up what might
1634 * be left from previous runs. */
1635 service_kill_control_processes(s);
1637 s->control_command_id = SERVICE_EXEC_START_PRE;
1639 r = service_spawn(s,
1641 s->timeout_start_usec,
1643 !s->permissions_start_only,
1644 !s->root_directory_start_only,
1651 service_set_state(s, SERVICE_START_PRE);
1653 service_enter_start(s);
1658 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-pre' task: %m", UNIT(s)->id);
1659 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1662 static void service_enter_restart(Service *s) {
1663 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1668 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1669 /* Don't restart things if we are going down anyway */
1670 log_unit_info(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1672 r = service_arm_timer(s, s->restart_usec);
1679 /* Any units that are bound to this service must also be
1680 * restarted. We use JOB_RESTART (instead of the more obvious
1681 * JOB_START) here so that those dependency jobs will be added
1683 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1687 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1688 * it will be canceled as part of the service_stop() call that
1689 * is executed as part of JOB_RESTART. */
1691 log_unit_debug(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1695 log_unit_warning(UNIT(s)->id, "%s failed to schedule restart job: %s", UNIT(s)->id, bus_error_message(&error, -r));
1696 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1699 static void service_enter_reload_by_notify(Service *s) {
1702 if (s->timeout_start_usec > 0)
1703 service_arm_timer(s, s->timeout_start_usec);
1705 service_set_state(s, SERVICE_RELOAD);
1708 static void service_enter_reload(Service *s) {
1713 service_unwatch_control_pid(s);
1715 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1716 if (s->control_command) {
1717 s->control_command_id = SERVICE_EXEC_RELOAD;
1719 r = service_spawn(s,
1721 s->timeout_start_usec,
1723 !s->permissions_start_only,
1724 !s->root_directory_start_only,
1731 service_set_state(s, SERVICE_RELOAD);
1733 service_enter_running(s, SERVICE_SUCCESS);
1738 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'reload' task: %m", UNIT(s)->id);
1739 s->reload_result = SERVICE_FAILURE_RESOURCES;
1740 service_enter_running(s, SERVICE_SUCCESS);
1743 static void service_run_next_control(Service *s) {
1747 assert(s->control_command);
1748 assert(s->control_command->command_next);
1750 assert(s->control_command_id != SERVICE_EXEC_START);
1752 s->control_command = s->control_command->command_next;
1753 service_unwatch_control_pid(s);
1755 r = service_spawn(s,
1757 IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec,
1759 !s->permissions_start_only,
1760 !s->root_directory_start_only,
1761 s->control_command_id == SERVICE_EXEC_START_PRE ||
1762 s->control_command_id == SERVICE_EXEC_STOP_POST,
1771 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next control task: %m", UNIT(s)->id);
1773 if (s->state == SERVICE_START_PRE)
1774 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1775 else if (s->state == SERVICE_STOP)
1776 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1777 else if (s->state == SERVICE_STOP_POST)
1778 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1779 else if (s->state == SERVICE_RELOAD) {
1780 s->reload_result = SERVICE_FAILURE_RESOURCES;
1781 service_enter_running(s, SERVICE_SUCCESS);
1783 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1786 static void service_run_next_main(Service *s) {
1791 assert(s->main_command);
1792 assert(s->main_command->command_next);
1793 assert(s->type == SERVICE_ONESHOT);
1795 s->main_command = s->main_command->command_next;
1796 service_unwatch_main_pid(s);
1798 r = service_spawn(s,
1800 s->timeout_start_usec,
1810 service_set_main_pid(s, pid);
1815 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next main task: %m", UNIT(s)->id);
1816 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1819 static int service_start_limit_test(Service *s) {
1822 if (ratelimit_test(&s->start_limit))
1825 log_unit_warning(UNIT(s)->id, "start request repeated too quickly for %s", UNIT(s)->id);
1827 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
1830 static int service_start(Unit *u) {
1831 Service *s = SERVICE(u);
1836 /* We cannot fulfill this request right now, try again later
1838 if (s->state == SERVICE_STOP ||
1839 s->state == SERVICE_STOP_SIGABRT ||
1840 s->state == SERVICE_STOP_SIGTERM ||
1841 s->state == SERVICE_STOP_SIGKILL ||
1842 s->state == SERVICE_STOP_POST ||
1843 s->state == SERVICE_FINAL_SIGTERM ||
1844 s->state == SERVICE_FINAL_SIGKILL)
1847 /* Already on it! */
1848 if (s->state == SERVICE_START_PRE ||
1849 s->state == SERVICE_START ||
1850 s->state == SERVICE_START_POST)
1853 /* A service that will be restarted must be stopped first to
1854 * trigger BindsTo and/or OnFailure dependencies. If a user
1855 * does not want to wait for the holdoff time to elapse, the
1856 * service should be manually restarted, not started. We
1857 * simply return EAGAIN here, so that any start jobs stay
1858 * queued, and assume that the auto restart timer will
1859 * eventually trigger the restart. */
1860 if (s->state == SERVICE_AUTO_RESTART)
1863 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1865 /* Make sure we don't enter a busy loop of some kind. */
1866 r = service_start_limit_test(s);
1868 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1872 s->result = SERVICE_SUCCESS;
1873 s->reload_result = SERVICE_SUCCESS;
1874 s->main_pid_known = false;
1875 s->main_pid_alien = false;
1876 s->forbid_restart = false;
1877 s->reset_cpu_usage = true;
1879 free(s->status_text);
1880 s->status_text = NULL;
1881 s->status_errno = 0;
1883 s->notify_state = NOTIFY_UNKNOWN;
1885 service_enter_start_pre(s);
1889 static int service_stop(Unit *u) {
1890 Service *s = SERVICE(u);
1894 /* Don't create restart jobs from here. */
1895 s->forbid_restart = true;
1898 if (s->state == SERVICE_STOP ||
1899 s->state == SERVICE_STOP_SIGABRT ||
1900 s->state == SERVICE_STOP_SIGTERM ||
1901 s->state == SERVICE_STOP_SIGKILL ||
1902 s->state == SERVICE_STOP_POST ||
1903 s->state == SERVICE_FINAL_SIGTERM ||
1904 s->state == SERVICE_FINAL_SIGKILL)
1907 /* A restart will be scheduled or is in progress. */
1908 if (s->state == SERVICE_AUTO_RESTART) {
1909 service_set_state(s, SERVICE_DEAD);
1913 /* If there's already something running we go directly into
1915 if (s->state == SERVICE_START_PRE ||
1916 s->state == SERVICE_START ||
1917 s->state == SERVICE_START_POST ||
1918 s->state == SERVICE_RELOAD) {
1919 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1923 assert(s->state == SERVICE_RUNNING ||
1924 s->state == SERVICE_EXITED);
1926 service_enter_stop(s, SERVICE_SUCCESS);
1930 static int service_reload(Unit *u) {
1931 Service *s = SERVICE(u);
1935 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1937 service_enter_reload(s);
1941 _pure_ static bool service_can_reload(Unit *u) {
1942 Service *s = SERVICE(u);
1946 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1949 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1950 Service *s = SERVICE(u);
1957 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1958 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1959 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1961 if (s->control_pid > 0)
1962 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1965 if (s->main_pid_known && s->main_pid > 0)
1966 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1968 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1971 unit_serialize_item(u, f, "status-text", s->status_text);
1973 /* FIXME: There's a minor uncleanliness here: if there are
1974 * multiple commands attached here, we will start from the
1975 * first one again */
1976 if (s->control_command_id >= 0)
1977 unit_serialize_item(u, f, "control-command",
1978 service_exec_command_to_string(s->control_command_id));
1980 if (s->socket_fd >= 0) {
1983 copy = fdset_put_dup(fds, s->socket_fd);
1987 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1990 if (s->bus_endpoint_fd >= 0) {
1993 copy = fdset_put_dup(fds, s->bus_endpoint_fd);
1997 unit_serialize_item_format(u, f, "endpoint-fd", "%i", copy);
2000 LIST_FOREACH(fd_store, fs, s->fd_store) {
2003 copy = fdset_put_dup(fds, fs->fd);
2007 unit_serialize_item_format(u, f, "fd-store-fd", "%i", copy);
2010 if (s->main_exec_status.pid > 0) {
2011 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
2012 s->main_exec_status.pid);
2013 dual_timestamp_serialize(f, "main-exec-status-start",
2014 &s->main_exec_status.start_timestamp);
2015 dual_timestamp_serialize(f, "main-exec-status-exit",
2016 &s->main_exec_status.exit_timestamp);
2018 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2019 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2020 s->main_exec_status.code);
2021 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2022 s->main_exec_status.status);
2025 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2026 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2028 if (s->forbid_restart)
2029 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2034 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2035 Service *s = SERVICE(u);
2043 if (streq(key, "state")) {
2046 state = service_state_from_string(value);
2048 log_unit_debug(u->id, "Failed to parse state value %s", value);
2050 s->deserialized_state = state;
2051 } else if (streq(key, "result")) {
2054 f = service_result_from_string(value);
2056 log_unit_debug(u->id, "Failed to parse result value %s", value);
2057 else if (f != SERVICE_SUCCESS)
2060 } else if (streq(key, "reload-result")) {
2063 f = service_result_from_string(value);
2065 log_unit_debug(u->id, "Failed to parse reload result value %s", value);
2066 else if (f != SERVICE_SUCCESS)
2067 s->reload_result = f;
2069 } else if (streq(key, "control-pid")) {
2072 if (parse_pid(value, &pid) < 0)
2073 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
2075 s->control_pid = pid;
2076 } else if (streq(key, "main-pid")) {
2079 if (parse_pid(value, &pid) < 0)
2080 log_unit_debug(u->id, "Failed to parse main-pid value %s", value);
2082 service_set_main_pid(s, pid);
2083 unit_watch_pid(UNIT(s), pid);
2085 } else if (streq(key, "main-pid-known")) {
2088 b = parse_boolean(value);
2090 log_unit_debug(u->id, "Failed to parse main-pid-known value %s", value);
2092 s->main_pid_known = b;
2093 } else if (streq(key, "status-text")) {
2100 free(s->status_text);
2104 } else if (streq(key, "control-command")) {
2105 ServiceExecCommand id;
2107 id = service_exec_command_from_string(value);
2109 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
2111 s->control_command_id = id;
2112 s->control_command = s->exec_command[id];
2114 } else if (streq(key, "socket-fd")) {
2117 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2118 log_unit_debug(u->id, "Failed to parse socket-fd value %s", value);
2120 asynchronous_close(s->socket_fd);
2121 s->socket_fd = fdset_remove(fds, fd);
2123 } else if (streq(key, "endpoint-fd")) {
2126 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2127 log_unit_debug(u->id, "Failed to parse endpoint-fd value %s", value);
2129 safe_close(s->bus_endpoint_fd);
2130 s->bus_endpoint_fd = fdset_remove(fds, fd);
2132 } else if (streq(key, "fd-store-fd")) {
2135 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2136 log_unit_debug(u->id, "Failed to parse fd-store-fd value %s", value);
2138 r = service_add_fd_store(s, fd);
2140 log_unit_error_errno(u->id, r, "Failed to add fd to store: %m");
2142 fdset_remove(fds, fd);
2145 } else if (streq(key, "main-exec-status-pid")) {
2148 if (parse_pid(value, &pid) < 0)
2149 log_unit_debug(u->id, "Failed to parse main-exec-status-pid value %s", value);
2151 s->main_exec_status.pid = pid;
2152 } else if (streq(key, "main-exec-status-code")) {
2155 if (safe_atoi(value, &i) < 0)
2156 log_unit_debug(u->id, "Failed to parse main-exec-status-code value %s", value);
2158 s->main_exec_status.code = i;
2159 } else if (streq(key, "main-exec-status-status")) {
2162 if (safe_atoi(value, &i) < 0)
2163 log_unit_debug(u->id, "Failed to parse main-exec-status-status value %s", value);
2165 s->main_exec_status.status = i;
2166 } else if (streq(key, "main-exec-status-start"))
2167 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2168 else if (streq(key, "main-exec-status-exit"))
2169 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2170 else if (streq(key, "watchdog-timestamp"))
2171 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2172 else if (streq(key, "forbid-restart")) {
2175 b = parse_boolean(value);
2177 log_unit_debug(u->id, "Failed to parse forbid-restart value %s", value);
2179 s->forbid_restart = b;
2181 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
2186 _pure_ static UnitActiveState service_active_state(Unit *u) {
2187 const UnitActiveState *table;
2191 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2193 return table[SERVICE(u)->state];
2196 static const char *service_sub_state_to_string(Unit *u) {
2199 return service_state_to_string(SERVICE(u)->state);
2202 static bool service_check_gc(Unit *u) {
2203 Service *s = SERVICE(u);
2207 /* Never clean up services that still have a process around,
2208 * even if the service is formally dead. */
2209 if (cgroup_good(s) > 0 ||
2210 main_pid_good(s) > 0 ||
2211 control_pid_good(s) > 0)
2217 _pure_ static bool service_check_snapshot(Unit *u) {
2218 Service *s = SERVICE(u);
2222 return s->socket_fd < 0;
2225 static int service_retry_pid_file(Service *s) {
2228 assert(s->pid_file);
2229 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2231 r = service_load_pid_file(s, false);
2235 service_unwatch_pid_file(s);
2237 service_enter_running(s, SERVICE_SUCCESS);
2241 static int service_watch_pid_file(Service *s) {
2244 log_unit_debug(UNIT(s)->id, "Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2246 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2250 /* the pidfile might have appeared just before we set the watch */
2251 log_unit_debug(UNIT(s)->id, "Trying to read %s's PID file %s in case it changed", UNIT(s)->id, s->pid_file_pathspec->path);
2252 service_retry_pid_file(s);
2256 log_unit_error_errno(UNIT(s)->id, r, "Failed to set a watch for %s's PID file %s: %m", UNIT(s)->id, s->pid_file_pathspec->path);
2257 service_unwatch_pid_file(s);
2261 static int service_demand_pid_file(Service *s) {
2264 assert(s->pid_file);
2265 assert(!s->pid_file_pathspec);
2267 ps = new0(PathSpec, 1);
2272 ps->path = strdup(s->pid_file);
2278 path_kill_slashes(ps->path);
2280 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2281 * keep their PID file open all the time. */
2282 ps->type = PATH_MODIFIED;
2283 ps->inotify_fd = -1;
2285 s->pid_file_pathspec = ps;
2287 return service_watch_pid_file(s);
2290 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2291 PathSpec *p = userdata;
2296 s = SERVICE(p->unit);
2300 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2301 assert(s->pid_file_pathspec);
2302 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2304 log_unit_debug(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2306 if (path_spec_fd_event(p, events) < 0)
2309 if (service_retry_pid_file(s) == 0)
2312 if (service_watch_pid_file(s) < 0)
2318 service_unwatch_pid_file(s);
2319 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2323 static void service_notify_cgroup_empty_event(Unit *u) {
2324 Service *s = SERVICE(u);
2328 log_unit_debug(u->id, "%s: cgroup is empty", u->id);
2332 /* Waiting for SIGCHLD is usually more interesting,
2333 * because it includes return codes/signals. Which is
2334 * why we ignore the cgroup events for most cases,
2335 * except when we don't know pid which to expect the
2339 case SERVICE_START_POST:
2340 /* If we were hoping for the daemon to write its PID file,
2341 * we can give up now. */
2342 if (s->pid_file_pathspec) {
2343 log_unit_warning(u->id, "%s never wrote its PID file. Failing.", UNIT(s)->id);
2345 service_unwatch_pid_file(s);
2346 if (s->state == SERVICE_START)
2347 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2349 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2353 case SERVICE_RUNNING:
2354 /* service_enter_running() will figure out what to do */
2355 service_enter_running(s, SERVICE_SUCCESS);
2358 case SERVICE_STOP_SIGABRT:
2359 case SERVICE_STOP_SIGTERM:
2360 case SERVICE_STOP_SIGKILL:
2362 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2363 service_enter_stop_post(s, SERVICE_SUCCESS);
2367 case SERVICE_STOP_POST:
2368 case SERVICE_FINAL_SIGTERM:
2369 case SERVICE_FINAL_SIGKILL:
2370 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2371 service_enter_dead(s, SERVICE_SUCCESS, true);
2380 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2381 Service *s = SERVICE(u);
2387 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2388 is_clean_exit_lsb(code, status, &s->success_status))
2389 f = SERVICE_SUCCESS;
2390 else if (code == CLD_EXITED)
2391 f = SERVICE_FAILURE_EXIT_CODE;
2392 else if (code == CLD_KILLED)
2393 f = SERVICE_FAILURE_SIGNAL;
2394 else if (code == CLD_DUMPED)
2395 f = SERVICE_FAILURE_CORE_DUMP;
2397 assert_not_reached("Unknown code");
2399 if (s->main_pid == pid) {
2400 /* Forking services may occasionally move to a new PID.
2401 * As long as they update the PID file before exiting the old
2402 * PID, they're fine. */
2403 if (service_load_pid_file(s, false) == 0)
2407 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2409 if (s->main_command) {
2410 /* If this is not a forking service than the
2411 * main process got started and hence we copy
2412 * the exit status so that it is recorded both
2413 * as main and as control process exit
2416 s->main_command->exec_status = s->main_exec_status;
2418 if (s->main_command->ignore)
2419 f = SERVICE_SUCCESS;
2420 } else if (s->exec_command[SERVICE_EXEC_START]) {
2422 /* If this is a forked process, then we should
2423 * ignore the return value if this was
2424 * configured for the starter process */
2426 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2427 f = SERVICE_SUCCESS;
2430 log_unit_struct(u->id,
2431 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2432 LOG_MESSAGE("%s: main process exited, code=%s, status=%i/%s",
2433 u->id, sigchld_code_to_string(code), status,
2434 strna(code == CLD_EXITED
2435 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2436 : signal_to_string(status))),
2437 "EXIT_CODE=%s", sigchld_code_to_string(code),
2438 "EXIT_STATUS=%i", status,
2441 if (f != SERVICE_SUCCESS)
2444 if (s->main_command &&
2445 s->main_command->command_next &&
2446 f == SERVICE_SUCCESS) {
2448 /* There is another command to *
2449 * execute, so let's do that. */
2451 log_unit_debug(u->id, "%s running next main command for state %s", u->id, service_state_to_string(s->state));
2452 service_run_next_main(s);
2456 /* The service exited, so the service is officially
2458 s->main_command = NULL;
2462 case SERVICE_START_POST:
2463 case SERVICE_RELOAD:
2465 /* Need to wait until the operation is
2470 if (s->type == SERVICE_ONESHOT) {
2471 /* This was our main goal, so let's go on */
2472 if (f == SERVICE_SUCCESS)
2473 service_enter_start_post(s);
2475 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2481 case SERVICE_RUNNING:
2482 service_enter_running(s, f);
2485 case SERVICE_STOP_SIGABRT:
2486 case SERVICE_STOP_SIGTERM:
2487 case SERVICE_STOP_SIGKILL:
2489 if (!control_pid_good(s))
2490 service_enter_stop_post(s, f);
2492 /* If there is still a control process, wait for that first */
2495 case SERVICE_STOP_POST:
2496 case SERVICE_FINAL_SIGTERM:
2497 case SERVICE_FINAL_SIGKILL:
2499 if (!control_pid_good(s))
2500 service_enter_dead(s, f, true);
2504 assert_not_reached("Uh, main process died at wrong time.");
2508 } else if (s->control_pid == pid) {
2511 if (s->control_command) {
2512 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2514 if (s->control_command->ignore)
2515 f = SERVICE_SUCCESS;
2518 log_unit_full(u->id,
2519 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2520 "%s: control process exited, code=%s status=%i",
2521 u->id, sigchld_code_to_string(code), status);
2523 if (f != SERVICE_SUCCESS)
2526 /* Immediately get rid of the cgroup, so that the
2527 * kernel doesn't delay the cgroup empty messages for
2528 * the service cgroup any longer than necessary */
2529 service_kill_control_processes(s);
2531 if (s->control_command &&
2532 s->control_command->command_next &&
2533 f == SERVICE_SUCCESS) {
2535 /* There is another command to *
2536 * execute, so let's do that. */
2538 log_unit_debug(u->id, "%s running next control command for state %s", u->id, service_state_to_string(s->state));
2539 service_run_next_control(s);
2542 /* No further commands for this step, so let's
2543 * figure out what to do next */
2545 s->control_command = NULL;
2546 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2548 log_unit_debug(u->id, "%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2552 case SERVICE_START_PRE:
2553 if (f == SERVICE_SUCCESS)
2554 service_enter_start(s);
2556 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2560 if (s->type != SERVICE_FORKING)
2561 /* Maybe spurious event due to a reload that changed the type? */
2564 if (f != SERVICE_SUCCESS) {
2565 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2570 bool has_start_post;
2573 /* Let's try to load the pid file here if we can.
2574 * The PID file might actually be created by a START_POST
2575 * script. In that case don't worry if the loading fails. */
2577 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2578 r = service_load_pid_file(s, !has_start_post);
2579 if (!has_start_post && r < 0) {
2580 r = service_demand_pid_file(s);
2581 if (r < 0 || !cgroup_good(s))
2582 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2586 service_search_main_pid(s);
2588 service_enter_start_post(s);
2591 case SERVICE_START_POST:
2592 if (f != SERVICE_SUCCESS) {
2593 service_enter_stop(s, f);
2600 r = service_load_pid_file(s, true);
2602 r = service_demand_pid_file(s);
2603 if (r < 0 || !cgroup_good(s))
2604 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2608 service_search_main_pid(s);
2610 service_enter_running(s, SERVICE_SUCCESS);
2613 case SERVICE_RELOAD:
2614 if (f == SERVICE_SUCCESS) {
2615 service_load_pid_file(s, true);
2616 service_search_main_pid(s);
2619 s->reload_result = f;
2620 service_enter_running(s, SERVICE_SUCCESS);
2624 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2627 case SERVICE_STOP_SIGABRT:
2628 case SERVICE_STOP_SIGTERM:
2629 case SERVICE_STOP_SIGKILL:
2630 if (main_pid_good(s) <= 0)
2631 service_enter_stop_post(s, f);
2633 /* If there is still a service
2634 * process around, wait until
2635 * that one quit, too */
2638 case SERVICE_STOP_POST:
2639 case SERVICE_FINAL_SIGTERM:
2640 case SERVICE_FINAL_SIGKILL:
2641 if (main_pid_good(s) <= 0)
2642 service_enter_dead(s, f, true);
2646 assert_not_reached("Uh, control process died at wrong time.");
2651 /* Notify clients about changed exit status */
2652 unit_add_to_dbus_queue(u);
2654 /* We got one SIGCHLD for the service, let's watch all
2655 * processes that are now running of the service, and watch
2656 * that. Among the PIDs we then watch will be children
2657 * reassigned to us, which hopefully allows us to identify
2658 * when all children are gone */
2659 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2660 unit_watch_all_pids(u);
2662 /* If the PID set is empty now, then let's finish this off */
2663 if (set_isempty(u->pids))
2664 service_notify_cgroup_empty_event(u);
2667 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2668 Service *s = SERVICE(userdata);
2671 assert(source == s->timer_event_source);
2675 case SERVICE_START_PRE:
2677 log_unit_warning(UNIT(s)->id, "%s %s operation timed out. Terminating.", UNIT(s)->id, s->state == SERVICE_START ? "start" : "start-pre");
2678 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2681 case SERVICE_START_POST:
2682 log_unit_warning(UNIT(s)->id, "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2683 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2686 case SERVICE_RELOAD:
2687 log_unit_warning(UNIT(s)->id, "%s reload operation timed out. Stopping.", UNIT(s)->id);
2688 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2689 service_enter_running(s, SERVICE_SUCCESS);
2693 log_unit_warning(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
2694 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2697 case SERVICE_STOP_SIGABRT:
2698 log_unit_warning(UNIT(s)->id,
2699 "%s stop-sigabrt timed out. Terminating.", UNIT(s)->id);
2700 service_enter_signal(s, SERVICE_STOP_SIGTERM, s->result);
2703 case SERVICE_STOP_SIGTERM:
2704 if (s->kill_context.send_sigkill) {
2705 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2706 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2708 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2709 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2714 case SERVICE_STOP_SIGKILL:
2715 /* Uh, we sent a SIGKILL and it is still not gone?
2716 * Must be something we cannot kill, so let's just be
2717 * weirded out and continue */
2719 log_unit_warning(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2720 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2723 case SERVICE_STOP_POST:
2724 log_unit_warning(UNIT(s)->id, "%s stop-post timed out. Terminating.", UNIT(s)->id);
2725 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2728 case SERVICE_FINAL_SIGTERM:
2729 if (s->kill_context.send_sigkill) {
2730 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2731 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2733 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.", UNIT(s)->id);
2734 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2739 case SERVICE_FINAL_SIGKILL:
2740 log_unit_warning(UNIT(s)->id, "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2741 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2744 case SERVICE_AUTO_RESTART:
2745 log_unit_info(UNIT(s)->id,
2746 s->restart_usec > 0 ?
2747 "%s holdoff time over, scheduling restart." :
2748 "%s has no holdoff time, scheduling restart.",
2750 service_enter_restart(s);
2754 assert_not_reached("Timeout at wrong time.");
2760 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2761 Service *s = SERVICE(userdata);
2762 char t[FORMAT_TIMESPAN_MAX];
2765 assert(source == s->watchdog_event_source);
2767 log_unit_error(UNIT(s)->id, "%s watchdog timeout (limit %s)!", UNIT(s)->id,
2768 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2770 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
2775 static void service_notify_message(Unit *u, pid_t pid, char **tags, FDSet *fds) {
2776 Service *s = SERVICE(u);
2777 _cleanup_free_ char *cc = NULL;
2778 bool notify_dbus = false;
2783 cc = strv_join(tags, ", ");
2784 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT" (%s)",
2785 u->id, pid, isempty(cc) ? "n/a" : cc);
2787 if (s->notify_access == NOTIFY_NONE) {
2788 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception is disabled.", u->id, pid);
2792 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2793 if (s->main_pid != 0)
2794 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, u->id, pid, s->main_pid);
2796 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", u->id, pid);
2800 /* Interpret MAINPID= */
2801 e = strv_find_startswith(tags, "MAINPID=");
2802 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2803 if (parse_pid(e, &pid) < 0)
2804 log_unit_warning(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2806 log_unit_debug(u->id, "%s: got MAINPID=%s", u->id, e);
2808 service_set_main_pid(s, pid);
2809 unit_watch_pid(UNIT(s), pid);
2814 /* Interpret RELOADING= */
2815 if (strv_find(tags, "RELOADING=1")) {
2817 log_unit_debug(u->id, "%s: got RELOADING=1", u->id);
2818 s->notify_state = NOTIFY_RELOADING;
2820 if (s->state == SERVICE_RUNNING)
2821 service_enter_reload_by_notify(s);
2826 /* Interpret READY= */
2827 if (strv_find(tags, "READY=1")) {
2829 log_unit_debug(u->id, "%s: got READY=1", u->id);
2830 s->notify_state = NOTIFY_READY;
2832 /* Type=notify services inform us about completed
2833 * initialization with READY=1 */
2834 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
2835 service_enter_start_post(s);
2837 /* Sending READY=1 while we are reloading informs us
2838 * that the reloading is complete */
2839 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
2840 service_enter_running(s, SERVICE_SUCCESS);
2845 /* Interpret STOPPING= */
2846 if (strv_find(tags, "STOPPING=1")) {
2848 log_unit_debug(u->id, "%s: got STOPPING=1", u->id);
2849 s->notify_state = NOTIFY_STOPPING;
2851 if (s->state == SERVICE_RUNNING)
2852 service_enter_stop_by_notify(s);
2857 /* Interpret STATUS= */
2858 e = strv_find_startswith(tags, "STATUS=");
2860 _cleanup_free_ char *t = NULL;
2863 if (!utf8_is_valid(e))
2864 log_unit_warning(u->id, "Status message in notification is not UTF-8 clean.");
2866 log_unit_debug(u->id, "%s: got STATUS=%s", u->id, e);
2874 if (!streq_ptr(s->status_text, t)) {
2876 free(s->status_text);
2884 /* Interpret ERRNO= */
2885 e = strv_find_startswith(tags, "ERRNO=");
2889 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
2890 log_unit_warning(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2892 log_unit_debug(u->id, "%s: got ERRNO=%s", u->id, e);
2894 if (s->status_errno != status_errno) {
2895 s->status_errno = status_errno;
2901 /* Interpret WATCHDOG= */
2902 if (strv_find(tags, "WATCHDOG=1")) {
2903 log_unit_debug(u->id, "%s: got WATCHDOG=1", u->id);
2904 service_reset_watchdog(s);
2907 /* Add the passed fds to the fd store */
2908 if (strv_find(tags, "FDSTORE=1")) {
2909 log_unit_debug(u->id, "%s: got FDSTORE=1", u->id);
2910 service_add_fd_store_set(s, fds);
2913 /* Notify clients about changed status or main pid */
2915 unit_add_to_dbus_queue(u);
2918 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2919 Service *s = SERVICE(u);
2922 if (!s->timer_event_source)
2925 r = sd_event_source_get_time(s->timer_event_source, timeout);
2932 static void service_bus_name_owner_change(
2935 const char *old_owner,
2936 const char *new_owner) {
2938 Service *s = SERVICE(u);
2944 assert(streq(s->bus_name, name));
2945 assert(old_owner || new_owner);
2947 if (old_owner && new_owner)
2948 log_unit_debug(u->id, "%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
2950 log_unit_debug(u->id, "%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
2952 log_unit_debug(u->id, "%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
2954 s->bus_name_good = !!new_owner;
2956 if (s->type == SERVICE_DBUS) {
2958 /* service_enter_running() will figure out what to
2960 if (s->state == SERVICE_RUNNING)
2961 service_enter_running(s, SERVICE_SUCCESS);
2962 else if (s->state == SERVICE_START && new_owner)
2963 service_enter_start_post(s);
2965 } else if (new_owner &&
2967 (s->state == SERVICE_START ||
2968 s->state == SERVICE_START_POST ||
2969 s->state == SERVICE_RUNNING ||
2970 s->state == SERVICE_RELOAD)) {
2972 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2975 /* Try to acquire PID from bus service */
2977 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2979 r = sd_bus_creds_get_pid(creds, &pid);
2981 log_unit_debug(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2983 service_set_main_pid(s, pid);
2984 unit_watch_pid(UNIT(s), pid);
2989 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
2990 _cleanup_free_ char *peer = NULL;
2996 /* This is called by the socket code when instantiating a new
2997 * service for a stream socket and the socket needs to be
3000 if (UNIT(s)->load_state != UNIT_LOADED)
3003 if (s->socket_fd >= 0)
3006 if (s->state != SERVICE_DEAD)
3009 if (getpeername_pretty(fd, &peer) >= 0) {
3011 if (UNIT(s)->description) {
3012 _cleanup_free_ char *a;
3014 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3018 r = unit_set_description(UNIT(s), a);
3020 r = unit_set_description(UNIT(s), peer);
3027 s->socket_fd_selinux_context_net = selinux_context_net;
3029 unit_ref_set(&s->accept_socket, UNIT(sock));
3031 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3034 static void service_reset_failed(Unit *u) {
3035 Service *s = SERVICE(u);
3039 if (s->state == SERVICE_FAILED)
3040 service_set_state(s, SERVICE_DEAD);
3042 s->result = SERVICE_SUCCESS;
3043 s->reload_result = SERVICE_SUCCESS;
3045 RATELIMIT_RESET(s->start_limit);
3048 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3049 Service *s = SERVICE(u);
3051 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3054 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3055 [SERVICE_DEAD] = "dead",
3056 [SERVICE_START_PRE] = "start-pre",
3057 [SERVICE_START] = "start",
3058 [SERVICE_START_POST] = "start-post",
3059 [SERVICE_RUNNING] = "running",
3060 [SERVICE_EXITED] = "exited",
3061 [SERVICE_RELOAD] = "reload",
3062 [SERVICE_STOP] = "stop",
3063 [SERVICE_STOP_SIGABRT] = "stop-sigabrt",
3064 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3065 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3066 [SERVICE_STOP_POST] = "stop-post",
3067 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3068 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3069 [SERVICE_FAILED] = "failed",
3070 [SERVICE_AUTO_RESTART] = "auto-restart",
3073 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3075 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3076 [SERVICE_RESTART_NO] = "no",
3077 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3078 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3079 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
3080 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3081 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3082 [SERVICE_RESTART_ALWAYS] = "always",
3085 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3087 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3088 [SERVICE_SIMPLE] = "simple",
3089 [SERVICE_FORKING] = "forking",
3090 [SERVICE_ONESHOT] = "oneshot",
3091 [SERVICE_DBUS] = "dbus",
3092 [SERVICE_NOTIFY] = "notify",
3093 [SERVICE_IDLE] = "idle"
3096 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3098 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3099 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3100 [SERVICE_EXEC_START] = "ExecStart",
3101 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3102 [SERVICE_EXEC_RELOAD] = "ExecReload",
3103 [SERVICE_EXEC_STOP] = "ExecStop",
3104 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3107 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3109 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3110 [NOTIFY_NONE] = "none",
3111 [NOTIFY_MAIN] = "main",
3112 [NOTIFY_ALL] = "all"
3115 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3117 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
3118 [NOTIFY_UNKNOWN] = "unknown",
3119 [NOTIFY_READY] = "ready",
3120 [NOTIFY_RELOADING] = "reloading",
3121 [NOTIFY_STOPPING] = "stopping",
3124 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
3126 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3127 [SERVICE_SUCCESS] = "success",
3128 [SERVICE_FAILURE_RESOURCES] = "resources",
3129 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3130 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3131 [SERVICE_FAILURE_SIGNAL] = "signal",
3132 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3133 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3134 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3137 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3139 const UnitVTable service_vtable = {
3140 .object_size = sizeof(Service),
3141 .exec_context_offset = offsetof(Service, exec_context),
3142 .cgroup_context_offset = offsetof(Service, cgroup_context),
3143 .kill_context_offset = offsetof(Service, kill_context),
3144 .exec_runtime_offset = offsetof(Service, exec_runtime),
3150 .private_section = "Service",
3152 .init = service_init,
3153 .done = service_done,
3154 .load = service_load,
3155 .release_resources = service_release_resources,
3157 .coldplug = service_coldplug,
3159 .dump = service_dump,
3161 .start = service_start,
3162 .stop = service_stop,
3163 .reload = service_reload,
3165 .can_reload = service_can_reload,
3167 .kill = service_kill,
3169 .serialize = service_serialize,
3170 .deserialize_item = service_deserialize_item,
3172 .active_state = service_active_state,
3173 .sub_state_to_string = service_sub_state_to_string,
3175 .check_gc = service_check_gc,
3176 .check_snapshot = service_check_snapshot,
3178 .sigchld_event = service_sigchld_event,
3180 .reset_failed = service_reset_failed,
3182 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3183 .notify_message = service_notify_message,
3185 .bus_name_owner_change = service_bus_name_owner_change,
3187 .bus_interface = "org.freedesktop.systemd1.Service",
3188 .bus_vtable = bus_service_vtable,
3189 .bus_set_property = bus_service_set_property,
3190 .bus_commit_properties = bus_service_commit_properties,
3192 .get_timeout = service_get_timeout,
3193 .can_transient = true,
3195 .status_message_formats = {
3196 .starting_stopping = {
3197 [0] = "Starting %s...",
3198 [1] = "Stopping %s...",
3200 .finished_start_job = {
3201 [JOB_DONE] = "Started %s.",
3202 [JOB_FAILED] = "Failed to start %s.",
3203 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3204 [JOB_TIMEOUT] = "Timed out starting %s.",
3206 .finished_stop_job = {
3207 [JOB_DONE] = "Stopped %s.",
3208 [JOB_FAILED] = "Stopped (with error) %s.",
3209 [JOB_TIMEOUT] = "Timed out stopping %s.",