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_extend_timeout(Service
*s
, usec_t extend_timeout_usec
) {
259 if (s
->timer_event_source
) {
260 uint64_t current
= 0, extended
= 0;
263 if (IN_SET(extend_timeout_usec
, 0, USEC_INFINITY
))
266 extended
= usec_add(now(CLOCK_MONOTONIC
), extend_timeout_usec
);
268 r
= sd_event_source_get_time(s
->timer_event_source
, ¤t
);
270 log_unit_error_errno(UNIT(s
), r
, "Failed to retrieve timeout timer: %m");
271 else if (extended
> current
) {
272 r
= sd_event_source_set_time(s
->timer_event_source
, extended
);
274 log_unit_warning_errno(UNIT(s
), r
, "Failed to set timeout timer: %m");
277 if (s
->watchdog_event_source
) {
278 /* extend watchdog if necessary. We've asked for an extended timeout so we
279 * shouldn't expect a watchdog timeout in the interval in between */
280 r
= sd_event_source_get_time(s
->watchdog_event_source
, ¤t
);
282 log_unit_error_errno(UNIT(s
), r
, "Failed to retrieve watchdog timer: %m");
286 if (extended
> current
) {
287 r
= sd_event_source_set_time(s
->watchdog_event_source
, extended
);
289 log_unit_warning_errno(UNIT(s
), r
, "Failed to set watchdog timer: %m");
295 static void service_reset_watchdog(Service
*s
) {
298 dual_timestamp_get(&s
->watchdog_timestamp
);
299 service_start_watchdog(s
);
302 static void service_reset_watchdog_timeout(Service
*s
, usec_t watchdog_override_usec
) {
305 s
->watchdog_override_enable
= true;
306 s
->watchdog_override_usec
= watchdog_override_usec
;
307 service_reset_watchdog(s
);
309 log_unit_debug(UNIT(s
), "watchdog_usec="USEC_FMT
, s
->watchdog_usec
);
310 log_unit_debug(UNIT(s
), "watchdog_override_usec="USEC_FMT
, s
->watchdog_override_usec
);
313 static void service_fd_store_unlink(ServiceFDStore
*fs
) {
319 assert(fs
->service
->n_fd_store
> 0);
320 LIST_REMOVE(fd_store
, fs
->service
->fd_store
, fs
);
321 fs
->service
->n_fd_store
--;
324 if (fs
->event_source
) {
325 sd_event_source_set_enabled(fs
->event_source
, SD_EVENT_OFF
);
326 sd_event_source_unref(fs
->event_source
);
334 static void service_release_fd_store(Service
*s
) {
337 if (s
->n_keep_fd_store
> 0)
340 log_unit_debug(UNIT(s
), "Releasing all stored fds");
342 service_fd_store_unlink(s
->fd_store
);
344 assert(s
->n_fd_store
== 0);
347 static void service_release_resources(Unit
*u
) {
348 Service
*s
= SERVICE(u
);
352 if (!s
->fd_store
&& s
->stdin_fd
< 0 && s
->stdout_fd
< 0 && s
->stderr_fd
< 0)
355 log_unit_debug(u
, "Releasing resources.");
357 s
->stdin_fd
= safe_close(s
->stdin_fd
);
358 s
->stdout_fd
= safe_close(s
->stdout_fd
);
359 s
->stderr_fd
= safe_close(s
->stderr_fd
);
361 service_release_fd_store(s
);
364 static void service_done(Unit
*u
) {
365 Service
*s
= SERVICE(u
);
369 s
->pid_file
= mfree(s
->pid_file
);
370 s
->status_text
= mfree(s
->status_text
);
372 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
373 exec_command_free_array(s
->exec_command
, _SERVICE_EXEC_COMMAND_MAX
);
374 s
->control_command
= NULL
;
375 s
->main_command
= NULL
;
377 dynamic_creds_unref(&s
->dynamic_creds
);
379 exit_status_set_free(&s
->restart_prevent_status
);
380 exit_status_set_free(&s
->restart_force_status
);
381 exit_status_set_free(&s
->success_status
);
383 /* This will leak a process, but at least no memory or any of
385 service_unwatch_main_pid(s
);
386 service_unwatch_control_pid(s
);
387 service_unwatch_pid_file(s
);
390 unit_unwatch_bus_name(u
, s
->bus_name
);
391 s
->bus_name
= mfree(s
->bus_name
);
394 s
->bus_name_owner
= mfree(s
->bus_name_owner
);
396 service_close_socket_fd(s
);
397 s
->peer
= socket_peer_unref(s
->peer
);
399 unit_ref_unset(&s
->accept_socket
);
401 service_stop_watchdog(s
);
403 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
405 service_release_resources(u
);
408 static int on_fd_store_io(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
409 ServiceFDStore
*fs
= userdata
;
414 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
415 log_unit_debug(UNIT(fs
->service
),
416 "Received %s on stored fd %d (%s), closing.",
417 revents
& EPOLLERR
? "EPOLLERR" : "EPOLLHUP",
418 fs
->fd
, strna(fs
->fdname
));
419 service_fd_store_unlink(fs
);
423 static int service_add_fd_store(Service
*s
, int fd
, const char *name
) {
427 /* fd is always consumed if we return >= 0 */
432 if (s
->n_fd_store
>= s
->n_fd_store_max
)
433 return -EXFULL
; /* Our store is full.
434 * Use this errno rather than E[NM]FILE to distinguish from
435 * the case where systemd itself hits the file limit. */
437 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
438 r
= same_fd(fs
->fd
, fd
);
443 return 0; /* fd already included */
447 fs
= new0(ServiceFDStore
, 1);
453 fs
->fdname
= strdup(name
?: "stored");
459 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &fs
->event_source
, fd
, 0, on_fd_store_io
, fs
);
460 if (r
< 0 && r
!= -EPERM
) { /* EPERM indicates fds that aren't pollable, which is OK */
465 (void) sd_event_source_set_description(fs
->event_source
, "service-fd-store");
467 LIST_PREPEND(fd_store
, s
->fd_store
, fs
);
470 return 1; /* fd newly stored */
473 static int service_add_fd_store_set(Service
*s
, FDSet
*fds
, const char *name
) {
478 while (fdset_size(fds
) > 0) {
479 _cleanup_close_
int fd
= -1;
481 fd
= fdset_steal_first(fds
);
485 r
= service_add_fd_store(s
, fd
, name
);
487 return log_unit_warning_errno(UNIT(s
), r
,
488 "Cannot store more fds than FileDescriptorStoreMax=%u, closing remaining.",
491 return log_unit_error_errno(UNIT(s
), r
, "Failed to add fd to store: %m");
493 log_unit_debug(UNIT(s
), "Added fd %u (%s) to fd store.", fd
, strna(name
));
500 static void service_remove_fd_store(Service
*s
, const char *name
) {
501 ServiceFDStore
*fs
, *n
;
506 LIST_FOREACH_SAFE(fd_store
, fs
, n
, s
->fd_store
) {
507 if (!streq(fs
->fdname
, name
))
510 log_unit_debug(UNIT(s
), "Got explicit request to remove fd %i (%s), closing.", fs
->fd
, name
);
511 service_fd_store_unlink(fs
);
515 static int service_arm_timer(Service
*s
, usec_t usec
) {
520 if (s
->timer_event_source
) {
521 r
= sd_event_source_set_time(s
->timer_event_source
, usec
);
525 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
528 if (usec
== USEC_INFINITY
)
531 r
= sd_event_add_time(
532 UNIT(s
)->manager
->event
,
533 &s
->timer_event_source
,
536 service_dispatch_timer
, s
);
540 (void) sd_event_source_set_description(s
->timer_event_source
, "service-timer");
545 static int service_verify(Service
*s
) {
548 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
551 if (!s
->exec_command
[SERVICE_EXEC_START
] && !s
->exec_command
[SERVICE_EXEC_STOP
]) {
552 log_unit_error(UNIT(s
), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
556 if (s
->type
!= SERVICE_ONESHOT
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
557 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
561 if (!s
->remain_after_exit
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
562 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
566 if (s
->type
!= SERVICE_ONESHOT
&& s
->exec_command
[SERVICE_EXEC_START
]->command_next
) {
567 log_unit_error(UNIT(s
), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
571 if (s
->type
== SERVICE_ONESHOT
&& s
->restart
!= SERVICE_RESTART_NO
) {
572 log_unit_error(UNIT(s
), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
576 if (s
->type
== SERVICE_ONESHOT
&& !exit_status_set_is_empty(&s
->restart_force_status
)) {
577 log_unit_error(UNIT(s
), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
581 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name
) {
582 log_unit_error(UNIT(s
), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
586 if (s
->bus_name
&& s
->type
!= SERVICE_DBUS
)
587 log_unit_warning(UNIT(s
), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
589 if (s
->exec_context
.pam_name
&& !IN_SET(s
->kill_context
.kill_mode
, KILL_CONTROL_GROUP
, KILL_MIXED
)) {
590 log_unit_error(UNIT(s
), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
594 if (s
->usb_function_descriptors
&& !s
->usb_function_strings
)
595 log_unit_warning(UNIT(s
), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
597 if (!s
->usb_function_descriptors
&& s
->usb_function_strings
)
598 log_unit_warning(UNIT(s
), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
600 if (s
->runtime_max_usec
!= USEC_INFINITY
&& s
->type
== SERVICE_ONESHOT
)
601 log_unit_warning(UNIT(s
), "MaxRuntimeSec= has no effect in combination with Type=oneshot. Ignoring.");
606 static int service_add_default_dependencies(Service
*s
) {
611 if (!UNIT(s
)->default_dependencies
)
614 /* Add a number of automatic dependencies useful for the
615 * majority of services. */
617 if (MANAGER_IS_SYSTEM(UNIT(s
)->manager
)) {
618 /* First, pull in the really early boot stuff, and
619 * require it, so that we fail if we can't acquire
622 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
627 /* In the --user instance there's no sysinit.target,
628 * in that case require basic.target instead. */
630 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_BASIC_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
635 /* Second, if the rest of the base system is in the same
636 * transaction, order us after it, but do not pull it in or
637 * even require it. */
638 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_BASIC_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
642 /* Third, add us in for normal shutdown. */
643 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
646 static void service_fix_output(Service
*s
) {
649 /* If nothing has been explicitly configured, patch default output in. If input is socket/tty we avoid this
650 * however, since in that case we want output to default to the same place as we read input from. */
652 if (s
->exec_context
.std_error
== EXEC_OUTPUT_INHERIT
&&
653 s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
654 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
655 s
->exec_context
.std_error
= UNIT(s
)->manager
->default_std_error
;
657 if (s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
658 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
659 s
->exec_context
.std_output
= UNIT(s
)->manager
->default_std_output
;
661 if (s
->exec_context
.std_input
== EXEC_INPUT_NULL
&&
662 s
->exec_context
.stdin_data_size
> 0)
663 s
->exec_context
.std_input
= EXEC_INPUT_DATA
;
666 static int service_setup_bus_name(Service
*s
) {
674 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_DBUS_SOCKET
, NULL
, true, UNIT_DEPENDENCY_FILE
);
676 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
678 /* We always want to be ordered against dbus.socket if both are in the transaction. */
679 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_DBUS_SOCKET
, NULL
, true, UNIT_DEPENDENCY_FILE
);
681 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
683 r
= unit_watch_bus_name(UNIT(s
), s
->bus_name
);
685 return log_unit_error_errno(UNIT(s
), r
, "Two services allocated for the same bus name %s, refusing operation.", s
->bus_name
);
687 return log_unit_error_errno(UNIT(s
), r
, "Cannot watch bus name %s: %m", s
->bus_name
);
692 static int service_add_extras(Service
*s
) {
697 if (s
->type
== _SERVICE_TYPE_INVALID
) {
698 /* Figure out a type automatically */
700 s
->type
= SERVICE_DBUS
;
701 else if (s
->exec_command
[SERVICE_EXEC_START
])
702 s
->type
= SERVICE_SIMPLE
;
704 s
->type
= SERVICE_ONESHOT
;
707 /* Oneshot services have disabled start timeout by default */
708 if (s
->type
== SERVICE_ONESHOT
&& !s
->start_timeout_defined
)
709 s
->timeout_start_usec
= USEC_INFINITY
;
711 service_fix_output(s
);
713 r
= unit_patch_contexts(UNIT(s
));
717 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
721 r
= unit_set_default_slice(UNIT(s
));
725 if (s
->type
== SERVICE_NOTIFY
&& s
->notify_access
== NOTIFY_NONE
)
726 s
->notify_access
= NOTIFY_MAIN
;
728 if (s
->watchdog_usec
> 0 && s
->notify_access
== NOTIFY_NONE
)
729 s
->notify_access
= NOTIFY_MAIN
;
731 r
= service_add_default_dependencies(s
);
735 r
= service_setup_bus_name(s
);
742 static int service_load(Unit
*u
) {
743 Service
*s
= SERVICE(u
);
748 /* Load a .service file */
749 r
= unit_load_fragment(u
);
753 /* Still nothing found? Then let's give up */
754 if (u
->load_state
== UNIT_STUB
)
757 /* This is a new unit? Then let's add in some extras */
758 if (u
->load_state
== UNIT_LOADED
) {
760 /* We were able to load something, then let's add in
761 * the dropin directories. */
762 r
= unit_load_dropin(u
);
766 /* This is a new unit? Then let's add in some
768 r
= service_add_extras(s
);
773 return service_verify(s
);
776 static void service_dump(Unit
*u
, FILE *f
, const char *prefix
) {
777 ServiceExecCommand c
;
778 Service
*s
= SERVICE(u
);
783 prefix
= strempty(prefix
);
784 prefix2
= strjoina(prefix
, "\t");
787 "%sService State: %s\n"
789 "%sReload Result: %s\n"
790 "%sPermissionsStartOnly: %s\n"
791 "%sRootDirectoryStartOnly: %s\n"
792 "%sRemainAfterExit: %s\n"
793 "%sGuessMainPID: %s\n"
796 "%sNotifyAccess: %s\n"
797 "%sNotifyState: %s\n",
798 prefix
, service_state_to_string(s
->state
),
799 prefix
, service_result_to_string(s
->result
),
800 prefix
, service_result_to_string(s
->reload_result
),
801 prefix
, yes_no(s
->permissions_start_only
),
802 prefix
, yes_no(s
->root_directory_start_only
),
803 prefix
, yes_no(s
->remain_after_exit
),
804 prefix
, yes_no(s
->guess_main_pid
),
805 prefix
, service_type_to_string(s
->type
),
806 prefix
, service_restart_to_string(s
->restart
),
807 prefix
, notify_access_to_string(s
->notify_access
),
808 prefix
, notify_state_to_string(s
->notify_state
));
810 if (s
->control_pid
> 0)
812 "%sControl PID: "PID_FMT
"\n",
813 prefix
, s
->control_pid
);
817 "%sMain PID: "PID_FMT
"\n"
818 "%sMain PID Known: %s\n"
819 "%sMain PID Alien: %s\n",
821 prefix
, yes_no(s
->main_pid_known
),
822 prefix
, yes_no(s
->main_pid_alien
));
827 prefix
, s
->pid_file
);
832 "%sBus Name Good: %s\n",
834 prefix
, yes_no(s
->bus_name_good
));
836 if (UNIT_ISSET(s
->accept_socket
))
838 "%sAccept Socket: %s\n",
839 prefix
, UNIT_DEREF(s
->accept_socket
)->id
);
841 kill_context_dump(&s
->kill_context
, f
, prefix
);
842 exec_context_dump(&s
->exec_context
, f
, prefix
);
844 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
846 if (!s
->exec_command
[c
])
849 fprintf(f
, "%s-> %s:\n",
850 prefix
, service_exec_command_to_string(c
));
852 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
856 fprintf(f
, "%sStatus Text: %s\n",
857 prefix
, s
->status_text
);
859 if (s
->n_fd_store_max
> 0)
861 "%sFile Descriptor Store Max: %u\n"
862 "%sFile Descriptor Store Current: %u\n",
863 prefix
, s
->n_fd_store_max
,
864 prefix
, s
->n_fd_store
);
866 cgroup_context_dump(&s
->cgroup_context
, f
, prefix
);
869 static int service_load_pid_file(Service
*s
, bool may_warn
) {
870 _cleanup_free_
char *k
= NULL
;
879 r
= read_one_line_file(s
->pid_file
, &k
);
882 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
));
886 r
= parse_pid(k
, &pid
);
889 log_unit_info_errno(UNIT(s
), r
, "Failed to read PID from file %s: %m", s
->pid_file
);
893 if (!pid_is_alive(pid
)) {
895 log_unit_info(UNIT(s
), "PID "PID_FMT
" read from file %s does not exist or is a zombie.", pid
, s
->pid_file
);
899 if (s
->main_pid_known
) {
900 if (pid
== s
->main_pid
)
903 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
905 service_unwatch_main_pid(s
);
906 s
->main_pid_known
= false;
908 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
910 r
= service_set_main_pid(s
, pid
);
914 r
= unit_watch_pid(UNIT(s
), pid
);
915 if (r
< 0) /* FIXME: we need to do something here */
916 return log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
921 static void service_search_main_pid(Service
*s
) {
927 /* If we know it anyway, don't ever fallback to unreliable
929 if (s
->main_pid_known
)
932 if (!s
->guess_main_pid
)
935 assert(s
->main_pid
<= 0);
937 if (unit_search_main_pid(UNIT(s
), &pid
) < 0)
940 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
941 if (service_set_main_pid(s
, pid
) < 0)
944 r
= unit_watch_pid(UNIT(s
), pid
);
946 /* FIXME: we need to do something here */
947 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
950 static void service_set_state(Service
*s
, ServiceState state
) {
951 ServiceState old_state
;
952 const UnitActiveState
*table
;
956 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
958 old_state
= s
->state
;
961 service_unwatch_pid_file(s
);
964 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
967 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
968 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
969 SERVICE_AUTO_RESTART
))
970 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
973 SERVICE_START
, SERVICE_START_POST
,
974 SERVICE_RUNNING
, SERVICE_RELOAD
,
975 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
976 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
977 service_unwatch_main_pid(s
);
978 s
->main_command
= NULL
;
982 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
984 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
985 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
986 service_unwatch_control_pid(s
);
987 s
->control_command
= NULL
;
988 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
991 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
992 unit_unwatch_all_pids(UNIT(s
));
995 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
996 SERVICE_RUNNING
, SERVICE_RELOAD
,
997 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
998 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
999 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
))
1000 service_close_socket_fd(s
);
1002 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
1003 service_stop_watchdog(s
);
1005 /* For the inactive states unit_notify() will trim the cgroup,
1006 * but for exit we have to do that ourselves... */
1007 if (state
== SERVICE_EXITED
&& !MANAGER_IS_RELOADING(UNIT(s
)->manager
))
1008 unit_prune_cgroup(UNIT(s
));
1010 /* For remain_after_exit services, let's see if we can "release" the
1011 * hold on the console, since unit_notify() only does that in case of
1012 * change of state */
1013 if (state
== SERVICE_EXITED
&&
1014 s
->remain_after_exit
&&
1015 UNIT(s
)->manager
->n_on_console
> 0) {
1019 ec
= unit_get_exec_context(UNIT(s
));
1020 if (ec
&& exec_context_may_touch_console(ec
)) {
1021 Manager
*m
= UNIT(s
)->manager
;
1024 if (m
->n_on_console
== 0)
1025 /* unset no_console_output flag, since the console is free */
1026 m
->no_console_output
= false;
1030 if (old_state
!= state
)
1031 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
1033 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
1036 static usec_t
service_coldplug_timeout(Service
*s
) {
1039 switch (s
->deserialized_state
) {
1041 case SERVICE_START_PRE
:
1043 case SERVICE_START_POST
:
1044 case SERVICE_RELOAD
:
1045 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_start_usec
);
1047 case SERVICE_RUNNING
:
1048 return usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
);
1051 case SERVICE_STOP_SIGABRT
:
1052 case SERVICE_STOP_SIGTERM
:
1053 case SERVICE_STOP_SIGKILL
:
1054 case SERVICE_STOP_POST
:
1055 case SERVICE_FINAL_SIGTERM
:
1056 case SERVICE_FINAL_SIGKILL
:
1057 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_stop_usec
);
1059 case SERVICE_AUTO_RESTART
:
1060 return usec_add(UNIT(s
)->inactive_enter_timestamp
.monotonic
, s
->restart_usec
);
1063 return USEC_INFINITY
;
1067 static int service_coldplug(Unit
*u
) {
1068 Service
*s
= SERVICE(u
);
1072 assert(s
->state
== SERVICE_DEAD
);
1074 if (s
->deserialized_state
== s
->state
)
1077 r
= service_arm_timer(s
, service_coldplug_timeout(s
));
1081 if (s
->main_pid
> 0 &&
1082 pid_is_unwaited(s
->main_pid
) &&
1083 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
1084 IN_SET(s
->deserialized_state
,
1085 SERVICE_START
, SERVICE_START_POST
,
1086 SERVICE_RUNNING
, SERVICE_RELOAD
,
1087 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1088 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
1089 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
1094 if (s
->control_pid
> 0 &&
1095 pid_is_unwaited(s
->control_pid
) &&
1096 IN_SET(s
->deserialized_state
,
1097 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1099 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1100 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
1101 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1106 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1107 unit_watch_all_pids(UNIT(s
));
1109 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
1110 service_start_watchdog(s
);
1112 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1113 (void) unit_setup_dynamic_creds(u
);
1115 if (UNIT_ISSET(s
->accept_socket
)) {
1116 Socket
* socket
= SOCKET(UNIT_DEREF(s
->accept_socket
));
1118 if (socket
->max_connections_per_source
> 0) {
1121 /* Make a best-effort attempt at bumping the connection count */
1122 if (socket_acquire_peer(socket
, s
->socket_fd
, &peer
) > 0) {
1123 socket_peer_unref(s
->peer
);
1129 service_set_state(s
, s
->deserialized_state
);
1133 static int service_collect_fds(Service
*s
,
1136 unsigned *n_storage_fds
,
1137 unsigned *n_socket_fds
) {
1139 _cleanup_strv_free_
char **rfd_names
= NULL
;
1140 _cleanup_free_
int *rfds
= NULL
;
1141 unsigned rn_socket_fds
= 0, rn_storage_fds
= 0;
1147 assert(n_socket_fds
);
1149 if (s
->socket_fd
>= 0) {
1151 /* Pass the per-connection socket */
1156 rfds
[0] = s
->socket_fd
;
1158 rfd_names
= strv_new("connection", NULL
);
1168 /* Pass all our configured sockets for singleton services */
1170 HASHMAP_FOREACH_KEY(v
, u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1171 _cleanup_free_
int *cfds
= NULL
;
1175 if (u
->type
!= UNIT_SOCKET
)
1180 cn_fds
= socket_collect_fds(sock
, &cfds
);
1189 rn_socket_fds
= cn_fds
;
1195 t
= realloc(rfds
, (rn_socket_fds
+ cn_fds
) * sizeof(int));
1199 memcpy(t
+ rn_socket_fds
, cfds
, cn_fds
* sizeof(int));
1202 rn_socket_fds
+= cn_fds
;
1205 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1211 if (s
->n_fd_store
> 0) {
1217 t
= realloc(rfds
, (rn_socket_fds
+ s
->n_fd_store
) * sizeof(int));
1223 nl
= realloc(rfd_names
, (rn_socket_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1228 n_fds
= rn_socket_fds
;
1230 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1231 rfds
[n_fds
] = fs
->fd
;
1232 rfd_names
[n_fds
] = strdup(strempty(fs
->fdname
));
1233 if (!rfd_names
[n_fds
])
1240 rfd_names
[n_fds
] = NULL
;
1244 *fd_names
= rfd_names
;
1245 *n_socket_fds
= rn_socket_fds
;
1246 *n_storage_fds
= rn_storage_fds
;
1254 static bool service_exec_needs_notify_socket(Service
*s
, ExecFlags flags
) {
1257 /* Notifications are accepted depending on the process and
1258 * the access setting of the service:
1259 * process: \ access: NONE MAIN EXEC ALL
1260 * main no yes yes yes
1261 * control no no yes yes
1262 * other (forked) no no no yes */
1264 if (flags
& EXEC_IS_CONTROL
)
1265 /* A control process */
1266 return IN_SET(s
->notify_access
, NOTIFY_EXEC
, NOTIFY_ALL
);
1268 /* We only spawn main processes and control processes, so any
1269 * process that is not a control process is a main process */
1270 return s
->notify_access
!= NOTIFY_NONE
;
1273 static int service_spawn(
1280 ExecParameters exec_params
= {
1286 _cleanup_strv_free_
char **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1287 unsigned n_storage_fds
= 0, n_socket_fds
= 0, n_env
= 0;
1288 _cleanup_free_
int *fds
= NULL
;
1296 r
= unit_prepare_exec(UNIT(s
));
1300 if (flags
& EXEC_IS_CONTROL
) {
1301 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1302 if (s
->permissions_start_only
)
1303 exec_params
.flags
&= ~EXEC_APPLY_SANDBOXING
;
1304 if (s
->root_directory_start_only
)
1305 exec_params
.flags
&= ~EXEC_APPLY_CHROOT
;
1308 if ((flags
& EXEC_PASS_FDS
) ||
1309 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1310 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1311 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1313 r
= service_collect_fds(s
, &fds
, &fd_names
, &n_storage_fds
, &n_socket_fds
);
1317 log_unit_debug(UNIT(s
), "Passing %i fds to service", n_storage_fds
+ n_socket_fds
);
1320 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), timeout
));
1324 our_env
= new0(char*, 9);
1328 if (service_exec_needs_notify_socket(s
, flags
))
1329 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0)
1332 if (s
->main_pid
> 0)
1333 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0)
1336 if (MANAGER_IS_USER(UNIT(s
)->manager
))
1337 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid_cached()) < 0)
1340 if (s
->socket_fd
>= 0) {
1341 union sockaddr_union sa
;
1342 socklen_t salen
= sizeof(sa
);
1344 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1345 * useful. Note that we do this only when we are still connected at this point in time, which we might
1346 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1347 * in ENOTCONN), and just use whate we can use. */
1349 if (getpeername(s
->socket_fd
, &sa
.sa
, &salen
) >= 0 &&
1350 IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
, AF_VSOCK
)) {
1352 _cleanup_free_
char *addr
= NULL
;
1356 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1360 t
= strappend("REMOTE_ADDR=", addr
);
1363 our_env
[n_env
++] = t
;
1365 r
= sockaddr_port(&sa
.sa
, &port
);
1369 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0)
1371 our_env
[n_env
++] = t
;
1375 if (flags
& EXEC_SETENV_RESULT
) {
1376 if (asprintf(our_env
+ n_env
++, "SERVICE_RESULT=%s", service_result_to_string(s
->result
)) < 0)
1379 if (s
->main_exec_status
.pid
> 0 &&
1380 dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
1381 if (asprintf(our_env
+ n_env
++, "EXIT_CODE=%s", sigchld_code_to_string(s
->main_exec_status
.code
)) < 0)
1384 if (s
->main_exec_status
.code
== CLD_EXITED
)
1385 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%i", s
->main_exec_status
.status
);
1387 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%s", signal_to_string(s
->main_exec_status
.status
));
1393 manager_set_exec_params(UNIT(s
)->manager
, &exec_params
);
1394 unit_set_exec_params(UNIT(s
), &exec_params
);
1396 final_env
= strv_env_merge(2, exec_params
.environment
, our_env
, NULL
);
1400 /* System services should get a new keyring by default. */
1401 SET_FLAG(exec_params
.flags
, EXEC_NEW_KEYRING
, MANAGER_IS_SYSTEM(UNIT(s
)->manager
));
1403 /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1404 SET_FLAG(exec_params
.flags
, EXEC_NSS_BYPASS_BUS
,
1405 MANAGER_IS_SYSTEM(UNIT(s
)->manager
) && unit_has_name(UNIT(s
), SPECIAL_DBUS_SERVICE
));
1407 exec_params
.argv
= c
->argv
;
1408 exec_params
.environment
= final_env
;
1409 exec_params
.fds
= fds
;
1410 exec_params
.fd_names
= fd_names
;
1411 exec_params
.n_storage_fds
= n_storage_fds
;
1412 exec_params
.n_socket_fds
= n_socket_fds
;
1413 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1414 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1415 if (s
->type
== SERVICE_IDLE
)
1416 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1417 exec_params
.stdin_fd
= s
->stdin_fd
;
1418 exec_params
.stdout_fd
= s
->stdout_fd
;
1419 exec_params
.stderr_fd
= s
->stderr_fd
;
1421 r
= exec_spawn(UNIT(s
),
1431 r
= unit_watch_pid(UNIT(s
), pid
);
1432 if (r
< 0) /* FIXME: we need to do something here */
1440 static int main_pid_good(Service
*s
) {
1443 /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1445 /* If we know the pid file, then let's just check if it is
1447 if (s
->main_pid_known
) {
1449 /* If it's an alien child let's check if it is still
1451 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1452 return pid_is_alive(s
->main_pid
);
1454 /* .. otherwise assume we'll get a SIGCHLD for it,
1455 * which we really should wait for to collect exit
1456 * status and code */
1457 return s
->main_pid
> 0;
1460 /* We don't know the pid */
1464 static int control_pid_good(Service
*s
) {
1467 /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1468 * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1469 * means: we can't figure it out. */
1471 return s
->control_pid
> 0;
1474 static int cgroup_good(Service
*s
) {
1479 /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1482 if (!UNIT(s
)->cgroup_path
)
1485 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1492 static bool service_shall_restart(Service
*s
) {
1495 /* Don't restart after manual stops */
1496 if (s
->forbid_restart
)
1499 /* Never restart if this is configured as special exception */
1500 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1503 /* Restart if the exit code/status are configured as restart triggers */
1504 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1507 switch (s
->restart
) {
1509 case SERVICE_RESTART_NO
:
1512 case SERVICE_RESTART_ALWAYS
:
1515 case SERVICE_RESTART_ON_SUCCESS
:
1516 return s
->result
== SERVICE_SUCCESS
;
1518 case SERVICE_RESTART_ON_FAILURE
:
1519 return s
->result
!= SERVICE_SUCCESS
;
1521 case SERVICE_RESTART_ON_ABNORMAL
:
1522 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1524 case SERVICE_RESTART_ON_WATCHDOG
:
1525 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1527 case SERVICE_RESTART_ON_ABORT
:
1528 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1531 assert_not_reached("unknown restart setting");
1535 static bool service_will_restart(Unit
*u
) {
1536 Service
*s
= SERVICE(u
);
1540 if (s
->will_auto_restart
)
1542 if (s
->state
== SERVICE_AUTO_RESTART
)
1546 if (UNIT(s
)->job
->type
== JOB_START
)
1551 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1556 /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1557 * undo what has already been enqueued. */
1558 if (unit_stop_pending(UNIT(s
)))
1559 allow_restart
= false;
1561 if (s
->result
== SERVICE_SUCCESS
)
1564 if (s
->result
!= SERVICE_SUCCESS
)
1565 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1567 if (allow_restart
&& service_shall_restart(s
))
1568 s
->will_auto_restart
= true;
1570 /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1571 * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1572 s
->n_keep_fd_store
++;
1574 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1576 if (s
->will_auto_restart
) {
1577 s
->will_auto_restart
= false;
1579 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
1581 s
->n_keep_fd_store
--;
1585 service_set_state(s
, SERVICE_AUTO_RESTART
);
1587 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1588 * user can still introspect the counter. Do so on the next start. */
1589 s
->flush_n_restarts
= true;
1591 /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
1592 * queue, so that the fd store is possibly gc'ed again */
1593 s
->n_keep_fd_store
--;
1594 unit_add_to_gc_queue(UNIT(s
));
1596 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1597 s
->forbid_restart
= false;
1599 /* We want fresh tmpdirs in case service is started again immediately */
1600 exec_runtime_destroy(s
->exec_runtime
);
1601 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1603 if (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_NO
||
1604 (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_RESTART
&& !service_will_restart(UNIT(s
))))
1605 /* Also, remove the runtime directory */
1606 exec_context_destroy_runtime_directory(&s
->exec_context
, UNIT(s
)->manager
->prefix
[EXEC_DIRECTORY_RUNTIME
]);
1608 /* Get rid of the IPC bits of the user */
1609 unit_unref_uid_gid(UNIT(s
), true);
1611 /* Release the user, and destroy it if we are the only remaining owner */
1612 dynamic_creds_destroy(&s
->dynamic_creds
);
1614 /* Try to delete the pid file. At this point it will be
1615 * out-of-date, and some software might be confused by it, so
1616 * let's remove it. */
1618 (void) unlink(s
->pid_file
);
1623 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1624 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1627 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1631 if (s
->result
== SERVICE_SUCCESS
)
1634 service_unwatch_control_pid(s
);
1635 unit_watch_all_pids(UNIT(s
));
1637 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1638 if (s
->control_command
) {
1639 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1641 r
= service_spawn(s
,
1643 s
->timeout_stop_usec
,
1644 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1649 service_set_state(s
, SERVICE_STOP_POST
);
1651 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1656 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1657 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1660 static int state_to_kill_operation(ServiceState state
) {
1663 case SERVICE_STOP_SIGABRT
:
1666 case SERVICE_STOP_SIGTERM
:
1667 case SERVICE_FINAL_SIGTERM
:
1668 return KILL_TERMINATE
;
1670 case SERVICE_STOP_SIGKILL
:
1671 case SERVICE_FINAL_SIGKILL
:
1675 return _KILL_OPERATION_INVALID
;
1679 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1684 if (s
->result
== SERVICE_SUCCESS
)
1687 unit_watch_all_pids(UNIT(s
));
1689 r
= unit_kill_context(
1692 state_to_kill_operation(state
),
1700 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1704 service_set_state(s
, state
);
1705 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1706 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1707 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1708 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1709 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1710 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1712 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1717 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1719 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1720 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1722 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1725 static void service_enter_stop_by_notify(Service
*s
) {
1728 unit_watch_all_pids(UNIT(s
));
1730 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1732 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1733 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1736 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1741 if (s
->result
== SERVICE_SUCCESS
)
1744 service_unwatch_control_pid(s
);
1745 unit_watch_all_pids(UNIT(s
));
1747 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1748 if (s
->control_command
) {
1749 s
->control_command_id
= SERVICE_EXEC_STOP
;
1751 r
= service_spawn(s
,
1753 s
->timeout_stop_usec
,
1754 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1759 service_set_state(s
, SERVICE_STOP
);
1761 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1766 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1767 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1770 static bool service_good(Service
*s
) {
1774 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1777 main_pid_ok
= main_pid_good(s
);
1778 if (main_pid_ok
> 0) /* It's alive */
1780 if (main_pid_ok
== 0) /* It's dead */
1783 /* OK, we don't know anything about the main PID, maybe
1784 * because there is none. Let's check the control group
1787 return cgroup_good(s
) != 0;
1790 static void service_enter_running(Service
*s
, ServiceResult f
) {
1793 if (s
->result
== SERVICE_SUCCESS
)
1796 service_unwatch_control_pid(s
);
1798 if (service_good(s
)) {
1800 /* If there are any queued up sd_notify()
1801 * notifications, process them now */
1802 if (s
->notify_state
== NOTIFY_RELOADING
)
1803 service_enter_reload_by_notify(s
);
1804 else if (s
->notify_state
== NOTIFY_STOPPING
)
1805 service_enter_stop_by_notify(s
);
1807 service_set_state(s
, SERVICE_RUNNING
);
1808 service_arm_timer(s
, usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
));
1811 } else if (f
!= SERVICE_SUCCESS
)
1812 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
1813 else if (s
->remain_after_exit
)
1814 service_set_state(s
, SERVICE_EXITED
);
1816 service_enter_stop(s
, SERVICE_SUCCESS
);
1819 static void service_enter_start_post(Service
*s
) {
1823 service_unwatch_control_pid(s
);
1824 service_reset_watchdog(s
);
1826 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1827 if (s
->control_command
) {
1828 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1830 r
= service_spawn(s
,
1832 s
->timeout_start_usec
,
1833 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
1838 service_set_state(s
, SERVICE_START_POST
);
1840 service_enter_running(s
, SERVICE_SUCCESS
);
1845 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1846 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1849 static void service_kill_control_process(Service
*s
) {
1854 if (s
->control_pid
<= 0)
1857 r
= kill_and_sigcont(s
->control_pid
, SIGKILL
);
1859 _cleanup_free_
char *comm
= NULL
;
1861 (void) get_process_comm(s
->control_pid
, &comm
);
1863 log_unit_debug_errno(UNIT(s
), r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m",
1864 s
->control_pid
, strna(comm
));
1868 static void service_enter_start(Service
*s
) {
1876 service_unwatch_control_pid(s
);
1877 service_unwatch_main_pid(s
);
1879 unit_warn_leftover_processes(UNIT(s
));
1881 if (s
->type
== SERVICE_FORKING
) {
1882 s
->control_command_id
= SERVICE_EXEC_START
;
1883 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1885 s
->main_command
= NULL
;
1887 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1888 s
->control_command
= NULL
;
1890 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1894 if (s
->type
!= SERVICE_ONESHOT
) {
1895 /* There's no command line configured for the main command? Hmm, that is strange. This can only
1896 * happen if the configuration changes at runtime. In this case, let's enter a failure
1898 log_unit_error(UNIT(s
), "There's no 'start' task anymore we could start: %m");
1903 service_enter_start_post(s
);
1907 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
))
1908 /* For simple + idle this is the main process. We don't apply any timeout here, but
1909 * service_enter_running() will later apply the .runtime_max_usec timeout. */
1910 timeout
= USEC_INFINITY
;
1912 timeout
= s
->timeout_start_usec
;
1914 r
= service_spawn(s
,
1917 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
1922 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
)) {
1923 /* For simple services we immediately start
1924 * the START_POST binaries. */
1926 service_set_main_pid(s
, pid
);
1927 service_enter_start_post(s
);
1929 } else if (s
->type
== SERVICE_FORKING
) {
1931 /* For forking services we wait until the start
1932 * process exited. */
1934 s
->control_pid
= pid
;
1935 service_set_state(s
, SERVICE_START
);
1937 } else if (IN_SET(s
->type
, SERVICE_ONESHOT
, SERVICE_DBUS
, SERVICE_NOTIFY
)) {
1939 /* For oneshot services we wait until the start
1940 * process exited, too, but it is our main process. */
1942 /* For D-Bus services we know the main pid right away,
1943 * but wait for the bus name to appear on the
1944 * bus. Notify services are similar. */
1946 service_set_main_pid(s
, pid
);
1947 service_set_state(s
, SERVICE_START
);
1949 assert_not_reached("Unknown service type");
1954 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1955 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1958 static void service_enter_start_pre(Service
*s
) {
1963 service_unwatch_control_pid(s
);
1965 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1966 if (s
->control_command
) {
1968 unit_warn_leftover_processes(UNIT(s
));
1970 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1972 r
= service_spawn(s
,
1974 s
->timeout_start_usec
,
1975 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_APPLY_TTY_STDIN
,
1980 service_set_state(s
, SERVICE_START_PRE
);
1982 service_enter_start(s
);
1987 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1988 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1991 static void service_enter_restart(Service
*s
) {
1992 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1997 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1998 /* Don't restart things if we are going down anyway */
1999 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
2001 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
2008 /* Any units that are bound to this service must also be
2009 * restarted. We use JOB_RESTART (instead of the more obvious
2010 * JOB_START) here so that those dependency jobs will be added
2012 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, &error
, NULL
);
2016 /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
2017 * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
2018 * explicitly however via the usual "systemctl reset-failure" logic. */
2020 s
->flush_n_restarts
= false;
2022 log_struct(LOG_INFO
,
2023 "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR
,
2024 LOG_UNIT_ID(UNIT(s
)),
2025 LOG_UNIT_INVOCATION_ID(UNIT(s
)),
2026 LOG_UNIT_MESSAGE(UNIT(s
), "Scheduled restart job, restart counter is at %u.", s
->n_restarts
),
2027 "N_RESTARTS=%u", s
->n_restarts
,
2030 /* Notify clients about changed restart counter */
2031 unit_add_to_dbus_queue(UNIT(s
));
2033 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2034 * it will be canceled as part of the service_stop() call that
2035 * is executed as part of JOB_RESTART. */
2040 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
2041 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
2044 static void service_enter_reload_by_notify(Service
*s
) {
2045 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2050 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_start_usec
));
2051 service_set_state(s
, SERVICE_RELOAD
);
2053 /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2054 r
= manager_propagate_reload(UNIT(s
)->manager
, UNIT(s
), JOB_FAIL
, &error
);
2056 log_unit_warning(UNIT(s
), "Failed to schedule propagation of reload: %s", bus_error_message(&error
, -r
));
2059 static void service_enter_reload(Service
*s
) {
2064 service_unwatch_control_pid(s
);
2065 s
->reload_result
= SERVICE_SUCCESS
;
2067 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
2068 if (s
->control_command
) {
2069 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
2071 r
= service_spawn(s
,
2073 s
->timeout_start_usec
,
2074 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
2079 service_set_state(s
, SERVICE_RELOAD
);
2081 service_enter_running(s
, SERVICE_SUCCESS
);
2086 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
2087 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2088 service_enter_running(s
, SERVICE_SUCCESS
);
2091 static void service_run_next_control(Service
*s
) {
2096 assert(s
->control_command
);
2097 assert(s
->control_command
->command_next
);
2099 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
2101 s
->control_command
= s
->control_command
->command_next
;
2102 service_unwatch_control_pid(s
);
2104 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
2105 timeout
= s
->timeout_start_usec
;
2107 timeout
= s
->timeout_stop_usec
;
2109 r
= service_spawn(s
,
2112 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|
2113 (IN_SET(s
->control_command_id
, SERVICE_EXEC_START_PRE
, SERVICE_EXEC_STOP_POST
) ? EXEC_APPLY_TTY_STDIN
: 0)|
2114 (IN_SET(s
->control_command_id
, SERVICE_EXEC_STOP
, SERVICE_EXEC_STOP_POST
) ? EXEC_SETENV_RESULT
: 0),
2122 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
2124 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START_POST
, SERVICE_STOP
))
2125 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2126 else if (s
->state
== SERVICE_STOP_POST
)
2127 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
2128 else if (s
->state
== SERVICE_RELOAD
) {
2129 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2130 service_enter_running(s
, SERVICE_SUCCESS
);
2132 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2135 static void service_run_next_main(Service
*s
) {
2140 assert(s
->main_command
);
2141 assert(s
->main_command
->command_next
);
2142 assert(s
->type
== SERVICE_ONESHOT
);
2144 s
->main_command
= s
->main_command
->command_next
;
2145 service_unwatch_main_pid(s
);
2147 r
= service_spawn(s
,
2149 s
->timeout_start_usec
,
2150 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
2155 service_set_main_pid(s
, pid
);
2160 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
2161 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2164 static int service_start(Unit
*u
) {
2165 Service
*s
= SERVICE(u
);
2170 /* We cannot fulfill this request right now, try again later
2172 if (IN_SET(s
->state
,
2173 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2174 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2177 /* Already on it! */
2178 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
2181 /* A service that will be restarted must be stopped first to
2182 * trigger BindsTo and/or OnFailure dependencies. If a user
2183 * does not want to wait for the holdoff time to elapse, the
2184 * service should be manually restarted, not started. We
2185 * simply return EAGAIN here, so that any start jobs stay
2186 * queued, and assume that the auto restart timer will
2187 * eventually trigger the restart. */
2188 if (s
->state
== SERVICE_AUTO_RESTART
)
2191 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
2193 /* Make sure we don't enter a busy loop of some kind. */
2194 r
= unit_start_limit_test(u
);
2196 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT_HIT
, false);
2200 r
= unit_acquire_invocation_id(u
);
2204 s
->result
= SERVICE_SUCCESS
;
2205 s
->reload_result
= SERVICE_SUCCESS
;
2206 s
->main_pid_known
= false;
2207 s
->main_pid_alien
= false;
2208 s
->forbid_restart
= false;
2210 u
->reset_accounting
= true;
2212 s
->status_text
= mfree(s
->status_text
);
2213 s
->status_errno
= 0;
2215 s
->notify_state
= NOTIFY_UNKNOWN
;
2217 s
->watchdog_override_enable
= false;
2218 s
->watchdog_override_usec
= 0;
2220 /* This is not an automatic restart? Flush the restart counter then */
2221 if (s
->flush_n_restarts
) {
2223 s
->flush_n_restarts
= false;
2226 service_enter_start_pre(s
);
2230 static int service_stop(Unit
*u
) {
2231 Service
*s
= SERVICE(u
);
2235 /* Don't create restart jobs from manual stops. */
2236 s
->forbid_restart
= true;
2239 if (IN_SET(s
->state
,
2240 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2241 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2244 /* A restart will be scheduled or is in progress. */
2245 if (s
->state
== SERVICE_AUTO_RESTART
) {
2246 service_set_state(s
, SERVICE_DEAD
);
2250 /* If there's already something running we go directly into
2252 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2253 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2257 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2259 service_enter_stop(s
, SERVICE_SUCCESS
);
2263 static int service_reload(Unit
*u
) {
2264 Service
*s
= SERVICE(u
);
2268 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2270 service_enter_reload(s
);
2274 _pure_
static bool service_can_reload(Unit
*u
) {
2275 Service
*s
= SERVICE(u
);
2279 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2282 static unsigned service_exec_command_index(Unit
*u
, ServiceExecCommand id
, ExecCommand
*current
) {
2283 Service
*s
= SERVICE(u
);
2285 ExecCommand
*first
, *c
;
2289 first
= s
->exec_command
[id
];
2291 /* Figure out where we are in the list by walking back to the beginning */
2292 for (c
= current
; c
!= first
; c
= c
->command_prev
)
2298 static int service_serialize_exec_command(Unit
*u
, FILE *f
, ExecCommand
*command
) {
2299 Service
*s
= SERVICE(u
);
2300 ServiceExecCommand id
;
2304 _cleanup_free_
char *args
= NULL
, *p
= NULL
;
2305 size_t allocated
= 0, length
= 0;
2313 if (command
== s
->control_command
) {
2315 id
= s
->control_command_id
;
2318 id
= SERVICE_EXEC_START
;
2321 idx
= service_exec_command_index(u
, id
, command
);
2323 STRV_FOREACH(arg
, command
->argv
) {
2325 _cleanup_free_
char *e
= NULL
;
2327 e
= xescape(*arg
, WHITESPACE
);
2332 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1 + n
+ 1))
2336 args
[length
++] = ' ';
2338 memcpy(args
+ length
, e
, n
);
2342 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1))
2346 p
= xescape(command
->path
, WHITESPACE
);
2350 fprintf(f
, "%s-command=%s %u %s %s\n", type
, service_exec_command_to_string(id
), idx
, p
, args
);
2355 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2356 Service
*s
= SERVICE(u
);
2364 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2365 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2366 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2368 if (s
->control_pid
> 0)
2369 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2371 if (s
->main_pid_known
&& s
->main_pid
> 0)
2372 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2374 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2375 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2376 unit_serialize_item(u
, f
, "bus-name-owner", s
->bus_name_owner
);
2378 unit_serialize_item_format(u
, f
, "n-restarts", "%u", s
->n_restarts
);
2379 unit_serialize_item(u
, f
, "flush-n-restarts", yes_no(s
->flush_n_restarts
));
2381 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2385 service_serialize_exec_command(u
, f
, s
->control_command
);
2386 service_serialize_exec_command(u
, f
, s
->main_command
);
2388 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2391 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2394 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2398 if (UNIT_ISSET(s
->accept_socket
)) {
2399 r
= unit_serialize_item(u
, f
, "accept-socket", UNIT_DEREF(s
->accept_socket
)->id
);
2404 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2408 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2409 _cleanup_free_
char *c
= NULL
;
2412 copy
= fdset_put_dup(fds
, fs
->fd
);
2416 c
= cescape(fs
->fdname
);
2418 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2421 if (s
->main_exec_status
.pid
> 0) {
2422 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2423 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2424 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2426 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2427 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2428 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2432 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2434 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2436 if (s
->watchdog_override_enable
)
2437 unit_serialize_item_format(u
, f
, "watchdog-override-usec", USEC_FMT
, s
->watchdog_override_usec
);
2442 static int service_deserialize_exec_command(Unit
*u
, const char *key
, const char *value
) {
2443 Service
*s
= SERVICE(u
);
2445 unsigned idx
= 0, i
;
2446 bool control
, found
= false;
2447 ServiceExecCommand id
= _SERVICE_EXEC_COMMAND_INVALID
;
2448 ExecCommand
*command
= NULL
;
2449 _cleanup_free_
char *path
= NULL
;
2450 _cleanup_strv_free_
char **argv
= NULL
;
2452 enum ExecCommandState
{
2453 STATE_EXEC_COMMAND_TYPE
,
2454 STATE_EXEC_COMMAND_INDEX
,
2455 STATE_EXEC_COMMAND_PATH
,
2456 STATE_EXEC_COMMAND_ARGS
,
2457 _STATE_EXEC_COMMAND_MAX
,
2458 _STATE_EXEC_COMMAND_INVALID
= -1,
2465 control
= streq(key
, "control-command");
2467 state
= STATE_EXEC_COMMAND_TYPE
;
2470 _cleanup_free_
char *arg
= NULL
;
2472 r
= extract_first_word(&value
, &arg
, NULL
, EXTRACT_CUNESCAPE
);
2479 case STATE_EXEC_COMMAND_TYPE
:
2480 id
= service_exec_command_from_string(arg
);
2484 state
= STATE_EXEC_COMMAND_INDEX
;
2486 case STATE_EXEC_COMMAND_INDEX
:
2487 r
= safe_atou(arg
, &idx
);
2491 state
= STATE_EXEC_COMMAND_PATH
;
2493 case STATE_EXEC_COMMAND_PATH
:
2496 state
= STATE_EXEC_COMMAND_ARGS
;
2498 if (!path_is_absolute(path
))
2501 case STATE_EXEC_COMMAND_ARGS
:
2502 r
= strv_extend(&argv
, arg
);
2507 assert_not_reached("Unknown error at deserialization of exec command");
2512 if (state
!= STATE_EXEC_COMMAND_ARGS
)
2515 /* Let's check whether exec command on given offset matches data that we just deserialized */
2516 for (command
= s
->exec_command
[id
], i
= 0; command
; command
= command
->command_next
, i
++) {
2520 found
= strv_equal(argv
, command
->argv
) && streq(command
->path
, path
);
2525 /* Command at the index we serialized is different, let's look for command that exactly
2526 * matches but is on different index. If there is no such command we will not resume execution. */
2527 for (command
= s
->exec_command
[id
]; command
; command
= command
->command_next
)
2528 if (strv_equal(command
->argv
, argv
) && streq(command
->path
, path
))
2532 if (command
&& control
)
2533 s
->control_command
= command
;
2535 s
->main_command
= command
;
2537 log_unit_warning(u
, "Current command vanished from the unit file, execution of the command list won't be resumed.");
2542 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2543 Service
*s
= SERVICE(u
);
2551 if (streq(key
, "state")) {
2554 state
= service_state_from_string(value
);
2556 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2558 s
->deserialized_state
= state
;
2559 } else if (streq(key
, "result")) {
2562 f
= service_result_from_string(value
);
2564 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2565 else if (f
!= SERVICE_SUCCESS
)
2568 } else if (streq(key
, "reload-result")) {
2571 f
= service_result_from_string(value
);
2573 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2574 else if (f
!= SERVICE_SUCCESS
)
2575 s
->reload_result
= f
;
2577 } else if (streq(key
, "control-pid")) {
2580 if (parse_pid(value
, &pid
) < 0)
2581 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2583 s
->control_pid
= pid
;
2584 } else if (streq(key
, "main-pid")) {
2587 if (parse_pid(value
, &pid
) < 0)
2588 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2590 service_set_main_pid(s
, pid
);
2591 unit_watch_pid(UNIT(s
), pid
);
2593 } else if (streq(key
, "main-pid-known")) {
2596 b
= parse_boolean(value
);
2598 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2600 s
->main_pid_known
= b
;
2601 } else if (streq(key
, "bus-name-good")) {
2604 b
= parse_boolean(value
);
2606 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2608 s
->bus_name_good
= b
;
2609 } else if (streq(key
, "bus-name-owner")) {
2610 r
= free_and_strdup(&s
->bus_name_owner
, value
);
2612 log_unit_error_errno(u
, r
, "Unable to deserialize current bus owner %s: %m", value
);
2613 } else if (streq(key
, "status-text")) {
2616 r
= cunescape(value
, 0, &t
);
2618 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2620 free(s
->status_text
);
2624 } else if (streq(key
, "accept-socket")) {
2627 r
= manager_load_unit(u
->manager
, value
, NULL
, NULL
, &socket
);
2629 log_unit_debug_errno(u
, r
, "Failed to load accept-socket unit: %s", value
);
2631 unit_ref_set(&s
->accept_socket
, socket
);
2632 SOCKET(socket
)->n_connections
++;
2635 } else if (streq(key
, "socket-fd")) {
2638 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2639 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2641 asynchronous_close(s
->socket_fd
);
2642 s
->socket_fd
= fdset_remove(fds
, fd
);
2644 } else if (streq(key
, "fd-store-fd")) {
2649 pf
= strcspn(value
, WHITESPACE
);
2650 fdv
= strndupa(value
, pf
);
2652 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2653 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2655 _cleanup_free_
char *t
= NULL
;
2659 fdn
+= strspn(fdn
, WHITESPACE
);
2660 (void) cunescape(fdn
, 0, &t
);
2662 r
= service_add_fd_store(s
, fd
, t
);
2664 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2666 fdset_remove(fds
, fd
);
2669 } else if (streq(key
, "main-exec-status-pid")) {
2672 if (parse_pid(value
, &pid
) < 0)
2673 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2675 s
->main_exec_status
.pid
= pid
;
2676 } else if (streq(key
, "main-exec-status-code")) {
2679 if (safe_atoi(value
, &i
) < 0)
2680 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2682 s
->main_exec_status
.code
= i
;
2683 } else if (streq(key
, "main-exec-status-status")) {
2686 if (safe_atoi(value
, &i
) < 0)
2687 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2689 s
->main_exec_status
.status
= i
;
2690 } else if (streq(key
, "main-exec-status-start"))
2691 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2692 else if (streq(key
, "main-exec-status-exit"))
2693 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2694 else if (streq(key
, "watchdog-timestamp"))
2695 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2696 else if (streq(key
, "forbid-restart")) {
2699 b
= parse_boolean(value
);
2701 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2703 s
->forbid_restart
= b
;
2704 } else if (streq(key
, "stdin-fd")) {
2707 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2708 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2710 asynchronous_close(s
->stdin_fd
);
2711 s
->stdin_fd
= fdset_remove(fds
, fd
);
2712 s
->exec_context
.stdio_as_fds
= true;
2714 } else if (streq(key
, "stdout-fd")) {
2717 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2718 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2720 asynchronous_close(s
->stdout_fd
);
2721 s
->stdout_fd
= fdset_remove(fds
, fd
);
2722 s
->exec_context
.stdio_as_fds
= true;
2724 } else if (streq(key
, "stderr-fd")) {
2727 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2728 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2730 asynchronous_close(s
->stderr_fd
);
2731 s
->stderr_fd
= fdset_remove(fds
, fd
);
2732 s
->exec_context
.stdio_as_fds
= true;
2734 } else if (streq(key
, "watchdog-override-usec")) {
2735 usec_t watchdog_override_usec
;
2736 if (timestamp_deserialize(value
, &watchdog_override_usec
) < 0)
2737 log_unit_debug(u
, "Failed to parse watchdog_override_usec value: %s", value
);
2739 s
->watchdog_override_enable
= true;
2740 s
->watchdog_override_usec
= watchdog_override_usec
;
2742 } else if (STR_IN_SET(key
, "main-command", "control-command")) {
2743 r
= service_deserialize_exec_command(u
, key
, value
);
2745 log_unit_debug_errno(u
, r
, "Failed to parse serialized command \"%s\": %m", value
);
2747 } else if (streq(key
, "n-restarts")) {
2748 r
= safe_atou(value
, &s
->n_restarts
);
2750 log_unit_debug_errno(u
, r
, "Failed to parse serialized restart counter '%s': %m", value
);
2752 } else if (streq(key
, "flush-n-restarts")) {
2753 r
= parse_boolean(value
);
2755 log_unit_debug_errno(u
, r
, "Failed to parse serialized flush restart counter setting '%s': %m", value
);
2757 s
->flush_n_restarts
= r
;
2759 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2764 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2765 const UnitActiveState
*table
;
2769 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2771 return table
[SERVICE(u
)->state
];
2774 static const char *service_sub_state_to_string(Unit
*u
) {
2777 return service_state_to_string(SERVICE(u
)->state
);
2780 static bool service_check_gc(Unit
*u
) {
2781 Service
*s
= SERVICE(u
);
2785 /* Never clean up services that still have a process around, even if the service is formally dead. Note that
2786 * unit_check_gc() already checked our cgroup for us, we just check our two additional PIDs, too, in case they
2787 * have moved outside of the cgroup. */
2789 if (main_pid_good(s
) > 0 ||
2790 control_pid_good(s
) > 0)
2796 static int service_retry_pid_file(Service
*s
) {
2799 assert(s
->pid_file
);
2800 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2802 r
= service_load_pid_file(s
, false);
2806 service_unwatch_pid_file(s
);
2808 service_enter_running(s
, SERVICE_SUCCESS
);
2812 static int service_watch_pid_file(Service
*s
) {
2815 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2817 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2821 /* the pidfile might have appeared just before we set the watch */
2822 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2823 service_retry_pid_file(s
);
2827 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2828 service_unwatch_pid_file(s
);
2832 static int service_demand_pid_file(Service
*s
) {
2835 assert(s
->pid_file
);
2836 assert(!s
->pid_file_pathspec
);
2838 ps
= new0(PathSpec
, 1);
2843 ps
->path
= strdup(s
->pid_file
);
2849 path_kill_slashes(ps
->path
);
2851 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2852 * keep their PID file open all the time. */
2853 ps
->type
= PATH_MODIFIED
;
2854 ps
->inotify_fd
= -1;
2856 s
->pid_file_pathspec
= ps
;
2858 return service_watch_pid_file(s
);
2861 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2862 PathSpec
*p
= userdata
;
2867 s
= SERVICE(p
->unit
);
2871 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2872 assert(s
->pid_file_pathspec
);
2873 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2875 log_unit_debug(UNIT(s
), "inotify event");
2877 if (path_spec_fd_event(p
, events
) < 0)
2880 if (service_retry_pid_file(s
) == 0)
2883 if (service_watch_pid_file(s
) < 0)
2889 service_unwatch_pid_file(s
);
2890 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2894 static void service_notify_cgroup_empty_event(Unit
*u
) {
2895 Service
*s
= SERVICE(u
);
2899 log_unit_debug(u
, "cgroup is empty");
2903 /* Waiting for SIGCHLD is usually more interesting,
2904 * because it includes return codes/signals. Which is
2905 * why we ignore the cgroup events for most cases,
2906 * except when we don't know pid which to expect the
2910 if (s
->type
== SERVICE_NOTIFY
&&
2911 main_pid_good(s
) == 0 &&
2912 control_pid_good(s
) == 0) {
2913 /* No chance of getting a ready notification anymore */
2914 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2919 case SERVICE_START_POST
:
2920 if (s
->pid_file_pathspec
&&
2921 main_pid_good(s
) == 0 &&
2922 control_pid_good(s
) == 0) {
2924 /* Give up hoping for the daemon to write its PID file */
2925 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2927 service_unwatch_pid_file(s
);
2928 if (s
->state
== SERVICE_START
)
2929 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2931 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
2935 case SERVICE_RUNNING
:
2936 /* service_enter_running() will figure out what to do */
2937 service_enter_running(s
, SERVICE_SUCCESS
);
2940 case SERVICE_STOP_SIGABRT
:
2941 case SERVICE_STOP_SIGTERM
:
2942 case SERVICE_STOP_SIGKILL
:
2944 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
2945 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2949 case SERVICE_STOP_POST
:
2950 case SERVICE_FINAL_SIGTERM
:
2951 case SERVICE_FINAL_SIGKILL
:
2952 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
2953 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2962 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2963 Service
*s
= SERVICE(u
);
2969 if (is_clean_exit(code
, status
, s
->type
== SERVICE_ONESHOT
? EXIT_CLEAN_COMMAND
: EXIT_CLEAN_DAEMON
, &s
->success_status
))
2970 f
= SERVICE_SUCCESS
;
2971 else if (code
== CLD_EXITED
)
2972 f
= SERVICE_FAILURE_EXIT_CODE
;
2973 else if (code
== CLD_KILLED
)
2974 f
= SERVICE_FAILURE_SIGNAL
;
2975 else if (code
== CLD_DUMPED
)
2976 f
= SERVICE_FAILURE_CORE_DUMP
;
2978 assert_not_reached("Unknown code");
2980 if (s
->main_pid
== pid
) {
2981 /* Forking services may occasionally move to a new PID.
2982 * As long as they update the PID file before exiting the old
2983 * PID, they're fine. */
2984 if (service_load_pid_file(s
, false) == 0)
2988 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2990 if (s
->main_command
) {
2991 /* If this is not a forking service than the
2992 * main process got started and hence we copy
2993 * the exit status so that it is recorded both
2994 * as main and as control process exit
2997 s
->main_command
->exec_status
= s
->main_exec_status
;
2999 if (s
->main_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3000 f
= SERVICE_SUCCESS
;
3001 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
3003 /* If this is a forked process, then we should
3004 * ignore the return value if this was
3005 * configured for the starter process */
3007 if (s
->exec_command
[SERVICE_EXEC_START
]->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3008 f
= SERVICE_SUCCESS
;
3011 /* When this is a successful exit, let's log about the exit code on DEBUG level. If this is a failure
3012 * and the process exited on its own via exit(), then let's make this a NOTICE, under the assumption
3013 * that the service already logged the reason at a higher log level on its own. However, if the service
3014 * died due to a signal, then it most likely didn't say anything about any reason, hence let's raise
3015 * our log level to WARNING then. */
3017 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
:
3018 (code
== CLD_EXITED
? LOG_NOTICE
: LOG_WARNING
),
3019 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
3020 sigchld_code_to_string(code
), status
,
3021 strna(code
== CLD_EXITED
3022 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
3023 : signal_to_string(status
))),
3024 "EXIT_CODE=%s", sigchld_code_to_string(code
),
3025 "EXIT_STATUS=%i", status
,
3027 LOG_UNIT_INVOCATION_ID(u
),
3030 if (s
->result
== SERVICE_SUCCESS
)
3033 if (s
->main_command
&&
3034 s
->main_command
->command_next
&&
3035 s
->type
== SERVICE_ONESHOT
&&
3036 f
== SERVICE_SUCCESS
) {
3038 /* There is another command to *
3039 * execute, so let's do that. */
3041 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
3042 service_run_next_main(s
);
3046 /* The service exited, so the service is officially
3048 s
->main_command
= NULL
;
3052 case SERVICE_START_POST
:
3053 case SERVICE_RELOAD
:
3055 /* Need to wait until the operation is
3060 if (s
->type
== SERVICE_ONESHOT
) {
3061 /* This was our main goal, so let's go on */
3062 if (f
== SERVICE_SUCCESS
)
3063 service_enter_start_post(s
);
3065 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3067 } else if (s
->type
== SERVICE_NOTIFY
) {
3068 /* Only enter running through a notification, so that the
3069 * SERVICE_START state signifies that no ready notification
3070 * has been received */
3071 if (f
!= SERVICE_SUCCESS
)
3072 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3073 else if (!s
->remain_after_exit
|| s
->notify_access
== NOTIFY_MAIN
)
3074 /* The service has never been and will never be active */
3075 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3080 case SERVICE_RUNNING
:
3081 service_enter_running(s
, f
);
3084 case SERVICE_STOP_SIGABRT
:
3085 case SERVICE_STOP_SIGTERM
:
3086 case SERVICE_STOP_SIGKILL
:
3088 if (control_pid_good(s
) <= 0)
3089 service_enter_stop_post(s
, f
);
3091 /* If there is still a control process, wait for that first */
3094 case SERVICE_STOP_POST
:
3095 case SERVICE_FINAL_SIGTERM
:
3096 case SERVICE_FINAL_SIGKILL
:
3098 if (control_pid_good(s
) <= 0)
3099 service_enter_dead(s
, f
, true);
3103 assert_not_reached("Uh, main process died at wrong time.");
3107 } else if (s
->control_pid
== pid
) {
3110 if (s
->control_command
) {
3111 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
3113 if (s
->control_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3114 f
= SERVICE_SUCCESS
;
3117 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
3118 "Control process exited, code=%s status=%i",
3119 sigchld_code_to_string(code
), status
);
3121 if (s
->result
== SERVICE_SUCCESS
)
3124 if (s
->control_command
&&
3125 s
->control_command
->command_next
&&
3126 f
== SERVICE_SUCCESS
) {
3128 /* There is another command to *
3129 * execute, so let's do that. */
3131 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
3132 service_run_next_control(s
);
3135 /* No further commands for this step, so let's
3136 * figure out what to do next */
3138 s
->control_command
= NULL
;
3139 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
3141 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
3145 case SERVICE_START_PRE
:
3146 if (f
== SERVICE_SUCCESS
)
3147 service_enter_start(s
);
3149 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3153 if (s
->type
!= SERVICE_FORKING
)
3154 /* Maybe spurious event due to a reload that changed the type? */
3157 if (f
!= SERVICE_SUCCESS
) {
3158 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3163 bool has_start_post
;
3166 /* Let's try to load the pid file here if we can.
3167 * The PID file might actually be created by a START_POST
3168 * script. In that case don't worry if the loading fails. */
3170 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
3171 r
= service_load_pid_file(s
, !has_start_post
);
3172 if (!has_start_post
&& r
< 0) {
3173 r
= service_demand_pid_file(s
);
3174 if (r
< 0 || cgroup_good(s
) == 0)
3175 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3179 service_search_main_pid(s
);
3181 service_enter_start_post(s
);
3184 case SERVICE_START_POST
:
3185 if (f
!= SERVICE_SUCCESS
) {
3186 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3193 r
= service_load_pid_file(s
, true);
3195 r
= service_demand_pid_file(s
);
3196 if (r
< 0 || cgroup_good(s
) == 0)
3197 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
3201 service_search_main_pid(s
);
3203 service_enter_running(s
, SERVICE_SUCCESS
);
3206 case SERVICE_RELOAD
:
3207 if (f
== SERVICE_SUCCESS
)
3208 if (service_load_pid_file(s
, true) < 0)
3209 service_search_main_pid(s
);
3211 s
->reload_result
= f
;
3212 service_enter_running(s
, SERVICE_SUCCESS
);
3216 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3219 case SERVICE_STOP_SIGABRT
:
3220 case SERVICE_STOP_SIGTERM
:
3221 case SERVICE_STOP_SIGKILL
:
3222 if (main_pid_good(s
) <= 0)
3223 service_enter_stop_post(s
, f
);
3225 /* If there is still a service
3226 * process around, wait until
3227 * that one quit, too */
3230 case SERVICE_STOP_POST
:
3231 case SERVICE_FINAL_SIGTERM
:
3232 case SERVICE_FINAL_SIGKILL
:
3233 if (main_pid_good(s
) <= 0)
3234 service_enter_dead(s
, f
, true);
3238 assert_not_reached("Uh, control process died at wrong time.");
3243 /* Notify clients about changed exit status */
3244 unit_add_to_dbus_queue(u
);
3246 /* We got one SIGCHLD for the service, let's watch all
3247 * processes that are now running of the service, and watch
3248 * that. Among the PIDs we then watch will be children
3249 * reassigned to us, which hopefully allows us to identify
3250 * when all children are gone */
3251 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
3252 unit_watch_all_pids(u
);
3254 /* If the PID set is empty now, then let's finish this off
3255 (On unified we use proper notifications) */
3256 if (cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER
) == 0 && set_isempty(u
->pids
))
3257 unit_add_to_cgroup_empty_queue(u
);
3260 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3261 Service
*s
= SERVICE(userdata
);
3264 assert(source
== s
->timer_event_source
);
3268 case SERVICE_START_PRE
:
3270 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
3271 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3274 case SERVICE_START_POST
:
3275 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
3276 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3279 case SERVICE_RUNNING
:
3280 log_unit_warning(UNIT(s
), "Service reached runtime time limit. Stopping.");
3281 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
3284 case SERVICE_RELOAD
:
3285 log_unit_warning(UNIT(s
), "Reload operation timed out. Killing reload process.");
3286 service_kill_control_process(s
);
3287 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
3288 service_enter_running(s
, SERVICE_SUCCESS
);
3292 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
3293 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3296 case SERVICE_STOP_SIGABRT
:
3297 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
3298 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3301 case SERVICE_STOP_SIGTERM
:
3302 if (s
->kill_context
.send_sigkill
) {
3303 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
3304 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3306 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
3307 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3312 case SERVICE_STOP_SIGKILL
:
3313 /* Uh, we sent a SIGKILL and it is still not gone?
3314 * Must be something we cannot kill, so let's just be
3315 * weirded out and continue */
3317 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
3318 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3321 case SERVICE_STOP_POST
:
3322 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
3323 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3326 case SERVICE_FINAL_SIGTERM
:
3327 if (s
->kill_context
.send_sigkill
) {
3328 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
3329 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3331 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
3332 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
3337 case SERVICE_FINAL_SIGKILL
:
3338 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
3339 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
3342 case SERVICE_AUTO_RESTART
:
3343 log_unit_info(UNIT(s
),
3344 s
->restart_usec
> 0 ?
3345 "Service hold-off time over, scheduling restart." :
3346 "Service has no hold-off time, scheduling restart.");
3347 service_enter_restart(s
);
3351 assert_not_reached("Timeout at wrong time.");
3357 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3358 Service
*s
= SERVICE(userdata
);
3359 char t
[FORMAT_TIMESPAN_MAX
];
3360 usec_t watchdog_usec
;
3363 assert(source
== s
->watchdog_event_source
);
3365 watchdog_usec
= service_get_watchdog_usec(s
);
3367 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
3368 format_timespan(t
, sizeof(t
), watchdog_usec
, 1));
3370 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
3375 static bool service_notify_message_authorized(Service
*s
, pid_t pid
, char **tags
, FDSet
*fds
) {
3378 if (s
->notify_access
== NOTIFY_NONE
) {
3379 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
3383 if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
3384 if (s
->main_pid
!= 0)
3385 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
);
3387 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
);
3392 if (s
->notify_access
== NOTIFY_EXEC
&& pid
!= s
->main_pid
&& pid
!= s
->control_pid
) {
3393 if (s
->main_pid
!= 0 && s
->control_pid
!= 0)
3394 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
,
3395 pid
, s
->main_pid
, s
->control_pid
);
3396 else if (s
->main_pid
!= 0)
3397 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
);
3398 else if (s
->control_pid
!= 0)
3399 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
);
3401 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
);
3409 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
3410 Service
*s
= SERVICE(u
);
3411 bool notify_dbus
= false;
3417 if (!service_notify_message_authorized(SERVICE(u
), pid
, tags
, fds
))
3420 if (DEBUG_LOGGING
) {
3421 _cleanup_free_
char *cc
= NULL
;
3423 cc
= strv_join(tags
, ", ");
3424 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
3427 /* Interpret MAINPID= */
3428 e
= strv_find_startswith(tags
, "MAINPID=");
3429 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
3430 if (parse_pid(e
, &pid
) < 0)
3431 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
3432 else if (pid
== s
->control_pid
)
3433 log_unit_warning(u
, "A control process cannot also be the main process");
3434 else if (pid
== getpid_cached() || pid
== 1)
3435 log_unit_warning(u
, "Service manager can't be main process, ignoring sd_notify() MAINPID= field");
3436 else if (pid
!= s
->main_pid
) {
3437 service_set_main_pid(s
, pid
);
3438 unit_watch_pid(UNIT(s
), pid
);
3443 /* Interpret READY=/STOPPING=/RELOADING=. Last one wins. */
3444 STRV_FOREACH_BACKWARDS(i
, tags
) {
3446 if (streq(*i
, "READY=1")) {
3447 s
->notify_state
= NOTIFY_READY
;
3449 /* Type=notify services inform us about completed
3450 * initialization with READY=1 */
3451 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
3452 service_enter_start_post(s
);
3454 /* Sending READY=1 while we are reloading informs us
3455 * that the reloading is complete */
3456 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
3457 service_enter_running(s
, SERVICE_SUCCESS
);
3462 } else if (streq(*i
, "RELOADING=1")) {
3463 s
->notify_state
= NOTIFY_RELOADING
;
3465 if (s
->state
== SERVICE_RUNNING
)
3466 service_enter_reload_by_notify(s
);
3471 } else if (streq(*i
, "STOPPING=1")) {
3472 s
->notify_state
= NOTIFY_STOPPING
;
3474 if (s
->state
== SERVICE_RUNNING
)
3475 service_enter_stop_by_notify(s
);
3482 /* Interpret STATUS= */
3483 e
= strv_find_startswith(tags
, "STATUS=");
3485 _cleanup_free_
char *t
= NULL
;
3488 if (!utf8_is_valid(e
))
3489 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3497 if (!streq_ptr(s
->status_text
, t
)) {
3498 free_and_replace(s
->status_text
, t
);
3503 /* Interpret ERRNO= */
3504 e
= strv_find_startswith(tags
, "ERRNO=");
3508 status_errno
= parse_errno(e
);
3509 if (status_errno
< 0)
3510 log_unit_warning_errno(u
, status_errno
,
3511 "Failed to parse ERRNO= field in notification message: %s", e
);
3512 else if (s
->status_errno
!= status_errno
) {
3513 s
->status_errno
= status_errno
;
3518 /* Interpret EXTEND_TIMEOUT= */
3519 e
= strv_find_startswith(tags
, "EXTEND_TIMEOUT_USEC=");
3521 usec_t extend_timeout_usec
;
3522 if (safe_atou64(e
, &extend_timeout_usec
) < 0)
3523 log_unit_warning(u
, "Failed to parse EXTEND_TIMEOUT_USEC=%s", e
);
3525 service_extend_timeout(s
, extend_timeout_usec
);
3528 /* Interpret WATCHDOG= */
3529 if (strv_find(tags
, "WATCHDOG=1"))
3530 service_reset_watchdog(s
);
3532 e
= strv_find_startswith(tags
, "WATCHDOG_USEC=");
3534 usec_t watchdog_override_usec
;
3535 if (safe_atou64(e
, &watchdog_override_usec
) < 0)
3536 log_unit_warning(u
, "Failed to parse WATCHDOG_USEC=%s", e
);
3538 service_reset_watchdog_timeout(s
, watchdog_override_usec
);
3541 /* Process FD store messages. Either FDSTOREREMOVE=1 for removal, or FDSTORE=1 for addition. In both cases,
3542 * process FDNAME= for picking the file descriptor name to use. Note that FDNAME= is required when removing
3543 * fds, but optional when pushing in new fds, for compatibility reasons. */
3544 if (strv_find(tags
, "FDSTOREREMOVE=1")) {
3547 name
= strv_find_startswith(tags
, "FDNAME=");
3548 if (!name
|| !fdname_is_valid(name
))
3549 log_unit_warning(u
, "FDSTOREREMOVE=1 requested, but no valid file descriptor name passed, ignoring.");
3551 service_remove_fd_store(s
, name
);
3553 } else if (strv_find(tags
, "FDSTORE=1")) {
3556 name
= strv_find_startswith(tags
, "FDNAME=");
3557 if (name
&& !fdname_is_valid(name
)) {
3558 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3562 (void) service_add_fd_store_set(s
, fds
, name
);
3565 /* Notify clients about changed status or main pid */
3567 unit_add_to_dbus_queue(u
);
3570 static int service_get_timeout(Unit
*u
, usec_t
*timeout
) {
3571 Service
*s
= SERVICE(u
);
3575 if (!s
->timer_event_source
)
3578 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
3581 if (t
== USEC_INFINITY
)
3588 static void service_bus_name_owner_change(
3591 const char *old_owner
,
3592 const char *new_owner
) {
3594 Service
*s
= SERVICE(u
);
3600 assert(streq(s
->bus_name
, name
));
3601 assert(old_owner
|| new_owner
);
3603 if (old_owner
&& new_owner
)
3604 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3606 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3608 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3610 s
->bus_name_good
= !!new_owner
;
3612 /* Track the current owner, so we can reconstruct changes after a daemon reload */
3613 r
= free_and_strdup(&s
->bus_name_owner
, new_owner
);
3615 log_unit_error_errno(u
, r
, "Unable to set new bus name owner %s: %m", new_owner
);
3619 if (s
->type
== SERVICE_DBUS
) {
3621 /* service_enter_running() will figure out what to
3623 if (s
->state
== SERVICE_RUNNING
)
3624 service_enter_running(s
, SERVICE_SUCCESS
);
3625 else if (s
->state
== SERVICE_START
&& new_owner
)
3626 service_enter_start_post(s
);
3628 } else if (new_owner
&&
3636 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
3639 /* Try to acquire PID from bus service */
3641 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3643 r
= sd_bus_creds_get_pid(creds
, &pid
);
3645 log_unit_debug(u
, "D-Bus name %s is now owned by process " PID_FMT
, name
, pid
);
3647 service_set_main_pid(s
, pid
);
3648 unit_watch_pid(UNIT(s
), pid
);
3653 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3654 _cleanup_free_
char *peer
= NULL
;
3660 /* This is called by the socket code when instantiating a new service for a stream socket and the socket needs
3661 * to be configured. We take ownership of the passed fd on success. */
3663 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3666 if (s
->socket_fd
>= 0)
3669 if (s
->state
!= SERVICE_DEAD
)
3672 if (getpeername_pretty(fd
, true, &peer
) >= 0) {
3674 if (UNIT(s
)->description
) {
3675 _cleanup_free_
char *a
;
3677 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")");
3681 r
= unit_set_description(UNIT(s
), a
);
3683 r
= unit_set_description(UNIT(s
), peer
);
3689 r
= unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false, UNIT_DEPENDENCY_IMPLICIT
);
3694 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3696 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3700 static void service_reset_failed(Unit
*u
) {
3701 Service
*s
= SERVICE(u
);
3705 if (s
->state
== SERVICE_FAILED
)
3706 service_set_state(s
, SERVICE_DEAD
);
3708 s
->result
= SERVICE_SUCCESS
;
3709 s
->reload_result
= SERVICE_SUCCESS
;
3711 s
->flush_n_restarts
= false;
3714 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3715 Service
*s
= SERVICE(u
);
3719 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3722 static int service_main_pid(Unit
*u
) {
3723 Service
*s
= SERVICE(u
);
3730 static int service_control_pid(Unit
*u
) {
3731 Service
*s
= SERVICE(u
);
3735 return s
->control_pid
;
3738 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3739 [SERVICE_RESTART_NO
] = "no",
3740 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3741 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3742 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3743 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3744 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3745 [SERVICE_RESTART_ALWAYS
] = "always",
3748 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3750 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3751 [SERVICE_SIMPLE
] = "simple",
3752 [SERVICE_FORKING
] = "forking",
3753 [SERVICE_ONESHOT
] = "oneshot",
3754 [SERVICE_DBUS
] = "dbus",
3755 [SERVICE_NOTIFY
] = "notify",
3756 [SERVICE_IDLE
] = "idle"
3759 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3761 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3762 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3763 [SERVICE_EXEC_START
] = "ExecStart",
3764 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3765 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3766 [SERVICE_EXEC_STOP
] = "ExecStop",
3767 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3770 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3772 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3773 [NOTIFY_UNKNOWN
] = "unknown",
3774 [NOTIFY_READY
] = "ready",
3775 [NOTIFY_RELOADING
] = "reloading",
3776 [NOTIFY_STOPPING
] = "stopping",
3779 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3781 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3782 [SERVICE_SUCCESS
] = "success",
3783 [SERVICE_FAILURE_RESOURCES
] = "resources",
3784 [SERVICE_FAILURE_PROTOCOL
] = "protocol",
3785 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3786 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3787 [SERVICE_FAILURE_SIGNAL
] = "signal",
3788 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3789 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3790 [SERVICE_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
3793 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3795 const UnitVTable service_vtable
= {
3796 .object_size
= sizeof(Service
),
3797 .exec_context_offset
= offsetof(Service
, exec_context
),
3798 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3799 .kill_context_offset
= offsetof(Service
, kill_context
),
3800 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3801 .dynamic_creds_offset
= offsetof(Service
, dynamic_creds
),
3807 .private_section
= "Service",
3809 .init
= service_init
,
3810 .done
= service_done
,
3811 .load
= service_load
,
3812 .release_resources
= service_release_resources
,
3814 .coldplug
= service_coldplug
,
3816 .dump
= service_dump
,
3818 .start
= service_start
,
3819 .stop
= service_stop
,
3820 .reload
= service_reload
,
3822 .can_reload
= service_can_reload
,
3824 .kill
= service_kill
,
3826 .serialize
= service_serialize
,
3827 .deserialize_item
= service_deserialize_item
,
3829 .active_state
= service_active_state
,
3830 .sub_state_to_string
= service_sub_state_to_string
,
3832 .will_restart
= service_will_restart
,
3834 .check_gc
= service_check_gc
,
3836 .sigchld_event
= service_sigchld_event
,
3838 .reset_failed
= service_reset_failed
,
3840 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3841 .notify_message
= service_notify_message
,
3843 .main_pid
= service_main_pid
,
3844 .control_pid
= service_control_pid
,
3846 .bus_name_owner_change
= service_bus_name_owner_change
,
3848 .bus_vtable
= bus_service_vtable
,
3849 .bus_set_property
= bus_service_set_property
,
3850 .bus_commit_properties
= bus_service_commit_properties
,
3852 .get_timeout
= service_get_timeout
,
3853 .can_transient
= true,
3855 .status_message_formats
= {
3856 .starting_stopping
= {
3857 [0] = "Starting %s...",
3858 [1] = "Stopping %s...",
3860 .finished_start_job
= {
3861 [JOB_DONE
] = "Started %s.",
3862 [JOB_FAILED
] = "Failed to start %s.",
3864 .finished_stop_job
= {
3865 [JOB_DONE
] = "Stopped %s.",
3866 [JOB_FAILED
] = "Stopped (with error) %s.",