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
, false);
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 char buf_restart
[FORMAT_TIMESPAN_MAX
], buf_start
[FORMAT_TIMESPAN_MAX
], buf_stop
[FORMAT_TIMESPAN_MAX
];
778 char buf_runtime
[FORMAT_TIMESPAN_MAX
], buf_watchdog
[FORMAT_TIMESPAN_MAX
];
779 ServiceExecCommand c
;
780 Service
*s
= SERVICE(u
);
785 prefix
= strempty(prefix
);
786 prefix2
= strjoina(prefix
, "\t");
789 "%sService State: %s\n"
791 "%sReload Result: %s\n"
792 "%sPermissionsStartOnly: %s\n"
793 "%sRootDirectoryStartOnly: %s\n"
794 "%sRemainAfterExit: %s\n"
795 "%sGuessMainPID: %s\n"
798 "%sNotifyAccess: %s\n"
799 "%sNotifyState: %s\n",
800 prefix
, service_state_to_string(s
->state
),
801 prefix
, service_result_to_string(s
->result
),
802 prefix
, service_result_to_string(s
->reload_result
),
803 prefix
, yes_no(s
->permissions_start_only
),
804 prefix
, yes_no(s
->root_directory_start_only
),
805 prefix
, yes_no(s
->remain_after_exit
),
806 prefix
, yes_no(s
->guess_main_pid
),
807 prefix
, service_type_to_string(s
->type
),
808 prefix
, service_restart_to_string(s
->restart
),
809 prefix
, notify_access_to_string(s
->notify_access
),
810 prefix
, notify_state_to_string(s
->notify_state
));
812 if (s
->control_pid
> 0)
814 "%sControl PID: "PID_FMT
"\n",
815 prefix
, s
->control_pid
);
819 "%sMain PID: "PID_FMT
"\n"
820 "%sMain PID Known: %s\n"
821 "%sMain PID Alien: %s\n",
823 prefix
, yes_no(s
->main_pid_known
),
824 prefix
, yes_no(s
->main_pid_alien
));
829 prefix
, s
->pid_file
);
834 "%sBus Name Good: %s\n",
836 prefix
, yes_no(s
->bus_name_good
));
838 if (UNIT_ISSET(s
->accept_socket
))
840 "%sAccept Socket: %s\n",
841 prefix
, UNIT_DEREF(s
->accept_socket
)->id
);
845 "%sTimeoutStartSec: %s\n"
846 "%sTimeoutStopSec: %s\n"
847 "%sRuntimeMaxSec: %s\n"
848 "%sWatchdogSec: %s\n",
849 prefix
, format_timespan(buf_restart
, sizeof(buf_restart
), s
->restart_usec
, USEC_PER_SEC
),
850 prefix
, format_timespan(buf_start
, sizeof(buf_start
), s
->timeout_start_usec
, USEC_PER_SEC
),
851 prefix
, format_timespan(buf_stop
, sizeof(buf_stop
), s
->timeout_stop_usec
, USEC_PER_SEC
),
852 prefix
, format_timespan(buf_runtime
, sizeof(buf_runtime
), s
->runtime_max_usec
, USEC_PER_SEC
),
853 prefix
, format_timespan(buf_watchdog
, sizeof(buf_watchdog
), s
->watchdog_usec
, USEC_PER_SEC
));
855 kill_context_dump(&s
->kill_context
, f
, prefix
);
856 exec_context_dump(&s
->exec_context
, f
, prefix
);
858 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
860 if (!s
->exec_command
[c
])
863 fprintf(f
, "%s-> %s:\n",
864 prefix
, service_exec_command_to_string(c
));
866 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
870 fprintf(f
, "%sStatus Text: %s\n",
871 prefix
, s
->status_text
);
873 if (s
->n_fd_store_max
> 0)
875 "%sFile Descriptor Store Max: %u\n"
876 "%sFile Descriptor Store Current: %u\n",
877 prefix
, s
->n_fd_store_max
,
878 prefix
, s
->n_fd_store
);
880 cgroup_context_dump(&s
->cgroup_context
, f
, prefix
);
883 static int service_is_suitable_main_pid(Service
*s
, pid_t pid
, int prio
) {
887 assert(pid_is_valid(pid
));
889 /* Checks whether the specified PID is suitable as main PID for this service. returns negative if not, 0 if the
890 * PID is questionnable but should be accepted if the source of configuration is trusted. > 0 if the PID is
893 if (pid
== getpid_cached() || pid
== 1) {
894 log_unit_full(UNIT(s
), prio
, 0, "New main PID "PID_FMT
" is the manager, refusing.", pid
);
898 if (pid
== s
->control_pid
) {
899 log_unit_full(UNIT(s
), prio
, 0, "New main PID "PID_FMT
" is the control process, refusing.", pid
);
903 if (!pid_is_alive(pid
)) {
904 log_unit_full(UNIT(s
), prio
, 0, "New main PID "PID_FMT
" does not exist or is a zombie.", pid
);
908 owner
= manager_get_unit_by_pid(UNIT(s
)->manager
, pid
);
909 if (owner
== UNIT(s
)) {
910 log_unit_debug(UNIT(s
), "New main PID "PID_FMT
" belongs to service, we are happy.", pid
);
911 return 1; /* Yay, it's definitely a good PID */
914 return 0; /* Hmm it's a suspicious PID, let's accept it if configuration source is trusted */
917 static int service_load_pid_file(Service
*s
, bool may_warn
) {
918 char procfs
[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
919 bool questionable_pid_file
= false;
920 _cleanup_free_
char *k
= NULL
;
921 _cleanup_close_
int fd
= -1;
930 prio
= may_warn
? LOG_INFO
: LOG_DEBUG
;
932 fd
= chase_symlinks(s
->pid_file
, NULL
, CHASE_OPEN
|CHASE_SAFE
, NULL
);
934 log_unit_full(UNIT(s
), LOG_DEBUG
, fd
, "Permission denied while opening PID file or potentially unsafe symlink chain, will now retry with relaxed checks: %s", s
->pid_file
);
936 questionable_pid_file
= true;
938 fd
= chase_symlinks(s
->pid_file
, NULL
, CHASE_OPEN
, NULL
);
941 return log_unit_full(UNIT(s
), prio
, fd
, "Can't open PID file %s (yet?) after %s: %m", s
->pid_file
, service_state_to_string(s
->state
));
943 /* Let's read the PID file now that we chased it down. But we need to convert the O_PATH fd chase_symlinks() returned us into a proper fd first. */
944 xsprintf(procfs
, "/proc/self/fd/%i", fd
);
945 r
= read_one_line_file(procfs
, &k
);
947 return log_unit_error_errno(UNIT(s
), r
, "Can't convert PID files %s O_PATH file descriptor to proper file descriptor: %m", s
->pid_file
);
949 r
= parse_pid(k
, &pid
);
951 return log_unit_full(UNIT(s
), prio
, r
, "Failed to parse PID from file %s: %m", s
->pid_file
);
953 if (s
->main_pid_known
&& pid
== s
->main_pid
)
956 r
= service_is_suitable_main_pid(s
, pid
, prio
);
962 if (questionable_pid_file
) {
963 log_unit_error(UNIT(s
), "Refusing to accept PID outside of service control group, acquired through unsafe symlink chain: %s", s
->pid_file
);
967 /* Hmm, it's not clear if the new main PID is safe. Let's allow this if the PID file is owned by root */
969 if (fstat(fd
, &st
) < 0)
970 return log_unit_error_errno(UNIT(s
), errno
, "Failed to fstat() PID file O_PATH fd: %m");
972 if (st
.st_uid
!= 0) {
973 log_unit_error(UNIT(s
), "New main PID "PID_FMT
" does not belong to service, and PID file is not owned by root. Refusing.", pid
);
977 log_unit_debug(UNIT(s
), "New main PID "PID_FMT
" does not belong to service, but we'll accept it since PID file is owned by root.", pid
);
980 if (s
->main_pid_known
) {
981 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
983 service_unwatch_main_pid(s
);
984 s
->main_pid_known
= false;
986 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
988 r
= service_set_main_pid(s
, pid
);
992 r
= unit_watch_pid(UNIT(s
), pid
);
993 if (r
< 0) /* FIXME: we need to do something here */
994 return log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
999 static void service_search_main_pid(Service
*s
) {
1005 /* If we know it anyway, don't ever fallback to unreliable
1007 if (s
->main_pid_known
)
1010 if (!s
->guess_main_pid
)
1013 assert(s
->main_pid
<= 0);
1015 if (unit_search_main_pid(UNIT(s
), &pid
) < 0)
1018 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
1019 if (service_set_main_pid(s
, pid
) < 0)
1022 r
= unit_watch_pid(UNIT(s
), pid
);
1024 /* FIXME: we need to do something here */
1025 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
1028 static void service_set_state(Service
*s
, ServiceState state
) {
1029 ServiceState old_state
;
1030 const UnitActiveState
*table
;
1034 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
1036 old_state
= s
->state
;
1039 service_unwatch_pid_file(s
);
1042 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1045 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1046 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
1047 SERVICE_AUTO_RESTART
))
1048 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1051 SERVICE_START
, SERVICE_START_POST
,
1052 SERVICE_RUNNING
, SERVICE_RELOAD
,
1053 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1054 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
1055 service_unwatch_main_pid(s
);
1056 s
->main_command
= NULL
;
1060 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1062 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1063 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
1064 service_unwatch_control_pid(s
);
1065 s
->control_command
= NULL
;
1066 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1069 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1070 unit_unwatch_all_pids(UNIT(s
));
1073 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1074 SERVICE_RUNNING
, SERVICE_RELOAD
,
1075 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1076 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
1077 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
))
1078 service_close_socket_fd(s
);
1080 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
1081 service_stop_watchdog(s
);
1083 /* For the inactive states unit_notify() will trim the cgroup,
1084 * but for exit we have to do that ourselves... */
1085 if (state
== SERVICE_EXITED
&& !MANAGER_IS_RELOADING(UNIT(s
)->manager
))
1086 unit_prune_cgroup(UNIT(s
));
1088 if (old_state
!= state
)
1089 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
1091 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
1094 static usec_t
service_coldplug_timeout(Service
*s
) {
1097 switch (s
->deserialized_state
) {
1099 case SERVICE_START_PRE
:
1101 case SERVICE_START_POST
:
1102 case SERVICE_RELOAD
:
1103 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_start_usec
);
1105 case SERVICE_RUNNING
:
1106 return usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
);
1109 case SERVICE_STOP_SIGABRT
:
1110 case SERVICE_STOP_SIGTERM
:
1111 case SERVICE_STOP_SIGKILL
:
1112 case SERVICE_STOP_POST
:
1113 case SERVICE_FINAL_SIGTERM
:
1114 case SERVICE_FINAL_SIGKILL
:
1115 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_stop_usec
);
1117 case SERVICE_AUTO_RESTART
:
1118 return usec_add(UNIT(s
)->inactive_enter_timestamp
.monotonic
, s
->restart_usec
);
1121 return USEC_INFINITY
;
1125 static int service_coldplug(Unit
*u
) {
1126 Service
*s
= SERVICE(u
);
1130 assert(s
->state
== SERVICE_DEAD
);
1132 if (s
->deserialized_state
== s
->state
)
1135 r
= service_arm_timer(s
, service_coldplug_timeout(s
));
1139 if (s
->main_pid
> 0 &&
1140 pid_is_unwaited(s
->main_pid
) &&
1141 (IN_SET(s
->deserialized_state
,
1142 SERVICE_START
, SERVICE_START_POST
,
1143 SERVICE_RUNNING
, SERVICE_RELOAD
,
1144 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1145 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
1146 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
1151 if (s
->control_pid
> 0 &&
1152 pid_is_unwaited(s
->control_pid
) &&
1153 IN_SET(s
->deserialized_state
,
1154 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1156 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1157 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
1158 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1163 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1164 unit_watch_all_pids(UNIT(s
));
1166 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
1167 service_start_watchdog(s
);
1169 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
)) {
1170 (void) unit_setup_dynamic_creds(u
);
1171 (void) unit_setup_exec_runtime(u
);
1174 if (UNIT_ISSET(s
->accept_socket
)) {
1175 Socket
* socket
= SOCKET(UNIT_DEREF(s
->accept_socket
));
1177 if (socket
->max_connections_per_source
> 0) {
1180 /* Make a best-effort attempt at bumping the connection count */
1181 if (socket_acquire_peer(socket
, s
->socket_fd
, &peer
) > 0) {
1182 socket_peer_unref(s
->peer
);
1188 service_set_state(s
, s
->deserialized_state
);
1192 static int service_collect_fds(Service
*s
,
1195 unsigned *n_storage_fds
,
1196 unsigned *n_socket_fds
) {
1198 _cleanup_strv_free_
char **rfd_names
= NULL
;
1199 _cleanup_free_
int *rfds
= NULL
;
1200 unsigned rn_socket_fds
= 0, rn_storage_fds
= 0;
1206 assert(n_socket_fds
);
1208 if (s
->socket_fd
>= 0) {
1210 /* Pass the per-connection socket */
1215 rfds
[0] = s
->socket_fd
;
1217 rfd_names
= strv_new("connection", NULL
);
1227 /* Pass all our configured sockets for singleton services */
1229 HASHMAP_FOREACH_KEY(v
, u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1230 _cleanup_free_
int *cfds
= NULL
;
1234 if (u
->type
!= UNIT_SOCKET
)
1239 cn_fds
= socket_collect_fds(sock
, &cfds
);
1248 rn_socket_fds
= cn_fds
;
1254 t
= realloc(rfds
, (rn_socket_fds
+ cn_fds
) * sizeof(int));
1258 memcpy(t
+ rn_socket_fds
, cfds
, cn_fds
* sizeof(int));
1261 rn_socket_fds
+= cn_fds
;
1264 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1270 if (s
->n_fd_store
> 0) {
1276 t
= realloc(rfds
, (rn_socket_fds
+ s
->n_fd_store
) * sizeof(int));
1282 nl
= realloc(rfd_names
, (rn_socket_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1287 n_fds
= rn_socket_fds
;
1289 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1290 rfds
[n_fds
] = fs
->fd
;
1291 rfd_names
[n_fds
] = strdup(strempty(fs
->fdname
));
1292 if (!rfd_names
[n_fds
])
1299 rfd_names
[n_fds
] = NULL
;
1303 *fd_names
= rfd_names
;
1304 *n_socket_fds
= rn_socket_fds
;
1305 *n_storage_fds
= rn_storage_fds
;
1313 static bool service_exec_needs_notify_socket(Service
*s
, ExecFlags flags
) {
1316 /* Notifications are accepted depending on the process and
1317 * the access setting of the service:
1318 * process: \ access: NONE MAIN EXEC ALL
1319 * main no yes yes yes
1320 * control no no yes yes
1321 * other (forked) no no no yes */
1323 if (flags
& EXEC_IS_CONTROL
)
1324 /* A control process */
1325 return IN_SET(s
->notify_access
, NOTIFY_EXEC
, NOTIFY_ALL
);
1327 /* We only spawn main processes and control processes, so any
1328 * process that is not a control process is a main process */
1329 return s
->notify_access
!= NOTIFY_NONE
;
1332 static int service_spawn(
1339 ExecParameters exec_params
= {
1345 _cleanup_strv_free_
char **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1346 unsigned n_storage_fds
= 0, n_socket_fds
= 0, n_env
= 0;
1347 _cleanup_free_
int *fds
= NULL
;
1355 r
= unit_prepare_exec(UNIT(s
));
1359 if (flags
& EXEC_IS_CONTROL
) {
1360 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1361 if (s
->permissions_start_only
)
1362 exec_params
.flags
&= ~EXEC_APPLY_SANDBOXING
;
1363 if (s
->root_directory_start_only
)
1364 exec_params
.flags
&= ~EXEC_APPLY_CHROOT
;
1367 if ((flags
& EXEC_PASS_FDS
) ||
1368 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1369 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1370 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1372 r
= service_collect_fds(s
, &fds
, &fd_names
, &n_storage_fds
, &n_socket_fds
);
1376 log_unit_debug(UNIT(s
), "Passing %i fds to service", n_storage_fds
+ n_socket_fds
);
1379 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), timeout
));
1383 our_env
= new0(char*, 9);
1387 if (service_exec_needs_notify_socket(s
, flags
))
1388 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0)
1391 if (s
->main_pid
> 0)
1392 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0)
1395 if (MANAGER_IS_USER(UNIT(s
)->manager
))
1396 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid_cached()) < 0)
1399 if (s
->socket_fd
>= 0) {
1400 union sockaddr_union sa
;
1401 socklen_t salen
= sizeof(sa
);
1403 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1404 * useful. Note that we do this only when we are still connected at this point in time, which we might
1405 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1406 * in ENOTCONN), and just use whate we can use. */
1408 if (getpeername(s
->socket_fd
, &sa
.sa
, &salen
) >= 0 &&
1409 IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
, AF_VSOCK
)) {
1411 _cleanup_free_
char *addr
= NULL
;
1415 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1419 t
= strappend("REMOTE_ADDR=", addr
);
1422 our_env
[n_env
++] = t
;
1424 r
= sockaddr_port(&sa
.sa
, &port
);
1428 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0)
1430 our_env
[n_env
++] = t
;
1434 if (flags
& EXEC_SETENV_RESULT
) {
1435 if (asprintf(our_env
+ n_env
++, "SERVICE_RESULT=%s", service_result_to_string(s
->result
)) < 0)
1438 if (s
->main_exec_status
.pid
> 0 &&
1439 dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
1440 if (asprintf(our_env
+ n_env
++, "EXIT_CODE=%s", sigchld_code_to_string(s
->main_exec_status
.code
)) < 0)
1443 if (s
->main_exec_status
.code
== CLD_EXITED
)
1444 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%i", s
->main_exec_status
.status
);
1446 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%s", signal_to_string(s
->main_exec_status
.status
));
1452 manager_set_exec_params(UNIT(s
)->manager
, &exec_params
);
1453 unit_set_exec_params(UNIT(s
), &exec_params
);
1455 final_env
= strv_env_merge(2, exec_params
.environment
, our_env
, NULL
);
1459 /* System services should get a new keyring by default. */
1460 SET_FLAG(exec_params
.flags
, EXEC_NEW_KEYRING
, MANAGER_IS_SYSTEM(UNIT(s
)->manager
));
1462 /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1463 SET_FLAG(exec_params
.flags
, EXEC_NSS_BYPASS_BUS
,
1464 MANAGER_IS_SYSTEM(UNIT(s
)->manager
) && unit_has_name(UNIT(s
), SPECIAL_DBUS_SERVICE
));
1466 exec_params
.argv
= c
->argv
;
1467 exec_params
.environment
= final_env
;
1468 exec_params
.fds
= fds
;
1469 exec_params
.fd_names
= fd_names
;
1470 exec_params
.n_storage_fds
= n_storage_fds
;
1471 exec_params
.n_socket_fds
= n_socket_fds
;
1472 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1473 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1474 if (s
->type
== SERVICE_IDLE
)
1475 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1476 exec_params
.stdin_fd
= s
->stdin_fd
;
1477 exec_params
.stdout_fd
= s
->stdout_fd
;
1478 exec_params
.stderr_fd
= s
->stderr_fd
;
1480 r
= exec_spawn(UNIT(s
),
1490 r
= unit_watch_pid(UNIT(s
), pid
);
1491 if (r
< 0) /* FIXME: we need to do something here */
1499 static int main_pid_good(Service
*s
) {
1502 /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1504 /* If we know the pid file, then let's just check if it is
1506 if (s
->main_pid_known
) {
1508 /* If it's an alien child let's check if it is still
1510 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1511 return pid_is_alive(s
->main_pid
);
1513 /* .. otherwise assume we'll get a SIGCHLD for it,
1514 * which we really should wait for to collect exit
1515 * status and code */
1516 return s
->main_pid
> 0;
1519 /* We don't know the pid */
1523 static int control_pid_good(Service
*s
) {
1526 /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1527 * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1528 * means: we can't figure it out. */
1530 return s
->control_pid
> 0;
1533 static int cgroup_good(Service
*s
) {
1538 /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1541 if (!UNIT(s
)->cgroup_path
)
1544 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1551 static bool service_shall_restart(Service
*s
) {
1554 /* Don't restart after manual stops */
1555 if (s
->forbid_restart
)
1558 /* Never restart if this is configured as special exception */
1559 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1562 /* Restart if the exit code/status are configured as restart triggers */
1563 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1566 switch (s
->restart
) {
1568 case SERVICE_RESTART_NO
:
1571 case SERVICE_RESTART_ALWAYS
:
1574 case SERVICE_RESTART_ON_SUCCESS
:
1575 return s
->result
== SERVICE_SUCCESS
;
1577 case SERVICE_RESTART_ON_FAILURE
:
1578 return s
->result
!= SERVICE_SUCCESS
;
1580 case SERVICE_RESTART_ON_ABNORMAL
:
1581 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1583 case SERVICE_RESTART_ON_WATCHDOG
:
1584 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1586 case SERVICE_RESTART_ON_ABORT
:
1587 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1590 assert_not_reached("unknown restart setting");
1594 static bool service_will_restart(Unit
*u
) {
1595 Service
*s
= SERVICE(u
);
1599 if (s
->will_auto_restart
)
1601 if (s
->state
== SERVICE_AUTO_RESTART
)
1605 if (UNIT(s
)->job
->type
== JOB_START
)
1610 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1615 /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1616 * undo what has already been enqueued. */
1617 if (unit_stop_pending(UNIT(s
)))
1618 allow_restart
= false;
1620 if (s
->result
== SERVICE_SUCCESS
)
1623 if (s
->result
!= SERVICE_SUCCESS
)
1624 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1626 if (allow_restart
&& service_shall_restart(s
))
1627 s
->will_auto_restart
= true;
1629 /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1630 * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1631 s
->n_keep_fd_store
++;
1633 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1635 if (s
->will_auto_restart
) {
1636 s
->will_auto_restart
= false;
1638 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
1640 s
->n_keep_fd_store
--;
1644 service_set_state(s
, SERVICE_AUTO_RESTART
);
1646 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1647 * user can still introspect the counter. Do so on the next start. */
1648 s
->flush_n_restarts
= true;
1650 /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
1651 * queue, so that the fd store is possibly gc'ed again */
1652 s
->n_keep_fd_store
--;
1653 unit_add_to_gc_queue(UNIT(s
));
1655 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1656 s
->forbid_restart
= false;
1658 /* We want fresh tmpdirs in case service is started again immediately */
1659 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
, true);
1661 if (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_NO
||
1662 (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_RESTART
&& !service_will_restart(UNIT(s
))))
1663 /* Also, remove the runtime directory */
1664 exec_context_destroy_runtime_directory(&s
->exec_context
, UNIT(s
)->manager
->prefix
[EXEC_DIRECTORY_RUNTIME
]);
1666 /* Get rid of the IPC bits of the user */
1667 unit_unref_uid_gid(UNIT(s
), true);
1669 /* Release the user, and destroy it if we are the only remaining owner */
1670 dynamic_creds_destroy(&s
->dynamic_creds
);
1672 /* Try to delete the pid file. At this point it will be
1673 * out-of-date, and some software might be confused by it, so
1674 * let's remove it. */
1676 (void) unlink(s
->pid_file
);
1681 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1682 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1685 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1689 if (s
->result
== SERVICE_SUCCESS
)
1692 service_unwatch_control_pid(s
);
1693 unit_watch_all_pids(UNIT(s
));
1695 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1696 if (s
->control_command
) {
1697 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1699 r
= service_spawn(s
,
1701 s
->timeout_stop_usec
,
1702 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1707 service_set_state(s
, SERVICE_STOP_POST
);
1709 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1714 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1715 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1718 static int state_to_kill_operation(ServiceState state
) {
1721 case SERVICE_STOP_SIGABRT
:
1724 case SERVICE_STOP_SIGTERM
:
1725 case SERVICE_FINAL_SIGTERM
:
1726 return KILL_TERMINATE
;
1728 case SERVICE_STOP_SIGKILL
:
1729 case SERVICE_FINAL_SIGKILL
:
1733 return _KILL_OPERATION_INVALID
;
1737 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1742 if (s
->result
== SERVICE_SUCCESS
)
1745 unit_watch_all_pids(UNIT(s
));
1747 r
= unit_kill_context(
1750 state_to_kill_operation(state
),
1758 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1762 service_set_state(s
, state
);
1763 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1764 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1765 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1766 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1767 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1768 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1770 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1775 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1777 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1778 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1780 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1783 static void service_enter_stop_by_notify(Service
*s
) {
1786 unit_watch_all_pids(UNIT(s
));
1788 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1790 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1791 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1794 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1799 if (s
->result
== SERVICE_SUCCESS
)
1802 service_unwatch_control_pid(s
);
1803 unit_watch_all_pids(UNIT(s
));
1805 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1806 if (s
->control_command
) {
1807 s
->control_command_id
= SERVICE_EXEC_STOP
;
1809 r
= service_spawn(s
,
1811 s
->timeout_stop_usec
,
1812 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1817 service_set_state(s
, SERVICE_STOP
);
1819 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1824 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1825 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1828 static bool service_good(Service
*s
) {
1832 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1835 main_pid_ok
= main_pid_good(s
);
1836 if (main_pid_ok
> 0) /* It's alive */
1838 if (main_pid_ok
== 0) /* It's dead */
1841 /* OK, we don't know anything about the main PID, maybe
1842 * because there is none. Let's check the control group
1845 return cgroup_good(s
) != 0;
1848 static void service_enter_running(Service
*s
, ServiceResult f
) {
1851 if (s
->result
== SERVICE_SUCCESS
)
1854 service_unwatch_control_pid(s
);
1856 if (service_good(s
)) {
1858 /* If there are any queued up sd_notify()
1859 * notifications, process them now */
1860 if (s
->notify_state
== NOTIFY_RELOADING
)
1861 service_enter_reload_by_notify(s
);
1862 else if (s
->notify_state
== NOTIFY_STOPPING
)
1863 service_enter_stop_by_notify(s
);
1865 service_set_state(s
, SERVICE_RUNNING
);
1866 service_arm_timer(s
, usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
));
1869 } else if (f
!= SERVICE_SUCCESS
)
1870 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
1871 else if (s
->remain_after_exit
)
1872 service_set_state(s
, SERVICE_EXITED
);
1874 service_enter_stop(s
, SERVICE_SUCCESS
);
1877 static void service_enter_start_post(Service
*s
) {
1881 service_unwatch_control_pid(s
);
1882 service_reset_watchdog(s
);
1884 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1885 if (s
->control_command
) {
1886 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1888 r
= service_spawn(s
,
1890 s
->timeout_start_usec
,
1891 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
1896 service_set_state(s
, SERVICE_START_POST
);
1898 service_enter_running(s
, SERVICE_SUCCESS
);
1903 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1904 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1907 static void service_kill_control_process(Service
*s
) {
1912 if (s
->control_pid
<= 0)
1915 r
= kill_and_sigcont(s
->control_pid
, SIGKILL
);
1917 _cleanup_free_
char *comm
= NULL
;
1919 (void) get_process_comm(s
->control_pid
, &comm
);
1921 log_unit_debug_errno(UNIT(s
), r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m",
1922 s
->control_pid
, strna(comm
));
1926 static void service_enter_start(Service
*s
) {
1934 service_unwatch_control_pid(s
);
1935 service_unwatch_main_pid(s
);
1937 unit_warn_leftover_processes(UNIT(s
));
1939 if (s
->type
== SERVICE_FORKING
) {
1940 s
->control_command_id
= SERVICE_EXEC_START
;
1941 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1943 s
->main_command
= NULL
;
1945 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1946 s
->control_command
= NULL
;
1948 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1952 if (s
->type
!= SERVICE_ONESHOT
) {
1953 /* There's no command line configured for the main command? Hmm, that is strange. This can only
1954 * happen if the configuration changes at runtime. In this case, let's enter a failure
1956 log_unit_error(UNIT(s
), "There's no 'start' task anymore we could start: %m");
1961 service_enter_start_post(s
);
1965 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
))
1966 /* For simple + idle this is the main process. We don't apply any timeout here, but
1967 * service_enter_running() will later apply the .runtime_max_usec timeout. */
1968 timeout
= USEC_INFINITY
;
1970 timeout
= s
->timeout_start_usec
;
1972 r
= service_spawn(s
,
1975 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
1980 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
)) {
1981 /* For simple services we immediately start
1982 * the START_POST binaries. */
1984 service_set_main_pid(s
, pid
);
1985 service_enter_start_post(s
);
1987 } else if (s
->type
== SERVICE_FORKING
) {
1989 /* For forking services we wait until the start
1990 * process exited. */
1992 s
->control_pid
= pid
;
1993 service_set_state(s
, SERVICE_START
);
1995 } else if (IN_SET(s
->type
, SERVICE_ONESHOT
, SERVICE_DBUS
, SERVICE_NOTIFY
)) {
1997 /* For oneshot services we wait until the start
1998 * process exited, too, but it is our main process. */
2000 /* For D-Bus services we know the main pid right away,
2001 * but wait for the bus name to appear on the
2002 * bus. Notify services are similar. */
2004 service_set_main_pid(s
, pid
);
2005 service_set_state(s
, SERVICE_START
);
2007 assert_not_reached("Unknown service type");
2012 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
2013 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2016 static void service_enter_start_pre(Service
*s
) {
2021 service_unwatch_control_pid(s
);
2023 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
2024 if (s
->control_command
) {
2026 unit_warn_leftover_processes(UNIT(s
));
2028 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
2030 r
= service_spawn(s
,
2032 s
->timeout_start_usec
,
2033 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_APPLY_TTY_STDIN
,
2038 service_set_state(s
, SERVICE_START_PRE
);
2040 service_enter_start(s
);
2045 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
2046 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
2049 static void service_enter_restart(Service
*s
) {
2050 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2055 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
2056 /* Don't restart things if we are going down anyway */
2057 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
2059 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
2066 /* Any units that are bound to this service must also be
2067 * restarted. We use JOB_RESTART (instead of the more obvious
2068 * JOB_START) here so that those dependency jobs will be added
2070 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, &error
, NULL
);
2074 /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
2075 * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
2076 * explicitly however via the usual "systemctl reset-failure" logic. */
2078 s
->flush_n_restarts
= false;
2080 log_struct(LOG_INFO
,
2081 "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR
,
2082 LOG_UNIT_ID(UNIT(s
)),
2083 LOG_UNIT_INVOCATION_ID(UNIT(s
)),
2084 LOG_UNIT_MESSAGE(UNIT(s
), "Scheduled restart job, restart counter is at %u.", s
->n_restarts
),
2085 "N_RESTARTS=%u", s
->n_restarts
,
2088 /* Notify clients about changed restart counter */
2089 unit_add_to_dbus_queue(UNIT(s
));
2091 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2092 * it will be canceled as part of the service_stop() call that
2093 * is executed as part of JOB_RESTART. */
2098 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
2099 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
2102 static void service_enter_reload_by_notify(Service
*s
) {
2103 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2108 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_start_usec
));
2109 service_set_state(s
, SERVICE_RELOAD
);
2111 /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2112 r
= manager_propagate_reload(UNIT(s
)->manager
, UNIT(s
), JOB_FAIL
, &error
);
2114 log_unit_warning(UNIT(s
), "Failed to schedule propagation of reload: %s", bus_error_message(&error
, -r
));
2117 static void service_enter_reload(Service
*s
) {
2122 service_unwatch_control_pid(s
);
2123 s
->reload_result
= SERVICE_SUCCESS
;
2125 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
2126 if (s
->control_command
) {
2127 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
2129 r
= service_spawn(s
,
2131 s
->timeout_start_usec
,
2132 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
2137 service_set_state(s
, SERVICE_RELOAD
);
2139 service_enter_running(s
, SERVICE_SUCCESS
);
2144 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
2145 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2146 service_enter_running(s
, SERVICE_SUCCESS
);
2149 static void service_run_next_control(Service
*s
) {
2154 assert(s
->control_command
);
2155 assert(s
->control_command
->command_next
);
2157 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
2159 s
->control_command
= s
->control_command
->command_next
;
2160 service_unwatch_control_pid(s
);
2162 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
2163 timeout
= s
->timeout_start_usec
;
2165 timeout
= s
->timeout_stop_usec
;
2167 r
= service_spawn(s
,
2170 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|
2171 (IN_SET(s
->control_command_id
, SERVICE_EXEC_START_PRE
, SERVICE_EXEC_STOP_POST
) ? EXEC_APPLY_TTY_STDIN
: 0)|
2172 (IN_SET(s
->control_command_id
, SERVICE_EXEC_STOP
, SERVICE_EXEC_STOP_POST
) ? EXEC_SETENV_RESULT
: 0),
2180 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
2182 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START_POST
, SERVICE_STOP
))
2183 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2184 else if (s
->state
== SERVICE_STOP_POST
)
2185 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
2186 else if (s
->state
== SERVICE_RELOAD
) {
2187 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2188 service_enter_running(s
, SERVICE_SUCCESS
);
2190 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2193 static void service_run_next_main(Service
*s
) {
2198 assert(s
->main_command
);
2199 assert(s
->main_command
->command_next
);
2200 assert(s
->type
== SERVICE_ONESHOT
);
2202 s
->main_command
= s
->main_command
->command_next
;
2203 service_unwatch_main_pid(s
);
2205 r
= service_spawn(s
,
2207 s
->timeout_start_usec
,
2208 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
2213 service_set_main_pid(s
, pid
);
2218 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
2219 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2222 static int service_start(Unit
*u
) {
2223 Service
*s
= SERVICE(u
);
2228 /* We cannot fulfill this request right now, try again later
2230 if (IN_SET(s
->state
,
2231 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2232 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2235 /* Already on it! */
2236 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
2239 /* A service that will be restarted must be stopped first to
2240 * trigger BindsTo and/or OnFailure dependencies. If a user
2241 * does not want to wait for the holdoff time to elapse, the
2242 * service should be manually restarted, not started. We
2243 * simply return EAGAIN here, so that any start jobs stay
2244 * queued, and assume that the auto restart timer will
2245 * eventually trigger the restart. */
2246 if (s
->state
== SERVICE_AUTO_RESTART
)
2249 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
2251 /* Make sure we don't enter a busy loop of some kind. */
2252 r
= unit_start_limit_test(u
);
2254 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT_HIT
, false);
2258 r
= unit_acquire_invocation_id(u
);
2262 s
->result
= SERVICE_SUCCESS
;
2263 s
->reload_result
= SERVICE_SUCCESS
;
2264 s
->main_pid_known
= false;
2265 s
->main_pid_alien
= false;
2266 s
->forbid_restart
= false;
2268 u
->reset_accounting
= true;
2270 s
->status_text
= mfree(s
->status_text
);
2271 s
->status_errno
= 0;
2273 s
->notify_state
= NOTIFY_UNKNOWN
;
2275 s
->watchdog_override_enable
= false;
2276 s
->watchdog_override_usec
= 0;
2278 /* This is not an automatic restart? Flush the restart counter then */
2279 if (s
->flush_n_restarts
) {
2281 s
->flush_n_restarts
= false;
2284 service_enter_start_pre(s
);
2288 static int service_stop(Unit
*u
) {
2289 Service
*s
= SERVICE(u
);
2293 /* Don't create restart jobs from manual stops. */
2294 s
->forbid_restart
= true;
2297 if (IN_SET(s
->state
,
2298 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2299 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2302 /* A restart will be scheduled or is in progress. */
2303 if (s
->state
== SERVICE_AUTO_RESTART
) {
2304 service_set_state(s
, SERVICE_DEAD
);
2308 /* If there's already something running we go directly into
2310 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2311 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2315 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2317 service_enter_stop(s
, SERVICE_SUCCESS
);
2321 static int service_reload(Unit
*u
) {
2322 Service
*s
= SERVICE(u
);
2326 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2328 service_enter_reload(s
);
2332 _pure_
static bool service_can_reload(Unit
*u
) {
2333 Service
*s
= SERVICE(u
);
2337 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2340 static unsigned service_exec_command_index(Unit
*u
, ServiceExecCommand id
, ExecCommand
*current
) {
2341 Service
*s
= SERVICE(u
);
2343 ExecCommand
*first
, *c
;
2347 first
= s
->exec_command
[id
];
2349 /* Figure out where we are in the list by walking back to the beginning */
2350 for (c
= current
; c
!= first
; c
= c
->command_prev
)
2356 static int service_serialize_exec_command(Unit
*u
, FILE *f
, ExecCommand
*command
) {
2357 Service
*s
= SERVICE(u
);
2358 ServiceExecCommand id
;
2362 _cleanup_free_
char *args
= NULL
, *p
= NULL
;
2363 size_t allocated
= 0, length
= 0;
2371 if (command
== s
->control_command
) {
2373 id
= s
->control_command_id
;
2376 id
= SERVICE_EXEC_START
;
2379 idx
= service_exec_command_index(u
, id
, command
);
2381 STRV_FOREACH(arg
, command
->argv
) {
2383 _cleanup_free_
char *e
= NULL
;
2385 e
= xescape(*arg
, WHITESPACE
);
2390 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1 + n
+ 1))
2394 args
[length
++] = ' ';
2396 memcpy(args
+ length
, e
, n
);
2400 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1))
2404 p
= xescape(command
->path
, WHITESPACE
);
2408 fprintf(f
, "%s-command=%s %u %s %s\n", type
, service_exec_command_to_string(id
), idx
, p
, args
);
2413 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2414 Service
*s
= SERVICE(u
);
2422 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2423 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2424 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2426 if (s
->control_pid
> 0)
2427 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2429 if (s
->main_pid_known
&& s
->main_pid
> 0)
2430 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2432 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2433 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2434 unit_serialize_item(u
, f
, "bus-name-owner", s
->bus_name_owner
);
2436 unit_serialize_item_format(u
, f
, "n-restarts", "%u", s
->n_restarts
);
2437 unit_serialize_item(u
, f
, "flush-n-restarts", yes_no(s
->flush_n_restarts
));
2439 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2443 service_serialize_exec_command(u
, f
, s
->control_command
);
2444 service_serialize_exec_command(u
, f
, s
->main_command
);
2446 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2449 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2452 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2456 if (UNIT_ISSET(s
->accept_socket
)) {
2457 r
= unit_serialize_item(u
, f
, "accept-socket", UNIT_DEREF(s
->accept_socket
)->id
);
2462 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2466 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2467 _cleanup_free_
char *c
= NULL
;
2470 copy
= fdset_put_dup(fds
, fs
->fd
);
2474 c
= cescape(fs
->fdname
);
2476 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2479 if (s
->main_exec_status
.pid
> 0) {
2480 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2481 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2482 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2484 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2485 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2486 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2490 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2492 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2494 if (s
->watchdog_override_enable
)
2495 unit_serialize_item_format(u
, f
, "watchdog-override-usec", USEC_FMT
, s
->watchdog_override_usec
);
2500 static int service_deserialize_exec_command(Unit
*u
, const char *key
, const char *value
) {
2501 Service
*s
= SERVICE(u
);
2503 unsigned idx
= 0, i
;
2504 bool control
, found
= false;
2505 ServiceExecCommand id
= _SERVICE_EXEC_COMMAND_INVALID
;
2506 ExecCommand
*command
= NULL
;
2507 _cleanup_free_
char *path
= NULL
;
2508 _cleanup_strv_free_
char **argv
= NULL
;
2510 enum ExecCommandState
{
2511 STATE_EXEC_COMMAND_TYPE
,
2512 STATE_EXEC_COMMAND_INDEX
,
2513 STATE_EXEC_COMMAND_PATH
,
2514 STATE_EXEC_COMMAND_ARGS
,
2515 _STATE_EXEC_COMMAND_MAX
,
2516 _STATE_EXEC_COMMAND_INVALID
= -1,
2523 control
= streq(key
, "control-command");
2525 state
= STATE_EXEC_COMMAND_TYPE
;
2528 _cleanup_free_
char *arg
= NULL
;
2530 r
= extract_first_word(&value
, &arg
, NULL
, EXTRACT_CUNESCAPE
);
2537 case STATE_EXEC_COMMAND_TYPE
:
2538 id
= service_exec_command_from_string(arg
);
2542 state
= STATE_EXEC_COMMAND_INDEX
;
2544 case STATE_EXEC_COMMAND_INDEX
:
2545 r
= safe_atou(arg
, &idx
);
2549 state
= STATE_EXEC_COMMAND_PATH
;
2551 case STATE_EXEC_COMMAND_PATH
:
2554 state
= STATE_EXEC_COMMAND_ARGS
;
2556 if (!path_is_absolute(path
))
2559 case STATE_EXEC_COMMAND_ARGS
:
2560 r
= strv_extend(&argv
, arg
);
2565 assert_not_reached("Unknown error at deserialization of exec command");
2570 if (state
!= STATE_EXEC_COMMAND_ARGS
)
2573 /* Let's check whether exec command on given offset matches data that we just deserialized */
2574 for (command
= s
->exec_command
[id
], i
= 0; command
; command
= command
->command_next
, i
++) {
2578 found
= strv_equal(argv
, command
->argv
) && streq(command
->path
, path
);
2583 /* Command at the index we serialized is different, let's look for command that exactly
2584 * matches but is on different index. If there is no such command we will not resume execution. */
2585 for (command
= s
->exec_command
[id
]; command
; command
= command
->command_next
)
2586 if (strv_equal(command
->argv
, argv
) && streq(command
->path
, path
))
2590 if (command
&& control
)
2591 s
->control_command
= command
;
2593 s
->main_command
= command
;
2595 log_unit_warning(u
, "Current command vanished from the unit file, execution of the command list won't be resumed.");
2600 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2601 Service
*s
= SERVICE(u
);
2609 if (streq(key
, "state")) {
2612 state
= service_state_from_string(value
);
2614 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2616 s
->deserialized_state
= state
;
2617 } else if (streq(key
, "result")) {
2620 f
= service_result_from_string(value
);
2622 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2623 else if (f
!= SERVICE_SUCCESS
)
2626 } else if (streq(key
, "reload-result")) {
2629 f
= service_result_from_string(value
);
2631 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2632 else if (f
!= SERVICE_SUCCESS
)
2633 s
->reload_result
= f
;
2635 } else if (streq(key
, "control-pid")) {
2638 if (parse_pid(value
, &pid
) < 0)
2639 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2641 s
->control_pid
= pid
;
2642 } else if (streq(key
, "main-pid")) {
2645 if (parse_pid(value
, &pid
) < 0)
2646 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2648 (void) service_set_main_pid(s
, pid
);
2649 } else if (streq(key
, "main-pid-known")) {
2652 b
= parse_boolean(value
);
2654 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2656 s
->main_pid_known
= b
;
2657 } else if (streq(key
, "bus-name-good")) {
2660 b
= parse_boolean(value
);
2662 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2664 s
->bus_name_good
= b
;
2665 } else if (streq(key
, "bus-name-owner")) {
2666 r
= free_and_strdup(&s
->bus_name_owner
, value
);
2668 log_unit_error_errno(u
, r
, "Unable to deserialize current bus owner %s: %m", value
);
2669 } else if (streq(key
, "status-text")) {
2672 r
= cunescape(value
, 0, &t
);
2674 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2676 free(s
->status_text
);
2680 } else if (streq(key
, "accept-socket")) {
2683 r
= manager_load_unit(u
->manager
, value
, NULL
, NULL
, &socket
);
2685 log_unit_debug_errno(u
, r
, "Failed to load accept-socket unit: %s", value
);
2687 unit_ref_set(&s
->accept_socket
, socket
);
2688 SOCKET(socket
)->n_connections
++;
2691 } else if (streq(key
, "socket-fd")) {
2694 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2695 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2697 asynchronous_close(s
->socket_fd
);
2698 s
->socket_fd
= fdset_remove(fds
, fd
);
2700 } else if (streq(key
, "fd-store-fd")) {
2705 pf
= strcspn(value
, WHITESPACE
);
2706 fdv
= strndupa(value
, pf
);
2708 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2709 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2711 _cleanup_free_
char *t
= NULL
;
2715 fdn
+= strspn(fdn
, WHITESPACE
);
2716 (void) cunescape(fdn
, 0, &t
);
2718 r
= service_add_fd_store(s
, fd
, t
);
2720 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2722 fdset_remove(fds
, fd
);
2725 } else if (streq(key
, "main-exec-status-pid")) {
2728 if (parse_pid(value
, &pid
) < 0)
2729 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2731 s
->main_exec_status
.pid
= pid
;
2732 } else if (streq(key
, "main-exec-status-code")) {
2735 if (safe_atoi(value
, &i
) < 0)
2736 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2738 s
->main_exec_status
.code
= i
;
2739 } else if (streq(key
, "main-exec-status-status")) {
2742 if (safe_atoi(value
, &i
) < 0)
2743 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2745 s
->main_exec_status
.status
= i
;
2746 } else if (streq(key
, "main-exec-status-start"))
2747 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2748 else if (streq(key
, "main-exec-status-exit"))
2749 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2750 else if (streq(key
, "watchdog-timestamp"))
2751 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2752 else if (streq(key
, "forbid-restart")) {
2755 b
= parse_boolean(value
);
2757 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2759 s
->forbid_restart
= b
;
2760 } else if (streq(key
, "stdin-fd")) {
2763 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2764 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2766 asynchronous_close(s
->stdin_fd
);
2767 s
->stdin_fd
= fdset_remove(fds
, fd
);
2768 s
->exec_context
.stdio_as_fds
= true;
2770 } else if (streq(key
, "stdout-fd")) {
2773 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2774 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2776 asynchronous_close(s
->stdout_fd
);
2777 s
->stdout_fd
= fdset_remove(fds
, fd
);
2778 s
->exec_context
.stdio_as_fds
= true;
2780 } else if (streq(key
, "stderr-fd")) {
2783 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2784 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2786 asynchronous_close(s
->stderr_fd
);
2787 s
->stderr_fd
= fdset_remove(fds
, fd
);
2788 s
->exec_context
.stdio_as_fds
= true;
2790 } else if (streq(key
, "watchdog-override-usec")) {
2791 usec_t watchdog_override_usec
;
2792 if (timestamp_deserialize(value
, &watchdog_override_usec
) < 0)
2793 log_unit_debug(u
, "Failed to parse watchdog_override_usec value: %s", value
);
2795 s
->watchdog_override_enable
= true;
2796 s
->watchdog_override_usec
= watchdog_override_usec
;
2798 } else if (STR_IN_SET(key
, "main-command", "control-command")) {
2799 r
= service_deserialize_exec_command(u
, key
, value
);
2801 log_unit_debug_errno(u
, r
, "Failed to parse serialized command \"%s\": %m", value
);
2803 } else if (streq(key
, "n-restarts")) {
2804 r
= safe_atou(value
, &s
->n_restarts
);
2806 log_unit_debug_errno(u
, r
, "Failed to parse serialized restart counter '%s': %m", value
);
2808 } else if (streq(key
, "flush-n-restarts")) {
2809 r
= parse_boolean(value
);
2811 log_unit_debug_errno(u
, r
, "Failed to parse serialized flush restart counter setting '%s': %m", value
);
2813 s
->flush_n_restarts
= r
;
2815 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2820 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2821 const UnitActiveState
*table
;
2825 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2827 return table
[SERVICE(u
)->state
];
2830 static const char *service_sub_state_to_string(Unit
*u
) {
2833 return service_state_to_string(SERVICE(u
)->state
);
2836 static bool service_may_gc(Unit
*u
) {
2837 Service
*s
= SERVICE(u
);
2841 /* Never clean up services that still have a process around, even if the service is formally dead. Note that
2842 * unit_may_gc() already checked our cgroup for us, we just check our two additional PIDs, too, in case they
2843 * have moved outside of the cgroup. */
2845 if (main_pid_good(s
) > 0 ||
2846 control_pid_good(s
) > 0)
2852 static int service_retry_pid_file(Service
*s
) {
2855 assert(s
->pid_file
);
2856 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2858 r
= service_load_pid_file(s
, false);
2862 service_unwatch_pid_file(s
);
2864 service_enter_running(s
, SERVICE_SUCCESS
);
2868 static int service_watch_pid_file(Service
*s
) {
2871 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2873 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2877 /* the pidfile might have appeared just before we set the watch */
2878 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2879 service_retry_pid_file(s
);
2883 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2884 service_unwatch_pid_file(s
);
2888 static int service_demand_pid_file(Service
*s
) {
2891 assert(s
->pid_file
);
2892 assert(!s
->pid_file_pathspec
);
2894 ps
= new0(PathSpec
, 1);
2899 ps
->path
= strdup(s
->pid_file
);
2905 path_kill_slashes(ps
->path
);
2907 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2908 * keep their PID file open all the time. */
2909 ps
->type
= PATH_MODIFIED
;
2910 ps
->inotify_fd
= -1;
2912 s
->pid_file_pathspec
= ps
;
2914 return service_watch_pid_file(s
);
2917 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2918 PathSpec
*p
= userdata
;
2923 s
= SERVICE(p
->unit
);
2927 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2928 assert(s
->pid_file_pathspec
);
2929 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2931 log_unit_debug(UNIT(s
), "inotify event");
2933 if (path_spec_fd_event(p
, events
) < 0)
2936 if (service_retry_pid_file(s
) == 0)
2939 if (service_watch_pid_file(s
) < 0)
2945 service_unwatch_pid_file(s
);
2946 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2950 static void service_notify_cgroup_empty_event(Unit
*u
) {
2951 Service
*s
= SERVICE(u
);
2955 log_unit_debug(u
, "cgroup is empty");
2959 /* Waiting for SIGCHLD is usually more interesting,
2960 * because it includes return codes/signals. Which is
2961 * why we ignore the cgroup events for most cases,
2962 * except when we don't know pid which to expect the
2966 if (s
->type
== SERVICE_NOTIFY
&&
2967 main_pid_good(s
) == 0 &&
2968 control_pid_good(s
) == 0) {
2969 /* No chance of getting a ready notification anymore */
2970 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2975 case SERVICE_START_POST
:
2976 if (s
->pid_file_pathspec
&&
2977 main_pid_good(s
) == 0 &&
2978 control_pid_good(s
) == 0) {
2980 /* Give up hoping for the daemon to write its PID file */
2981 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2983 service_unwatch_pid_file(s
);
2984 if (s
->state
== SERVICE_START
)
2985 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2987 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
2991 case SERVICE_RUNNING
:
2992 /* service_enter_running() will figure out what to do */
2993 service_enter_running(s
, SERVICE_SUCCESS
);
2996 case SERVICE_STOP_SIGABRT
:
2997 case SERVICE_STOP_SIGTERM
:
2998 case SERVICE_STOP_SIGKILL
:
3000 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
3001 service_enter_stop_post(s
, SERVICE_SUCCESS
);
3005 case SERVICE_STOP_POST
:
3006 case SERVICE_FINAL_SIGTERM
:
3007 case SERVICE_FINAL_SIGKILL
:
3008 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
3009 service_enter_dead(s
, SERVICE_SUCCESS
, true);
3018 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
3019 bool notify_dbus
= true;
3020 Service
*s
= SERVICE(u
);
3026 if (is_clean_exit(code
, status
, s
->type
== SERVICE_ONESHOT
? EXIT_CLEAN_COMMAND
: EXIT_CLEAN_DAEMON
, &s
->success_status
))
3027 f
= SERVICE_SUCCESS
;
3028 else if (code
== CLD_EXITED
)
3029 f
= SERVICE_FAILURE_EXIT_CODE
;
3030 else if (code
== CLD_KILLED
)
3031 f
= SERVICE_FAILURE_SIGNAL
;
3032 else if (code
== CLD_DUMPED
)
3033 f
= SERVICE_FAILURE_CORE_DUMP
;
3035 assert_not_reached("Unknown code");
3037 if (s
->main_pid
== pid
) {
3038 /* Forking services may occasionally move to a new PID.
3039 * As long as they update the PID file before exiting the old
3040 * PID, they're fine. */
3041 if (service_load_pid_file(s
, false) > 0)
3045 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
3047 if (s
->main_command
) {
3048 /* If this is not a forking service than the
3049 * main process got started and hence we copy
3050 * the exit status so that it is recorded both
3051 * as main and as control process exit
3054 s
->main_command
->exec_status
= s
->main_exec_status
;
3056 if (s
->main_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3057 f
= SERVICE_SUCCESS
;
3058 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
3060 /* If this is a forked process, then we should
3061 * ignore the return value if this was
3062 * configured for the starter process */
3064 if (s
->exec_command
[SERVICE_EXEC_START
]->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3065 f
= SERVICE_SUCCESS
;
3068 /* When this is a successful exit, let's log about the exit code on DEBUG level. If this is a failure
3069 * and the process exited on its own via exit(), then let's make this a NOTICE, under the assumption
3070 * that the service already logged the reason at a higher log level on its own. However, if the service
3071 * died due to a signal, then it most likely didn't say anything about any reason, hence let's raise
3072 * our log level to WARNING then. */
3074 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
:
3075 (code
== CLD_EXITED
? LOG_NOTICE
: LOG_WARNING
),
3076 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
3077 sigchld_code_to_string(code
), status
,
3078 strna(code
== CLD_EXITED
3079 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
3080 : signal_to_string(status
))),
3081 "EXIT_CODE=%s", sigchld_code_to_string(code
),
3082 "EXIT_STATUS=%i", status
,
3084 LOG_UNIT_INVOCATION_ID(u
),
3087 if (s
->result
== SERVICE_SUCCESS
)
3090 if (s
->main_command
&&
3091 s
->main_command
->command_next
&&
3092 s
->type
== SERVICE_ONESHOT
&&
3093 f
== SERVICE_SUCCESS
) {
3095 /* There is another command to *
3096 * execute, so let's do that. */
3098 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
3099 service_run_next_main(s
);
3103 /* The service exited, so the service is officially
3105 s
->main_command
= NULL
;
3109 case SERVICE_START_POST
:
3110 case SERVICE_RELOAD
:
3112 /* Need to wait until the operation is
3117 if (s
->type
== SERVICE_ONESHOT
) {
3118 /* This was our main goal, so let's go on */
3119 if (f
== SERVICE_SUCCESS
)
3120 service_enter_start_post(s
);
3122 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3124 } else if (s
->type
== SERVICE_NOTIFY
) {
3125 /* Only enter running through a notification, so that the
3126 * SERVICE_START state signifies that no ready notification
3127 * has been received */
3128 if (f
!= SERVICE_SUCCESS
)
3129 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3130 else if (!s
->remain_after_exit
|| s
->notify_access
== NOTIFY_MAIN
)
3131 /* The service has never been and will never be active */
3132 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3137 case SERVICE_RUNNING
:
3138 service_enter_running(s
, f
);
3141 case SERVICE_STOP_SIGABRT
:
3142 case SERVICE_STOP_SIGTERM
:
3143 case SERVICE_STOP_SIGKILL
:
3145 if (control_pid_good(s
) <= 0)
3146 service_enter_stop_post(s
, f
);
3148 /* If there is still a control process, wait for that first */
3151 case SERVICE_STOP_POST
:
3152 case SERVICE_FINAL_SIGTERM
:
3153 case SERVICE_FINAL_SIGKILL
:
3155 if (control_pid_good(s
) <= 0)
3156 service_enter_dead(s
, f
, true);
3160 assert_not_reached("Uh, main process died at wrong time.");
3164 } else if (s
->control_pid
== pid
) {
3167 if (s
->control_command
) {
3168 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
3170 if (s
->control_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3171 f
= SERVICE_SUCCESS
;
3174 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
3175 "Control process exited, code=%s status=%i",
3176 sigchld_code_to_string(code
), status
);
3178 if (s
->result
== SERVICE_SUCCESS
)
3181 if (s
->control_command
&&
3182 s
->control_command
->command_next
&&
3183 f
== SERVICE_SUCCESS
) {
3185 /* There is another command to *
3186 * execute, so let's do that. */
3188 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
3189 service_run_next_control(s
);
3192 /* No further commands for this step, so let's
3193 * figure out what to do next */
3195 s
->control_command
= NULL
;
3196 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
3198 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
3202 case SERVICE_START_PRE
:
3203 if (f
== SERVICE_SUCCESS
)
3204 service_enter_start(s
);
3206 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3210 if (s
->type
!= SERVICE_FORKING
)
3211 /* Maybe spurious event due to a reload that changed the type? */
3214 if (f
!= SERVICE_SUCCESS
) {
3215 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3220 bool has_start_post
;
3223 /* Let's try to load the pid file here if we can.
3224 * The PID file might actually be created by a START_POST
3225 * script. In that case don't worry if the loading fails. */
3227 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
3228 r
= service_load_pid_file(s
, !has_start_post
);
3229 if (!has_start_post
&& r
< 0) {
3230 r
= service_demand_pid_file(s
);
3231 if (r
< 0 || cgroup_good(s
) == 0)
3232 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3236 service_search_main_pid(s
);
3238 service_enter_start_post(s
);
3241 case SERVICE_START_POST
:
3242 if (f
!= SERVICE_SUCCESS
) {
3243 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3250 r
= service_load_pid_file(s
, true);
3252 r
= service_demand_pid_file(s
);
3253 if (r
< 0 || cgroup_good(s
) == 0)
3254 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
3258 service_search_main_pid(s
);
3260 service_enter_running(s
, SERVICE_SUCCESS
);
3263 case SERVICE_RELOAD
:
3264 if (f
== SERVICE_SUCCESS
)
3265 if (service_load_pid_file(s
, true) < 0)
3266 service_search_main_pid(s
);
3268 s
->reload_result
= f
;
3269 service_enter_running(s
, SERVICE_SUCCESS
);
3273 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3276 case SERVICE_STOP_SIGABRT
:
3277 case SERVICE_STOP_SIGTERM
:
3278 case SERVICE_STOP_SIGKILL
:
3279 if (main_pid_good(s
) <= 0)
3280 service_enter_stop_post(s
, f
);
3282 /* If there is still a service
3283 * process around, wait until
3284 * that one quit, too */
3287 case SERVICE_STOP_POST
:
3288 case SERVICE_FINAL_SIGTERM
:
3289 case SERVICE_FINAL_SIGKILL
:
3290 if (main_pid_good(s
) <= 0)
3291 service_enter_dead(s
, f
, true);
3295 assert_not_reached("Uh, control process died at wrong time.");
3298 } else /* Neither control nor main PID? If so, don't notify about anything */
3299 notify_dbus
= false;
3301 /* Notify clients about changed exit status */
3303 unit_add_to_dbus_queue(u
);
3305 /* If we get a SIGCHLD event for one of the processes we were interested in, then we look for others to watch,
3306 * under the assumption that we'll sooner or later get a SIGCHLD for them, as the original process we watched
3307 * was probably the parent of them, and they are hence now our children. */
3308 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
3309 unit_watch_all_pids(u
);
3311 /* If the PID set is empty now, then let's check if the cgroup is empty too and finish off the unit. */
3312 unit_synthesize_cgroup_empty_event(u
);
3315 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3316 Service
*s
= SERVICE(userdata
);
3319 assert(source
== s
->timer_event_source
);
3323 case SERVICE_START_PRE
:
3325 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
3326 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3329 case SERVICE_START_POST
:
3330 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
3331 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3334 case SERVICE_RUNNING
:
3335 log_unit_warning(UNIT(s
), "Service reached runtime time limit. Stopping.");
3336 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
3339 case SERVICE_RELOAD
:
3340 log_unit_warning(UNIT(s
), "Reload operation timed out. Killing reload process.");
3341 service_kill_control_process(s
);
3342 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
3343 service_enter_running(s
, SERVICE_SUCCESS
);
3347 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
3348 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3351 case SERVICE_STOP_SIGABRT
:
3352 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
3353 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3356 case SERVICE_STOP_SIGTERM
:
3357 if (s
->kill_context
.send_sigkill
) {
3358 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
3359 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3361 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
3362 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3367 case SERVICE_STOP_SIGKILL
:
3368 /* Uh, we sent a SIGKILL and it is still not gone?
3369 * Must be something we cannot kill, so let's just be
3370 * weirded out and continue */
3372 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
3373 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3376 case SERVICE_STOP_POST
:
3377 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
3378 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3381 case SERVICE_FINAL_SIGTERM
:
3382 if (s
->kill_context
.send_sigkill
) {
3383 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
3384 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3386 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
3387 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
3392 case SERVICE_FINAL_SIGKILL
:
3393 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
3394 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
3397 case SERVICE_AUTO_RESTART
:
3398 log_unit_info(UNIT(s
),
3399 s
->restart_usec
> 0 ?
3400 "Service hold-off time over, scheduling restart." :
3401 "Service has no hold-off time, scheduling restart.");
3402 service_enter_restart(s
);
3406 assert_not_reached("Timeout at wrong time.");
3412 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3413 Service
*s
= SERVICE(userdata
);
3414 char t
[FORMAT_TIMESPAN_MAX
];
3415 usec_t watchdog_usec
;
3418 assert(source
== s
->watchdog_event_source
);
3420 watchdog_usec
= service_get_watchdog_usec(s
);
3422 if (UNIT(s
)->manager
->service_watchdogs
) {
3423 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
3424 format_timespan(t
, sizeof(t
), watchdog_usec
, 1));
3426 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
3428 log_unit_warning(UNIT(s
), "Watchdog disabled! Ignoring watchdog timeout (limit %s)!",
3429 format_timespan(t
, sizeof(t
), watchdog_usec
, 1));
3434 static bool service_notify_message_authorized(Service
*s
, pid_t pid
, char **tags
, FDSet
*fds
) {
3437 if (s
->notify_access
== NOTIFY_NONE
) {
3438 log_unit_warning(UNIT(s
), "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
3442 if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
3443 if (s
->main_pid
!= 0)
3444 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
);
3446 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
);
3451 if (s
->notify_access
== NOTIFY_EXEC
&& pid
!= s
->main_pid
&& pid
!= s
->control_pid
) {
3452 if (s
->main_pid
!= 0 && s
->control_pid
!= 0)
3453 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
,
3454 pid
, s
->main_pid
, s
->control_pid
);
3455 else if (s
->main_pid
!= 0)
3456 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
);
3457 else if (s
->control_pid
!= 0)
3458 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
);
3460 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
);
3468 static void service_notify_message(
3470 const struct ucred
*ucred
,
3474 Service
*s
= SERVICE(u
);
3475 bool notify_dbus
= false;
3483 if (!service_notify_message_authorized(SERVICE(u
), ucred
->pid
, tags
, fds
))
3486 if (DEBUG_LOGGING
) {
3487 _cleanup_free_
char *cc
= NULL
;
3489 cc
= strv_join(tags
, ", ");
3490 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", ucred
->pid
, isempty(cc
) ? "n/a" : cc
);
3493 /* Interpret MAINPID= */
3494 e
= strv_find_startswith(tags
, "MAINPID=");
3495 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
3498 if (parse_pid(e
, &new_main_pid
) < 0)
3499 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message, ignoring: %s", e
);
3500 else if (!s
->main_pid_known
|| new_main_pid
!= s
->main_pid
) {
3502 r
= service_is_suitable_main_pid(s
, new_main_pid
, LOG_WARNING
);
3504 /* The new main PID is a bit suspicous, which is OK if the sender is privileged. */
3506 if (ucred
->uid
== 0) {
3507 log_unit_debug(u
, "New main PID "PID_FMT
" does not belong to service, but we'll accept it as the request to change it came from a privileged process.", new_main_pid
);
3510 log_unit_debug(u
, "New main PID "PID_FMT
" does not belong to service, refusing.", new_main_pid
);
3513 service_set_main_pid(s
, new_main_pid
);
3514 unit_watch_pid(UNIT(s
), new_main_pid
);
3520 /* Interpret READY=/STOPPING=/RELOADING=. Last one wins. */
3521 STRV_FOREACH_BACKWARDS(i
, tags
) {
3523 if (streq(*i
, "READY=1")) {
3524 s
->notify_state
= NOTIFY_READY
;
3526 /* Type=notify services inform us about completed
3527 * initialization with READY=1 */
3528 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
3529 service_enter_start_post(s
);
3531 /* Sending READY=1 while we are reloading informs us
3532 * that the reloading is complete */
3533 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
3534 service_enter_running(s
, SERVICE_SUCCESS
);
3539 } else if (streq(*i
, "RELOADING=1")) {
3540 s
->notify_state
= NOTIFY_RELOADING
;
3542 if (s
->state
== SERVICE_RUNNING
)
3543 service_enter_reload_by_notify(s
);
3548 } else if (streq(*i
, "STOPPING=1")) {
3549 s
->notify_state
= NOTIFY_STOPPING
;
3551 if (s
->state
== SERVICE_RUNNING
)
3552 service_enter_stop_by_notify(s
);
3559 /* Interpret STATUS= */
3560 e
= strv_find_startswith(tags
, "STATUS=");
3562 _cleanup_free_
char *t
= NULL
;
3565 if (!utf8_is_valid(e
))
3566 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3574 if (!streq_ptr(s
->status_text
, t
)) {
3575 free_and_replace(s
->status_text
, t
);
3580 /* Interpret ERRNO= */
3581 e
= strv_find_startswith(tags
, "ERRNO=");
3585 status_errno
= parse_errno(e
);
3586 if (status_errno
< 0)
3587 log_unit_warning_errno(u
, status_errno
,
3588 "Failed to parse ERRNO= field in notification message: %s", e
);
3589 else if (s
->status_errno
!= status_errno
) {
3590 s
->status_errno
= status_errno
;
3595 /* Interpret EXTEND_TIMEOUT= */
3596 e
= strv_find_startswith(tags
, "EXTEND_TIMEOUT_USEC=");
3598 usec_t extend_timeout_usec
;
3599 if (safe_atou64(e
, &extend_timeout_usec
) < 0)
3600 log_unit_warning(u
, "Failed to parse EXTEND_TIMEOUT_USEC=%s", e
);
3602 service_extend_timeout(s
, extend_timeout_usec
);
3605 /* Interpret WATCHDOG= */
3606 if (strv_find(tags
, "WATCHDOG=1"))
3607 service_reset_watchdog(s
);
3609 e
= strv_find_startswith(tags
, "WATCHDOG_USEC=");
3611 usec_t watchdog_override_usec
;
3612 if (safe_atou64(e
, &watchdog_override_usec
) < 0)
3613 log_unit_warning(u
, "Failed to parse WATCHDOG_USEC=%s", e
);
3615 service_reset_watchdog_timeout(s
, watchdog_override_usec
);
3618 /* Process FD store messages. Either FDSTOREREMOVE=1 for removal, or FDSTORE=1 for addition. In both cases,
3619 * process FDNAME= for picking the file descriptor name to use. Note that FDNAME= is required when removing
3620 * fds, but optional when pushing in new fds, for compatibility reasons. */
3621 if (strv_find(tags
, "FDSTOREREMOVE=1")) {
3624 name
= strv_find_startswith(tags
, "FDNAME=");
3625 if (!name
|| !fdname_is_valid(name
))
3626 log_unit_warning(u
, "FDSTOREREMOVE=1 requested, but no valid file descriptor name passed, ignoring.");
3628 service_remove_fd_store(s
, name
);
3630 } else if (strv_find(tags
, "FDSTORE=1")) {
3633 name
= strv_find_startswith(tags
, "FDNAME=");
3634 if (name
&& !fdname_is_valid(name
)) {
3635 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3639 (void) service_add_fd_store_set(s
, fds
, name
);
3642 /* Notify clients about changed status or main pid */
3644 unit_add_to_dbus_queue(u
);
3647 static int service_get_timeout(Unit
*u
, usec_t
*timeout
) {
3648 Service
*s
= SERVICE(u
);
3652 if (!s
->timer_event_source
)
3655 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
3658 if (t
== USEC_INFINITY
)
3665 static void service_bus_name_owner_change(
3668 const char *old_owner
,
3669 const char *new_owner
) {
3671 Service
*s
= SERVICE(u
);
3677 assert(streq(s
->bus_name
, name
));
3678 assert(old_owner
|| new_owner
);
3680 if (old_owner
&& new_owner
)
3681 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3683 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3685 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3687 s
->bus_name_good
= !!new_owner
;
3689 /* Track the current owner, so we can reconstruct changes after a daemon reload */
3690 r
= free_and_strdup(&s
->bus_name_owner
, new_owner
);
3692 log_unit_error_errno(u
, r
, "Unable to set new bus name owner %s: %m", new_owner
);
3696 if (s
->type
== SERVICE_DBUS
) {
3698 /* service_enter_running() will figure out what to
3700 if (s
->state
== SERVICE_RUNNING
)
3701 service_enter_running(s
, SERVICE_SUCCESS
);
3702 else if (s
->state
== SERVICE_START
&& new_owner
)
3703 service_enter_start_post(s
);
3705 } else if (new_owner
&&
3713 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
3716 /* Try to acquire PID from bus service */
3718 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3720 r
= sd_bus_creds_get_pid(creds
, &pid
);
3722 log_unit_debug(u
, "D-Bus name %s is now owned by process " PID_FMT
, name
, pid
);
3724 service_set_main_pid(s
, pid
);
3725 unit_watch_pid(UNIT(s
), pid
);
3730 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3731 _cleanup_free_
char *peer
= NULL
;
3737 /* This is called by the socket code when instantiating a new service for a stream socket and the socket needs
3738 * to be configured. We take ownership of the passed fd on success. */
3740 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3743 if (s
->socket_fd
>= 0)
3746 if (s
->state
!= SERVICE_DEAD
)
3749 if (getpeername_pretty(fd
, true, &peer
) >= 0) {
3751 if (UNIT(s
)->description
) {
3752 _cleanup_free_
char *a
;
3754 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")");
3758 r
= unit_set_description(UNIT(s
), a
);
3760 r
= unit_set_description(UNIT(s
), peer
);
3766 r
= unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false, UNIT_DEPENDENCY_IMPLICIT
);
3771 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3773 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3777 static void service_reset_failed(Unit
*u
) {
3778 Service
*s
= SERVICE(u
);
3782 if (s
->state
== SERVICE_FAILED
)
3783 service_set_state(s
, SERVICE_DEAD
);
3785 s
->result
= SERVICE_SUCCESS
;
3786 s
->reload_result
= SERVICE_SUCCESS
;
3788 s
->flush_n_restarts
= false;
3791 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3792 Service
*s
= SERVICE(u
);
3796 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3799 static int service_main_pid(Unit
*u
) {
3800 Service
*s
= SERVICE(u
);
3807 static int service_control_pid(Unit
*u
) {
3808 Service
*s
= SERVICE(u
);
3812 return s
->control_pid
;
3815 static bool service_needs_console(Unit
*u
) {
3816 Service
*s
= SERVICE(u
);
3820 /* We provide our own implementation of this here, instead of relying of the generic implementation
3821 * unit_needs_console() provides, since we want to return false if we are in SERVICE_EXITED state. */
3823 if (!exec_context_may_touch_console(&s
->exec_context
))
3826 return IN_SET(s
->state
,
3833 SERVICE_STOP_SIGABRT
,
3834 SERVICE_STOP_SIGTERM
,
3835 SERVICE_STOP_SIGKILL
,
3837 SERVICE_FINAL_SIGTERM
,
3838 SERVICE_FINAL_SIGKILL
);
3841 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3842 [SERVICE_RESTART_NO
] = "no",
3843 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3844 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3845 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3846 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3847 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3848 [SERVICE_RESTART_ALWAYS
] = "always",
3851 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3853 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3854 [SERVICE_SIMPLE
] = "simple",
3855 [SERVICE_FORKING
] = "forking",
3856 [SERVICE_ONESHOT
] = "oneshot",
3857 [SERVICE_DBUS
] = "dbus",
3858 [SERVICE_NOTIFY
] = "notify",
3859 [SERVICE_IDLE
] = "idle"
3862 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3864 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3865 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3866 [SERVICE_EXEC_START
] = "ExecStart",
3867 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3868 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3869 [SERVICE_EXEC_STOP
] = "ExecStop",
3870 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3873 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3875 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3876 [NOTIFY_UNKNOWN
] = "unknown",
3877 [NOTIFY_READY
] = "ready",
3878 [NOTIFY_RELOADING
] = "reloading",
3879 [NOTIFY_STOPPING
] = "stopping",
3882 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3884 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3885 [SERVICE_SUCCESS
] = "success",
3886 [SERVICE_FAILURE_RESOURCES
] = "resources",
3887 [SERVICE_FAILURE_PROTOCOL
] = "protocol",
3888 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3889 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3890 [SERVICE_FAILURE_SIGNAL
] = "signal",
3891 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3892 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3893 [SERVICE_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
3896 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3898 const UnitVTable service_vtable
= {
3899 .object_size
= sizeof(Service
),
3900 .exec_context_offset
= offsetof(Service
, exec_context
),
3901 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3902 .kill_context_offset
= offsetof(Service
, kill_context
),
3903 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3904 .dynamic_creds_offset
= offsetof(Service
, dynamic_creds
),
3910 .private_section
= "Service",
3912 .init
= service_init
,
3913 .done
= service_done
,
3914 .load
= service_load
,
3915 .release_resources
= service_release_resources
,
3917 .coldplug
= service_coldplug
,
3919 .dump
= service_dump
,
3921 .start
= service_start
,
3922 .stop
= service_stop
,
3923 .reload
= service_reload
,
3925 .can_reload
= service_can_reload
,
3927 .kill
= service_kill
,
3929 .serialize
= service_serialize
,
3930 .deserialize_item
= service_deserialize_item
,
3932 .active_state
= service_active_state
,
3933 .sub_state_to_string
= service_sub_state_to_string
,
3935 .will_restart
= service_will_restart
,
3937 .may_gc
= service_may_gc
,
3939 .sigchld_event
= service_sigchld_event
,
3941 .reset_failed
= service_reset_failed
,
3943 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3944 .notify_message
= service_notify_message
,
3946 .main_pid
= service_main_pid
,
3947 .control_pid
= service_control_pid
,
3949 .bus_name_owner_change
= service_bus_name_owner_change
,
3951 .bus_vtable
= bus_service_vtable
,
3952 .bus_set_property
= bus_service_set_property
,
3953 .bus_commit_properties
= bus_service_commit_properties
,
3955 .get_timeout
= service_get_timeout
,
3956 .needs_console
= service_needs_console
,
3957 .can_transient
= true,
3959 .status_message_formats
= {
3960 .starting_stopping
= {
3961 [0] = "Starting %s...",
3962 [1] = "Stopping %s...",
3964 .finished_start_job
= {
3965 [JOB_DONE
] = "Started %s.",
3966 [JOB_FAILED
] = "Failed to start %s.",
3968 .finished_stop_job
= {
3969 [JOB_DONE
] = "Stopped %s.",
3970 [JOB_FAILED
] = "Stopped (with error) %s.",