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"
48 #include "formats-util.h"
49 #include "process-util.h"
50 #include "signal-util.h"
52 static const UnitActiveState state_translation_table
[_SERVICE_STATE_MAX
] = {
53 [SERVICE_DEAD
] = UNIT_INACTIVE
,
54 [SERVICE_START_PRE
] = UNIT_ACTIVATING
,
55 [SERVICE_START
] = UNIT_ACTIVATING
,
56 [SERVICE_START_POST
] = UNIT_ACTIVATING
,
57 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
58 [SERVICE_EXITED
] = UNIT_ACTIVE
,
59 [SERVICE_RELOAD
] = UNIT_RELOADING
,
60 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
61 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
62 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
63 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
64 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
65 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
66 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
67 [SERVICE_FAILED
] = UNIT_FAILED
,
68 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
71 /* For Type=idle we never want to delay any other jobs, hence we
72 * consider idle jobs active as soon as we start working on them */
73 static const UnitActiveState state_translation_table_idle
[_SERVICE_STATE_MAX
] = {
74 [SERVICE_DEAD
] = UNIT_INACTIVE
,
75 [SERVICE_START_PRE
] = UNIT_ACTIVE
,
76 [SERVICE_START
] = UNIT_ACTIVE
,
77 [SERVICE_START_POST
] = UNIT_ACTIVE
,
78 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
79 [SERVICE_EXITED
] = UNIT_ACTIVE
,
80 [SERVICE_RELOAD
] = UNIT_RELOADING
,
81 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
82 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
83 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
84 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
85 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
86 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
87 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
88 [SERVICE_FAILED
] = UNIT_FAILED
,
89 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
92 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
);
93 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
94 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
);
96 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
);
97 static void service_enter_reload_by_notify(Service
*s
);
99 static void service_init(Unit
*u
) {
100 Service
*s
= SERVICE(u
);
103 assert(u
->load_state
== UNIT_STUB
);
105 s
->timeout_start_usec
= u
->manager
->default_timeout_start_usec
;
106 s
->timeout_stop_usec
= u
->manager
->default_timeout_stop_usec
;
107 s
->restart_usec
= u
->manager
->default_restart_usec
;
108 s
->type
= _SERVICE_TYPE_INVALID
;
110 s
->bus_endpoint_fd
= -1;
111 s
->guess_main_pid
= true;
113 RATELIMIT_INIT(s
->start_limit
, u
->manager
->default_start_limit_interval
, u
->manager
->default_start_limit_burst
);
115 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
118 static void service_unwatch_control_pid(Service
*s
) {
121 if (s
->control_pid
<= 0)
124 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
128 static void service_unwatch_main_pid(Service
*s
) {
131 if (s
->main_pid
<= 0)
134 unit_unwatch_pid(UNIT(s
), s
->main_pid
);
138 static void service_unwatch_pid_file(Service
*s
) {
139 if (!s
->pid_file_pathspec
)
142 log_unit_debug(UNIT(s
), "Stopping watch for PID file %s", s
->pid_file_pathspec
->path
);
143 path_spec_unwatch(s
->pid_file_pathspec
);
144 path_spec_done(s
->pid_file_pathspec
);
145 s
->pid_file_pathspec
= mfree(s
->pid_file_pathspec
);
148 static int service_set_main_pid(Service
*s
, pid_t pid
) {
159 if (s
->main_pid
== pid
&& s
->main_pid_known
)
162 if (s
->main_pid
!= pid
) {
163 service_unwatch_main_pid(s
);
164 exec_status_start(&s
->main_exec_status
, pid
);
168 s
->main_pid_known
= true;
170 if (get_parent_of_pid(pid
, &ppid
) >= 0 && ppid
!= getpid()) {
171 log_unit_warning(UNIT(s
), "Supervising process "PID_FMT
" which is not our child. We'll most likely not notice when it exits.", pid
);
172 s
->main_pid_alien
= true;
174 s
->main_pid_alien
= false;
179 static void service_close_socket_fd(Service
*s
) {
182 s
->socket_fd
= asynchronous_close(s
->socket_fd
);
185 static void service_connection_unref(Service
*s
) {
188 if (!UNIT_ISSET(s
->accept_socket
))
191 socket_connection_unref(SOCKET(UNIT_DEREF(s
->accept_socket
)));
192 unit_ref_unset(&s
->accept_socket
);
195 static void service_stop_watchdog(Service
*s
) {
198 s
->watchdog_event_source
= sd_event_source_unref(s
->watchdog_event_source
);
199 s
->watchdog_timestamp
= DUAL_TIMESTAMP_NULL
;
202 static void service_start_watchdog(Service
*s
) {
207 if (s
->watchdog_usec
<= 0)
210 if (s
->watchdog_event_source
) {
211 r
= sd_event_source_set_time(s
->watchdog_event_source
, s
->watchdog_timestamp
.monotonic
+ s
->watchdog_usec
);
213 log_unit_warning_errno(UNIT(s
), r
, "Failed to reset watchdog timer: %m");
217 r
= sd_event_source_set_enabled(s
->watchdog_event_source
, SD_EVENT_ONESHOT
);
219 r
= sd_event_add_time(
220 UNIT(s
)->manager
->event
,
221 &s
->watchdog_event_source
,
223 s
->watchdog_timestamp
.monotonic
+ s
->watchdog_usec
, 0,
224 service_dispatch_watchdog
, s
);
226 log_unit_warning_errno(UNIT(s
), r
, "Failed to add watchdog timer: %m");
230 (void) sd_event_source_set_description(s
->watchdog_event_source
, "service-watchdog");
232 /* Let's process everything else which might be a sign
233 * of living before we consider a service died. */
234 r
= sd_event_source_set_priority(s
->watchdog_event_source
, SD_EVENT_PRIORITY_IDLE
);
238 log_unit_warning_errno(UNIT(s
), r
, "Failed to install watchdog timer: %m");
241 static void service_reset_watchdog(Service
*s
) {
244 dual_timestamp_get(&s
->watchdog_timestamp
);
245 service_start_watchdog(s
);
248 static void service_fd_store_unlink(ServiceFDStore
*fs
) {
254 assert(fs
->service
->n_fd_store
> 0);
255 LIST_REMOVE(fd_store
, fs
->service
->fd_store
, fs
);
256 fs
->service
->n_fd_store
--;
259 if (fs
->event_source
) {
260 sd_event_source_set_enabled(fs
->event_source
, SD_EVENT_OFF
);
261 sd_event_source_unref(fs
->event_source
);
268 static void service_release_resources(Unit
*u
) {
269 Service
*s
= SERVICE(u
);
276 log_unit_debug(u
, "Releasing all resources.");
279 service_fd_store_unlink(s
->fd_store
);
281 assert(s
->n_fd_store
== 0);
284 static void service_done(Unit
*u
) {
285 Service
*s
= SERVICE(u
);
289 s
->pid_file
= mfree(s
->pid_file
);
290 s
->status_text
= mfree(s
->status_text
);
291 s
->reboot_arg
= mfree(s
->reboot_arg
);
293 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
294 exec_command_free_array(s
->exec_command
, _SERVICE_EXEC_COMMAND_MAX
);
295 s
->control_command
= NULL
;
296 s
->main_command
= NULL
;
298 exit_status_set_free(&s
->restart_prevent_status
);
299 exit_status_set_free(&s
->restart_force_status
);
300 exit_status_set_free(&s
->success_status
);
302 /* This will leak a process, but at least no memory or any of
304 service_unwatch_main_pid(s
);
305 service_unwatch_control_pid(s
);
306 service_unwatch_pid_file(s
);
309 unit_unwatch_bus_name(u
, s
->bus_name
);
310 s
->bus_name
= mfree(s
->bus_name
);
313 s
->bus_endpoint_fd
= safe_close(s
->bus_endpoint_fd
);
314 service_close_socket_fd(s
);
315 service_connection_unref(s
);
317 unit_ref_unset(&s
->accept_socket
);
319 service_stop_watchdog(s
);
321 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
323 service_release_resources(u
);
326 static int on_fd_store_io(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
327 ServiceFDStore
*fs
= userdata
;
332 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
333 service_fd_store_unlink(fs
);
337 static int service_add_fd_store(Service
*s
, int fd
) {
344 if (s
->n_fd_store
>= s
->n_fd_store_max
)
347 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
348 r
= same_fd(fs
->fd
, fd
);
352 /* Already included */
358 fs
= new0(ServiceFDStore
, 1);
365 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &fs
->event_source
, fd
, 0, on_fd_store_io
, fs
);
371 (void) sd_event_source_set_description(fs
->event_source
, "service-fd-store");
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
), r
, "Couldn't add fd to fd store: %m");
398 log_unit_debug(UNIT(s
), "Added fd to fd store.");
403 if (fdset_size(fds
) > 0)
404 log_unit_warning(UNIT(s
), "Tried to store more fds than FDStoreMax=%u allows, closing remaining.", s
->n_fd_store_max
);
409 static int service_arm_timer(Service
*s
, usec_t usec
) {
414 if (s
->timer_event_source
) {
415 r
= sd_event_source_set_time(s
->timer_event_source
, now(CLOCK_MONOTONIC
) + usec
);
419 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
422 r
= sd_event_add_time(
423 UNIT(s
)->manager
->event
,
424 &s
->timer_event_source
,
426 now(CLOCK_MONOTONIC
) + usec
, 0,
427 service_dispatch_timer
, s
);
431 (void) sd_event_source_set_description(s
->timer_event_source
, "service-timer");
436 static int service_verify(Service
*s
) {
439 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
442 if (!s
->exec_command
[SERVICE_EXEC_START
] && !s
->exec_command
[SERVICE_EXEC_STOP
]) {
443 log_unit_error(UNIT(s
), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
447 if (s
->type
!= SERVICE_ONESHOT
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
448 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
452 if (!s
->remain_after_exit
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
453 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
457 if (s
->type
!= SERVICE_ONESHOT
&& s
->exec_command
[SERVICE_EXEC_START
]->command_next
) {
458 log_unit_error(UNIT(s
), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
462 if (s
->type
== SERVICE_ONESHOT
&& s
->restart
!= SERVICE_RESTART_NO
) {
463 log_unit_error(UNIT(s
), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
467 if (s
->type
== SERVICE_ONESHOT
&& !exit_status_set_is_empty(&s
->restart_force_status
)) {
468 log_unit_error(UNIT(s
), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
472 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name
) {
473 log_unit_error(UNIT(s
), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
477 if (s
->bus_name
&& s
->type
!= SERVICE_DBUS
)
478 log_unit_warning(UNIT(s
), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
480 if (s
->exec_context
.pam_name
&& !(s
->kill_context
.kill_mode
== KILL_CONTROL_GROUP
|| s
->kill_context
.kill_mode
== KILL_MIXED
)) {
481 log_unit_error(UNIT(s
), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
488 static int service_add_default_dependencies(Service
*s
) {
493 /* Add a number of automatic dependencies useful for the
494 * majority of services. */
496 /* First, pull in base system */
497 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_BASIC_TARGET
, NULL
, true);
501 /* Second, activate normal shutdown */
502 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
505 static void service_fix_output(Service
*s
) {
508 /* If nothing has been explicitly configured, patch default
509 * output in. If input is socket/tty we avoid this however,
510 * since in that case we want output to default to the same
511 * place as we read input from. */
513 if (s
->exec_context
.std_error
== EXEC_OUTPUT_INHERIT
&&
514 s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
515 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
516 s
->exec_context
.std_error
= UNIT(s
)->manager
->default_std_error
;
518 if (s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
519 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
520 s
->exec_context
.std_output
= UNIT(s
)->manager
->default_std_output
;
523 static int service_add_extras(Service
*s
) {
528 if (s
->type
== _SERVICE_TYPE_INVALID
) {
529 /* Figure out a type automatically */
531 s
->type
= SERVICE_DBUS
;
532 else if (s
->exec_command
[SERVICE_EXEC_START
])
533 s
->type
= SERVICE_SIMPLE
;
535 s
->type
= SERVICE_ONESHOT
;
538 /* Oneshot services have disabled start timeout by default */
539 if (s
->type
== SERVICE_ONESHOT
&& !s
->start_timeout_defined
)
540 s
->timeout_start_usec
= 0;
542 service_fix_output(s
);
544 r
= unit_patch_contexts(UNIT(s
));
548 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
552 r
= unit_set_default_slice(UNIT(s
));
556 if (s
->type
== SERVICE_NOTIFY
&& s
->notify_access
== NOTIFY_NONE
)
557 s
->notify_access
= NOTIFY_MAIN
;
559 if (s
->watchdog_usec
> 0 && s
->notify_access
== NOTIFY_NONE
)
560 s
->notify_access
= NOTIFY_MAIN
;
565 n
= strjoina(s
->bus_name
, ".busname");
566 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, n
, NULL
, true);
570 r
= unit_watch_bus_name(UNIT(s
), s
->bus_name
);
572 return log_unit_error_errno(UNIT(s
), r
, "Two services allocated for the same bus name %s, refusing operation.", s
->bus_name
);
574 return log_unit_error_errno(UNIT(s
), r
, "Cannot watch bus name %s: %m", s
->bus_name
);
577 if (UNIT(s
)->default_dependencies
) {
578 r
= service_add_default_dependencies(s
);
586 static int service_load(Unit
*u
) {
587 Service
*s
= SERVICE(u
);
592 /* Load a .service file */
593 r
= unit_load_fragment(u
);
597 /* Still nothing found? Then let's give up */
598 if (u
->load_state
== UNIT_STUB
)
601 /* This is a new unit? Then let's add in some extras */
602 if (u
->load_state
== UNIT_LOADED
) {
604 /* We were able to load something, then let's add in
605 * the dropin directories. */
606 r
= unit_load_dropin(u
);
610 /* This is a new unit? Then let's add in some
612 r
= service_add_extras(s
);
617 return service_verify(s
);
620 static void service_dump(Unit
*u
, FILE *f
, const char *prefix
) {
621 ServiceExecCommand c
;
622 Service
*s
= SERVICE(u
);
627 prefix
= strempty(prefix
);
628 prefix2
= strjoina(prefix
, "\t");
631 "%sService State: %s\n"
633 "%sReload Result: %s\n"
634 "%sPermissionsStartOnly: %s\n"
635 "%sRootDirectoryStartOnly: %s\n"
636 "%sRemainAfterExit: %s\n"
637 "%sGuessMainPID: %s\n"
640 "%sNotifyAccess: %s\n"
641 "%sNotifyState: %s\n",
642 prefix
, service_state_to_string(s
->state
),
643 prefix
, service_result_to_string(s
->result
),
644 prefix
, service_result_to_string(s
->reload_result
),
645 prefix
, yes_no(s
->permissions_start_only
),
646 prefix
, yes_no(s
->root_directory_start_only
),
647 prefix
, yes_no(s
->remain_after_exit
),
648 prefix
, yes_no(s
->guess_main_pid
),
649 prefix
, service_type_to_string(s
->type
),
650 prefix
, service_restart_to_string(s
->restart
),
651 prefix
, notify_access_to_string(s
->notify_access
),
652 prefix
, notify_state_to_string(s
->notify_state
));
654 if (s
->control_pid
> 0)
656 "%sControl PID: "PID_FMT
"\n",
657 prefix
, s
->control_pid
);
661 "%sMain PID: "PID_FMT
"\n"
662 "%sMain PID Known: %s\n"
663 "%sMain PID Alien: %s\n",
665 prefix
, yes_no(s
->main_pid_known
),
666 prefix
, yes_no(s
->main_pid_alien
));
671 prefix
, s
->pid_file
);
676 "%sBus Name Good: %s\n",
678 prefix
, yes_no(s
->bus_name_good
));
680 kill_context_dump(&s
->kill_context
, f
, prefix
);
681 exec_context_dump(&s
->exec_context
, f
, prefix
);
683 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
685 if (!s
->exec_command
[c
])
688 fprintf(f
, "%s-> %s:\n",
689 prefix
, service_exec_command_to_string(c
));
691 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
695 fprintf(f
, "%sStatus Text: %s\n",
696 prefix
, s
->status_text
);
698 if (s
->n_fd_store_max
> 0)
700 "%sFile Descriptor Store Max: %u\n"
701 "%sFile Descriptor Store Current: %u\n",
702 prefix
, s
->n_fd_store_max
,
703 prefix
, s
->n_fd_store
);
706 static int service_load_pid_file(Service
*s
, bool may_warn
) {
707 _cleanup_free_
char *k
= NULL
;
716 r
= read_one_line_file(s
->pid_file
, &k
);
719 log_unit_info_errno(UNIT(s
), r
, "PID file %s not readable (yet?) after %s: %m", s
->pid_file
, service_state_to_string(s
->state
));
723 r
= parse_pid(k
, &pid
);
726 log_unit_info_errno(UNIT(s
), r
, "Failed to read PID from file %s: %m", s
->pid_file
);
730 if (!pid_is_alive(pid
)) {
732 log_unit_info(UNIT(s
), "PID "PID_FMT
" read from file %s does not exist or is a zombie.", pid
, s
->pid_file
);
736 if (s
->main_pid_known
) {
737 if (pid
== s
->main_pid
)
740 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
742 service_unwatch_main_pid(s
);
743 s
->main_pid_known
= false;
745 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
747 r
= service_set_main_pid(s
, pid
);
751 r
= unit_watch_pid(UNIT(s
), pid
);
753 /* FIXME: we need to do something here */
754 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
761 static int service_search_main_pid(Service
*s
) {
767 /* If we know it anyway, don't ever fallback to unreliable
769 if (s
->main_pid_known
)
772 if (!s
->guess_main_pid
)
775 assert(s
->main_pid
<= 0);
777 r
= unit_search_main_pid(UNIT(s
), &pid
);
781 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
782 r
= service_set_main_pid(s
, pid
);
786 r
= unit_watch_pid(UNIT(s
), pid
);
788 /* FIXME: we need to do something here */
789 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
796 static void service_set_state(Service
*s
, ServiceState state
) {
797 ServiceState old_state
;
798 const UnitActiveState
*table
;
802 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
804 old_state
= s
->state
;
807 service_unwatch_pid_file(s
);
810 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
812 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
813 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
814 SERVICE_AUTO_RESTART
))
815 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
818 SERVICE_START
, SERVICE_START_POST
,
819 SERVICE_RUNNING
, SERVICE_RELOAD
,
820 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
821 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
822 service_unwatch_main_pid(s
);
823 s
->main_command
= NULL
;
827 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
829 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
830 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
831 service_unwatch_control_pid(s
);
832 s
->control_command
= NULL
;
833 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
836 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
837 unit_unwatch_all_pids(UNIT(s
));
840 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
841 SERVICE_RUNNING
, SERVICE_RELOAD
,
842 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
843 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
844 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
)) {
845 service_close_socket_fd(s
);
846 service_connection_unref(s
);
849 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
850 service_stop_watchdog(s
);
852 /* For the inactive states unit_notify() will trim the cgroup,
853 * but for exit we have to do that ourselves... */
854 if (state
== SERVICE_EXITED
&& UNIT(s
)->manager
->n_reloading
<= 0)
855 unit_prune_cgroup(UNIT(s
));
857 /* For remain_after_exit services, let's see if we can "release" the
858 * hold on the console, since unit_notify() only does that in case of
860 if (state
== SERVICE_EXITED
&&
861 s
->remain_after_exit
&&
862 UNIT(s
)->manager
->n_on_console
> 0) {
866 ec
= unit_get_exec_context(UNIT(s
));
867 if (ec
&& exec_context_may_touch_console(ec
)) {
868 Manager
*m
= UNIT(s
)->manager
;
871 if (m
->n_on_console
== 0)
872 /* unset no_console_output flag, since the console is free */
873 m
->no_console_output
= false;
877 if (old_state
!= state
)
878 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
880 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
881 s
->reload_result
= SERVICE_SUCCESS
;
884 static int service_coldplug(Unit
*u
) {
885 Service
*s
= SERVICE(u
);
889 assert(s
->state
== SERVICE_DEAD
);
891 if (s
->deserialized_state
!= s
->state
) {
893 if (IN_SET(s
->deserialized_state
,
894 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
896 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
897 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
901 k
= IN_SET(s
->deserialized_state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
;
903 /* For the start/stop timeouts 0 means off */
905 r
= service_arm_timer(s
, k
);
911 if (s
->deserialized_state
== SERVICE_AUTO_RESTART
) {
913 /* The restart timeouts 0 means immediately */
914 r
= service_arm_timer(s
, s
->restart_usec
);
919 if (pid_is_unwaited(s
->main_pid
) &&
920 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
921 IN_SET(s
->deserialized_state
,
922 SERVICE_START
, SERVICE_START_POST
,
923 SERVICE_RUNNING
, SERVICE_RELOAD
,
924 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
925 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
926 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
931 if (pid_is_unwaited(s
->control_pid
) &&
932 IN_SET(s
->deserialized_state
,
933 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
935 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, 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
!= MANAGER_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
;
1174 if (s
->exec_context
.bus_endpoint
) {
1175 r
= bus_kernel_create_endpoint(UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
? "system" : "user",
1176 UNIT(s
)->id
, &bus_endpoint_path
);
1180 /* Pass the fd to the exec_params so that the child process can upload the policy.
1181 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1182 * as the service is running. */
1183 exec_params
.bus_endpoint_fd
= s
->bus_endpoint_fd
= r
;
1186 exec_params
.argv
= argv
;
1187 exec_params
.fds
= fds
;
1188 exec_params
.n_fds
= n_fds
;
1189 exec_params
.environment
= final_env
;
1190 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1191 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1192 exec_params
.cgroup_path
= path
;
1193 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1194 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1195 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1196 exec_params
.bus_endpoint_path
= bus_endpoint_path
;
1197 if (s
->type
== SERVICE_IDLE
)
1198 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1200 r
= exec_spawn(UNIT(s
),
1209 r
= unit_watch_pid(UNIT(s
), pid
);
1211 /* FIXME: we need to do something here */
1220 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1225 static int main_pid_good(Service
*s
) {
1228 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1231 /* If we know the pid file, then let's just check if it is
1233 if (s
->main_pid_known
) {
1235 /* If it's an alien child let's check if it is still
1237 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1238 return pid_is_alive(s
->main_pid
);
1240 /* .. otherwise assume we'll get a SIGCHLD for it,
1241 * which we really should wait for to collect exit
1242 * status and code */
1243 return s
->main_pid
> 0;
1246 /* We don't know the pid */
1250 _pure_
static int control_pid_good(Service
*s
) {
1253 return s
->control_pid
> 0;
1256 static int cgroup_good(Service
*s
) {
1261 if (!UNIT(s
)->cgroup_path
)
1264 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1271 static bool service_shall_restart(Service
*s
) {
1274 /* Don't restart after manual stops */
1275 if (s
->forbid_restart
)
1278 /* Never restart if this is configured as special exception */
1279 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1282 /* Restart if the exit code/status are configured as restart triggers */
1283 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1286 switch (s
->restart
) {
1288 case SERVICE_RESTART_NO
:
1291 case SERVICE_RESTART_ALWAYS
:
1294 case SERVICE_RESTART_ON_SUCCESS
:
1295 return s
->result
== SERVICE_SUCCESS
;
1297 case SERVICE_RESTART_ON_FAILURE
:
1298 return s
->result
!= SERVICE_SUCCESS
;
1300 case SERVICE_RESTART_ON_ABNORMAL
:
1301 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1303 case SERVICE_RESTART_ON_WATCHDOG
:
1304 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1306 case SERVICE_RESTART_ON_ABORT
:
1307 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1310 assert_not_reached("unknown restart setting");
1314 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1318 if (f
!= SERVICE_SUCCESS
)
1321 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1323 if (s
->result
!= SERVICE_SUCCESS
) {
1324 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1325 failure_action(UNIT(s
)->manager
, s
->failure_action
, s
->reboot_arg
);
1328 if (allow_restart
&& service_shall_restart(s
)) {
1330 r
= service_arm_timer(s
, s
->restart_usec
);
1334 service_set_state(s
, SERVICE_AUTO_RESTART
);
1337 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1338 s
->forbid_restart
= false;
1340 /* We want fresh tmpdirs in case service is started again immediately */
1341 exec_runtime_destroy(s
->exec_runtime
);
1342 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1344 /* Also, remove the runtime directory in */
1345 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1347 /* Try to delete the pid file. At this point it will be
1348 * out-of-date, and some software might be confused by it, so
1349 * let's remove it. */
1351 unlink_noerrno(s
->pid_file
);
1356 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1357 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1360 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1364 if (f
!= SERVICE_SUCCESS
)
1367 service_unwatch_control_pid(s
);
1368 unit_watch_all_pids(UNIT(s
));
1370 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1371 if (s
->control_command
) {
1372 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1374 r
= service_spawn(s
,
1376 s
->timeout_stop_usec
,
1378 !s
->permissions_start_only
,
1379 !s
->root_directory_start_only
,
1386 service_set_state(s
, SERVICE_STOP_POST
);
1388 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1393 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1394 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1397 static int state_to_kill_operation(ServiceState state
) {
1400 case SERVICE_STOP_SIGABRT
:
1403 case SERVICE_STOP_SIGTERM
:
1404 case SERVICE_FINAL_SIGTERM
:
1405 return KILL_TERMINATE
;
1407 case SERVICE_STOP_SIGKILL
:
1408 case SERVICE_FINAL_SIGKILL
:
1412 return _KILL_OPERATION_INVALID
;
1416 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1421 if (f
!= SERVICE_SUCCESS
)
1424 unit_watch_all_pids(UNIT(s
));
1426 r
= unit_kill_context(
1429 state_to_kill_operation(state
),
1438 if (s
->timeout_stop_usec
> 0) {
1439 r
= service_arm_timer(s
, s
->timeout_stop_usec
);
1444 service_set_state(s
, state
);
1445 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1446 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1447 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1448 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1449 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1450 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1452 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1457 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1459 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1460 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1462 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1465 static void service_enter_stop_by_notify(Service
*s
) {
1468 unit_watch_all_pids(UNIT(s
));
1470 if (s
->timeout_stop_usec
> 0)
1471 service_arm_timer(s
, s
->timeout_stop_usec
);
1473 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1474 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1477 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1482 if (f
!= SERVICE_SUCCESS
)
1485 service_unwatch_control_pid(s
);
1486 unit_watch_all_pids(UNIT(s
));
1488 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1489 if (s
->control_command
) {
1490 s
->control_command_id
= SERVICE_EXEC_STOP
;
1492 r
= service_spawn(s
,
1494 s
->timeout_stop_usec
,
1496 !s
->permissions_start_only
,
1497 !s
->root_directory_start_only
,
1504 service_set_state(s
, SERVICE_STOP
);
1506 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1511 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1512 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1515 static bool service_good(Service
*s
) {
1519 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1522 main_pid_ok
= main_pid_good(s
);
1523 if (main_pid_ok
> 0) /* It's alive */
1525 if (main_pid_ok
== 0) /* It's dead */
1528 /* OK, we don't know anything about the main PID, maybe
1529 * because there is none. Let's check the control group
1532 return cgroup_good(s
) != 0;
1535 static void service_enter_running(Service
*s
, ServiceResult f
) {
1538 if (f
!= SERVICE_SUCCESS
)
1541 if (service_good(s
)) {
1543 /* If there are any queued up sd_notify()
1544 * notifications, process them now */
1545 if (s
->notify_state
== NOTIFY_RELOADING
)
1546 service_enter_reload_by_notify(s
);
1547 else if (s
->notify_state
== NOTIFY_STOPPING
)
1548 service_enter_stop_by_notify(s
);
1550 service_set_state(s
, SERVICE_RUNNING
);
1552 } else if (s
->remain_after_exit
)
1553 service_set_state(s
, SERVICE_EXITED
);
1555 service_enter_stop(s
, SERVICE_SUCCESS
);
1558 static void service_enter_start_post(Service
*s
) {
1562 service_unwatch_control_pid(s
);
1563 service_reset_watchdog(s
);
1565 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1566 if (s
->control_command
) {
1567 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1569 r
= service_spawn(s
,
1571 s
->timeout_start_usec
,
1573 !s
->permissions_start_only
,
1574 !s
->root_directory_start_only
,
1581 service_set_state(s
, SERVICE_START_POST
);
1583 service_enter_running(s
, SERVICE_SUCCESS
);
1588 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1589 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1592 static void service_kill_control_processes(Service
*s
) {
1595 if (!UNIT(s
)->cgroup_path
)
1598 p
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1599 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, p
, SIGKILL
, true, true, true, NULL
);
1602 static void service_enter_start(Service
*s
) {
1609 service_unwatch_control_pid(s
);
1610 service_unwatch_main_pid(s
);
1612 /* We want to ensure that nobody leaks processes from
1613 * START_PRE here, so let's go on a killing spree, People
1614 * should not spawn long running processes from START_PRE. */
1615 service_kill_control_processes(s
);
1617 if (s
->type
== SERVICE_FORKING
) {
1618 s
->control_command_id
= SERVICE_EXEC_START
;
1619 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1621 s
->main_command
= NULL
;
1623 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1624 s
->control_command
= NULL
;
1626 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1630 assert(s
->type
== SERVICE_ONESHOT
);
1631 service_enter_start_post(s
);
1635 r
= service_spawn(s
,
1637 IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_NOTIFY
, SERVICE_ONESHOT
) ? s
->timeout_start_usec
: 0,
1647 if (s
->type
== SERVICE_SIMPLE
|| s
->type
== SERVICE_IDLE
) {
1648 /* For simple services we immediately start
1649 * the START_POST binaries. */
1651 service_set_main_pid(s
, pid
);
1652 service_enter_start_post(s
);
1654 } else if (s
->type
== SERVICE_FORKING
) {
1656 /* For forking services we wait until the start
1657 * process exited. */
1659 s
->control_pid
= pid
;
1660 service_set_state(s
, SERVICE_START
);
1662 } else if (s
->type
== SERVICE_ONESHOT
||
1663 s
->type
== SERVICE_DBUS
||
1664 s
->type
== SERVICE_NOTIFY
) {
1666 /* For oneshot services we wait until the start
1667 * process exited, too, but it is our main process. */
1669 /* For D-Bus services we know the main pid right away,
1670 * but wait for the bus name to appear on the
1671 * bus. Notify services are similar. */
1673 service_set_main_pid(s
, pid
);
1674 service_set_state(s
, SERVICE_START
);
1676 assert_not_reached("Unknown service type");
1681 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1682 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1685 static void service_enter_start_pre(Service
*s
) {
1690 service_unwatch_control_pid(s
);
1692 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1693 if (s
->control_command
) {
1694 /* Before we start anything, let's clear up what might
1695 * be left from previous runs. */
1696 service_kill_control_processes(s
);
1698 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1700 r
= service_spawn(s
,
1702 s
->timeout_start_usec
,
1704 !s
->permissions_start_only
,
1705 !s
->root_directory_start_only
,
1712 service_set_state(s
, SERVICE_START_PRE
);
1714 service_enter_start(s
);
1719 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1720 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1723 static void service_enter_restart(Service
*s
) {
1724 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1729 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1730 /* Don't restart things if we are going down anyway */
1731 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
1733 r
= service_arm_timer(s
, s
->restart_usec
);
1740 /* Any units that are bound to this service must also be
1741 * restarted. We use JOB_RESTART (instead of the more obvious
1742 * JOB_START) here so that those dependency jobs will be added
1744 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, false, &error
, NULL
);
1748 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1749 * it will be canceled as part of the service_stop() call that
1750 * is executed as part of JOB_RESTART. */
1752 log_unit_debug(UNIT(s
), "Scheduled restart job.");
1756 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
1757 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1760 static void service_enter_reload_by_notify(Service
*s
) {
1763 if (s
->timeout_start_usec
> 0)
1764 service_arm_timer(s
, s
->timeout_start_usec
);
1766 service_set_state(s
, SERVICE_RELOAD
);
1769 static void service_enter_reload(Service
*s
) {
1774 service_unwatch_control_pid(s
);
1776 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
1777 if (s
->control_command
) {
1778 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
1780 r
= service_spawn(s
,
1782 s
->timeout_start_usec
,
1784 !s
->permissions_start_only
,
1785 !s
->root_directory_start_only
,
1792 service_set_state(s
, SERVICE_RELOAD
);
1794 service_enter_running(s
, SERVICE_SUCCESS
);
1799 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
1800 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1801 service_enter_running(s
, SERVICE_SUCCESS
);
1804 static void service_run_next_control(Service
*s
) {
1808 assert(s
->control_command
);
1809 assert(s
->control_command
->command_next
);
1811 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
1813 s
->control_command
= s
->control_command
->command_next
;
1814 service_unwatch_control_pid(s
);
1816 r
= service_spawn(s
,
1818 IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
,
1820 !s
->permissions_start_only
,
1821 !s
->root_directory_start_only
,
1822 s
->control_command_id
== SERVICE_EXEC_START_PRE
||
1823 s
->control_command_id
== SERVICE_EXEC_STOP_POST
,
1832 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
1834 if (s
->state
== SERVICE_START_PRE
)
1835 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1836 else if (s
->state
== SERVICE_STOP
)
1837 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1838 else if (s
->state
== SERVICE_STOP_POST
)
1839 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1840 else if (s
->state
== SERVICE_RELOAD
) {
1841 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1842 service_enter_running(s
, SERVICE_SUCCESS
);
1844 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1847 static void service_run_next_main(Service
*s
) {
1852 assert(s
->main_command
);
1853 assert(s
->main_command
->command_next
);
1854 assert(s
->type
== SERVICE_ONESHOT
);
1856 s
->main_command
= s
->main_command
->command_next
;
1857 service_unwatch_main_pid(s
);
1859 r
= service_spawn(s
,
1861 s
->timeout_start_usec
,
1871 service_set_main_pid(s
, pid
);
1876 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
1877 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1880 static int service_start_limit_test(Service
*s
) {
1883 if (ratelimit_test(&s
->start_limit
))
1886 log_unit_warning(UNIT(s
), "Start request repeated too quickly.");
1888 return failure_action(UNIT(s
)->manager
, s
->start_limit_action
, s
->reboot_arg
);
1891 static int service_start(Unit
*u
) {
1892 Service
*s
= SERVICE(u
);
1897 /* We cannot fulfill this request right now, try again later
1899 if (IN_SET(s
->state
,
1900 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1901 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
1904 /* Already on it! */
1905 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
1908 /* A service that will be restarted must be stopped first to
1909 * trigger BindsTo and/or OnFailure dependencies. If a user
1910 * does not want to wait for the holdoff time to elapse, the
1911 * service should be manually restarted, not started. We
1912 * simply return EAGAIN here, so that any start jobs stay
1913 * queued, and assume that the auto restart timer will
1914 * eventually trigger the restart. */
1915 if (s
->state
== SERVICE_AUTO_RESTART
)
1918 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
1920 /* Make sure we don't enter a busy loop of some kind. */
1921 r
= service_start_limit_test(s
);
1923 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT
, false);
1927 s
->result
= SERVICE_SUCCESS
;
1928 s
->reload_result
= SERVICE_SUCCESS
;
1929 s
->main_pid_known
= false;
1930 s
->main_pid_alien
= false;
1931 s
->forbid_restart
= false;
1932 s
->reset_cpu_usage
= true;
1934 s
->status_text
= mfree(s
->status_text
);
1935 s
->status_errno
= 0;
1937 s
->notify_state
= NOTIFY_UNKNOWN
;
1939 service_enter_start_pre(s
);
1943 static int service_stop(Unit
*u
) {
1944 Service
*s
= SERVICE(u
);
1948 /* Don't create restart jobs from manual stops. */
1949 s
->forbid_restart
= true;
1952 if (IN_SET(s
->state
,
1953 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1954 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
1957 /* A restart will be scheduled or is in progress. */
1958 if (s
->state
== SERVICE_AUTO_RESTART
) {
1959 service_set_state(s
, SERVICE_DEAD
);
1963 /* If there's already something running we go directly into
1965 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
1966 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1970 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
1972 service_enter_stop(s
, SERVICE_SUCCESS
);
1976 static int service_reload(Unit
*u
) {
1977 Service
*s
= SERVICE(u
);
1981 assert(s
->state
== SERVICE_RUNNING
|| s
->state
== SERVICE_EXITED
);
1983 service_enter_reload(s
);
1987 _pure_
static bool service_can_reload(Unit
*u
) {
1988 Service
*s
= SERVICE(u
);
1992 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
1995 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
1996 Service
*s
= SERVICE(u
);
2003 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2004 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2005 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2007 if (s
->control_pid
> 0)
2008 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2010 if (s
->main_pid_known
&& s
->main_pid
> 0)
2011 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2013 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2014 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2016 if (s
->status_text
) {
2017 _cleanup_free_
char *c
= NULL
;
2019 c
= cescape(s
->status_text
);
2020 unit_serialize_item(u
, f
, "status-text", strempty(c
));
2023 /* FIXME: There's a minor uncleanliness here: if there are
2024 * multiple commands attached here, we will start from the
2025 * first one again */
2026 if (s
->control_command_id
>= 0)
2027 unit_serialize_item(u
, f
, "control-command", service_exec_command_to_string(s
->control_command_id
));
2029 if (s
->socket_fd
>= 0) {
2032 copy
= fdset_put_dup(fds
, s
->socket_fd
);
2036 unit_serialize_item_format(u
, f
, "socket-fd", "%i", copy
);
2039 if (s
->bus_endpoint_fd
>= 0) {
2042 copy
= fdset_put_dup(fds
, s
->bus_endpoint_fd
);
2046 unit_serialize_item_format(u
, f
, "endpoint-fd", "%i", copy
);
2049 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2052 copy
= fdset_put_dup(fds
, fs
->fd
);
2056 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i", copy
);
2059 if (s
->main_exec_status
.pid
> 0) {
2060 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2061 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2062 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2064 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2065 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2066 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2070 if (dual_timestamp_is_set(&s
->watchdog_timestamp
))
2071 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2073 if (s
->forbid_restart
)
2074 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2079 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2080 Service
*s
= SERVICE(u
);
2088 if (streq(key
, "state")) {
2091 state
= service_state_from_string(value
);
2093 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2095 s
->deserialized_state
= state
;
2096 } else if (streq(key
, "result")) {
2099 f
= service_result_from_string(value
);
2101 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2102 else if (f
!= SERVICE_SUCCESS
)
2105 } else if (streq(key
, "reload-result")) {
2108 f
= service_result_from_string(value
);
2110 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2111 else if (f
!= SERVICE_SUCCESS
)
2112 s
->reload_result
= f
;
2114 } else if (streq(key
, "control-pid")) {
2117 if (parse_pid(value
, &pid
) < 0)
2118 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2120 s
->control_pid
= pid
;
2121 } else if (streq(key
, "main-pid")) {
2124 if (parse_pid(value
, &pid
) < 0)
2125 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2127 service_set_main_pid(s
, pid
);
2128 unit_watch_pid(UNIT(s
), pid
);
2130 } else if (streq(key
, "main-pid-known")) {
2133 b
= parse_boolean(value
);
2135 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2137 s
->main_pid_known
= b
;
2138 } else if (streq(key
, "bus-name-good")) {
2141 b
= parse_boolean(value
);
2143 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2145 s
->bus_name_good
= b
;
2146 } else if (streq(key
, "status-text")) {
2149 r
= cunescape(value
, 0, &t
);
2151 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2153 free(s
->status_text
);
2157 } else if (streq(key
, "control-command")) {
2158 ServiceExecCommand id
;
2160 id
= service_exec_command_from_string(value
);
2162 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2164 s
->control_command_id
= id
;
2165 s
->control_command
= s
->exec_command
[id
];
2167 } else if (streq(key
, "socket-fd")) {
2170 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2171 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2173 asynchronous_close(s
->socket_fd
);
2174 s
->socket_fd
= fdset_remove(fds
, fd
);
2176 } else if (streq(key
, "endpoint-fd")) {
2179 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2180 log_unit_debug(u
, "Failed to parse endpoint-fd value: %s", value
);
2182 safe_close(s
->bus_endpoint_fd
);
2183 s
->bus_endpoint_fd
= fdset_remove(fds
, fd
);
2185 } else if (streq(key
, "fd-store-fd")) {
2188 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2189 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2191 r
= service_add_fd_store(s
, fd
);
2193 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2195 fdset_remove(fds
, fd
);
2198 } else if (streq(key
, "main-exec-status-pid")) {
2201 if (parse_pid(value
, &pid
) < 0)
2202 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2204 s
->main_exec_status
.pid
= pid
;
2205 } else if (streq(key
, "main-exec-status-code")) {
2208 if (safe_atoi(value
, &i
) < 0)
2209 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2211 s
->main_exec_status
.code
= i
;
2212 } else if (streq(key
, "main-exec-status-status")) {
2215 if (safe_atoi(value
, &i
) < 0)
2216 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2218 s
->main_exec_status
.status
= i
;
2219 } else if (streq(key
, "main-exec-status-start"))
2220 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2221 else if (streq(key
, "main-exec-status-exit"))
2222 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2223 else if (streq(key
, "watchdog-timestamp"))
2224 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2225 else if (streq(key
, "forbid-restart")) {
2228 b
= parse_boolean(value
);
2230 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2232 s
->forbid_restart
= b
;
2234 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2239 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2240 const UnitActiveState
*table
;
2244 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2246 return table
[SERVICE(u
)->state
];
2249 static const char *service_sub_state_to_string(Unit
*u
) {
2252 return service_state_to_string(SERVICE(u
)->state
);
2255 static bool service_check_gc(Unit
*u
) {
2256 Service
*s
= SERVICE(u
);
2260 /* Never clean up services that still have a process around,
2261 * even if the service is formally dead. */
2262 if (cgroup_good(s
) > 0 ||
2263 main_pid_good(s
) > 0 ||
2264 control_pid_good(s
) > 0)
2270 _pure_
static bool service_check_snapshot(Unit
*u
) {
2271 Service
*s
= SERVICE(u
);
2275 return s
->socket_fd
< 0;
2278 static int service_retry_pid_file(Service
*s
) {
2281 assert(s
->pid_file
);
2282 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2284 r
= service_load_pid_file(s
, false);
2288 service_unwatch_pid_file(s
);
2290 service_enter_running(s
, SERVICE_SUCCESS
);
2294 static int service_watch_pid_file(Service
*s
) {
2297 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2299 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2303 /* the pidfile might have appeared just before we set the watch */
2304 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2305 service_retry_pid_file(s
);
2309 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2310 service_unwatch_pid_file(s
);
2314 static int service_demand_pid_file(Service
*s
) {
2317 assert(s
->pid_file
);
2318 assert(!s
->pid_file_pathspec
);
2320 ps
= new0(PathSpec
, 1);
2325 ps
->path
= strdup(s
->pid_file
);
2331 path_kill_slashes(ps
->path
);
2333 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2334 * keep their PID file open all the time. */
2335 ps
->type
= PATH_MODIFIED
;
2336 ps
->inotify_fd
= -1;
2338 s
->pid_file_pathspec
= ps
;
2340 return service_watch_pid_file(s
);
2343 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2344 PathSpec
*p
= userdata
;
2349 s
= SERVICE(p
->unit
);
2353 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2354 assert(s
->pid_file_pathspec
);
2355 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2357 log_unit_debug(UNIT(s
), "inotify event");
2359 if (path_spec_fd_event(p
, events
) < 0)
2362 if (service_retry_pid_file(s
) == 0)
2365 if (service_watch_pid_file(s
) < 0)
2371 service_unwatch_pid_file(s
);
2372 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2376 static void service_notify_cgroup_empty_event(Unit
*u
) {
2377 Service
*s
= SERVICE(u
);
2381 log_unit_debug(u
, "cgroup is empty");
2385 /* Waiting for SIGCHLD is usually more interesting,
2386 * because it includes return codes/signals. Which is
2387 * why we ignore the cgroup events for most cases,
2388 * except when we don't know pid which to expect the
2392 case SERVICE_START_POST
:
2393 /* If we were hoping for the daemon to write its PID file,
2394 * we can give up now. */
2395 if (s
->pid_file_pathspec
) {
2396 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2398 service_unwatch_pid_file(s
);
2399 if (s
->state
== SERVICE_START
)
2400 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2402 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2406 case SERVICE_RUNNING
:
2407 /* service_enter_running() will figure out what to do */
2408 service_enter_running(s
, SERVICE_SUCCESS
);
2411 case SERVICE_STOP_SIGABRT
:
2412 case SERVICE_STOP_SIGTERM
:
2413 case SERVICE_STOP_SIGKILL
:
2415 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2416 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2420 case SERVICE_STOP_POST
:
2421 case SERVICE_FINAL_SIGTERM
:
2422 case SERVICE_FINAL_SIGKILL
:
2423 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2424 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2433 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2434 Service
*s
= SERVICE(u
);
2440 if (UNIT(s
)->fragment_path
? is_clean_exit(code
, status
, &s
->success_status
) :
2441 is_clean_exit_lsb(code
, status
, &s
->success_status
))
2442 f
= SERVICE_SUCCESS
;
2443 else if (code
== CLD_EXITED
)
2444 f
= SERVICE_FAILURE_EXIT_CODE
;
2445 else if (code
== CLD_KILLED
)
2446 f
= SERVICE_FAILURE_SIGNAL
;
2447 else if (code
== CLD_DUMPED
)
2448 f
= SERVICE_FAILURE_CORE_DUMP
;
2450 assert_not_reached("Unknown code");
2452 if (s
->main_pid
== pid
) {
2453 /* Forking services may occasionally move to a new PID.
2454 * As long as they update the PID file before exiting the old
2455 * PID, they're fine. */
2456 if (service_load_pid_file(s
, false) == 0)
2460 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2462 if (s
->main_command
) {
2463 /* If this is not a forking service than the
2464 * main process got started and hence we copy
2465 * the exit status so that it is recorded both
2466 * as main and as control process exit
2469 s
->main_command
->exec_status
= s
->main_exec_status
;
2471 if (s
->main_command
->ignore
)
2472 f
= SERVICE_SUCCESS
;
2473 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
2475 /* If this is a forked process, then we should
2476 * ignore the return value if this was
2477 * configured for the starter process */
2479 if (s
->exec_command
[SERVICE_EXEC_START
]->ignore
)
2480 f
= SERVICE_SUCCESS
;
2483 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
,
2485 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
2486 sigchld_code_to_string(code
), status
,
2487 strna(code
== CLD_EXITED
2488 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
2489 : signal_to_string(status
))),
2490 "EXIT_CODE=%s", sigchld_code_to_string(code
),
2491 "EXIT_STATUS=%i", status
,
2494 if (f
!= SERVICE_SUCCESS
)
2497 if (s
->main_command
&&
2498 s
->main_command
->command_next
&&
2499 f
== SERVICE_SUCCESS
) {
2501 /* There is another command to *
2502 * execute, so let's do that. */
2504 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
2505 service_run_next_main(s
);
2509 /* The service exited, so the service is officially
2511 s
->main_command
= NULL
;
2515 case SERVICE_START_POST
:
2516 case SERVICE_RELOAD
:
2518 /* Need to wait until the operation is
2523 if (s
->type
== SERVICE_ONESHOT
) {
2524 /* This was our main goal, so let's go on */
2525 if (f
== SERVICE_SUCCESS
)
2526 service_enter_start_post(s
);
2528 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2534 case SERVICE_RUNNING
:
2535 service_enter_running(s
, f
);
2538 case SERVICE_STOP_SIGABRT
:
2539 case SERVICE_STOP_SIGTERM
:
2540 case SERVICE_STOP_SIGKILL
:
2542 if (!control_pid_good(s
))
2543 service_enter_stop_post(s
, f
);
2545 /* If there is still a control process, wait for that first */
2548 case SERVICE_STOP_POST
:
2549 case SERVICE_FINAL_SIGTERM
:
2550 case SERVICE_FINAL_SIGKILL
:
2552 if (!control_pid_good(s
))
2553 service_enter_dead(s
, f
, true);
2557 assert_not_reached("Uh, main process died at wrong time.");
2561 } else if (s
->control_pid
== pid
) {
2564 if (s
->control_command
) {
2565 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2567 if (s
->control_command
->ignore
)
2568 f
= SERVICE_SUCCESS
;
2571 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2572 "Control process exited, code=%s status=%i",
2573 sigchld_code_to_string(code
), status
);
2575 if (f
!= SERVICE_SUCCESS
)
2578 /* Immediately get rid of the cgroup, so that the
2579 * kernel doesn't delay the cgroup empty messages for
2580 * the service cgroup any longer than necessary */
2581 service_kill_control_processes(s
);
2583 if (s
->control_command
&&
2584 s
->control_command
->command_next
&&
2585 f
== SERVICE_SUCCESS
) {
2587 /* There is another command to *
2588 * execute, so let's do that. */
2590 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
2591 service_run_next_control(s
);
2594 /* No further commands for this step, so let's
2595 * figure out what to do next */
2597 s
->control_command
= NULL
;
2598 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
2600 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
2604 case SERVICE_START_PRE
:
2605 if (f
== SERVICE_SUCCESS
)
2606 service_enter_start(s
);
2608 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2612 if (s
->type
!= SERVICE_FORKING
)
2613 /* Maybe spurious event due to a reload that changed the type? */
2616 if (f
!= SERVICE_SUCCESS
) {
2617 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2622 bool has_start_post
;
2625 /* Let's try to load the pid file here if we can.
2626 * The PID file might actually be created by a START_POST
2627 * script. In that case don't worry if the loading fails. */
2629 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
2630 r
= service_load_pid_file(s
, !has_start_post
);
2631 if (!has_start_post
&& r
< 0) {
2632 r
= service_demand_pid_file(s
);
2633 if (r
< 0 || !cgroup_good(s
))
2634 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2638 (void) service_search_main_pid(s
);
2640 service_enter_start_post(s
);
2643 case SERVICE_START_POST
:
2644 if (f
!= SERVICE_SUCCESS
) {
2645 service_enter_stop(s
, f
);
2652 r
= service_load_pid_file(s
, true);
2654 r
= service_demand_pid_file(s
);
2655 if (r
< 0 || !cgroup_good(s
))
2656 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2660 (void) service_search_main_pid(s
);
2662 service_enter_running(s
, SERVICE_SUCCESS
);
2665 case SERVICE_RELOAD
:
2666 if (f
== SERVICE_SUCCESS
) {
2667 service_load_pid_file(s
, true);
2668 (void) service_search_main_pid(s
);
2671 s
->reload_result
= f
;
2672 service_enter_running(s
, SERVICE_SUCCESS
);
2676 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
2679 case SERVICE_STOP_SIGABRT
:
2680 case SERVICE_STOP_SIGTERM
:
2681 case SERVICE_STOP_SIGKILL
:
2682 if (main_pid_good(s
) <= 0)
2683 service_enter_stop_post(s
, f
);
2685 /* If there is still a service
2686 * process around, wait until
2687 * that one quit, too */
2690 case SERVICE_STOP_POST
:
2691 case SERVICE_FINAL_SIGTERM
:
2692 case SERVICE_FINAL_SIGKILL
:
2693 if (main_pid_good(s
) <= 0)
2694 service_enter_dead(s
, f
, true);
2698 assert_not_reached("Uh, control process died at wrong time.");
2703 /* Notify clients about changed exit status */
2704 unit_add_to_dbus_queue(u
);
2706 /* We got one SIGCHLD for the service, let's watch all
2707 * processes that are now running of the service, and watch
2708 * that. Among the PIDs we then watch will be children
2709 * reassigned to us, which hopefully allows us to identify
2710 * when all children are gone */
2711 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
2712 unit_watch_all_pids(u
);
2714 /* If the PID set is empty now, then let's finish this off */
2715 if (set_isempty(u
->pids
))
2716 service_notify_cgroup_empty_event(u
);
2719 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2720 Service
*s
= SERVICE(userdata
);
2723 assert(source
== s
->timer_event_source
);
2727 case SERVICE_START_PRE
:
2729 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
2730 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2733 case SERVICE_START_POST
:
2734 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
2735 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
2738 case SERVICE_RELOAD
:
2739 log_unit_warning(UNIT(s
), "Reload operation timed out. Stopping.");
2740 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
2741 service_enter_running(s
, SERVICE_SUCCESS
);
2745 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2746 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2749 case SERVICE_STOP_SIGABRT
:
2750 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
2751 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2754 case SERVICE_STOP_SIGTERM
:
2755 if (s
->kill_context
.send_sigkill
) {
2756 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
2757 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2759 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
2760 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2765 case SERVICE_STOP_SIGKILL
:
2766 /* Uh, we sent a SIGKILL and it is still not gone?
2767 * Must be something we cannot kill, so let's just be
2768 * weirded out and continue */
2770 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2771 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2774 case SERVICE_STOP_POST
:
2775 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
2776 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2779 case SERVICE_FINAL_SIGTERM
:
2780 if (s
->kill_context
.send_sigkill
) {
2781 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
2782 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2784 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
2785 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
2790 case SERVICE_FINAL_SIGKILL
:
2791 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
2792 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
2795 case SERVICE_AUTO_RESTART
:
2796 log_unit_info(UNIT(s
),
2797 s
->restart_usec
> 0 ?
2798 "Service hold-off time over, scheduling restart." :
2799 "Service has no hold-off time, scheduling restart.");
2800 service_enter_restart(s
);
2804 assert_not_reached("Timeout at wrong time.");
2810 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2811 Service
*s
= SERVICE(userdata
);
2812 char t
[FORMAT_TIMESPAN_MAX
];
2815 assert(source
== s
->watchdog_event_source
);
2817 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
2818 format_timespan(t
, sizeof(t
), s
->watchdog_usec
, 1));
2820 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
2825 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
2826 Service
*s
= SERVICE(u
);
2827 _cleanup_free_
char *cc
= NULL
;
2828 bool notify_dbus
= false;
2833 cc
= strv_join(tags
, ", ");
2835 if (s
->notify_access
== NOTIFY_NONE
) {
2836 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
2838 } else if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
2839 if (s
->main_pid
!= 0)
2840 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
2842 log_unit_debug(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID which is currently not known", pid
);
2845 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
2847 /* Interpret MAINPID= */
2848 e
= strv_find_startswith(tags
, "MAINPID=");
2849 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
2850 if (parse_pid(e
, &pid
) < 0)
2851 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
2853 service_set_main_pid(s
, pid
);
2854 unit_watch_pid(UNIT(s
), pid
);
2859 /* Interpret RELOADING= */
2860 if (strv_find(tags
, "RELOADING=1")) {
2862 s
->notify_state
= NOTIFY_RELOADING
;
2864 if (s
->state
== SERVICE_RUNNING
)
2865 service_enter_reload_by_notify(s
);
2870 /* Interpret READY= */
2871 if (strv_find(tags
, "READY=1")) {
2873 s
->notify_state
= NOTIFY_READY
;
2875 /* Type=notify services inform us about completed
2876 * initialization with READY=1 */
2877 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
2878 service_enter_start_post(s
);
2880 /* Sending READY=1 while we are reloading informs us
2881 * that the reloading is complete */
2882 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
2883 service_enter_running(s
, SERVICE_SUCCESS
);
2888 /* Interpret STOPPING= */
2889 if (strv_find(tags
, "STOPPING=1")) {
2891 s
->notify_state
= NOTIFY_STOPPING
;
2893 if (s
->state
== SERVICE_RUNNING
)
2894 service_enter_stop_by_notify(s
);
2899 /* Interpret STATUS= */
2900 e
= strv_find_startswith(tags
, "STATUS=");
2902 _cleanup_free_
char *t
= NULL
;
2905 if (!utf8_is_valid(e
))
2906 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
2914 if (!streq_ptr(s
->status_text
, t
)) {
2916 free(s
->status_text
);
2924 /* Interpret ERRNO= */
2925 e
= strv_find_startswith(tags
, "ERRNO=");
2929 if (safe_atoi(e
, &status_errno
) < 0 || status_errno
< 0)
2930 log_unit_warning(u
, "Failed to parse ERRNO= field in notification message: %s", e
);
2932 if (s
->status_errno
!= status_errno
) {
2933 s
->status_errno
= status_errno
;
2939 /* Interpret WATCHDOG= */
2940 if (strv_find(tags
, "WATCHDOG=1")) {
2941 service_reset_watchdog(s
);
2944 /* Add the passed fds to the fd store */
2945 if (strv_find(tags
, "FDSTORE=1")) {
2946 service_add_fd_store_set(s
, fds
);
2949 /* Notify clients about changed status or main pid */
2951 unit_add_to_dbus_queue(u
);
2954 static int service_get_timeout(Unit
*u
, uint64_t *timeout
) {
2955 Service
*s
= SERVICE(u
);
2958 if (!s
->timer_event_source
)
2961 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
2968 static void service_bus_name_owner_change(
2971 const char *old_owner
,
2972 const char *new_owner
) {
2974 Service
*s
= SERVICE(u
);
2980 assert(streq(s
->bus_name
, name
));
2981 assert(old_owner
|| new_owner
);
2983 if (old_owner
&& new_owner
)
2984 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
2986 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
2988 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
2990 s
->bus_name_good
= !!new_owner
;
2992 if (s
->type
== SERVICE_DBUS
) {
2994 /* service_enter_running() will figure out what to
2996 if (s
->state
== SERVICE_RUNNING
)
2997 service_enter_running(s
, SERVICE_SUCCESS
);
2998 else if (s
->state
== SERVICE_START
&& new_owner
)
2999 service_enter_start_post(s
);
3001 } else if (new_owner
&&
3003 (s
->state
== SERVICE_START
||
3004 s
->state
== SERVICE_START_POST
||
3005 s
->state
== SERVICE_RUNNING
||
3006 s
->state
== SERVICE_RELOAD
)) {
3008 _cleanup_bus_creds_unref_ sd_bus_creds
*creds
= NULL
;
3011 /* Try to acquire PID from bus service */
3013 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3015 r
= sd_bus_creds_get_pid(creds
, &pid
);
3017 log_unit_debug(u
, "D-Bus name %s is now owned by process %u", name
, (unsigned) pid
);
3019 service_set_main_pid(s
, pid
);
3020 unit_watch_pid(UNIT(s
), pid
);
3025 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3026 _cleanup_free_
char *peer
= NULL
;
3032 /* This is called by the socket code when instantiating a new
3033 * service for a stream socket and the socket needs to be
3036 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3039 if (s
->socket_fd
>= 0)
3042 if (s
->state
!= SERVICE_DEAD
)
3045 if (getpeername_pretty(fd
, &peer
) >= 0) {
3047 if (UNIT(s
)->description
) {
3048 _cleanup_free_
char *a
;
3050 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")", NULL
);
3054 r
= unit_set_description(UNIT(s
), a
);
3056 r
= unit_set_description(UNIT(s
), peer
);
3063 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3065 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3067 return unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false);
3070 static void service_reset_failed(Unit
*u
) {
3071 Service
*s
= SERVICE(u
);
3075 if (s
->state
== SERVICE_FAILED
)
3076 service_set_state(s
, SERVICE_DEAD
);
3078 s
->result
= SERVICE_SUCCESS
;
3079 s
->reload_result
= SERVICE_SUCCESS
;
3081 RATELIMIT_RESET(s
->start_limit
);
3084 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3085 Service
*s
= SERVICE(u
);
3087 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3090 static const char* const service_state_table
[_SERVICE_STATE_MAX
] = {
3091 [SERVICE_DEAD
] = "dead",
3092 [SERVICE_START_PRE
] = "start-pre",
3093 [SERVICE_START
] = "start",
3094 [SERVICE_START_POST
] = "start-post",
3095 [SERVICE_RUNNING
] = "running",
3096 [SERVICE_EXITED
] = "exited",
3097 [SERVICE_RELOAD
] = "reload",
3098 [SERVICE_STOP
] = "stop",
3099 [SERVICE_STOP_SIGABRT
] = "stop-sigabrt",
3100 [SERVICE_STOP_SIGTERM
] = "stop-sigterm",
3101 [SERVICE_STOP_SIGKILL
] = "stop-sigkill",
3102 [SERVICE_STOP_POST
] = "stop-post",
3103 [SERVICE_FINAL_SIGTERM
] = "final-sigterm",
3104 [SERVICE_FINAL_SIGKILL
] = "final-sigkill",
3105 [SERVICE_FAILED
] = "failed",
3106 [SERVICE_AUTO_RESTART
] = "auto-restart",
3109 DEFINE_STRING_TABLE_LOOKUP(service_state
, ServiceState
);
3111 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3112 [SERVICE_RESTART_NO
] = "no",
3113 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3114 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3115 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3116 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3117 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3118 [SERVICE_RESTART_ALWAYS
] = "always",
3121 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3123 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3124 [SERVICE_SIMPLE
] = "simple",
3125 [SERVICE_FORKING
] = "forking",
3126 [SERVICE_ONESHOT
] = "oneshot",
3127 [SERVICE_DBUS
] = "dbus",
3128 [SERVICE_NOTIFY
] = "notify",
3129 [SERVICE_IDLE
] = "idle"
3132 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3134 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3135 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3136 [SERVICE_EXEC_START
] = "ExecStart",
3137 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3138 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3139 [SERVICE_EXEC_STOP
] = "ExecStop",
3140 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3143 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3145 static const char* const notify_access_table
[_NOTIFY_ACCESS_MAX
] = {
3146 [NOTIFY_NONE
] = "none",
3147 [NOTIFY_MAIN
] = "main",
3148 [NOTIFY_ALL
] = "all"
3151 DEFINE_STRING_TABLE_LOOKUP(notify_access
, NotifyAccess
);
3153 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3154 [NOTIFY_UNKNOWN
] = "unknown",
3155 [NOTIFY_READY
] = "ready",
3156 [NOTIFY_RELOADING
] = "reloading",
3157 [NOTIFY_STOPPING
] = "stopping",
3160 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3162 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3163 [SERVICE_SUCCESS
] = "success",
3164 [SERVICE_FAILURE_RESOURCES
] = "resources",
3165 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3166 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3167 [SERVICE_FAILURE_SIGNAL
] = "signal",
3168 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3169 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3170 [SERVICE_FAILURE_START_LIMIT
] = "start-limit"
3173 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3175 const UnitVTable service_vtable
= {
3176 .object_size
= sizeof(Service
),
3177 .exec_context_offset
= offsetof(Service
, exec_context
),
3178 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3179 .kill_context_offset
= offsetof(Service
, kill_context
),
3180 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3186 .private_section
= "Service",
3188 .init
= service_init
,
3189 .done
= service_done
,
3190 .load
= service_load
,
3191 .release_resources
= service_release_resources
,
3193 .coldplug
= service_coldplug
,
3195 .dump
= service_dump
,
3197 .start
= service_start
,
3198 .stop
= service_stop
,
3199 .reload
= service_reload
,
3201 .can_reload
= service_can_reload
,
3203 .kill
= service_kill
,
3205 .serialize
= service_serialize
,
3206 .deserialize_item
= service_deserialize_item
,
3208 .active_state
= service_active_state
,
3209 .sub_state_to_string
= service_sub_state_to_string
,
3211 .check_gc
= service_check_gc
,
3212 .check_snapshot
= service_check_snapshot
,
3214 .sigchld_event
= service_sigchld_event
,
3216 .reset_failed
= service_reset_failed
,
3218 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3219 .notify_message
= service_notify_message
,
3221 .bus_name_owner_change
= service_bus_name_owner_change
,
3223 .bus_vtable
= bus_service_vtable
,
3224 .bus_set_property
= bus_service_set_property
,
3225 .bus_commit_properties
= bus_service_commit_properties
,
3227 .get_timeout
= service_get_timeout
,
3228 .can_transient
= true,
3230 .status_message_formats
= {
3231 .starting_stopping
= {
3232 [0] = "Starting %s...",
3233 [1] = "Stopping %s...",
3235 .finished_start_job
= {
3236 [JOB_DONE
] = "Started %s.",
3237 [JOB_FAILED
] = "Failed to start %s.",
3239 .finished_stop_job
= {
3240 [JOB_DONE
] = "Stopped %s.",
3241 [JOB_FAILED
] = "Stopped (with error) %s.",