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, Hashmap *deferred_work) {
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*, 6);
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 if (UNIT_DEREF(s->accept_socket)) {
1123 union sockaddr_union sa;
1124 socklen_t salen = sizeof(sa);
1126 r = getpeername(s->socket_fd, &sa.sa, &salen);
1132 if (IN_SET(sa.sa.sa_family, AF_INET, AF_INET6)) {
1133 _cleanup_free_ char *addr = NULL;
1137 r = sockaddr_pretty(&sa.sa, salen, true, false, &addr);
1141 t = strappend("REMOTE_ADDR=", addr);
1146 our_env[n_env++] = t;
1148 port = sockaddr_port(&sa.sa);
1154 if (asprintf(&t, "REMOTE_PORT=%u", port) < 0) {
1158 our_env[n_env++] = t;
1162 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
1168 if (is_control && UNIT(s)->cgroup_path) {
1169 path = strjoina(UNIT(s)->cgroup_path, "/control");
1170 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
1172 path = UNIT(s)->cgroup_path;
1175 if (s->exec_context.bus_endpoint) {
1176 r = bus_kernel_create_endpoint(UNIT(s)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user",
1177 UNIT(s)->id, &bus_endpoint_path);
1181 /* Pass the fd to the exec_params so that the child process can upload the policy.
1182 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1183 * as the service is running. */
1184 exec_params.bus_endpoint_fd = s->bus_endpoint_fd = r;
1188 exec_params.argv = argv;
1189 exec_params.fds = fds;
1190 exec_params.n_fds = n_fds;
1191 exec_params.environment = final_env;
1192 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
1193 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
1194 exec_params.cgroup_path = path;
1195 exec_params.cgroup_delegate = s->cgroup_context.delegate;
1196 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
1197 exec_params.unit_id = UNIT(s)->id;
1198 exec_params.watchdog_usec = s->watchdog_usec;
1199 exec_params.bus_endpoint_path = bus_endpoint_path;
1200 if (s->type == SERVICE_IDLE)
1201 exec_params.idle_pipe = UNIT(s)->manager->idle_pipe;
1211 r = unit_watch_pid(UNIT(s), pid);
1213 /* FIXME: we need to do something here */
1222 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1227 static int main_pid_good(Service *s) {
1230 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1233 /* If we know the pid file, then lets just check if it is
1235 if (s->main_pid_known) {
1237 /* If it's an alien child let's check if it is still
1239 if (s->main_pid_alien && s->main_pid > 0)
1240 return pid_is_alive(s->main_pid);
1242 /* .. otherwise assume we'll get a SIGCHLD for it,
1243 * which we really should wait for to collect exit
1244 * status and code */
1245 return s->main_pid > 0;
1248 /* We don't know the pid */
1252 _pure_ static int control_pid_good(Service *s) {
1255 return s->control_pid > 0;
1258 static int cgroup_good(Service *s) {
1263 if (!UNIT(s)->cgroup_path)
1266 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1273 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1277 if (f != SERVICE_SUCCESS)
1280 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1282 if (s->result != SERVICE_SUCCESS) {
1283 log_unit_warning(UNIT(s)->id, "%s failed.", UNIT(s)->id);
1284 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1287 if (allow_restart &&
1288 !s->forbid_restart &&
1289 (s->restart == SERVICE_RESTART_ALWAYS ||
1290 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1291 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1292 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1293 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1294 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1295 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1296 (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)))) &&
1297 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_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_prevent_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1300 r = service_arm_timer(s, s->restart_usec);
1304 service_set_state(s, SERVICE_AUTO_RESTART);
1307 s->forbid_restart = false;
1309 /* We want fresh tmpdirs in case service is started again immediately */
1310 exec_runtime_destroy(s->exec_runtime);
1311 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1313 /* Also, remove the runtime directory in */
1314 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1316 /* Try to delete the pid file. At this point it will be
1317 * out-of-date, and some software might be confused by it, so
1318 * let's remove it. */
1320 unlink_noerrno(s->pid_file);
1325 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run install restart timer: %m", UNIT(s)->id);
1326 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1329 static void service_enter_stop_post(Service *s, ServiceResult f) {
1333 if (f != SERVICE_SUCCESS)
1336 service_unwatch_control_pid(s);
1337 unit_watch_all_pids(UNIT(s));
1339 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1340 if (s->control_command) {
1341 s->control_command_id = SERVICE_EXEC_STOP_POST;
1343 r = service_spawn(s,
1345 s->timeout_stop_usec,
1347 !s->permissions_start_only,
1348 !s->root_directory_start_only,
1355 service_set_state(s, SERVICE_STOP_POST);
1357 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1362 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop-post' task: %m", UNIT(s)->id);
1363 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1366 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1371 if (f != SERVICE_SUCCESS)
1374 unit_watch_all_pids(UNIT(s));
1376 r = unit_kill_context(
1379 (state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM && state != SERVICE_STOP_SIGABRT) ?
1380 KILL_KILL : (state == SERVICE_STOP_SIGABRT ? KILL_ABORT : KILL_TERMINATE),
1389 if (s->timeout_stop_usec > 0) {
1390 r = service_arm_timer(s, s->timeout_stop_usec);
1395 service_set_state(s, state);
1396 } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGABRT)
1397 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1398 else if (state == SERVICE_STOP_SIGKILL)
1399 service_enter_stop_post(s, SERVICE_SUCCESS);
1400 else if (state == SERVICE_FINAL_SIGTERM)
1401 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1403 service_enter_dead(s, SERVICE_SUCCESS, true);
1408 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
1410 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL ||
1411 state == SERVICE_STOP_SIGABRT)
1412 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1414 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1417 static void service_enter_stop_by_notify(Service *s) {
1420 unit_watch_all_pids(UNIT(s));
1422 if (s->timeout_stop_usec > 0)
1423 service_arm_timer(s, s->timeout_stop_usec);
1425 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1426 service_set_state(s, SERVICE_STOP_SIGTERM);
1429 static void service_enter_stop(Service *s, ServiceResult f) {
1434 if (f != SERVICE_SUCCESS)
1437 service_unwatch_control_pid(s);
1438 unit_watch_all_pids(UNIT(s));
1440 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1441 if (s->control_command) {
1442 s->control_command_id = SERVICE_EXEC_STOP;
1444 r = service_spawn(s,
1446 s->timeout_stop_usec,
1448 !s->permissions_start_only,
1449 !s->root_directory_start_only,
1456 service_set_state(s, SERVICE_STOP);
1458 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1463 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'stop' task: %m", UNIT(s)->id);
1464 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1467 static void service_enter_running(Service *s, ServiceResult f) {
1468 int main_pid_ok, cgroup_ok;
1471 if (f != SERVICE_SUCCESS)
1474 main_pid_ok = main_pid_good(s);
1475 cgroup_ok = cgroup_good(s);
1477 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1478 (s->bus_name_good || s->type != SERVICE_DBUS)) {
1480 /* If there are any queued up sd_notify()
1481 * notifications, process them now */
1482 if (s->notify_state == NOTIFY_RELOADING)
1483 service_enter_reload_by_notify(s);
1484 else if (s->notify_state == NOTIFY_STOPPING)
1485 service_enter_stop_by_notify(s);
1487 service_set_state(s, SERVICE_RUNNING);
1489 } else if (s->remain_after_exit)
1490 service_set_state(s, SERVICE_EXITED);
1492 service_enter_stop(s, SERVICE_SUCCESS);
1495 static void service_enter_start_post(Service *s) {
1499 service_unwatch_control_pid(s);
1500 service_reset_watchdog(s);
1502 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1503 if (s->control_command) {
1504 s->control_command_id = SERVICE_EXEC_START_POST;
1506 r = service_spawn(s,
1508 s->timeout_start_usec,
1510 !s->permissions_start_only,
1511 !s->root_directory_start_only,
1518 service_set_state(s, SERVICE_START_POST);
1520 service_enter_running(s, SERVICE_SUCCESS);
1525 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-post' task: %m", UNIT(s)->id);
1526 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1529 static void service_kill_control_processes(Service *s) {
1532 if (!UNIT(s)->cgroup_path)
1535 p = strjoina(UNIT(s)->cgroup_path, "/control");
1536 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1539 static void service_enter_start(Service *s) {
1546 service_unwatch_control_pid(s);
1547 service_unwatch_main_pid(s);
1549 /* We want to ensure that nobody leaks processes from
1550 * START_PRE here, so let's go on a killing spree, People
1551 * should not spawn long running processes from START_PRE. */
1552 service_kill_control_processes(s);
1554 if (s->type == SERVICE_FORKING) {
1555 s->control_command_id = SERVICE_EXEC_START;
1556 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1558 s->main_command = NULL;
1560 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1561 s->control_command = NULL;
1563 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1567 assert(s->type == SERVICE_ONESHOT);
1568 service_enter_start_post(s);
1572 r = service_spawn(s,
1574 IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_ONESHOT) ? s->timeout_start_usec : 0,
1584 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1585 /* For simple services we immediately start
1586 * the START_POST binaries. */
1588 service_set_main_pid(s, pid);
1589 service_enter_start_post(s);
1591 } else if (s->type == SERVICE_FORKING) {
1593 /* For forking services we wait until the start
1594 * process exited. */
1596 s->control_pid = pid;
1597 service_set_state(s, SERVICE_START);
1599 } else if (s->type == SERVICE_ONESHOT ||
1600 s->type == SERVICE_DBUS ||
1601 s->type == SERVICE_NOTIFY) {
1603 /* For oneshot services we wait until the start
1604 * process exited, too, but it is our main process. */
1606 /* For D-Bus services we know the main pid right away,
1607 * but wait for the bus name to appear on the
1608 * bus. Notify services are similar. */
1610 service_set_main_pid(s, pid);
1611 service_set_state(s, SERVICE_START);
1613 assert_not_reached("Unknown service type");
1618 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start' task: %m", UNIT(s)->id);
1619 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1622 static void service_enter_start_pre(Service *s) {
1627 service_unwatch_control_pid(s);
1629 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1630 if (s->control_command) {
1631 /* Before we start anything, let's clear up what might
1632 * be left from previous runs. */
1633 service_kill_control_processes(s);
1635 s->control_command_id = SERVICE_EXEC_START_PRE;
1637 r = service_spawn(s,
1639 s->timeout_start_usec,
1641 !s->permissions_start_only,
1642 !s->root_directory_start_only,
1649 service_set_state(s, SERVICE_START_PRE);
1651 service_enter_start(s);
1656 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'start-pre' task: %m", UNIT(s)->id);
1657 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1660 static void service_enter_restart(Service *s) {
1661 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1666 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1667 /* Don't restart things if we are going down anyway */
1668 log_unit_info(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1670 r = service_arm_timer(s, s->restart_usec);
1677 /* Any units that are bound to this service must also be
1678 * restarted. We use JOB_RESTART (instead of the more obvious
1679 * JOB_START) here so that those dependency jobs will be added
1681 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1685 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1686 * it will be canceled as part of the service_stop() call that
1687 * is executed as part of JOB_RESTART. */
1689 log_unit_debug(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1693 log_unit_warning(UNIT(s)->id, "%s failed to schedule restart job: %s", UNIT(s)->id, bus_error_message(&error, -r));
1694 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1697 static void service_enter_reload_by_notify(Service *s) {
1700 if (s->timeout_start_usec > 0)
1701 service_arm_timer(s, s->timeout_start_usec);
1703 service_set_state(s, SERVICE_RELOAD);
1706 static void service_enter_reload(Service *s) {
1711 service_unwatch_control_pid(s);
1713 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1714 if (s->control_command) {
1715 s->control_command_id = SERVICE_EXEC_RELOAD;
1717 r = service_spawn(s,
1719 s->timeout_start_usec,
1721 !s->permissions_start_only,
1722 !s->root_directory_start_only,
1729 service_set_state(s, SERVICE_RELOAD);
1731 service_enter_running(s, SERVICE_SUCCESS);
1736 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'reload' task: %m", UNIT(s)->id);
1737 s->reload_result = SERVICE_FAILURE_RESOURCES;
1738 service_enter_running(s, SERVICE_SUCCESS);
1741 static void service_run_next_control(Service *s) {
1745 assert(s->control_command);
1746 assert(s->control_command->command_next);
1748 assert(s->control_command_id != SERVICE_EXEC_START);
1750 s->control_command = s->control_command->command_next;
1751 service_unwatch_control_pid(s);
1753 r = service_spawn(s,
1755 IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec,
1757 !s->permissions_start_only,
1758 !s->root_directory_start_only,
1759 s->control_command_id == SERVICE_EXEC_START_PRE ||
1760 s->control_command_id == SERVICE_EXEC_STOP_POST,
1769 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next control task: %m", UNIT(s)->id);
1771 if (s->state == SERVICE_START_PRE)
1772 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1773 else if (s->state == SERVICE_STOP)
1774 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1775 else if (s->state == SERVICE_STOP_POST)
1776 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1777 else if (s->state == SERVICE_RELOAD) {
1778 s->reload_result = SERVICE_FAILURE_RESOURCES;
1779 service_enter_running(s, SERVICE_SUCCESS);
1781 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1784 static void service_run_next_main(Service *s) {
1789 assert(s->main_command);
1790 assert(s->main_command->command_next);
1791 assert(s->type == SERVICE_ONESHOT);
1793 s->main_command = s->main_command->command_next;
1794 service_unwatch_main_pid(s);
1796 r = service_spawn(s,
1798 s->timeout_start_usec,
1808 service_set_main_pid(s, pid);
1813 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run next main task: %m", UNIT(s)->id);
1814 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1817 static int service_start_limit_test(Service *s) {
1820 if (ratelimit_test(&s->start_limit))
1823 log_unit_warning(UNIT(s)->id, "start request repeated too quickly for %s", UNIT(s)->id);
1825 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
1828 static int service_start(Unit *u) {
1829 Service *s = SERVICE(u);
1834 /* We cannot fulfill this request right now, try again later
1836 if (s->state == SERVICE_STOP ||
1837 s->state == SERVICE_STOP_SIGABRT ||
1838 s->state == SERVICE_STOP_SIGTERM ||
1839 s->state == SERVICE_STOP_SIGKILL ||
1840 s->state == SERVICE_STOP_POST ||
1841 s->state == SERVICE_FINAL_SIGTERM ||
1842 s->state == SERVICE_FINAL_SIGKILL)
1845 /* Already on it! */
1846 if (s->state == SERVICE_START_PRE ||
1847 s->state == SERVICE_START ||
1848 s->state == SERVICE_START_POST)
1851 /* A service that will be restarted must be stopped first to
1852 * trigger BindsTo and/or OnFailure dependencies. If a user
1853 * does not want to wait for the holdoff time to elapse, the
1854 * service should be manually restarted, not started. We
1855 * simply return EAGAIN here, so that any start jobs stay
1856 * queued, and assume that the auto restart timer will
1857 * eventually trigger the restart. */
1858 if (s->state == SERVICE_AUTO_RESTART)
1861 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1863 /* Make sure we don't enter a busy loop of some kind. */
1864 r = service_start_limit_test(s);
1866 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1870 s->result = SERVICE_SUCCESS;
1871 s->reload_result = SERVICE_SUCCESS;
1872 s->main_pid_known = false;
1873 s->main_pid_alien = false;
1874 s->forbid_restart = false;
1875 s->reset_cpu_usage = true;
1877 free(s->status_text);
1878 s->status_text = NULL;
1879 s->status_errno = 0;
1881 s->notify_state = NOTIFY_UNKNOWN;
1883 service_enter_start_pre(s);
1887 static int service_stop(Unit *u) {
1888 Service *s = SERVICE(u);
1892 /* Don't create restart jobs from here. */
1893 s->forbid_restart = true;
1896 if (s->state == SERVICE_STOP ||
1897 s->state == SERVICE_STOP_SIGABRT ||
1898 s->state == SERVICE_STOP_SIGTERM ||
1899 s->state == SERVICE_STOP_SIGKILL ||
1900 s->state == SERVICE_STOP_POST ||
1901 s->state == SERVICE_FINAL_SIGTERM ||
1902 s->state == SERVICE_FINAL_SIGKILL)
1905 /* A restart will be scheduled or is in progress. */
1906 if (s->state == SERVICE_AUTO_RESTART) {
1907 service_set_state(s, SERVICE_DEAD);
1911 /* If there's already something running we go directly into
1913 if (s->state == SERVICE_START_PRE ||
1914 s->state == SERVICE_START ||
1915 s->state == SERVICE_START_POST ||
1916 s->state == SERVICE_RELOAD) {
1917 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1921 assert(s->state == SERVICE_RUNNING ||
1922 s->state == SERVICE_EXITED);
1924 service_enter_stop(s, SERVICE_SUCCESS);
1928 static int service_reload(Unit *u) {
1929 Service *s = SERVICE(u);
1933 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1935 service_enter_reload(s);
1939 _pure_ static bool service_can_reload(Unit *u) {
1940 Service *s = SERVICE(u);
1944 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1947 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1948 Service *s = SERVICE(u);
1955 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1956 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1957 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1959 if (s->control_pid > 0)
1960 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1963 if (s->main_pid_known && s->main_pid > 0)
1964 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1966 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1969 unit_serialize_item(u, f, "status-text", s->status_text);
1971 /* FIXME: There's a minor uncleanliness here: if there are
1972 * multiple commands attached here, we will start from the
1973 * first one again */
1974 if (s->control_command_id >= 0)
1975 unit_serialize_item(u, f, "control-command",
1976 service_exec_command_to_string(s->control_command_id));
1978 if (s->socket_fd >= 0) {
1981 copy = fdset_put_dup(fds, s->socket_fd);
1985 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1988 if (s->bus_endpoint_fd >= 0) {
1991 copy = fdset_put_dup(fds, s->bus_endpoint_fd);
1995 unit_serialize_item_format(u, f, "endpoint-fd", "%i", copy);
1998 LIST_FOREACH(fd_store, fs, s->fd_store) {
2001 copy = fdset_put_dup(fds, fs->fd);
2005 unit_serialize_item_format(u, f, "fd-store-fd", "%i", copy);
2008 if (s->main_exec_status.pid > 0) {
2009 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
2010 s->main_exec_status.pid);
2011 dual_timestamp_serialize(f, "main-exec-status-start",
2012 &s->main_exec_status.start_timestamp);
2013 dual_timestamp_serialize(f, "main-exec-status-exit",
2014 &s->main_exec_status.exit_timestamp);
2016 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2017 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
2018 s->main_exec_status.code);
2019 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
2020 s->main_exec_status.status);
2023 if (dual_timestamp_is_set(&s->watchdog_timestamp))
2024 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2026 if (s->forbid_restart)
2027 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
2032 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2033 Service *s = SERVICE(u);
2041 if (streq(key, "state")) {
2044 state = service_state_from_string(value);
2046 log_unit_debug(u->id, "Failed to parse state value %s", value);
2048 s->deserialized_state = state;
2049 } else if (streq(key, "result")) {
2052 f = service_result_from_string(value);
2054 log_unit_debug(u->id, "Failed to parse result value %s", value);
2055 else if (f != SERVICE_SUCCESS)
2058 } else if (streq(key, "reload-result")) {
2061 f = service_result_from_string(value);
2063 log_unit_debug(u->id, "Failed to parse reload result value %s", value);
2064 else if (f != SERVICE_SUCCESS)
2065 s->reload_result = f;
2067 } else if (streq(key, "control-pid")) {
2070 if (parse_pid(value, &pid) < 0)
2071 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
2073 s->control_pid = pid;
2074 } else if (streq(key, "main-pid")) {
2077 if (parse_pid(value, &pid) < 0)
2078 log_unit_debug(u->id, "Failed to parse main-pid value %s", value);
2080 service_set_main_pid(s, pid);
2081 unit_watch_pid(UNIT(s), pid);
2083 } else if (streq(key, "main-pid-known")) {
2086 b = parse_boolean(value);
2088 log_unit_debug(u->id, "Failed to parse main-pid-known value %s", value);
2090 s->main_pid_known = b;
2091 } else if (streq(key, "status-text")) {
2098 free(s->status_text);
2102 } else if (streq(key, "control-command")) {
2103 ServiceExecCommand id;
2105 id = service_exec_command_from_string(value);
2107 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
2109 s->control_command_id = id;
2110 s->control_command = s->exec_command[id];
2112 } else if (streq(key, "socket-fd")) {
2115 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2116 log_unit_debug(u->id, "Failed to parse socket-fd value %s", value);
2118 asynchronous_close(s->socket_fd);
2119 s->socket_fd = fdset_remove(fds, fd);
2121 } else if (streq(key, "endpoint-fd")) {
2124 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2125 log_unit_debug(u->id, "Failed to parse endpoint-fd value %s", value);
2127 safe_close(s->bus_endpoint_fd);
2128 s->bus_endpoint_fd = fdset_remove(fds, fd);
2130 } else if (streq(key, "fd-store-fd")) {
2133 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2134 log_unit_debug(u->id, "Failed to parse fd-store-fd value %s", value);
2136 r = service_add_fd_store(s, fd);
2138 log_unit_error_errno(u->id, r, "Failed to add fd to store: %m");
2140 fdset_remove(fds, fd);
2143 } else if (streq(key, "main-exec-status-pid")) {
2146 if (parse_pid(value, &pid) < 0)
2147 log_unit_debug(u->id, "Failed to parse main-exec-status-pid value %s", value);
2149 s->main_exec_status.pid = pid;
2150 } else if (streq(key, "main-exec-status-code")) {
2153 if (safe_atoi(value, &i) < 0)
2154 log_unit_debug(u->id, "Failed to parse main-exec-status-code value %s", value);
2156 s->main_exec_status.code = i;
2157 } else if (streq(key, "main-exec-status-status")) {
2160 if (safe_atoi(value, &i) < 0)
2161 log_unit_debug(u->id, "Failed to parse main-exec-status-status value %s", value);
2163 s->main_exec_status.status = i;
2164 } else if (streq(key, "main-exec-status-start"))
2165 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2166 else if (streq(key, "main-exec-status-exit"))
2167 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2168 else if (streq(key, "watchdog-timestamp"))
2169 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2170 else if (streq(key, "forbid-restart")) {
2173 b = parse_boolean(value);
2175 log_unit_debug(u->id, "Failed to parse forbid-restart value %s", value);
2177 s->forbid_restart = b;
2179 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
2184 _pure_ static UnitActiveState service_active_state(Unit *u) {
2185 const UnitActiveState *table;
2189 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2191 return table[SERVICE(u)->state];
2194 static const char *service_sub_state_to_string(Unit *u) {
2197 return service_state_to_string(SERVICE(u)->state);
2200 static bool service_check_gc(Unit *u) {
2201 Service *s = SERVICE(u);
2205 /* Never clean up services that still have a process around,
2206 * even if the service is formally dead. */
2207 if (cgroup_good(s) > 0 ||
2208 main_pid_good(s) > 0 ||
2209 control_pid_good(s) > 0)
2215 _pure_ static bool service_check_snapshot(Unit *u) {
2216 Service *s = SERVICE(u);
2220 return s->socket_fd < 0;
2223 static int service_retry_pid_file(Service *s) {
2226 assert(s->pid_file);
2227 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2229 r = service_load_pid_file(s, false);
2233 service_unwatch_pid_file(s);
2235 service_enter_running(s, SERVICE_SUCCESS);
2239 static int service_watch_pid_file(Service *s) {
2242 log_unit_debug(UNIT(s)->id, "Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2244 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
2248 /* the pidfile might have appeared just before we set the watch */
2249 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);
2250 service_retry_pid_file(s);
2254 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);
2255 service_unwatch_pid_file(s);
2259 static int service_demand_pid_file(Service *s) {
2262 assert(s->pid_file);
2263 assert(!s->pid_file_pathspec);
2265 ps = new0(PathSpec, 1);
2270 ps->path = strdup(s->pid_file);
2276 path_kill_slashes(ps->path);
2278 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2279 * keep their PID file open all the time. */
2280 ps->type = PATH_MODIFIED;
2281 ps->inotify_fd = -1;
2283 s->pid_file_pathspec = ps;
2285 return service_watch_pid_file(s);
2288 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2289 PathSpec *p = userdata;
2294 s = SERVICE(p->unit);
2298 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2299 assert(s->pid_file_pathspec);
2300 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2302 log_unit_debug(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2304 if (path_spec_fd_event(p, events) < 0)
2307 if (service_retry_pid_file(s) == 0)
2310 if (service_watch_pid_file(s) < 0)
2316 service_unwatch_pid_file(s);
2317 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2321 static void service_notify_cgroup_empty_event(Unit *u) {
2322 Service *s = SERVICE(u);
2326 log_unit_debug(u->id, "%s: cgroup is empty", u->id);
2330 /* Waiting for SIGCHLD is usually more interesting,
2331 * because it includes return codes/signals. Which is
2332 * why we ignore the cgroup events for most cases,
2333 * except when we don't know pid which to expect the
2337 case SERVICE_START_POST:
2338 /* If we were hoping for the daemon to write its PID file,
2339 * we can give up now. */
2340 if (s->pid_file_pathspec) {
2341 log_unit_warning(u->id, "%s never wrote its PID file. Failing.", UNIT(s)->id);
2343 service_unwatch_pid_file(s);
2344 if (s->state == SERVICE_START)
2345 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2347 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2351 case SERVICE_RUNNING:
2352 /* service_enter_running() will figure out what to do */
2353 service_enter_running(s, SERVICE_SUCCESS);
2356 case SERVICE_STOP_SIGABRT:
2357 case SERVICE_STOP_SIGTERM:
2358 case SERVICE_STOP_SIGKILL:
2360 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2361 service_enter_stop_post(s, SERVICE_SUCCESS);
2365 case SERVICE_STOP_POST:
2366 case SERVICE_FINAL_SIGTERM:
2367 case SERVICE_FINAL_SIGKILL:
2368 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2369 service_enter_dead(s, SERVICE_SUCCESS, true);
2378 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2379 Service *s = SERVICE(u);
2385 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2386 is_clean_exit_lsb(code, status, &s->success_status))
2387 f = SERVICE_SUCCESS;
2388 else if (code == CLD_EXITED)
2389 f = SERVICE_FAILURE_EXIT_CODE;
2390 else if (code == CLD_KILLED)
2391 f = SERVICE_FAILURE_SIGNAL;
2392 else if (code == CLD_DUMPED)
2393 f = SERVICE_FAILURE_CORE_DUMP;
2395 assert_not_reached("Unknown code");
2397 if (s->main_pid == pid) {
2398 /* Forking services may occasionally move to a new PID.
2399 * As long as they update the PID file before exiting the old
2400 * PID, they're fine. */
2401 if (service_load_pid_file(s, false) == 0)
2405 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2407 if (s->main_command) {
2408 /* If this is not a forking service than the
2409 * main process got started and hence we copy
2410 * the exit status so that it is recorded both
2411 * as main and as control process exit
2414 s->main_command->exec_status = s->main_exec_status;
2416 if (s->main_command->ignore)
2417 f = SERVICE_SUCCESS;
2418 } else if (s->exec_command[SERVICE_EXEC_START]) {
2420 /* If this is a forked process, then we should
2421 * ignore the return value if this was
2422 * configured for the starter process */
2424 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2425 f = SERVICE_SUCCESS;
2428 log_unit_struct(u->id,
2429 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2430 LOG_MESSAGE("%s: main process exited, code=%s, status=%i/%s",
2431 u->id, sigchld_code_to_string(code), status,
2432 strna(code == CLD_EXITED
2433 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2434 : signal_to_string(status))),
2435 "EXIT_CODE=%s", sigchld_code_to_string(code),
2436 "EXIT_STATUS=%i", status,
2439 if (f != SERVICE_SUCCESS)
2442 if (s->main_command &&
2443 s->main_command->command_next &&
2444 f == SERVICE_SUCCESS) {
2446 /* There is another command to *
2447 * execute, so let's do that. */
2449 log_unit_debug(u->id, "%s running next main command for state %s", u->id, service_state_to_string(s->state));
2450 service_run_next_main(s);
2454 /* The service exited, so the service is officially
2456 s->main_command = NULL;
2460 case SERVICE_START_POST:
2461 case SERVICE_RELOAD:
2463 /* Need to wait until the operation is
2468 if (s->type == SERVICE_ONESHOT) {
2469 /* This was our main goal, so let's go on */
2470 if (f == SERVICE_SUCCESS)
2471 service_enter_start_post(s);
2473 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2479 case SERVICE_RUNNING:
2480 service_enter_running(s, f);
2483 case SERVICE_STOP_SIGABRT:
2484 case SERVICE_STOP_SIGTERM:
2485 case SERVICE_STOP_SIGKILL:
2487 if (!control_pid_good(s))
2488 service_enter_stop_post(s, f);
2490 /* If there is still a control process, wait for that first */
2493 case SERVICE_STOP_POST:
2494 case SERVICE_FINAL_SIGTERM:
2495 case SERVICE_FINAL_SIGKILL:
2497 if (!control_pid_good(s))
2498 service_enter_dead(s, f, true);
2502 assert_not_reached("Uh, main process died at wrong time.");
2506 } else if (s->control_pid == pid) {
2509 if (s->control_command) {
2510 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2512 if (s->control_command->ignore)
2513 f = SERVICE_SUCCESS;
2516 log_unit_full(u->id,
2517 f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2518 "%s: control process exited, code=%s status=%i",
2519 u->id, sigchld_code_to_string(code), status);
2521 if (f != SERVICE_SUCCESS)
2524 /* Immediately get rid of the cgroup, so that the
2525 * kernel doesn't delay the cgroup empty messages for
2526 * the service cgroup any longer than necessary */
2527 service_kill_control_processes(s);
2529 if (s->control_command &&
2530 s->control_command->command_next &&
2531 f == SERVICE_SUCCESS) {
2533 /* There is another command to *
2534 * execute, so let's do that. */
2536 log_unit_debug(u->id, "%s running next control command for state %s", u->id, service_state_to_string(s->state));
2537 service_run_next_control(s);
2540 /* No further commands for this step, so let's
2541 * figure out what to do next */
2543 s->control_command = NULL;
2544 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2546 log_unit_debug(u->id, "%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2550 case SERVICE_START_PRE:
2551 if (f == SERVICE_SUCCESS)
2552 service_enter_start(s);
2554 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2558 if (s->type != SERVICE_FORKING)
2559 /* Maybe spurious event due to a reload that changed the type? */
2562 if (f != SERVICE_SUCCESS) {
2563 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2568 bool has_start_post;
2571 /* Let's try to load the pid file here if we can.
2572 * The PID file might actually be created by a START_POST
2573 * script. In that case don't worry if the loading fails. */
2575 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2576 r = service_load_pid_file(s, !has_start_post);
2577 if (!has_start_post && r < 0) {
2578 r = service_demand_pid_file(s);
2579 if (r < 0 || !cgroup_good(s))
2580 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2584 service_search_main_pid(s);
2586 service_enter_start_post(s);
2589 case SERVICE_START_POST:
2590 if (f != SERVICE_SUCCESS) {
2591 service_enter_stop(s, f);
2598 r = service_load_pid_file(s, true);
2600 r = service_demand_pid_file(s);
2601 if (r < 0 || !cgroup_good(s))
2602 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2606 service_search_main_pid(s);
2608 service_enter_running(s, SERVICE_SUCCESS);
2611 case SERVICE_RELOAD:
2612 if (f == SERVICE_SUCCESS) {
2613 service_load_pid_file(s, true);
2614 service_search_main_pid(s);
2617 s->reload_result = f;
2618 service_enter_running(s, SERVICE_SUCCESS);
2622 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2625 case SERVICE_STOP_SIGABRT:
2626 case SERVICE_STOP_SIGTERM:
2627 case SERVICE_STOP_SIGKILL:
2628 if (main_pid_good(s) <= 0)
2629 service_enter_stop_post(s, f);
2631 /* If there is still a service
2632 * process around, wait until
2633 * that one quit, too */
2636 case SERVICE_STOP_POST:
2637 case SERVICE_FINAL_SIGTERM:
2638 case SERVICE_FINAL_SIGKILL:
2639 if (main_pid_good(s) <= 0)
2640 service_enter_dead(s, f, true);
2644 assert_not_reached("Uh, control process died at wrong time.");
2649 /* Notify clients about changed exit status */
2650 unit_add_to_dbus_queue(u);
2652 /* We got one SIGCHLD for the service, let's watch all
2653 * processes that are now running of the service, and watch
2654 * that. Among the PIDs we then watch will be children
2655 * reassigned to us, which hopefully allows us to identify
2656 * when all children are gone */
2657 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2658 unit_watch_all_pids(u);
2660 /* If the PID set is empty now, then let's finish this off */
2661 if (set_isempty(u->pids))
2662 service_notify_cgroup_empty_event(u);
2665 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2666 Service *s = SERVICE(userdata);
2669 assert(source == s->timer_event_source);
2673 case SERVICE_START_PRE:
2675 log_unit_warning(UNIT(s)->id, "%s %s operation timed out. Terminating.", UNIT(s)->id, s->state == SERVICE_START ? "start" : "start-pre");
2676 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2679 case SERVICE_START_POST:
2680 log_unit_warning(UNIT(s)->id, "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2681 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2684 case SERVICE_RELOAD:
2685 log_unit_warning(UNIT(s)->id, "%s reload operation timed out. Stopping.", UNIT(s)->id);
2686 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2687 service_enter_running(s, SERVICE_SUCCESS);
2691 log_unit_warning(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
2692 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2695 case SERVICE_STOP_SIGABRT:
2696 log_unit_warning(UNIT(s)->id,
2697 "%s stop-sigabrt timed out. Terminating.", UNIT(s)->id);
2698 service_enter_signal(s, SERVICE_STOP_SIGTERM, s->result);
2701 case SERVICE_STOP_SIGTERM:
2702 if (s->kill_context.send_sigkill) {
2703 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2704 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2706 log_unit_warning(UNIT(s)->id, "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2707 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2712 case SERVICE_STOP_SIGKILL:
2713 /* Uh, we sent a SIGKILL and it is still not gone?
2714 * Must be something we cannot kill, so let's just be
2715 * weirded out and continue */
2717 log_unit_warning(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2718 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2721 case SERVICE_STOP_POST:
2722 log_unit_warning(UNIT(s)->id, "%s stop-post timed out. Terminating.", UNIT(s)->id);
2723 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2726 case SERVICE_FINAL_SIGTERM:
2727 if (s->kill_context.send_sigkill) {
2728 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2729 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2731 log_unit_warning(UNIT(s)->id, "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.", UNIT(s)->id);
2732 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2737 case SERVICE_FINAL_SIGKILL:
2738 log_unit_warning(UNIT(s)->id, "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2739 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2742 case SERVICE_AUTO_RESTART:
2743 log_unit_info(UNIT(s)->id,
2744 s->restart_usec > 0 ?
2745 "%s holdoff time over, scheduling restart." :
2746 "%s has no holdoff time, scheduling restart.",
2748 service_enter_restart(s);
2752 assert_not_reached("Timeout at wrong time.");
2758 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2759 Service *s = SERVICE(userdata);
2760 char t[FORMAT_TIMESPAN_MAX];
2763 assert(source == s->watchdog_event_source);
2765 log_unit_error(UNIT(s)->id, "%s watchdog timeout (limit %s)!", UNIT(s)->id,
2766 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2768 service_enter_signal(s, SERVICE_STOP_SIGABRT, SERVICE_FAILURE_WATCHDOG);
2773 static void service_notify_message(Unit *u, pid_t pid, char **tags, FDSet *fds) {
2774 Service *s = SERVICE(u);
2775 _cleanup_free_ char *cc = NULL;
2776 bool notify_dbus = false;
2781 cc = strv_join(tags, ", ");
2782 log_unit_debug(u->id, "%s: Got notification message from PID "PID_FMT" (%s)",
2783 u->id, pid, isempty(cc) ? "n/a" : cc);
2785 if (s->notify_access == NOTIFY_NONE) {
2786 log_unit_warning(u->id, "%s: Got notification message from PID "PID_FMT", but reception is disabled.", u->id, pid);
2790 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2791 if (s->main_pid != 0)
2792 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);
2794 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);
2798 /* Interpret MAINPID= */
2799 e = strv_find_startswith(tags, "MAINPID=");
2800 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2801 if (parse_pid(e, &pid) < 0)
2802 log_unit_warning(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2804 log_unit_debug(u->id, "%s: got MAINPID=%s", u->id, e);
2806 service_set_main_pid(s, pid);
2807 unit_watch_pid(UNIT(s), pid);
2812 /* Interpret RELOADING= */
2813 if (strv_find(tags, "RELOADING=1")) {
2815 log_unit_debug(u->id, "%s: got RELOADING=1", u->id);
2816 s->notify_state = NOTIFY_RELOADING;
2818 if (s->state == SERVICE_RUNNING)
2819 service_enter_reload_by_notify(s);
2824 /* Interpret READY= */
2825 if (strv_find(tags, "READY=1")) {
2827 log_unit_debug(u->id, "%s: got READY=1", u->id);
2828 s->notify_state = NOTIFY_READY;
2830 /* Type=notify services inform us about completed
2831 * initialization with READY=1 */
2832 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
2833 service_enter_start_post(s);
2835 /* Sending READY=1 while we are reloading informs us
2836 * that the reloading is complete */
2837 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
2838 service_enter_running(s, SERVICE_SUCCESS);
2843 /* Interpret STOPPING= */
2844 if (strv_find(tags, "STOPPING=1")) {
2846 log_unit_debug(u->id, "%s: got STOPPING=1", u->id);
2847 s->notify_state = NOTIFY_STOPPING;
2849 if (s->state == SERVICE_RUNNING)
2850 service_enter_stop_by_notify(s);
2855 /* Interpret STATUS= */
2856 e = strv_find_startswith(tags, "STATUS=");
2858 _cleanup_free_ char *t = NULL;
2861 if (!utf8_is_valid(e))
2862 log_unit_warning(u->id, "Status message in notification is not UTF-8 clean.");
2864 log_unit_debug(u->id, "%s: got STATUS=%s", u->id, e);
2872 if (!streq_ptr(s->status_text, t)) {
2874 free(s->status_text);
2882 /* Interpret ERRNO= */
2883 e = strv_find_startswith(tags, "ERRNO=");
2887 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
2888 log_unit_warning(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2890 log_unit_debug(u->id, "%s: got ERRNO=%s", u->id, e);
2892 if (s->status_errno != status_errno) {
2893 s->status_errno = status_errno;
2899 /* Interpret WATCHDOG= */
2900 if (strv_find(tags, "WATCHDOG=1")) {
2901 log_unit_debug(u->id, "%s: got WATCHDOG=1", u->id);
2902 service_reset_watchdog(s);
2905 /* Add the passed fds to the fd store */
2906 if (strv_find(tags, "FDSTORE=1")) {
2907 log_unit_debug(u->id, "%s: got FDSTORE=1", u->id);
2908 service_add_fd_store_set(s, fds);
2911 /* Notify clients about changed status or main pid */
2913 unit_add_to_dbus_queue(u);
2916 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2917 Service *s = SERVICE(u);
2920 if (!s->timer_event_source)
2923 r = sd_event_source_get_time(s->timer_event_source, timeout);
2930 static void service_bus_name_owner_change(
2933 const char *old_owner,
2934 const char *new_owner) {
2936 Service *s = SERVICE(u);
2942 assert(streq(s->bus_name, name));
2943 assert(old_owner || new_owner);
2945 if (old_owner && new_owner)
2946 log_unit_debug(u->id, "%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
2948 log_unit_debug(u->id, "%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
2950 log_unit_debug(u->id, "%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
2952 s->bus_name_good = !!new_owner;
2954 if (s->type == SERVICE_DBUS) {
2956 /* service_enter_running() will figure out what to
2958 if (s->state == SERVICE_RUNNING)
2959 service_enter_running(s, SERVICE_SUCCESS);
2960 else if (s->state == SERVICE_START && new_owner)
2961 service_enter_start_post(s);
2963 } else if (new_owner &&
2965 (s->state == SERVICE_START ||
2966 s->state == SERVICE_START_POST ||
2967 s->state == SERVICE_RUNNING ||
2968 s->state == SERVICE_RELOAD)) {
2970 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2973 /* Try to acquire PID from bus service */
2975 r = sd_bus_get_name_creds(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2977 r = sd_bus_creds_get_pid(creds, &pid);
2979 log_unit_debug(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2981 service_set_main_pid(s, pid);
2982 unit_watch_pid(UNIT(s), pid);
2987 int service_set_socket_fd(Service *s, int fd, Socket *sock, bool selinux_context_net) {
2988 _cleanup_free_ char *peer = NULL;
2994 /* This is called by the socket code when instantiating a new
2995 * service for a stream socket and the socket needs to be
2998 if (UNIT(s)->load_state != UNIT_LOADED)
3001 if (s->socket_fd >= 0)
3004 if (s->state != SERVICE_DEAD)
3007 if (getpeername_pretty(fd, &peer) >= 0) {
3009 if (UNIT(s)->description) {
3010 _cleanup_free_ char *a;
3012 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
3016 r = unit_set_description(UNIT(s), a);
3018 r = unit_set_description(UNIT(s), peer);
3025 s->socket_fd_selinux_context_net = selinux_context_net;
3027 unit_ref_set(&s->accept_socket, UNIT(sock));
3029 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3032 static void service_reset_failed(Unit *u) {
3033 Service *s = SERVICE(u);
3037 if (s->state == SERVICE_FAILED)
3038 service_set_state(s, SERVICE_DEAD);
3040 s->result = SERVICE_SUCCESS;
3041 s->reload_result = SERVICE_SUCCESS;
3043 RATELIMIT_RESET(s->start_limit);
3046 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3047 Service *s = SERVICE(u);
3049 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
3052 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3053 [SERVICE_DEAD] = "dead",
3054 [SERVICE_START_PRE] = "start-pre",
3055 [SERVICE_START] = "start",
3056 [SERVICE_START_POST] = "start-post",
3057 [SERVICE_RUNNING] = "running",
3058 [SERVICE_EXITED] = "exited",
3059 [SERVICE_RELOAD] = "reload",
3060 [SERVICE_STOP] = "stop",
3061 [SERVICE_STOP_SIGABRT] = "stop-sigabrt",
3062 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3063 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3064 [SERVICE_STOP_POST] = "stop-post",
3065 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3066 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3067 [SERVICE_FAILED] = "failed",
3068 [SERVICE_AUTO_RESTART] = "auto-restart",
3071 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3073 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3074 [SERVICE_RESTART_NO] = "no",
3075 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3076 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3077 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
3078 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
3079 [SERVICE_RESTART_ON_ABORT] = "on-abort",
3080 [SERVICE_RESTART_ALWAYS] = "always",
3083 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3085 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3086 [SERVICE_SIMPLE] = "simple",
3087 [SERVICE_FORKING] = "forking",
3088 [SERVICE_ONESHOT] = "oneshot",
3089 [SERVICE_DBUS] = "dbus",
3090 [SERVICE_NOTIFY] = "notify",
3091 [SERVICE_IDLE] = "idle"
3094 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3096 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3097 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3098 [SERVICE_EXEC_START] = "ExecStart",
3099 [SERVICE_EXEC_START_POST] = "ExecStartPost",
3100 [SERVICE_EXEC_RELOAD] = "ExecReload",
3101 [SERVICE_EXEC_STOP] = "ExecStop",
3102 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3105 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3107 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3108 [NOTIFY_NONE] = "none",
3109 [NOTIFY_MAIN] = "main",
3110 [NOTIFY_ALL] = "all"
3113 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3115 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
3116 [NOTIFY_UNKNOWN] = "unknown",
3117 [NOTIFY_READY] = "ready",
3118 [NOTIFY_RELOADING] = "reloading",
3119 [NOTIFY_STOPPING] = "stopping",
3122 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
3124 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3125 [SERVICE_SUCCESS] = "success",
3126 [SERVICE_FAILURE_RESOURCES] = "resources",
3127 [SERVICE_FAILURE_TIMEOUT] = "timeout",
3128 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3129 [SERVICE_FAILURE_SIGNAL] = "signal",
3130 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3131 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3132 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3135 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3137 const UnitVTable service_vtable = {
3138 .object_size = sizeof(Service),
3139 .exec_context_offset = offsetof(Service, exec_context),
3140 .cgroup_context_offset = offsetof(Service, cgroup_context),
3141 .kill_context_offset = offsetof(Service, kill_context),
3142 .exec_runtime_offset = offsetof(Service, exec_runtime),
3148 .private_section = "Service",
3150 .init = service_init,
3151 .done = service_done,
3152 .load = service_load,
3153 .release_resources = service_release_resources,
3155 .coldplug = service_coldplug,
3157 .dump = service_dump,
3159 .start = service_start,
3160 .stop = service_stop,
3161 .reload = service_reload,
3163 .can_reload = service_can_reload,
3165 .kill = service_kill,
3167 .serialize = service_serialize,
3168 .deserialize_item = service_deserialize_item,
3170 .active_state = service_active_state,
3171 .sub_state_to_string = service_sub_state_to_string,
3173 .check_gc = service_check_gc,
3174 .check_snapshot = service_check_snapshot,
3176 .sigchld_event = service_sigchld_event,
3178 .reset_failed = service_reset_failed,
3180 .notify_cgroup_empty = service_notify_cgroup_empty_event,
3181 .notify_message = service_notify_message,
3183 .bus_name_owner_change = service_bus_name_owner_change,
3185 .bus_interface = "org.freedesktop.systemd1.Service",
3186 .bus_vtable = bus_service_vtable,
3187 .bus_set_property = bus_service_set_property,
3188 .bus_commit_properties = bus_service_commit_properties,
3190 .get_timeout = service_get_timeout,
3191 .can_transient = true,
3193 .status_message_formats = {
3194 .starting_stopping = {
3195 [0] = "Starting %s...",
3196 [1] = "Stopping %s...",
3198 .finished_start_job = {
3199 [JOB_DONE] = "Started %s.",
3200 [JOB_FAILED] = "Failed to start %s.",
3201 [JOB_DEPENDENCY] = "Dependency failed for %s.",
3202 [JOB_TIMEOUT] = "Timed out starting %s.",
3204 .finished_stop_job = {
3205 [JOB_DONE] = "Stopped %s.",
3206 [JOB_FAILED] = "Stopped (with error) %s.",
3207 [JOB_TIMEOUT] = "Timed out stopping %s.",