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;
560 r = unit_watch_bus_name(UNIT(s), s->bus_name);
564 n = strjoina(s->bus_name, ".busname");
565 r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, n, NULL, true);
570 if (UNIT(s)->default_dependencies) {
571 r = service_add_default_dependencies(s);
579 static int service_load(Unit *u) {
580 Service *s = SERVICE(u);
585 /* Load a .service file */
586 r = unit_load_fragment(u);
590 /* Still nothing found? Then let's give up */
591 if (u->load_state == UNIT_STUB)
594 /* This is a new unit? Then let's add in some extras */
595 if (u->load_state == UNIT_LOADED) {
597 /* We were able to load something, then let's add in
598 * the dropin directories. */
599 r = unit_load_dropin(u);
603 /* This is a new unit? Then let's add in some
605 r = service_add_extras(s);
610 return service_verify(s);
613 static void service_dump(Unit *u, FILE *f, const char *prefix) {
614 ServiceExecCommand c;
615 Service *s = SERVICE(u);
620 prefix = strempty(prefix);
621 prefix2 = strjoina(prefix, "\t");
624 "%sService State: %s\n"
626 "%sReload Result: %s\n"
627 "%sPermissionsStartOnly: %s\n"
628 "%sRootDirectoryStartOnly: %s\n"
629 "%sRemainAfterExit: %s\n"
630 "%sGuessMainPID: %s\n"
633 "%sNotifyAccess: %s\n"
634 "%sNotifyState: %s\n",
635 prefix, service_state_to_string(s->state),
636 prefix, service_result_to_string(s->result),
637 prefix, service_result_to_string(s->reload_result),
638 prefix, yes_no(s->permissions_start_only),
639 prefix, yes_no(s->root_directory_start_only),
640 prefix, yes_no(s->remain_after_exit),
641 prefix, yes_no(s->guess_main_pid),
642 prefix, service_type_to_string(s->type),
643 prefix, service_restart_to_string(s->restart),
644 prefix, notify_access_to_string(s->notify_access),
645 prefix, notify_state_to_string(s->notify_state));
647 if (s->control_pid > 0)
649 "%sControl PID: "PID_FMT"\n",
650 prefix, s->control_pid);
654 "%sMain PID: "PID_FMT"\n"
655 "%sMain PID Known: %s\n"
656 "%sMain PID Alien: %s\n",
658 prefix, yes_no(s->main_pid_known),
659 prefix, yes_no(s->main_pid_alien));
664 prefix, s->pid_file);
669 "%sBus Name Good: %s\n",
671 prefix, yes_no(s->bus_name_good));
673 kill_context_dump(&s->kill_context, f, prefix);
674 exec_context_dump(&s->exec_context, f, prefix);
676 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
678 if (!s->exec_command[c])
681 fprintf(f, "%s-> %s:\n",
682 prefix, service_exec_command_to_string(c));
684 exec_command_dump_list(s->exec_command[c], f, prefix2);
688 fprintf(f, "%sStatus Text: %s\n",
689 prefix, s->status_text);
691 if (s->n_fd_store_max > 0) {
693 "%sFile Descriptor Store Max: %u\n"
694 "%sFile Descriptor Store Current: %u\n",
695 prefix, s->n_fd_store_max,
696 prefix, s->n_fd_store);
700 static int service_load_pid_file(Service *s, bool may_warn) {
701 _cleanup_free_ char *k = NULL;
710 r = read_one_line_file(s->pid_file, &k);
713 log_unit_info(UNIT(s)->id, "PID file %s not readable (yet?) after %s.", s->pid_file, service_state_to_string(s->state));
717 r = parse_pid(k, &pid);
720 log_unit_info_errno(UNIT(s)->id, r, "Failed to read PID from file %s: %m", s->pid_file);
724 if (!pid_is_alive(pid)) {
726 log_unit_info(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
730 if (s->main_pid_known) {
731 if (pid == s->main_pid)
734 log_unit_debug(UNIT(s)->id, "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
736 service_unwatch_main_pid(s);
737 s->main_pid_known = false;
739 log_unit_debug(UNIT(s)->id, "Main PID loaded: "PID_FMT, pid);
741 r = service_set_main_pid(s, pid);
745 r = unit_watch_pid(UNIT(s), pid);
747 /* FIXME: we need to do something here */
748 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
755 static int service_search_main_pid(Service *s) {
761 /* If we know it anyway, don't ever fallback to unreliable
763 if (s->main_pid_known)
766 if (!s->guess_main_pid)
769 assert(s->main_pid <= 0);
771 pid = unit_search_main_pid(UNIT(s));
775 log_unit_debug(UNIT(s)->id, "Main PID guessed: "PID_FMT, pid);
776 r = service_set_main_pid(s, pid);
780 r = unit_watch_pid(UNIT(s), pid);
782 /* FIXME: we need to do something here */
783 log_unit_warning(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
790 static void service_set_state(Service *s, ServiceState state) {
791 ServiceState old_state;
792 const UnitActiveState *table;
796 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
798 old_state = s->state;
801 service_unwatch_pid_file(s);
804 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
806 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
807 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
808 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
809 SERVICE_AUTO_RESTART))
810 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
813 SERVICE_START, SERVICE_START_POST,
814 SERVICE_RUNNING, SERVICE_RELOAD,
815 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
816 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
817 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
818 service_unwatch_main_pid(s);
819 s->main_command = NULL;
823 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
825 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
826 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
827 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
828 service_unwatch_control_pid(s);
829 s->control_command = NULL;
830 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
833 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
834 unit_unwatch_all_pids(UNIT(s));
837 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
838 SERVICE_RUNNING, SERVICE_RELOAD,
839 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
840 SERVICE_STOP_SIGABRT, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
841 !(state == SERVICE_DEAD && UNIT(s)->job)) {
842 service_close_socket_fd(s);
843 service_connection_unref(s);
846 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
847 service_stop_watchdog(s);
849 /* For the inactive states unit_notify() will trim the cgroup,
850 * but for exit we have to do that ourselves... */
851 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
852 unit_destroy_cgroup_if_empty(UNIT(s));
854 /* For remain_after_exit services, let's see if we can "release" the
855 * hold on the console, since unit_notify() only does that in case of
857 if (state == SERVICE_EXITED &&
858 s->remain_after_exit &&
859 UNIT(s)->manager->n_on_console > 0) {
863 ec = unit_get_exec_context(UNIT(s));
864 if (ec && exec_context_may_touch_console(ec)) {
865 Manager *m = UNIT(s)->manager;
868 if (m->n_on_console == 0)
869 /* unset no_console_output flag, since the console is free */
870 m->no_console_output = false;
874 if (old_state != state)
875 log_unit_debug(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
877 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
878 s->reload_result = SERVICE_SUCCESS;
881 static int service_coldplug(Unit *u) {
882 Service *s = SERVICE(u);
886 assert(s->state == SERVICE_DEAD);
888 if (s->deserialized_state != s->state) {
890 if (IN_SET(s->deserialized_state,
891 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
893 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
894 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
895 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
899 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
901 /* For the start/stop timeouts 0 means off */
903 r = service_arm_timer(s, k);
909 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
911 /* The restart timeouts 0 means immediately */
912 r = service_arm_timer(s, s->restart_usec);
917 if (pid_is_unwaited(s->main_pid) &&
918 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
919 IN_SET(s->deserialized_state,
920 SERVICE_START, SERVICE_START_POST,
921 SERVICE_RUNNING, SERVICE_RELOAD,
922 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
923 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
924 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
925 r = unit_watch_pid(UNIT(s), s->main_pid);
930 if (pid_is_unwaited(s->control_pid) &&
931 IN_SET(s->deserialized_state,
932 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
934 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
935 SERVICE_STOP_SIGABRT, SERVICE_STOP_POST,
936 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
937 r = unit_watch_pid(UNIT(s), s->control_pid);
942 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
943 unit_watch_all_pids(UNIT(s));
945 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
946 service_start_watchdog(s);
948 service_set_state(s, s->deserialized_state);
954 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
955 _cleanup_free_ int *rfds = NULL;
965 if (s->socket_fd >= 0)
968 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
973 if (u->type != UNIT_SOCKET)
978 r = socket_collect_fds(sock, &cfds, &cn_fds);
993 t = realloc(rfds, (rn_fds + cn_fds) * sizeof(int));
999 memcpy(t + rn_fds, cfds, cn_fds * sizeof(int));
1008 if (s->n_fd_store > 0) {
1012 t = realloc(rfds, (rn_fds + s->n_fd_store) * sizeof(int));
1017 LIST_FOREACH(fd_store, fs, s->fd_store)
1018 rfds[rn_fds++] = fs->fd;
1028 static int service_spawn(
1033 bool apply_permissions,
1035 bool apply_tty_stdin,
1042 _cleanup_free_ int *fdsbuf = NULL;
1043 unsigned n_fds = 0, n_env = 0;
1044 _cleanup_free_ char *bus_endpoint_path = NULL;
1045 _cleanup_strv_free_ char
1046 **argv = NULL, **final_env = NULL, **our_env = NULL;
1048 ExecParameters exec_params = {
1049 .apply_permissions = apply_permissions,
1050 .apply_chroot = apply_chroot,
1051 .apply_tty_stdin = apply_tty_stdin,
1052 .bus_endpoint_fd = -1,
1053 .selinux_context_net = s->socket_fd_selinux_context_net
1060 (void) unit_realize_cgroup(UNIT(s));
1061 if (s->reset_cpu_usage) {
1062 (void) unit_reset_cpu_usage(UNIT(s));
1063 s->reset_cpu_usage = false;
1066 r = unit_setup_exec_runtime(UNIT(s));
1071 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1072 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1073 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1075 if (s->socket_fd >= 0) {
1076 fds = &s->socket_fd;
1079 r = service_collect_fds(s, &fdsbuf, &n_fds);
1088 r = service_arm_timer(s, timeout);
1092 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1094 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1098 our_env = new0(char*, 4);
1104 if (is_control ? s->notify_access == NOTIFY_ALL : s->notify_access != NOTIFY_NONE)
1105 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1110 if (s->main_pid > 0)
1111 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
1116 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
1117 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
1122 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1128 if (is_control && UNIT(s)->cgroup_path) {
1129 path = strjoina(UNIT(s)->cgroup_path, "/control");
1130 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1132 path = UNIT(s)->cgroup_path;
1135 if (s->exec_context.bus_endpoint) {
1136 r = bus_kernel_create_endpoint(UNIT(s)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user",
1137 UNIT(s)->id, &bus_endpoint_path);
1141 /* Pass the fd to the exec_params so that the child process can upload the policy.
1142 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1143 * as the service is running. */
1144 exec_params.bus_endpoint_fd = s->bus_endpoint_fd = r;
1148 exec_params.argv = argv;
1149 exec_params.fds = fds;
1150 exec_params.n_fds = n_fds;
1151 exec_params.environment = final_env;
1152 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
1153 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
1154 exec_params.cgroup_path = path;
1155 exec_params.cgroup_delegate = s->cgroup_context.delegate;
1156 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
1157 exec_params.unit_id = UNIT(s)->id;
1158 exec_params.watchdog_usec = s->watchdog_usec;
1159 exec_params.bus_endpoint_path = bus_endpoint_path;
1160 if (s->type == SERVICE_IDLE)
1161 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1171 r = unit_watch_pid(UNIT(s), pid);
1173 /* FIXME: we need to do something here */
1182 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1187 static int main_pid_good(Service *s) {
1190 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1193 /* If we know the pid file, then lets just check if it is
1195 if (s->main_pid_known) {
1197 /* If it's an alien child let's check if it is still
1199 if (s->main_pid_alien && s->main_pid > 0)
1200 return pid_is_alive(s->main_pid);
1202 /* .. otherwise assume we'll get a SIGCHLD for it,
1203 * which we really should wait for to collect exit
1204 * status and code */
1205 return s->main_pid > 0;
1208 /* We don't know the pid */
1212 _pure_ static int control_pid_good(Service *s) {
1215 return s->control_pid > 0;
1218 static int cgroup_good(Service *s) {
1223 if (!UNIT(s)->cgroup_path)
1226 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1233 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1237 if (f != SERVICE_SUCCESS)
1240 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1242 if (s->result != SERVICE_SUCCESS) {
1243 log_unit_warning(UNIT(s)->id, "%s failed.", UNIT(s)->id);
1244 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1247 if (allow_restart &&
1248 !s->forbid_restart &&
1249 (s->restart == SERVICE_RESTART_ALWAYS ||
1250 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1251 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1252 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1253 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1254 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1255 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1256 (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)))) &&
1257 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
1258 (!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)))) {
1260 r = service_arm_timer(s, s->restart_usec);
1264 service_set_state(s, SERVICE_AUTO_RESTART);
1267 s->forbid_restart = false;
1269 /* We want fresh tmpdirs in case service is started again immediately */
1270 exec_runtime_destroy(s->exec_runtime);
1271 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1273 /* Also, remove the runtime directory in */
1274 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1276 /* Try to delete the pid file. At this point it will be
1277 * out-of-date, and some software might be confused by it, so
1278 * let's remove it. */
1280 unlink_noerrno(s->pid_file);
1285 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run install restart timer: %m", UNIT(s)->id);
1286 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1289 static void service_enter_stop_post(Service *s, ServiceResult f) {
1293 if (f != SERVICE_SUCCESS)
1296 service_unwatch_control_pid(s);
1297 unit_watch_all_pids(UNIT(s));
1299 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1300 if (s->control_command) {
1301 s->control_command_id = SERVICE_EXEC_STOP_POST;
1303 r = service_spawn(s,
1305 s->timeout_stop_usec,
1307 !s->permissions_start_only,
1308 !s->root_directory_start_only,
1315 service_set_state(s, SERVICE_STOP_POST);
1317 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1322 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop-post' task: %m", UNIT(s)->id);
1323 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1326 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1331 if (f != SERVICE_SUCCESS)
1334 unit_watch_all_pids(UNIT(s));
1336 r = unit_kill_context(
1339 (state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM && state != SERVICE_STOP_SIGABRT) ?
1340 KILL_KILL : (state == SERVICE_STOP_SIGABRT ? KILL_ABORT : KILL_TERMINATE),
1349 if (s->timeout_stop_usec > 0) {
1350 r = service_arm_timer(s, s->timeout_stop_usec);
1355 service_set_state(s, state);
1356 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGABRT)
1357 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1358 else if (state == SERVICE_STOP_SIGKILL)
1359 service_enter_stop_post(s, SERVICE_SUCCESS);
1360 else if (state == SERVICE_FINAL_SIGTERM)
1361 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1363 service_enter_dead(s, SERVICE_SUCCESS, true);
1368 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
1370 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL ||
1371 state == SERVICE_STOP_SIGABRT)
1372 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1374 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1377 static void service_enter_stop_by_notify(Service *s) {
1380 unit_watch_all_pids(UNIT(s));
1382 if (s->timeout_stop_usec > 0)
1383 service_arm_timer(s, s->timeout_stop_usec);
1385 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1386 service_set_state(s, SERVICE_STOP_SIGTERM);
1389 static void service_enter_stop(Service *s, ServiceResult f) {
1394 if (f != SERVICE_SUCCESS)
1397 service_unwatch_control_pid(s);
1398 unit_watch_all_pids(UNIT(s));
1400 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1401 if (s->control_command) {
1402 s->control_command_id = SERVICE_EXEC_STOP;
1404 r = service_spawn(s,
1406 s->timeout_stop_usec,
1408 !s->permissions_start_only,
1409 !s->root_directory_start_only,
1416 service_set_state(s, SERVICE_STOP);
1418 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1423 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop' task: %m", UNIT(s)->id);
1424 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1427 static void service_enter_running(Service *s, ServiceResult f) {
1428 int main_pid_ok, cgroup_ok;
1431 if (f != SERVICE_SUCCESS)
1434 main_pid_ok = main_pid_good(s);
1435 cgroup_ok = cgroup_good(s);
1437 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1438 (s->bus_name_good || s->type != SERVICE_DBUS)) {
1440 /* If there are any queued up sd_notify()
1441 * notifications, process them now */
1442 if (s->notify_state == NOTIFY_RELOADING)
1443 service_enter_reload_by_notify(s);
1444 else if (s->notify_state == NOTIFY_STOPPING)
1445 service_enter_stop_by_notify(s);
1447 service_set_state(s, SERVICE_RUNNING);
1449 } else if (s->remain_after_exit)
1450 service_set_state(s, SERVICE_EXITED);
1452 service_enter_stop(s, SERVICE_SUCCESS);
1455 static void service_enter_start_post(Service *s) {
1459 service_unwatch_control_pid(s);
1460 service_reset_watchdog(s);
1462 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1463 if (s->control_command) {
1464 s->control_command_id = SERVICE_EXEC_START_POST;
1466 r = service_spawn(s,
1468 s->timeout_start_usec,
1470 !s->permissions_start_only,
1471 !s->root_directory_start_only,
1478 service_set_state(s, SERVICE_START_POST);
1480 service_enter_running(s, SERVICE_SUCCESS);
1485 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-post' task: %m", UNIT(s)->id);
1486 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1489 static void service_kill_control_processes(Service *s) {
1492 if (!UNIT(s)->cgroup_path)
1495 p = strjoina(UNIT(s)->cgroup_path, "/control");
1496 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1499 static void service_enter_start(Service *s) {
1506 service_unwatch_control_pid(s);
1507 service_unwatch_main_pid(s);
1509 /* We want to ensure that nobody leaks processes from
1510 * START_PRE here, so let's go on a killing spree, People
1511 * should not spawn long running processes from START_PRE. */
1512 service_kill_control_processes(s);
1514 if (s->type == SERVICE_FORKING) {
1515 s->control_command_id = SERVICE_EXEC_START;
1516 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1518 s->main_command = NULL;
1520 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1521 s->control_command = NULL;
1523 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1527 assert(s->type == SERVICE_ONESHOT);
1528 service_enter_start_post(s);
1532 r = service_spawn(s,
1534 IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_ONESHOT) ? s->timeout_start_usec : 0,
1544 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1545 /* For simple services we immediately start
1546 * the START_POST binaries. */
1548 service_set_main_pid(s, pid);
1549 service_enter_start_post(s);
1551 } else if (s->type == SERVICE_FORKING) {
1553 /* For forking services we wait until the start
1554 * process exited. */
1556 s->control_pid = pid;
1557 service_set_state(s, SERVICE_START);
1559 } else if (s->type == SERVICE_ONESHOT ||
1560 s->type == SERVICE_DBUS ||
1561 s->type == SERVICE_NOTIFY) {
1563 /* For oneshot services we wait until the start
1564 * process exited, too, but it is our main process. */
1566 /* For D-Bus services we know the main pid right away,
1567 * but wait for the bus name to appear on the
1568 * bus. Notify services are similar. */
1570 service_set_main_pid(s, pid);
1571 service_set_state(s, SERVICE_START);
1573 assert_not_reached("Unknown service type");
1578 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start' task: %m", UNIT(s)->id);
1579 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1582 static void service_enter_start_pre(Service *s) {
1587 service_unwatch_control_pid(s);
1589 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1590 if (s->control_command) {
1591 /* Before we start anything, let's clear up what might
1592 * be left from previous runs. */
1593 service_kill_control_processes(s);
1595 s->control_command_id = SERVICE_EXEC_START_PRE;
1597 r = service_spawn(s,
1599 s->timeout_start_usec,
1601 !s->permissions_start_only,
1602 !s->root_directory_start_only,
1609 service_set_state(s, SERVICE_START_PRE);
1611 service_enter_start(s);
1616 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-pre' task: %m", UNIT(s)->id);
1617 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1620 static void service_enter_restart(Service *s) {
1621 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1626 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1627 /* Don't restart things if we are going down anyway */
1628 log_unit_info(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1630 r = service_arm_timer(s, s->restart_usec);
1637 /* Any units that are bound to this service must also be
1638 * restarted. We use JOB_RESTART (instead of the more obvious
1639 * JOB_START) here so that those dependency jobs will be added
1641 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1645 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1646 * it will be canceled as part of the service_stop() call that
1647 * is executed as part of JOB_RESTART. */
1649 log_unit_debug(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1653 log_unit_warning(UNIT(s)->id, "%s failed to schedule restart job: %s", UNIT(s)->id, bus_error_message(&error, -r));
1654 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1657 static void service_enter_reload_by_notify(Service *s) {
1660 if (s->timeout_start_usec > 0)
1661 service_arm_timer(s, s->timeout_start_usec);
1663 service_set_state(s, SERVICE_RELOAD);
1666 static void service_enter_reload(Service *s) {
1671 service_unwatch_control_pid(s);
1673 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1674 if (s->control_command) {
1675 s->control_command_id = SERVICE_EXEC_RELOAD;
1677 r = service_spawn(s,
1679 s->timeout_start_usec,
1681 !s->permissions_start_only,
1682 !s->root_directory_start_only,
1689 service_set_state(s, SERVICE_RELOAD);
1691 service_enter_running(s, SERVICE_SUCCESS);
1696 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'reload' task: %m", UNIT(s)->id);
1697 s->reload_result = SERVICE_FAILURE_RESOURCES;
1698 service_enter_running(s, SERVICE_SUCCESS);
1701 static void service_run_next_control(Service *s) {
1705 assert(s->control_command);
1706 assert(s->control_command->command_next);
1708 assert(s->control_command_id != SERVICE_EXEC_START);
1710 s->control_command = s->control_command->command_next;
1711 service_unwatch_control_pid(s);
1713 r = service_spawn(s,
1715 IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec,
1717 !s->permissions_start_only,
1718 !s->root_directory_start_only,
1719 s->control_command_id == SERVICE_EXEC_START_PRE ||
1720 s->control_command_id == SERVICE_EXEC_STOP_POST,
1729 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next control task: %m", UNIT(s)->id);
1731 if (s->state == SERVICE_START_PRE)
1732 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1733 else if (s->state == SERVICE_STOP)
1734 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1735 else if (s->state == SERVICE_STOP_POST)
1736 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1737 else if (s->state == SERVICE_RELOAD) {
1738 s->reload_result = SERVICE_FAILURE_RESOURCES;
1739 service_enter_running(s, SERVICE_SUCCESS);
1741 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1744 static void service_run_next_main(Service *s) {
1749 assert(s->main_command);
1750 assert(s->main_command->command_next);
1751 assert(s->type == SERVICE_ONESHOT);
1753 s->main_command = s->main_command->command_next;
1754 service_unwatch_main_pid(s);
1756 r = service_spawn(s,
1758 s->timeout_start_usec,
1768 service_set_main_pid(s, pid);
1773 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next main task: %m", UNIT(s)->id);
1774 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1777 static int service_start_limit_test(Service *s) {
1780 if (ratelimit_test(&s->start_limit))
1783 log_unit_warning(UNIT(s)->id, "start request repeated too quickly for %s", UNIT(s)->id);
1785 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
1788 static int service_start(Unit *u) {
1789 Service *s = SERVICE(u);
1794 /* We cannot fulfill this request right now, try again later
1796 if (s->state == SERVICE_STOP ||
1797 s->state == SERVICE_STOP_SIGABRT ||
1798 s->state == SERVICE_STOP_SIGTERM ||
1799 s->state == SERVICE_STOP_SIGKILL ||
1800 s->state == SERVICE_STOP_POST ||
1801 s->state == SERVICE_FINAL_SIGTERM ||
1802 s->state == SERVICE_FINAL_SIGKILL)
1805 /* Already on it! */
1806 if (s->state == SERVICE_START_PRE ||
1807 s->state == SERVICE_START ||
1808 s->state == SERVICE_START_POST)
1811 /* A service that will be restarted must be stopped first to
1812 * trigger BindsTo and/or OnFailure dependencies. If a user
1813 * does not want to wait for the holdoff time to elapse, the
1814 * service should be manually restarted, not started. We
1815 * simply return EAGAIN here, so that any start jobs stay
1816 * queued, and assume that the auto restart timer will
1817 * eventually trigger the restart. */
1818 if (s->state == SERVICE_AUTO_RESTART)
1821 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1823 /* Make sure we don't enter a busy loop of some kind. */
1824 r = service_start_limit_test(s);
1826 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1830 s->result = SERVICE_SUCCESS;
1831 s->reload_result = SERVICE_SUCCESS;
1832 s->main_pid_known = false;
1833 s->main_pid_alien = false;
1834 s->forbid_restart = false;
1835 s->reset_cpu_usage = true;
1837 free(s->status_text);
1838 s->status_text = NULL;
1839 s->status_errno = 0;
1841 s->notify_state = NOTIFY_UNKNOWN;
1843 service_enter_start_pre(s);
1847 static int service_stop(Unit *u) {
1848 Service *s = SERVICE(u);
1852 /* Don't create restart jobs from here. */
1853 s->forbid_restart = true;
1856 if (s->state == SERVICE_STOP ||
1857 s->state == SERVICE_STOP_SIGABRT ||
1858 s->state == SERVICE_STOP_SIGTERM ||
1859 s->state == SERVICE_STOP_SIGKILL ||
1860 s->state == SERVICE_STOP_POST ||
1861 s->state == SERVICE_FINAL_SIGTERM ||
1862 s->state == SERVICE_FINAL_SIGKILL)
1865 /* A restart will be scheduled or is in progress. */
1866 if (s->state == SERVICE_AUTO_RESTART) {
1867 service_set_state(s, SERVICE_DEAD);
1871 /* If there's already something running we go directly into
1873 if (s->state == SERVICE_START_PRE ||
1874 s->state == SERVICE_START ||
1875 s->state == SERVICE_START_POST ||
1876 s->state == SERVICE_RELOAD) {
1877 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1881 assert(s->state == SERVICE_RUNNING ||
1882 s->state == SERVICE_EXITED);
1884 service_enter_stop(s, SERVICE_SUCCESS);
1888 static int service_reload(Unit *u) {
1889 Service *s = SERVICE(u);
1893 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1895 service_enter_reload(s);
1899 _pure_ static bool service_can_reload(Unit *u) {
1900 Service *s = SERVICE(u);
1904 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1907 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1908 Service *s = SERVICE(u);
1915 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1916 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1917 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1919 if (s->control_pid > 0)
1920 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1923 if (s->main_pid_known && s->main_pid > 0)
1924 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1926 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1929 unit_serialize_item(u, f, "status-text", s->status_text);
1931 /* FIXME: There's a minor uncleanliness here: if there are
1932 * multiple commands attached here, we will start from the
1933 * first one again */
1934 if (s->control_command_id >= 0)
1935 unit_serialize_item(u, f, "control-command",
1936 service_exec_command_to_string(s->control_command_id));
1938 if (s->socket_fd >= 0) {
1941 copy = fdset_put_dup(fds, s->socket_fd);
1945 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1948 if (s->bus_endpoint_fd >= 0) {
1951 copy = fdset_put_dup(fds, s->bus_endpoint_fd);
1955 unit_serialize_item_format(u, f, "endpoint-fd", "%i", copy);
1958 LIST_FOREACH(fd_store, fs, s->fd_store) {
1961 copy = fdset_put_dup(fds, fs->fd);
1965 unit_serialize_item_format(u, f, "fd-store-fd", "%i", copy);
1968 if (s->main_exec_status.pid > 0) {
1969 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
1970 s->main_exec_status.pid);
1971 dual_timestamp_serialize(f, "main-exec-status-start",
1972 &s->main_exec_status.start_timestamp);
1973 dual_timestamp_serialize(f, "main-exec-status-exit",
1974 &s->main_exec_status.exit_timestamp);
1976 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1977 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
1978 s->main_exec_status.code);
1979 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
1980 s->main_exec_status.status);
1983 if (dual_timestamp_is_set(&s->watchdog_timestamp))
1984 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
1986 if (s->forbid_restart)
1987 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
1992 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1993 Service *s = SERVICE(u);
2001 if (streq(key, "state")) {
2004 state = service_state_from_string(value);
2006 log_unit_debug(u->id, "Failed to parse state value %s", value);
2008 s->deserialized_state = state;
2009 } else if (streq(key, "result")) {
2012 f = service_result_from_string(value);
2014 log_unit_debug(u->id, "Failed to parse result value %s", value);
2015 else if (f != SERVICE_SUCCESS)
2018 } else if (streq(key, "reload-result")) {
2021 f = service_result_from_string(value);
2023 log_unit_debug(u->id, "Failed to parse reload result value %s", value);
2024 else if (f != SERVICE_SUCCESS)
2025 s->reload_result = f;
2027 } else if (streq(key, "control-pid")) {
2030 if (parse_pid(value, &pid) < 0)
2031 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
2033 s->control_pid = pid;
2034 } else if (streq(key, "main-pid")) {
2037 if (parse_pid(value, &pid) < 0)
2038 log_unit_debug(u->id, "Failed to parse main-pid value %s", value);
2040 service_set_main_pid(s, pid);
2041 unit_watch_pid(UNIT(s), pid);
2043 } else if (streq(key, "main-pid-known")) {
2046 b = parse_boolean(value);
2048 log_unit_debug(u->id, "Failed to parse main-pid-known value %s", value);
2050 s->main_pid_known = b;
2051 } else if (streq(key, "status-text")) {
2058 free(s->status_text);
2062 } else if (streq(key, "control-command")) {
2063 ServiceExecCommand id;
2065 id = service_exec_command_from_string(value);
2067 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
2069 s->control_command_id = id;
2070 s->control_command = s->exec_command[id];
2072 } else if (streq(key, "socket-fd")) {
2075 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2076 log_unit_debug(u->id, "Failed to parse socket-fd value %s", value);
2078 asynchronous_close(s->socket_fd);
2079 s->socket_fd = fdset_remove(fds, fd);
2081 } else if (streq(key, "endpoint-fd")) {
2084 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2085 log_unit_debug(u->id, "Failed to parse endpoint-fd value %s", value);
2087 safe_close(s->bus_endpoint_fd);
2088 s->bus_endpoint_fd = fdset_remove(fds, fd);
2090 } else if (streq(key, "fd-store-fd")) {
2093 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2094 log_unit_debug(u->id, "Failed to parse fd-store-fd value %s", value);
2096 r = service_add_fd_store(s, fd);
2098 log_unit_error_errno(u->id, r, "Failed to add fd to store: %m");
2100 fdset_remove(fds, fd);
2103 } else if (streq(key, "main-exec-status-pid")) {
2106 if (parse_pid(value, &pid) < 0)
2107 log_unit_debug(u->id, "Failed to parse main-exec-status-pid value %s", value);
2109 s->main_exec_status.pid = pid;
2110 } else if (streq(key, "main-exec-status-code")) {
2113 if (safe_atoi(value, &i) < 0)
2114 log_unit_debug(u->id, "Failed to parse main-exec-status-code value %s", value);
2116 s->main_exec_status.code = i;
2117 } else if (streq(key, "main-exec-status-status")) {
2120 if (safe_atoi(value, &i) < 0)
2121 log_unit_debug(u->id, "Failed to parse main-exec-status-status value %s", value);
2123 s->main_exec_status.status = i;
2124 } else if (streq(key, "main-exec-status-start"))
2125 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2126 else if (streq(key, "main-exec-status-exit"))
2127 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2128 else if (streq(key, "watchdog-timestamp"))
2129 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2130 else if (streq(key, "forbid-restart")) {
2133 b = parse_boolean(value);
2135 log_unit_debug(u->id, "Failed to parse forbid-restart value %s", value);
2137 s->forbid_restart = b;
2139 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
2144 _pure_ static UnitActiveState service_active_state(Unit *u) {
2145 const UnitActiveState *table;
2149 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2151 return table[SERVICE(u)->state];
2154 static const char *service_sub_state_to_string(Unit *u) {
2157 return service_state_to_string(SERVICE(u)->state);
2160 static bool service_check_gc(Unit *u) {
2161 Service *s = SERVICE(u);
2165 /* Never clean up services that still have a process around,
2166 * even if the service is formally dead. */
2167 if (cgroup_good(s) > 0 ||
2168 main_pid_good(s) > 0 ||
2169 control_pid_good(s) > 0)
2175 _pure_ static bool service_check_snapshot(Unit *u) {
2176 Service *s = SERVICE(u);
2180 return s->socket_fd < 0;
2183 static int service_retry_pid_file(Service *s) {
2186 assert(s->pid_file);
2187 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2189 r = service_load_pid_file(s, false);
2193 service_unwatch_pid_file(s);
2195 service_enter_running(s, SERVICE_SUCCESS);
2199 static int service_watch_pid_file(Service *s) {
2202 log_unit_debug(UNIT(s)->id, "Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2204 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2208 /* the pidfile might have appeared just before we set the watch */
2209 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);
2210 service_retry_pid_file(s);
2214 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);
2215 service_unwatch_pid_file(s);
2219 static int service_demand_pid_file(Service *s) {
2222 assert(s->pid_file);
2223 assert(!s->pid_file_pathspec);
2225 ps = new0(PathSpec, 1);
2230 ps->path = strdup(s->pid_file);
2236 path_kill_slashes(ps->path);
2238 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2239 * keep their PID file open all the time. */
2240 ps->type = PATH_MODIFIED;
2241 ps->inotify_fd = -1;
2243 s->pid_file_pathspec = ps;
2245 return service_watch_pid_file(s);
2248 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2249 PathSpec *p = userdata;
2254 s = SERVICE(p->unit);
2258 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2259 assert(s->pid_file_pathspec);
2260 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2262 log_unit_debug(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2264 if (path_spec_fd_event(p, events) < 0)
2267 if (service_retry_pid_file(s) == 0)
2270 if (service_watch_pid_file(s) < 0)
2276 service_unwatch_pid_file(s);
2277 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2281 static void service_notify_cgroup_empty_event(Unit *u) {
2282 Service *s = SERVICE(u);
2286 log_unit_debug(u->id, "%s: cgroup is empty", u->id);
2290 /* Waiting for SIGCHLD is usually more interesting,
2291 * because it includes return codes/signals. Which is
2292 * why we ignore the cgroup events for most cases,
2293 * except when we don't know pid which to expect the
2297 case SERVICE_START_POST:
2298 /* If we were hoping for the daemon to write its PID file,
2299 * we can give up now. */
2300 if (s->pid_file_pathspec) {
2301 log_unit_warning(u->id, "%s never wrote its PID file. Failing.", UNIT(s)->id);
2303 service_unwatch_pid_file(s);
2304 if (s->state == SERVICE_START)
2305 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2307 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2311 case SERVICE_RUNNING:
2312 /* service_enter_running() will figure out what to do */
2313 service_enter_running(s, SERVICE_SUCCESS);
2316 case SERVICE_STOP_SIGABRT:
2317 case SERVICE_STOP_SIGTERM:
2318 case SERVICE_STOP_SIGKILL:
2320 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2321 service_enter_stop_post(s, SERVICE_SUCCESS);
2325 case SERVICE_STOP_POST:
2326 case SERVICE_FINAL_SIGTERM:
2327 case SERVICE_FINAL_SIGKILL:
2328 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2329 service_enter_dead(s, SERVICE_SUCCESS, true);
2338 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2339 Service *s = SERVICE(u);
2345 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2346 is_clean_exit_lsb(code, status, &s->success_status))
2347 f = SERVICE_SUCCESS;
2348 else if (code == CLD_EXITED)
2349 f = SERVICE_FAILURE_EXIT_CODE;
2350 else if (code == CLD_KILLED)
2351 f = SERVICE_FAILURE_SIGNAL;
2352 else if (code == CLD_DUMPED)
2353 f = SERVICE_FAILURE_CORE_DUMP;
2355 assert_not_reached("Unknown code");
2357 if (s->main_pid == pid) {
2358 /* Forking services may occasionally move to a new PID.
2359 * As long as they update the PID file before exiting the old
2360 * PID, they're fine. */
2361 if (service_load_pid_file(s, false) == 0)
2365 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2367 if (s->main_command) {
2368 /* If this is not a forking service than the
2369 * main process got started and hence we copy
2370 * the exit status so that it is recorded both
2371 * as main and as control process exit
2374 s->main_command->exec_status = s->main_exec_status;
2376 if (s->main_command->ignore)
2377 f = SERVICE_SUCCESS;
2378 } else if (s->exec_command[SERVICE_EXEC_START]) {
2380 /* If this is a forked process, then we should
2381 * ignore the return value if this was
2382 * configured for the starter process */
2384 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2385 f = SERVICE_SUCCESS;
2388 log_unit_struct(u->id,
2389 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2390 LOG_MESSAGE("%s: main process exited, code=%s, status=%i/%s",
2391 u->id, sigchld_code_to_string(code), status,
2392 strna(code == CLD_EXITED
2393 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2394 : signal_to_string(status))),
2395 "EXIT_CODE=%s", sigchld_code_to_string(code),
2396 "EXIT_STATUS=%i", status,
2399 if (f != SERVICE_SUCCESS)
2402 if (s->main_command &&
2403 s->main_command->command_next &&
2404 f == SERVICE_SUCCESS) {
2406 /* There is another command to *
2407 * execute, so let's do that. */
2409 log_unit_debug(u->id, "%s running next main command for state %s", u->id, service_state_to_string(s->state));
2410 service_run_next_main(s);
2414 /* The service exited, so the service is officially
2416 s->main_command = NULL;
2420 case SERVICE_START_POST:
2421 case SERVICE_RELOAD:
2423 /* Need to wait until the operation is
2428 if (s->type == SERVICE_ONESHOT) {
2429 /* This was our main goal, so let's go on */
2430 if (f == SERVICE_SUCCESS)
2431 service_enter_start_post(s);
2433 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2439 case SERVICE_RUNNING:
2440 service_enter_running(s, f);
2443 case SERVICE_STOP_SIGABRT:
2444 case SERVICE_STOP_SIGTERM:
2445 case SERVICE_STOP_SIGKILL:
2447 if (!control_pid_good(s))
2448 service_enter_stop_post(s, f);
2450 /* If there is still a control process, wait for that first */
2453 case SERVICE_STOP_POST:
2454 case SERVICE_FINAL_SIGTERM:
2455 case SERVICE_FINAL_SIGKILL:
2457 if (!control_pid_good(s))
2458 service_enter_dead(s, f, true);
2462 assert_not_reached("Uh, main process died at wrong time.");
2466 } else if (s->control_pid == pid) {
2469 if (s->control_command) {
2470 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2472 if (s->control_command->ignore)
2473 f = SERVICE_SUCCESS;
2476 log_unit_full(u->id,
2477 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2478 "%s: control process exited, code=%s status=%i",
2479 u->id, sigchld_code_to_string(code), status);
2481 if (f != SERVICE_SUCCESS)
2484 /* Immediately get rid of the cgroup, so that the
2485 * kernel doesn't delay the cgroup empty messages for
2486 * the service cgroup any longer than necessary */
2487 service_kill_control_processes(s);
2489 if (s->control_command &&
2490 s->control_command->command_next &&
2491 f == SERVICE_SUCCESS) {
2493 /* There is another command to *
2494 * execute, so let's do that. */
2496 log_unit_debug(u->id, "%s running next control command for state %s", u->id, service_state_to_string(s->state));
2497 service_run_next_control(s);
2500 /* No further commands for this step, so let's
2501 * figure out what to do next */
2503 s->control_command = NULL;
2504 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2506 log_unit_debug(u->id, "%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2510 case SERVICE_START_PRE:
2511 if (f == SERVICE_SUCCESS)
2512 service_enter_start(s);
2514 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2518 if (s->type != SERVICE_FORKING)
2519 /* Maybe spurious event due to a reload that changed the type? */
2522 if (f != SERVICE_SUCCESS) {
2523 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2528 bool has_start_post;
2531 /* Let's try to load the pid file here if we can.
2532 * The PID file might actually be created by a START_POST
2533 * script. In that case don't worry if the loading fails. */
2535 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2536 r = service_load_pid_file(s, !has_start_post);
2537 if (!has_start_post && r < 0) {
2538 r = service_demand_pid_file(s);
2539 if (r < 0 || !cgroup_good(s))
2540 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2544 service_search_main_pid(s);
2546 service_enter_start_post(s);
2549 case SERVICE_START_POST:
2550 if (f != SERVICE_SUCCESS) {
2551 service_enter_stop(s, f);
2558 r = service_load_pid_file(s, true);
2560 r = service_demand_pid_file(s);
2561 if (r < 0 || !cgroup_good(s))
2562 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2566 service_search_main_pid(s);
2568 service_enter_running(s, SERVICE_SUCCESS);
2571 case SERVICE_RELOAD:
2572 if (f == SERVICE_SUCCESS) {
2573 service_load_pid_file(s, true);
2574 service_search_main_pid(s);
2577 s->reload_result = f;
2578 service_enter_running(s, SERVICE_SUCCESS);
2582 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2585 case SERVICE_STOP_SIGABRT:
2586 case SERVICE_STOP_SIGTERM:
2587 case SERVICE_STOP_SIGKILL:
2588 if (main_pid_good(s) <= 0)
2589 service_enter_stop_post(s, f);
2591 /* If there is still a service
2592 * process around, wait until
2593 * that one quit, too */
2596 case SERVICE_STOP_POST:
2597 case SERVICE_FINAL_SIGTERM:
2598 case SERVICE_FINAL_SIGKILL:
2599 if (main_pid_good(s) <= 0)
2600 service_enter_dead(s, f, true);
2604 assert_not_reached("Uh, control process died at wrong time.");
2609 /* Notify clients about changed exit status */
2610 unit_add_to_dbus_queue(u);
2612 /* We got one SIGCHLD for the service, let's watch all
2613 * processes that are now running of the service, and watch
2614 * that. Among the PIDs we then watch will be children
2615 * reassigned to us, which hopefully allows us to identify
2616 * when all children are gone */
2617 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2618 unit_watch_all_pids(u);
2620 /* If the PID set is empty now, then let's finish this off */
2621 if (set_isempty(u->pids))
2622 service_notify_cgroup_empty_event(u);
2625 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2626 Service *s = SERVICE(userdata);
2629 assert(source == s->timer_event_source);
2633 case SERVICE_START_PRE:
2635 log_unit_warning(UNIT(s)->id, "%s %s operation timed out. Terminating.", UNIT(s)->id, s->state == SERVICE_START ? "start" : "start-pre");
2636 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2639 case SERVICE_START_POST:
2640 log_unit_warning(UNIT(s)->id, "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2641 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2644 case SERVICE_RELOAD:
2645 log_unit_warning(UNIT(s)->id, "%s reload operation timed out. Stopping.", UNIT(s)->id);
2646 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2647 service_enter_running(s, SERVICE_SUCCESS);
2651 log_unit_warning(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
2652 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2655 case SERVICE_STOP_SIGABRT:
2656 log_unit_warning(UNIT(s)->id,
2657 "%s stop-sigabrt timed out. Terminating.", UNIT(s)->id);
2658 service_enter_signal(s, SERVICE_STOP_SIGTERM, s->result);
2661 case SERVICE_STOP_SIGTERM:
2662 if (s->kill_context.send_sigkill) {
2663 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2664 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2666 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2667 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2672 case SERVICE_STOP_SIGKILL:
2673 /* Uh, we sent a SIGKILL and it is still not gone?
2674 * Must be something we cannot kill, so let's just be
2675 * weirded out and continue */
2677 log_unit_warning(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2678 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2681 case SERVICE_STOP_POST:
2682 log_unit_warning(UNIT(s)->id, "%s stop-post timed out. Terminating.", UNIT(s)->id);
2683 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2686 case SERVICE_FINAL_SIGTERM:
2687 if (s->kill_context.send_sigkill) {
2688 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2689 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2691 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.", UNIT(s)->id);
2692 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2697 case SERVICE_FINAL_SIGKILL:
2698 log_unit_warning(UNIT(s)->id, "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2699 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2702 case SERVICE_AUTO_RESTART:
2703 log_unit_info(UNIT(s)->id,
2704 s->restart_usec > 0 ?
2705 "%s holdoff time over, scheduling restart." :
2706 "%s has no holdoff time, scheduling restart.",
2708 service_enter_restart(s);
2712 assert_not_reached("Timeout at wrong time.");
2718 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2719 Service *s = SERVICE(userdata);
2720 char t[FORMAT_TIMESPAN_MAX];
2723 assert(source == s->watchdog_event_source);
2725 log_unit_error(UNIT(s)->id, "%s watchdog timeout (limit %s)!", UNIT(s)->id,
2726 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2728 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
2733 static void service_notify_message(Unit *u, pid_t pid, char **tags, FDSet *fds) {
2734 Service *s = SERVICE(u);
2735 _cleanup_free_ char *cc = NULL;
2736 bool notify_dbus = false;
2741 cc = strv_join(tags, ", ");
2742 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT" (%s)",
2743 u->id, pid, isempty(cc) ? "n/a" : cc);
2745 if (s->notify_access == NOTIFY_NONE) {
2746 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception is disabled.", u->id, pid);
2750 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2751 if (s->main_pid != 0)
2752 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);
2754 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);
2758 /* Interpret MAINPID= */
2759 e = strv_find_startswith(tags, "MAINPID=");
2760 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2761 if (parse_pid(e, &pid) < 0)
2762 log_unit_warning(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2764 log_unit_debug(u->id, "%s: got MAINPID=%s", u->id, e);
2766 service_set_main_pid(s, pid);
2767 unit_watch_pid(UNIT(s), pid);
2772 /* Interpret RELOADING= */
2773 if (strv_find(tags, "RELOADING=1")) {
2775 log_unit_debug(u->id, "%s: got RELOADING=1", u->id);
2776 s->notify_state = NOTIFY_RELOADING;
2778 if (s->state == SERVICE_RUNNING)
2779 service_enter_reload_by_notify(s);
2784 /* Interpret READY= */
2785 if (strv_find(tags, "READY=1")) {
2787 log_unit_debug(u->id, "%s: got READY=1", u->id);
2788 s->notify_state = NOTIFY_READY;
2790 /* Type=notify services inform us about completed
2791 * initialization with READY=1 */
2792 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
2793 service_enter_start_post(s);
2795 /* Sending READY=1 while we are reloading informs us
2796 * that the reloading is complete */
2797 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
2798 service_enter_running(s, SERVICE_SUCCESS);
2803 /* Interpret STOPPING= */
2804 if (strv_find(tags, "STOPPING=1")) {
2806 log_unit_debug(u->id, "%s: got STOPPING=1", u->id);
2807 s->notify_state = NOTIFY_STOPPING;
2809 if (s->state == SERVICE_RUNNING)
2810 service_enter_stop_by_notify(s);
2815 /* Interpret STATUS= */
2816 e = strv_find_startswith(tags, "STATUS=");
2818 _cleanup_free_ char *t = NULL;
2821 if (!utf8_is_valid(e))
2822 log_unit_warning(u->id, "Status message in notification is not UTF-8 clean.");
2824 log_unit_debug(u->id, "%s: got STATUS=%s", u->id, e);
2832 if (!streq_ptr(s->status_text, t)) {
2834 free(s->status_text);
2842 /* Interpret ERRNO= */
2843 e = strv_find_startswith(tags, "ERRNO=");
2847 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
2848 log_unit_warning(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2850 log_unit_debug(u->id, "%s: got ERRNO=%s", u->id, e);
2852 if (s->status_errno != status_errno) {
2853 s->status_errno = status_errno;
2859 /* Interpret WATCHDOG= */
2860 if (strv_find(tags, "WATCHDOG=1")) {
2861 log_unit_debug(u->id, "%s: got WATCHDOG=1", u->id);
2862 service_reset_watchdog(s);
2865 /* Add the passed fds to the fd store */
2866 if (strv_find(tags, "FDSTORE=1")) {
2867 log_unit_debug(u->id, "%s: got FDSTORE=1", u->id);
2868 service_add_fd_store_set(s, fds);
2871 /* Notify clients about changed status or main pid */
2873 unit_add_to_dbus_queue(u);
2876 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2877 Service *s = SERVICE(u);
2880 if (!s->timer_event_source)
2883 r = sd_event_source_get_time(s->timer_event_source, timeout);
2890 static void service_bus_name_owner_change(
2893 const char *old_owner,
2894 const char *new_owner) {
2896 Service *s = SERVICE(u);
2902 assert(streq(s->bus_name, name));
2903 assert(old_owner || new_owner);
2905 if (old_owner && new_owner)
2906 log_unit_debug(u->id, "%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
2908 log_unit_debug(u->id, "%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
2910 log_unit_debug(u->id, "%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
2912 s->bus_name_good = !!new_owner;
2914 if (s->type == SERVICE_DBUS) {
2916 /* service_enter_running() will figure out what to
2918 if (s->state == SERVICE_RUNNING)
2919 service_enter_running(s, SERVICE_SUCCESS);
2920 else if (s->state == SERVICE_START && new_owner)
2921 service_enter_start_post(s);
2923 } else if (new_owner &&
2925 (s->state == SERVICE_START ||
2926 s->state == SERVICE_START_POST ||
2927 s->state == SERVICE_RUNNING ||
2928 s->state == SERVICE_RELOAD)) {
2930 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2933 /* Try to acquire PID from bus service */
2935 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2937 r = sd_bus_creds_get_pid(creds, &pid);
2939 log_unit_debug(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2941 service_set_main_pid(s, pid);
2942 unit_watch_pid(UNIT(s), pid);
2947 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
2948 _cleanup_free_ char *peer = NULL;
2954 /* This is called by the socket code when instantiating a new
2955 * service for a stream socket and the socket needs to be
2958 if (UNIT(s)->load_state != UNIT_LOADED)
2961 if (s->socket_fd >= 0)
2964 if (s->state != SERVICE_DEAD)
2967 if (getpeername_pretty(fd, &peer) >= 0) {
2969 if (UNIT(s)->description) {
2970 _cleanup_free_ char *a;
2972 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
2976 r = unit_set_description(UNIT(s), a);
2978 r = unit_set_description(UNIT(s), peer);
2985 s->socket_fd_selinux_context_net = selinux_context_net;
2987 unit_ref_set(&s->accept_socket, UNIT(sock));
2989 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
2992 static void service_reset_failed(Unit *u) {
2993 Service *s = SERVICE(u);
2997 if (s->state == SERVICE_FAILED)
2998 service_set_state(s, SERVICE_DEAD);
3000 s->result = SERVICE_SUCCESS;
3001 s->reload_result = SERVICE_SUCCESS;
3003 RATELIMIT_RESET(s->start_limit);
3006 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3007 Service *s = SERVICE(u);
3009 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3012 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3013 [SERVICE_DEAD] = "dead",
3014 [SERVICE_START_PRE] = "start-pre",
3015 [SERVICE_START] = "start",
3016 [SERVICE_START_POST] = "start-post",
3017 [SERVICE_RUNNING] = "running",
3018 [SERVICE_EXITED] = "exited",
3019 [SERVICE_RELOAD] = "reload",
3020 [SERVICE_STOP] = "stop",
3021 [SERVICE_STOP_SIGABRT] = "stop-sigabrt",
3022 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3023 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3024 [SERVICE_STOP_POST] = "stop-post",
3025 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3026 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3027 [SERVICE_FAILED] = "failed",
3028 [SERVICE_AUTO_RESTART] = "auto-restart",
3031 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3033 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3034 [SERVICE_RESTART_NO] = "no",
3035 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3036 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3037 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
3038 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3039 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3040 [SERVICE_RESTART_ALWAYS] = "always",
3043 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3045 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3046 [SERVICE_SIMPLE] = "simple",
3047 [SERVICE_FORKING] = "forking",
3048 [SERVICE_ONESHOT] = "oneshot",
3049 [SERVICE_DBUS] = "dbus",
3050 [SERVICE_NOTIFY] = "notify",
3051 [SERVICE_IDLE] = "idle"
3054 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3056 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3057 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3058 [SERVICE_EXEC_START] = "ExecStart",
3059 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3060 [SERVICE_EXEC_RELOAD] = "ExecReload",
3061 [SERVICE_EXEC_STOP] = "ExecStop",
3062 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3065 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3067 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3068 [NOTIFY_NONE] = "none",
3069 [NOTIFY_MAIN] = "main",
3070 [NOTIFY_ALL] = "all"
3073 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3075 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
3076 [NOTIFY_UNKNOWN] = "unknown",
3077 [NOTIFY_READY] = "ready",
3078 [NOTIFY_RELOADING] = "reloading",
3079 [NOTIFY_STOPPING] = "stopping",
3082 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
3084 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3085 [SERVICE_SUCCESS] = "success",
3086 [SERVICE_FAILURE_RESOURCES] = "resources",
3087 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3088 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3089 [SERVICE_FAILURE_SIGNAL] = "signal",
3090 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3091 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3092 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3095 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3097 const UnitVTable service_vtable = {
3098 .object_size = sizeof(Service),
3099 .exec_context_offset = offsetof(Service, exec_context),
3100 .cgroup_context_offset = offsetof(Service, cgroup_context),
3101 .kill_context_offset = offsetof(Service, kill_context),
3102 .exec_runtime_offset = offsetof(Service, exec_runtime),
3108 .private_section = "Service",
3110 .init = service_init,
3111 .done = service_done,
3112 .load = service_load,
3113 .release_resources = service_release_resources,
3115 .coldplug = service_coldplug,
3117 .dump = service_dump,
3119 .start = service_start,
3120 .stop = service_stop,
3121 .reload = service_reload,
3123 .can_reload = service_can_reload,
3125 .kill = service_kill,
3127 .serialize = service_serialize,
3128 .deserialize_item = service_deserialize_item,
3130 .active_state = service_active_state,
3131 .sub_state_to_string = service_sub_state_to_string,
3133 .check_gc = service_check_gc,
3134 .check_snapshot = service_check_snapshot,
3136 .sigchld_event = service_sigchld_event,
3138 .reset_failed = service_reset_failed,
3140 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3141 .notify_message = service_notify_message,
3143 .bus_name_owner_change = service_bus_name_owner_change,
3145 .bus_interface = "org.freedesktop.systemd1.Service",
3146 .bus_vtable = bus_service_vtable,
3147 .bus_set_property = bus_service_set_property,
3148 .bus_commit_properties = bus_service_commit_properties,
3150 .get_timeout = service_get_timeout,
3151 .can_transient = true,
3153 .status_message_formats = {
3154 .starting_stopping = {
3155 [0] = "Starting %s...",
3156 [1] = "Stopping %s...",
3158 .finished_start_job = {
3159 [JOB_DONE] = "Started %s.",
3160 [JOB_FAILED] = "Failed to start %s.",
3161 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3162 [JOB_TIMEOUT] = "Timed out starting %s.",
3164 .finished_stop_job = {
3165 [JOB_DONE] = "Stopped %s.",
3166 [JOB_FAILED] = "Stopped (with error) %s.",
3167 [JOB_TIMEOUT] = "Timed out stopping %s.",