1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include "sd-messages.h"
27 #include "alloc-util.h"
29 #include "bus-error.h"
30 #include "bus-kernel.h"
32 #include "dbus-service.h"
36 #include "exit-status.h"
39 #include "format-util.h"
41 #include "load-dropin.h"
42 #include "load-fragment.h"
45 #include "parse-util.h"
46 #include "path-util.h"
47 #include "process-util.h"
49 #include "signal-util.h"
51 #include "stdio-util.h"
52 #include "string-table.h"
53 #include "string-util.h"
55 #include "unit-name.h"
60 static const UnitActiveState state_translation_table
[_SERVICE_STATE_MAX
] = {
61 [SERVICE_DEAD
] = UNIT_INACTIVE
,
62 [SERVICE_START_PRE
] = UNIT_ACTIVATING
,
63 [SERVICE_START
] = UNIT_ACTIVATING
,
64 [SERVICE_START_POST
] = UNIT_ACTIVATING
,
65 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
66 [SERVICE_EXITED
] = UNIT_ACTIVE
,
67 [SERVICE_RELOAD
] = UNIT_RELOADING
,
68 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
69 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
70 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
71 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
72 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
73 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
74 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
75 [SERVICE_FAILED
] = UNIT_FAILED
,
76 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
79 /* For Type=idle we never want to delay any other jobs, hence we
80 * consider idle jobs active as soon as we start working on them */
81 static const UnitActiveState state_translation_table_idle
[_SERVICE_STATE_MAX
] = {
82 [SERVICE_DEAD
] = UNIT_INACTIVE
,
83 [SERVICE_START_PRE
] = UNIT_ACTIVE
,
84 [SERVICE_START
] = UNIT_ACTIVE
,
85 [SERVICE_START_POST
] = UNIT_ACTIVE
,
86 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
87 [SERVICE_EXITED
] = UNIT_ACTIVE
,
88 [SERVICE_RELOAD
] = UNIT_RELOADING
,
89 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
90 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
91 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
92 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
93 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
94 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
95 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
96 [SERVICE_FAILED
] = UNIT_FAILED
,
97 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
100 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
);
101 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
102 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
);
104 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
);
105 static void service_enter_reload_by_notify(Service
*s
);
107 static void service_init(Unit
*u
) {
108 Service
*s
= SERVICE(u
);
111 assert(u
->load_state
== UNIT_STUB
);
113 s
->timeout_start_usec
= u
->manager
->default_timeout_start_usec
;
114 s
->timeout_stop_usec
= u
->manager
->default_timeout_stop_usec
;
115 s
->restart_usec
= u
->manager
->default_restart_usec
;
116 s
->runtime_max_usec
= USEC_INFINITY
;
117 s
->type
= _SERVICE_TYPE_INVALID
;
119 s
->stdin_fd
= s
->stdout_fd
= s
->stderr_fd
= -1;
120 s
->guess_main_pid
= true;
122 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
125 static void service_unwatch_control_pid(Service
*s
) {
128 if (s
->control_pid
<= 0)
131 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
135 static void service_unwatch_main_pid(Service
*s
) {
138 if (s
->main_pid
<= 0)
141 unit_unwatch_pid(UNIT(s
), s
->main_pid
);
145 static void service_unwatch_pid_file(Service
*s
) {
146 if (!s
->pid_file_pathspec
)
149 log_unit_debug(UNIT(s
), "Stopping watch for PID file %s", s
->pid_file_pathspec
->path
);
150 path_spec_unwatch(s
->pid_file_pathspec
);
151 path_spec_done(s
->pid_file_pathspec
);
152 s
->pid_file_pathspec
= mfree(s
->pid_file_pathspec
);
155 static int service_set_main_pid(Service
*s
, pid_t pid
) {
163 if (pid
== getpid_cached())
166 if (s
->main_pid
== pid
&& s
->main_pid_known
)
169 if (s
->main_pid
!= pid
) {
170 service_unwatch_main_pid(s
);
171 exec_status_start(&s
->main_exec_status
, pid
);
175 s
->main_pid_known
= true;
177 if (get_process_ppid(pid
, &ppid
) >= 0 && ppid
!= getpid_cached()) {
178 log_unit_warning(UNIT(s
), "Supervising process "PID_FMT
" which is not our child. We'll most likely not notice when it exits.", pid
);
179 s
->main_pid_alien
= true;
181 s
->main_pid_alien
= false;
186 void service_close_socket_fd(Service
*s
) {
189 /* Undo the effect of service_set_socket_fd(). */
191 s
->socket_fd
= asynchronous_close(s
->socket_fd
);
193 if (UNIT_ISSET(s
->accept_socket
)) {
194 socket_connection_unref(SOCKET(UNIT_DEREF(s
->accept_socket
)));
195 unit_ref_unset(&s
->accept_socket
);
199 static void service_stop_watchdog(Service
*s
) {
202 s
->watchdog_event_source
= sd_event_source_unref(s
->watchdog_event_source
);
203 s
->watchdog_timestamp
= DUAL_TIMESTAMP_NULL
;
206 static usec_t
service_get_watchdog_usec(Service
*s
) {
209 if (s
->watchdog_override_enable
)
210 return s
->watchdog_override_usec
;
212 return s
->watchdog_usec
;
215 static void service_start_watchdog(Service
*s
) {
217 usec_t watchdog_usec
;
221 watchdog_usec
= service_get_watchdog_usec(s
);
222 if (IN_SET(watchdog_usec
, 0, USEC_INFINITY
))
225 if (s
->watchdog_event_source
) {
226 r
= sd_event_source_set_time(s
->watchdog_event_source
, usec_add(s
->watchdog_timestamp
.monotonic
, watchdog_usec
));
228 log_unit_warning_errno(UNIT(s
), r
, "Failed to reset watchdog timer: %m");
232 r
= sd_event_source_set_enabled(s
->watchdog_event_source
, SD_EVENT_ONESHOT
);
234 r
= sd_event_add_time(
235 UNIT(s
)->manager
->event
,
236 &s
->watchdog_event_source
,
238 usec_add(s
->watchdog_timestamp
.monotonic
, watchdog_usec
), 0,
239 service_dispatch_watchdog
, s
);
241 log_unit_warning_errno(UNIT(s
), r
, "Failed to add watchdog timer: %m");
245 (void) sd_event_source_set_description(s
->watchdog_event_source
, "service-watchdog");
247 /* Let's process everything else which might be a sign
248 * of living before we consider a service died. */
249 r
= sd_event_source_set_priority(s
->watchdog_event_source
, SD_EVENT_PRIORITY_IDLE
);
253 log_unit_warning_errno(UNIT(s
), r
, "Failed to install watchdog timer: %m");
256 static void service_reset_watchdog(Service
*s
) {
259 dual_timestamp_get(&s
->watchdog_timestamp
);
260 service_start_watchdog(s
);
263 static void service_reset_watchdog_timeout(Service
*s
, usec_t watchdog_override_usec
) {
266 s
->watchdog_override_enable
= true;
267 s
->watchdog_override_usec
= watchdog_override_usec
;
268 service_reset_watchdog(s
);
270 log_unit_debug(UNIT(s
), "watchdog_usec="USEC_FMT
, s
->watchdog_usec
);
271 log_unit_debug(UNIT(s
), "watchdog_override_usec="USEC_FMT
, s
->watchdog_override_usec
);
274 static void service_fd_store_unlink(ServiceFDStore
*fs
) {
280 assert(fs
->service
->n_fd_store
> 0);
281 LIST_REMOVE(fd_store
, fs
->service
->fd_store
, fs
);
282 fs
->service
->n_fd_store
--;
285 if (fs
->event_source
) {
286 sd_event_source_set_enabled(fs
->event_source
, SD_EVENT_OFF
);
287 sd_event_source_unref(fs
->event_source
);
295 static void service_release_fd_store(Service
*s
) {
298 if (s
->n_keep_fd_store
> 0)
301 log_unit_debug(UNIT(s
), "Releasing all stored fds");
303 service_fd_store_unlink(s
->fd_store
);
305 assert(s
->n_fd_store
== 0);
308 static void service_release_resources(Unit
*u
) {
309 Service
*s
= SERVICE(u
);
313 if (!s
->fd_store
&& s
->stdin_fd
< 0 && s
->stdout_fd
< 0 && s
->stderr_fd
< 0)
316 log_unit_debug(u
, "Releasing resources.");
318 s
->stdin_fd
= safe_close(s
->stdin_fd
);
319 s
->stdout_fd
= safe_close(s
->stdout_fd
);
320 s
->stderr_fd
= safe_close(s
->stderr_fd
);
322 service_release_fd_store(s
);
325 static void service_done(Unit
*u
) {
326 Service
*s
= SERVICE(u
);
330 s
->pid_file
= mfree(s
->pid_file
);
331 s
->status_text
= mfree(s
->status_text
);
333 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
334 exec_command_free_array(s
->exec_command
, _SERVICE_EXEC_COMMAND_MAX
);
335 s
->control_command
= NULL
;
336 s
->main_command
= NULL
;
338 dynamic_creds_unref(&s
->dynamic_creds
);
340 exit_status_set_free(&s
->restart_prevent_status
);
341 exit_status_set_free(&s
->restart_force_status
);
342 exit_status_set_free(&s
->success_status
);
344 /* This will leak a process, but at least no memory or any of
346 service_unwatch_main_pid(s
);
347 service_unwatch_control_pid(s
);
348 service_unwatch_pid_file(s
);
351 unit_unwatch_bus_name(u
, s
->bus_name
);
352 s
->bus_name
= mfree(s
->bus_name
);
355 s
->bus_name_owner
= mfree(s
->bus_name_owner
);
357 service_close_socket_fd(s
);
358 s
->peer
= socket_peer_unref(s
->peer
);
360 unit_ref_unset(&s
->accept_socket
);
362 service_stop_watchdog(s
);
364 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
366 service_release_resources(u
);
369 static int on_fd_store_io(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
370 ServiceFDStore
*fs
= userdata
;
375 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
376 log_unit_debug(UNIT(fs
->service
),
377 "Received %s on stored fd %d (%s), closing.",
378 revents
& EPOLLERR
? "EPOLLERR" : "EPOLLHUP",
379 fs
->fd
, strna(fs
->fdname
));
380 service_fd_store_unlink(fs
);
384 static int service_add_fd_store(Service
*s
, int fd
, const char *name
) {
388 /* fd is always consumed if we return >= 0 */
393 if (s
->n_fd_store
>= s
->n_fd_store_max
)
394 return -EXFULL
; /* Our store is full.
395 * Use this errno rather than E[NM]FILE to distinguish from
396 * the case where systemd itself hits the file limit. */
398 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
399 r
= same_fd(fs
->fd
, fd
);
404 return 0; /* fd already included */
408 fs
= new0(ServiceFDStore
, 1);
414 fs
->fdname
= strdup(name
?: "stored");
420 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &fs
->event_source
, fd
, 0, on_fd_store_io
, fs
);
421 if (r
< 0 && r
!= -EPERM
) { /* EPERM indicates fds that aren't pollable, which is OK */
426 (void) sd_event_source_set_description(fs
->event_source
, "service-fd-store");
428 LIST_PREPEND(fd_store
, s
->fd_store
, fs
);
431 return 1; /* fd newly stored */
434 static int service_add_fd_store_set(Service
*s
, FDSet
*fds
, const char *name
) {
439 while (fdset_size(fds
) > 0) {
440 _cleanup_close_
int fd
= -1;
442 fd
= fdset_steal_first(fds
);
446 r
= service_add_fd_store(s
, fd
, name
);
448 return log_unit_warning_errno(UNIT(s
), r
,
449 "Cannot store more fds than FileDescriptorStoreMax=%u, closing remaining.",
452 return log_unit_error_errno(UNIT(s
), r
, "Failed to add fd to store: %m");
454 log_unit_debug(UNIT(s
), "Added fd %u (%s) to fd store.", fd
, strna(name
));
461 static void service_remove_fd_store(Service
*s
, const char *name
) {
462 ServiceFDStore
*fs
, *n
;
467 LIST_FOREACH_SAFE(fd_store
, fs
, n
, s
->fd_store
) {
468 if (!streq(fs
->fdname
, name
))
471 log_unit_debug(UNIT(s
), "Got explicit request to remove fd %i (%s), closing.", fs
->fd
, name
);
472 service_fd_store_unlink(fs
);
476 static int service_arm_timer(Service
*s
, usec_t usec
) {
481 if (s
->timer_event_source
) {
482 r
= sd_event_source_set_time(s
->timer_event_source
, usec
);
486 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
489 if (usec
== USEC_INFINITY
)
492 r
= sd_event_add_time(
493 UNIT(s
)->manager
->event
,
494 &s
->timer_event_source
,
497 service_dispatch_timer
, s
);
501 (void) sd_event_source_set_description(s
->timer_event_source
, "service-timer");
506 static int service_verify(Service
*s
) {
509 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
512 if (!s
->exec_command
[SERVICE_EXEC_START
] && !s
->exec_command
[SERVICE_EXEC_STOP
]) {
513 log_unit_error(UNIT(s
), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
517 if (s
->type
!= SERVICE_ONESHOT
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
518 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
522 if (!s
->remain_after_exit
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
523 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
527 if (s
->type
!= SERVICE_ONESHOT
&& s
->exec_command
[SERVICE_EXEC_START
]->command_next
) {
528 log_unit_error(UNIT(s
), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
532 if (s
->type
== SERVICE_ONESHOT
&& s
->restart
!= SERVICE_RESTART_NO
) {
533 log_unit_error(UNIT(s
), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
537 if (s
->type
== SERVICE_ONESHOT
&& !exit_status_set_is_empty(&s
->restart_force_status
)) {
538 log_unit_error(UNIT(s
), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
542 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name
) {
543 log_unit_error(UNIT(s
), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
547 if (s
->bus_name
&& s
->type
!= SERVICE_DBUS
)
548 log_unit_warning(UNIT(s
), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
550 if (s
->exec_context
.pam_name
&& !IN_SET(s
->kill_context
.kill_mode
, KILL_CONTROL_GROUP
, KILL_MIXED
)) {
551 log_unit_error(UNIT(s
), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
555 if (s
->usb_function_descriptors
&& !s
->usb_function_strings
)
556 log_unit_warning(UNIT(s
), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
558 if (!s
->usb_function_descriptors
&& s
->usb_function_strings
)
559 log_unit_warning(UNIT(s
), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
561 if (s
->runtime_max_usec
!= USEC_INFINITY
&& s
->type
== SERVICE_ONESHOT
)
562 log_unit_warning(UNIT(s
), "MaxRuntimeSec= has no effect in combination with Type=oneshot. Ignoring.");
567 static int service_add_default_dependencies(Service
*s
) {
572 if (!UNIT(s
)->default_dependencies
)
575 /* Add a number of automatic dependencies useful for the
576 * majority of services. */
578 if (MANAGER_IS_SYSTEM(UNIT(s
)->manager
)) {
579 /* First, pull in the really early boot stuff, and
580 * require it, so that we fail if we can't acquire
583 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
588 /* In the --user instance there's no sysinit.target,
589 * in that case require basic.target instead. */
591 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_BASIC_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
596 /* Second, if the rest of the base system is in the same
597 * transaction, order us after it, but do not pull it in or
598 * even require it. */
599 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_BASIC_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
603 /* Third, add us in for normal shutdown. */
604 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
607 static void service_fix_output(Service
*s
) {
610 /* If nothing has been explicitly configured, patch default output in. If input is socket/tty we avoid this
611 * however, since in that case we want output to default to the same place as we read input from. */
613 if (s
->exec_context
.std_error
== EXEC_OUTPUT_INHERIT
&&
614 s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
615 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
616 s
->exec_context
.std_error
= UNIT(s
)->manager
->default_std_error
;
618 if (s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
619 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
620 s
->exec_context
.std_output
= UNIT(s
)->manager
->default_std_output
;
622 if (s
->exec_context
.std_input
== EXEC_INPUT_NULL
&&
623 s
->exec_context
.stdin_data_size
> 0)
624 s
->exec_context
.std_input
= EXEC_INPUT_DATA
;
627 static int service_setup_bus_name(Service
*s
) {
635 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_DBUS_SOCKET
, NULL
, true, UNIT_DEPENDENCY_FILE
);
637 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
639 /* We always want to be ordered against dbus.socket if both are in the transaction. */
640 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_DBUS_SOCKET
, NULL
, true, UNIT_DEPENDENCY_FILE
);
642 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
644 r
= unit_watch_bus_name(UNIT(s
), s
->bus_name
);
646 return log_unit_error_errno(UNIT(s
), r
, "Two services allocated for the same bus name %s, refusing operation.", s
->bus_name
);
648 return log_unit_error_errno(UNIT(s
), r
, "Cannot watch bus name %s: %m", s
->bus_name
);
653 static int service_add_extras(Service
*s
) {
658 if (s
->type
== _SERVICE_TYPE_INVALID
) {
659 /* Figure out a type automatically */
661 s
->type
= SERVICE_DBUS
;
662 else if (s
->exec_command
[SERVICE_EXEC_START
])
663 s
->type
= SERVICE_SIMPLE
;
665 s
->type
= SERVICE_ONESHOT
;
668 /* Oneshot services have disabled start timeout by default */
669 if (s
->type
== SERVICE_ONESHOT
&& !s
->start_timeout_defined
)
670 s
->timeout_start_usec
= USEC_INFINITY
;
672 service_fix_output(s
);
674 r
= unit_patch_contexts(UNIT(s
));
678 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
682 r
= unit_set_default_slice(UNIT(s
));
686 if (s
->type
== SERVICE_NOTIFY
&& s
->notify_access
== NOTIFY_NONE
)
687 s
->notify_access
= NOTIFY_MAIN
;
689 if (s
->watchdog_usec
> 0 && s
->notify_access
== NOTIFY_NONE
)
690 s
->notify_access
= NOTIFY_MAIN
;
692 r
= service_add_default_dependencies(s
);
696 r
= service_setup_bus_name(s
);
703 static int service_load(Unit
*u
) {
704 Service
*s
= SERVICE(u
);
709 /* Load a .service file */
710 r
= unit_load_fragment(u
);
714 /* Still nothing found? Then let's give up */
715 if (u
->load_state
== UNIT_STUB
)
718 /* This is a new unit? Then let's add in some extras */
719 if (u
->load_state
== UNIT_LOADED
) {
721 /* We were able to load something, then let's add in
722 * the dropin directories. */
723 r
= unit_load_dropin(u
);
727 /* This is a new unit? Then let's add in some
729 r
= service_add_extras(s
);
734 return service_verify(s
);
737 static void service_dump(Unit
*u
, FILE *f
, const char *prefix
) {
738 ServiceExecCommand c
;
739 Service
*s
= SERVICE(u
);
744 prefix
= strempty(prefix
);
745 prefix2
= strjoina(prefix
, "\t");
748 "%sService State: %s\n"
750 "%sReload Result: %s\n"
751 "%sPermissionsStartOnly: %s\n"
752 "%sRootDirectoryStartOnly: %s\n"
753 "%sRemainAfterExit: %s\n"
754 "%sGuessMainPID: %s\n"
757 "%sNotifyAccess: %s\n"
758 "%sNotifyState: %s\n",
759 prefix
, service_state_to_string(s
->state
),
760 prefix
, service_result_to_string(s
->result
),
761 prefix
, service_result_to_string(s
->reload_result
),
762 prefix
, yes_no(s
->permissions_start_only
),
763 prefix
, yes_no(s
->root_directory_start_only
),
764 prefix
, yes_no(s
->remain_after_exit
),
765 prefix
, yes_no(s
->guess_main_pid
),
766 prefix
, service_type_to_string(s
->type
),
767 prefix
, service_restart_to_string(s
->restart
),
768 prefix
, notify_access_to_string(s
->notify_access
),
769 prefix
, notify_state_to_string(s
->notify_state
));
771 if (s
->control_pid
> 0)
773 "%sControl PID: "PID_FMT
"\n",
774 prefix
, s
->control_pid
);
778 "%sMain PID: "PID_FMT
"\n"
779 "%sMain PID Known: %s\n"
780 "%sMain PID Alien: %s\n",
782 prefix
, yes_no(s
->main_pid_known
),
783 prefix
, yes_no(s
->main_pid_alien
));
788 prefix
, s
->pid_file
);
793 "%sBus Name Good: %s\n",
795 prefix
, yes_no(s
->bus_name_good
));
797 if (UNIT_ISSET(s
->accept_socket
))
799 "%sAccept Socket: %s\n",
800 prefix
, UNIT_DEREF(s
->accept_socket
)->id
);
802 kill_context_dump(&s
->kill_context
, f
, prefix
);
803 exec_context_dump(&s
->exec_context
, f
, prefix
);
805 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
807 if (!s
->exec_command
[c
])
810 fprintf(f
, "%s-> %s:\n",
811 prefix
, service_exec_command_to_string(c
));
813 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
817 fprintf(f
, "%sStatus Text: %s\n",
818 prefix
, s
->status_text
);
820 if (s
->n_fd_store_max
> 0)
822 "%sFile Descriptor Store Max: %u\n"
823 "%sFile Descriptor Store Current: %u\n",
824 prefix
, s
->n_fd_store_max
,
825 prefix
, s
->n_fd_store
);
827 cgroup_context_dump(&s
->cgroup_context
, f
, prefix
);
830 static int service_load_pid_file(Service
*s
, bool may_warn
) {
831 _cleanup_free_
char *k
= NULL
;
840 r
= read_one_line_file(s
->pid_file
, &k
);
843 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
));
847 r
= parse_pid(k
, &pid
);
850 log_unit_info_errno(UNIT(s
), r
, "Failed to read PID from file %s: %m", s
->pid_file
);
854 if (!pid_is_alive(pid
)) {
856 log_unit_info(UNIT(s
), "PID "PID_FMT
" read from file %s does not exist or is a zombie.", pid
, s
->pid_file
);
860 if (s
->main_pid_known
) {
861 if (pid
== s
->main_pid
)
864 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
866 service_unwatch_main_pid(s
);
867 s
->main_pid_known
= false;
869 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
871 r
= service_set_main_pid(s
, pid
);
875 r
= unit_watch_pid(UNIT(s
), pid
);
876 if (r
< 0) /* FIXME: we need to do something here */
877 return log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
882 static void service_search_main_pid(Service
*s
) {
888 /* If we know it anyway, don't ever fallback to unreliable
890 if (s
->main_pid_known
)
893 if (!s
->guess_main_pid
)
896 assert(s
->main_pid
<= 0);
898 if (unit_search_main_pid(UNIT(s
), &pid
) < 0)
901 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
902 if (service_set_main_pid(s
, pid
) < 0)
905 r
= unit_watch_pid(UNIT(s
), pid
);
907 /* FIXME: we need to do something here */
908 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
911 static void service_set_state(Service
*s
, ServiceState state
) {
912 ServiceState old_state
;
913 const UnitActiveState
*table
;
917 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
919 old_state
= s
->state
;
922 service_unwatch_pid_file(s
);
925 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
928 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
929 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
930 SERVICE_AUTO_RESTART
))
931 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
934 SERVICE_START
, SERVICE_START_POST
,
935 SERVICE_RUNNING
, SERVICE_RELOAD
,
936 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
937 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
938 service_unwatch_main_pid(s
);
939 s
->main_command
= NULL
;
943 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
945 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
946 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
947 service_unwatch_control_pid(s
);
948 s
->control_command
= NULL
;
949 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
952 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
953 unit_unwatch_all_pids(UNIT(s
));
956 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
957 SERVICE_RUNNING
, SERVICE_RELOAD
,
958 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
959 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
960 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
))
961 service_close_socket_fd(s
);
963 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
964 service_stop_watchdog(s
);
966 /* For the inactive states unit_notify() will trim the cgroup,
967 * but for exit we have to do that ourselves... */
968 if (state
== SERVICE_EXITED
&& !MANAGER_IS_RELOADING(UNIT(s
)->manager
))
969 unit_prune_cgroup(UNIT(s
));
971 /* For remain_after_exit services, let's see if we can "release" the
972 * hold on the console, since unit_notify() only does that in case of
974 if (state
== SERVICE_EXITED
&&
975 s
->remain_after_exit
&&
976 UNIT(s
)->manager
->n_on_console
> 0) {
980 ec
= unit_get_exec_context(UNIT(s
));
981 if (ec
&& exec_context_may_touch_console(ec
)) {
982 Manager
*m
= UNIT(s
)->manager
;
985 if (m
->n_on_console
== 0)
986 /* unset no_console_output flag, since the console is free */
987 m
->no_console_output
= false;
991 if (old_state
!= state
)
992 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
994 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
997 static usec_t
service_coldplug_timeout(Service
*s
) {
1000 switch (s
->deserialized_state
) {
1002 case SERVICE_START_PRE
:
1004 case SERVICE_START_POST
:
1005 case SERVICE_RELOAD
:
1006 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_start_usec
);
1008 case SERVICE_RUNNING
:
1009 return usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
);
1012 case SERVICE_STOP_SIGABRT
:
1013 case SERVICE_STOP_SIGTERM
:
1014 case SERVICE_STOP_SIGKILL
:
1015 case SERVICE_STOP_POST
:
1016 case SERVICE_FINAL_SIGTERM
:
1017 case SERVICE_FINAL_SIGKILL
:
1018 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_stop_usec
);
1020 case SERVICE_AUTO_RESTART
:
1021 return usec_add(UNIT(s
)->inactive_enter_timestamp
.monotonic
, s
->restart_usec
);
1024 return USEC_INFINITY
;
1028 static int service_coldplug(Unit
*u
) {
1029 Service
*s
= SERVICE(u
);
1033 assert(s
->state
== SERVICE_DEAD
);
1035 if (s
->deserialized_state
== s
->state
)
1038 r
= service_arm_timer(s
, service_coldplug_timeout(s
));
1042 if (s
->main_pid
> 0 &&
1043 pid_is_unwaited(s
->main_pid
) &&
1044 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
1045 IN_SET(s
->deserialized_state
,
1046 SERVICE_START
, SERVICE_START_POST
,
1047 SERVICE_RUNNING
, SERVICE_RELOAD
,
1048 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1049 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
1050 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
1055 if (s
->control_pid
> 0 &&
1056 pid_is_unwaited(s
->control_pid
) &&
1057 IN_SET(s
->deserialized_state
,
1058 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1060 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1061 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
1062 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1067 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1068 unit_watch_all_pids(UNIT(s
));
1070 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
1071 service_start_watchdog(s
);
1073 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1074 (void) unit_setup_dynamic_creds(u
);
1076 if (UNIT_ISSET(s
->accept_socket
)) {
1077 Socket
* socket
= SOCKET(UNIT_DEREF(s
->accept_socket
));
1079 if (socket
->max_connections_per_source
> 0) {
1082 /* Make a best-effort attempt at bumping the connection count */
1083 if (socket_acquire_peer(socket
, s
->socket_fd
, &peer
) > 0) {
1084 socket_peer_unref(s
->peer
);
1090 service_set_state(s
, s
->deserialized_state
);
1094 static int service_collect_fds(Service
*s
,
1097 unsigned *n_storage_fds
,
1098 unsigned *n_socket_fds
) {
1100 _cleanup_strv_free_
char **rfd_names
= NULL
;
1101 _cleanup_free_
int *rfds
= NULL
;
1102 unsigned rn_socket_fds
= 0, rn_storage_fds
= 0;
1108 assert(n_socket_fds
);
1110 if (s
->socket_fd
>= 0) {
1112 /* Pass the per-connection socket */
1117 rfds
[0] = s
->socket_fd
;
1119 rfd_names
= strv_new("connection", NULL
);
1129 /* Pass all our configured sockets for singleton services */
1131 HASHMAP_FOREACH_KEY(v
, u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1132 _cleanup_free_
int *cfds
= NULL
;
1136 if (u
->type
!= UNIT_SOCKET
)
1141 cn_fds
= socket_collect_fds(sock
, &cfds
);
1150 rn_socket_fds
= cn_fds
;
1156 t
= realloc(rfds
, (rn_socket_fds
+ cn_fds
) * sizeof(int));
1160 memcpy(t
+ rn_socket_fds
, cfds
, cn_fds
* sizeof(int));
1163 rn_socket_fds
+= cn_fds
;
1166 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1172 if (s
->n_fd_store
> 0) {
1178 t
= realloc(rfds
, (rn_socket_fds
+ s
->n_fd_store
) * sizeof(int));
1184 nl
= realloc(rfd_names
, (rn_socket_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1189 n_fds
= rn_socket_fds
;
1191 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1192 rfds
[n_fds
] = fs
->fd
;
1193 rfd_names
[n_fds
] = strdup(strempty(fs
->fdname
));
1194 if (!rfd_names
[n_fds
])
1201 rfd_names
[n_fds
] = NULL
;
1205 *fd_names
= rfd_names
;
1206 *n_socket_fds
= rn_socket_fds
;
1207 *n_storage_fds
= rn_storage_fds
;
1215 static bool service_exec_needs_notify_socket(Service
*s
, ExecFlags flags
) {
1218 /* Notifications are accepted depending on the process and
1219 * the access setting of the service:
1220 * process: \ access: NONE MAIN EXEC ALL
1221 * main no yes yes yes
1222 * control no no yes yes
1223 * other (forked) no no no yes */
1225 if (flags
& EXEC_IS_CONTROL
)
1226 /* A control process */
1227 return IN_SET(s
->notify_access
, NOTIFY_EXEC
, NOTIFY_ALL
);
1229 /* We only spawn main processes and control processes, so any
1230 * process that is not a control process is a main process */
1231 return s
->notify_access
!= NOTIFY_NONE
;
1234 static int service_spawn(
1241 ExecParameters exec_params
= {
1247 _cleanup_strv_free_
char **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1248 unsigned n_storage_fds
= 0, n_socket_fds
= 0, n_env
= 0;
1249 _cleanup_free_
int *fds
= NULL
;
1257 r
= unit_prepare_exec(UNIT(s
));
1261 if (flags
& EXEC_IS_CONTROL
) {
1262 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1263 if (s
->permissions_start_only
)
1264 exec_params
.flags
&= ~EXEC_APPLY_SANDBOXING
;
1265 if (s
->root_directory_start_only
)
1266 exec_params
.flags
&= ~EXEC_APPLY_CHROOT
;
1269 if ((flags
& EXEC_PASS_FDS
) ||
1270 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1271 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1272 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1274 r
= service_collect_fds(s
, &fds
, &fd_names
, &n_storage_fds
, &n_socket_fds
);
1278 log_unit_debug(UNIT(s
), "Passing %i fds to service", n_storage_fds
+ n_socket_fds
);
1281 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), timeout
));
1285 our_env
= new0(char*, 9);
1289 if (service_exec_needs_notify_socket(s
, flags
))
1290 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0)
1293 if (s
->main_pid
> 0)
1294 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0)
1297 if (MANAGER_IS_USER(UNIT(s
)->manager
))
1298 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid_cached()) < 0)
1301 if (s
->socket_fd
>= 0) {
1302 union sockaddr_union sa
;
1303 socklen_t salen
= sizeof(sa
);
1305 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1306 * useful. Note that we do this only when we are still connected at this point in time, which we might
1307 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1308 * in ENOTCONN), and just use whate we can use. */
1310 if (getpeername(s
->socket_fd
, &sa
.sa
, &salen
) >= 0 &&
1311 IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
, AF_VSOCK
)) {
1313 _cleanup_free_
char *addr
= NULL
;
1317 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1321 t
= strappend("REMOTE_ADDR=", addr
);
1324 our_env
[n_env
++] = t
;
1326 r
= sockaddr_port(&sa
.sa
, &port
);
1330 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0)
1332 our_env
[n_env
++] = t
;
1336 if (flags
& EXEC_SETENV_RESULT
) {
1337 if (asprintf(our_env
+ n_env
++, "SERVICE_RESULT=%s", service_result_to_string(s
->result
)) < 0)
1340 if (s
->main_exec_status
.pid
> 0 &&
1341 dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
1342 if (asprintf(our_env
+ n_env
++, "EXIT_CODE=%s", sigchld_code_to_string(s
->main_exec_status
.code
)) < 0)
1345 if (s
->main_exec_status
.code
== CLD_EXITED
)
1346 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%i", s
->main_exec_status
.status
);
1348 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%s", signal_to_string(s
->main_exec_status
.status
));
1354 manager_set_exec_params(UNIT(s
)->manager
, &exec_params
);
1355 unit_set_exec_params(UNIT(s
), &exec_params
);
1357 final_env
= strv_env_merge(2, exec_params
.environment
, our_env
, NULL
);
1361 /* System services should get a new keyring by default. */
1362 SET_FLAG(exec_params
.flags
, EXEC_NEW_KEYRING
, MANAGER_IS_SYSTEM(UNIT(s
)->manager
));
1364 /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1365 SET_FLAG(exec_params
.flags
, EXEC_NSS_BYPASS_BUS
,
1366 MANAGER_IS_SYSTEM(UNIT(s
)->manager
) && unit_has_name(UNIT(s
), SPECIAL_DBUS_SERVICE
));
1368 exec_params
.argv
= c
->argv
;
1369 exec_params
.environment
= final_env
;
1370 exec_params
.fds
= fds
;
1371 exec_params
.fd_names
= fd_names
;
1372 exec_params
.n_storage_fds
= n_storage_fds
;
1373 exec_params
.n_socket_fds
= n_socket_fds
;
1374 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1375 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1376 if (s
->type
== SERVICE_IDLE
)
1377 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1378 exec_params
.stdin_fd
= s
->stdin_fd
;
1379 exec_params
.stdout_fd
= s
->stdout_fd
;
1380 exec_params
.stderr_fd
= s
->stderr_fd
;
1382 r
= exec_spawn(UNIT(s
),
1392 r
= unit_watch_pid(UNIT(s
), pid
);
1393 if (r
< 0) /* FIXME: we need to do something here */
1401 static int main_pid_good(Service
*s
) {
1404 /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1406 /* If we know the pid file, then let's just check if it is
1408 if (s
->main_pid_known
) {
1410 /* If it's an alien child let's check if it is still
1412 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1413 return pid_is_alive(s
->main_pid
);
1415 /* .. otherwise assume we'll get a SIGCHLD for it,
1416 * which we really should wait for to collect exit
1417 * status and code */
1418 return s
->main_pid
> 0;
1421 /* We don't know the pid */
1425 static int control_pid_good(Service
*s
) {
1428 /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1429 * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1430 * means: we can't figure it out. */
1432 return s
->control_pid
> 0;
1435 static int cgroup_good(Service
*s
) {
1440 /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1443 if (!UNIT(s
)->cgroup_path
)
1446 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1453 static bool service_shall_restart(Service
*s
) {
1456 /* Don't restart after manual stops */
1457 if (s
->forbid_restart
)
1460 /* Never restart if this is configured as special exception */
1461 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1464 /* Restart if the exit code/status are configured as restart triggers */
1465 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1468 switch (s
->restart
) {
1470 case SERVICE_RESTART_NO
:
1473 case SERVICE_RESTART_ALWAYS
:
1476 case SERVICE_RESTART_ON_SUCCESS
:
1477 return s
->result
== SERVICE_SUCCESS
;
1479 case SERVICE_RESTART_ON_FAILURE
:
1480 return s
->result
!= SERVICE_SUCCESS
;
1482 case SERVICE_RESTART_ON_ABNORMAL
:
1483 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1485 case SERVICE_RESTART_ON_WATCHDOG
:
1486 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1488 case SERVICE_RESTART_ON_ABORT
:
1489 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1492 assert_not_reached("unknown restart setting");
1496 static bool service_will_restart(Service
*s
) {
1499 if (s
->state
== SERVICE_AUTO_RESTART
)
1503 if (UNIT(s
)->job
->type
== JOB_START
)
1508 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1513 /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1514 * undo what has already been enqueued. */
1515 if (unit_stop_pending(UNIT(s
)))
1516 allow_restart
= false;
1518 if (s
->result
== SERVICE_SUCCESS
)
1521 if (s
->result
!= SERVICE_SUCCESS
)
1522 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1524 /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1525 * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1526 s
->n_keep_fd_store
++;
1528 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1530 if (allow_restart
&& service_shall_restart(s
)) {
1532 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
1534 s
->n_keep_fd_store
--;
1538 service_set_state(s
, SERVICE_AUTO_RESTART
);
1540 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1541 * user can still introspect the counter. Do so on the next start. */
1542 s
->flush_n_restarts
= true;
1544 /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
1545 * queue, so that the fd store is possibly gc'ed again */
1546 s
->n_keep_fd_store
--;
1547 unit_add_to_gc_queue(UNIT(s
));
1549 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1550 s
->forbid_restart
= false;
1552 /* We want fresh tmpdirs in case service is started again immediately */
1553 exec_runtime_destroy(s
->exec_runtime
);
1554 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1556 if (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_NO
||
1557 (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_RESTART
&& !service_will_restart(s
)))
1558 /* Also, remove the runtime directory */
1559 exec_context_destroy_runtime_directory(&s
->exec_context
, UNIT(s
)->manager
->prefix
[EXEC_DIRECTORY_RUNTIME
]);
1561 /* Get rid of the IPC bits of the user */
1562 unit_unref_uid_gid(UNIT(s
), true);
1564 /* Release the user, and destroy it if we are the only remaining owner */
1565 dynamic_creds_destroy(&s
->dynamic_creds
);
1567 /* Try to delete the pid file. At this point it will be
1568 * out-of-date, and some software might be confused by it, so
1569 * let's remove it. */
1571 (void) unlink(s
->pid_file
);
1576 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1577 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1580 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1584 if (s
->result
== SERVICE_SUCCESS
)
1587 service_unwatch_control_pid(s
);
1588 unit_watch_all_pids(UNIT(s
));
1590 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1591 if (s
->control_command
) {
1592 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1594 r
= service_spawn(s
,
1596 s
->timeout_stop_usec
,
1597 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1602 service_set_state(s
, SERVICE_STOP_POST
);
1604 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1609 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1610 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1613 static int state_to_kill_operation(ServiceState state
) {
1616 case SERVICE_STOP_SIGABRT
:
1619 case SERVICE_STOP_SIGTERM
:
1620 case SERVICE_FINAL_SIGTERM
:
1621 return KILL_TERMINATE
;
1623 case SERVICE_STOP_SIGKILL
:
1624 case SERVICE_FINAL_SIGKILL
:
1628 return _KILL_OPERATION_INVALID
;
1632 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1637 if (s
->result
== SERVICE_SUCCESS
)
1640 unit_watch_all_pids(UNIT(s
));
1642 r
= unit_kill_context(
1645 state_to_kill_operation(state
),
1653 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1657 service_set_state(s
, state
);
1658 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1659 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1660 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1661 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1662 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1663 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1665 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1670 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1672 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1673 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1675 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1678 static void service_enter_stop_by_notify(Service
*s
) {
1681 unit_watch_all_pids(UNIT(s
));
1683 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1685 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1686 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1689 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1694 if (s
->result
== SERVICE_SUCCESS
)
1697 service_unwatch_control_pid(s
);
1698 unit_watch_all_pids(UNIT(s
));
1700 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1701 if (s
->control_command
) {
1702 s
->control_command_id
= SERVICE_EXEC_STOP
;
1704 r
= service_spawn(s
,
1706 s
->timeout_stop_usec
,
1707 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1712 service_set_state(s
, SERVICE_STOP
);
1714 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1719 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1720 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1723 static bool service_good(Service
*s
) {
1727 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1730 main_pid_ok
= main_pid_good(s
);
1731 if (main_pid_ok
> 0) /* It's alive */
1733 if (main_pid_ok
== 0) /* It's dead */
1736 /* OK, we don't know anything about the main PID, maybe
1737 * because there is none. Let's check the control group
1740 return cgroup_good(s
) != 0;
1743 static void service_enter_running(Service
*s
, ServiceResult f
) {
1746 if (s
->result
== SERVICE_SUCCESS
)
1749 service_unwatch_control_pid(s
);
1751 if (service_good(s
)) {
1753 /* If there are any queued up sd_notify()
1754 * notifications, process them now */
1755 if (s
->notify_state
== NOTIFY_RELOADING
)
1756 service_enter_reload_by_notify(s
);
1757 else if (s
->notify_state
== NOTIFY_STOPPING
)
1758 service_enter_stop_by_notify(s
);
1760 service_set_state(s
, SERVICE_RUNNING
);
1761 service_arm_timer(s
, usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
));
1764 } else if (f
!= SERVICE_SUCCESS
)
1765 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
1766 else if (s
->remain_after_exit
)
1767 service_set_state(s
, SERVICE_EXITED
);
1769 service_enter_stop(s
, SERVICE_SUCCESS
);
1772 static void service_enter_start_post(Service
*s
) {
1776 service_unwatch_control_pid(s
);
1777 service_reset_watchdog(s
);
1779 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1780 if (s
->control_command
) {
1781 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1783 r
= service_spawn(s
,
1785 s
->timeout_start_usec
,
1786 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
1791 service_set_state(s
, SERVICE_START_POST
);
1793 service_enter_running(s
, SERVICE_SUCCESS
);
1798 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1799 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1802 static void service_kill_control_process(Service
*s
) {
1807 if (s
->control_pid
<= 0)
1810 r
= kill_and_sigcont(s
->control_pid
, SIGKILL
);
1812 _cleanup_free_
char *comm
= NULL
;
1814 (void) get_process_comm(s
->control_pid
, &comm
);
1816 log_unit_debug_errno(UNIT(s
), r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m",
1817 s
->control_pid
, strna(comm
));
1821 static void service_enter_start(Service
*s
) {
1829 service_unwatch_control_pid(s
);
1830 service_unwatch_main_pid(s
);
1832 unit_warn_leftover_processes(UNIT(s
));
1834 if (s
->type
== SERVICE_FORKING
) {
1835 s
->control_command_id
= SERVICE_EXEC_START
;
1836 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1838 s
->main_command
= NULL
;
1840 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1841 s
->control_command
= NULL
;
1843 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1847 if (s
->type
!= SERVICE_ONESHOT
) {
1848 /* There's no command line configured for the main command? Hmm, that is strange. This can only
1849 * happen if the configuration changes at runtime. In this case, let's enter a failure
1851 log_unit_error(UNIT(s
), "There's no 'start' task anymore we could start: %m");
1856 service_enter_start_post(s
);
1860 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
))
1861 /* For simple + idle this is the main process. We don't apply any timeout here, but
1862 * service_enter_running() will later apply the .runtime_max_usec timeout. */
1863 timeout
= USEC_INFINITY
;
1865 timeout
= s
->timeout_start_usec
;
1867 r
= service_spawn(s
,
1870 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
1875 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
)) {
1876 /* For simple services we immediately start
1877 * the START_POST binaries. */
1879 service_set_main_pid(s
, pid
);
1880 service_enter_start_post(s
);
1882 } else if (s
->type
== SERVICE_FORKING
) {
1884 /* For forking services we wait until the start
1885 * process exited. */
1887 s
->control_pid
= pid
;
1888 service_set_state(s
, SERVICE_START
);
1890 } else if (IN_SET(s
->type
, SERVICE_ONESHOT
, SERVICE_DBUS
, SERVICE_NOTIFY
)) {
1892 /* For oneshot services we wait until the start
1893 * process exited, too, but it is our main process. */
1895 /* For D-Bus services we know the main pid right away,
1896 * but wait for the bus name to appear on the
1897 * bus. Notify services are similar. */
1899 service_set_main_pid(s
, pid
);
1900 service_set_state(s
, SERVICE_START
);
1902 assert_not_reached("Unknown service type");
1907 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1908 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1911 static void service_enter_start_pre(Service
*s
) {
1916 service_unwatch_control_pid(s
);
1918 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1919 if (s
->control_command
) {
1921 unit_warn_leftover_processes(UNIT(s
));
1923 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1925 r
= service_spawn(s
,
1927 s
->timeout_start_usec
,
1928 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_APPLY_TTY_STDIN
,
1933 service_set_state(s
, SERVICE_START_PRE
);
1935 service_enter_start(s
);
1940 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1941 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1944 static void service_enter_restart(Service
*s
) {
1945 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1950 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1951 /* Don't restart things if we are going down anyway */
1952 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
1954 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
1961 /* Any units that are bound to this service must also be
1962 * restarted. We use JOB_RESTART (instead of the more obvious
1963 * JOB_START) here so that those dependency jobs will be added
1965 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, &error
, NULL
);
1969 /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
1970 * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
1971 * explicitly however via the usual "systemctl reset-failure" logic. */
1973 s
->flush_n_restarts
= false;
1975 log_struct(LOG_INFO
,
1976 "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR
,
1977 LOG_UNIT_ID(UNIT(s
)),
1978 LOG_UNIT_INVOCATION_ID(UNIT(s
)),
1979 LOG_UNIT_MESSAGE(UNIT(s
), "Scheduled restart job, restart counter is at %u.", s
->n_restarts
),
1980 "N_RESTARTS=%u", s
->n_restarts
,
1983 /* Notify clients about changed restart counter */
1984 unit_add_to_dbus_queue(UNIT(s
));
1986 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1987 * it will be canceled as part of the service_stop() call that
1988 * is executed as part of JOB_RESTART. */
1993 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
1994 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1997 static void service_enter_reload_by_notify(Service
*s
) {
1998 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2003 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_start_usec
));
2004 service_set_state(s
, SERVICE_RELOAD
);
2006 /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2007 r
= manager_propagate_reload(UNIT(s
)->manager
, UNIT(s
), JOB_FAIL
, &error
);
2009 log_unit_warning(UNIT(s
), "Failed to schedule propagation of reload: %s", bus_error_message(&error
, -r
));
2012 static void service_enter_reload(Service
*s
) {
2017 service_unwatch_control_pid(s
);
2018 s
->reload_result
= SERVICE_SUCCESS
;
2020 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
2021 if (s
->control_command
) {
2022 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
2024 r
= service_spawn(s
,
2026 s
->timeout_start_usec
,
2027 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
2032 service_set_state(s
, SERVICE_RELOAD
);
2034 service_enter_running(s
, SERVICE_SUCCESS
);
2039 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
2040 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2041 service_enter_running(s
, SERVICE_SUCCESS
);
2044 static void service_run_next_control(Service
*s
) {
2049 assert(s
->control_command
);
2050 assert(s
->control_command
->command_next
);
2052 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
2054 s
->control_command
= s
->control_command
->command_next
;
2055 service_unwatch_control_pid(s
);
2057 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
2058 timeout
= s
->timeout_start_usec
;
2060 timeout
= s
->timeout_stop_usec
;
2062 r
= service_spawn(s
,
2065 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|
2066 (IN_SET(s
->control_command_id
, SERVICE_EXEC_START_PRE
, SERVICE_EXEC_STOP_POST
) ? EXEC_APPLY_TTY_STDIN
: 0)|
2067 (IN_SET(s
->control_command_id
, SERVICE_EXEC_STOP
, SERVICE_EXEC_STOP_POST
) ? EXEC_SETENV_RESULT
: 0),
2075 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
2077 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START_POST
, SERVICE_STOP
))
2078 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2079 else if (s
->state
== SERVICE_STOP_POST
)
2080 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
2081 else if (s
->state
== SERVICE_RELOAD
) {
2082 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2083 service_enter_running(s
, SERVICE_SUCCESS
);
2085 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2088 static void service_run_next_main(Service
*s
) {
2093 assert(s
->main_command
);
2094 assert(s
->main_command
->command_next
);
2095 assert(s
->type
== SERVICE_ONESHOT
);
2097 s
->main_command
= s
->main_command
->command_next
;
2098 service_unwatch_main_pid(s
);
2100 r
= service_spawn(s
,
2102 s
->timeout_start_usec
,
2103 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
2108 service_set_main_pid(s
, pid
);
2113 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
2114 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2117 static int service_start(Unit
*u
) {
2118 Service
*s
= SERVICE(u
);
2123 /* We cannot fulfill this request right now, try again later
2125 if (IN_SET(s
->state
,
2126 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2127 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2130 /* Already on it! */
2131 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
2134 /* A service that will be restarted must be stopped first to
2135 * trigger BindsTo and/or OnFailure dependencies. If a user
2136 * does not want to wait for the holdoff time to elapse, the
2137 * service should be manually restarted, not started. We
2138 * simply return EAGAIN here, so that any start jobs stay
2139 * queued, and assume that the auto restart timer will
2140 * eventually trigger the restart. */
2141 if (s
->state
== SERVICE_AUTO_RESTART
)
2144 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
2146 /* Make sure we don't enter a busy loop of some kind. */
2147 r
= unit_start_limit_test(u
);
2149 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT_HIT
, false);
2153 r
= unit_acquire_invocation_id(u
);
2157 s
->result
= SERVICE_SUCCESS
;
2158 s
->reload_result
= SERVICE_SUCCESS
;
2159 s
->main_pid_known
= false;
2160 s
->main_pid_alien
= false;
2161 s
->forbid_restart
= false;
2163 u
->reset_accounting
= true;
2165 s
->status_text
= mfree(s
->status_text
);
2166 s
->status_errno
= 0;
2168 s
->notify_state
= NOTIFY_UNKNOWN
;
2170 s
->watchdog_override_enable
= false;
2171 s
->watchdog_override_usec
= 0;
2173 /* This is not an automatic restart? Flush the restart counter then */
2174 if (s
->flush_n_restarts
) {
2176 s
->flush_n_restarts
= false;
2179 service_enter_start_pre(s
);
2183 static int service_stop(Unit
*u
) {
2184 Service
*s
= SERVICE(u
);
2188 /* Don't create restart jobs from manual stops. */
2189 s
->forbid_restart
= true;
2192 if (IN_SET(s
->state
,
2193 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2194 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2197 /* A restart will be scheduled or is in progress. */
2198 if (s
->state
== SERVICE_AUTO_RESTART
) {
2199 service_set_state(s
, SERVICE_DEAD
);
2203 /* If there's already something running we go directly into
2205 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2206 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2210 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2212 service_enter_stop(s
, SERVICE_SUCCESS
);
2216 static int service_reload(Unit
*u
) {
2217 Service
*s
= SERVICE(u
);
2221 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2223 service_enter_reload(s
);
2227 _pure_
static bool service_can_reload(Unit
*u
) {
2228 Service
*s
= SERVICE(u
);
2232 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2235 static unsigned service_exec_command_index(Unit
*u
, ServiceExecCommand id
, ExecCommand
*current
) {
2236 Service
*s
= SERVICE(u
);
2238 ExecCommand
*first
, *c
;
2242 first
= s
->exec_command
[id
];
2244 /* Figure out where we are in the list by walking back to the beginning */
2245 for (c
= current
; c
!= first
; c
= c
->command_prev
)
2251 static int service_serialize_exec_command(Unit
*u
, FILE *f
, ExecCommand
*command
) {
2252 Service
*s
= SERVICE(u
);
2253 ServiceExecCommand id
;
2257 _cleanup_free_
char *args
= NULL
, *p
= NULL
;
2258 size_t allocated
= 0, length
= 0;
2266 if (command
== s
->control_command
) {
2268 id
= s
->control_command_id
;
2271 id
= SERVICE_EXEC_START
;
2274 idx
= service_exec_command_index(u
, id
, command
);
2276 STRV_FOREACH(arg
, command
->argv
) {
2278 _cleanup_free_
char *e
= NULL
;
2280 e
= xescape(*arg
, WHITESPACE
);
2285 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1 + n
+ 1))
2289 args
[length
++] = ' ';
2291 memcpy(args
+ length
, e
, n
);
2295 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1))
2299 p
= xescape(command
->path
, WHITESPACE
);
2303 fprintf(f
, "%s-command=%s %u %s %s\n", type
, service_exec_command_to_string(id
), idx
, p
, args
);
2308 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2309 Service
*s
= SERVICE(u
);
2317 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2318 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2319 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2321 if (s
->control_pid
> 0)
2322 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2324 if (s
->main_pid_known
&& s
->main_pid
> 0)
2325 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2327 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2328 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2329 unit_serialize_item(u
, f
, "bus-name-owner", s
->bus_name_owner
);
2331 unit_serialize_item_format(u
, f
, "n-restarts", "%u", s
->n_restarts
);
2332 unit_serialize_item(u
, f
, "flush-n-restarts", yes_no(s
->flush_n_restarts
));
2334 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2338 service_serialize_exec_command(u
, f
, s
->control_command
);
2339 service_serialize_exec_command(u
, f
, s
->main_command
);
2341 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2344 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2347 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2351 if (UNIT_ISSET(s
->accept_socket
)) {
2352 r
= unit_serialize_item(u
, f
, "accept-socket", UNIT_DEREF(s
->accept_socket
)->id
);
2357 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2361 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2362 _cleanup_free_
char *c
= NULL
;
2365 copy
= fdset_put_dup(fds
, fs
->fd
);
2369 c
= cescape(fs
->fdname
);
2371 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2374 if (s
->main_exec_status
.pid
> 0) {
2375 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2376 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2377 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2379 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2380 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2381 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2385 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2387 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2389 if (s
->watchdog_override_enable
)
2390 unit_serialize_item_format(u
, f
, "watchdog-override-usec", USEC_FMT
, s
->watchdog_override_usec
);
2395 static int service_deserialize_exec_command(Unit
*u
, const char *key
, const char *value
) {
2396 Service
*s
= SERVICE(u
);
2398 unsigned idx
= 0, i
;
2399 bool control
, found
= false;
2400 ServiceExecCommand id
= _SERVICE_EXEC_COMMAND_INVALID
;
2401 ExecCommand
*command
= NULL
;
2402 _cleanup_free_
char *path
= NULL
;
2403 _cleanup_strv_free_
char **argv
= NULL
;
2405 enum ExecCommandState
{
2406 STATE_EXEC_COMMAND_TYPE
,
2407 STATE_EXEC_COMMAND_INDEX
,
2408 STATE_EXEC_COMMAND_PATH
,
2409 STATE_EXEC_COMMAND_ARGS
,
2410 _STATE_EXEC_COMMAND_MAX
,
2411 _STATE_EXEC_COMMAND_INVALID
= -1,
2418 control
= streq(key
, "control-command");
2420 state
= STATE_EXEC_COMMAND_TYPE
;
2423 _cleanup_free_
char *arg
= NULL
;
2425 r
= extract_first_word(&value
, &arg
, NULL
, EXTRACT_CUNESCAPE
);
2432 case STATE_EXEC_COMMAND_TYPE
:
2433 id
= service_exec_command_from_string(arg
);
2437 state
= STATE_EXEC_COMMAND_INDEX
;
2439 case STATE_EXEC_COMMAND_INDEX
:
2440 r
= safe_atou(arg
, &idx
);
2444 state
= STATE_EXEC_COMMAND_PATH
;
2446 case STATE_EXEC_COMMAND_PATH
:
2449 state
= STATE_EXEC_COMMAND_ARGS
;
2451 if (!path_is_absolute(path
))
2454 case STATE_EXEC_COMMAND_ARGS
:
2455 r
= strv_extend(&argv
, arg
);
2460 assert_not_reached("Unknown error at deserialization of exec command");
2465 if (state
!= STATE_EXEC_COMMAND_ARGS
)
2468 /* Let's check whether exec command on given offset matches data that we just deserialized */
2469 for (command
= s
->exec_command
[id
], i
= 0; command
; command
= command
->command_next
, i
++) {
2473 found
= strv_equal(argv
, command
->argv
) && streq(command
->path
, path
);
2478 /* Command at the index we serialized is different, let's look for command that exactly
2479 * matches but is on different index. If there is no such command we will not resume execution. */
2480 for (command
= s
->exec_command
[id
]; command
; command
= command
->command_next
)
2481 if (strv_equal(command
->argv
, argv
) && streq(command
->path
, path
))
2485 if (command
&& control
)
2486 s
->control_command
= command
;
2488 s
->main_command
= command
;
2490 log_unit_warning(u
, "Current command vanished from the unit file, execution of the command list won't be resumed.");
2495 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2496 Service
*s
= SERVICE(u
);
2504 if (streq(key
, "state")) {
2507 state
= service_state_from_string(value
);
2509 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2511 s
->deserialized_state
= state
;
2512 } else if (streq(key
, "result")) {
2515 f
= service_result_from_string(value
);
2517 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2518 else if (f
!= SERVICE_SUCCESS
)
2521 } else if (streq(key
, "reload-result")) {
2524 f
= service_result_from_string(value
);
2526 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2527 else if (f
!= SERVICE_SUCCESS
)
2528 s
->reload_result
= f
;
2530 } else if (streq(key
, "control-pid")) {
2533 if (parse_pid(value
, &pid
) < 0)
2534 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2536 s
->control_pid
= pid
;
2537 } else if (streq(key
, "main-pid")) {
2540 if (parse_pid(value
, &pid
) < 0)
2541 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2543 service_set_main_pid(s
, pid
);
2544 unit_watch_pid(UNIT(s
), pid
);
2546 } else if (streq(key
, "main-pid-known")) {
2549 b
= parse_boolean(value
);
2551 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2553 s
->main_pid_known
= b
;
2554 } else if (streq(key
, "bus-name-good")) {
2557 b
= parse_boolean(value
);
2559 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2561 s
->bus_name_good
= b
;
2562 } else if (streq(key
, "bus-name-owner")) {
2563 r
= free_and_strdup(&s
->bus_name_owner
, value
);
2565 log_unit_error_errno(u
, r
, "Unable to deserialize current bus owner %s: %m", value
);
2566 } else if (streq(key
, "status-text")) {
2569 r
= cunescape(value
, 0, &t
);
2571 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2573 free(s
->status_text
);
2577 } else if (streq(key
, "accept-socket")) {
2580 r
= manager_load_unit(u
->manager
, value
, NULL
, NULL
, &socket
);
2582 log_unit_debug_errno(u
, r
, "Failed to load accept-socket unit: %s", value
);
2584 unit_ref_set(&s
->accept_socket
, socket
);
2585 SOCKET(socket
)->n_connections
++;
2588 } else if (streq(key
, "socket-fd")) {
2591 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2592 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2594 asynchronous_close(s
->socket_fd
);
2595 s
->socket_fd
= fdset_remove(fds
, fd
);
2597 } else if (streq(key
, "fd-store-fd")) {
2602 pf
= strcspn(value
, WHITESPACE
);
2603 fdv
= strndupa(value
, pf
);
2605 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2606 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2608 _cleanup_free_
char *t
= NULL
;
2612 fdn
+= strspn(fdn
, WHITESPACE
);
2613 (void) cunescape(fdn
, 0, &t
);
2615 r
= service_add_fd_store(s
, fd
, t
);
2617 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2619 fdset_remove(fds
, fd
);
2622 } else if (streq(key
, "main-exec-status-pid")) {
2625 if (parse_pid(value
, &pid
) < 0)
2626 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2628 s
->main_exec_status
.pid
= pid
;
2629 } else if (streq(key
, "main-exec-status-code")) {
2632 if (safe_atoi(value
, &i
) < 0)
2633 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2635 s
->main_exec_status
.code
= i
;
2636 } else if (streq(key
, "main-exec-status-status")) {
2639 if (safe_atoi(value
, &i
) < 0)
2640 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2642 s
->main_exec_status
.status
= i
;
2643 } else if (streq(key
, "main-exec-status-start"))
2644 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2645 else if (streq(key
, "main-exec-status-exit"))
2646 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2647 else if (streq(key
, "watchdog-timestamp"))
2648 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2649 else if (streq(key
, "forbid-restart")) {
2652 b
= parse_boolean(value
);
2654 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2656 s
->forbid_restart
= b
;
2657 } else if (streq(key
, "stdin-fd")) {
2660 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2661 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2663 asynchronous_close(s
->stdin_fd
);
2664 s
->stdin_fd
= fdset_remove(fds
, fd
);
2665 s
->exec_context
.stdio_as_fds
= true;
2667 } else if (streq(key
, "stdout-fd")) {
2670 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2671 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2673 asynchronous_close(s
->stdout_fd
);
2674 s
->stdout_fd
= fdset_remove(fds
, fd
);
2675 s
->exec_context
.stdio_as_fds
= true;
2677 } else if (streq(key
, "stderr-fd")) {
2680 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2681 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2683 asynchronous_close(s
->stderr_fd
);
2684 s
->stderr_fd
= fdset_remove(fds
, fd
);
2685 s
->exec_context
.stdio_as_fds
= true;
2687 } else if (streq(key
, "watchdog-override-usec")) {
2688 usec_t watchdog_override_usec
;
2689 if (timestamp_deserialize(value
, &watchdog_override_usec
) < 0)
2690 log_unit_debug(u
, "Failed to parse watchdog_override_usec value: %s", value
);
2692 s
->watchdog_override_enable
= true;
2693 s
->watchdog_override_usec
= watchdog_override_usec
;
2695 } else if (STR_IN_SET(key
, "main-command", "control-command")) {
2696 r
= service_deserialize_exec_command(u
, key
, value
);
2698 log_unit_debug_errno(u
, r
, "Failed to parse serialized command \"%s\": %m", value
);
2700 } else if (streq(key
, "n-restarts")) {
2701 r
= safe_atou(value
, &s
->n_restarts
);
2703 log_unit_debug_errno(u
, r
, "Failed to parse serialized restart counter '%s': %m", value
);
2705 } else if (streq(key
, "flush-n-restarts")) {
2706 r
= parse_boolean(value
);
2708 log_unit_debug_errno(u
, r
, "Failed to parse serialized flush restart counter setting '%s': %m", value
);
2710 s
->flush_n_restarts
= r
;
2712 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2717 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2718 const UnitActiveState
*table
;
2722 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2724 return table
[SERVICE(u
)->state
];
2727 static const char *service_sub_state_to_string(Unit
*u
) {
2730 return service_state_to_string(SERVICE(u
)->state
);
2733 static bool service_check_gc(Unit
*u
) {
2734 Service
*s
= SERVICE(u
);
2738 /* Never clean up services that still have a process around, even if the service is formally dead. Note that
2739 * unit_check_gc() already checked our cgroup for us, we just check our two additional PIDs, too, in case they
2740 * have moved outside of the cgroup. */
2742 if (main_pid_good(s
) > 0 ||
2743 control_pid_good(s
) > 0)
2749 static int service_retry_pid_file(Service
*s
) {
2752 assert(s
->pid_file
);
2753 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2755 r
= service_load_pid_file(s
, false);
2759 service_unwatch_pid_file(s
);
2761 service_enter_running(s
, SERVICE_SUCCESS
);
2765 static int service_watch_pid_file(Service
*s
) {
2768 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2770 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2774 /* the pidfile might have appeared just before we set the watch */
2775 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2776 service_retry_pid_file(s
);
2780 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2781 service_unwatch_pid_file(s
);
2785 static int service_demand_pid_file(Service
*s
) {
2788 assert(s
->pid_file
);
2789 assert(!s
->pid_file_pathspec
);
2791 ps
= new0(PathSpec
, 1);
2796 ps
->path
= strdup(s
->pid_file
);
2802 path_kill_slashes(ps
->path
);
2804 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2805 * keep their PID file open all the time. */
2806 ps
->type
= PATH_MODIFIED
;
2807 ps
->inotify_fd
= -1;
2809 s
->pid_file_pathspec
= ps
;
2811 return service_watch_pid_file(s
);
2814 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2815 PathSpec
*p
= userdata
;
2820 s
= SERVICE(p
->unit
);
2824 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2825 assert(s
->pid_file_pathspec
);
2826 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2828 log_unit_debug(UNIT(s
), "inotify event");
2830 if (path_spec_fd_event(p
, events
) < 0)
2833 if (service_retry_pid_file(s
) == 0)
2836 if (service_watch_pid_file(s
) < 0)
2842 service_unwatch_pid_file(s
);
2843 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2847 static void service_notify_cgroup_empty_event(Unit
*u
) {
2848 Service
*s
= SERVICE(u
);
2852 log_unit_debug(u
, "cgroup is empty");
2856 /* Waiting for SIGCHLD is usually more interesting,
2857 * because it includes return codes/signals. Which is
2858 * why we ignore the cgroup events for most cases,
2859 * except when we don't know pid which to expect the
2863 if (s
->type
== SERVICE_NOTIFY
&&
2864 main_pid_good(s
) == 0 &&
2865 control_pid_good(s
) == 0) {
2866 /* No chance of getting a ready notification anymore */
2867 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2872 case SERVICE_START_POST
:
2873 if (s
->pid_file_pathspec
&&
2874 main_pid_good(s
) == 0 &&
2875 control_pid_good(s
) == 0) {
2877 /* Give up hoping for the daemon to write its PID file */
2878 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2880 service_unwatch_pid_file(s
);
2881 if (s
->state
== SERVICE_START
)
2882 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2884 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
2888 case SERVICE_RUNNING
:
2889 /* service_enter_running() will figure out what to do */
2890 service_enter_running(s
, SERVICE_SUCCESS
);
2893 case SERVICE_STOP_SIGABRT
:
2894 case SERVICE_STOP_SIGTERM
:
2895 case SERVICE_STOP_SIGKILL
:
2897 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
2898 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2902 case SERVICE_STOP_POST
:
2903 case SERVICE_FINAL_SIGTERM
:
2904 case SERVICE_FINAL_SIGKILL
:
2905 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
2906 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2915 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2916 Service
*s
= SERVICE(u
);
2922 if (is_clean_exit(code
, status
, s
->type
== SERVICE_ONESHOT
? EXIT_CLEAN_COMMAND
: EXIT_CLEAN_DAEMON
, &s
->success_status
))
2923 f
= SERVICE_SUCCESS
;
2924 else if (code
== CLD_EXITED
)
2925 f
= SERVICE_FAILURE_EXIT_CODE
;
2926 else if (code
== CLD_KILLED
)
2927 f
= SERVICE_FAILURE_SIGNAL
;
2928 else if (code
== CLD_DUMPED
)
2929 f
= SERVICE_FAILURE_CORE_DUMP
;
2931 assert_not_reached("Unknown code");
2933 if (s
->main_pid
== pid
) {
2934 /* Forking services may occasionally move to a new PID.
2935 * As long as they update the PID file before exiting the old
2936 * PID, they're fine. */
2937 if (service_load_pid_file(s
, false) == 0)
2941 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2943 if (s
->main_command
) {
2944 /* If this is not a forking service than the
2945 * main process got started and hence we copy
2946 * the exit status so that it is recorded both
2947 * as main and as control process exit
2950 s
->main_command
->exec_status
= s
->main_exec_status
;
2952 if (s
->main_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
2953 f
= SERVICE_SUCCESS
;
2954 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
2956 /* If this is a forked process, then we should
2957 * ignore the return value if this was
2958 * configured for the starter process */
2960 if (s
->exec_command
[SERVICE_EXEC_START
]->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
2961 f
= SERVICE_SUCCESS
;
2964 /* When this is a successful exit, let's log about the exit code on DEBUG level. If this is a failure
2965 * and the process exited on its own via exit(), then let's make this a NOTICE, under the assumption
2966 * that the service already logged the reason at a higher log level on its own. However, if the service
2967 * died due to a signal, then it most likely didn't say anything about any reason, hence let's raise
2968 * our log level to WARNING then. */
2970 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
:
2971 (code
== CLD_EXITED
? LOG_NOTICE
: LOG_WARNING
),
2972 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
2973 sigchld_code_to_string(code
), status
,
2974 strna(code
== CLD_EXITED
2975 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
2976 : signal_to_string(status
))),
2977 "EXIT_CODE=%s", sigchld_code_to_string(code
),
2978 "EXIT_STATUS=%i", status
,
2980 LOG_UNIT_INVOCATION_ID(u
),
2983 if (s
->result
== SERVICE_SUCCESS
)
2986 if (s
->main_command
&&
2987 s
->main_command
->command_next
&&
2988 s
->type
== SERVICE_ONESHOT
&&
2989 f
== SERVICE_SUCCESS
) {
2991 /* There is another command to *
2992 * execute, so let's do that. */
2994 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
2995 service_run_next_main(s
);
2999 /* The service exited, so the service is officially
3001 s
->main_command
= NULL
;
3005 case SERVICE_START_POST
:
3006 case SERVICE_RELOAD
:
3008 /* Need to wait until the operation is
3013 if (s
->type
== SERVICE_ONESHOT
) {
3014 /* This was our main goal, so let's go on */
3015 if (f
== SERVICE_SUCCESS
)
3016 service_enter_start_post(s
);
3018 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3020 } else if (s
->type
== SERVICE_NOTIFY
) {
3021 /* Only enter running through a notification, so that the
3022 * SERVICE_START state signifies that no ready notification
3023 * has been received */
3024 if (f
!= SERVICE_SUCCESS
)
3025 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3026 else if (!s
->remain_after_exit
|| s
->notify_access
== NOTIFY_MAIN
)
3027 /* The service has never been and will never be active */
3028 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3033 case SERVICE_RUNNING
:
3034 service_enter_running(s
, f
);
3037 case SERVICE_STOP_SIGABRT
:
3038 case SERVICE_STOP_SIGTERM
:
3039 case SERVICE_STOP_SIGKILL
:
3041 if (control_pid_good(s
) <= 0)
3042 service_enter_stop_post(s
, f
);
3044 /* If there is still a control process, wait for that first */
3047 case SERVICE_STOP_POST
:
3048 case SERVICE_FINAL_SIGTERM
:
3049 case SERVICE_FINAL_SIGKILL
:
3051 if (control_pid_good(s
) <= 0)
3052 service_enter_dead(s
, f
, true);
3056 assert_not_reached("Uh, main process died at wrong time.");
3060 } else if (s
->control_pid
== pid
) {
3063 if (s
->control_command
) {
3064 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
3066 if (s
->control_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3067 f
= SERVICE_SUCCESS
;
3070 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
3071 "Control process exited, code=%s status=%i",
3072 sigchld_code_to_string(code
), status
);
3074 if (s
->result
== SERVICE_SUCCESS
)
3077 if (s
->control_command
&&
3078 s
->control_command
->command_next
&&
3079 f
== SERVICE_SUCCESS
) {
3081 /* There is another command to *
3082 * execute, so let's do that. */
3084 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
3085 service_run_next_control(s
);
3088 /* No further commands for this step, so let's
3089 * figure out what to do next */
3091 s
->control_command
= NULL
;
3092 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
3094 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
3098 case SERVICE_START_PRE
:
3099 if (f
== SERVICE_SUCCESS
)
3100 service_enter_start(s
);
3102 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3106 if (s
->type
!= SERVICE_FORKING
)
3107 /* Maybe spurious event due to a reload that changed the type? */
3110 if (f
!= SERVICE_SUCCESS
) {
3111 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3116 bool has_start_post
;
3119 /* Let's try to load the pid file here if we can.
3120 * The PID file might actually be created by a START_POST
3121 * script. In that case don't worry if the loading fails. */
3123 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
3124 r
= service_load_pid_file(s
, !has_start_post
);
3125 if (!has_start_post
&& r
< 0) {
3126 r
= service_demand_pid_file(s
);
3127 if (r
< 0 || cgroup_good(s
) == 0)
3128 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3132 service_search_main_pid(s
);
3134 service_enter_start_post(s
);
3137 case SERVICE_START_POST
:
3138 if (f
!= SERVICE_SUCCESS
) {
3139 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3146 r
= service_load_pid_file(s
, true);
3148 r
= service_demand_pid_file(s
);
3149 if (r
< 0 || cgroup_good(s
) == 0)
3150 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
3154 service_search_main_pid(s
);
3156 service_enter_running(s
, SERVICE_SUCCESS
);
3159 case SERVICE_RELOAD
:
3160 if (f
== SERVICE_SUCCESS
)
3161 if (service_load_pid_file(s
, true) < 0)
3162 service_search_main_pid(s
);
3164 s
->reload_result
= f
;
3165 service_enter_running(s
, SERVICE_SUCCESS
);
3169 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3172 case SERVICE_STOP_SIGABRT
:
3173 case SERVICE_STOP_SIGTERM
:
3174 case SERVICE_STOP_SIGKILL
:
3175 if (main_pid_good(s
) <= 0)
3176 service_enter_stop_post(s
, f
);
3178 /* If there is still a service
3179 * process around, wait until
3180 * that one quit, too */
3183 case SERVICE_STOP_POST
:
3184 case SERVICE_FINAL_SIGTERM
:
3185 case SERVICE_FINAL_SIGKILL
:
3186 if (main_pid_good(s
) <= 0)
3187 service_enter_dead(s
, f
, true);
3191 assert_not_reached("Uh, control process died at wrong time.");
3196 /* Notify clients about changed exit status */
3197 unit_add_to_dbus_queue(u
);
3199 /* We got one SIGCHLD for the service, let's watch all
3200 * processes that are now running of the service, and watch
3201 * that. Among the PIDs we then watch will be children
3202 * reassigned to us, which hopefully allows us to identify
3203 * when all children are gone */
3204 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
3205 unit_watch_all_pids(u
);
3207 /* If the PID set is empty now, then let's finish this off
3208 (On unified we use proper notifications) */
3209 if (cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER
) == 0 && set_isempty(u
->pids
))
3210 unit_add_to_cgroup_empty_queue(u
);
3213 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3214 Service
*s
= SERVICE(userdata
);
3217 assert(source
== s
->timer_event_source
);
3221 case SERVICE_START_PRE
:
3223 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
3224 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3227 case SERVICE_START_POST
:
3228 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
3229 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3232 case SERVICE_RUNNING
:
3233 log_unit_warning(UNIT(s
), "Service reached runtime time limit. Stopping.");
3234 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
3237 case SERVICE_RELOAD
:
3238 log_unit_warning(UNIT(s
), "Reload operation timed out. Killing reload process.");
3239 service_kill_control_process(s
);
3240 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
3241 service_enter_running(s
, SERVICE_SUCCESS
);
3245 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
3246 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3249 case SERVICE_STOP_SIGABRT
:
3250 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
3251 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3254 case SERVICE_STOP_SIGTERM
:
3255 if (s
->kill_context
.send_sigkill
) {
3256 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
3257 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3259 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
3260 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3265 case SERVICE_STOP_SIGKILL
:
3266 /* Uh, we sent a SIGKILL and it is still not gone?
3267 * Must be something we cannot kill, so let's just be
3268 * weirded out and continue */
3270 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
3271 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3274 case SERVICE_STOP_POST
:
3275 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
3276 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3279 case SERVICE_FINAL_SIGTERM
:
3280 if (s
->kill_context
.send_sigkill
) {
3281 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
3282 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3284 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
3285 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
3290 case SERVICE_FINAL_SIGKILL
:
3291 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
3292 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
3295 case SERVICE_AUTO_RESTART
:
3296 log_unit_info(UNIT(s
),
3297 s
->restart_usec
> 0 ?
3298 "Service hold-off time over, scheduling restart." :
3299 "Service has no hold-off time, scheduling restart.");
3300 service_enter_restart(s
);
3304 assert_not_reached("Timeout at wrong time.");
3310 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3311 Service
*s
= SERVICE(userdata
);
3312 char t
[FORMAT_TIMESPAN_MAX
];
3313 usec_t watchdog_usec
;
3316 assert(source
== s
->watchdog_event_source
);
3318 watchdog_usec
= service_get_watchdog_usec(s
);
3320 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
3321 format_timespan(t
, sizeof(t
), watchdog_usec
, 1));
3323 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
3328 static bool service_notify_message_authorized(Service
*s
, pid_t pid
, char **tags
, FDSet
*fds
) {
3331 if (s
->notify_access
== NOTIFY_NONE
) {
3332 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
3336 if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
3337 if (s
->main_pid
!= 0)
3338 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
3340 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception only permitted for main PID which is currently not known", pid
);
3345 if (s
->notify_access
== NOTIFY_EXEC
&& pid
!= s
->main_pid
&& pid
!= s
->control_pid
) {
3346 if (s
->main_pid
!= 0 && s
->control_pid
!= 0)
3347 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
" and control PID "PID_FMT
,
3348 pid
, s
->main_pid
, s
->control_pid
);
3349 else if (s
->main_pid
!= 0)
3350 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
3351 else if (s
->control_pid
!= 0)
3352 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception only permitted for control PID "PID_FMT
, pid
, s
->control_pid
);
3354 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception only permitted for main PID and control PID which are currently not known", pid
);
3362 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
3363 Service
*s
= SERVICE(u
);
3364 bool notify_dbus
= false;
3370 if (!service_notify_message_authorized(SERVICE(u
), pid
, tags
, fds
))
3373 if (log_get_max_level() >= LOG_DEBUG
) {
3374 _cleanup_free_
char *cc
= NULL
;
3376 cc
= strv_join(tags
, ", ");
3377 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
3380 /* Interpret MAINPID= */
3381 e
= strv_find_startswith(tags
, "MAINPID=");
3382 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
3383 if (parse_pid(e
, &pid
) < 0)
3384 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
3385 else if (pid
== s
->control_pid
)
3386 log_unit_warning(u
, "A control process cannot also be the main process");
3387 else if (pid
== getpid_cached() || pid
== 1)
3388 log_unit_warning(u
, "Service manager can't be main process, ignoring sd_notify() MAINPID= field");
3390 service_set_main_pid(s
, pid
);
3391 unit_watch_pid(UNIT(s
), pid
);
3396 /* Interpret READY=/STOPPING=/RELOADING=. Last one wins. */
3397 STRV_FOREACH_BACKWARDS(i
, tags
) {
3399 if (streq(*i
, "READY=1")) {
3400 s
->notify_state
= NOTIFY_READY
;
3402 /* Type=notify services inform us about completed
3403 * initialization with READY=1 */
3404 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
3405 service_enter_start_post(s
);
3407 /* Sending READY=1 while we are reloading informs us
3408 * that the reloading is complete */
3409 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
3410 service_enter_running(s
, SERVICE_SUCCESS
);
3415 } else if (streq(*i
, "RELOADING=1")) {
3416 s
->notify_state
= NOTIFY_RELOADING
;
3418 if (s
->state
== SERVICE_RUNNING
)
3419 service_enter_reload_by_notify(s
);
3424 } else if (streq(*i
, "STOPPING=1")) {
3425 s
->notify_state
= NOTIFY_STOPPING
;
3427 if (s
->state
== SERVICE_RUNNING
)
3428 service_enter_stop_by_notify(s
);
3435 /* Interpret STATUS= */
3436 e
= strv_find_startswith(tags
, "STATUS=");
3438 _cleanup_free_
char *t
= NULL
;
3441 if (!utf8_is_valid(e
))
3442 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3450 if (!streq_ptr(s
->status_text
, t
)) {
3451 free_and_replace(s
->status_text
, t
);
3456 /* Interpret ERRNO= */
3457 e
= strv_find_startswith(tags
, "ERRNO=");
3461 if (safe_atoi(e
, &status_errno
) < 0 || status_errno
< 0)
3462 log_unit_warning(u
, "Failed to parse ERRNO= field in notification message: %s", e
);
3464 if (s
->status_errno
!= status_errno
) {
3465 s
->status_errno
= status_errno
;
3471 /* Interpret WATCHDOG= */
3472 if (strv_find(tags
, "WATCHDOG=1"))
3473 service_reset_watchdog(s
);
3475 e
= strv_find_startswith(tags
, "WATCHDOG_USEC=");
3477 usec_t watchdog_override_usec
;
3478 if (safe_atou64(e
, &watchdog_override_usec
) < 0)
3479 log_unit_warning(u
, "Failed to parse WATCHDOG_USEC=%s", e
);
3481 service_reset_watchdog_timeout(s
, watchdog_override_usec
);
3484 /* Process FD store messages. Either FDSTOREREMOVE=1 for removal, or FDSTORE=1 for addition. In both cases,
3485 * process FDNAME= for picking the file descriptor name to use. Note that FDNAME= is required when removing
3486 * fds, but optional when pushing in new fds, for compatibility reasons. */
3487 if (strv_find(tags
, "FDSTOREREMOVE=1")) {
3490 name
= strv_find_startswith(tags
, "FDNAME=");
3491 if (!name
|| !fdname_is_valid(name
))
3492 log_unit_warning(u
, "FDSTOREREMOVE=1 requested, but no valid file descriptor name passed, ignoring.");
3494 service_remove_fd_store(s
, name
);
3496 } else if (strv_find(tags
, "FDSTORE=1")) {
3499 name
= strv_find_startswith(tags
, "FDNAME=");
3500 if (name
&& !fdname_is_valid(name
)) {
3501 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3505 (void) service_add_fd_store_set(s
, fds
, name
);
3508 /* Notify clients about changed status or main pid */
3510 unit_add_to_dbus_queue(u
);
3513 static int service_get_timeout(Unit
*u
, usec_t
*timeout
) {
3514 Service
*s
= SERVICE(u
);
3518 if (!s
->timer_event_source
)
3521 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
3524 if (t
== USEC_INFINITY
)
3531 static void service_bus_name_owner_change(
3534 const char *old_owner
,
3535 const char *new_owner
) {
3537 Service
*s
= SERVICE(u
);
3543 assert(streq(s
->bus_name
, name
));
3544 assert(old_owner
|| new_owner
);
3546 if (old_owner
&& new_owner
)
3547 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3549 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3551 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3553 s
->bus_name_good
= !!new_owner
;
3555 /* Track the current owner, so we can reconstruct changes after a daemon reload */
3556 r
= free_and_strdup(&s
->bus_name_owner
, new_owner
);
3558 log_unit_error_errno(u
, r
, "Unable to set new bus name owner %s: %m", new_owner
);
3562 if (s
->type
== SERVICE_DBUS
) {
3564 /* service_enter_running() will figure out what to
3566 if (s
->state
== SERVICE_RUNNING
)
3567 service_enter_running(s
, SERVICE_SUCCESS
);
3568 else if (s
->state
== SERVICE_START
&& new_owner
)
3569 service_enter_start_post(s
);
3571 } else if (new_owner
&&
3579 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
3582 /* Try to acquire PID from bus service */
3584 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3586 r
= sd_bus_creds_get_pid(creds
, &pid
);
3588 log_unit_debug(u
, "D-Bus name %s is now owned by process " PID_FMT
, name
, pid
);
3590 service_set_main_pid(s
, pid
);
3591 unit_watch_pid(UNIT(s
), pid
);
3596 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3597 _cleanup_free_
char *peer
= NULL
;
3603 /* This is called by the socket code when instantiating a new service for a stream socket and the socket needs
3604 * to be configured. We take ownership of the passed fd on success. */
3606 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3609 if (s
->socket_fd
>= 0)
3612 if (s
->state
!= SERVICE_DEAD
)
3615 if (getpeername_pretty(fd
, true, &peer
) >= 0) {
3617 if (UNIT(s
)->description
) {
3618 _cleanup_free_
char *a
;
3620 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")");
3624 r
= unit_set_description(UNIT(s
), a
);
3626 r
= unit_set_description(UNIT(s
), peer
);
3632 r
= unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false, UNIT_DEPENDENCY_IMPLICIT
);
3637 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3639 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3643 static void service_reset_failed(Unit
*u
) {
3644 Service
*s
= SERVICE(u
);
3648 if (s
->state
== SERVICE_FAILED
)
3649 service_set_state(s
, SERVICE_DEAD
);
3651 s
->result
= SERVICE_SUCCESS
;
3652 s
->reload_result
= SERVICE_SUCCESS
;
3654 s
->flush_n_restarts
= false;
3657 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3658 Service
*s
= SERVICE(u
);
3662 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3665 static int service_main_pid(Unit
*u
) {
3666 Service
*s
= SERVICE(u
);
3673 static int service_control_pid(Unit
*u
) {
3674 Service
*s
= SERVICE(u
);
3678 return s
->control_pid
;
3681 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3682 [SERVICE_RESTART_NO
] = "no",
3683 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3684 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3685 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3686 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3687 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3688 [SERVICE_RESTART_ALWAYS
] = "always",
3691 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3693 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3694 [SERVICE_SIMPLE
] = "simple",
3695 [SERVICE_FORKING
] = "forking",
3696 [SERVICE_ONESHOT
] = "oneshot",
3697 [SERVICE_DBUS
] = "dbus",
3698 [SERVICE_NOTIFY
] = "notify",
3699 [SERVICE_IDLE
] = "idle"
3702 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3704 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3705 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3706 [SERVICE_EXEC_START
] = "ExecStart",
3707 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3708 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3709 [SERVICE_EXEC_STOP
] = "ExecStop",
3710 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3713 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3715 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3716 [NOTIFY_UNKNOWN
] = "unknown",
3717 [NOTIFY_READY
] = "ready",
3718 [NOTIFY_RELOADING
] = "reloading",
3719 [NOTIFY_STOPPING
] = "stopping",
3722 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3724 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3725 [SERVICE_SUCCESS
] = "success",
3726 [SERVICE_FAILURE_RESOURCES
] = "resources",
3727 [SERVICE_FAILURE_PROTOCOL
] = "protocol",
3728 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3729 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3730 [SERVICE_FAILURE_SIGNAL
] = "signal",
3731 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3732 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3733 [SERVICE_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
3736 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3738 const UnitVTable service_vtable
= {
3739 .object_size
= sizeof(Service
),
3740 .exec_context_offset
= offsetof(Service
, exec_context
),
3741 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3742 .kill_context_offset
= offsetof(Service
, kill_context
),
3743 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3744 .dynamic_creds_offset
= offsetof(Service
, dynamic_creds
),
3750 .private_section
= "Service",
3752 .init
= service_init
,
3753 .done
= service_done
,
3754 .load
= service_load
,
3755 .release_resources
= service_release_resources
,
3757 .coldplug
= service_coldplug
,
3759 .dump
= service_dump
,
3761 .start
= service_start
,
3762 .stop
= service_stop
,
3763 .reload
= service_reload
,
3765 .can_reload
= service_can_reload
,
3767 .kill
= service_kill
,
3769 .serialize
= service_serialize
,
3770 .deserialize_item
= service_deserialize_item
,
3772 .active_state
= service_active_state
,
3773 .sub_state_to_string
= service_sub_state_to_string
,
3775 .check_gc
= service_check_gc
,
3777 .sigchld_event
= service_sigchld_event
,
3779 .reset_failed
= service_reset_failed
,
3781 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3782 .notify_message
= service_notify_message
,
3784 .main_pid
= service_main_pid
,
3785 .control_pid
= service_control_pid
,
3787 .bus_name_owner_change
= service_bus_name_owner_change
,
3789 .bus_vtable
= bus_service_vtable
,
3790 .bus_set_property
= bus_service_set_property
,
3791 .bus_commit_properties
= bus_service_commit_properties
,
3793 .get_timeout
= service_get_timeout
,
3794 .can_transient
= true,
3796 .status_message_formats
= {
3797 .starting_stopping
= {
3798 [0] = "Starting %s...",
3799 [1] = "Stopping %s...",
3801 .finished_start_job
= {
3802 [JOB_DONE
] = "Started %s.",
3803 [JOB_FAILED
] = "Failed to start %s.",
3805 .finished_stop_job
= {
3806 [JOB_DONE
] = "Stopped %s.",
3807 [JOB_FAILED
] = "Stopped (with error) %s.",