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/>.
31 #include "load-fragment.h"
32 #include "load-dropin.h"
35 #include "unit-name.h"
36 #include "unit-printf.h"
37 #include "dbus-service.h"
39 #include "exit-status.h"
41 #include "path-util.h"
46 #include "bus-error.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_SIGTERM] = UNIT_DEACTIVATING,
59 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
60 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
61 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
62 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
63 [SERVICE_FAILED] = UNIT_FAILED,
64 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
67 /* For Type=idle we never want to delay any other jobs, hence we
68 * consider idle jobs active as soon as we start working on them */
69 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
70 [SERVICE_DEAD] = UNIT_INACTIVE,
71 [SERVICE_START_PRE] = UNIT_ACTIVE,
72 [SERVICE_START] = UNIT_ACTIVE,
73 [SERVICE_START_POST] = UNIT_ACTIVE,
74 [SERVICE_RUNNING] = UNIT_ACTIVE,
75 [SERVICE_EXITED] = UNIT_ACTIVE,
76 [SERVICE_RELOAD] = UNIT_RELOADING,
77 [SERVICE_STOP] = UNIT_DEACTIVATING,
78 [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
79 [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
80 [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
81 [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
82 [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
83 [SERVICE_FAILED] = UNIT_FAILED,
84 [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
87 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata);
88 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
89 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata);
91 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
92 static void service_enter_reload_by_notify(Service *s);
94 static void service_init(Unit *u) {
95 Service *s = SERVICE(u);
98 assert(u->load_state == UNIT_STUB);
100 s->timeout_start_usec = u->manager->default_timeout_start_usec;
101 s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
102 s->restart_usec = u->manager->default_restart_usec;
103 s->type = _SERVICE_TYPE_INVALID;
105 s->guess_main_pid = true;
107 RATELIMIT_INIT(s->start_limit, u->manager->default_start_limit_interval, u->manager->default_start_limit_burst);
109 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
112 static void service_unwatch_control_pid(Service *s) {
115 if (s->control_pid <= 0)
118 unit_unwatch_pid(UNIT(s), s->control_pid);
122 static void service_unwatch_main_pid(Service *s) {
125 if (s->main_pid <= 0)
128 unit_unwatch_pid(UNIT(s), s->main_pid);
132 static void service_unwatch_pid_file(Service *s) {
133 if (!s->pid_file_pathspec)
136 log_debug_unit(UNIT(s)->id, "Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
137 path_spec_unwatch(s->pid_file_pathspec);
138 path_spec_done(s->pid_file_pathspec);
139 free(s->pid_file_pathspec);
140 s->pid_file_pathspec = NULL;
143 static int service_set_main_pid(Service *s, pid_t pid) {
154 if (s->main_pid == pid && s->main_pid_known)
157 if (s->main_pid != pid) {
158 service_unwatch_main_pid(s);
159 exec_status_start(&s->main_exec_status, pid);
163 s->main_pid_known = true;
165 if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
166 log_warning_unit(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);
167 s->main_pid_alien = true;
169 s->main_pid_alien = false;
174 static void service_close_socket_fd(Service *s) {
177 s->socket_fd = asynchronous_close(s->socket_fd);
180 static void service_connection_unref(Service *s) {
183 if (!UNIT_ISSET(s->accept_socket))
186 socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
187 unit_ref_unset(&s->accept_socket);
190 static void service_stop_watchdog(Service *s) {
193 s->watchdog_event_source = sd_event_source_unref(s->watchdog_event_source);
194 s->watchdog_timestamp = DUAL_TIMESTAMP_NULL;
197 static void service_start_watchdog(Service *s) {
202 if (s->watchdog_usec <= 0)
205 if (s->watchdog_event_source) {
206 r = sd_event_source_set_time(s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec);
208 log_warning_unit(UNIT(s)->id, "%s failed to reset watchdog timer: %s", UNIT(s)->id, strerror(-r));
212 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
214 r = sd_event_add_time(
215 UNIT(s)->manager->event,
216 &s->watchdog_event_source,
218 s->watchdog_timestamp.monotonic + s->watchdog_usec, 0,
219 service_dispatch_watchdog, s);
221 log_warning_unit(UNIT(s)->id, "%s failed to add watchdog timer: %s", UNIT(s)->id, strerror(-r));
225 /* Let's process everything else which might be a sign
226 * of living before we consider a service died. */
227 r = sd_event_source_set_priority(s->watchdog_event_source, SD_EVENT_PRIORITY_IDLE);
231 log_warning_unit(UNIT(s)->id, "%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
234 static void service_reset_watchdog(Service *s) {
237 dual_timestamp_get(&s->watchdog_timestamp);
238 service_start_watchdog(s);
241 static void service_done(Unit *u) {
242 Service *s = SERVICE(u);
249 free(s->status_text);
250 s->status_text = NULL;
253 s->reboot_arg = NULL;
255 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
256 exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
257 s->control_command = NULL;
258 s->main_command = NULL;
260 exit_status_set_free(&s->restart_prevent_status);
261 exit_status_set_free(&s->restart_force_status);
262 exit_status_set_free(&s->success_status);
264 /* This will leak a process, but at least no memory or any of
266 service_unwatch_main_pid(s);
267 service_unwatch_control_pid(s);
268 service_unwatch_pid_file(s);
271 unit_unwatch_bus_name(u, s->bus_name);
276 service_close_socket_fd(s);
277 service_connection_unref(s);
279 unit_ref_unset(&s->accept_socket);
281 service_stop_watchdog(s);
283 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
286 static int service_arm_timer(Service *s, usec_t usec) {
291 if (s->timer_event_source) {
292 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + usec);
296 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
299 return sd_event_add_time(
300 UNIT(s)->manager->event,
301 &s->timer_event_source,
303 now(CLOCK_MONOTONIC) + usec, 0,
304 service_dispatch_timer, s);
307 static int service_verify(Service *s) {
310 if (UNIT(s)->load_state != UNIT_LOADED)
313 if (!s->exec_command[SERVICE_EXEC_START] && !s->exec_command[SERVICE_EXEC_STOP]) {
314 log_error_unit(UNIT(s)->id, "%s lacks both ExecStart= and ExecStop= setting. Refusing.", UNIT(s)->id);
318 if (s->type != SERVICE_ONESHOT && !s->exec_command[SERVICE_EXEC_START]) {
319 log_error_unit(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
323 if (!s->remain_after_exit && !s->exec_command[SERVICE_EXEC_START]) {
324 log_error_unit(UNIT(s)->id, "%s has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.", UNIT(s)->id);
328 if (s->type != SERVICE_ONESHOT && s->exec_command[SERVICE_EXEC_START]->command_next) {
329 log_error_unit(UNIT(s)->id, "%s has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
333 if (s->type == SERVICE_ONESHOT && s->restart != SERVICE_RESTART_NO) {
334 log_error_unit(UNIT(s)->id, "%s has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
338 if (s->type == SERVICE_ONESHOT && !exit_status_set_is_empty(&s->restart_force_status)) {
339 log_error_unit(UNIT(s)->id, "%s has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
343 if (s->type == SERVICE_DBUS && !s->bus_name) {
344 log_error_unit(UNIT(s)->id, "%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
348 if (s->bus_name && s->type != SERVICE_DBUS)
349 log_warning_unit(UNIT(s)->id, "%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
351 if (s->exec_context.pam_name && !(s->kill_context.kill_mode == KILL_CONTROL_GROUP || s->kill_context.kill_mode == KILL_MIXED)) {
352 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.", UNIT(s)->id);
359 static int service_add_default_dependencies(Service *s) {
364 /* Add a number of automatic dependencies useful for the
365 * majority of services. */
367 /* First, pull in base system */
368 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true);
372 /* Second, activate normal shutdown */
373 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
377 static void service_fix_output(Service *s) {
380 /* If nothing has been explicitly configured, patch default
381 * output in. If input is socket/tty we avoid this however,
382 * since in that case we want output to default to the same
383 * place as we read input from. */
385 if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
386 s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
387 s->exec_context.std_input == EXEC_INPUT_NULL)
388 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
390 if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
391 s->exec_context.std_input == EXEC_INPUT_NULL)
392 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
395 static int service_load(Unit *u) {
396 Service *s = SERVICE(u);
401 /* Load a .service file */
402 r = unit_load_fragment(u);
406 /* Still nothing found? Then let's give up */
407 if (u->load_state == UNIT_STUB)
410 /* This is a new unit? Then let's add in some extras */
411 if (u->load_state == UNIT_LOADED) {
413 /* We were able to load something, then let's add in
414 * the dropin directories. */
415 r = unit_load_dropin(u);
419 if (s->type == _SERVICE_TYPE_INVALID) {
420 /* Figure out a type automatically */
422 s->type = SERVICE_DBUS;
423 else if (s->exec_command[SERVICE_EXEC_START])
424 s->type = SERVICE_SIMPLE;
426 s->type = SERVICE_ONESHOT;
429 /* Oneshot services have disabled start timeout by default */
430 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
431 s->timeout_start_usec = 0;
433 service_fix_output(s);
435 r = unit_patch_contexts(u);
439 r = unit_add_exec_dependencies(u, &s->exec_context);
443 r = unit_add_default_slice(u, &s->cgroup_context);
447 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
448 s->notify_access = NOTIFY_MAIN;
450 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
451 s->notify_access = NOTIFY_MAIN;
454 r = unit_watch_bus_name(u, s->bus_name);
459 if (u->default_dependencies) {
460 r = service_add_default_dependencies(s);
467 return service_verify(s);
470 static void service_dump(Unit *u, FILE *f, const char *prefix) {
471 ServiceExecCommand c;
472 Service *s = SERVICE(u);
477 prefix = strempty(prefix);
478 prefix2 = strappenda(prefix, "\t");
481 "%sService State: %s\n"
483 "%sReload Result: %s\n"
484 "%sPermissionsStartOnly: %s\n"
485 "%sRootDirectoryStartOnly: %s\n"
486 "%sRemainAfterExit: %s\n"
487 "%sGuessMainPID: %s\n"
490 "%sNotifyAccess: %s\n"
491 "%sNotifyState: %s\n",
492 prefix, service_state_to_string(s->state),
493 prefix, service_result_to_string(s->result),
494 prefix, service_result_to_string(s->reload_result),
495 prefix, yes_no(s->permissions_start_only),
496 prefix, yes_no(s->root_directory_start_only),
497 prefix, yes_no(s->remain_after_exit),
498 prefix, yes_no(s->guess_main_pid),
499 prefix, service_type_to_string(s->type),
500 prefix, service_restart_to_string(s->restart),
501 prefix, notify_access_to_string(s->notify_access),
502 prefix, notify_state_to_string(s->notify_state));
504 if (s->control_pid > 0)
506 "%sControl PID: "PID_FMT"\n",
507 prefix, s->control_pid);
511 "%sMain PID: "PID_FMT"\n"
512 "%sMain PID Known: %s\n"
513 "%sMain PID Alien: %s\n",
515 prefix, yes_no(s->main_pid_known),
516 prefix, yes_no(s->main_pid_alien));
521 prefix, s->pid_file);
526 "%sBus Name Good: %s\n",
528 prefix, yes_no(s->bus_name_good));
530 kill_context_dump(&s->kill_context, f, prefix);
531 exec_context_dump(&s->exec_context, f, prefix);
533 for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
535 if (!s->exec_command[c])
538 fprintf(f, "%s-> %s:\n",
539 prefix, service_exec_command_to_string(c));
541 exec_command_dump_list(s->exec_command[c], f, prefix2);
544 #ifdef HAVE_SYSV_COMPAT
545 if (s->sysv_start_priority >= 0)
547 "%sSysVStartPriority: %i\n",
548 prefix, s->sysv_start_priority);
552 fprintf(f, "%sStatus Text: %s\n",
553 prefix, s->status_text);
556 static int service_load_pid_file(Service *s, bool may_warn) {
557 _cleanup_free_ char *k = NULL;
566 r = read_one_line_file(s->pid_file, &k);
569 log_info_unit(UNIT(s)->id, "PID file %s not readable (yet?) after %s.", s->pid_file, service_state_to_string(s->state));
573 r = parse_pid(k, &pid);
576 log_info_unit(UNIT(s)->id, "Failed to read PID from file %s: %s", s->pid_file, strerror(-r));
580 if (!pid_is_alive(pid)) {
582 log_info_unit(UNIT(s)->id, "PID "PID_FMT" read from file %s does not exist or is a zombie.", pid, s->pid_file);
586 if (s->main_pid_known) {
587 if (pid == s->main_pid)
590 log_debug_unit(UNIT(s)->id, "Main PID changing: "PID_FMT" -> "PID_FMT, s->main_pid, pid);
592 service_unwatch_main_pid(s);
593 s->main_pid_known = false;
595 log_debug_unit(UNIT(s)->id, "Main PID loaded: "PID_FMT, pid);
597 r = service_set_main_pid(s, pid);
601 r = unit_watch_pid(UNIT(s), pid);
603 /* FIXME: we need to do something here */
604 log_warning_unit(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
611 static int service_search_main_pid(Service *s) {
617 /* If we know it anyway, don't ever fallback to unreliable
619 if (s->main_pid_known)
622 if (!s->guess_main_pid)
625 assert(s->main_pid <= 0);
627 pid = unit_search_main_pid(UNIT(s));
631 log_debug_unit(UNIT(s)->id, "Main PID guessed: "PID_FMT, pid);
632 r = service_set_main_pid(s, pid);
636 r = unit_watch_pid(UNIT(s), pid);
638 /* FIXME: we need to do something here */
639 log_warning_unit(UNIT(s)->id, "Failed to watch PID "PID_FMT" from service %s", pid, UNIT(s)->id);
646 static void service_set_state(Service *s, ServiceState state) {
647 ServiceState old_state;
648 const UnitActiveState *table;
652 table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
654 old_state = s->state;
657 service_unwatch_pid_file(s);
660 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
662 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
664 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
665 SERVICE_AUTO_RESTART))
666 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
669 SERVICE_START, SERVICE_START_POST,
670 SERVICE_RUNNING, SERVICE_RELOAD,
671 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
673 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
674 service_unwatch_main_pid(s);
675 s->main_command = NULL;
679 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
681 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
683 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
684 service_unwatch_control_pid(s);
685 s->control_command = NULL;
686 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
689 if (IN_SET(state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
690 unit_unwatch_all_pids(UNIT(s));
693 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
694 SERVICE_RUNNING, SERVICE_RELOAD,
695 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL, SERVICE_STOP_POST,
696 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL) &&
697 !(state == SERVICE_DEAD && UNIT(s)->job)) {
698 service_close_socket_fd(s);
699 service_connection_unref(s);
702 if (!IN_SET(state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
703 service_stop_watchdog(s);
705 /* For the inactive states unit_notify() will trim the cgroup,
706 * but for exit we have to do that ourselves... */
707 if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
708 unit_destroy_cgroup(UNIT(s));
710 /* For remain_after_exit services, let's see if we can "release" the
711 * hold on the console, since unit_notify() only does that in case of
713 if (state == SERVICE_EXITED &&
714 s->remain_after_exit &&
715 UNIT(s)->manager->n_on_console > 0) {
719 ec = unit_get_exec_context(UNIT(s));
720 if (ec && exec_context_may_touch_console(ec)) {
721 Manager *m = UNIT(s)->manager;
724 if (m->n_on_console == 0)
725 /* unset no_console_output flag, since the console is free */
726 m->no_console_output = false;
730 if (old_state != state)
731 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
733 unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
734 s->reload_result = SERVICE_SUCCESS;
737 static int service_coldplug(Unit *u) {
738 Service *s = SERVICE(u);
742 assert(s->state == SERVICE_DEAD);
744 if (s->deserialized_state != s->state) {
746 if (IN_SET(s->deserialized_state,
747 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
749 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
751 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
755 k = IN_SET(s->deserialized_state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec;
757 /* For the start/stop timeouts 0 means off */
759 r = service_arm_timer(s, k);
765 if (s->deserialized_state == SERVICE_AUTO_RESTART) {
767 /* The restart timeouts 0 means immediately */
768 r = service_arm_timer(s, s->restart_usec);
773 if (pid_is_unwaited(s->main_pid) &&
774 ((s->deserialized_state == SERVICE_START && IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_ONESHOT, SERVICE_NOTIFY)) ||
775 IN_SET(s->deserialized_state,
776 SERVICE_START, SERVICE_START_POST,
777 SERVICE_RUNNING, SERVICE_RELOAD,
778 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
780 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL))) {
781 r = unit_watch_pid(UNIT(s), s->main_pid);
786 if (pid_is_unwaited(s->control_pid) &&
787 IN_SET(s->deserialized_state,
788 SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST,
790 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
792 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL)) {
793 r = unit_watch_pid(UNIT(s), s->control_pid);
798 if (!IN_SET(s->deserialized_state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART))
799 unit_watch_all_pids(UNIT(s));
801 if (IN_SET(s->deserialized_state, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD))
802 service_start_watchdog(s);
804 service_set_state(s, s->deserialized_state);
810 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
821 if (s->socket_fd >= 0)
824 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
829 if (u->type != UNIT_SOCKET)
834 r = socket_collect_fds(sock, &cfds, &cn_fds);
847 t = new(int, rn_fds+cn_fds);
854 memcpy(t, rfds, rn_fds * sizeof(int));
855 memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
860 rn_fds = rn_fds+cn_fds;
875 static int service_spawn(
880 bool apply_permissions,
882 bool apply_tty_stdin,
883 bool set_notify_socket,
890 _cleanup_free_ int *fdsbuf = NULL;
891 unsigned n_fds = 0, n_env = 0;
892 _cleanup_strv_free_ char
893 **argv = NULL, **final_env = NULL, **our_env = NULL;
900 unit_realize_cgroup(UNIT(s));
902 r = unit_setup_exec_runtime(UNIT(s));
907 s->exec_context.std_input == EXEC_INPUT_SOCKET ||
908 s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
909 s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
911 if (s->socket_fd >= 0) {
915 r = service_collect_fds(s, &fdsbuf, &n_fds);
924 r = service_arm_timer(s, timeout);
928 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
930 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
934 our_env = new0(char*, 4);
940 if (set_notify_socket)
941 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
947 if (asprintf(our_env + n_env++, "MAINPID="PID_FMT, s->main_pid) < 0) {
952 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
953 if (asprintf(our_env + n_env++, "MANAGERPID="PID_FMT, getpid()) < 0) {
958 final_env = strv_env_merge(2, UNIT(s)->manager->environment, our_env, NULL);
964 if (is_control && UNIT(s)->cgroup_path) {
965 path = strappenda(UNIT(s)->cgroup_path, "/control");
966 cg_create(SYSTEMD_CGROUP_CONTROLLER, path);
968 path = UNIT(s)->cgroup_path;
978 UNIT(s)->manager->confirm_spawn,
979 UNIT(s)->manager->cgroup_supported,
981 manager_get_runtime_prefix(UNIT(s)->manager),
984 s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
990 r = unit_watch_pid(UNIT(s), pid);
992 /* FIXME: we need to do something here */
1001 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1006 static int main_pid_good(Service *s) {
1009 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1012 /* If we know the pid file, then lets just check if it is
1014 if (s->main_pid_known) {
1016 /* If it's an alien child let's check if it is still
1018 if (s->main_pid_alien && s->main_pid > 0)
1019 return pid_is_alive(s->main_pid);
1021 /* .. otherwise assume we'll get a SIGCHLD for it,
1022 * which we really should wait for to collect exit
1023 * status and code */
1024 return s->main_pid > 0;
1027 /* We don't know the pid */
1031 _pure_ static int control_pid_good(Service *s) {
1034 return s->control_pid > 0;
1037 static int cgroup_good(Service *s) {
1042 if (!UNIT(s)->cgroup_path)
1045 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
1052 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1056 if (f != SERVICE_SUCCESS)
1059 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1061 if (s->result != SERVICE_SUCCESS) {
1062 log_warning_unit(UNIT(s)->id, "%s failed.", UNIT(s)->id);
1063 failure_action(UNIT(s)->manager, s->failure_action, s->reboot_arg);
1066 if (allow_restart &&
1067 !s->forbid_restart &&
1068 (s->restart == SERVICE_RESTART_ALWAYS ||
1069 (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1070 (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1071 (s->restart == SERVICE_RESTART_ON_ABNORMAL && !IN_SET(s->result, SERVICE_SUCCESS, SERVICE_FAILURE_EXIT_CODE)) ||
1072 (s->restart == SERVICE_RESTART_ON_WATCHDOG && s->result == SERVICE_FAILURE_WATCHDOG) ||
1073 (s->restart == SERVICE_RESTART_ON_ABORT && IN_SET(s->result, SERVICE_FAILURE_SIGNAL, SERVICE_FAILURE_CORE_DUMP)) ||
1074 (s->main_exec_status.code == CLD_EXITED && set_contains(s->restart_force_status.status, INT_TO_PTR(s->main_exec_status.status))) ||
1075 (IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) && set_contains(s->restart_force_status.signal, INT_TO_PTR(s->main_exec_status.status)))) &&
1076 (s->main_exec_status.code != CLD_EXITED || !set_contains(s->restart_prevent_status.status, INT_TO_PTR(s->main_exec_status.status))) &&
1077 (!IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) || !set_contains(s->restart_prevent_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
1079 r = service_arm_timer(s, s->restart_usec);
1083 service_set_state(s, SERVICE_AUTO_RESTART);
1086 s->forbid_restart = false;
1088 /* We want fresh tmpdirs in case service is started again immediately */
1089 exec_runtime_destroy(s->exec_runtime);
1090 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1092 /* Also, remove the runtime directory in */
1093 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1095 /* Try to delete the pid file. At this point it will be
1096 * out-of-date, and some software might be confused by it, so
1097 * let's remove it. */
1099 unlink_noerrno(s->pid_file);
1104 log_warning_unit(UNIT(s)->id, "%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1105 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1108 static void service_enter_stop_post(Service *s, ServiceResult f) {
1112 if (f != SERVICE_SUCCESS)
1115 service_unwatch_control_pid(s);
1116 unit_watch_all_pids(UNIT(s));
1118 s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST];
1119 if (s->control_command) {
1120 s->control_command_id = SERVICE_EXEC_STOP_POST;
1122 r = service_spawn(s,
1124 s->timeout_stop_usec,
1126 !s->permissions_start_only,
1127 !s->root_directory_start_only,
1135 service_set_state(s, SERVICE_STOP_POST);
1137 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1142 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1143 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1146 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1151 if (f != SERVICE_SUCCESS)
1154 unit_watch_all_pids(UNIT(s));
1156 r = unit_kill_context(
1159 state != SERVICE_STOP_SIGTERM && state != SERVICE_FINAL_SIGTERM,
1168 if (s->timeout_stop_usec > 0) {
1169 r = service_arm_timer(s, s->timeout_stop_usec);
1174 service_set_state(s, state);
1175 } else if (state == SERVICE_STOP_SIGTERM)
1176 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_SUCCESS);
1177 else if (state == SERVICE_STOP_SIGKILL)
1178 service_enter_stop_post(s, SERVICE_SUCCESS);
1179 else if (state == SERVICE_FINAL_SIGTERM)
1180 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_SUCCESS);
1182 service_enter_dead(s, SERVICE_SUCCESS, true);
1187 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1189 if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1190 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1192 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1195 static void service_enter_stop_by_notify(Service *s) {
1198 unit_watch_all_pids(UNIT(s));
1200 if (s->timeout_stop_usec > 0)
1201 service_arm_timer(s, s->timeout_stop_usec);
1203 service_set_state(s, SERVICE_STOP);
1206 static void service_enter_stop(Service *s, ServiceResult f) {
1211 if (f != SERVICE_SUCCESS)
1214 service_unwatch_control_pid(s);
1215 unit_watch_all_pids(UNIT(s));
1217 s->control_command = s->exec_command[SERVICE_EXEC_STOP];
1218 if (s->control_command) {
1219 s->control_command_id = SERVICE_EXEC_STOP;
1221 r = service_spawn(s,
1223 s->timeout_stop_usec,
1225 !s->permissions_start_only,
1226 !s->root_directory_start_only,
1234 service_set_state(s, SERVICE_STOP);
1236 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1241 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
1242 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1245 static void service_enter_running(Service *s, ServiceResult f) {
1246 int main_pid_ok, cgroup_ok;
1249 if (f != SERVICE_SUCCESS)
1252 main_pid_ok = main_pid_good(s);
1253 cgroup_ok = cgroup_good(s);
1255 if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
1256 (s->bus_name_good || s->type != SERVICE_DBUS)) {
1258 /* If there are any queued up sd_notify()
1259 * notifications, process them now */
1260 if (s->notify_state == NOTIFY_RELOADING)
1261 service_enter_reload_by_notify(s);
1262 else if (s->notify_state == NOTIFY_STOPPING)
1263 service_enter_stop_by_notify(s);
1265 service_set_state(s, SERVICE_RUNNING);
1267 } else if (s->remain_after_exit)
1268 service_set_state(s, SERVICE_EXITED);
1270 service_enter_stop(s, SERVICE_SUCCESS);
1273 static void service_enter_start_post(Service *s) {
1277 service_unwatch_control_pid(s);
1278 service_reset_watchdog(s);
1280 s->control_command = s->exec_command[SERVICE_EXEC_START_POST];
1281 if (s->control_command) {
1282 s->control_command_id = SERVICE_EXEC_START_POST;
1284 r = service_spawn(s,
1286 s->timeout_start_usec,
1288 !s->permissions_start_only,
1289 !s->root_directory_start_only,
1297 service_set_state(s, SERVICE_START_POST);
1299 service_enter_running(s, SERVICE_SUCCESS);
1304 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1305 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1308 static void service_kill_control_processes(Service *s) {
1311 if (!UNIT(s)->cgroup_path)
1314 p = strappenda(UNIT(s)->cgroup_path, "/control");
1315 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, p, SIGKILL, true, true, true, NULL);
1318 static void service_enter_start(Service *s) {
1325 service_unwatch_control_pid(s);
1326 service_unwatch_main_pid(s);
1328 /* We want to ensure that nobody leaks processes from
1329 * START_PRE here, so let's go on a killing spree, People
1330 * should not spawn long running processes from START_PRE. */
1331 service_kill_control_processes(s);
1333 if (s->type == SERVICE_FORKING) {
1334 s->control_command_id = SERVICE_EXEC_START;
1335 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
1337 s->main_command = NULL;
1339 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1340 s->control_command = NULL;
1342 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
1346 assert(s->type == SERVICE_ONESHOT);
1347 service_enter_start_post(s);
1351 r = service_spawn(s,
1353 IN_SET(s->type, SERVICE_FORKING, SERVICE_DBUS, SERVICE_NOTIFY, SERVICE_ONESHOT) ? s->timeout_start_usec : 0,
1358 s->notify_access != NOTIFY_NONE,
1364 if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
1365 /* For simple services we immediately start
1366 * the START_POST binaries. */
1368 service_set_main_pid(s, pid);
1369 service_enter_start_post(s);
1371 } else if (s->type == SERVICE_FORKING) {
1373 /* For forking services we wait until the start
1374 * process exited. */
1376 s->control_pid = pid;
1377 service_set_state(s, SERVICE_START);
1379 } else if (s->type == SERVICE_ONESHOT ||
1380 s->type == SERVICE_DBUS ||
1381 s->type == SERVICE_NOTIFY) {
1383 /* For oneshot services we wait until the start
1384 * process exited, too, but it is our main process. */
1386 /* For D-Bus services we know the main pid right away,
1387 * but wait for the bus name to appear on the
1388 * bus. Notify services are similar. */
1390 service_set_main_pid(s, pid);
1391 service_set_state(s, SERVICE_START);
1393 assert_not_reached("Unknown service type");
1398 log_warning_unit(UNIT(s)->id, "%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
1399 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1402 static void service_enter_start_pre(Service *s) {
1407 service_unwatch_control_pid(s);
1409 s->control_command = s->exec_command[SERVICE_EXEC_START_PRE];
1410 if (s->control_command) {
1411 /* Before we start anything, let's clear up what might
1412 * be left from previous runs. */
1413 service_kill_control_processes(s);
1415 s->control_command_id = SERVICE_EXEC_START_PRE;
1417 r = service_spawn(s,
1419 s->timeout_start_usec,
1421 !s->permissions_start_only,
1422 !s->root_directory_start_only,
1430 service_set_state(s, SERVICE_START_PRE);
1432 service_enter_start(s);
1437 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1438 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1441 static void service_enter_restart(Service *s) {
1442 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1447 if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
1448 /* Don't restart things if we are going down anyway */
1449 log_info_unit(UNIT(s)->id, "Stop job pending for unit, delaying automatic restart.");
1451 r = service_arm_timer(s, s->restart_usec);
1458 /* Any units that are bound to this service must also be
1459 * restarted. We use JOB_RESTART (instead of the more obvious
1460 * JOB_START) here so that those dependency jobs will be added
1462 r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
1466 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1467 * it will be canceled as part of the service_stop() call that
1468 * is executed as part of JOB_RESTART. */
1470 log_debug_unit(UNIT(s)->id, "%s scheduled restart job.", UNIT(s)->id);
1474 log_warning_unit(UNIT(s)->id, "%s failed to schedule restart job: %s", UNIT(s)->id, bus_error_message(&error, -r));
1475 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1478 static void service_enter_reload_by_notify(Service *s) {
1481 if (s->timeout_start_usec > 0)
1482 service_arm_timer(s, s->timeout_start_usec);
1484 service_set_state(s, SERVICE_RELOAD);
1487 static void service_enter_reload(Service *s) {
1492 service_unwatch_control_pid(s);
1494 s->control_command = s->exec_command[SERVICE_EXEC_RELOAD];
1495 if (s->control_command) {
1496 s->control_command_id = SERVICE_EXEC_RELOAD;
1498 r = service_spawn(s,
1500 s->timeout_start_usec,
1502 !s->permissions_start_only,
1503 !s->root_directory_start_only,
1511 service_set_state(s, SERVICE_RELOAD);
1513 service_enter_running(s, SERVICE_SUCCESS);
1518 log_warning_unit(UNIT(s)->id, "%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
1519 s->reload_result = SERVICE_FAILURE_RESOURCES;
1520 service_enter_running(s, SERVICE_SUCCESS);
1523 static void service_run_next_control(Service *s) {
1527 assert(s->control_command);
1528 assert(s->control_command->command_next);
1530 assert(s->control_command_id != SERVICE_EXEC_START);
1532 s->control_command = s->control_command->command_next;
1533 service_unwatch_control_pid(s);
1535 r = service_spawn(s,
1537 IN_SET(s->state, SERVICE_START_PRE, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD) ? s->timeout_start_usec : s->timeout_stop_usec,
1539 !s->permissions_start_only,
1540 !s->root_directory_start_only,
1541 s->control_command_id == SERVICE_EXEC_START_PRE ||
1542 s->control_command_id == SERVICE_EXEC_STOP_POST,
1552 log_warning_unit(UNIT(s)->id, "%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
1554 if (s->state == SERVICE_START_PRE)
1555 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1556 else if (s->state == SERVICE_STOP)
1557 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
1558 else if (s->state == SERVICE_STOP_POST)
1559 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1560 else if (s->state == SERVICE_RELOAD) {
1561 s->reload_result = SERVICE_FAILURE_RESOURCES;
1562 service_enter_running(s, SERVICE_SUCCESS);
1564 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1567 static void service_run_next_main(Service *s) {
1572 assert(s->main_command);
1573 assert(s->main_command->command_next);
1574 assert(s->type == SERVICE_ONESHOT);
1576 s->main_command = s->main_command->command_next;
1577 service_unwatch_main_pid(s);
1579 r = service_spawn(s,
1581 s->timeout_start_usec,
1586 s->notify_access != NOTIFY_NONE,
1592 service_set_main_pid(s, pid);
1597 log_warning_unit(UNIT(s)->id, "%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
1598 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
1601 static int service_start_limit_test(Service *s) {
1604 if (ratelimit_test(&s->start_limit))
1607 log_warning_unit(UNIT(s)->id, "start request repeated too quickly for %s", UNIT(s)->id);
1609 return failure_action(UNIT(s)->manager, s->start_limit_action, s->reboot_arg);
1612 static int service_start(Unit *u) {
1613 Service *s = SERVICE(u);
1618 /* We cannot fulfill this request right now, try again later
1620 if (s->state == SERVICE_STOP ||
1621 s->state == SERVICE_STOP_SIGTERM ||
1622 s->state == SERVICE_STOP_SIGKILL ||
1623 s->state == SERVICE_STOP_POST ||
1624 s->state == SERVICE_FINAL_SIGTERM ||
1625 s->state == SERVICE_FINAL_SIGKILL)
1628 /* Already on it! */
1629 if (s->state == SERVICE_START_PRE ||
1630 s->state == SERVICE_START ||
1631 s->state == SERVICE_START_POST)
1634 /* A service that will be restarted must be stopped first to
1635 * trigger BindsTo and/or OnFailure dependencies. If a user
1636 * does not want to wait for the holdoff time to elapse, the
1637 * service should be manually restarted, not started. We
1638 * simply return EAGAIN here, so that any start jobs stay
1639 * queued, and assume that the auto restart timer will
1640 * eventually trigger the restart. */
1641 if (s->state == SERVICE_AUTO_RESTART)
1644 assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
1646 /* Make sure we don't enter a busy loop of some kind. */
1647 r = service_start_limit_test(s);
1649 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
1653 s->result = SERVICE_SUCCESS;
1654 s->reload_result = SERVICE_SUCCESS;
1655 s->main_pid_known = false;
1656 s->main_pid_alien = false;
1657 s->forbid_restart = false;
1659 free(s->status_text);
1660 s->status_text = NULL;
1661 s->status_errno = 0;
1663 s->notify_state = NOTIFY_UNKNOWN;
1665 service_enter_start_pre(s);
1669 static int service_stop(Unit *u) {
1670 Service *s = SERVICE(u);
1674 /* Don't create restart jobs from here. */
1675 s->forbid_restart = true;
1678 if (s->state == SERVICE_STOP ||
1679 s->state == SERVICE_STOP_SIGTERM ||
1680 s->state == SERVICE_STOP_SIGKILL ||
1681 s->state == SERVICE_STOP_POST ||
1682 s->state == SERVICE_FINAL_SIGTERM ||
1683 s->state == SERVICE_FINAL_SIGKILL)
1686 /* A restart will be scheduled or is in progress. */
1687 if (s->state == SERVICE_AUTO_RESTART) {
1688 service_set_state(s, SERVICE_DEAD);
1692 /* If there's already something running we go directly into
1694 if (s->state == SERVICE_START_PRE ||
1695 s->state == SERVICE_START ||
1696 s->state == SERVICE_START_POST ||
1697 s->state == SERVICE_RELOAD) {
1698 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
1702 assert(s->state == SERVICE_RUNNING ||
1703 s->state == SERVICE_EXITED);
1705 service_enter_stop(s, SERVICE_SUCCESS);
1709 static int service_reload(Unit *u) {
1710 Service *s = SERVICE(u);
1714 assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
1716 service_enter_reload(s);
1720 _pure_ static bool service_can_reload(Unit *u) {
1721 Service *s = SERVICE(u);
1725 return !!s->exec_command[SERVICE_EXEC_RELOAD];
1728 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
1729 Service *s = SERVICE(u);
1735 unit_serialize_item(u, f, "state", service_state_to_string(s->state));
1736 unit_serialize_item(u, f, "result", service_result_to_string(s->result));
1737 unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
1739 if (s->control_pid > 0)
1740 unit_serialize_item_format(u, f, "control-pid", PID_FMT,
1743 if (s->main_pid_known && s->main_pid > 0)
1744 unit_serialize_item_format(u, f, "main-pid", PID_FMT, s->main_pid);
1746 unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
1749 unit_serialize_item(u, f, "status-text", s->status_text);
1751 /* FIXME: There's a minor uncleanliness here: if there are
1752 * multiple commands attached here, we will start from the
1753 * first one again */
1754 if (s->control_command_id >= 0)
1755 unit_serialize_item(u, f, "control-command",
1756 service_exec_command_to_string(s->control_command_id));
1758 if (s->socket_fd >= 0) {
1761 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
1764 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
1767 if (s->main_exec_status.pid > 0) {
1768 unit_serialize_item_format(u, f, "main-exec-status-pid", PID_FMT,
1769 s->main_exec_status.pid);
1770 dual_timestamp_serialize(f, "main-exec-status-start",
1771 &s->main_exec_status.start_timestamp);
1772 dual_timestamp_serialize(f, "main-exec-status-exit",
1773 &s->main_exec_status.exit_timestamp);
1775 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
1776 unit_serialize_item_format(u, f, "main-exec-status-code", "%i",
1777 s->main_exec_status.code);
1778 unit_serialize_item_format(u, f, "main-exec-status-status", "%i",
1779 s->main_exec_status.status);
1782 if (dual_timestamp_is_set(&s->watchdog_timestamp))
1783 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
1785 if (s->forbid_restart)
1786 unit_serialize_item(u, f, "forbid-restart", yes_no(s->forbid_restart));
1791 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1792 Service *s = SERVICE(u);
1799 if (streq(key, "state")) {
1802 state = service_state_from_string(value);
1804 log_debug_unit(u->id, "Failed to parse state value %s", value);
1806 s->deserialized_state = state;
1807 } else if (streq(key, "result")) {
1810 f = service_result_from_string(value);
1812 log_debug_unit(u->id, "Failed to parse result value %s", value);
1813 else if (f != SERVICE_SUCCESS)
1816 } else if (streq(key, "reload-result")) {
1819 f = service_result_from_string(value);
1821 log_debug_unit(u->id, "Failed to parse reload result value %s", value);
1822 else if (f != SERVICE_SUCCESS)
1823 s->reload_result = f;
1825 } else if (streq(key, "control-pid")) {
1828 if (parse_pid(value, &pid) < 0)
1829 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1831 s->control_pid = pid;
1832 } else if (streq(key, "main-pid")) {
1835 if (parse_pid(value, &pid) < 0)
1836 log_debug_unit(u->id, "Failed to parse main-pid value %s", value);
1838 service_set_main_pid(s, pid);
1839 unit_watch_pid(UNIT(s), pid);
1841 } else if (streq(key, "main-pid-known")) {
1844 b = parse_boolean(value);
1846 log_debug_unit(u->id, "Failed to parse main-pid-known value %s", value);
1848 s->main_pid_known = b;
1849 } else if (streq(key, "status-text")) {
1856 free(s->status_text);
1860 } else if (streq(key, "control-command")) {
1861 ServiceExecCommand id;
1863 id = service_exec_command_from_string(value);
1865 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1867 s->control_command_id = id;
1868 s->control_command = s->exec_command[id];
1870 } else if (streq(key, "socket-fd")) {
1873 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1874 log_debug_unit(u->id, "Failed to parse socket-fd value %s", value);
1877 asynchronous_close(s->socket_fd);
1878 s->socket_fd = fdset_remove(fds, fd);
1880 } else if (streq(key, "main-exec-status-pid")) {
1883 if (parse_pid(value, &pid) < 0)
1884 log_debug_unit(u->id, "Failed to parse main-exec-status-pid value %s", value);
1886 s->main_exec_status.pid = pid;
1887 } else if (streq(key, "main-exec-status-code")) {
1890 if (safe_atoi(value, &i) < 0)
1891 log_debug_unit(u->id, "Failed to parse main-exec-status-code value %s", value);
1893 s->main_exec_status.code = i;
1894 } else if (streq(key, "main-exec-status-status")) {
1897 if (safe_atoi(value, &i) < 0)
1898 log_debug_unit(u->id, "Failed to parse main-exec-status-status value %s", value);
1900 s->main_exec_status.status = i;
1901 } else if (streq(key, "main-exec-status-start"))
1902 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
1903 else if (streq(key, "main-exec-status-exit"))
1904 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
1905 else if (streq(key, "watchdog-timestamp"))
1906 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
1907 else if (streq(key, "forbid-restart")) {
1910 b = parse_boolean(value);
1912 log_debug_unit(u->id, "Failed to parse forbid-restart value %s", value);
1914 s->forbid_restart = b;
1916 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
1921 _pure_ static UnitActiveState service_active_state(Unit *u) {
1922 const UnitActiveState *table;
1926 table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1928 return table[SERVICE(u)->state];
1931 static const char *service_sub_state_to_string(Unit *u) {
1934 return service_state_to_string(SERVICE(u)->state);
1937 static bool service_check_gc(Unit *u) {
1938 Service *s = SERVICE(u);
1942 /* Never clean up services that still have a process around,
1943 * even if the service is formally dead. */
1944 if (cgroup_good(s) > 0 ||
1945 main_pid_good(s) > 0 ||
1946 control_pid_good(s) > 0)
1952 _pure_ static bool service_check_snapshot(Unit *u) {
1953 Service *s = SERVICE(u);
1957 return s->socket_fd < 0;
1960 static int service_retry_pid_file(Service *s) {
1963 assert(s->pid_file);
1964 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
1966 r = service_load_pid_file(s, false);
1970 service_unwatch_pid_file(s);
1972 service_enter_running(s, SERVICE_SUCCESS);
1976 static int service_watch_pid_file(Service *s) {
1979 log_debug_unit(UNIT(s)->id, "Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
1981 r = path_spec_watch(s->pid_file_pathspec, service_dispatch_io);
1985 /* the pidfile might have appeared just before we set the watch */
1986 log_debug_unit(UNIT(s)->id, "Trying to read %s's PID file %s in case it changed", UNIT(s)->id, s->pid_file_pathspec->path);
1987 service_retry_pid_file(s);
1991 log_error_unit(UNIT(s)->id, "Failed to set a watch for %s's PID file %s: %s", UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
1992 service_unwatch_pid_file(s);
1996 static int service_demand_pid_file(Service *s) {
1999 assert(s->pid_file);
2000 assert(!s->pid_file_pathspec);
2002 ps = new0(PathSpec, 1);
2007 ps->path = strdup(s->pid_file);
2013 path_kill_slashes(ps->path);
2015 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2016 * keep their PID file open all the time. */
2017 ps->type = PATH_MODIFIED;
2018 ps->inotify_fd = -1;
2020 s->pid_file_pathspec = ps;
2022 return service_watch_pid_file(s);
2025 static int service_dispatch_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
2026 PathSpec *p = userdata;
2031 s = SERVICE(p->unit);
2035 assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2036 assert(s->pid_file_pathspec);
2037 assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2039 log_debug_unit(UNIT(s)->id, "inotify event for %s", UNIT(s)->id);
2041 if (path_spec_fd_event(p, events) < 0)
2044 if (service_retry_pid_file(s) == 0)
2047 if (service_watch_pid_file(s) < 0)
2053 service_unwatch_pid_file(s);
2054 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2058 static void service_notify_cgroup_empty_event(Unit *u) {
2059 Service *s = SERVICE(u);
2063 log_debug_unit(u->id, "%s: cgroup is empty", u->id);
2067 /* Waiting for SIGCHLD is usually more interesting,
2068 * because it includes return codes/signals. Which is
2069 * why we ignore the cgroup events for most cases,
2070 * except when we don't know pid which to expect the
2074 case SERVICE_START_POST:
2075 /* If we were hoping for the daemon to write its PID file,
2076 * we can give up now. */
2077 if (s->pid_file_pathspec) {
2078 log_warning_unit(u->id, "%s never wrote its PID file. Failing.", UNIT(s)->id);
2080 service_unwatch_pid_file(s);
2081 if (s->state == SERVICE_START)
2082 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2084 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2088 case SERVICE_RUNNING:
2089 /* service_enter_running() will figure out what to do */
2090 service_enter_running(s, SERVICE_SUCCESS);
2093 case SERVICE_STOP_SIGTERM:
2094 case SERVICE_STOP_SIGKILL:
2096 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2097 service_enter_stop_post(s, SERVICE_SUCCESS);
2101 case SERVICE_STOP_POST:
2102 case SERVICE_FINAL_SIGTERM:
2103 case SERVICE_FINAL_SIGKILL:
2104 if (main_pid_good(s) <= 0 && !control_pid_good(s))
2105 service_enter_dead(s, SERVICE_SUCCESS, true);
2114 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2115 Service *s = SERVICE(u);
2121 if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2122 is_clean_exit_lsb(code, status, &s->success_status))
2123 f = SERVICE_SUCCESS;
2124 else if (code == CLD_EXITED)
2125 f = SERVICE_FAILURE_EXIT_CODE;
2126 else if (code == CLD_KILLED)
2127 f = SERVICE_FAILURE_SIGNAL;
2128 else if (code == CLD_DUMPED)
2129 f = SERVICE_FAILURE_CORE_DUMP;
2131 assert_not_reached("Unknown code");
2133 if (s->main_pid == pid) {
2134 /* Forking services may occasionally move to a new PID.
2135 * As long as they update the PID file before exiting the old
2136 * PID, they're fine. */
2137 if (service_load_pid_file(s, false) == 0)
2141 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2143 if (s->main_command) {
2144 /* If this is not a forking service than the
2145 * main process got started and hence we copy
2146 * the exit status so that it is recorded both
2147 * as main and as control process exit
2150 s->main_command->exec_status = s->main_exec_status;
2152 if (s->main_command->ignore)
2153 f = SERVICE_SUCCESS;
2154 } else if (s->exec_command[SERVICE_EXEC_START]) {
2156 /* If this is a forked process, then we should
2157 * ignore the return value if this was
2158 * configured for the starter process */
2160 if (s->exec_command[SERVICE_EXEC_START]->ignore)
2161 f = SERVICE_SUCCESS;
2164 log_struct_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2166 "MESSAGE=%s: main process exited, code=%s, status=%i/%s",
2167 u->id, sigchld_code_to_string(code), status,
2168 strna(code == CLD_EXITED
2169 ? exit_status_to_string(status, EXIT_STATUS_FULL)
2170 : signal_to_string(status)),
2171 "EXIT_CODE=%s", sigchld_code_to_string(code),
2172 "EXIT_STATUS=%i", status,
2175 if (f != SERVICE_SUCCESS)
2178 if (s->main_command &&
2179 s->main_command->command_next &&
2180 f == SERVICE_SUCCESS) {
2182 /* There is another command to *
2183 * execute, so let's do that. */
2185 log_debug_unit(u->id, "%s running next main command for state %s", u->id, service_state_to_string(s->state));
2186 service_run_next_main(s);
2190 /* The service exited, so the service is officially
2192 s->main_command = NULL;
2196 case SERVICE_START_POST:
2197 case SERVICE_RELOAD:
2199 /* Need to wait until the operation is
2204 if (s->type == SERVICE_ONESHOT) {
2205 /* This was our main goal, so let's go on */
2206 if (f == SERVICE_SUCCESS)
2207 service_enter_start_post(s);
2209 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2215 case SERVICE_RUNNING:
2216 service_enter_running(s, f);
2219 case SERVICE_STOP_SIGTERM:
2220 case SERVICE_STOP_SIGKILL:
2222 if (!control_pid_good(s))
2223 service_enter_stop_post(s, f);
2225 /* If there is still a control process, wait for that first */
2228 case SERVICE_STOP_POST:
2229 case SERVICE_FINAL_SIGTERM:
2230 case SERVICE_FINAL_SIGKILL:
2232 if (!control_pid_good(s))
2233 service_enter_dead(s, f, true);
2237 assert_not_reached("Uh, main process died at wrong time.");
2241 } else if (s->control_pid == pid) {
2244 if (s->control_command) {
2245 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2247 if (s->control_command->ignore)
2248 f = SERVICE_SUCCESS;
2251 log_full_unit(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
2252 "%s: control process exited, code=%s status=%i",
2253 u->id, sigchld_code_to_string(code), status);
2255 if (f != SERVICE_SUCCESS)
2258 /* Immediately get rid of the cgroup, so that the
2259 * kernel doesn't delay the cgroup empty messages for
2260 * the service cgroup any longer than necessary */
2261 service_kill_control_processes(s);
2263 if (s->control_command &&
2264 s->control_command->command_next &&
2265 f == SERVICE_SUCCESS) {
2267 /* There is another command to *
2268 * execute, so let's do that. */
2270 log_debug_unit(u->id, "%s running next control command for state %s", u->id, service_state_to_string(s->state));
2271 service_run_next_control(s);
2274 /* No further commands for this step, so let's
2275 * figure out what to do next */
2277 s->control_command = NULL;
2278 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2280 log_debug_unit(u->id, "%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2284 case SERVICE_START_PRE:
2285 if (f == SERVICE_SUCCESS)
2286 service_enter_start(s);
2288 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2292 if (s->type != SERVICE_FORKING)
2293 /* Maybe spurious event due to a reload that changed the type? */
2296 if (f != SERVICE_SUCCESS) {
2297 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2302 bool has_start_post;
2305 /* Let's try to load the pid file here if we can.
2306 * The PID file might actually be created by a START_POST
2307 * script. In that case don't worry if the loading fails. */
2309 has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2310 r = service_load_pid_file(s, !has_start_post);
2311 if (!has_start_post && r < 0) {
2312 r = service_demand_pid_file(s);
2313 if (r < 0 || !cgroup_good(s))
2314 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2318 service_search_main_pid(s);
2320 service_enter_start_post(s);
2323 case SERVICE_START_POST:
2324 if (f != SERVICE_SUCCESS) {
2325 service_enter_stop(s, f);
2332 r = service_load_pid_file(s, true);
2334 r = service_demand_pid_file(s);
2335 if (r < 0 || !cgroup_good(s))
2336 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2340 service_search_main_pid(s);
2342 service_enter_running(s, SERVICE_SUCCESS);
2345 case SERVICE_RELOAD:
2346 if (f == SERVICE_SUCCESS) {
2347 service_load_pid_file(s, true);
2348 service_search_main_pid(s);
2351 s->reload_result = f;
2352 service_enter_running(s, SERVICE_SUCCESS);
2356 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2359 case SERVICE_STOP_SIGTERM:
2360 case SERVICE_STOP_SIGKILL:
2361 if (main_pid_good(s) <= 0)
2362 service_enter_stop_post(s, f);
2364 /* If there is still a service
2365 * process around, wait until
2366 * that one quit, too */
2369 case SERVICE_STOP_POST:
2370 case SERVICE_FINAL_SIGTERM:
2371 case SERVICE_FINAL_SIGKILL:
2372 if (main_pid_good(s) <= 0)
2373 service_enter_dead(s, f, true);
2377 assert_not_reached("Uh, control process died at wrong time.");
2382 /* Notify clients about changed exit status */
2383 unit_add_to_dbus_queue(u);
2385 /* We got one SIGCHLD for the service, let's watch all
2386 * processes that are now running of the service, and watch
2387 * that. Among the PIDs we then watch will be children
2388 * reassigned to us, which hopefully allows us to identify
2389 * when all children are gone */
2390 unit_tidy_watch_pids(u, s->main_pid, s->control_pid);
2391 unit_watch_all_pids(u);
2393 /* If the PID set is empty now, then let's finish this off */
2394 if (set_isempty(u->pids))
2395 service_notify_cgroup_empty_event(u);
2398 static int service_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2399 Service *s = SERVICE(userdata);
2402 assert(source == s->timer_event_source);
2406 case SERVICE_START_PRE:
2408 log_warning_unit(UNIT(s)->id, "%s %s operation timed out. Terminating.", UNIT(s)->id, s->state == SERVICE_START ? "start" : "start-pre");
2409 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2412 case SERVICE_START_POST:
2413 log_warning_unit(UNIT(s)->id, "%s start-post operation timed out. Stopping.", UNIT(s)->id);
2414 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
2417 case SERVICE_RELOAD:
2418 log_warning_unit(UNIT(s)->id, "%s reload operation timed out. Stopping.", UNIT(s)->id);
2419 s->reload_result = SERVICE_FAILURE_TIMEOUT;
2420 service_enter_running(s, SERVICE_SUCCESS);
2424 log_warning_unit(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
2425 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2428 case SERVICE_STOP_SIGTERM:
2429 if (s->kill_context.send_sigkill) {
2430 log_warning_unit(UNIT(s)->id, "%s stop-sigterm timed out. Killing.", UNIT(s)->id);
2431 service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2433 log_warning_unit(UNIT(s)->id, "%s stop-sigterm timed out. Skipping SIGKILL.", UNIT(s)->id);
2434 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2439 case SERVICE_STOP_SIGKILL:
2440 /* Uh, we sent a SIGKILL and it is still not gone?
2441 * Must be something we cannot kill, so let's just be
2442 * weirded out and continue */
2444 log_warning_unit(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2445 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
2448 case SERVICE_STOP_POST:
2449 log_warning_unit(UNIT(s)->id, "%s stop-post timed out. Terminating.", UNIT(s)->id);
2450 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
2453 case SERVICE_FINAL_SIGTERM:
2454 if (s->kill_context.send_sigkill) {
2455 log_warning_unit(UNIT(s)->id, "%s stop-final-sigterm timed out. Killing.", UNIT(s)->id);
2456 service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
2458 log_warning_unit(UNIT(s)->id, "%s stop-final-sigterm timed out. Skipping SIGKILL. Entering failed mode.", UNIT(s)->id);
2459 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
2464 case SERVICE_FINAL_SIGKILL:
2465 log_warning_unit(UNIT(s)->id, "%s still around after final SIGKILL. Entering failed mode.", UNIT(s)->id);
2466 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
2469 case SERVICE_AUTO_RESTART:
2470 log_info_unit(UNIT(s)->id,
2471 s->restart_usec > 0 ?
2472 "%s holdoff time over, scheduling restart." :
2473 "%s has no holdoff time, scheduling restart.",
2475 service_enter_restart(s);
2479 assert_not_reached("Timeout at wrong time.");
2485 static int service_dispatch_watchdog(sd_event_source *source, usec_t usec, void *userdata) {
2486 Service *s = SERVICE(userdata);
2487 char t[FORMAT_TIMESPAN_MAX];
2490 assert(source == s->watchdog_event_source);
2492 log_error_unit(UNIT(s)->id, "%s watchdog timeout (limit %s)!", UNIT(s)->id,
2493 format_timespan(t, sizeof(t), s->watchdog_usec, 1));
2495 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_WATCHDOG);
2500 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
2501 Service *s = SERVICE(u);
2502 _cleanup_free_ char *cc = NULL;
2503 bool notify_dbus = false;
2508 cc = strv_join(tags, ", ");
2509 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT" (%s)",
2510 u->id, pid, isempty(cc) ? "n/a" : cc);
2512 if (s->notify_access == NOTIFY_NONE) {
2513 log_warning_unit(u->id, "%s: Got notification message from PID "PID_FMT", but reception is disabled.", u->id, pid);
2517 if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
2518 if (s->main_pid != 0)
2519 log_warning_unit(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID "PID_FMT, u->id, pid, s->main_pid);
2521 log_debug_unit(u->id, "%s: Got notification message from PID "PID_FMT", but reception only permitted for main PID which is currently not known", u->id, pid);
2525 /* Interpret MAINPID= */
2526 e = strv_find_startswith(tags, "MAINPID=");
2527 if (e && IN_SET(s->state, SERVICE_START, SERVICE_START_POST, SERVICE_RUNNING, SERVICE_RELOAD)) {
2528 if (parse_pid(e, &pid) < 0)
2529 log_warning_unit(u->id, "Failed to parse MAINPID= field in notification message: %s", e);
2531 log_debug_unit(u->id, "%s: got MAINPID=%s", u->id, e);
2533 service_set_main_pid(s, pid);
2534 unit_watch_pid(UNIT(s), pid);
2539 /* Interpret RELOADING= */
2540 if (strv_find(tags, "RELOADING=1")) {
2542 log_debug_unit(u->id, "%s: got RELOADING=1", u->id);
2543 s->notify_state = NOTIFY_RELOADING;
2545 if (s->state == SERVICE_RUNNING)
2546 service_enter_reload_by_notify(s);
2551 /* Interpret READY= */
2552 if (strv_find(tags, "READY=1")) {
2554 log_debug_unit(u->id, "%s: got READY=1", u->id);
2555 s->notify_state = NOTIFY_READY;
2557 /* Type=notify services inform us about completed
2558 * initialization with READY=1 */
2559 if (s->type == SERVICE_NOTIFY && s->state == SERVICE_START)
2560 service_enter_start_post(s);
2562 /* Sending READY=1 while we are reloading informs us
2563 * that the reloading is complete */
2564 if (s->state == SERVICE_RELOAD && s->control_pid == 0)
2565 service_enter_running(s, SERVICE_SUCCESS);
2570 /* Interpret STOPPING= */
2571 if (strv_find(tags, "STOPPING=1")) {
2573 log_debug_unit(u->id, "%s: got STOPPING=1", u->id);
2574 s->notify_state = NOTIFY_STOPPING;
2576 if (s->state == SERVICE_RUNNING)
2577 service_enter_stop_by_notify(s);
2582 /* Interpret STATUS= */
2583 e = strv_find_startswith(tags, "STATUS=");
2585 _cleanup_free_ char *t = NULL;
2588 if (!utf8_is_valid(e))
2589 log_warning_unit(u->id, "Status message in notification is not UTF-8 clean.");
2591 log_debug_unit(u->id, "%s: got STATUS=%s", u->id, e);
2599 if (!streq_ptr(s->status_text, t)) {
2601 free(s->status_text);
2609 /* Interpret ERRNO= */
2610 e = strv_find_startswith(tags, "ERRNO=");
2614 if (safe_atoi(e, &status_errno) < 0 || status_errno < 0)
2615 log_warning_unit(u->id, "Failed to parse ERRNO= field in notification message: %s", e);
2617 log_debug_unit(u->id, "%s: got ERRNO=%s", u->id, e);
2619 if (s->status_errno != status_errno) {
2620 s->status_errno = status_errno;
2626 /* Interpret WATCHDOG= */
2627 if (strv_find(tags, "WATCHDOG=1")) {
2628 log_debug_unit(u->id, "%s: got WATCHDOG=1", u->id);
2629 service_reset_watchdog(s);
2632 /* Notify clients about changed status or main pid */
2634 unit_add_to_dbus_queue(u);
2637 static int service_get_timeout(Unit *u, uint64_t *timeout) {
2638 Service *s = SERVICE(u);
2641 if (!s->timer_event_source)
2644 r = sd_event_source_get_time(s->timer_event_source, timeout);
2651 static void service_bus_name_owner_change(
2654 const char *old_owner,
2655 const char *new_owner) {
2657 Service *s = SERVICE(u);
2663 assert(streq(s->bus_name, name));
2664 assert(old_owner || new_owner);
2666 if (old_owner && new_owner)
2667 log_debug_unit(u->id, "%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
2669 log_debug_unit(u->id, "%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
2671 log_debug_unit(u->id, "%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
2673 s->bus_name_good = !!new_owner;
2675 if (s->type == SERVICE_DBUS) {
2677 /* service_enter_running() will figure out what to
2679 if (s->state == SERVICE_RUNNING)
2680 service_enter_running(s, SERVICE_SUCCESS);
2681 else if (s->state == SERVICE_START && new_owner)
2682 service_enter_start_post(s);
2684 } else if (new_owner &&
2686 (s->state == SERVICE_START ||
2687 s->state == SERVICE_START_POST ||
2688 s->state == SERVICE_RUNNING ||
2689 s->state == SERVICE_RELOAD)) {
2691 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
2694 /* Try to acquire PID from bus service */
2696 r = sd_bus_get_owner(u->manager->api_bus, name, SD_BUS_CREDS_PID, &creds);
2698 r = sd_bus_creds_get_pid(creds, &pid);
2700 log_debug_unit(u->id, "%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
2702 service_set_main_pid(s, pid);
2703 unit_watch_pid(UNIT(s), pid);
2708 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
2709 _cleanup_free_ char *peer = NULL;
2715 /* This is called by the socket code when instantiating a new
2716 * service for a stream socket and the socket needs to be
2719 if (UNIT(s)->load_state != UNIT_LOADED)
2722 if (s->socket_fd >= 0)
2725 if (s->state != SERVICE_DEAD)
2728 if (getpeername_pretty(fd, &peer) >= 0) {
2730 if (UNIT(s)->description) {
2731 _cleanup_free_ char *a;
2733 a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
2737 r = unit_set_description(UNIT(s), a);
2739 r = unit_set_description(UNIT(s), peer);
2747 unit_ref_set(&s->accept_socket, UNIT(sock));
2749 return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
2752 static void service_reset_failed(Unit *u) {
2753 Service *s = SERVICE(u);
2757 if (s->state == SERVICE_FAILED)
2758 service_set_state(s, SERVICE_DEAD);
2760 s->result = SERVICE_SUCCESS;
2761 s->reload_result = SERVICE_SUCCESS;
2763 RATELIMIT_RESET(s->start_limit);
2766 static int service_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2767 Service *s = SERVICE(u);
2769 return unit_kill_common(u, who, signo, s->main_pid, s->control_pid, error);
2772 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
2773 [SERVICE_DEAD] = "dead",
2774 [SERVICE_START_PRE] = "start-pre",
2775 [SERVICE_START] = "start",
2776 [SERVICE_START_POST] = "start-post",
2777 [SERVICE_RUNNING] = "running",
2778 [SERVICE_EXITED] = "exited",
2779 [SERVICE_RELOAD] = "reload",
2780 [SERVICE_STOP] = "stop",
2781 [SERVICE_STOP_SIGTERM] = "stop-sigterm",
2782 [SERVICE_STOP_SIGKILL] = "stop-sigkill",
2783 [SERVICE_STOP_POST] = "stop-post",
2784 [SERVICE_FINAL_SIGTERM] = "final-sigterm",
2785 [SERVICE_FINAL_SIGKILL] = "final-sigkill",
2786 [SERVICE_FAILED] = "failed",
2787 [SERVICE_AUTO_RESTART] = "auto-restart",
2790 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
2792 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
2793 [SERVICE_RESTART_NO] = "no",
2794 [SERVICE_RESTART_ON_SUCCESS] = "on-success",
2795 [SERVICE_RESTART_ON_FAILURE] = "on-failure",
2796 [SERVICE_RESTART_ON_ABNORMAL] = "on-abnormal",
2797 [SERVICE_RESTART_ON_WATCHDOG] = "on-watchdog",
2798 [SERVICE_RESTART_ON_ABORT] = "on-abort",
2799 [SERVICE_RESTART_ALWAYS] = "always",
2802 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
2804 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
2805 [SERVICE_SIMPLE] = "simple",
2806 [SERVICE_FORKING] = "forking",
2807 [SERVICE_ONESHOT] = "oneshot",
2808 [SERVICE_DBUS] = "dbus",
2809 [SERVICE_NOTIFY] = "notify",
2810 [SERVICE_IDLE] = "idle"
2813 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
2815 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
2816 [SERVICE_EXEC_START_PRE] = "ExecStartPre",
2817 [SERVICE_EXEC_START] = "ExecStart",
2818 [SERVICE_EXEC_START_POST] = "ExecStartPost",
2819 [SERVICE_EXEC_RELOAD] = "ExecReload",
2820 [SERVICE_EXEC_STOP] = "ExecStop",
2821 [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
2824 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
2826 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
2827 [NOTIFY_NONE] = "none",
2828 [NOTIFY_MAIN] = "main",
2829 [NOTIFY_ALL] = "all"
2832 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
2834 static const char* const notify_state_table[_NOTIFY_STATE_MAX] = {
2835 [NOTIFY_UNKNOWN] = "unknown",
2836 [NOTIFY_READY] = "ready",
2837 [NOTIFY_RELOADING] = "reloading",
2838 [NOTIFY_STOPPING] = "stopping",
2841 DEFINE_STRING_TABLE_LOOKUP(notify_state, NotifyState);
2843 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
2844 [SERVICE_SUCCESS] = "success",
2845 [SERVICE_FAILURE_RESOURCES] = "resources",
2846 [SERVICE_FAILURE_TIMEOUT] = "timeout",
2847 [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
2848 [SERVICE_FAILURE_SIGNAL] = "signal",
2849 [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
2850 [SERVICE_FAILURE_WATCHDOG] = "watchdog",
2851 [SERVICE_FAILURE_START_LIMIT] = "start-limit"
2854 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
2856 const UnitVTable service_vtable = {
2857 .object_size = sizeof(Service),
2858 .exec_context_offset = offsetof(Service, exec_context),
2859 .cgroup_context_offset = offsetof(Service, cgroup_context),
2860 .kill_context_offset = offsetof(Service, kill_context),
2861 .exec_runtime_offset = offsetof(Service, exec_runtime),
2867 .private_section = "Service",
2869 .init = service_init,
2870 .done = service_done,
2871 .load = service_load,
2873 .coldplug = service_coldplug,
2875 .dump = service_dump,
2877 .start = service_start,
2878 .stop = service_stop,
2879 .reload = service_reload,
2881 .can_reload = service_can_reload,
2883 .kill = service_kill,
2885 .serialize = service_serialize,
2886 .deserialize_item = service_deserialize_item,
2888 .active_state = service_active_state,
2889 .sub_state_to_string = service_sub_state_to_string,
2891 .check_gc = service_check_gc,
2892 .check_snapshot = service_check_snapshot,
2894 .sigchld_event = service_sigchld_event,
2896 .reset_failed = service_reset_failed,
2898 .notify_cgroup_empty = service_notify_cgroup_empty_event,
2899 .notify_message = service_notify_message,
2901 .bus_name_owner_change = service_bus_name_owner_change,
2903 .bus_interface = "org.freedesktop.systemd1.Service",
2904 .bus_vtable = bus_service_vtable,
2905 .bus_set_property = bus_service_set_property,
2906 .bus_commit_properties = bus_service_commit_properties,
2908 .get_timeout = service_get_timeout,
2909 .can_transient = true,
2911 .status_message_formats = {
2912 .starting_stopping = {
2913 [0] = "Starting %s...",
2914 [1] = "Stopping %s...",
2916 .finished_start_job = {
2917 [JOB_DONE] = "Started %s.",
2918 [JOB_FAILED] = "Failed to start %s.",
2919 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2920 [JOB_TIMEOUT] = "Timed out starting %s.",
2922 .finished_stop_job = {
2923 [JOB_DONE] = "Stopped %s.",
2924 [JOB_FAILED] = "Stopped (with error) %s.",
2925 [JOB_TIMEOUT] = "Timed out stopping %s.",