1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include "sd-messages.h"
27 #include "alloc-util.h"
29 #include "bus-error.h"
30 #include "bus-kernel.h"
32 #include "dbus-service.h"
36 #include "exit-status.h"
39 #include "format-util.h"
41 #include "load-dropin.h"
42 #include "load-fragment.h"
45 #include "parse-util.h"
46 #include "path-util.h"
47 #include "process-util.h"
49 #include "signal-util.h"
51 #include "stdio-util.h"
52 #include "string-table.h"
53 #include "string-util.h"
55 #include "unit-name.h"
60 static const UnitActiveState state_translation_table
[_SERVICE_STATE_MAX
] = {
61 [SERVICE_DEAD
] = UNIT_INACTIVE
,
62 [SERVICE_START_PRE
] = UNIT_ACTIVATING
,
63 [SERVICE_START
] = UNIT_ACTIVATING
,
64 [SERVICE_START_POST
] = UNIT_ACTIVATING
,
65 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
66 [SERVICE_EXITED
] = UNIT_ACTIVE
,
67 [SERVICE_RELOAD
] = UNIT_RELOADING
,
68 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
69 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
70 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
71 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
72 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
73 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
74 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
75 [SERVICE_FAILED
] = UNIT_FAILED
,
76 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
79 /* For Type=idle we never want to delay any other jobs, hence we
80 * consider idle jobs active as soon as we start working on them */
81 static const UnitActiveState state_translation_table_idle
[_SERVICE_STATE_MAX
] = {
82 [SERVICE_DEAD
] = UNIT_INACTIVE
,
83 [SERVICE_START_PRE
] = UNIT_ACTIVE
,
84 [SERVICE_START
] = UNIT_ACTIVE
,
85 [SERVICE_START_POST
] = UNIT_ACTIVE
,
86 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
87 [SERVICE_EXITED
] = UNIT_ACTIVE
,
88 [SERVICE_RELOAD
] = UNIT_RELOADING
,
89 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
90 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
91 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
92 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
93 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
94 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
95 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
96 [SERVICE_FAILED
] = UNIT_FAILED
,
97 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
100 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
);
101 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
102 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
);
104 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
);
105 static void service_enter_reload_by_notify(Service
*s
);
107 static void service_init(Unit
*u
) {
108 Service
*s
= SERVICE(u
);
111 assert(u
->load_state
== UNIT_STUB
);
113 s
->timeout_start_usec
= u
->manager
->default_timeout_start_usec
;
114 s
->timeout_stop_usec
= u
->manager
->default_timeout_stop_usec
;
115 s
->restart_usec
= u
->manager
->default_restart_usec
;
116 s
->runtime_max_usec
= USEC_INFINITY
;
117 s
->type
= _SERVICE_TYPE_INVALID
;
119 s
->stdin_fd
= s
->stdout_fd
= s
->stderr_fd
= -1;
120 s
->guess_main_pid
= true;
122 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
125 static void service_unwatch_control_pid(Service
*s
) {
128 if (s
->control_pid
<= 0)
131 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
135 static void service_unwatch_main_pid(Service
*s
) {
138 if (s
->main_pid
<= 0)
141 unit_unwatch_pid(UNIT(s
), s
->main_pid
);
145 static void service_unwatch_pid_file(Service
*s
) {
146 if (!s
->pid_file_pathspec
)
149 log_unit_debug(UNIT(s
), "Stopping watch for PID file %s", s
->pid_file_pathspec
->path
);
150 path_spec_unwatch(s
->pid_file_pathspec
);
151 path_spec_done(s
->pid_file_pathspec
);
152 s
->pid_file_pathspec
= mfree(s
->pid_file_pathspec
);
155 static int service_set_main_pid(Service
*s
, pid_t pid
) {
163 if (pid
== getpid_cached())
166 if (s
->main_pid
== pid
&& s
->main_pid_known
)
169 if (s
->main_pid
!= pid
) {
170 service_unwatch_main_pid(s
);
171 exec_status_start(&s
->main_exec_status
, pid
);
175 s
->main_pid_known
= true;
177 if (get_process_ppid(pid
, &ppid
) >= 0 && ppid
!= getpid_cached()) {
178 log_unit_warning(UNIT(s
), "Supervising process "PID_FMT
" which is not our child. We'll most likely not notice when it exits.", pid
);
179 s
->main_pid_alien
= true;
181 s
->main_pid_alien
= false;
186 void service_close_socket_fd(Service
*s
) {
189 /* Undo the effect of service_set_socket_fd(). */
191 s
->socket_fd
= asynchronous_close(s
->socket_fd
);
193 if (UNIT_ISSET(s
->accept_socket
)) {
194 socket_connection_unref(SOCKET(UNIT_DEREF(s
->accept_socket
)));
195 unit_ref_unset(&s
->accept_socket
);
199 static void service_stop_watchdog(Service
*s
) {
202 s
->watchdog_event_source
= sd_event_source_unref(s
->watchdog_event_source
);
203 s
->watchdog_timestamp
= DUAL_TIMESTAMP_NULL
;
206 static usec_t
service_get_watchdog_usec(Service
*s
) {
209 if (s
->watchdog_override_enable
)
210 return s
->watchdog_override_usec
;
212 return s
->watchdog_usec
;
215 static void service_start_watchdog(Service
*s
) {
217 usec_t watchdog_usec
;
221 watchdog_usec
= service_get_watchdog_usec(s
);
222 if (IN_SET(watchdog_usec
, 0, USEC_INFINITY
))
225 if (s
->watchdog_event_source
) {
226 r
= sd_event_source_set_time(s
->watchdog_event_source
, usec_add(s
->watchdog_timestamp
.monotonic
, watchdog_usec
));
228 log_unit_warning_errno(UNIT(s
), r
, "Failed to reset watchdog timer: %m");
232 r
= sd_event_source_set_enabled(s
->watchdog_event_source
, SD_EVENT_ONESHOT
);
234 r
= sd_event_add_time(
235 UNIT(s
)->manager
->event
,
236 &s
->watchdog_event_source
,
238 usec_add(s
->watchdog_timestamp
.monotonic
, watchdog_usec
), 0,
239 service_dispatch_watchdog
, s
);
241 log_unit_warning_errno(UNIT(s
), r
, "Failed to add watchdog timer: %m");
245 (void) sd_event_source_set_description(s
->watchdog_event_source
, "service-watchdog");
247 /* Let's process everything else which might be a sign
248 * of living before we consider a service died. */
249 r
= sd_event_source_set_priority(s
->watchdog_event_source
, SD_EVENT_PRIORITY_IDLE
);
253 log_unit_warning_errno(UNIT(s
), r
, "Failed to install watchdog timer: %m");
256 static void service_reset_watchdog(Service
*s
) {
259 dual_timestamp_get(&s
->watchdog_timestamp
);
260 service_start_watchdog(s
);
263 static void service_reset_watchdog_timeout(Service
*s
, usec_t watchdog_override_usec
) {
266 s
->watchdog_override_enable
= true;
267 s
->watchdog_override_usec
= watchdog_override_usec
;
268 service_reset_watchdog(s
);
270 log_unit_debug(UNIT(s
), "watchdog_usec="USEC_FMT
, s
->watchdog_usec
);
271 log_unit_debug(UNIT(s
), "watchdog_override_usec="USEC_FMT
, s
->watchdog_override_usec
);
274 static void service_fd_store_unlink(ServiceFDStore
*fs
) {
280 assert(fs
->service
->n_fd_store
> 0);
281 LIST_REMOVE(fd_store
, fs
->service
->fd_store
, fs
);
282 fs
->service
->n_fd_store
--;
285 if (fs
->event_source
) {
286 sd_event_source_set_enabled(fs
->event_source
, SD_EVENT_OFF
);
287 sd_event_source_unref(fs
->event_source
);
295 static void service_release_fd_store(Service
*s
) {
298 if (s
->n_keep_fd_store
> 0)
301 log_unit_debug(UNIT(s
), "Releasing all stored fds");
303 service_fd_store_unlink(s
->fd_store
);
305 assert(s
->n_fd_store
== 0);
308 static void service_release_resources(Unit
*u
) {
309 Service
*s
= SERVICE(u
);
313 if (!s
->fd_store
&& s
->stdin_fd
< 0 && s
->stdout_fd
< 0 && s
->stderr_fd
< 0)
316 log_unit_debug(u
, "Releasing resources.");
318 s
->stdin_fd
= safe_close(s
->stdin_fd
);
319 s
->stdout_fd
= safe_close(s
->stdout_fd
);
320 s
->stderr_fd
= safe_close(s
->stderr_fd
);
322 service_release_fd_store(s
);
325 static void service_done(Unit
*u
) {
326 Service
*s
= SERVICE(u
);
330 s
->pid_file
= mfree(s
->pid_file
);
331 s
->status_text
= mfree(s
->status_text
);
333 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
334 exec_command_free_array(s
->exec_command
, _SERVICE_EXEC_COMMAND_MAX
);
335 s
->control_command
= NULL
;
336 s
->main_command
= NULL
;
338 dynamic_creds_unref(&s
->dynamic_creds
);
340 exit_status_set_free(&s
->restart_prevent_status
);
341 exit_status_set_free(&s
->restart_force_status
);
342 exit_status_set_free(&s
->success_status
);
344 /* This will leak a process, but at least no memory or any of
346 service_unwatch_main_pid(s
);
347 service_unwatch_control_pid(s
);
348 service_unwatch_pid_file(s
);
351 unit_unwatch_bus_name(u
, s
->bus_name
);
352 s
->bus_name
= mfree(s
->bus_name
);
355 s
->bus_name_owner
= mfree(s
->bus_name_owner
);
357 service_close_socket_fd(s
);
358 s
->peer
= socket_peer_unref(s
->peer
);
360 unit_ref_unset(&s
->accept_socket
);
362 service_stop_watchdog(s
);
364 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
366 service_release_resources(u
);
369 static int on_fd_store_io(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
370 ServiceFDStore
*fs
= userdata
;
375 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
376 log_unit_debug(UNIT(fs
->service
),
377 "Received %s on stored fd %d (%s), closing.",
378 revents
& EPOLLERR
? "EPOLLERR" : "EPOLLHUP",
379 fs
->fd
, strna(fs
->fdname
));
380 service_fd_store_unlink(fs
);
384 static int service_add_fd_store(Service
*s
, int fd
, const char *name
) {
388 /* fd is always consumed if we return >= 0 */
393 if (s
->n_fd_store
>= s
->n_fd_store_max
)
394 return -EXFULL
; /* Our store is full.
395 * Use this errno rather than E[NM]FILE to distinguish from
396 * the case where systemd itself hits the file limit. */
398 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
399 r
= same_fd(fs
->fd
, fd
);
404 return 0; /* fd already included */
408 fs
= new0(ServiceFDStore
, 1);
414 fs
->fdname
= strdup(name
?: "stored");
420 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &fs
->event_source
, fd
, 0, on_fd_store_io
, fs
);
421 if (r
< 0 && r
!= -EPERM
) { /* EPERM indicates fds that aren't pollable, which is OK */
426 (void) sd_event_source_set_description(fs
->event_source
, "service-fd-store");
428 LIST_PREPEND(fd_store
, s
->fd_store
, fs
);
431 return 1; /* fd newly stored */
434 static int service_add_fd_store_set(Service
*s
, FDSet
*fds
, const char *name
) {
439 while (fdset_size(fds
) > 0) {
440 _cleanup_close_
int fd
= -1;
442 fd
= fdset_steal_first(fds
);
446 r
= service_add_fd_store(s
, fd
, name
);
448 return log_unit_warning_errno(UNIT(s
), r
,
449 "Cannot store more fds than FileDescriptorStoreMax=%u, closing remaining.",
452 return log_unit_error_errno(UNIT(s
), r
, "Failed to add fd to store: %m");
454 log_unit_debug(UNIT(s
), "Added fd %u (%s) to fd store.", fd
, strna(name
));
461 static int service_arm_timer(Service
*s
, usec_t usec
) {
466 if (s
->timer_event_source
) {
467 r
= sd_event_source_set_time(s
->timer_event_source
, usec
);
471 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
474 if (usec
== USEC_INFINITY
)
477 r
= sd_event_add_time(
478 UNIT(s
)->manager
->event
,
479 &s
->timer_event_source
,
482 service_dispatch_timer
, s
);
486 (void) sd_event_source_set_description(s
->timer_event_source
, "service-timer");
491 static int service_verify(Service
*s
) {
494 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
497 if (!s
->exec_command
[SERVICE_EXEC_START
] && !s
->exec_command
[SERVICE_EXEC_STOP
]) {
498 log_unit_error(UNIT(s
), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
502 if (s
->type
!= SERVICE_ONESHOT
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
503 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
507 if (!s
->remain_after_exit
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
508 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
512 if (s
->type
!= SERVICE_ONESHOT
&& s
->exec_command
[SERVICE_EXEC_START
]->command_next
) {
513 log_unit_error(UNIT(s
), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
517 if (s
->type
== SERVICE_ONESHOT
&& s
->restart
!= SERVICE_RESTART_NO
) {
518 log_unit_error(UNIT(s
), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
522 if (s
->type
== SERVICE_ONESHOT
&& !exit_status_set_is_empty(&s
->restart_force_status
)) {
523 log_unit_error(UNIT(s
), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
527 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name
) {
528 log_unit_error(UNIT(s
), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
532 if (s
->bus_name
&& s
->type
!= SERVICE_DBUS
)
533 log_unit_warning(UNIT(s
), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
535 if (s
->exec_context
.pam_name
&& !IN_SET(s
->kill_context
.kill_mode
, KILL_CONTROL_GROUP
, KILL_MIXED
)) {
536 log_unit_error(UNIT(s
), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
540 if (s
->usb_function_descriptors
&& !s
->usb_function_strings
)
541 log_unit_warning(UNIT(s
), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
543 if (!s
->usb_function_descriptors
&& s
->usb_function_strings
)
544 log_unit_warning(UNIT(s
), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
546 if (s
->runtime_max_usec
!= USEC_INFINITY
&& s
->type
== SERVICE_ONESHOT
)
547 log_unit_warning(UNIT(s
), "MaxRuntimeSec= has no effect in combination with Type=oneshot. Ignoring.");
552 static int service_add_default_dependencies(Service
*s
) {
557 if (!UNIT(s
)->default_dependencies
)
560 /* Add a number of automatic dependencies useful for the
561 * majority of services. */
563 if (MANAGER_IS_SYSTEM(UNIT(s
)->manager
)) {
564 /* First, pull in the really early boot stuff, and
565 * require it, so that we fail if we can't acquire
568 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
573 /* In the --user instance there's no sysinit.target,
574 * in that case require basic.target instead. */
576 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_BASIC_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
581 /* Second, if the rest of the base system is in the same
582 * transaction, order us after it, but do not pull it in or
583 * even require it. */
584 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_BASIC_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
588 /* Third, add us in for normal shutdown. */
589 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
592 static void service_fix_output(Service
*s
) {
595 /* If nothing has been explicitly configured, patch default
596 * output in. If input is socket/tty we avoid this however,
597 * since in that case we want output to default to the same
598 * place as we read input from. */
600 if (s
->exec_context
.std_error
== EXEC_OUTPUT_INHERIT
&&
601 s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
602 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
603 s
->exec_context
.std_error
= UNIT(s
)->manager
->default_std_error
;
605 if (s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
606 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
607 s
->exec_context
.std_output
= UNIT(s
)->manager
->default_std_output
;
610 static int service_setup_bus_name(Service
*s
) {
618 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_DBUS_SOCKET
, NULL
, true, UNIT_DEPENDENCY_FILE
);
620 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
622 /* We always want to be ordered against dbus.socket if both are in the transaction. */
623 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_DBUS_SOCKET
, NULL
, true, UNIT_DEPENDENCY_FILE
);
625 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
627 r
= unit_watch_bus_name(UNIT(s
), s
->bus_name
);
629 return log_unit_error_errno(UNIT(s
), r
, "Two services allocated for the same bus name %s, refusing operation.", s
->bus_name
);
631 return log_unit_error_errno(UNIT(s
), r
, "Cannot watch bus name %s: %m", s
->bus_name
);
636 static int service_add_extras(Service
*s
) {
641 if (s
->type
== _SERVICE_TYPE_INVALID
) {
642 /* Figure out a type automatically */
644 s
->type
= SERVICE_DBUS
;
645 else if (s
->exec_command
[SERVICE_EXEC_START
])
646 s
->type
= SERVICE_SIMPLE
;
648 s
->type
= SERVICE_ONESHOT
;
651 /* Oneshot services have disabled start timeout by default */
652 if (s
->type
== SERVICE_ONESHOT
&& !s
->start_timeout_defined
)
653 s
->timeout_start_usec
= USEC_INFINITY
;
655 service_fix_output(s
);
657 r
= unit_patch_contexts(UNIT(s
));
661 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
665 r
= unit_set_default_slice(UNIT(s
));
669 if (s
->type
== SERVICE_NOTIFY
&& s
->notify_access
== NOTIFY_NONE
)
670 s
->notify_access
= NOTIFY_MAIN
;
672 if (s
->watchdog_usec
> 0 && s
->notify_access
== NOTIFY_NONE
)
673 s
->notify_access
= NOTIFY_MAIN
;
675 r
= service_add_default_dependencies(s
);
679 r
= service_setup_bus_name(s
);
686 static int service_load(Unit
*u
) {
687 Service
*s
= SERVICE(u
);
692 /* Load a .service file */
693 r
= unit_load_fragment(u
);
697 /* Still nothing found? Then let's give up */
698 if (u
->load_state
== UNIT_STUB
)
701 /* This is a new unit? Then let's add in some extras */
702 if (u
->load_state
== UNIT_LOADED
) {
704 /* We were able to load something, then let's add in
705 * the dropin directories. */
706 r
= unit_load_dropin(u
);
710 /* This is a new unit? Then let's add in some
712 r
= service_add_extras(s
);
717 return service_verify(s
);
720 static void service_dump(Unit
*u
, FILE *f
, const char *prefix
) {
721 ServiceExecCommand c
;
722 Service
*s
= SERVICE(u
);
727 prefix
= strempty(prefix
);
728 prefix2
= strjoina(prefix
, "\t");
731 "%sService State: %s\n"
733 "%sReload Result: %s\n"
734 "%sPermissionsStartOnly: %s\n"
735 "%sRootDirectoryStartOnly: %s\n"
736 "%sRemainAfterExit: %s\n"
737 "%sGuessMainPID: %s\n"
740 "%sNotifyAccess: %s\n"
741 "%sNotifyState: %s\n",
742 prefix
, service_state_to_string(s
->state
),
743 prefix
, service_result_to_string(s
->result
),
744 prefix
, service_result_to_string(s
->reload_result
),
745 prefix
, yes_no(s
->permissions_start_only
),
746 prefix
, yes_no(s
->root_directory_start_only
),
747 prefix
, yes_no(s
->remain_after_exit
),
748 prefix
, yes_no(s
->guess_main_pid
),
749 prefix
, service_type_to_string(s
->type
),
750 prefix
, service_restart_to_string(s
->restart
),
751 prefix
, notify_access_to_string(s
->notify_access
),
752 prefix
, notify_state_to_string(s
->notify_state
));
754 if (s
->control_pid
> 0)
756 "%sControl PID: "PID_FMT
"\n",
757 prefix
, s
->control_pid
);
761 "%sMain PID: "PID_FMT
"\n"
762 "%sMain PID Known: %s\n"
763 "%sMain PID Alien: %s\n",
765 prefix
, yes_no(s
->main_pid_known
),
766 prefix
, yes_no(s
->main_pid_alien
));
771 prefix
, s
->pid_file
);
776 "%sBus Name Good: %s\n",
778 prefix
, yes_no(s
->bus_name_good
));
780 if (UNIT_ISSET(s
->accept_socket
))
782 "%sAccept Socket: %s\n",
783 prefix
, UNIT_DEREF(s
->accept_socket
)->id
);
785 kill_context_dump(&s
->kill_context
, f
, prefix
);
786 exec_context_dump(&s
->exec_context
, f
, prefix
);
788 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
790 if (!s
->exec_command
[c
])
793 fprintf(f
, "%s-> %s:\n",
794 prefix
, service_exec_command_to_string(c
));
796 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
800 fprintf(f
, "%sStatus Text: %s\n",
801 prefix
, s
->status_text
);
803 if (s
->n_fd_store_max
> 0)
805 "%sFile Descriptor Store Max: %u\n"
806 "%sFile Descriptor Store Current: %u\n",
807 prefix
, s
->n_fd_store_max
,
808 prefix
, s
->n_fd_store
);
810 cgroup_context_dump(&s
->cgroup_context
, f
, prefix
);
813 static int service_load_pid_file(Service
*s
, bool may_warn
) {
814 _cleanup_free_
char *k
= NULL
;
823 r
= read_one_line_file(s
->pid_file
, &k
);
826 log_unit_info_errno(UNIT(s
), r
, "PID file %s not readable (yet?) after %s: %m", s
->pid_file
, service_state_to_string(s
->state
));
830 r
= parse_pid(k
, &pid
);
833 log_unit_info_errno(UNIT(s
), r
, "Failed to read PID from file %s: %m", s
->pid_file
);
837 if (!pid_is_alive(pid
)) {
839 log_unit_info(UNIT(s
), "PID "PID_FMT
" read from file %s does not exist or is a zombie.", pid
, s
->pid_file
);
843 if (s
->main_pid_known
) {
844 if (pid
== s
->main_pid
)
847 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
849 service_unwatch_main_pid(s
);
850 s
->main_pid_known
= false;
852 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
854 r
= service_set_main_pid(s
, pid
);
858 r
= unit_watch_pid(UNIT(s
), pid
);
859 if (r
< 0) /* FIXME: we need to do something here */
860 return log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
865 static void service_search_main_pid(Service
*s
) {
871 /* If we know it anyway, don't ever fallback to unreliable
873 if (s
->main_pid_known
)
876 if (!s
->guess_main_pid
)
879 assert(s
->main_pid
<= 0);
881 if (unit_search_main_pid(UNIT(s
), &pid
) < 0)
884 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
885 if (service_set_main_pid(s
, pid
) < 0)
888 r
= unit_watch_pid(UNIT(s
), pid
);
890 /* FIXME: we need to do something here */
891 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
894 static void service_set_state(Service
*s
, ServiceState state
) {
895 ServiceState old_state
;
896 const UnitActiveState
*table
;
900 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
902 old_state
= s
->state
;
905 service_unwatch_pid_file(s
);
908 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
911 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
912 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
913 SERVICE_AUTO_RESTART
))
914 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
917 SERVICE_START
, SERVICE_START_POST
,
918 SERVICE_RUNNING
, SERVICE_RELOAD
,
919 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
920 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
921 service_unwatch_main_pid(s
);
922 s
->main_command
= NULL
;
926 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
928 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
929 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
930 service_unwatch_control_pid(s
);
931 s
->control_command
= NULL
;
932 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
935 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
936 unit_unwatch_all_pids(UNIT(s
));
939 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
940 SERVICE_RUNNING
, SERVICE_RELOAD
,
941 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
942 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
943 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
))
944 service_close_socket_fd(s
);
946 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
947 service_stop_watchdog(s
);
949 /* For the inactive states unit_notify() will trim the cgroup,
950 * but for exit we have to do that ourselves... */
951 if (state
== SERVICE_EXITED
&& !MANAGER_IS_RELOADING(UNIT(s
)->manager
))
952 unit_prune_cgroup(UNIT(s
));
954 /* For remain_after_exit services, let's see if we can "release" the
955 * hold on the console, since unit_notify() only does that in case of
957 if (state
== SERVICE_EXITED
&&
958 s
->remain_after_exit
&&
959 UNIT(s
)->manager
->n_on_console
> 0) {
963 ec
= unit_get_exec_context(UNIT(s
));
964 if (ec
&& exec_context_may_touch_console(ec
)) {
965 Manager
*m
= UNIT(s
)->manager
;
968 if (m
->n_on_console
== 0)
969 /* unset no_console_output flag, since the console is free */
970 m
->no_console_output
= false;
974 if (old_state
!= state
)
975 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
977 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
980 static usec_t
service_coldplug_timeout(Service
*s
) {
983 switch (s
->deserialized_state
) {
985 case SERVICE_START_PRE
:
987 case SERVICE_START_POST
:
989 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_start_usec
);
991 case SERVICE_RUNNING
:
992 return usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
);
995 case SERVICE_STOP_SIGABRT
:
996 case SERVICE_STOP_SIGTERM
:
997 case SERVICE_STOP_SIGKILL
:
998 case SERVICE_STOP_POST
:
999 case SERVICE_FINAL_SIGTERM
:
1000 case SERVICE_FINAL_SIGKILL
:
1001 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_stop_usec
);
1003 case SERVICE_AUTO_RESTART
:
1004 return usec_add(UNIT(s
)->inactive_enter_timestamp
.monotonic
, s
->restart_usec
);
1007 return USEC_INFINITY
;
1011 static int service_coldplug(Unit
*u
) {
1012 Service
*s
= SERVICE(u
);
1016 assert(s
->state
== SERVICE_DEAD
);
1018 if (s
->deserialized_state
== s
->state
)
1021 r
= service_arm_timer(s
, service_coldplug_timeout(s
));
1025 if (s
->main_pid
> 0 &&
1026 pid_is_unwaited(s
->main_pid
) &&
1027 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
1028 IN_SET(s
->deserialized_state
,
1029 SERVICE_START
, SERVICE_START_POST
,
1030 SERVICE_RUNNING
, SERVICE_RELOAD
,
1031 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1032 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
1033 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
1038 if (s
->control_pid
> 0 &&
1039 pid_is_unwaited(s
->control_pid
) &&
1040 IN_SET(s
->deserialized_state
,
1041 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1043 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1044 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
1045 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1050 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1051 unit_watch_all_pids(UNIT(s
));
1053 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
1054 service_start_watchdog(s
);
1056 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1057 (void) unit_setup_dynamic_creds(u
);
1059 if (UNIT_ISSET(s
->accept_socket
)) {
1060 Socket
* socket
= SOCKET(UNIT_DEREF(s
->accept_socket
));
1062 if (socket
->max_connections_per_source
> 0) {
1065 /* Make a best-effort attempt at bumping the connection count */
1066 if (socket_acquire_peer(socket
, s
->socket_fd
, &peer
) > 0) {
1067 socket_peer_unref(s
->peer
);
1073 service_set_state(s
, s
->deserialized_state
);
1077 static int service_collect_fds(Service
*s
,
1080 unsigned *n_storage_fds
,
1081 unsigned *n_socket_fds
) {
1083 _cleanup_strv_free_
char **rfd_names
= NULL
;
1084 _cleanup_free_
int *rfds
= NULL
;
1085 unsigned rn_socket_fds
= 0, rn_storage_fds
= 0;
1091 assert(n_socket_fds
);
1093 if (s
->socket_fd
>= 0) {
1095 /* Pass the per-connection socket */
1100 rfds
[0] = s
->socket_fd
;
1102 rfd_names
= strv_new("connection", NULL
);
1112 /* Pass all our configured sockets for singleton services */
1114 HASHMAP_FOREACH_KEY(v
, u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1115 _cleanup_free_
int *cfds
= NULL
;
1119 if (u
->type
!= UNIT_SOCKET
)
1124 cn_fds
= socket_collect_fds(sock
, &cfds
);
1133 rn_socket_fds
= cn_fds
;
1139 t
= realloc(rfds
, (rn_socket_fds
+ cn_fds
) * sizeof(int));
1143 memcpy(t
+ rn_socket_fds
, cfds
, cn_fds
* sizeof(int));
1146 rn_socket_fds
+= cn_fds
;
1149 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1155 if (s
->n_fd_store
> 0) {
1161 t
= realloc(rfds
, (rn_socket_fds
+ s
->n_fd_store
) * sizeof(int));
1167 nl
= realloc(rfd_names
, (rn_socket_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1172 n_fds
= rn_socket_fds
;
1174 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1175 rfds
[n_fds
] = fs
->fd
;
1176 rfd_names
[n_fds
] = strdup(strempty(fs
->fdname
));
1177 if (!rfd_names
[n_fds
])
1184 rfd_names
[n_fds
] = NULL
;
1188 *fd_names
= rfd_names
;
1189 *n_socket_fds
= rn_socket_fds
;
1190 *n_storage_fds
= rn_storage_fds
;
1198 static bool service_exec_needs_notify_socket(Service
*s
, ExecFlags flags
) {
1201 /* Notifications are accepted depending on the process and
1202 * the access setting of the service:
1203 * process: \ access: NONE MAIN EXEC ALL
1204 * main no yes yes yes
1205 * control no no yes yes
1206 * other (forked) no no no yes */
1208 if (flags
& EXEC_IS_CONTROL
)
1209 /* A control process */
1210 return IN_SET(s
->notify_access
, NOTIFY_EXEC
, NOTIFY_ALL
);
1212 /* We only spawn main processes and control processes, so any
1213 * process that is not a control process is a main process */
1214 return s
->notify_access
!= NOTIFY_NONE
;
1217 static int service_spawn(
1224 _cleanup_strv_free_
char **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1225 _cleanup_free_
int *fds
= NULL
;
1226 unsigned n_storage_fds
= 0, n_socket_fds
= 0, n_env
= 0;
1229 ExecParameters exec_params
= {
1242 if (flags
& EXEC_IS_CONTROL
) {
1243 /* If this is a control process, mask the permissions/chroot application if this is requested. */
1244 if (s
->permissions_start_only
)
1245 exec_params
.flags
&= ~EXEC_APPLY_SANDBOXING
;
1246 if (s
->root_directory_start_only
)
1247 exec_params
.flags
&= ~EXEC_APPLY_CHROOT
;
1250 (void) unit_realize_cgroup(UNIT(s
));
1251 if (s
->reset_accounting
) {
1252 (void) unit_reset_cpu_accounting(UNIT(s
));
1253 (void) unit_reset_ip_accounting(UNIT(s
));
1254 s
->reset_accounting
= false;
1257 unit_export_state_files(UNIT(s
));
1259 r
= unit_setup_exec_runtime(UNIT(s
));
1263 r
= unit_setup_dynamic_creds(UNIT(s
));
1267 if ((flags
& EXEC_PASS_FDS
) ||
1268 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1269 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1270 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1272 r
= service_collect_fds(s
, &fds
, &fd_names
, &n_storage_fds
, &n_socket_fds
);
1276 log_unit_debug(UNIT(s
), "Passing %i fds to service", n_storage_fds
+ n_socket_fds
);
1279 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), timeout
));
1283 our_env
= new0(char*, 9);
1287 if (service_exec_needs_notify_socket(s
, flags
))
1288 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0)
1291 if (s
->main_pid
> 0)
1292 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0)
1295 if (MANAGER_IS_USER(UNIT(s
)->manager
))
1296 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid_cached()) < 0)
1299 if (s
->socket_fd
>= 0) {
1300 union sockaddr_union sa
;
1301 socklen_t salen
= sizeof(sa
);
1303 /* If this is a per-connection service instance, let's set $REMOTE_ADDR and $REMOTE_PORT to something
1304 * useful. Note that we do this only when we are still connected at this point in time, which we might
1305 * very well not be. Hence we ignore all errors when retrieving peer information (as that might result
1306 * in ENOTCONN), and just use whate we can use. */
1308 if (getpeername(s
->socket_fd
, &sa
.sa
, &salen
) >= 0 &&
1309 IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
, AF_VSOCK
)) {
1311 _cleanup_free_
char *addr
= NULL
;
1315 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1319 t
= strappend("REMOTE_ADDR=", addr
);
1322 our_env
[n_env
++] = t
;
1324 r
= sockaddr_port(&sa
.sa
, &port
);
1328 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0)
1330 our_env
[n_env
++] = t
;
1334 if (flags
& EXEC_SETENV_RESULT
) {
1335 if (asprintf(our_env
+ n_env
++, "SERVICE_RESULT=%s", service_result_to_string(s
->result
)) < 0)
1338 if (s
->main_exec_status
.pid
> 0 &&
1339 dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
1340 if (asprintf(our_env
+ n_env
++, "EXIT_CODE=%s", sigchld_code_to_string(s
->main_exec_status
.code
)) < 0)
1343 if (s
->main_exec_status
.code
== CLD_EXITED
)
1344 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%i", s
->main_exec_status
.status
);
1346 r
= asprintf(our_env
+ n_env
++, "EXIT_STATUS=%s", signal_to_string(s
->main_exec_status
.status
));
1352 manager_set_exec_params(UNIT(s
)->manager
, &exec_params
);
1353 unit_set_exec_params(UNIT(s
), &exec_params
);
1355 final_env
= strv_env_merge(2, exec_params
.environment
, our_env
, NULL
);
1359 if ((flags
& EXEC_IS_CONTROL
) && UNIT(s
)->cgroup_path
) {
1360 exec_params
.cgroup_path
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1361 (void) cg_create(SYSTEMD_CGROUP_CONTROLLER
, exec_params
.cgroup_path
);
1364 /* System services should get a new keyring by default. */
1365 SET_FLAG(exec_params
.flags
, EXEC_NEW_KEYRING
, MANAGER_IS_SYSTEM(UNIT(s
)->manager
));
1367 /* System D-Bus needs nss-systemd disabled, so that we don't deadlock */
1368 SET_FLAG(exec_params
.flags
, EXEC_NSS_BYPASS_BUS
,
1369 MANAGER_IS_SYSTEM(UNIT(s
)->manager
) && unit_has_name(UNIT(s
), SPECIAL_DBUS_SERVICE
));
1371 exec_params
.argv
= c
->argv
;
1372 exec_params
.environment
= final_env
;
1373 exec_params
.fds
= fds
;
1374 exec_params
.fd_names
= fd_names
;
1375 exec_params
.n_storage_fds
= n_storage_fds
;
1376 exec_params
.n_socket_fds
= n_socket_fds
;
1377 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1378 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1379 if (s
->type
== SERVICE_IDLE
)
1380 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1381 exec_params
.stdin_fd
= s
->stdin_fd
;
1382 exec_params
.stdout_fd
= s
->stdout_fd
;
1383 exec_params
.stderr_fd
= s
->stderr_fd
;
1385 r
= exec_spawn(UNIT(s
),
1395 r
= unit_watch_pid(UNIT(s
), pid
);
1396 if (r
< 0) /* FIXME: we need to do something here */
1404 static int main_pid_good(Service
*s
) {
1407 /* Returns 0 if the pid is dead, > 0 if it is good, < 0 if we don't know */
1409 /* If we know the pid file, then let's just check if it is
1411 if (s
->main_pid_known
) {
1413 /* If it's an alien child let's check if it is still
1415 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1416 return pid_is_alive(s
->main_pid
);
1418 /* .. otherwise assume we'll get a SIGCHLD for it,
1419 * which we really should wait for to collect exit
1420 * status and code */
1421 return s
->main_pid
> 0;
1424 /* We don't know the pid */
1428 static int control_pid_good(Service
*s
) {
1431 /* Returns 0 if the control PID is dead, > 0 if it is good. We never actually return < 0 here, but in order to
1432 * make this function as similar as possible to main_pid_good() and cgroup_good(), we pretend that < 0 also
1433 * means: we can't figure it out. */
1435 return s
->control_pid
> 0;
1438 static int cgroup_good(Service
*s
) {
1443 /* Returns 0 if the cgroup is empty or doesn't exist, > 0 if it is exists and is populated, < 0 if we can't
1446 if (!UNIT(s
)->cgroup_path
)
1449 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1456 static bool service_shall_restart(Service
*s
) {
1459 /* Don't restart after manual stops */
1460 if (s
->forbid_restart
)
1463 /* Never restart if this is configured as special exception */
1464 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1467 /* Restart if the exit code/status are configured as restart triggers */
1468 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1471 switch (s
->restart
) {
1473 case SERVICE_RESTART_NO
:
1476 case SERVICE_RESTART_ALWAYS
:
1479 case SERVICE_RESTART_ON_SUCCESS
:
1480 return s
->result
== SERVICE_SUCCESS
;
1482 case SERVICE_RESTART_ON_FAILURE
:
1483 return s
->result
!= SERVICE_SUCCESS
;
1485 case SERVICE_RESTART_ON_ABNORMAL
:
1486 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1488 case SERVICE_RESTART_ON_WATCHDOG
:
1489 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1491 case SERVICE_RESTART_ON_ABORT
:
1492 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1495 assert_not_reached("unknown restart setting");
1499 static bool service_will_restart(Service
*s
) {
1502 if (s
->state
== SERVICE_AUTO_RESTART
)
1506 if (UNIT(s
)->job
->type
== JOB_START
)
1511 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1516 /* If there's a stop job queued before we enter the DEAD state, we shouldn't act on Restart=, in order to not
1517 * undo what has already been enqueued. */
1518 if (unit_stop_pending(UNIT(s
)))
1519 allow_restart
= false;
1521 if (s
->result
== SERVICE_SUCCESS
)
1524 if (s
->result
!= SERVICE_SUCCESS
)
1525 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1527 /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
1528 * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
1529 s
->n_keep_fd_store
++;
1531 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1533 if (s
->result
!= SERVICE_SUCCESS
)
1534 emergency_action(UNIT(s
)->manager
, s
->emergency_action
, UNIT(s
)->reboot_arg
, "service failed");
1536 if (allow_restart
&& service_shall_restart(s
)) {
1538 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
1540 s
->n_keep_fd_store
--;
1544 service_set_state(s
, SERVICE_AUTO_RESTART
);
1546 /* If we shan't restart, then flush out the restart counter. But don't do that immediately, so that the
1547 * user can still introspect the counter. Do so on the next start. */
1548 s
->flush_n_restarts
= true;
1550 /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
1551 * queue, so that the fd store is possibly gc'ed again */
1552 s
->n_keep_fd_store
--;
1553 unit_add_to_gc_queue(UNIT(s
));
1555 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1556 s
->forbid_restart
= false;
1558 /* We want fresh tmpdirs in case service is started again immediately */
1559 exec_runtime_destroy(s
->exec_runtime
);
1560 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1562 if (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_NO
||
1563 (s
->exec_context
.runtime_directory_preserve_mode
== EXEC_PRESERVE_RESTART
&& !service_will_restart(s
)))
1564 /* Also, remove the runtime directory */
1565 exec_context_destroy_runtime_directory(&s
->exec_context
, UNIT(s
)->manager
->prefix
[EXEC_DIRECTORY_RUNTIME
]);
1567 /* Get rid of the IPC bits of the user */
1568 unit_unref_uid_gid(UNIT(s
), true);
1570 /* Release the user, and destroy it if we are the only remaining owner */
1571 dynamic_creds_destroy(&s
->dynamic_creds
);
1573 /* Try to delete the pid file. At this point it will be
1574 * out-of-date, and some software might be confused by it, so
1575 * let's remove it. */
1577 (void) unlink(s
->pid_file
);
1582 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1583 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1586 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1590 if (s
->result
== SERVICE_SUCCESS
)
1593 service_unwatch_control_pid(s
);
1594 unit_watch_all_pids(UNIT(s
));
1596 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1597 if (s
->control_command
) {
1598 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1600 r
= service_spawn(s
,
1602 s
->timeout_stop_usec
,
1603 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1608 service_set_state(s
, SERVICE_STOP_POST
);
1610 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1615 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1616 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1619 static int state_to_kill_operation(ServiceState state
) {
1622 case SERVICE_STOP_SIGABRT
:
1625 case SERVICE_STOP_SIGTERM
:
1626 case SERVICE_FINAL_SIGTERM
:
1627 return KILL_TERMINATE
;
1629 case SERVICE_STOP_SIGKILL
:
1630 case SERVICE_FINAL_SIGKILL
:
1634 return _KILL_OPERATION_INVALID
;
1638 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1643 if (s
->result
== SERVICE_SUCCESS
)
1646 unit_watch_all_pids(UNIT(s
));
1648 r
= unit_kill_context(
1651 state_to_kill_operation(state
),
1659 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1663 service_set_state(s
, state
);
1664 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1665 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1666 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1667 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1668 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1669 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1671 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1676 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1678 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1679 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1681 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1684 static void service_enter_stop_by_notify(Service
*s
) {
1687 unit_watch_all_pids(UNIT(s
));
1689 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
1691 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1692 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1695 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1700 if (s
->result
== SERVICE_SUCCESS
)
1703 service_unwatch_control_pid(s
);
1704 unit_watch_all_pids(UNIT(s
));
1706 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1707 if (s
->control_command
) {
1708 s
->control_command_id
= SERVICE_EXEC_STOP
;
1710 r
= service_spawn(s
,
1712 s
->timeout_stop_usec
,
1713 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_SETENV_RESULT
,
1718 service_set_state(s
, SERVICE_STOP
);
1720 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1725 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1726 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1729 static bool service_good(Service
*s
) {
1733 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1736 main_pid_ok
= main_pid_good(s
);
1737 if (main_pid_ok
> 0) /* It's alive */
1739 if (main_pid_ok
== 0) /* It's dead */
1742 /* OK, we don't know anything about the main PID, maybe
1743 * because there is none. Let's check the control group
1746 return cgroup_good(s
) != 0;
1749 static void service_enter_running(Service
*s
, ServiceResult f
) {
1752 if (s
->result
== SERVICE_SUCCESS
)
1755 service_unwatch_control_pid(s
);
1757 if (service_good(s
)) {
1759 /* If there are any queued up sd_notify()
1760 * notifications, process them now */
1761 if (s
->notify_state
== NOTIFY_RELOADING
)
1762 service_enter_reload_by_notify(s
);
1763 else if (s
->notify_state
== NOTIFY_STOPPING
)
1764 service_enter_stop_by_notify(s
);
1766 service_set_state(s
, SERVICE_RUNNING
);
1767 service_arm_timer(s
, usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
, s
->runtime_max_usec
));
1770 } else if (f
!= SERVICE_SUCCESS
)
1771 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
1772 else if (s
->remain_after_exit
)
1773 service_set_state(s
, SERVICE_EXITED
);
1775 service_enter_stop(s
, SERVICE_SUCCESS
);
1778 static void service_enter_start_post(Service
*s
) {
1782 service_unwatch_control_pid(s
);
1783 service_reset_watchdog(s
);
1785 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1786 if (s
->control_command
) {
1787 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1789 r
= service_spawn(s
,
1791 s
->timeout_start_usec
,
1792 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
1797 service_set_state(s
, SERVICE_START_POST
);
1799 service_enter_running(s
, SERVICE_SUCCESS
);
1804 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1805 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1808 static void service_kill_control_processes(Service
*s
) {
1813 if (s
->control_pid
> 0) {
1814 r
= kill_and_sigcont(s
->control_pid
, SIGKILL
);
1816 _cleanup_free_
char *comm
= NULL
;
1818 (void) get_process_comm(s
->control_pid
, &comm
);
1820 log_unit_debug_errno(UNIT(s
), r
, "Failed to kill control process " PID_FMT
" (%s), ignoring: %m",
1821 s
->control_pid
, strna(comm
));
1825 if (UNIT(s
)->cgroup_path
) {
1826 _cleanup_set_free_ Set
*pid_set
= NULL
;
1829 if (s
->control_pid
> 0) {
1830 r
= set_make(&pid_set
, PID_TO_PTR(s
->control_pid
), NULL
);
1837 p
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1838 r
= cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, p
, SIGKILL
, CGROUP_SIGCONT
|CGROUP_IGNORE_SELF
|CGROUP_REMOVE
, pid_set
, NULL
, NULL
);
1840 log_unit_debug_errno(UNIT(s
), r
, "Failed to send SIGKILL to processes of control group %s: %m", p
);
1844 static void service_enter_start(Service
*s
) {
1852 service_unwatch_control_pid(s
);
1853 service_unwatch_main_pid(s
);
1855 /* We want to ensure that nobody leaks processes from
1856 * START_PRE here, so let's go on a killing spree, People
1857 * should not spawn long running processes from START_PRE. */
1858 service_kill_control_processes(s
);
1860 if (s
->type
== SERVICE_FORKING
) {
1861 s
->control_command_id
= SERVICE_EXEC_START
;
1862 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1864 s
->main_command
= NULL
;
1866 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1867 s
->control_command
= NULL
;
1869 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1873 if (s
->type
!= SERVICE_ONESHOT
) {
1874 /* There's no command line configured for the main command? Hmm, that is strange. This can only
1875 * happen if the configuration changes at runtime. In this case, let's enter a failure
1877 log_unit_error(UNIT(s
), "There's no 'start' task anymore we could start: %m");
1882 service_enter_start_post(s
);
1886 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
))
1887 /* For simple + idle this is the main process. We don't apply any timeout here, but
1888 * service_enter_running() will later apply the .runtime_max_usec timeout. */
1889 timeout
= USEC_INFINITY
;
1891 timeout
= s
->timeout_start_usec
;
1893 r
= service_spawn(s
,
1896 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
1901 if (IN_SET(s
->type
, SERVICE_SIMPLE
, SERVICE_IDLE
)) {
1902 /* For simple services we immediately start
1903 * the START_POST binaries. */
1905 service_set_main_pid(s
, pid
);
1906 service_enter_start_post(s
);
1908 } else if (s
->type
== SERVICE_FORKING
) {
1910 /* For forking services we wait until the start
1911 * process exited. */
1913 s
->control_pid
= pid
;
1914 service_set_state(s
, SERVICE_START
);
1916 } else if (IN_SET(s
->type
, SERVICE_ONESHOT
, SERVICE_DBUS
, SERVICE_NOTIFY
)) {
1918 /* For oneshot services we wait until the start
1919 * process exited, too, but it is our main process. */
1921 /* For D-Bus services we know the main pid right away,
1922 * but wait for the bus name to appear on the
1923 * bus. Notify services are similar. */
1925 service_set_main_pid(s
, pid
);
1926 service_set_state(s
, SERVICE_START
);
1928 assert_not_reached("Unknown service type");
1933 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1934 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1937 static void service_enter_start_pre(Service
*s
) {
1942 service_unwatch_control_pid(s
);
1944 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1945 if (s
->control_command
) {
1946 /* Before we start anything, let's clear up what might
1947 * be left from previous runs. */
1948 service_kill_control_processes(s
);
1950 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1952 r
= service_spawn(s
,
1954 s
->timeout_start_usec
,
1955 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|EXEC_APPLY_TTY_STDIN
,
1960 service_set_state(s
, SERVICE_START_PRE
);
1962 service_enter_start(s
);
1967 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1968 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1971 static void service_enter_restart(Service
*s
) {
1972 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1977 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1978 /* Don't restart things if we are going down anyway */
1979 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
1981 r
= service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->restart_usec
));
1988 /* Any units that are bound to this service must also be
1989 * restarted. We use JOB_RESTART (instead of the more obvious
1990 * JOB_START) here so that those dependency jobs will be added
1992 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, &error
, NULL
);
1996 /* Count the jobs we enqueue for restarting. This counter is maintained as long as the unit isn't fully
1997 * stopped, i.e. as long as it remains up or remains in auto-start states. The use can reset the counter
1998 * explicitly however via the usual "systemctl reset-failure" logic. */
2000 s
->flush_n_restarts
= false;
2002 log_struct(LOG_INFO
,
2003 "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR
,
2004 LOG_UNIT_ID(UNIT(s
)),
2005 LOG_UNIT_INVOCATION_ID(UNIT(s
)),
2006 LOG_UNIT_MESSAGE(UNIT(s
), "Scheduled restart job, restart counter is at %u.", s
->n_restarts
),
2007 "N_RESTARTS=%u", s
->n_restarts
,
2010 /* Notify clients about changed restart counter */
2011 unit_add_to_dbus_queue(UNIT(s
));
2013 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2014 * it will be canceled as part of the service_stop() call that
2015 * is executed as part of JOB_RESTART. */
2020 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
2021 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
2024 static void service_enter_reload_by_notify(Service
*s
) {
2025 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2030 service_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_start_usec
));
2031 service_set_state(s
, SERVICE_RELOAD
);
2033 /* service_enter_reload_by_notify is never called during a reload, thus no loops are possible. */
2034 r
= manager_propagate_reload(UNIT(s
)->manager
, UNIT(s
), JOB_FAIL
, &error
);
2036 log_unit_warning(UNIT(s
), "Failed to schedule propagation of reload: %s", bus_error_message(&error
, -r
));
2039 static void service_enter_reload(Service
*s
) {
2044 service_unwatch_control_pid(s
);
2045 s
->reload_result
= SERVICE_SUCCESS
;
2047 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
2048 if (s
->control_command
) {
2049 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
2051 r
= service_spawn(s
,
2053 s
->timeout_start_usec
,
2054 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
,
2059 service_set_state(s
, SERVICE_RELOAD
);
2061 service_enter_running(s
, SERVICE_SUCCESS
);
2066 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
2067 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2068 service_enter_running(s
, SERVICE_SUCCESS
);
2071 static void service_run_next_control(Service
*s
) {
2076 assert(s
->control_command
);
2077 assert(s
->control_command
->command_next
);
2079 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
2081 s
->control_command
= s
->control_command
->command_next
;
2082 service_unwatch_control_pid(s
);
2084 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
2085 timeout
= s
->timeout_start_usec
;
2087 timeout
= s
->timeout_stop_usec
;
2089 r
= service_spawn(s
,
2092 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_IS_CONTROL
|
2093 (IN_SET(s
->control_command_id
, SERVICE_EXEC_START_PRE
, SERVICE_EXEC_STOP_POST
) ? EXEC_APPLY_TTY_STDIN
: 0)|
2094 (IN_SET(s
->control_command_id
, SERVICE_EXEC_STOP
, SERVICE_EXEC_STOP_POST
) ? EXEC_SETENV_RESULT
: 0),
2102 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
2104 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START_POST
, SERVICE_STOP
))
2105 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2106 else if (s
->state
== SERVICE_STOP_POST
)
2107 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
2108 else if (s
->state
== SERVICE_RELOAD
) {
2109 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
2110 service_enter_running(s
, SERVICE_SUCCESS
);
2112 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2115 static void service_run_next_main(Service
*s
) {
2120 assert(s
->main_command
);
2121 assert(s
->main_command
->command_next
);
2122 assert(s
->type
== SERVICE_ONESHOT
);
2124 s
->main_command
= s
->main_command
->command_next
;
2125 service_unwatch_main_pid(s
);
2127 r
= service_spawn(s
,
2129 s
->timeout_start_usec
,
2130 EXEC_PASS_FDS
|EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
|EXEC_SET_WATCHDOG
,
2135 service_set_main_pid(s
, pid
);
2140 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
2141 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2144 static int service_start(Unit
*u
) {
2145 Service
*s
= SERVICE(u
);
2150 /* We cannot fulfill this request right now, try again later
2152 if (IN_SET(s
->state
,
2153 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2154 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2157 /* Already on it! */
2158 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
2161 /* A service that will be restarted must be stopped first to
2162 * trigger BindsTo and/or OnFailure dependencies. If a user
2163 * does not want to wait for the holdoff time to elapse, the
2164 * service should be manually restarted, not started. We
2165 * simply return EAGAIN here, so that any start jobs stay
2166 * queued, and assume that the auto restart timer will
2167 * eventually trigger the restart. */
2168 if (s
->state
== SERVICE_AUTO_RESTART
)
2171 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
2173 /* Make sure we don't enter a busy loop of some kind. */
2174 r
= unit_start_limit_test(u
);
2176 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT_HIT
, false);
2180 r
= unit_acquire_invocation_id(u
);
2184 s
->result
= SERVICE_SUCCESS
;
2185 s
->reload_result
= SERVICE_SUCCESS
;
2186 s
->main_pid_known
= false;
2187 s
->main_pid_alien
= false;
2188 s
->forbid_restart
= false;
2189 s
->reset_accounting
= true;
2191 s
->status_text
= mfree(s
->status_text
);
2192 s
->status_errno
= 0;
2194 s
->notify_state
= NOTIFY_UNKNOWN
;
2196 s
->watchdog_override_enable
= false;
2197 s
->watchdog_override_usec
= 0;
2199 /* This is not an automatic restart? Flush the restart counter then */
2200 if (s
->flush_n_restarts
) {
2202 s
->flush_n_restarts
= false;
2205 service_enter_start_pre(s
);
2209 static int service_stop(Unit
*u
) {
2210 Service
*s
= SERVICE(u
);
2214 /* Don't create restart jobs from manual stops. */
2215 s
->forbid_restart
= true;
2218 if (IN_SET(s
->state
,
2219 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2220 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2223 /* A restart will be scheduled or is in progress. */
2224 if (s
->state
== SERVICE_AUTO_RESTART
) {
2225 service_set_state(s
, SERVICE_DEAD
);
2229 /* If there's already something running we go directly into
2231 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2232 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2236 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2238 service_enter_stop(s
, SERVICE_SUCCESS
);
2242 static int service_reload(Unit
*u
) {
2243 Service
*s
= SERVICE(u
);
2247 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2249 service_enter_reload(s
);
2253 _pure_
static bool service_can_reload(Unit
*u
) {
2254 Service
*s
= SERVICE(u
);
2258 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2261 static unsigned service_exec_command_index(Unit
*u
, ServiceExecCommand id
, ExecCommand
*current
) {
2262 Service
*s
= SERVICE(u
);
2264 ExecCommand
*first
, *c
;
2268 first
= s
->exec_command
[id
];
2270 /* Figure out where we are in the list by walking back to the beginning */
2271 for (c
= current
; c
!= first
; c
= c
->command_prev
)
2277 static int service_serialize_exec_command(Unit
*u
, FILE *f
, ExecCommand
*command
) {
2278 Service
*s
= SERVICE(u
);
2279 ServiceExecCommand id
;
2283 _cleanup_free_
char *args
= NULL
, *p
= NULL
;
2284 size_t allocated
= 0, length
= 0;
2292 if (command
== s
->control_command
) {
2294 id
= s
->control_command_id
;
2297 id
= SERVICE_EXEC_START
;
2300 idx
= service_exec_command_index(u
, id
, command
);
2302 STRV_FOREACH(arg
, command
->argv
) {
2304 _cleanup_free_
char *e
= NULL
;
2306 e
= xescape(*arg
, WHITESPACE
);
2311 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1 + n
+ 1))
2315 args
[length
++] = ' ';
2317 memcpy(args
+ length
, e
, n
);
2321 if (!GREEDY_REALLOC(args
, allocated
, length
+ 1))
2325 p
= xescape(command
->path
, WHITESPACE
);
2329 fprintf(f
, "%s-command=%s %u %s %s\n", type
, service_exec_command_to_string(id
), idx
, p
, args
);
2334 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2335 Service
*s
= SERVICE(u
);
2343 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2344 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2345 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2347 if (s
->control_pid
> 0)
2348 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2350 if (s
->main_pid_known
&& s
->main_pid
> 0)
2351 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2353 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2354 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2355 unit_serialize_item(u
, f
, "bus-name-owner", s
->bus_name_owner
);
2357 unit_serialize_item_format(u
, f
, "n-restarts", "%u", s
->n_restarts
);
2358 unit_serialize_item(u
, f
, "flush-n-restarts", yes_no(s
->flush_n_restarts
));
2360 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2364 service_serialize_exec_command(u
, f
, s
->control_command
);
2365 service_serialize_exec_command(u
, f
, s
->main_command
);
2367 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2370 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2373 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2377 if (UNIT_ISSET(s
->accept_socket
)) {
2378 r
= unit_serialize_item(u
, f
, "accept-socket", UNIT_DEREF(s
->accept_socket
)->id
);
2383 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2387 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2388 _cleanup_free_
char *c
= NULL
;
2391 copy
= fdset_put_dup(fds
, fs
->fd
);
2395 c
= cescape(fs
->fdname
);
2397 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2400 if (s
->main_exec_status
.pid
> 0) {
2401 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2402 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2403 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2405 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2406 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2407 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2411 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2413 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2415 if (s
->watchdog_override_enable
)
2416 unit_serialize_item_format(u
, f
, "watchdog-override-usec", USEC_FMT
, s
->watchdog_override_usec
);
2421 static int service_deserialize_exec_command(Unit
*u
, const char *key
, const char *value
) {
2422 Service
*s
= SERVICE(u
);
2424 unsigned idx
= 0, i
;
2425 bool control
, found
= false;
2426 ServiceExecCommand id
= _SERVICE_EXEC_COMMAND_INVALID
;
2427 ExecCommand
*command
= NULL
;
2428 _cleanup_free_
char *path
= NULL
;
2429 _cleanup_strv_free_
char **argv
= NULL
;
2431 enum ExecCommandState
{
2432 STATE_EXEC_COMMAND_TYPE
,
2433 STATE_EXEC_COMMAND_INDEX
,
2434 STATE_EXEC_COMMAND_PATH
,
2435 STATE_EXEC_COMMAND_ARGS
,
2436 _STATE_EXEC_COMMAND_MAX
,
2437 _STATE_EXEC_COMMAND_INVALID
= -1,
2444 control
= streq(key
, "control-command");
2446 state
= STATE_EXEC_COMMAND_TYPE
;
2449 _cleanup_free_
char *arg
= NULL
;
2451 r
= extract_first_word(&value
, &arg
, NULL
, EXTRACT_CUNESCAPE
);
2458 case STATE_EXEC_COMMAND_TYPE
:
2459 id
= service_exec_command_from_string(arg
);
2463 state
= STATE_EXEC_COMMAND_INDEX
;
2465 case STATE_EXEC_COMMAND_INDEX
:
2466 r
= safe_atou(arg
, &idx
);
2470 state
= STATE_EXEC_COMMAND_PATH
;
2472 case STATE_EXEC_COMMAND_PATH
:
2475 state
= STATE_EXEC_COMMAND_ARGS
;
2477 if (!path_is_absolute(path
))
2480 case STATE_EXEC_COMMAND_ARGS
:
2481 r
= strv_extend(&argv
, arg
);
2486 assert_not_reached("Unknown error at deserialization of exec command");
2491 if (state
!= STATE_EXEC_COMMAND_ARGS
)
2494 /* Let's check whether exec command on given offset matches data that we just deserialized */
2495 for (command
= s
->exec_command
[id
], i
= 0; command
; command
= command
->command_next
, i
++) {
2499 found
= strv_equal(argv
, command
->argv
) && streq(command
->path
, path
);
2504 /* Command at the index we serialized is different, let's look for command that exactly
2505 * matches but is on different index. If there is no such command we will not resume execution. */
2506 for (command
= s
->exec_command
[id
]; command
; command
= command
->command_next
)
2507 if (strv_equal(command
->argv
, argv
) && streq(command
->path
, path
))
2511 if (command
&& control
)
2512 s
->control_command
= command
;
2514 s
->main_command
= command
;
2516 log_unit_warning(u
, "Current command vanished from the unit file, execution of the command list won't be resumed.");
2521 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2522 Service
*s
= SERVICE(u
);
2530 if (streq(key
, "state")) {
2533 state
= service_state_from_string(value
);
2535 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2537 s
->deserialized_state
= state
;
2538 } else if (streq(key
, "result")) {
2541 f
= service_result_from_string(value
);
2543 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2544 else if (f
!= SERVICE_SUCCESS
)
2547 } else if (streq(key
, "reload-result")) {
2550 f
= service_result_from_string(value
);
2552 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2553 else if (f
!= SERVICE_SUCCESS
)
2554 s
->reload_result
= f
;
2556 } else if (streq(key
, "control-pid")) {
2559 if (parse_pid(value
, &pid
) < 0)
2560 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2562 s
->control_pid
= pid
;
2563 } else if (streq(key
, "main-pid")) {
2566 if (parse_pid(value
, &pid
) < 0)
2567 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2569 service_set_main_pid(s
, pid
);
2570 unit_watch_pid(UNIT(s
), pid
);
2572 } else if (streq(key
, "main-pid-known")) {
2575 b
= parse_boolean(value
);
2577 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2579 s
->main_pid_known
= b
;
2580 } else if (streq(key
, "bus-name-good")) {
2583 b
= parse_boolean(value
);
2585 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2587 s
->bus_name_good
= b
;
2588 } else if (streq(key
, "bus-name-owner")) {
2589 r
= free_and_strdup(&s
->bus_name_owner
, value
);
2591 log_unit_error_errno(u
, r
, "Unable to deserialize current bus owner %s: %m", value
);
2592 } else if (streq(key
, "status-text")) {
2595 r
= cunescape(value
, 0, &t
);
2597 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2599 free(s
->status_text
);
2603 } else if (streq(key
, "accept-socket")) {
2606 r
= manager_load_unit(u
->manager
, value
, NULL
, NULL
, &socket
);
2608 log_unit_debug_errno(u
, r
, "Failed to load accept-socket unit: %s", value
);
2610 unit_ref_set(&s
->accept_socket
, socket
);
2611 SOCKET(socket
)->n_connections
++;
2614 } else if (streq(key
, "socket-fd")) {
2617 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2618 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2620 asynchronous_close(s
->socket_fd
);
2621 s
->socket_fd
= fdset_remove(fds
, fd
);
2623 } else if (streq(key
, "fd-store-fd")) {
2628 pf
= strcspn(value
, WHITESPACE
);
2629 fdv
= strndupa(value
, pf
);
2631 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2632 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2634 _cleanup_free_
char *t
= NULL
;
2638 fdn
+= strspn(fdn
, WHITESPACE
);
2639 (void) cunescape(fdn
, 0, &t
);
2641 r
= service_add_fd_store(s
, fd
, t
);
2643 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2645 fdset_remove(fds
, fd
);
2648 } else if (streq(key
, "main-exec-status-pid")) {
2651 if (parse_pid(value
, &pid
) < 0)
2652 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2654 s
->main_exec_status
.pid
= pid
;
2655 } else if (streq(key
, "main-exec-status-code")) {
2658 if (safe_atoi(value
, &i
) < 0)
2659 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2661 s
->main_exec_status
.code
= i
;
2662 } else if (streq(key
, "main-exec-status-status")) {
2665 if (safe_atoi(value
, &i
) < 0)
2666 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2668 s
->main_exec_status
.status
= i
;
2669 } else if (streq(key
, "main-exec-status-start"))
2670 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2671 else if (streq(key
, "main-exec-status-exit"))
2672 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2673 else if (streq(key
, "watchdog-timestamp"))
2674 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2675 else if (streq(key
, "forbid-restart")) {
2678 b
= parse_boolean(value
);
2680 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2682 s
->forbid_restart
= b
;
2683 } else if (streq(key
, "stdin-fd")) {
2686 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2687 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2689 asynchronous_close(s
->stdin_fd
);
2690 s
->stdin_fd
= fdset_remove(fds
, fd
);
2691 s
->exec_context
.stdio_as_fds
= true;
2693 } else if (streq(key
, "stdout-fd")) {
2696 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2697 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2699 asynchronous_close(s
->stdout_fd
);
2700 s
->stdout_fd
= fdset_remove(fds
, fd
);
2701 s
->exec_context
.stdio_as_fds
= true;
2703 } else if (streq(key
, "stderr-fd")) {
2706 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2707 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2709 asynchronous_close(s
->stderr_fd
);
2710 s
->stderr_fd
= fdset_remove(fds
, fd
);
2711 s
->exec_context
.stdio_as_fds
= true;
2713 } else if (streq(key
, "watchdog-override-usec")) {
2714 usec_t watchdog_override_usec
;
2715 if (timestamp_deserialize(value
, &watchdog_override_usec
) < 0)
2716 log_unit_debug(u
, "Failed to parse watchdog_override_usec value: %s", value
);
2718 s
->watchdog_override_enable
= true;
2719 s
->watchdog_override_usec
= watchdog_override_usec
;
2721 } else if (STR_IN_SET(key
, "main-command", "control-command")) {
2722 r
= service_deserialize_exec_command(u
, key
, value
);
2724 log_unit_debug_errno(u
, r
, "Failed to parse serialized command \"%s\": %m", value
);
2726 } else if (streq(key
, "n-restarts")) {
2727 r
= safe_atou(value
, &s
->n_restarts
);
2729 log_unit_debug_errno(u
, r
, "Failed to parse serialized restart counter '%s': %m", value
);
2731 } else if (streq(key
, "flush-n-restarts")) {
2732 r
= parse_boolean(value
);
2734 log_unit_debug_errno(u
, r
, "Failed to parse serialized flush restart counter setting '%s': %m", value
);
2736 s
->flush_n_restarts
= r
;
2738 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2743 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2744 const UnitActiveState
*table
;
2748 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2750 return table
[SERVICE(u
)->state
];
2753 static const char *service_sub_state_to_string(Unit
*u
) {
2756 return service_state_to_string(SERVICE(u
)->state
);
2759 static bool service_check_gc(Unit
*u
) {
2760 Service
*s
= SERVICE(u
);
2764 /* Never clean up services that still have a process around,
2765 * even if the service is formally dead. */
2766 if (cgroup_good(s
) > 0 ||
2767 main_pid_good(s
) > 0 ||
2768 control_pid_good(s
) > 0)
2774 static int service_retry_pid_file(Service
*s
) {
2777 assert(s
->pid_file
);
2778 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2780 r
= service_load_pid_file(s
, false);
2784 service_unwatch_pid_file(s
);
2786 service_enter_running(s
, SERVICE_SUCCESS
);
2790 static int service_watch_pid_file(Service
*s
) {
2793 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2795 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2799 /* the pidfile might have appeared just before we set the watch */
2800 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2801 service_retry_pid_file(s
);
2805 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2806 service_unwatch_pid_file(s
);
2810 static int service_demand_pid_file(Service
*s
) {
2813 assert(s
->pid_file
);
2814 assert(!s
->pid_file_pathspec
);
2816 ps
= new0(PathSpec
, 1);
2821 ps
->path
= strdup(s
->pid_file
);
2827 path_kill_slashes(ps
->path
);
2829 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2830 * keep their PID file open all the time. */
2831 ps
->type
= PATH_MODIFIED
;
2832 ps
->inotify_fd
= -1;
2834 s
->pid_file_pathspec
= ps
;
2836 return service_watch_pid_file(s
);
2839 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2840 PathSpec
*p
= userdata
;
2845 s
= SERVICE(p
->unit
);
2849 assert(IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
));
2850 assert(s
->pid_file_pathspec
);
2851 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2853 log_unit_debug(UNIT(s
), "inotify event");
2855 if (path_spec_fd_event(p
, events
) < 0)
2858 if (service_retry_pid_file(s
) == 0)
2861 if (service_watch_pid_file(s
) < 0)
2867 service_unwatch_pid_file(s
);
2868 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2872 static void service_notify_cgroup_empty_event(Unit
*u
) {
2873 Service
*s
= SERVICE(u
);
2877 log_unit_debug(u
, "cgroup is empty");
2881 /* Waiting for SIGCHLD is usually more interesting,
2882 * because it includes return codes/signals. Which is
2883 * why we ignore the cgroup events for most cases,
2884 * except when we don't know pid which to expect the
2888 if (s
->type
== SERVICE_NOTIFY
&&
2889 main_pid_good(s
) == 0 &&
2890 control_pid_good(s
) == 0) {
2891 /* No chance of getting a ready notification anymore */
2892 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2898 case SERVICE_START_POST
:
2899 if (s
->pid_file_pathspec
&&
2900 main_pid_good(s
) == 0 &&
2901 control_pid_good(s
) == 0) {
2903 /* Give up hoping for the daemon to write its PID file */
2904 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2906 service_unwatch_pid_file(s
);
2907 if (s
->state
== SERVICE_START
)
2908 service_enter_stop_post(s
, SERVICE_FAILURE_PROTOCOL
);
2910 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
2914 case SERVICE_RUNNING
:
2915 /* service_enter_running() will figure out what to do */
2916 service_enter_running(s
, SERVICE_SUCCESS
);
2919 case SERVICE_STOP_SIGABRT
:
2920 case SERVICE_STOP_SIGTERM
:
2921 case SERVICE_STOP_SIGKILL
:
2923 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
2924 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2928 case SERVICE_STOP_POST
:
2929 case SERVICE_FINAL_SIGTERM
:
2930 case SERVICE_FINAL_SIGKILL
:
2931 if (main_pid_good(s
) <= 0 && control_pid_good(s
) <= 0)
2932 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2941 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2942 Service
*s
= SERVICE(u
);
2948 if (is_clean_exit(code
, status
, s
->type
== SERVICE_ONESHOT
? EXIT_CLEAN_COMMAND
: EXIT_CLEAN_DAEMON
, &s
->success_status
))
2949 f
= SERVICE_SUCCESS
;
2950 else if (code
== CLD_EXITED
)
2951 f
= SERVICE_FAILURE_EXIT_CODE
;
2952 else if (code
== CLD_KILLED
)
2953 f
= SERVICE_FAILURE_SIGNAL
;
2954 else if (code
== CLD_DUMPED
)
2955 f
= SERVICE_FAILURE_CORE_DUMP
;
2957 assert_not_reached("Unknown code");
2959 if (s
->main_pid
== pid
) {
2960 /* Forking services may occasionally move to a new PID.
2961 * As long as they update the PID file before exiting the old
2962 * PID, they're fine. */
2963 if (service_load_pid_file(s
, false) == 0)
2967 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2969 if (s
->main_command
) {
2970 /* If this is not a forking service than the
2971 * main process got started and hence we copy
2972 * the exit status so that it is recorded both
2973 * as main and as control process exit
2976 s
->main_command
->exec_status
= s
->main_exec_status
;
2978 if (s
->main_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
2979 f
= SERVICE_SUCCESS
;
2980 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
2982 /* If this is a forked process, then we should
2983 * ignore the return value if this was
2984 * configured for the starter process */
2986 if (s
->exec_command
[SERVICE_EXEC_START
]->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
2987 f
= SERVICE_SUCCESS
;
2990 /* When this is a successful exit, let's log about the exit code on DEBUG level. If this is a failure
2991 * and the process exited on its own via exit(), then let's make this a NOTICE, under the assumption
2992 * that the service already logged the reason at a higher log level on its own. However, if the service
2993 * died due to a signal, then it most likely didn't say anything about any reason, hence let's raise
2994 * our log level to WARNING then. */
2996 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
:
2997 (code
== CLD_EXITED
? LOG_NOTICE
: LOG_WARNING
),
2998 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
2999 sigchld_code_to_string(code
), status
,
3000 strna(code
== CLD_EXITED
3001 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
3002 : signal_to_string(status
))),
3003 "EXIT_CODE=%s", sigchld_code_to_string(code
),
3004 "EXIT_STATUS=%i", status
,
3006 LOG_UNIT_INVOCATION_ID(u
),
3009 if (s
->result
== SERVICE_SUCCESS
)
3012 if (s
->main_command
&&
3013 s
->main_command
->command_next
&&
3014 s
->type
== SERVICE_ONESHOT
&&
3015 f
== SERVICE_SUCCESS
) {
3017 /* There is another command to *
3018 * execute, so let's do that. */
3020 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
3021 service_run_next_main(s
);
3025 /* The service exited, so the service is officially
3027 s
->main_command
= NULL
;
3031 case SERVICE_START_POST
:
3032 case SERVICE_RELOAD
:
3034 /* Need to wait until the operation is
3039 if (s
->type
== SERVICE_ONESHOT
) {
3040 /* This was our main goal, so let's go on */
3041 if (f
== SERVICE_SUCCESS
)
3042 service_enter_start_post(s
);
3044 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3046 } else if (s
->type
== SERVICE_NOTIFY
) {
3047 /* Only enter running through a notification, so that the
3048 * SERVICE_START state signifies that no ready notification
3049 * has been received */
3050 if (f
!= SERVICE_SUCCESS
)
3051 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3052 else if (!s
->remain_after_exit
|| s
->notify_access
== NOTIFY_MAIN
)
3053 /* The service has never been and will never be active */
3054 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3060 case SERVICE_RUNNING
:
3061 service_enter_running(s
, f
);
3064 case SERVICE_STOP_SIGABRT
:
3065 case SERVICE_STOP_SIGTERM
:
3066 case SERVICE_STOP_SIGKILL
:
3068 if (control_pid_good(s
) <= 0)
3069 service_enter_stop_post(s
, f
);
3071 /* If there is still a control process, wait for that first */
3074 case SERVICE_STOP_POST
:
3075 case SERVICE_FINAL_SIGTERM
:
3076 case SERVICE_FINAL_SIGKILL
:
3078 if (control_pid_good(s
) <= 0)
3079 service_enter_dead(s
, f
, true);
3083 assert_not_reached("Uh, main process died at wrong time.");
3087 } else if (s
->control_pid
== pid
) {
3090 if (s
->control_command
) {
3091 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
3093 if (s
->control_command
->flags
& EXEC_COMMAND_IGNORE_FAILURE
)
3094 f
= SERVICE_SUCCESS
;
3097 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
3098 "Control process exited, code=%s status=%i",
3099 sigchld_code_to_string(code
), status
);
3101 if (s
->result
== SERVICE_SUCCESS
)
3104 /* Immediately get rid of the cgroup, so that the
3105 * kernel doesn't delay the cgroup empty messages for
3106 * the service cgroup any longer than necessary */
3107 service_kill_control_processes(s
);
3109 if (s
->control_command
&&
3110 s
->control_command
->command_next
&&
3111 f
== SERVICE_SUCCESS
) {
3113 /* There is another command to *
3114 * execute, so let's do that. */
3116 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
3117 service_run_next_control(s
);
3120 /* No further commands for this step, so let's
3121 * figure out what to do next */
3123 s
->control_command
= NULL
;
3124 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
3126 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
3130 case SERVICE_START_PRE
:
3131 if (f
== SERVICE_SUCCESS
)
3132 service_enter_start(s
);
3134 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3138 if (s
->type
!= SERVICE_FORKING
)
3139 /* Maybe spurious event due to a reload that changed the type? */
3142 if (f
!= SERVICE_SUCCESS
) {
3143 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3148 bool has_start_post
;
3151 /* Let's try to load the pid file here if we can.
3152 * The PID file might actually be created by a START_POST
3153 * script. In that case don't worry if the loading fails. */
3155 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
3156 r
= service_load_pid_file(s
, !has_start_post
);
3157 if (!has_start_post
&& r
< 0) {
3158 r
= service_demand_pid_file(s
);
3159 if (r
< 0 || cgroup_good(s
) == 0)
3160 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_PROTOCOL
);
3164 service_search_main_pid(s
);
3166 service_enter_start_post(s
);
3169 case SERVICE_START_POST
:
3170 if (f
!= SERVICE_SUCCESS
) {
3171 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3178 r
= service_load_pid_file(s
, true);
3180 r
= service_demand_pid_file(s
);
3181 if (r
< 0 || cgroup_good(s
) == 0)
3182 service_enter_stop(s
, SERVICE_FAILURE_PROTOCOL
);
3186 service_search_main_pid(s
);
3188 service_enter_running(s
, SERVICE_SUCCESS
);
3191 case SERVICE_RELOAD
:
3192 if (f
== SERVICE_SUCCESS
)
3193 if (service_load_pid_file(s
, true) < 0)
3194 service_search_main_pid(s
);
3196 s
->reload_result
= f
;
3197 service_enter_running(s
, SERVICE_SUCCESS
);
3201 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
3204 case SERVICE_STOP_SIGABRT
:
3205 case SERVICE_STOP_SIGTERM
:
3206 case SERVICE_STOP_SIGKILL
:
3207 if (main_pid_good(s
) <= 0)
3208 service_enter_stop_post(s
, f
);
3210 /* If there is still a service
3211 * process around, wait until
3212 * that one quit, too */
3215 case SERVICE_STOP_POST
:
3216 case SERVICE_FINAL_SIGTERM
:
3217 case SERVICE_FINAL_SIGKILL
:
3218 if (main_pid_good(s
) <= 0)
3219 service_enter_dead(s
, f
, true);
3223 assert_not_reached("Uh, control process died at wrong time.");
3228 /* Notify clients about changed exit status */
3229 unit_add_to_dbus_queue(u
);
3231 /* We got one SIGCHLD for the service, let's watch all
3232 * processes that are now running of the service, and watch
3233 * that. Among the PIDs we then watch will be children
3234 * reassigned to us, which hopefully allows us to identify
3235 * when all children are gone */
3236 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
3237 unit_watch_all_pids(u
);
3239 /* If the PID set is empty now, then let's finish this off
3240 (On unified we use proper notifications) */
3241 if (cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER
) == 0 && set_isempty(u
->pids
))
3242 unit_add_to_cgroup_empty_queue(u
);
3245 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3246 Service
*s
= SERVICE(userdata
);
3249 assert(source
== s
->timer_event_source
);
3253 case SERVICE_START_PRE
:
3255 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
3256 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3259 case SERVICE_START_POST
:
3260 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
3261 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3264 case SERVICE_RUNNING
:
3265 log_unit_warning(UNIT(s
), "Service reached runtime time limit. Stopping.");
3266 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
3269 case SERVICE_RELOAD
:
3270 log_unit_warning(UNIT(s
), "Reload operation timed out. Killing reload process.");
3271 service_kill_control_processes(s
);
3272 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
3273 service_enter_running(s
, SERVICE_SUCCESS
);
3277 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
3278 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3281 case SERVICE_STOP_SIGABRT
:
3282 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
3283 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3286 case SERVICE_STOP_SIGTERM
:
3287 if (s
->kill_context
.send_sigkill
) {
3288 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
3289 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3291 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
3292 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3297 case SERVICE_STOP_SIGKILL
:
3298 /* Uh, we sent a SIGKILL and it is still not gone?
3299 * Must be something we cannot kill, so let's just be
3300 * weirded out and continue */
3302 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
3303 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
3306 case SERVICE_STOP_POST
:
3307 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
3308 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
3311 case SERVICE_FINAL_SIGTERM
:
3312 if (s
->kill_context
.send_sigkill
) {
3313 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
3314 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
3316 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
3317 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
3322 case SERVICE_FINAL_SIGKILL
:
3323 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
3324 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
3327 case SERVICE_AUTO_RESTART
:
3328 log_unit_info(UNIT(s
),
3329 s
->restart_usec
> 0 ?
3330 "Service hold-off time over, scheduling restart." :
3331 "Service has no hold-off time, scheduling restart.");
3332 service_enter_restart(s
);
3336 assert_not_reached("Timeout at wrong time.");
3342 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
3343 Service
*s
= SERVICE(userdata
);
3344 char t
[FORMAT_TIMESPAN_MAX
];
3345 usec_t watchdog_usec
;
3348 assert(source
== s
->watchdog_event_source
);
3350 watchdog_usec
= service_get_watchdog_usec(s
);
3352 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
3353 format_timespan(t
, sizeof(t
), watchdog_usec
, 1));
3355 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
3360 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
3361 Service
*s
= SERVICE(u
);
3362 _cleanup_free_
char *cc
= NULL
;
3363 bool notify_dbus
= false;
3368 cc
= strv_join(tags
, ", ");
3370 if (s
->notify_access
== NOTIFY_NONE
) {
3371 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
3373 } else if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
3374 if (s
->main_pid
!= 0)
3375 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
3377 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID which is currently not known", pid
);
3379 } else if (s
->notify_access
== NOTIFY_EXEC
&& pid
!= s
->main_pid
&& pid
!= s
->control_pid
) {
3380 if (s
->main_pid
!= 0 && s
->control_pid
!= 0)
3381 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
" and control PID "PID_FMT
,
3382 pid
, s
->main_pid
, s
->control_pid
);
3383 else if (s
->main_pid
!= 0)
3384 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
3385 else if (s
->control_pid
!= 0)
3386 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for control PID "PID_FMT
, pid
, s
->control_pid
);
3388 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID and control PID which are currently not known", pid
);
3391 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
3393 /* Interpret MAINPID= */
3394 e
= strv_find_startswith(tags
, "MAINPID=");
3395 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
3396 if (parse_pid(e
, &pid
) < 0)
3397 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
3398 else if (pid
== s
->control_pid
)
3399 log_unit_warning(u
, "A control process cannot also be the main process");
3400 else if (pid
== getpid_cached() || pid
== 1)
3401 log_unit_warning(u
, "Service manager can't be main process, ignoring sd_notify() MAINPID= field");
3403 service_set_main_pid(s
, pid
);
3404 unit_watch_pid(UNIT(s
), pid
);
3409 /* Interpret RELOADING= */
3410 if (strv_find(tags
, "RELOADING=1")) {
3412 s
->notify_state
= NOTIFY_RELOADING
;
3414 if (s
->state
== SERVICE_RUNNING
)
3415 service_enter_reload_by_notify(s
);
3420 /* Interpret READY= */
3421 if (strv_find(tags
, "READY=1")) {
3423 s
->notify_state
= NOTIFY_READY
;
3425 /* Type=notify services inform us about completed
3426 * initialization with READY=1 */
3427 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
3428 service_enter_start_post(s
);
3430 /* Sending READY=1 while we are reloading informs us
3431 * that the reloading is complete */
3432 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
3433 service_enter_running(s
, SERVICE_SUCCESS
);
3438 /* Interpret STOPPING= */
3439 if (strv_find(tags
, "STOPPING=1")) {
3441 s
->notify_state
= NOTIFY_STOPPING
;
3443 if (s
->state
== SERVICE_RUNNING
)
3444 service_enter_stop_by_notify(s
);
3449 /* Interpret STATUS= */
3450 e
= strv_find_startswith(tags
, "STATUS=");
3452 _cleanup_free_
char *t
= NULL
;
3455 if (!utf8_is_valid(e
))
3456 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3464 if (!streq_ptr(s
->status_text
, t
)) {
3465 free_and_replace(s
->status_text
, t
);
3470 /* Interpret ERRNO= */
3471 e
= strv_find_startswith(tags
, "ERRNO=");
3475 if (safe_atoi(e
, &status_errno
) < 0 || status_errno
< 0)
3476 log_unit_warning(u
, "Failed to parse ERRNO= field in notification message: %s", e
);
3478 if (s
->status_errno
!= status_errno
) {
3479 s
->status_errno
= status_errno
;
3485 /* Interpret WATCHDOG= */
3486 if (strv_find(tags
, "WATCHDOG=1"))
3487 service_reset_watchdog(s
);
3489 if (strv_find(tags
, "FDSTORE=1")) {
3492 name
= strv_find_startswith(tags
, "FDNAME=");
3493 if (name
&& !fdname_is_valid(name
)) {
3494 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3498 service_add_fd_store_set(s
, fds
, name
);
3501 e
= strv_find_startswith(tags
, "WATCHDOG_USEC=");
3503 usec_t watchdog_override_usec
;
3504 if (safe_atou64(e
, &watchdog_override_usec
) < 0)
3505 log_unit_warning(u
, "Failed to parse WATCHDOG_USEC=%s", e
);
3507 service_reset_watchdog_timeout(s
, watchdog_override_usec
);
3510 /* Notify clients about changed status or main pid */
3512 unit_add_to_dbus_queue(u
);
3515 static int service_get_timeout(Unit
*u
, usec_t
*timeout
) {
3516 Service
*s
= SERVICE(u
);
3520 if (!s
->timer_event_source
)
3523 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
3526 if (t
== USEC_INFINITY
)
3533 static void service_bus_name_owner_change(
3536 const char *old_owner
,
3537 const char *new_owner
) {
3539 Service
*s
= SERVICE(u
);
3545 assert(streq(s
->bus_name
, name
));
3546 assert(old_owner
|| new_owner
);
3548 if (old_owner
&& new_owner
)
3549 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3551 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3553 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3555 s
->bus_name_good
= !!new_owner
;
3557 /* Track the current owner, so we can reconstruct changes after a daemon reload */
3558 r
= free_and_strdup(&s
->bus_name_owner
, new_owner
);
3560 log_unit_error_errno(u
, r
, "Unable to set new bus name owner %s: %m", new_owner
);
3564 if (s
->type
== SERVICE_DBUS
) {
3566 /* service_enter_running() will figure out what to
3568 if (s
->state
== SERVICE_RUNNING
)
3569 service_enter_running(s
, SERVICE_SUCCESS
);
3570 else if (s
->state
== SERVICE_START
&& new_owner
)
3571 service_enter_start_post(s
);
3573 } else if (new_owner
&&
3581 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
3584 /* Try to acquire PID from bus service */
3586 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3588 r
= sd_bus_creds_get_pid(creds
, &pid
);
3590 log_unit_debug(u
, "D-Bus name %s is now owned by process " PID_FMT
, name
, pid
);
3592 service_set_main_pid(s
, pid
);
3593 unit_watch_pid(UNIT(s
), pid
);
3598 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3599 _cleanup_free_
char *peer
= NULL
;
3605 /* This is called by the socket code when instantiating a new service for a stream socket and the socket needs
3606 * to be configured. We take ownership of the passed fd on success. */
3608 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3611 if (s
->socket_fd
>= 0)
3614 if (s
->state
!= SERVICE_DEAD
)
3617 if (getpeername_pretty(fd
, true, &peer
) >= 0) {
3619 if (UNIT(s
)->description
) {
3620 _cleanup_free_
char *a
;
3622 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")");
3626 r
= unit_set_description(UNIT(s
), a
);
3628 r
= unit_set_description(UNIT(s
), peer
);
3634 r
= unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false, UNIT_DEPENDENCY_IMPLICIT
);
3639 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3641 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3645 static void service_reset_failed(Unit
*u
) {
3646 Service
*s
= SERVICE(u
);
3650 if (s
->state
== SERVICE_FAILED
)
3651 service_set_state(s
, SERVICE_DEAD
);
3653 s
->result
= SERVICE_SUCCESS
;
3654 s
->reload_result
= SERVICE_SUCCESS
;
3656 s
->flush_n_restarts
= false;
3659 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3660 Service
*s
= SERVICE(u
);
3664 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3667 static int service_main_pid(Unit
*u
) {
3668 Service
*s
= SERVICE(u
);
3675 static int service_control_pid(Unit
*u
) {
3676 Service
*s
= SERVICE(u
);
3680 return s
->control_pid
;
3683 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3684 [SERVICE_RESTART_NO
] = "no",
3685 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3686 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3687 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3688 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3689 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3690 [SERVICE_RESTART_ALWAYS
] = "always",
3693 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3695 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3696 [SERVICE_SIMPLE
] = "simple",
3697 [SERVICE_FORKING
] = "forking",
3698 [SERVICE_ONESHOT
] = "oneshot",
3699 [SERVICE_DBUS
] = "dbus",
3700 [SERVICE_NOTIFY
] = "notify",
3701 [SERVICE_IDLE
] = "idle"
3704 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3706 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3707 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3708 [SERVICE_EXEC_START
] = "ExecStart",
3709 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3710 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3711 [SERVICE_EXEC_STOP
] = "ExecStop",
3712 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3715 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3717 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3718 [NOTIFY_UNKNOWN
] = "unknown",
3719 [NOTIFY_READY
] = "ready",
3720 [NOTIFY_RELOADING
] = "reloading",
3721 [NOTIFY_STOPPING
] = "stopping",
3724 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3726 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3727 [SERVICE_SUCCESS
] = "success",
3728 [SERVICE_FAILURE_RESOURCES
] = "resources",
3729 [SERVICE_FAILURE_PROTOCOL
] = "protocol",
3730 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3731 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3732 [SERVICE_FAILURE_SIGNAL
] = "signal",
3733 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3734 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3735 [SERVICE_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
3738 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3740 const UnitVTable service_vtable
= {
3741 .object_size
= sizeof(Service
),
3742 .exec_context_offset
= offsetof(Service
, exec_context
),
3743 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3744 .kill_context_offset
= offsetof(Service
, kill_context
),
3745 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3746 .dynamic_creds_offset
= offsetof(Service
, dynamic_creds
),
3752 .private_section
= "Service",
3754 .init
= service_init
,
3755 .done
= service_done
,
3756 .load
= service_load
,
3757 .release_resources
= service_release_resources
,
3759 .coldplug
= service_coldplug
,
3761 .dump
= service_dump
,
3763 .start
= service_start
,
3764 .stop
= service_stop
,
3765 .reload
= service_reload
,
3767 .can_reload
= service_can_reload
,
3769 .kill
= service_kill
,
3771 .serialize
= service_serialize
,
3772 .deserialize_item
= service_deserialize_item
,
3774 .active_state
= service_active_state
,
3775 .sub_state_to_string
= service_sub_state_to_string
,
3777 .check_gc
= service_check_gc
,
3779 .sigchld_event
= service_sigchld_event
,
3781 .reset_failed
= service_reset_failed
,
3783 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3784 .notify_message
= service_notify_message
,
3786 .main_pid
= service_main_pid
,
3787 .control_pid
= service_control_pid
,
3789 .bus_name_owner_change
= service_bus_name_owner_change
,
3791 .bus_vtable
= bus_service_vtable
,
3792 .bus_set_property
= bus_service_set_property
,
3793 .bus_commit_properties
= bus_service_commit_properties
,
3795 .get_timeout
= service_get_timeout
,
3796 .can_transient
= true,
3798 .status_message_formats
= {
3799 .starting_stopping
= {
3800 [0] = "Starting %s...",
3801 [1] = "Stopping %s...",
3803 .finished_start_job
= {
3804 [JOB_DONE
] = "Started %s.",
3805 [JOB_FAILED
] = "Failed to start %s.",
3807 .finished_stop_job
= {
3808 [JOB_DONE
] = "Stopped %s.",
3809 [JOB_FAILED
] = "Stopped (with error) %s.",