1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
27 #include "bus-error.h"
28 #include "bus-kernel.h"
30 #include "dbus-service.h"
34 #include "exit-status.h"
37 #include "formats-util.h"
38 #include "load-dropin.h"
39 #include "load-fragment.h"
42 #include "parse-util.h"
43 #include "path-util.h"
44 #include "process-util.h"
46 #include "signal-util.h"
48 #include "string-util.h"
50 #include "unit-name.h"
51 #include "unit-printf.h"
56 static const UnitActiveState state_translation_table
[_SERVICE_STATE_MAX
] = {
57 [SERVICE_DEAD
] = UNIT_INACTIVE
,
58 [SERVICE_START_PRE
] = UNIT_ACTIVATING
,
59 [SERVICE_START
] = UNIT_ACTIVATING
,
60 [SERVICE_START_POST
] = UNIT_ACTIVATING
,
61 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
62 [SERVICE_EXITED
] = UNIT_ACTIVE
,
63 [SERVICE_RELOAD
] = UNIT_RELOADING
,
64 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
65 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
66 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
67 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
68 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
69 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
70 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
71 [SERVICE_FAILED
] = UNIT_FAILED
,
72 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
75 /* For Type=idle we never want to delay any other jobs, hence we
76 * consider idle jobs active as soon as we start working on them */
77 static const UnitActiveState state_translation_table_idle
[_SERVICE_STATE_MAX
] = {
78 [SERVICE_DEAD
] = UNIT_INACTIVE
,
79 [SERVICE_START_PRE
] = UNIT_ACTIVE
,
80 [SERVICE_START
] = UNIT_ACTIVE
,
81 [SERVICE_START_POST
] = UNIT_ACTIVE
,
82 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
83 [SERVICE_EXITED
] = UNIT_ACTIVE
,
84 [SERVICE_RELOAD
] = UNIT_RELOADING
,
85 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
86 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
87 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
88 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
89 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
90 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
91 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
92 [SERVICE_FAILED
] = UNIT_FAILED
,
93 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
96 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
);
97 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
98 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
);
100 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
);
101 static void service_enter_reload_by_notify(Service
*s
);
103 static void service_init(Unit
*u
) {
104 Service
*s
= SERVICE(u
);
107 assert(u
->load_state
== UNIT_STUB
);
109 s
->timeout_start_usec
= u
->manager
->default_timeout_start_usec
;
110 s
->timeout_stop_usec
= u
->manager
->default_timeout_stop_usec
;
111 s
->restart_usec
= u
->manager
->default_restart_usec
;
112 s
->type
= _SERVICE_TYPE_INVALID
;
114 s
->bus_endpoint_fd
= -1;
115 s
->stdin_fd
= s
->stdout_fd
= s
->stderr_fd
= -1;
116 s
->guess_main_pid
= true;
118 RATELIMIT_INIT(s
->start_limit
, u
->manager
->default_start_limit_interval
, u
->manager
->default_start_limit_burst
);
120 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
123 static void service_unwatch_control_pid(Service
*s
) {
126 if (s
->control_pid
<= 0)
129 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
133 static void service_unwatch_main_pid(Service
*s
) {
136 if (s
->main_pid
<= 0)
139 unit_unwatch_pid(UNIT(s
), s
->main_pid
);
143 static void service_unwatch_pid_file(Service
*s
) {
144 if (!s
->pid_file_pathspec
)
147 log_unit_debug(UNIT(s
), "Stopping watch for PID file %s", s
->pid_file_pathspec
->path
);
148 path_spec_unwatch(s
->pid_file_pathspec
);
149 path_spec_done(s
->pid_file_pathspec
);
150 s
->pid_file_pathspec
= mfree(s
->pid_file_pathspec
);
153 static int service_set_main_pid(Service
*s
, pid_t pid
) {
164 if (s
->main_pid
== pid
&& s
->main_pid_known
)
167 if (s
->main_pid
!= pid
) {
168 service_unwatch_main_pid(s
);
169 exec_status_start(&s
->main_exec_status
, pid
);
173 s
->main_pid_known
= true;
175 if (get_parent_of_pid(pid
, &ppid
) >= 0 && ppid
!= getpid()) {
176 log_unit_warning(UNIT(s
), "Supervising process "PID_FMT
" which is not our child. We'll most likely not notice when it exits.", pid
);
177 s
->main_pid_alien
= true;
179 s
->main_pid_alien
= false;
184 static void service_close_socket_fd(Service
*s
) {
187 s
->socket_fd
= asynchronous_close(s
->socket_fd
);
190 static void service_connection_unref(Service
*s
) {
193 if (!UNIT_ISSET(s
->accept_socket
))
196 socket_connection_unref(SOCKET(UNIT_DEREF(s
->accept_socket
)));
197 unit_ref_unset(&s
->accept_socket
);
200 static void service_stop_watchdog(Service
*s
) {
203 s
->watchdog_event_source
= sd_event_source_unref(s
->watchdog_event_source
);
204 s
->watchdog_timestamp
= DUAL_TIMESTAMP_NULL
;
207 static void service_start_watchdog(Service
*s
) {
212 if (s
->watchdog_usec
<= 0)
215 if (s
->watchdog_event_source
) {
216 r
= sd_event_source_set_time(s
->watchdog_event_source
, s
->watchdog_timestamp
.monotonic
+ s
->watchdog_usec
);
218 log_unit_warning_errno(UNIT(s
), r
, "Failed to reset watchdog timer: %m");
222 r
= sd_event_source_set_enabled(s
->watchdog_event_source
, SD_EVENT_ONESHOT
);
224 r
= sd_event_add_time(
225 UNIT(s
)->manager
->event
,
226 &s
->watchdog_event_source
,
228 s
->watchdog_timestamp
.monotonic
+ s
->watchdog_usec
, 0,
229 service_dispatch_watchdog
, s
);
231 log_unit_warning_errno(UNIT(s
), r
, "Failed to add watchdog timer: %m");
235 (void) sd_event_source_set_description(s
->watchdog_event_source
, "service-watchdog");
237 /* Let's process everything else which might be a sign
238 * of living before we consider a service died. */
239 r
= sd_event_source_set_priority(s
->watchdog_event_source
, SD_EVENT_PRIORITY_IDLE
);
243 log_unit_warning_errno(UNIT(s
), r
, "Failed to install watchdog timer: %m");
246 static void service_reset_watchdog(Service
*s
) {
249 dual_timestamp_get(&s
->watchdog_timestamp
);
250 service_start_watchdog(s
);
253 static void service_fd_store_unlink(ServiceFDStore
*fs
) {
259 assert(fs
->service
->n_fd_store
> 0);
260 LIST_REMOVE(fd_store
, fs
->service
->fd_store
, fs
);
261 fs
->service
->n_fd_store
--;
264 if (fs
->event_source
) {
265 sd_event_source_set_enabled(fs
->event_source
, SD_EVENT_OFF
);
266 sd_event_source_unref(fs
->event_source
);
274 static void service_release_resources(Unit
*u
) {
275 Service
*s
= SERVICE(u
);
279 if (!s
->fd_store
&& s
->stdin_fd
< 0 && s
->stdout_fd
< 0 && s
->stderr_fd
< 0)
282 log_unit_debug(u
, "Releasing all resources.");
284 s
->stdin_fd
= safe_close(s
->stdin_fd
);
285 s
->stdout_fd
= safe_close(s
->stdout_fd
);
286 s
->stderr_fd
= safe_close(s
->stderr_fd
);
289 service_fd_store_unlink(s
->fd_store
);
291 assert(s
->n_fd_store
== 0);
294 static void service_done(Unit
*u
) {
295 Service
*s
= SERVICE(u
);
299 s
->pid_file
= mfree(s
->pid_file
);
300 s
->status_text
= mfree(s
->status_text
);
301 s
->reboot_arg
= mfree(s
->reboot_arg
);
303 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
304 exec_command_free_array(s
->exec_command
, _SERVICE_EXEC_COMMAND_MAX
);
305 s
->control_command
= NULL
;
306 s
->main_command
= NULL
;
308 exit_status_set_free(&s
->restart_prevent_status
);
309 exit_status_set_free(&s
->restart_force_status
);
310 exit_status_set_free(&s
->success_status
);
312 /* This will leak a process, but at least no memory or any of
314 service_unwatch_main_pid(s
);
315 service_unwatch_control_pid(s
);
316 service_unwatch_pid_file(s
);
319 unit_unwatch_bus_name(u
, s
->bus_name
);
320 s
->bus_name
= mfree(s
->bus_name
);
323 s
->bus_endpoint_fd
= safe_close(s
->bus_endpoint_fd
);
324 service_close_socket_fd(s
);
325 service_connection_unref(s
);
327 unit_ref_unset(&s
->accept_socket
);
329 service_stop_watchdog(s
);
331 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
333 service_release_resources(u
);
336 static int on_fd_store_io(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
337 ServiceFDStore
*fs
= userdata
;
342 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
343 service_fd_store_unlink(fs
);
347 static int service_add_fd_store(Service
*s
, int fd
, const char *name
) {
354 if (s
->n_fd_store
>= s
->n_fd_store_max
)
357 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
358 r
= same_fd(fs
->fd
, fd
);
362 /* Already included */
368 fs
= new0(ServiceFDStore
, 1);
374 fs
->fdname
= strdup(name
?: "stored");
380 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &fs
->event_source
, fd
, 0, on_fd_store_io
, fs
);
387 (void) sd_event_source_set_description(fs
->event_source
, "service-fd-store");
389 LIST_PREPEND(fd_store
, s
->fd_store
, fs
);
395 static int service_add_fd_store_set(Service
*s
, FDSet
*fds
, const char *name
) {
400 if (fdset_size(fds
) <= 0)
403 while (s
->n_fd_store
< s
->n_fd_store_max
) {
404 _cleanup_close_
int fd
= -1;
406 fd
= fdset_steal_first(fds
);
410 r
= service_add_fd_store(s
, fd
, name
);
412 return log_unit_error_errno(UNIT(s
), r
, "Couldn't add fd to fd store: %m");
414 log_unit_debug(UNIT(s
), "Added fd to fd store.");
419 if (fdset_size(fds
) > 0)
420 log_unit_warning(UNIT(s
), "Tried to store more fds than FDStoreMax=%u allows, closing remaining.", s
->n_fd_store_max
);
425 static int service_arm_timer(Service
*s
, usec_t usec
) {
430 if (s
->timer_event_source
) {
431 r
= sd_event_source_set_time(s
->timer_event_source
, now(CLOCK_MONOTONIC
) + usec
);
435 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
438 r
= sd_event_add_time(
439 UNIT(s
)->manager
->event
,
440 &s
->timer_event_source
,
442 now(CLOCK_MONOTONIC
) + usec
, 0,
443 service_dispatch_timer
, s
);
447 (void) sd_event_source_set_description(s
->timer_event_source
, "service-timer");
452 static int service_verify(Service
*s
) {
455 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
458 if (!s
->exec_command
[SERVICE_EXEC_START
] && !s
->exec_command
[SERVICE_EXEC_STOP
]) {
459 log_unit_error(UNIT(s
), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
463 if (s
->type
!= SERVICE_ONESHOT
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
464 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
468 if (!s
->remain_after_exit
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
469 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
473 if (s
->type
!= SERVICE_ONESHOT
&& s
->exec_command
[SERVICE_EXEC_START
]->command_next
) {
474 log_unit_error(UNIT(s
), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
478 if (s
->type
== SERVICE_ONESHOT
&& s
->restart
!= SERVICE_RESTART_NO
) {
479 log_unit_error(UNIT(s
), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
483 if (s
->type
== SERVICE_ONESHOT
&& !exit_status_set_is_empty(&s
->restart_force_status
)) {
484 log_unit_error(UNIT(s
), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
488 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name
) {
489 log_unit_error(UNIT(s
), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
493 if (s
->bus_name
&& s
->type
!= SERVICE_DBUS
)
494 log_unit_warning(UNIT(s
), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
496 if (s
->exec_context
.pam_name
&& !(s
->kill_context
.kill_mode
== KILL_CONTROL_GROUP
|| s
->kill_context
.kill_mode
== KILL_MIXED
)) {
497 log_unit_error(UNIT(s
), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
501 if (s
->usb_function_descriptors
&& !s
->usb_function_strings
)
502 log_unit_warning(UNIT(s
), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
504 if (!s
->usb_function_descriptors
&& s
->usb_function_strings
)
505 log_unit_warning(UNIT(s
), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
510 static int service_add_default_dependencies(Service
*s
) {
515 /* Add a number of automatic dependencies useful for the
516 * majority of services. */
518 /* First, pull in base system */
519 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_BASIC_TARGET
, NULL
, true);
523 /* Second, activate normal shutdown */
524 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
527 static void service_fix_output(Service
*s
) {
530 /* If nothing has been explicitly configured, patch default
531 * output in. If input is socket/tty we avoid this however,
532 * since in that case we want output to default to the same
533 * place as we read input from. */
535 if (s
->exec_context
.std_error
== EXEC_OUTPUT_INHERIT
&&
536 s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
537 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
538 s
->exec_context
.std_error
= UNIT(s
)->manager
->default_std_error
;
540 if (s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
541 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
542 s
->exec_context
.std_output
= UNIT(s
)->manager
->default_std_output
;
545 static int service_add_extras(Service
*s
) {
550 if (s
->type
== _SERVICE_TYPE_INVALID
) {
551 /* Figure out a type automatically */
553 s
->type
= SERVICE_DBUS
;
554 else if (s
->exec_command
[SERVICE_EXEC_START
])
555 s
->type
= SERVICE_SIMPLE
;
557 s
->type
= SERVICE_ONESHOT
;
560 /* Oneshot services have disabled start timeout by default */
561 if (s
->type
== SERVICE_ONESHOT
&& !s
->start_timeout_defined
)
562 s
->timeout_start_usec
= 0;
564 service_fix_output(s
);
566 r
= unit_patch_contexts(UNIT(s
));
570 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
574 r
= unit_set_default_slice(UNIT(s
));
578 if (s
->type
== SERVICE_NOTIFY
&& s
->notify_access
== NOTIFY_NONE
)
579 s
->notify_access
= NOTIFY_MAIN
;
581 if (s
->watchdog_usec
> 0 && s
->notify_access
== NOTIFY_NONE
)
582 s
->notify_access
= NOTIFY_MAIN
;
587 n
= strjoina(s
->bus_name
, ".busname");
588 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, n
, NULL
, true);
592 r
= unit_watch_bus_name(UNIT(s
), s
->bus_name
);
594 return log_unit_error_errno(UNIT(s
), r
, "Two services allocated for the same bus name %s, refusing operation.", s
->bus_name
);
596 return log_unit_error_errno(UNIT(s
), r
, "Cannot watch bus name %s: %m", s
->bus_name
);
599 if (UNIT(s
)->default_dependencies
) {
600 r
= service_add_default_dependencies(s
);
608 static int service_load(Unit
*u
) {
609 Service
*s
= SERVICE(u
);
614 /* Load a .service file */
615 r
= unit_load_fragment(u
);
619 /* Still nothing found? Then let's give up */
620 if (u
->load_state
== UNIT_STUB
)
623 /* This is a new unit? Then let's add in some extras */
624 if (u
->load_state
== UNIT_LOADED
) {
626 /* We were able to load something, then let's add in
627 * the dropin directories. */
628 r
= unit_load_dropin(u
);
632 /* This is a new unit? Then let's add in some
634 r
= service_add_extras(s
);
639 return service_verify(s
);
642 static void service_dump(Unit
*u
, FILE *f
, const char *prefix
) {
643 ServiceExecCommand c
;
644 Service
*s
= SERVICE(u
);
649 prefix
= strempty(prefix
);
650 prefix2
= strjoina(prefix
, "\t");
653 "%sService State: %s\n"
655 "%sReload Result: %s\n"
656 "%sPermissionsStartOnly: %s\n"
657 "%sRootDirectoryStartOnly: %s\n"
658 "%sRemainAfterExit: %s\n"
659 "%sGuessMainPID: %s\n"
662 "%sNotifyAccess: %s\n"
663 "%sNotifyState: %s\n",
664 prefix
, service_state_to_string(s
->state
),
665 prefix
, service_result_to_string(s
->result
),
666 prefix
, service_result_to_string(s
->reload_result
),
667 prefix
, yes_no(s
->permissions_start_only
),
668 prefix
, yes_no(s
->root_directory_start_only
),
669 prefix
, yes_no(s
->remain_after_exit
),
670 prefix
, yes_no(s
->guess_main_pid
),
671 prefix
, service_type_to_string(s
->type
),
672 prefix
, service_restart_to_string(s
->restart
),
673 prefix
, notify_access_to_string(s
->notify_access
),
674 prefix
, notify_state_to_string(s
->notify_state
));
676 if (s
->control_pid
> 0)
678 "%sControl PID: "PID_FMT
"\n",
679 prefix
, s
->control_pid
);
683 "%sMain PID: "PID_FMT
"\n"
684 "%sMain PID Known: %s\n"
685 "%sMain PID Alien: %s\n",
687 prefix
, yes_no(s
->main_pid_known
),
688 prefix
, yes_no(s
->main_pid_alien
));
693 prefix
, s
->pid_file
);
698 "%sBus Name Good: %s\n",
700 prefix
, yes_no(s
->bus_name_good
));
702 kill_context_dump(&s
->kill_context
, f
, prefix
);
703 exec_context_dump(&s
->exec_context
, f
, prefix
);
705 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
707 if (!s
->exec_command
[c
])
710 fprintf(f
, "%s-> %s:\n",
711 prefix
, service_exec_command_to_string(c
));
713 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
717 fprintf(f
, "%sStatus Text: %s\n",
718 prefix
, s
->status_text
);
720 if (s
->n_fd_store_max
> 0)
722 "%sFile Descriptor Store Max: %u\n"
723 "%sFile Descriptor Store Current: %u\n",
724 prefix
, s
->n_fd_store_max
,
725 prefix
, s
->n_fd_store
);
728 static int service_load_pid_file(Service
*s
, bool may_warn
) {
729 _cleanup_free_
char *k
= NULL
;
738 r
= read_one_line_file(s
->pid_file
, &k
);
741 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
));
745 r
= parse_pid(k
, &pid
);
748 log_unit_info_errno(UNIT(s
), r
, "Failed to read PID from file %s: %m", s
->pid_file
);
752 if (!pid_is_alive(pid
)) {
754 log_unit_info(UNIT(s
), "PID "PID_FMT
" read from file %s does not exist or is a zombie.", pid
, s
->pid_file
);
758 if (s
->main_pid_known
) {
759 if (pid
== s
->main_pid
)
762 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
764 service_unwatch_main_pid(s
);
765 s
->main_pid_known
= false;
767 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
769 r
= service_set_main_pid(s
, pid
);
773 r
= unit_watch_pid(UNIT(s
), pid
);
775 /* FIXME: we need to do something here */
776 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
783 static int service_search_main_pid(Service
*s
) {
789 /* If we know it anyway, don't ever fallback to unreliable
791 if (s
->main_pid_known
)
794 if (!s
->guess_main_pid
)
797 assert(s
->main_pid
<= 0);
799 r
= unit_search_main_pid(UNIT(s
), &pid
);
803 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
804 r
= service_set_main_pid(s
, pid
);
808 r
= unit_watch_pid(UNIT(s
), pid
);
810 /* FIXME: we need to do something here */
811 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
818 static void service_set_state(Service
*s
, ServiceState state
) {
819 ServiceState old_state
;
820 const UnitActiveState
*table
;
824 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
826 old_state
= s
->state
;
829 service_unwatch_pid_file(s
);
832 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
834 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
835 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
836 SERVICE_AUTO_RESTART
))
837 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
840 SERVICE_START
, SERVICE_START_POST
,
841 SERVICE_RUNNING
, SERVICE_RELOAD
,
842 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
843 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
844 service_unwatch_main_pid(s
);
845 s
->main_command
= NULL
;
849 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
851 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
852 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
853 service_unwatch_control_pid(s
);
854 s
->control_command
= NULL
;
855 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
858 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
859 unit_unwatch_all_pids(UNIT(s
));
862 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
863 SERVICE_RUNNING
, SERVICE_RELOAD
,
864 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
865 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
866 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
)) {
867 service_close_socket_fd(s
);
868 service_connection_unref(s
);
871 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
872 service_stop_watchdog(s
);
874 /* For the inactive states unit_notify() will trim the cgroup,
875 * but for exit we have to do that ourselves... */
876 if (state
== SERVICE_EXITED
&& UNIT(s
)->manager
->n_reloading
<= 0)
877 unit_prune_cgroup(UNIT(s
));
879 /* For remain_after_exit services, let's see if we can "release" the
880 * hold on the console, since unit_notify() only does that in case of
882 if (state
== SERVICE_EXITED
&&
883 s
->remain_after_exit
&&
884 UNIT(s
)->manager
->n_on_console
> 0) {
888 ec
= unit_get_exec_context(UNIT(s
));
889 if (ec
&& exec_context_may_touch_console(ec
)) {
890 Manager
*m
= UNIT(s
)->manager
;
893 if (m
->n_on_console
== 0)
894 /* unset no_console_output flag, since the console is free */
895 m
->no_console_output
= false;
899 if (old_state
!= state
)
900 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
902 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
905 static int service_coldplug(Unit
*u
) {
906 Service
*s
= SERVICE(u
);
910 assert(s
->state
== SERVICE_DEAD
);
912 if (s
->deserialized_state
!= s
->state
) {
914 if (IN_SET(s
->deserialized_state
,
915 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
917 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
918 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
922 k
= IN_SET(s
->deserialized_state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
;
924 /* For the start/stop timeouts 0 means off */
926 r
= service_arm_timer(s
, k
);
932 if (s
->deserialized_state
== SERVICE_AUTO_RESTART
) {
934 /* The restart timeouts 0 means immediately */
935 r
= service_arm_timer(s
, s
->restart_usec
);
940 if (pid_is_unwaited(s
->main_pid
) &&
941 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
942 IN_SET(s
->deserialized_state
,
943 SERVICE_START
, SERVICE_START_POST
,
944 SERVICE_RUNNING
, SERVICE_RELOAD
,
945 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
946 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
947 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
952 if (pid_is_unwaited(s
->control_pid
) &&
953 IN_SET(s
->deserialized_state
,
954 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
956 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
957 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
958 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
963 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
964 unit_watch_all_pids(UNIT(s
));
966 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
967 service_start_watchdog(s
);
969 service_set_state(s
, s
->deserialized_state
);
975 static int service_collect_fds(Service
*s
, int **fds
, char ***fd_names
) {
976 _cleanup_strv_free_
char **rfd_names
= NULL
;
977 _cleanup_free_
int *rfds
= NULL
;
984 if (s
->socket_fd
>= 0) {
986 /* Pass the per-connection socket */
991 rfds
[0] = s
->socket_fd
;
993 rfd_names
= strv_new("connection", NULL
);
1002 /* Pass all our configured sockets for singleton services */
1004 SET_FOREACH(u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1005 _cleanup_free_
int *cfds
= NULL
;
1009 if (u
->type
!= UNIT_SOCKET
)
1014 cn_fds
= socket_collect_fds(sock
, &cfds
);
1029 t
= realloc(rfds
, (rn_fds
+ cn_fds
) * sizeof(int));
1033 memcpy(t
+ rn_fds
, cfds
, cn_fds
* sizeof(int));
1039 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1045 if (s
->n_fd_store
> 0) {
1050 t
= realloc(rfds
, (rn_fds
+ s
->n_fd_store
) * sizeof(int));
1056 nl
= realloc(rfd_names
, (rn_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1062 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1063 rfds
[rn_fds
] = fs
->fd
;
1064 rfd_names
[rn_fds
] = strdup(strempty(fs
->fdname
));
1065 if (!rfd_names
[rn_fds
])
1071 rfd_names
[rn_fds
] = NULL
;
1075 *fd_names
= rfd_names
;
1083 static int service_spawn(
1088 bool apply_permissions
,
1090 bool apply_tty_stdin
,
1094 _cleanup_strv_free_
char **argv
= NULL
, **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1095 _cleanup_free_
char *bus_endpoint_path
= NULL
;
1096 _cleanup_free_
int *fds
= NULL
;
1097 unsigned n_fds
= 0, n_env
= 0;
1101 ExecParameters exec_params
= {
1102 .apply_permissions
= apply_permissions
,
1103 .apply_chroot
= apply_chroot
,
1104 .apply_tty_stdin
= apply_tty_stdin
,
1105 .bus_endpoint_fd
= -1,
1117 (void) unit_realize_cgroup(UNIT(s
));
1118 if (s
->reset_cpu_usage
) {
1119 (void) unit_reset_cpu_usage(UNIT(s
));
1120 s
->reset_cpu_usage
= false;
1123 r
= unit_setup_exec_runtime(UNIT(s
));
1128 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1129 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1130 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1132 r
= service_collect_fds(s
, &fds
, &fd_names
);
1140 r
= service_arm_timer(s
, timeout
);
1144 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1146 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1150 our_env
= new0(char*, 6);
1156 if (is_control
? s
->notify_access
== NOTIFY_ALL
: s
->notify_access
!= NOTIFY_NONE
)
1157 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0) {
1162 if (s
->main_pid
> 0)
1163 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0) {
1168 if (UNIT(s
)->manager
->running_as
!= MANAGER_SYSTEM
)
1169 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid()) < 0) {
1174 if (s
->socket_fd
>= 0) {
1175 union sockaddr_union sa
;
1176 socklen_t salen
= sizeof(sa
);
1178 r
= getpeername(s
->socket_fd
, &sa
.sa
, &salen
);
1184 if (IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
)) {
1185 _cleanup_free_
char *addr
= NULL
;
1189 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1193 t
= strappend("REMOTE_ADDR=", addr
);
1198 our_env
[n_env
++] = t
;
1200 port
= sockaddr_port(&sa
.sa
);
1206 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0) {
1210 our_env
[n_env
++] = t
;
1214 final_env
= strv_env_merge(2, UNIT(s
)->manager
->environment
, our_env
, NULL
);
1220 if (is_control
&& UNIT(s
)->cgroup_path
) {
1221 path
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1222 (void) cg_create(SYSTEMD_CGROUP_CONTROLLER
, path
);
1224 path
= UNIT(s
)->cgroup_path
;
1226 if (s
->exec_context
.bus_endpoint
) {
1227 r
= bus_kernel_create_endpoint(UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
? "system" : "user",
1228 UNIT(s
)->id
, &bus_endpoint_path
);
1232 /* Pass the fd to the exec_params so that the child process can upload the policy.
1233 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1234 * as the service is running. */
1235 exec_params
.bus_endpoint_fd
= s
->bus_endpoint_fd
= r
;
1238 exec_params
.argv
= argv
;
1239 exec_params
.fds
= fds
;
1240 exec_params
.fd_names
= fd_names
;
1241 exec_params
.n_fds
= n_fds
;
1242 exec_params
.environment
= final_env
;
1243 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1244 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1245 exec_params
.cgroup_path
= path
;
1246 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1247 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1248 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1249 exec_params
.bus_endpoint_path
= bus_endpoint_path
;
1250 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1251 if (s
->type
== SERVICE_IDLE
)
1252 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1253 exec_params
.stdin_fd
= s
->stdin_fd
;
1254 exec_params
.stdout_fd
= s
->stdout_fd
;
1255 exec_params
.stderr_fd
= s
->stderr_fd
;
1257 r
= exec_spawn(UNIT(s
),
1266 r
= unit_watch_pid(UNIT(s
), pid
);
1268 /* FIXME: we need to do something here */
1277 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1282 static int main_pid_good(Service
*s
) {
1285 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1288 /* If we know the pid file, then let's just check if it is
1290 if (s
->main_pid_known
) {
1292 /* If it's an alien child let's check if it is still
1294 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1295 return pid_is_alive(s
->main_pid
);
1297 /* .. otherwise assume we'll get a SIGCHLD for it,
1298 * which we really should wait for to collect exit
1299 * status and code */
1300 return s
->main_pid
> 0;
1303 /* We don't know the pid */
1307 _pure_
static int control_pid_good(Service
*s
) {
1310 return s
->control_pid
> 0;
1313 static int cgroup_good(Service
*s
) {
1318 if (!UNIT(s
)->cgroup_path
)
1321 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1328 static bool service_shall_restart(Service
*s
) {
1331 /* Don't restart after manual stops */
1332 if (s
->forbid_restart
)
1335 /* Never restart if this is configured as special exception */
1336 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1339 /* Restart if the exit code/status are configured as restart triggers */
1340 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1343 switch (s
->restart
) {
1345 case SERVICE_RESTART_NO
:
1348 case SERVICE_RESTART_ALWAYS
:
1351 case SERVICE_RESTART_ON_SUCCESS
:
1352 return s
->result
== SERVICE_SUCCESS
;
1354 case SERVICE_RESTART_ON_FAILURE
:
1355 return s
->result
!= SERVICE_SUCCESS
;
1357 case SERVICE_RESTART_ON_ABNORMAL
:
1358 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1360 case SERVICE_RESTART_ON_WATCHDOG
:
1361 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1363 case SERVICE_RESTART_ON_ABORT
:
1364 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1367 assert_not_reached("unknown restart setting");
1371 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1375 if (f
!= SERVICE_SUCCESS
)
1378 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1380 if (s
->result
!= SERVICE_SUCCESS
) {
1381 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1382 failure_action(UNIT(s
)->manager
, s
->failure_action
, s
->reboot_arg
);
1385 if (allow_restart
&& service_shall_restart(s
)) {
1387 r
= service_arm_timer(s
, s
->restart_usec
);
1391 service_set_state(s
, SERVICE_AUTO_RESTART
);
1394 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1395 s
->forbid_restart
= false;
1397 /* We want fresh tmpdirs in case service is started again immediately */
1398 exec_runtime_destroy(s
->exec_runtime
);
1399 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1401 /* Also, remove the runtime directory in */
1402 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1404 /* Try to delete the pid file. At this point it will be
1405 * out-of-date, and some software might be confused by it, so
1406 * let's remove it. */
1408 unlink_noerrno(s
->pid_file
);
1413 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1414 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1417 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1421 if (f
!= SERVICE_SUCCESS
)
1424 service_unwatch_control_pid(s
);
1425 unit_watch_all_pids(UNIT(s
));
1427 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1428 if (s
->control_command
) {
1429 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1431 r
= service_spawn(s
,
1433 s
->timeout_stop_usec
,
1435 !s
->permissions_start_only
,
1436 !s
->root_directory_start_only
,
1443 service_set_state(s
, SERVICE_STOP_POST
);
1445 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1450 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1451 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1454 static int state_to_kill_operation(ServiceState state
) {
1457 case SERVICE_STOP_SIGABRT
:
1460 case SERVICE_STOP_SIGTERM
:
1461 case SERVICE_FINAL_SIGTERM
:
1462 return KILL_TERMINATE
;
1464 case SERVICE_STOP_SIGKILL
:
1465 case SERVICE_FINAL_SIGKILL
:
1469 return _KILL_OPERATION_INVALID
;
1473 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1478 if (f
!= SERVICE_SUCCESS
)
1481 unit_watch_all_pids(UNIT(s
));
1483 r
= unit_kill_context(
1486 state_to_kill_operation(state
),
1495 if (s
->timeout_stop_usec
> 0) {
1496 r
= service_arm_timer(s
, s
->timeout_stop_usec
);
1501 service_set_state(s
, state
);
1502 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1503 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1504 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1505 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1506 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1507 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1509 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1514 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1516 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1517 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1519 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1522 static void service_enter_stop_by_notify(Service
*s
) {
1525 unit_watch_all_pids(UNIT(s
));
1527 if (s
->timeout_stop_usec
> 0)
1528 service_arm_timer(s
, s
->timeout_stop_usec
);
1530 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1531 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1534 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1539 if (f
!= SERVICE_SUCCESS
)
1542 service_unwatch_control_pid(s
);
1543 unit_watch_all_pids(UNIT(s
));
1545 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1546 if (s
->control_command
) {
1547 s
->control_command_id
= SERVICE_EXEC_STOP
;
1549 r
= service_spawn(s
,
1551 s
->timeout_stop_usec
,
1553 !s
->permissions_start_only
,
1554 !s
->root_directory_start_only
,
1561 service_set_state(s
, SERVICE_STOP
);
1563 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1568 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1569 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1572 static bool service_good(Service
*s
) {
1576 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1579 main_pid_ok
= main_pid_good(s
);
1580 if (main_pid_ok
> 0) /* It's alive */
1582 if (main_pid_ok
== 0) /* It's dead */
1585 /* OK, we don't know anything about the main PID, maybe
1586 * because there is none. Let's check the control group
1589 return cgroup_good(s
) != 0;
1592 static void service_enter_running(Service
*s
, ServiceResult f
) {
1595 if (f
!= SERVICE_SUCCESS
)
1598 if (service_good(s
)) {
1600 /* If there are any queued up sd_notify()
1601 * notifications, process them now */
1602 if (s
->notify_state
== NOTIFY_RELOADING
)
1603 service_enter_reload_by_notify(s
);
1604 else if (s
->notify_state
== NOTIFY_STOPPING
)
1605 service_enter_stop_by_notify(s
);
1607 service_set_state(s
, SERVICE_RUNNING
);
1609 } else if (s
->remain_after_exit
)
1610 service_set_state(s
, SERVICE_EXITED
);
1612 service_enter_stop(s
, SERVICE_SUCCESS
);
1615 static void service_enter_start_post(Service
*s
) {
1619 service_unwatch_control_pid(s
);
1620 service_reset_watchdog(s
);
1622 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1623 if (s
->control_command
) {
1624 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1626 r
= service_spawn(s
,
1628 s
->timeout_start_usec
,
1630 !s
->permissions_start_only
,
1631 !s
->root_directory_start_only
,
1638 service_set_state(s
, SERVICE_START_POST
);
1640 service_enter_running(s
, SERVICE_SUCCESS
);
1645 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1646 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1649 static void service_kill_control_processes(Service
*s
) {
1652 if (!UNIT(s
)->cgroup_path
)
1655 p
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1656 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, p
, SIGKILL
, true, true, true, NULL
);
1659 static void service_enter_start(Service
*s
) {
1666 service_unwatch_control_pid(s
);
1667 service_unwatch_main_pid(s
);
1669 /* We want to ensure that nobody leaks processes from
1670 * START_PRE here, so let's go on a killing spree, People
1671 * should not spawn long running processes from START_PRE. */
1672 service_kill_control_processes(s
);
1674 if (s
->type
== SERVICE_FORKING
) {
1675 s
->control_command_id
= SERVICE_EXEC_START
;
1676 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1678 s
->main_command
= NULL
;
1680 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1681 s
->control_command
= NULL
;
1683 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1687 assert(s
->type
== SERVICE_ONESHOT
);
1688 service_enter_start_post(s
);
1692 r
= service_spawn(s
,
1694 IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_NOTIFY
, SERVICE_ONESHOT
) ? s
->timeout_start_usec
: 0,
1704 if (s
->type
== SERVICE_SIMPLE
|| s
->type
== SERVICE_IDLE
) {
1705 /* For simple services we immediately start
1706 * the START_POST binaries. */
1708 service_set_main_pid(s
, pid
);
1709 service_enter_start_post(s
);
1711 } else if (s
->type
== SERVICE_FORKING
) {
1713 /* For forking services we wait until the start
1714 * process exited. */
1716 s
->control_pid
= pid
;
1717 service_set_state(s
, SERVICE_START
);
1719 } else if (s
->type
== SERVICE_ONESHOT
||
1720 s
->type
== SERVICE_DBUS
||
1721 s
->type
== SERVICE_NOTIFY
) {
1723 /* For oneshot services we wait until the start
1724 * process exited, too, but it is our main process. */
1726 /* For D-Bus services we know the main pid right away,
1727 * but wait for the bus name to appear on the
1728 * bus. Notify services are similar. */
1730 service_set_main_pid(s
, pid
);
1731 service_set_state(s
, SERVICE_START
);
1733 assert_not_reached("Unknown service type");
1738 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1739 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1742 static void service_enter_start_pre(Service
*s
) {
1747 service_unwatch_control_pid(s
);
1749 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1750 if (s
->control_command
) {
1751 /* Before we start anything, let's clear up what might
1752 * be left from previous runs. */
1753 service_kill_control_processes(s
);
1755 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1757 r
= service_spawn(s
,
1759 s
->timeout_start_usec
,
1761 !s
->permissions_start_only
,
1762 !s
->root_directory_start_only
,
1769 service_set_state(s
, SERVICE_START_PRE
);
1771 service_enter_start(s
);
1776 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1777 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1780 static void service_enter_restart(Service
*s
) {
1781 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1786 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1787 /* Don't restart things if we are going down anyway */
1788 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
1790 r
= service_arm_timer(s
, s
->restart_usec
);
1797 /* Any units that are bound to this service must also be
1798 * restarted. We use JOB_RESTART (instead of the more obvious
1799 * JOB_START) here so that those dependency jobs will be added
1801 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, false, &error
, NULL
);
1805 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1806 * it will be canceled as part of the service_stop() call that
1807 * is executed as part of JOB_RESTART. */
1809 log_unit_debug(UNIT(s
), "Scheduled restart job.");
1813 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
1814 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1817 static void service_enter_reload_by_notify(Service
*s
) {
1820 if (s
->timeout_start_usec
> 0)
1821 service_arm_timer(s
, s
->timeout_start_usec
);
1823 service_set_state(s
, SERVICE_RELOAD
);
1826 static void service_enter_reload(Service
*s
) {
1831 service_unwatch_control_pid(s
);
1832 s
->reload_result
= SERVICE_SUCCESS
;
1834 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
1835 if (s
->control_command
) {
1836 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
1838 r
= service_spawn(s
,
1840 s
->timeout_start_usec
,
1842 !s
->permissions_start_only
,
1843 !s
->root_directory_start_only
,
1850 service_set_state(s
, SERVICE_RELOAD
);
1852 service_enter_running(s
, SERVICE_SUCCESS
);
1857 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
1858 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1859 service_enter_running(s
, SERVICE_SUCCESS
);
1862 static void service_run_next_control(Service
*s
) {
1866 assert(s
->control_command
);
1867 assert(s
->control_command
->command_next
);
1869 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
1871 s
->control_command
= s
->control_command
->command_next
;
1872 service_unwatch_control_pid(s
);
1874 r
= service_spawn(s
,
1876 IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
,
1878 !s
->permissions_start_only
,
1879 !s
->root_directory_start_only
,
1880 s
->control_command_id
== SERVICE_EXEC_START_PRE
||
1881 s
->control_command_id
== SERVICE_EXEC_STOP_POST
,
1890 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
1892 if (s
->state
== SERVICE_START_PRE
)
1893 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1894 else if (s
->state
== SERVICE_STOP
)
1895 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1896 else if (s
->state
== SERVICE_STOP_POST
)
1897 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1898 else if (s
->state
== SERVICE_RELOAD
) {
1899 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1900 service_enter_running(s
, SERVICE_SUCCESS
);
1902 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1905 static void service_run_next_main(Service
*s
) {
1910 assert(s
->main_command
);
1911 assert(s
->main_command
->command_next
);
1912 assert(s
->type
== SERVICE_ONESHOT
);
1914 s
->main_command
= s
->main_command
->command_next
;
1915 service_unwatch_main_pid(s
);
1917 r
= service_spawn(s
,
1919 s
->timeout_start_usec
,
1929 service_set_main_pid(s
, pid
);
1934 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
1935 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1938 static int service_start_limit_test(Service
*s
) {
1941 if (ratelimit_test(&s
->start_limit
))
1944 log_unit_warning(UNIT(s
), "Start request repeated too quickly.");
1946 return failure_action(UNIT(s
)->manager
, s
->start_limit_action
, s
->reboot_arg
);
1949 static int service_start(Unit
*u
) {
1950 Service
*s
= SERVICE(u
);
1955 /* We cannot fulfill this request right now, try again later
1957 if (IN_SET(s
->state
,
1958 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1959 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
1962 /* Already on it! */
1963 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
1966 /* A service that will be restarted must be stopped first to
1967 * trigger BindsTo and/or OnFailure dependencies. If a user
1968 * does not want to wait for the holdoff time to elapse, the
1969 * service should be manually restarted, not started. We
1970 * simply return EAGAIN here, so that any start jobs stay
1971 * queued, and assume that the auto restart timer will
1972 * eventually trigger the restart. */
1973 if (s
->state
== SERVICE_AUTO_RESTART
)
1976 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
1978 /* Make sure we don't enter a busy loop of some kind. */
1979 r
= service_start_limit_test(s
);
1981 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT
, false);
1985 s
->result
= SERVICE_SUCCESS
;
1986 s
->reload_result
= SERVICE_SUCCESS
;
1987 s
->main_pid_known
= false;
1988 s
->main_pid_alien
= false;
1989 s
->forbid_restart
= false;
1990 s
->reset_cpu_usage
= true;
1992 s
->status_text
= mfree(s
->status_text
);
1993 s
->status_errno
= 0;
1995 s
->notify_state
= NOTIFY_UNKNOWN
;
1997 service_enter_start_pre(s
);
2001 static int service_stop(Unit
*u
) {
2002 Service
*s
= SERVICE(u
);
2006 /* Don't create restart jobs from manual stops. */
2007 s
->forbid_restart
= true;
2010 if (IN_SET(s
->state
,
2011 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2012 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2015 /* A restart will be scheduled or is in progress. */
2016 if (s
->state
== SERVICE_AUTO_RESTART
) {
2017 service_set_state(s
, SERVICE_DEAD
);
2021 /* If there's already something running we go directly into
2023 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2024 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2028 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2030 service_enter_stop(s
, SERVICE_SUCCESS
);
2034 static int service_reload(Unit
*u
) {
2035 Service
*s
= SERVICE(u
);
2039 assert(s
->state
== SERVICE_RUNNING
|| s
->state
== SERVICE_EXITED
);
2041 service_enter_reload(s
);
2045 _pure_
static bool service_can_reload(Unit
*u
) {
2046 Service
*s
= SERVICE(u
);
2050 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2053 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2054 Service
*s
= SERVICE(u
);
2062 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2063 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2064 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2066 if (s
->control_pid
> 0)
2067 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2069 if (s
->main_pid_known
&& s
->main_pid
> 0)
2070 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2072 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2073 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2075 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2079 /* FIXME: There's a minor uncleanliness here: if there are
2080 * multiple commands attached here, we will start from the
2081 * first one again */
2082 if (s
->control_command_id
>= 0)
2083 unit_serialize_item(u
, f
, "control-command", service_exec_command_to_string(s
->control_command_id
));
2085 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2088 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2091 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2095 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2098 r
= unit_serialize_item_fd(u
, f
, fds
, "endpoint-fd", s
->bus_endpoint_fd
);
2102 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2103 _cleanup_free_
char *c
= NULL
;
2106 copy
= fdset_put_dup(fds
, fs
->fd
);
2110 c
= cescape(fs
->fdname
);
2112 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2115 if (s
->main_exec_status
.pid
> 0) {
2116 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2117 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2118 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2120 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2121 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2122 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2126 if (dual_timestamp_is_set(&s
->watchdog_timestamp
))
2127 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2129 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2134 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2135 Service
*s
= SERVICE(u
);
2143 if (streq(key
, "state")) {
2146 state
= service_state_from_string(value
);
2148 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2150 s
->deserialized_state
= state
;
2151 } else if (streq(key
, "result")) {
2154 f
= service_result_from_string(value
);
2156 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2157 else if (f
!= SERVICE_SUCCESS
)
2160 } else if (streq(key
, "reload-result")) {
2163 f
= service_result_from_string(value
);
2165 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2166 else if (f
!= SERVICE_SUCCESS
)
2167 s
->reload_result
= f
;
2169 } else if (streq(key
, "control-pid")) {
2172 if (parse_pid(value
, &pid
) < 0)
2173 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2175 s
->control_pid
= pid
;
2176 } else if (streq(key
, "main-pid")) {
2179 if (parse_pid(value
, &pid
) < 0)
2180 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2182 service_set_main_pid(s
, pid
);
2183 unit_watch_pid(UNIT(s
), pid
);
2185 } else if (streq(key
, "main-pid-known")) {
2188 b
= parse_boolean(value
);
2190 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2192 s
->main_pid_known
= b
;
2193 } else if (streq(key
, "bus-name-good")) {
2196 b
= parse_boolean(value
);
2198 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2200 s
->bus_name_good
= b
;
2201 } else if (streq(key
, "status-text")) {
2204 r
= cunescape(value
, 0, &t
);
2206 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2208 free(s
->status_text
);
2212 } else if (streq(key
, "control-command")) {
2213 ServiceExecCommand id
;
2215 id
= service_exec_command_from_string(value
);
2217 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2219 s
->control_command_id
= id
;
2220 s
->control_command
= s
->exec_command
[id
];
2222 } else if (streq(key
, "socket-fd")) {
2225 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2226 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2228 asynchronous_close(s
->socket_fd
);
2229 s
->socket_fd
= fdset_remove(fds
, fd
);
2231 } else if (streq(key
, "endpoint-fd")) {
2234 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2235 log_unit_debug(u
, "Failed to parse endpoint-fd value: %s", value
);
2237 safe_close(s
->bus_endpoint_fd
);
2238 s
->bus_endpoint_fd
= fdset_remove(fds
, fd
);
2240 } else if (streq(key
, "fd-store-fd")) {
2245 pf
= strcspn(value
, WHITESPACE
);
2246 fdv
= strndupa(value
, pf
);
2248 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2249 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2251 _cleanup_free_
char *t
= NULL
;
2255 fdn
+= strspn(fdn
, WHITESPACE
);
2256 (void) cunescape(fdn
, 0, &t
);
2258 r
= service_add_fd_store(s
, fd
, t
);
2260 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2262 fdset_remove(fds
, fd
);
2265 } else if (streq(key
, "main-exec-status-pid")) {
2268 if (parse_pid(value
, &pid
) < 0)
2269 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2271 s
->main_exec_status
.pid
= pid
;
2272 } else if (streq(key
, "main-exec-status-code")) {
2275 if (safe_atoi(value
, &i
) < 0)
2276 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2278 s
->main_exec_status
.code
= i
;
2279 } else if (streq(key
, "main-exec-status-status")) {
2282 if (safe_atoi(value
, &i
) < 0)
2283 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2285 s
->main_exec_status
.status
= i
;
2286 } else if (streq(key
, "main-exec-status-start"))
2287 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2288 else if (streq(key
, "main-exec-status-exit"))
2289 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2290 else if (streq(key
, "watchdog-timestamp"))
2291 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2292 else if (streq(key
, "forbid-restart")) {
2295 b
= parse_boolean(value
);
2297 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2299 s
->forbid_restart
= b
;
2300 } else if (streq(key
, "stdin-fd")) {
2303 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2304 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2306 asynchronous_close(s
->stdin_fd
);
2307 s
->stdin_fd
= fdset_remove(fds
, fd
);
2309 } else if (streq(key
, "stdout-fd")) {
2312 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2313 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2315 asynchronous_close(s
->stdout_fd
);
2316 s
->stdout_fd
= fdset_remove(fds
, fd
);
2318 } else if (streq(key
, "stderr-fd")) {
2321 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2322 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2324 asynchronous_close(s
->stderr_fd
);
2325 s
->stderr_fd
= fdset_remove(fds
, fd
);
2328 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2333 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2334 const UnitActiveState
*table
;
2338 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2340 return table
[SERVICE(u
)->state
];
2343 static const char *service_sub_state_to_string(Unit
*u
) {
2346 return service_state_to_string(SERVICE(u
)->state
);
2349 static bool service_check_gc(Unit
*u
) {
2350 Service
*s
= SERVICE(u
);
2354 /* Never clean up services that still have a process around,
2355 * even if the service is formally dead. */
2356 if (cgroup_good(s
) > 0 ||
2357 main_pid_good(s
) > 0 ||
2358 control_pid_good(s
) > 0)
2364 _pure_
static bool service_check_snapshot(Unit
*u
) {
2365 Service
*s
= SERVICE(u
);
2369 return s
->socket_fd
< 0;
2372 static int service_retry_pid_file(Service
*s
) {
2375 assert(s
->pid_file
);
2376 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2378 r
= service_load_pid_file(s
, false);
2382 service_unwatch_pid_file(s
);
2384 service_enter_running(s
, SERVICE_SUCCESS
);
2388 static int service_watch_pid_file(Service
*s
) {
2391 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2393 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2397 /* the pidfile might have appeared just before we set the watch */
2398 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2399 service_retry_pid_file(s
);
2403 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2404 service_unwatch_pid_file(s
);
2408 static int service_demand_pid_file(Service
*s
) {
2411 assert(s
->pid_file
);
2412 assert(!s
->pid_file_pathspec
);
2414 ps
= new0(PathSpec
, 1);
2419 ps
->path
= strdup(s
->pid_file
);
2425 path_kill_slashes(ps
->path
);
2427 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2428 * keep their PID file open all the time. */
2429 ps
->type
= PATH_MODIFIED
;
2430 ps
->inotify_fd
= -1;
2432 s
->pid_file_pathspec
= ps
;
2434 return service_watch_pid_file(s
);
2437 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2438 PathSpec
*p
= userdata
;
2443 s
= SERVICE(p
->unit
);
2447 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2448 assert(s
->pid_file_pathspec
);
2449 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2451 log_unit_debug(UNIT(s
), "inotify event");
2453 if (path_spec_fd_event(p
, events
) < 0)
2456 if (service_retry_pid_file(s
) == 0)
2459 if (service_watch_pid_file(s
) < 0)
2465 service_unwatch_pid_file(s
);
2466 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2470 static void service_notify_cgroup_empty_event(Unit
*u
) {
2471 Service
*s
= SERVICE(u
);
2475 log_unit_debug(u
, "cgroup is empty");
2479 /* Waiting for SIGCHLD is usually more interesting,
2480 * because it includes return codes/signals. Which is
2481 * why we ignore the cgroup events for most cases,
2482 * except when we don't know pid which to expect the
2486 case SERVICE_START_POST
:
2487 /* If we were hoping for the daemon to write its PID file,
2488 * we can give up now. */
2489 if (s
->pid_file_pathspec
) {
2490 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2492 service_unwatch_pid_file(s
);
2493 if (s
->state
== SERVICE_START
)
2494 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2496 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2500 case SERVICE_RUNNING
:
2501 /* service_enter_running() will figure out what to do */
2502 service_enter_running(s
, SERVICE_SUCCESS
);
2505 case SERVICE_STOP_SIGABRT
:
2506 case SERVICE_STOP_SIGTERM
:
2507 case SERVICE_STOP_SIGKILL
:
2509 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2510 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2514 case SERVICE_STOP_POST
:
2515 case SERVICE_FINAL_SIGTERM
:
2516 case SERVICE_FINAL_SIGKILL
:
2517 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2518 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2527 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2528 Service
*s
= SERVICE(u
);
2534 if (UNIT(s
)->fragment_path
? is_clean_exit(code
, status
, &s
->success_status
) :
2535 is_clean_exit_lsb(code
, status
, &s
->success_status
))
2536 f
= SERVICE_SUCCESS
;
2537 else if (code
== CLD_EXITED
)
2538 f
= SERVICE_FAILURE_EXIT_CODE
;
2539 else if (code
== CLD_KILLED
)
2540 f
= SERVICE_FAILURE_SIGNAL
;
2541 else if (code
== CLD_DUMPED
)
2542 f
= SERVICE_FAILURE_CORE_DUMP
;
2544 assert_not_reached("Unknown code");
2546 if (s
->main_pid
== pid
) {
2547 /* Forking services may occasionally move to a new PID.
2548 * As long as they update the PID file before exiting the old
2549 * PID, they're fine. */
2550 if (service_load_pid_file(s
, false) == 0)
2554 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2556 if (s
->main_command
) {
2557 /* If this is not a forking service than the
2558 * main process got started and hence we copy
2559 * the exit status so that it is recorded both
2560 * as main and as control process exit
2563 s
->main_command
->exec_status
= s
->main_exec_status
;
2565 if (s
->main_command
->ignore
)
2566 f
= SERVICE_SUCCESS
;
2567 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
2569 /* If this is a forked process, then we should
2570 * ignore the return value if this was
2571 * configured for the starter process */
2573 if (s
->exec_command
[SERVICE_EXEC_START
]->ignore
)
2574 f
= SERVICE_SUCCESS
;
2577 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
,
2579 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
2580 sigchld_code_to_string(code
), status
,
2581 strna(code
== CLD_EXITED
2582 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
2583 : signal_to_string(status
))),
2584 "EXIT_CODE=%s", sigchld_code_to_string(code
),
2585 "EXIT_STATUS=%i", status
,
2588 if (f
!= SERVICE_SUCCESS
)
2591 if (s
->main_command
&&
2592 s
->main_command
->command_next
&&
2593 f
== SERVICE_SUCCESS
) {
2595 /* There is another command to *
2596 * execute, so let's do that. */
2598 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
2599 service_run_next_main(s
);
2603 /* The service exited, so the service is officially
2605 s
->main_command
= NULL
;
2609 case SERVICE_START_POST
:
2610 case SERVICE_RELOAD
:
2612 /* Need to wait until the operation is
2617 if (s
->type
== SERVICE_ONESHOT
) {
2618 /* This was our main goal, so let's go on */
2619 if (f
== SERVICE_SUCCESS
)
2620 service_enter_start_post(s
);
2622 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2628 case SERVICE_RUNNING
:
2629 service_enter_running(s
, f
);
2632 case SERVICE_STOP_SIGABRT
:
2633 case SERVICE_STOP_SIGTERM
:
2634 case SERVICE_STOP_SIGKILL
:
2636 if (!control_pid_good(s
))
2637 service_enter_stop_post(s
, f
);
2639 /* If there is still a control process, wait for that first */
2642 case SERVICE_STOP_POST
:
2643 case SERVICE_FINAL_SIGTERM
:
2644 case SERVICE_FINAL_SIGKILL
:
2646 if (!control_pid_good(s
))
2647 service_enter_dead(s
, f
, true);
2651 assert_not_reached("Uh, main process died at wrong time.");
2655 } else if (s
->control_pid
== pid
) {
2658 if (s
->control_command
) {
2659 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2661 if (s
->control_command
->ignore
)
2662 f
= SERVICE_SUCCESS
;
2665 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2666 "Control process exited, code=%s status=%i",
2667 sigchld_code_to_string(code
), status
);
2669 if (f
!= SERVICE_SUCCESS
)
2672 /* Immediately get rid of the cgroup, so that the
2673 * kernel doesn't delay the cgroup empty messages for
2674 * the service cgroup any longer than necessary */
2675 service_kill_control_processes(s
);
2677 if (s
->control_command
&&
2678 s
->control_command
->command_next
&&
2679 f
== SERVICE_SUCCESS
) {
2681 /* There is another command to *
2682 * execute, so let's do that. */
2684 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
2685 service_run_next_control(s
);
2688 /* No further commands for this step, so let's
2689 * figure out what to do next */
2691 s
->control_command
= NULL
;
2692 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
2694 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
2698 case SERVICE_START_PRE
:
2699 if (f
== SERVICE_SUCCESS
)
2700 service_enter_start(s
);
2702 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2706 if (s
->type
!= SERVICE_FORKING
)
2707 /* Maybe spurious event due to a reload that changed the type? */
2710 if (f
!= SERVICE_SUCCESS
) {
2711 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2716 bool has_start_post
;
2719 /* Let's try to load the pid file here if we can.
2720 * The PID file might actually be created by a START_POST
2721 * script. In that case don't worry if the loading fails. */
2723 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
2724 r
= service_load_pid_file(s
, !has_start_post
);
2725 if (!has_start_post
&& r
< 0) {
2726 r
= service_demand_pid_file(s
);
2727 if (r
< 0 || !cgroup_good(s
))
2728 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2732 (void) service_search_main_pid(s
);
2734 service_enter_start_post(s
);
2737 case SERVICE_START_POST
:
2738 if (f
!= SERVICE_SUCCESS
) {
2739 service_enter_stop(s
, f
);
2746 r
= service_load_pid_file(s
, true);
2748 r
= service_demand_pid_file(s
);
2749 if (r
< 0 || !cgroup_good(s
))
2750 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2754 (void) service_search_main_pid(s
);
2756 service_enter_running(s
, SERVICE_SUCCESS
);
2759 case SERVICE_RELOAD
:
2760 if (f
== SERVICE_SUCCESS
) {
2761 service_load_pid_file(s
, true);
2762 (void) service_search_main_pid(s
);
2765 s
->reload_result
= f
;
2766 service_enter_running(s
, SERVICE_SUCCESS
);
2770 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
2773 case SERVICE_STOP_SIGABRT
:
2774 case SERVICE_STOP_SIGTERM
:
2775 case SERVICE_STOP_SIGKILL
:
2776 if (main_pid_good(s
) <= 0)
2777 service_enter_stop_post(s
, f
);
2779 /* If there is still a service
2780 * process around, wait until
2781 * that one quit, too */
2784 case SERVICE_STOP_POST
:
2785 case SERVICE_FINAL_SIGTERM
:
2786 case SERVICE_FINAL_SIGKILL
:
2787 if (main_pid_good(s
) <= 0)
2788 service_enter_dead(s
, f
, true);
2792 assert_not_reached("Uh, control process died at wrong time.");
2797 /* Notify clients about changed exit status */
2798 unit_add_to_dbus_queue(u
);
2800 /* We got one SIGCHLD for the service, let's watch all
2801 * processes that are now running of the service, and watch
2802 * that. Among the PIDs we then watch will be children
2803 * reassigned to us, which hopefully allows us to identify
2804 * when all children are gone */
2805 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
2806 unit_watch_all_pids(u
);
2808 /* If the PID set is empty now, then let's finish this off */
2809 if (set_isempty(u
->pids
))
2810 service_notify_cgroup_empty_event(u
);
2813 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2814 Service
*s
= SERVICE(userdata
);
2817 assert(source
== s
->timer_event_source
);
2821 case SERVICE_START_PRE
:
2823 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
2824 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2827 case SERVICE_START_POST
:
2828 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
2829 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
2832 case SERVICE_RELOAD
:
2833 log_unit_warning(UNIT(s
), "Reload operation timed out. Stopping.");
2834 service_unwatch_control_pid(s
);
2835 service_kill_control_processes(s
);
2836 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
2837 service_enter_running(s
, SERVICE_SUCCESS
);
2841 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2842 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2845 case SERVICE_STOP_SIGABRT
:
2846 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
2847 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2850 case SERVICE_STOP_SIGTERM
:
2851 if (s
->kill_context
.send_sigkill
) {
2852 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
2853 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2855 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
2856 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2861 case SERVICE_STOP_SIGKILL
:
2862 /* Uh, we sent a SIGKILL and it is still not gone?
2863 * Must be something we cannot kill, so let's just be
2864 * weirded out and continue */
2866 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2867 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2870 case SERVICE_STOP_POST
:
2871 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
2872 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2875 case SERVICE_FINAL_SIGTERM
:
2876 if (s
->kill_context
.send_sigkill
) {
2877 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
2878 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2880 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
2881 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
2886 case SERVICE_FINAL_SIGKILL
:
2887 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
2888 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
2891 case SERVICE_AUTO_RESTART
:
2892 log_unit_info(UNIT(s
),
2893 s
->restart_usec
> 0 ?
2894 "Service hold-off time over, scheduling restart." :
2895 "Service has no hold-off time, scheduling restart.");
2896 service_enter_restart(s
);
2900 assert_not_reached("Timeout at wrong time.");
2906 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2907 Service
*s
= SERVICE(userdata
);
2908 char t
[FORMAT_TIMESPAN_MAX
];
2911 assert(source
== s
->watchdog_event_source
);
2913 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
2914 format_timespan(t
, sizeof(t
), s
->watchdog_usec
, 1));
2916 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
2921 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
2922 Service
*s
= SERVICE(u
);
2923 _cleanup_free_
char *cc
= NULL
;
2924 bool notify_dbus
= false;
2929 cc
= strv_join(tags
, ", ");
2931 if (s
->notify_access
== NOTIFY_NONE
) {
2932 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
2934 } else if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
2935 if (s
->main_pid
!= 0)
2936 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
2938 log_unit_debug(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID which is currently not known", pid
);
2941 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
2943 /* Interpret MAINPID= */
2944 e
= strv_find_startswith(tags
, "MAINPID=");
2945 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
2946 if (parse_pid(e
, &pid
) < 0)
2947 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
2949 service_set_main_pid(s
, pid
);
2950 unit_watch_pid(UNIT(s
), pid
);
2955 /* Interpret RELOADING= */
2956 if (strv_find(tags
, "RELOADING=1")) {
2958 s
->notify_state
= NOTIFY_RELOADING
;
2960 if (s
->state
== SERVICE_RUNNING
)
2961 service_enter_reload_by_notify(s
);
2966 /* Interpret READY= */
2967 if (strv_find(tags
, "READY=1")) {
2969 s
->notify_state
= NOTIFY_READY
;
2971 /* Type=notify services inform us about completed
2972 * initialization with READY=1 */
2973 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
2974 service_enter_start_post(s
);
2976 /* Sending READY=1 while we are reloading informs us
2977 * that the reloading is complete */
2978 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
2979 service_enter_running(s
, SERVICE_SUCCESS
);
2984 /* Interpret STOPPING= */
2985 if (strv_find(tags
, "STOPPING=1")) {
2987 s
->notify_state
= NOTIFY_STOPPING
;
2989 if (s
->state
== SERVICE_RUNNING
)
2990 service_enter_stop_by_notify(s
);
2995 /* Interpret STATUS= */
2996 e
= strv_find_startswith(tags
, "STATUS=");
2998 _cleanup_free_
char *t
= NULL
;
3001 if (!utf8_is_valid(e
))
3002 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3010 if (!streq_ptr(s
->status_text
, t
)) {
3012 free(s
->status_text
);
3020 /* Interpret ERRNO= */
3021 e
= strv_find_startswith(tags
, "ERRNO=");
3025 if (safe_atoi(e
, &status_errno
) < 0 || status_errno
< 0)
3026 log_unit_warning(u
, "Failed to parse ERRNO= field in notification message: %s", e
);
3028 if (s
->status_errno
!= status_errno
) {
3029 s
->status_errno
= status_errno
;
3035 /* Interpret WATCHDOG= */
3036 if (strv_find(tags
, "WATCHDOG=1"))
3037 service_reset_watchdog(s
);
3039 if (strv_find(tags
, "FDSTORE=1")) {
3042 name
= strv_find_startswith(tags
, "FDNAME=");
3043 if (name
&& !fdname_is_valid(name
)) {
3044 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3048 service_add_fd_store_set(s
, fds
, name
);
3051 /* Notify clients about changed status or main pid */
3053 unit_add_to_dbus_queue(u
);
3056 static int service_get_timeout(Unit
*u
, uint64_t *timeout
) {
3057 Service
*s
= SERVICE(u
);
3060 if (!s
->timer_event_source
)
3063 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
3070 static void service_bus_name_owner_change(
3073 const char *old_owner
,
3074 const char *new_owner
) {
3076 Service
*s
= SERVICE(u
);
3082 assert(streq(s
->bus_name
, name
));
3083 assert(old_owner
|| new_owner
);
3085 if (old_owner
&& new_owner
)
3086 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3088 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3090 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3092 s
->bus_name_good
= !!new_owner
;
3094 if (s
->type
== SERVICE_DBUS
) {
3096 /* service_enter_running() will figure out what to
3098 if (s
->state
== SERVICE_RUNNING
)
3099 service_enter_running(s
, SERVICE_SUCCESS
);
3100 else if (s
->state
== SERVICE_START
&& new_owner
)
3101 service_enter_start_post(s
);
3103 } else if (new_owner
&&
3105 (s
->state
== SERVICE_START
||
3106 s
->state
== SERVICE_START_POST
||
3107 s
->state
== SERVICE_RUNNING
||
3108 s
->state
== SERVICE_RELOAD
)) {
3110 _cleanup_bus_creds_unref_ sd_bus_creds
*creds
= NULL
;
3113 /* Try to acquire PID from bus service */
3115 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3117 r
= sd_bus_creds_get_pid(creds
, &pid
);
3119 log_unit_debug(u
, "D-Bus name %s is now owned by process %u", name
, (unsigned) pid
);
3121 service_set_main_pid(s
, pid
);
3122 unit_watch_pid(UNIT(s
), pid
);
3127 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3128 _cleanup_free_
char *peer
= NULL
;
3134 /* This is called by the socket code when instantiating a new
3135 * service for a stream socket and the socket needs to be
3138 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3141 if (s
->socket_fd
>= 0)
3144 if (s
->state
!= SERVICE_DEAD
)
3147 if (getpeername_pretty(fd
, &peer
) >= 0) {
3149 if (UNIT(s
)->description
) {
3150 _cleanup_free_
char *a
;
3152 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")", NULL
);
3156 r
= unit_set_description(UNIT(s
), a
);
3158 r
= unit_set_description(UNIT(s
), peer
);
3165 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3167 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3169 return unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false);
3172 static void service_reset_failed(Unit
*u
) {
3173 Service
*s
= SERVICE(u
);
3177 if (s
->state
== SERVICE_FAILED
)
3178 service_set_state(s
, SERVICE_DEAD
);
3180 s
->result
= SERVICE_SUCCESS
;
3181 s
->reload_result
= SERVICE_SUCCESS
;
3183 RATELIMIT_RESET(s
->start_limit
);
3186 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3187 Service
*s
= SERVICE(u
);
3189 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3192 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3193 [SERVICE_RESTART_NO
] = "no",
3194 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3195 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3196 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3197 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3198 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3199 [SERVICE_RESTART_ALWAYS
] = "always",
3202 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3204 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3205 [SERVICE_SIMPLE
] = "simple",
3206 [SERVICE_FORKING
] = "forking",
3207 [SERVICE_ONESHOT
] = "oneshot",
3208 [SERVICE_DBUS
] = "dbus",
3209 [SERVICE_NOTIFY
] = "notify",
3210 [SERVICE_IDLE
] = "idle"
3213 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3215 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3216 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3217 [SERVICE_EXEC_START
] = "ExecStart",
3218 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3219 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3220 [SERVICE_EXEC_STOP
] = "ExecStop",
3221 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3224 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3226 static const char* const notify_access_table
[_NOTIFY_ACCESS_MAX
] = {
3227 [NOTIFY_NONE
] = "none",
3228 [NOTIFY_MAIN
] = "main",
3229 [NOTIFY_ALL
] = "all"
3232 DEFINE_STRING_TABLE_LOOKUP(notify_access
, NotifyAccess
);
3234 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3235 [NOTIFY_UNKNOWN
] = "unknown",
3236 [NOTIFY_READY
] = "ready",
3237 [NOTIFY_RELOADING
] = "reloading",
3238 [NOTIFY_STOPPING
] = "stopping",
3241 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3243 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3244 [SERVICE_SUCCESS
] = "success",
3245 [SERVICE_FAILURE_RESOURCES
] = "resources",
3246 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3247 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3248 [SERVICE_FAILURE_SIGNAL
] = "signal",
3249 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3250 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3251 [SERVICE_FAILURE_START_LIMIT
] = "start-limit"
3254 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3256 const UnitVTable service_vtable
= {
3257 .object_size
= sizeof(Service
),
3258 .exec_context_offset
= offsetof(Service
, exec_context
),
3259 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3260 .kill_context_offset
= offsetof(Service
, kill_context
),
3261 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3267 .private_section
= "Service",
3269 .init
= service_init
,
3270 .done
= service_done
,
3271 .load
= service_load
,
3272 .release_resources
= service_release_resources
,
3274 .coldplug
= service_coldplug
,
3276 .dump
= service_dump
,
3278 .start
= service_start
,
3279 .stop
= service_stop
,
3280 .reload
= service_reload
,
3282 .can_reload
= service_can_reload
,
3284 .kill
= service_kill
,
3286 .serialize
= service_serialize
,
3287 .deserialize_item
= service_deserialize_item
,
3289 .active_state
= service_active_state
,
3290 .sub_state_to_string
= service_sub_state_to_string
,
3292 .check_gc
= service_check_gc
,
3293 .check_snapshot
= service_check_snapshot
,
3295 .sigchld_event
= service_sigchld_event
,
3297 .reset_failed
= service_reset_failed
,
3299 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3300 .notify_message
= service_notify_message
,
3302 .bus_name_owner_change
= service_bus_name_owner_change
,
3304 .bus_vtable
= bus_service_vtable
,
3305 .bus_set_property
= bus_service_set_property
,
3306 .bus_commit_properties
= bus_service_commit_properties
,
3308 .get_timeout
= service_get_timeout
,
3309 .can_transient
= true,
3311 .status_message_formats
= {
3312 .starting_stopping
= {
3313 [0] = "Starting %s...",
3314 [1] = "Stopping %s...",
3316 .finished_start_job
= {
3317 [JOB_DONE
] = "Started %s.",
3318 [JOB_FAILED
] = "Failed to start %s.",
3320 .finished_stop_job
= {
3321 [JOB_DONE
] = "Stopped %s.",
3322 [JOB_FAILED
] = "Stopped (with error) %s.",