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/>.
26 #include "alloc-util.h"
28 #include "bus-error.h"
29 #include "bus-kernel.h"
31 #include "dbus-service.h"
35 #include "exit-status.h"
38 #include "formats-util.h"
40 #include "load-dropin.h"
41 #include "load-fragment.h"
44 #include "parse-util.h"
45 #include "path-util.h"
46 #include "process-util.h"
48 #include "signal-util.h"
50 #include "string-table.h"
51 #include "string-util.h"
53 #include "unit-name.h"
54 #include "unit-printf.h"
59 static const UnitActiveState state_translation_table
[_SERVICE_STATE_MAX
] = {
60 [SERVICE_DEAD
] = UNIT_INACTIVE
,
61 [SERVICE_START_PRE
] = UNIT_ACTIVATING
,
62 [SERVICE_START
] = UNIT_ACTIVATING
,
63 [SERVICE_START_POST
] = UNIT_ACTIVATING
,
64 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
65 [SERVICE_EXITED
] = UNIT_ACTIVE
,
66 [SERVICE_RELOAD
] = UNIT_RELOADING
,
67 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
68 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
69 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
70 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
71 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
72 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
73 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
74 [SERVICE_FAILED
] = UNIT_FAILED
,
75 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
78 /* For Type=idle we never want to delay any other jobs, hence we
79 * consider idle jobs active as soon as we start working on them */
80 static const UnitActiveState state_translation_table_idle
[_SERVICE_STATE_MAX
] = {
81 [SERVICE_DEAD
] = UNIT_INACTIVE
,
82 [SERVICE_START_PRE
] = UNIT_ACTIVE
,
83 [SERVICE_START
] = UNIT_ACTIVE
,
84 [SERVICE_START_POST
] = UNIT_ACTIVE
,
85 [SERVICE_RUNNING
] = UNIT_ACTIVE
,
86 [SERVICE_EXITED
] = UNIT_ACTIVE
,
87 [SERVICE_RELOAD
] = UNIT_RELOADING
,
88 [SERVICE_STOP
] = UNIT_DEACTIVATING
,
89 [SERVICE_STOP_SIGABRT
] = UNIT_DEACTIVATING
,
90 [SERVICE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
91 [SERVICE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
92 [SERVICE_STOP_POST
] = UNIT_DEACTIVATING
,
93 [SERVICE_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
94 [SERVICE_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
95 [SERVICE_FAILED
] = UNIT_FAILED
,
96 [SERVICE_AUTO_RESTART
] = UNIT_ACTIVATING
99 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
);
100 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
101 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
);
103 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
);
104 static void service_enter_reload_by_notify(Service
*s
);
106 static void service_init(Unit
*u
) {
107 Service
*s
= SERVICE(u
);
110 assert(u
->load_state
== UNIT_STUB
);
112 s
->timeout_start_usec
= u
->manager
->default_timeout_start_usec
;
113 s
->timeout_stop_usec
= u
->manager
->default_timeout_stop_usec
;
114 s
->restart_usec
= u
->manager
->default_restart_usec
;
115 s
->type
= _SERVICE_TYPE_INVALID
;
117 s
->bus_endpoint_fd
= -1;
118 s
->stdin_fd
= s
->stdout_fd
= s
->stderr_fd
= -1;
119 s
->guess_main_pid
= true;
121 RATELIMIT_INIT(s
->start_limit
, u
->manager
->default_start_limit_interval
, u
->manager
->default_start_limit_burst
);
123 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
126 static void service_unwatch_control_pid(Service
*s
) {
129 if (s
->control_pid
<= 0)
132 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
136 static void service_unwatch_main_pid(Service
*s
) {
139 if (s
->main_pid
<= 0)
142 unit_unwatch_pid(UNIT(s
), s
->main_pid
);
146 static void service_unwatch_pid_file(Service
*s
) {
147 if (!s
->pid_file_pathspec
)
150 log_unit_debug(UNIT(s
), "Stopping watch for PID file %s", s
->pid_file_pathspec
->path
);
151 path_spec_unwatch(s
->pid_file_pathspec
);
152 path_spec_done(s
->pid_file_pathspec
);
153 s
->pid_file_pathspec
= mfree(s
->pid_file_pathspec
);
156 static int service_set_main_pid(Service
*s
, pid_t pid
) {
167 if (s
->main_pid
== pid
&& s
->main_pid_known
)
170 if (s
->main_pid
!= pid
) {
171 service_unwatch_main_pid(s
);
172 exec_status_start(&s
->main_exec_status
, pid
);
176 s
->main_pid_known
= true;
178 if (get_process_ppid(pid
, &ppid
) >= 0 && ppid
!= getpid()) {
179 log_unit_warning(UNIT(s
), "Supervising process "PID_FMT
" which is not our child. We'll most likely not notice when it exits.", pid
);
180 s
->main_pid_alien
= true;
182 s
->main_pid_alien
= false;
187 static void service_close_socket_fd(Service
*s
) {
190 s
->socket_fd
= asynchronous_close(s
->socket_fd
);
193 static void service_connection_unref(Service
*s
) {
196 if (!UNIT_ISSET(s
->accept_socket
))
199 socket_connection_unref(SOCKET(UNIT_DEREF(s
->accept_socket
)));
200 unit_ref_unset(&s
->accept_socket
);
203 static void service_stop_watchdog(Service
*s
) {
206 s
->watchdog_event_source
= sd_event_source_unref(s
->watchdog_event_source
);
207 s
->watchdog_timestamp
= DUAL_TIMESTAMP_NULL
;
210 static void service_start_watchdog(Service
*s
) {
215 if (s
->watchdog_usec
<= 0)
218 if (s
->watchdog_event_source
) {
219 r
= sd_event_source_set_time(s
->watchdog_event_source
, s
->watchdog_timestamp
.monotonic
+ s
->watchdog_usec
);
221 log_unit_warning_errno(UNIT(s
), r
, "Failed to reset watchdog timer: %m");
225 r
= sd_event_source_set_enabled(s
->watchdog_event_source
, SD_EVENT_ONESHOT
);
227 r
= sd_event_add_time(
228 UNIT(s
)->manager
->event
,
229 &s
->watchdog_event_source
,
231 s
->watchdog_timestamp
.monotonic
+ s
->watchdog_usec
, 0,
232 service_dispatch_watchdog
, s
);
234 log_unit_warning_errno(UNIT(s
), r
, "Failed to add watchdog timer: %m");
238 (void) sd_event_source_set_description(s
->watchdog_event_source
, "service-watchdog");
240 /* Let's process everything else which might be a sign
241 * of living before we consider a service died. */
242 r
= sd_event_source_set_priority(s
->watchdog_event_source
, SD_EVENT_PRIORITY_IDLE
);
246 log_unit_warning_errno(UNIT(s
), r
, "Failed to install watchdog timer: %m");
249 static void service_reset_watchdog(Service
*s
) {
252 dual_timestamp_get(&s
->watchdog_timestamp
);
253 service_start_watchdog(s
);
256 static void service_fd_store_unlink(ServiceFDStore
*fs
) {
262 assert(fs
->service
->n_fd_store
> 0);
263 LIST_REMOVE(fd_store
, fs
->service
->fd_store
, fs
);
264 fs
->service
->n_fd_store
--;
267 if (fs
->event_source
) {
268 sd_event_source_set_enabled(fs
->event_source
, SD_EVENT_OFF
);
269 sd_event_source_unref(fs
->event_source
);
277 static void service_release_resources(Unit
*u
) {
278 Service
*s
= SERVICE(u
);
282 if (!s
->fd_store
&& s
->stdin_fd
< 0 && s
->stdout_fd
< 0 && s
->stderr_fd
< 0)
285 log_unit_debug(u
, "Releasing all resources.");
287 s
->stdin_fd
= safe_close(s
->stdin_fd
);
288 s
->stdout_fd
= safe_close(s
->stdout_fd
);
289 s
->stderr_fd
= safe_close(s
->stderr_fd
);
292 service_fd_store_unlink(s
->fd_store
);
294 assert(s
->n_fd_store
== 0);
297 static void service_done(Unit
*u
) {
298 Service
*s
= SERVICE(u
);
302 s
->pid_file
= mfree(s
->pid_file
);
303 s
->status_text
= mfree(s
->status_text
);
304 s
->reboot_arg
= mfree(s
->reboot_arg
);
306 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
307 exec_command_free_array(s
->exec_command
, _SERVICE_EXEC_COMMAND_MAX
);
308 s
->control_command
= NULL
;
309 s
->main_command
= NULL
;
311 exit_status_set_free(&s
->restart_prevent_status
);
312 exit_status_set_free(&s
->restart_force_status
);
313 exit_status_set_free(&s
->success_status
);
315 /* This will leak a process, but at least no memory or any of
317 service_unwatch_main_pid(s
);
318 service_unwatch_control_pid(s
);
319 service_unwatch_pid_file(s
);
322 unit_unwatch_bus_name(u
, s
->bus_name
);
323 s
->bus_name
= mfree(s
->bus_name
);
326 s
->bus_endpoint_fd
= safe_close(s
->bus_endpoint_fd
);
327 service_close_socket_fd(s
);
328 service_connection_unref(s
);
330 unit_ref_unset(&s
->accept_socket
);
332 service_stop_watchdog(s
);
334 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
336 service_release_resources(u
);
339 static int on_fd_store_io(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
340 ServiceFDStore
*fs
= userdata
;
345 /* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
346 service_fd_store_unlink(fs
);
350 static int service_add_fd_store(Service
*s
, int fd
, const char *name
) {
357 if (s
->n_fd_store
>= s
->n_fd_store_max
)
360 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
361 r
= same_fd(fs
->fd
, fd
);
365 /* Already included */
371 fs
= new0(ServiceFDStore
, 1);
377 fs
->fdname
= strdup(name
?: "stored");
383 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &fs
->event_source
, fd
, 0, on_fd_store_io
, fs
);
390 (void) sd_event_source_set_description(fs
->event_source
, "service-fd-store");
392 LIST_PREPEND(fd_store
, s
->fd_store
, fs
);
398 static int service_add_fd_store_set(Service
*s
, FDSet
*fds
, const char *name
) {
403 if (fdset_size(fds
) <= 0)
406 while (s
->n_fd_store
< s
->n_fd_store_max
) {
407 _cleanup_close_
int fd
= -1;
409 fd
= fdset_steal_first(fds
);
413 r
= service_add_fd_store(s
, fd
, name
);
415 return log_unit_error_errno(UNIT(s
), r
, "Couldn't add fd to fd store: %m");
417 log_unit_debug(UNIT(s
), "Added fd to fd store.");
422 if (fdset_size(fds
) > 0)
423 log_unit_warning(UNIT(s
), "Tried to store more fds than FileDescriptorStoreMax=%u allows, closing remaining.", s
->n_fd_store_max
);
428 static int service_arm_timer(Service
*s
, usec_t usec
) {
433 if (s
->timer_event_source
) {
434 r
= sd_event_source_set_time(s
->timer_event_source
, now(CLOCK_MONOTONIC
) + usec
);
438 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
441 r
= sd_event_add_time(
442 UNIT(s
)->manager
->event
,
443 &s
->timer_event_source
,
445 now(CLOCK_MONOTONIC
) + usec
, 0,
446 service_dispatch_timer
, s
);
450 (void) sd_event_source_set_description(s
->timer_event_source
, "service-timer");
455 static int service_verify(Service
*s
) {
458 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
461 if (!s
->exec_command
[SERVICE_EXEC_START
] && !s
->exec_command
[SERVICE_EXEC_STOP
]) {
462 log_unit_error(UNIT(s
), "Service lacks both ExecStart= and ExecStop= setting. Refusing.");
466 if (s
->type
!= SERVICE_ONESHOT
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
467 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
471 if (!s
->remain_after_exit
&& !s
->exec_command
[SERVICE_EXEC_START
]) {
472 log_unit_error(UNIT(s
), "Service has no ExecStart= setting, which is only allowed for RemainAfterExit=yes services. Refusing.");
476 if (s
->type
!= SERVICE_ONESHOT
&& s
->exec_command
[SERVICE_EXEC_START
]->command_next
) {
477 log_unit_error(UNIT(s
), "Service has more than one ExecStart= setting, which is only allowed for Type=oneshot services. Refusing.");
481 if (s
->type
== SERVICE_ONESHOT
&& s
->restart
!= SERVICE_RESTART_NO
) {
482 log_unit_error(UNIT(s
), "Service has Restart= setting other than no, which isn't allowed for Type=oneshot services. Refusing.");
486 if (s
->type
== SERVICE_ONESHOT
&& !exit_status_set_is_empty(&s
->restart_force_status
)) {
487 log_unit_error(UNIT(s
), "Service has RestartForceStatus= set, which isn't allowed for Type=oneshot services. Refusing.");
491 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name
) {
492 log_unit_error(UNIT(s
), "Service is of type D-Bus but no D-Bus service name has been specified. Refusing.");
496 if (s
->bus_name
&& s
->type
!= SERVICE_DBUS
)
497 log_unit_warning(UNIT(s
), "Service has a D-Bus service name specified, but is not of type dbus. Ignoring.");
499 if (s
->exec_context
.pam_name
&& !(s
->kill_context
.kill_mode
== KILL_CONTROL_GROUP
|| s
->kill_context
.kill_mode
== KILL_MIXED
)) {
500 log_unit_error(UNIT(s
), "Service has PAM enabled. Kill mode must be set to 'control-group' or 'mixed'. Refusing.");
504 if (s
->usb_function_descriptors
&& !s
->usb_function_strings
)
505 log_unit_warning(UNIT(s
), "Service has USBFunctionDescriptors= setting, but no USBFunctionStrings=. Ignoring.");
507 if (!s
->usb_function_descriptors
&& s
->usb_function_strings
)
508 log_unit_warning(UNIT(s
), "Service has USBFunctionStrings= setting, but no USBFunctionDescriptors=. Ignoring.");
513 static int service_add_default_dependencies(Service
*s
) {
518 /* Add a number of automatic dependencies useful for the
519 * majority of services. */
521 /* First, pull in base system */
522 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_BASIC_TARGET
, NULL
, true);
526 /* Second, activate normal shutdown */
527 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
530 static void service_fix_output(Service
*s
) {
533 /* If nothing has been explicitly configured, patch default
534 * output in. If input is socket/tty we avoid this however,
535 * since in that case we want output to default to the same
536 * place as we read input from. */
538 if (s
->exec_context
.std_error
== EXEC_OUTPUT_INHERIT
&&
539 s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
540 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
541 s
->exec_context
.std_error
= UNIT(s
)->manager
->default_std_error
;
543 if (s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
544 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
545 s
->exec_context
.std_output
= UNIT(s
)->manager
->default_std_output
;
548 static int service_add_extras(Service
*s
) {
553 if (s
->type
== _SERVICE_TYPE_INVALID
) {
554 /* Figure out a type automatically */
556 s
->type
= SERVICE_DBUS
;
557 else if (s
->exec_command
[SERVICE_EXEC_START
])
558 s
->type
= SERVICE_SIMPLE
;
560 s
->type
= SERVICE_ONESHOT
;
563 /* Oneshot services have disabled start timeout by default */
564 if (s
->type
== SERVICE_ONESHOT
&& !s
->start_timeout_defined
)
565 s
->timeout_start_usec
= 0;
567 service_fix_output(s
);
569 r
= unit_patch_contexts(UNIT(s
));
573 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
577 r
= unit_set_default_slice(UNIT(s
));
581 if (s
->type
== SERVICE_NOTIFY
&& s
->notify_access
== NOTIFY_NONE
)
582 s
->notify_access
= NOTIFY_MAIN
;
584 if (s
->watchdog_usec
> 0 && s
->notify_access
== NOTIFY_NONE
)
585 s
->notify_access
= NOTIFY_MAIN
;
590 n
= strjoina(s
->bus_name
, ".busname");
591 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, n
, NULL
, true);
595 r
= unit_watch_bus_name(UNIT(s
), s
->bus_name
);
597 return log_unit_error_errno(UNIT(s
), r
, "Two services allocated for the same bus name %s, refusing operation.", s
->bus_name
);
599 return log_unit_error_errno(UNIT(s
), r
, "Cannot watch bus name %s: %m", s
->bus_name
);
602 if (UNIT(s
)->default_dependencies
) {
603 r
= service_add_default_dependencies(s
);
611 static int service_load(Unit
*u
) {
612 Service
*s
= SERVICE(u
);
617 /* Load a .service file */
618 r
= unit_load_fragment(u
);
622 /* Still nothing found? Then let's give up */
623 if (u
->load_state
== UNIT_STUB
)
626 /* This is a new unit? Then let's add in some extras */
627 if (u
->load_state
== UNIT_LOADED
) {
629 /* We were able to load something, then let's add in
630 * the dropin directories. */
631 r
= unit_load_dropin(u
);
635 /* This is a new unit? Then let's add in some
637 r
= service_add_extras(s
);
642 return service_verify(s
);
645 static void service_dump(Unit
*u
, FILE *f
, const char *prefix
) {
646 ServiceExecCommand c
;
647 Service
*s
= SERVICE(u
);
652 prefix
= strempty(prefix
);
653 prefix2
= strjoina(prefix
, "\t");
656 "%sService State: %s\n"
658 "%sReload Result: %s\n"
659 "%sPermissionsStartOnly: %s\n"
660 "%sRootDirectoryStartOnly: %s\n"
661 "%sRemainAfterExit: %s\n"
662 "%sGuessMainPID: %s\n"
665 "%sNotifyAccess: %s\n"
666 "%sNotifyState: %s\n",
667 prefix
, service_state_to_string(s
->state
),
668 prefix
, service_result_to_string(s
->result
),
669 prefix
, service_result_to_string(s
->reload_result
),
670 prefix
, yes_no(s
->permissions_start_only
),
671 prefix
, yes_no(s
->root_directory_start_only
),
672 prefix
, yes_no(s
->remain_after_exit
),
673 prefix
, yes_no(s
->guess_main_pid
),
674 prefix
, service_type_to_string(s
->type
),
675 prefix
, service_restart_to_string(s
->restart
),
676 prefix
, notify_access_to_string(s
->notify_access
),
677 prefix
, notify_state_to_string(s
->notify_state
));
679 if (s
->control_pid
> 0)
681 "%sControl PID: "PID_FMT
"\n",
682 prefix
, s
->control_pid
);
686 "%sMain PID: "PID_FMT
"\n"
687 "%sMain PID Known: %s\n"
688 "%sMain PID Alien: %s\n",
690 prefix
, yes_no(s
->main_pid_known
),
691 prefix
, yes_no(s
->main_pid_alien
));
696 prefix
, s
->pid_file
);
701 "%sBus Name Good: %s\n",
703 prefix
, yes_no(s
->bus_name_good
));
705 kill_context_dump(&s
->kill_context
, f
, prefix
);
706 exec_context_dump(&s
->exec_context
, f
, prefix
);
708 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
710 if (!s
->exec_command
[c
])
713 fprintf(f
, "%s-> %s:\n",
714 prefix
, service_exec_command_to_string(c
));
716 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
720 fprintf(f
, "%sStatus Text: %s\n",
721 prefix
, s
->status_text
);
723 if (s
->n_fd_store_max
> 0)
725 "%sFile Descriptor Store Max: %u\n"
726 "%sFile Descriptor Store Current: %u\n",
727 prefix
, s
->n_fd_store_max
,
728 prefix
, s
->n_fd_store
);
731 static int service_load_pid_file(Service
*s
, bool may_warn
) {
732 _cleanup_free_
char *k
= NULL
;
741 r
= read_one_line_file(s
->pid_file
, &k
);
744 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
));
748 r
= parse_pid(k
, &pid
);
751 log_unit_info_errno(UNIT(s
), r
, "Failed to read PID from file %s: %m", s
->pid_file
);
755 if (!pid_is_alive(pid
)) {
757 log_unit_info(UNIT(s
), "PID "PID_FMT
" read from file %s does not exist or is a zombie.", pid
, s
->pid_file
);
761 if (s
->main_pid_known
) {
762 if (pid
== s
->main_pid
)
765 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
767 service_unwatch_main_pid(s
);
768 s
->main_pid_known
= false;
770 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
772 r
= service_set_main_pid(s
, pid
);
776 r
= unit_watch_pid(UNIT(s
), pid
);
778 /* FIXME: we need to do something here */
779 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
786 static int service_search_main_pid(Service
*s
) {
792 /* If we know it anyway, don't ever fallback to unreliable
794 if (s
->main_pid_known
)
797 if (!s
->guess_main_pid
)
800 assert(s
->main_pid
<= 0);
802 r
= unit_search_main_pid(UNIT(s
), &pid
);
806 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
807 r
= service_set_main_pid(s
, pid
);
811 r
= unit_watch_pid(UNIT(s
), pid
);
813 /* FIXME: we need to do something here */
814 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
821 static void service_set_state(Service
*s
, ServiceState state
) {
822 ServiceState old_state
;
823 const UnitActiveState
*table
;
827 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
829 old_state
= s
->state
;
832 service_unwatch_pid_file(s
);
835 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
837 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
838 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
839 SERVICE_AUTO_RESTART
))
840 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
843 SERVICE_START
, SERVICE_START_POST
,
844 SERVICE_RUNNING
, SERVICE_RELOAD
,
845 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
846 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
847 service_unwatch_main_pid(s
);
848 s
->main_command
= NULL
;
852 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
854 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
855 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
856 service_unwatch_control_pid(s
);
857 s
->control_command
= NULL
;
858 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
861 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
862 unit_unwatch_all_pids(UNIT(s
));
865 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
866 SERVICE_RUNNING
, SERVICE_RELOAD
,
867 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
868 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
869 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
)) {
870 service_close_socket_fd(s
);
871 service_connection_unref(s
);
874 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
875 service_stop_watchdog(s
);
877 /* For the inactive states unit_notify() will trim the cgroup,
878 * but for exit we have to do that ourselves... */
879 if (state
== SERVICE_EXITED
&& UNIT(s
)->manager
->n_reloading
<= 0)
880 unit_prune_cgroup(UNIT(s
));
882 /* For remain_after_exit services, let's see if we can "release" the
883 * hold on the console, since unit_notify() only does that in case of
885 if (state
== SERVICE_EXITED
&&
886 s
->remain_after_exit
&&
887 UNIT(s
)->manager
->n_on_console
> 0) {
891 ec
= unit_get_exec_context(UNIT(s
));
892 if (ec
&& exec_context_may_touch_console(ec
)) {
893 Manager
*m
= UNIT(s
)->manager
;
896 if (m
->n_on_console
== 0)
897 /* unset no_console_output flag, since the console is free */
898 m
->no_console_output
= false;
902 if (old_state
!= state
)
903 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
905 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
908 static int service_coldplug(Unit
*u
) {
909 Service
*s
= SERVICE(u
);
913 assert(s
->state
== SERVICE_DEAD
);
915 if (s
->deserialized_state
== s
->state
)
918 if (IN_SET(s
->deserialized_state
,
919 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
921 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
922 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
926 k
= IN_SET(s
->deserialized_state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
;
928 /* For the start/stop timeouts 0 means off */
930 r
= service_arm_timer(s
, k
);
936 if (s
->deserialized_state
== SERVICE_AUTO_RESTART
) {
938 /* The restart timeouts 0 means immediately */
939 r
= service_arm_timer(s
, s
->restart_usec
);
944 if (s
->main_pid
> 0 &&
945 pid_is_unwaited(s
->main_pid
) &&
946 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
947 IN_SET(s
->deserialized_state
,
948 SERVICE_START
, SERVICE_START_POST
,
949 SERVICE_RUNNING
, SERVICE_RELOAD
,
950 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
951 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
952 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
957 if (s
->control_pid
> 0 &&
958 pid_is_unwaited(s
->control_pid
) &&
959 IN_SET(s
->deserialized_state
,
960 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
962 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
963 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
964 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
969 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
970 unit_watch_all_pids(UNIT(s
));
972 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
973 service_start_watchdog(s
);
975 service_set_state(s
, s
->deserialized_state
);
979 static int service_collect_fds(Service
*s
, int **fds
, char ***fd_names
) {
980 _cleanup_strv_free_
char **rfd_names
= NULL
;
981 _cleanup_free_
int *rfds
= NULL
;
988 if (s
->socket_fd
>= 0) {
990 /* Pass the per-connection socket */
995 rfds
[0] = s
->socket_fd
;
997 rfd_names
= strv_new("connection", NULL
);
1006 /* Pass all our configured sockets for singleton services */
1008 SET_FOREACH(u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1009 _cleanup_free_
int *cfds
= NULL
;
1013 if (u
->type
!= UNIT_SOCKET
)
1018 cn_fds
= socket_collect_fds(sock
, &cfds
);
1033 t
= realloc(rfds
, (rn_fds
+ cn_fds
) * sizeof(int));
1037 memcpy(t
+ rn_fds
, cfds
, cn_fds
* sizeof(int));
1043 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1049 if (s
->n_fd_store
> 0) {
1054 t
= realloc(rfds
, (rn_fds
+ s
->n_fd_store
) * sizeof(int));
1060 nl
= realloc(rfd_names
, (rn_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1066 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1067 rfds
[rn_fds
] = fs
->fd
;
1068 rfd_names
[rn_fds
] = strdup(strempty(fs
->fdname
));
1069 if (!rfd_names
[rn_fds
])
1075 rfd_names
[rn_fds
] = NULL
;
1079 *fd_names
= rfd_names
;
1087 static int service_spawn(
1092 bool apply_permissions
,
1094 bool apply_tty_stdin
,
1098 _cleanup_strv_free_
char **argv
= NULL
, **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1099 _cleanup_free_
char *bus_endpoint_path
= NULL
;
1100 _cleanup_free_
int *fds
= NULL
;
1101 unsigned n_fds
= 0, n_env
= 0;
1105 ExecParameters exec_params
= {
1106 .apply_permissions
= apply_permissions
,
1107 .apply_chroot
= apply_chroot
,
1108 .apply_tty_stdin
= apply_tty_stdin
,
1109 .bus_endpoint_fd
= -1,
1121 (void) unit_realize_cgroup(UNIT(s
));
1122 if (s
->reset_cpu_usage
) {
1123 (void) unit_reset_cpu_usage(UNIT(s
));
1124 s
->reset_cpu_usage
= false;
1127 r
= unit_setup_exec_runtime(UNIT(s
));
1132 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1133 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1134 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1136 r
= service_collect_fds(s
, &fds
, &fd_names
);
1144 r
= service_arm_timer(s
, timeout
);
1148 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1150 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1154 our_env
= new0(char*, 6);
1160 if (is_control
? s
->notify_access
== NOTIFY_ALL
: s
->notify_access
!= NOTIFY_NONE
)
1161 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0) {
1166 if (s
->main_pid
> 0)
1167 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0) {
1172 if (UNIT(s
)->manager
->running_as
!= MANAGER_SYSTEM
)
1173 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid()) < 0) {
1178 if (s
->socket_fd
>= 0) {
1179 union sockaddr_union sa
;
1180 socklen_t salen
= sizeof(sa
);
1182 r
= getpeername(s
->socket_fd
, &sa
.sa
, &salen
);
1188 if (IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
)) {
1189 _cleanup_free_
char *addr
= NULL
;
1193 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1197 t
= strappend("REMOTE_ADDR=", addr
);
1202 our_env
[n_env
++] = t
;
1204 port
= sockaddr_port(&sa
.sa
);
1210 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0) {
1214 our_env
[n_env
++] = t
;
1218 final_env
= strv_env_merge(2, UNIT(s
)->manager
->environment
, our_env
, NULL
);
1224 if (is_control
&& UNIT(s
)->cgroup_path
) {
1225 path
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1226 (void) cg_create(SYSTEMD_CGROUP_CONTROLLER
, path
);
1228 path
= UNIT(s
)->cgroup_path
;
1230 if (s
->exec_context
.bus_endpoint
) {
1231 r
= bus_kernel_create_endpoint(UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
? "system" : "user",
1232 UNIT(s
)->id
, &bus_endpoint_path
);
1236 /* Pass the fd to the exec_params so that the child process can upload the policy.
1237 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1238 * as the service is running. */
1239 exec_params
.bus_endpoint_fd
= s
->bus_endpoint_fd
= r
;
1242 exec_params
.argv
= argv
;
1243 exec_params
.fds
= fds
;
1244 exec_params
.fd_names
= fd_names
;
1245 exec_params
.n_fds
= n_fds
;
1246 exec_params
.environment
= final_env
;
1247 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1248 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1249 exec_params
.cgroup_path
= path
;
1250 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1251 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1252 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1253 exec_params
.bus_endpoint_path
= bus_endpoint_path
;
1254 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1255 if (s
->type
== SERVICE_IDLE
)
1256 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1257 exec_params
.stdin_fd
= s
->stdin_fd
;
1258 exec_params
.stdout_fd
= s
->stdout_fd
;
1259 exec_params
.stderr_fd
= s
->stderr_fd
;
1261 r
= exec_spawn(UNIT(s
),
1270 r
= unit_watch_pid(UNIT(s
), pid
);
1272 /* FIXME: we need to do something here */
1281 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1286 static int main_pid_good(Service
*s
) {
1289 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1292 /* If we know the pid file, then let's just check if it is
1294 if (s
->main_pid_known
) {
1296 /* If it's an alien child let's check if it is still
1298 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1299 return pid_is_alive(s
->main_pid
);
1301 /* .. otherwise assume we'll get a SIGCHLD for it,
1302 * which we really should wait for to collect exit
1303 * status and code */
1304 return s
->main_pid
> 0;
1307 /* We don't know the pid */
1311 _pure_
static int control_pid_good(Service
*s
) {
1314 return s
->control_pid
> 0;
1317 static int cgroup_good(Service
*s
) {
1322 if (!UNIT(s
)->cgroup_path
)
1325 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1332 static bool service_shall_restart(Service
*s
) {
1335 /* Don't restart after manual stops */
1336 if (s
->forbid_restart
)
1339 /* Never restart if this is configured as special exception */
1340 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1343 /* Restart if the exit code/status are configured as restart triggers */
1344 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1347 switch (s
->restart
) {
1349 case SERVICE_RESTART_NO
:
1352 case SERVICE_RESTART_ALWAYS
:
1355 case SERVICE_RESTART_ON_SUCCESS
:
1356 return s
->result
== SERVICE_SUCCESS
;
1358 case SERVICE_RESTART_ON_FAILURE
:
1359 return s
->result
!= SERVICE_SUCCESS
;
1361 case SERVICE_RESTART_ON_ABNORMAL
:
1362 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1364 case SERVICE_RESTART_ON_WATCHDOG
:
1365 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1367 case SERVICE_RESTART_ON_ABORT
:
1368 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1371 assert_not_reached("unknown restart setting");
1375 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1379 if (f
!= SERVICE_SUCCESS
)
1382 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1384 if (s
->result
!= SERVICE_SUCCESS
) {
1385 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1386 failure_action(UNIT(s
)->manager
, s
->failure_action
, s
->reboot_arg
);
1389 if (allow_restart
&& service_shall_restart(s
)) {
1391 r
= service_arm_timer(s
, s
->restart_usec
);
1395 service_set_state(s
, SERVICE_AUTO_RESTART
);
1398 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1399 s
->forbid_restart
= false;
1401 /* We want fresh tmpdirs in case service is started again immediately */
1402 exec_runtime_destroy(s
->exec_runtime
);
1403 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1405 /* Also, remove the runtime directory in */
1406 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1408 /* Try to delete the pid file. At this point it will be
1409 * out-of-date, and some software might be confused by it, so
1410 * let's remove it. */
1412 unlink_noerrno(s
->pid_file
);
1417 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1418 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1421 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1425 if (f
!= SERVICE_SUCCESS
)
1428 service_unwatch_control_pid(s
);
1429 unit_watch_all_pids(UNIT(s
));
1431 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1432 if (s
->control_command
) {
1433 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1435 r
= service_spawn(s
,
1437 s
->timeout_stop_usec
,
1439 !s
->permissions_start_only
,
1440 !s
->root_directory_start_only
,
1447 service_set_state(s
, SERVICE_STOP_POST
);
1449 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1454 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1455 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1458 static int state_to_kill_operation(ServiceState state
) {
1461 case SERVICE_STOP_SIGABRT
:
1464 case SERVICE_STOP_SIGTERM
:
1465 case SERVICE_FINAL_SIGTERM
:
1466 return KILL_TERMINATE
;
1468 case SERVICE_STOP_SIGKILL
:
1469 case SERVICE_FINAL_SIGKILL
:
1473 return _KILL_OPERATION_INVALID
;
1477 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1482 if (f
!= SERVICE_SUCCESS
)
1485 unit_watch_all_pids(UNIT(s
));
1487 r
= unit_kill_context(
1490 state_to_kill_operation(state
),
1499 if (s
->timeout_stop_usec
> 0) {
1500 r
= service_arm_timer(s
, s
->timeout_stop_usec
);
1505 service_set_state(s
, state
);
1506 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1507 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1508 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1509 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1510 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1511 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1513 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1518 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1520 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1521 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1523 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1526 static void service_enter_stop_by_notify(Service
*s
) {
1529 unit_watch_all_pids(UNIT(s
));
1531 if (s
->timeout_stop_usec
> 0)
1532 service_arm_timer(s
, s
->timeout_stop_usec
);
1534 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1535 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1538 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1543 if (f
!= SERVICE_SUCCESS
)
1546 service_unwatch_control_pid(s
);
1547 unit_watch_all_pids(UNIT(s
));
1549 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1550 if (s
->control_command
) {
1551 s
->control_command_id
= SERVICE_EXEC_STOP
;
1553 r
= service_spawn(s
,
1555 s
->timeout_stop_usec
,
1557 !s
->permissions_start_only
,
1558 !s
->root_directory_start_only
,
1565 service_set_state(s
, SERVICE_STOP
);
1567 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1572 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1573 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1576 static bool service_good(Service
*s
) {
1580 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1583 main_pid_ok
= main_pid_good(s
);
1584 if (main_pid_ok
> 0) /* It's alive */
1586 if (main_pid_ok
== 0) /* It's dead */
1589 /* OK, we don't know anything about the main PID, maybe
1590 * because there is none. Let's check the control group
1593 return cgroup_good(s
) != 0;
1596 static void service_enter_running(Service
*s
, ServiceResult f
) {
1599 if (f
!= SERVICE_SUCCESS
)
1602 if (service_good(s
)) {
1604 /* If there are any queued up sd_notify()
1605 * notifications, process them now */
1606 if (s
->notify_state
== NOTIFY_RELOADING
)
1607 service_enter_reload_by_notify(s
);
1608 else if (s
->notify_state
== NOTIFY_STOPPING
)
1609 service_enter_stop_by_notify(s
);
1611 service_set_state(s
, SERVICE_RUNNING
);
1613 } else if (s
->remain_after_exit
)
1614 service_set_state(s
, SERVICE_EXITED
);
1616 service_enter_stop(s
, SERVICE_SUCCESS
);
1619 static void service_enter_start_post(Service
*s
) {
1623 service_unwatch_control_pid(s
);
1624 service_reset_watchdog(s
);
1626 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1627 if (s
->control_command
) {
1628 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1630 r
= service_spawn(s
,
1632 s
->timeout_start_usec
,
1634 !s
->permissions_start_only
,
1635 !s
->root_directory_start_only
,
1642 service_set_state(s
, SERVICE_START_POST
);
1644 service_enter_running(s
, SERVICE_SUCCESS
);
1649 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1650 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1653 static void service_kill_control_processes(Service
*s
) {
1656 if (!UNIT(s
)->cgroup_path
)
1659 p
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1660 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, p
, SIGKILL
, true, true, true, NULL
);
1663 static void service_enter_start(Service
*s
) {
1670 service_unwatch_control_pid(s
);
1671 service_unwatch_main_pid(s
);
1673 /* We want to ensure that nobody leaks processes from
1674 * START_PRE here, so let's go on a killing spree, People
1675 * should not spawn long running processes from START_PRE. */
1676 service_kill_control_processes(s
);
1678 if (s
->type
== SERVICE_FORKING
) {
1679 s
->control_command_id
= SERVICE_EXEC_START
;
1680 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1682 s
->main_command
= NULL
;
1684 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1685 s
->control_command
= NULL
;
1687 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1691 assert(s
->type
== SERVICE_ONESHOT
);
1692 service_enter_start_post(s
);
1696 r
= service_spawn(s
,
1698 IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_NOTIFY
, SERVICE_ONESHOT
) ? s
->timeout_start_usec
: 0,
1708 if (s
->type
== SERVICE_SIMPLE
|| s
->type
== SERVICE_IDLE
) {
1709 /* For simple services we immediately start
1710 * the START_POST binaries. */
1712 service_set_main_pid(s
, pid
);
1713 service_enter_start_post(s
);
1715 } else if (s
->type
== SERVICE_FORKING
) {
1717 /* For forking services we wait until the start
1718 * process exited. */
1720 s
->control_pid
= pid
;
1721 service_set_state(s
, SERVICE_START
);
1723 } else if (s
->type
== SERVICE_ONESHOT
||
1724 s
->type
== SERVICE_DBUS
||
1725 s
->type
== SERVICE_NOTIFY
) {
1727 /* For oneshot services we wait until the start
1728 * process exited, too, but it is our main process. */
1730 /* For D-Bus services we know the main pid right away,
1731 * but wait for the bus name to appear on the
1732 * bus. Notify services are similar. */
1734 service_set_main_pid(s
, pid
);
1735 service_set_state(s
, SERVICE_START
);
1737 assert_not_reached("Unknown service type");
1742 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1743 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1746 static void service_enter_start_pre(Service
*s
) {
1751 service_unwatch_control_pid(s
);
1753 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1754 if (s
->control_command
) {
1755 /* Before we start anything, let's clear up what might
1756 * be left from previous runs. */
1757 service_kill_control_processes(s
);
1759 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1761 r
= service_spawn(s
,
1763 s
->timeout_start_usec
,
1765 !s
->permissions_start_only
,
1766 !s
->root_directory_start_only
,
1773 service_set_state(s
, SERVICE_START_PRE
);
1775 service_enter_start(s
);
1780 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1781 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1784 static void service_enter_restart(Service
*s
) {
1785 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1790 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1791 /* Don't restart things if we are going down anyway */
1792 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
1794 r
= service_arm_timer(s
, s
->restart_usec
);
1801 /* Any units that are bound to this service must also be
1802 * restarted. We use JOB_RESTART (instead of the more obvious
1803 * JOB_START) here so that those dependency jobs will be added
1805 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, false, &error
, NULL
);
1809 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1810 * it will be canceled as part of the service_stop() call that
1811 * is executed as part of JOB_RESTART. */
1813 log_unit_debug(UNIT(s
), "Scheduled restart job.");
1817 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
1818 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1821 static void service_enter_reload_by_notify(Service
*s
) {
1824 if (s
->timeout_start_usec
> 0)
1825 service_arm_timer(s
, s
->timeout_start_usec
);
1827 service_set_state(s
, SERVICE_RELOAD
);
1830 static void service_enter_reload(Service
*s
) {
1835 service_unwatch_control_pid(s
);
1836 s
->reload_result
= SERVICE_SUCCESS
;
1838 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
1839 if (s
->control_command
) {
1840 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
1842 r
= service_spawn(s
,
1844 s
->timeout_start_usec
,
1846 !s
->permissions_start_only
,
1847 !s
->root_directory_start_only
,
1854 service_set_state(s
, SERVICE_RELOAD
);
1856 service_enter_running(s
, SERVICE_SUCCESS
);
1861 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
1862 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1863 service_enter_running(s
, SERVICE_SUCCESS
);
1866 static void service_run_next_control(Service
*s
) {
1870 assert(s
->control_command
);
1871 assert(s
->control_command
->command_next
);
1873 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
1875 s
->control_command
= s
->control_command
->command_next
;
1876 service_unwatch_control_pid(s
);
1878 r
= service_spawn(s
,
1880 IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
,
1882 !s
->permissions_start_only
,
1883 !s
->root_directory_start_only
,
1884 s
->control_command_id
== SERVICE_EXEC_START_PRE
||
1885 s
->control_command_id
== SERVICE_EXEC_STOP_POST
,
1894 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
1896 if (s
->state
== SERVICE_START_PRE
)
1897 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1898 else if (s
->state
== SERVICE_STOP
)
1899 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1900 else if (s
->state
== SERVICE_STOP_POST
)
1901 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1902 else if (s
->state
== SERVICE_RELOAD
) {
1903 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1904 service_enter_running(s
, SERVICE_SUCCESS
);
1906 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1909 static void service_run_next_main(Service
*s
) {
1914 assert(s
->main_command
);
1915 assert(s
->main_command
->command_next
);
1916 assert(s
->type
== SERVICE_ONESHOT
);
1918 s
->main_command
= s
->main_command
->command_next
;
1919 service_unwatch_main_pid(s
);
1921 r
= service_spawn(s
,
1923 s
->timeout_start_usec
,
1933 service_set_main_pid(s
, pid
);
1938 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
1939 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1942 static int service_start_limit_test(Service
*s
) {
1945 if (ratelimit_test(&s
->start_limit
))
1948 log_unit_warning(UNIT(s
), "Start request repeated too quickly.");
1950 return failure_action(UNIT(s
)->manager
, s
->start_limit_action
, s
->reboot_arg
);
1953 static int service_start(Unit
*u
) {
1954 Service
*s
= SERVICE(u
);
1959 /* We cannot fulfill this request right now, try again later
1961 if (IN_SET(s
->state
,
1962 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1963 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
1966 /* Already on it! */
1967 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
1970 /* A service that will be restarted must be stopped first to
1971 * trigger BindsTo and/or OnFailure dependencies. If a user
1972 * does not want to wait for the holdoff time to elapse, the
1973 * service should be manually restarted, not started. We
1974 * simply return EAGAIN here, so that any start jobs stay
1975 * queued, and assume that the auto restart timer will
1976 * eventually trigger the restart. */
1977 if (s
->state
== SERVICE_AUTO_RESTART
)
1980 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
1982 /* Make sure we don't enter a busy loop of some kind. */
1983 r
= service_start_limit_test(s
);
1985 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT
, false);
1989 s
->result
= SERVICE_SUCCESS
;
1990 s
->reload_result
= SERVICE_SUCCESS
;
1991 s
->main_pid_known
= false;
1992 s
->main_pid_alien
= false;
1993 s
->forbid_restart
= false;
1994 s
->reset_cpu_usage
= true;
1996 s
->status_text
= mfree(s
->status_text
);
1997 s
->status_errno
= 0;
1999 s
->notify_state
= NOTIFY_UNKNOWN
;
2001 service_enter_start_pre(s
);
2005 static int service_stop(Unit
*u
) {
2006 Service
*s
= SERVICE(u
);
2010 /* Don't create restart jobs from manual stops. */
2011 s
->forbid_restart
= true;
2014 if (IN_SET(s
->state
,
2015 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2016 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2019 /* A restart will be scheduled or is in progress. */
2020 if (s
->state
== SERVICE_AUTO_RESTART
) {
2021 service_set_state(s
, SERVICE_DEAD
);
2025 /* If there's already something running we go directly into
2027 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2028 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2032 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2034 service_enter_stop(s
, SERVICE_SUCCESS
);
2038 static int service_reload(Unit
*u
) {
2039 Service
*s
= SERVICE(u
);
2043 assert(s
->state
== SERVICE_RUNNING
|| s
->state
== SERVICE_EXITED
);
2045 service_enter_reload(s
);
2049 _pure_
static bool service_can_reload(Unit
*u
) {
2050 Service
*s
= SERVICE(u
);
2054 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2057 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2058 Service
*s
= SERVICE(u
);
2066 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2067 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2068 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2070 if (s
->control_pid
> 0)
2071 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2073 if (s
->main_pid_known
&& s
->main_pid
> 0)
2074 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2076 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2077 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2079 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2083 /* FIXME: There's a minor uncleanliness here: if there are
2084 * multiple commands attached here, we will start from the
2085 * first one again */
2086 if (s
->control_command_id
>= 0)
2087 unit_serialize_item(u
, f
, "control-command", service_exec_command_to_string(s
->control_command_id
));
2089 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2092 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2095 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2099 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2102 r
= unit_serialize_item_fd(u
, f
, fds
, "endpoint-fd", s
->bus_endpoint_fd
);
2106 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2107 _cleanup_free_
char *c
= NULL
;
2110 copy
= fdset_put_dup(fds
, fs
->fd
);
2114 c
= cescape(fs
->fdname
);
2116 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2119 if (s
->main_exec_status
.pid
> 0) {
2120 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2121 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2122 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2124 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2125 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2126 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2130 if (dual_timestamp_is_set(&s
->watchdog_timestamp
))
2131 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2133 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2138 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2139 Service
*s
= SERVICE(u
);
2147 if (streq(key
, "state")) {
2150 state
= service_state_from_string(value
);
2152 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2154 s
->deserialized_state
= state
;
2155 } else if (streq(key
, "result")) {
2158 f
= service_result_from_string(value
);
2160 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2161 else if (f
!= SERVICE_SUCCESS
)
2164 } else if (streq(key
, "reload-result")) {
2167 f
= service_result_from_string(value
);
2169 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2170 else if (f
!= SERVICE_SUCCESS
)
2171 s
->reload_result
= f
;
2173 } else if (streq(key
, "control-pid")) {
2176 if (parse_pid(value
, &pid
) < 0)
2177 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2179 s
->control_pid
= pid
;
2180 } else if (streq(key
, "main-pid")) {
2183 if (parse_pid(value
, &pid
) < 0)
2184 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2186 service_set_main_pid(s
, pid
);
2187 unit_watch_pid(UNIT(s
), pid
);
2189 } else if (streq(key
, "main-pid-known")) {
2192 b
= parse_boolean(value
);
2194 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2196 s
->main_pid_known
= b
;
2197 } else if (streq(key
, "bus-name-good")) {
2200 b
= parse_boolean(value
);
2202 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2204 s
->bus_name_good
= b
;
2205 } else if (streq(key
, "status-text")) {
2208 r
= cunescape(value
, 0, &t
);
2210 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2212 free(s
->status_text
);
2216 } else if (streq(key
, "control-command")) {
2217 ServiceExecCommand id
;
2219 id
= service_exec_command_from_string(value
);
2221 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2223 s
->control_command_id
= id
;
2224 s
->control_command
= s
->exec_command
[id
];
2226 } else if (streq(key
, "socket-fd")) {
2229 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2230 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2232 asynchronous_close(s
->socket_fd
);
2233 s
->socket_fd
= fdset_remove(fds
, fd
);
2235 } else if (streq(key
, "endpoint-fd")) {
2238 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2239 log_unit_debug(u
, "Failed to parse endpoint-fd value: %s", value
);
2241 safe_close(s
->bus_endpoint_fd
);
2242 s
->bus_endpoint_fd
= fdset_remove(fds
, fd
);
2244 } else if (streq(key
, "fd-store-fd")) {
2249 pf
= strcspn(value
, WHITESPACE
);
2250 fdv
= strndupa(value
, pf
);
2252 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2253 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2255 _cleanup_free_
char *t
= NULL
;
2259 fdn
+= strspn(fdn
, WHITESPACE
);
2260 (void) cunescape(fdn
, 0, &t
);
2262 r
= service_add_fd_store(s
, fd
, t
);
2264 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2266 fdset_remove(fds
, fd
);
2269 } else if (streq(key
, "main-exec-status-pid")) {
2272 if (parse_pid(value
, &pid
) < 0)
2273 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2275 s
->main_exec_status
.pid
= pid
;
2276 } else if (streq(key
, "main-exec-status-code")) {
2279 if (safe_atoi(value
, &i
) < 0)
2280 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2282 s
->main_exec_status
.code
= i
;
2283 } else if (streq(key
, "main-exec-status-status")) {
2286 if (safe_atoi(value
, &i
) < 0)
2287 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2289 s
->main_exec_status
.status
= i
;
2290 } else if (streq(key
, "main-exec-status-start"))
2291 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2292 else if (streq(key
, "main-exec-status-exit"))
2293 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2294 else if (streq(key
, "watchdog-timestamp"))
2295 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2296 else if (streq(key
, "forbid-restart")) {
2299 b
= parse_boolean(value
);
2301 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2303 s
->forbid_restart
= b
;
2304 } else if (streq(key
, "stdin-fd")) {
2307 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2308 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2310 asynchronous_close(s
->stdin_fd
);
2311 s
->stdin_fd
= fdset_remove(fds
, fd
);
2313 } else if (streq(key
, "stdout-fd")) {
2316 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2317 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2319 asynchronous_close(s
->stdout_fd
);
2320 s
->stdout_fd
= fdset_remove(fds
, fd
);
2322 } else if (streq(key
, "stderr-fd")) {
2325 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2326 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2328 asynchronous_close(s
->stderr_fd
);
2329 s
->stderr_fd
= fdset_remove(fds
, fd
);
2332 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2337 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2338 const UnitActiveState
*table
;
2342 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2344 return table
[SERVICE(u
)->state
];
2347 static const char *service_sub_state_to_string(Unit
*u
) {
2350 return service_state_to_string(SERVICE(u
)->state
);
2353 static bool service_check_gc(Unit
*u
) {
2354 Service
*s
= SERVICE(u
);
2358 /* Never clean up services that still have a process around,
2359 * even if the service is formally dead. */
2360 if (cgroup_good(s
) > 0 ||
2361 main_pid_good(s
) > 0 ||
2362 control_pid_good(s
) > 0)
2368 _pure_
static bool service_check_snapshot(Unit
*u
) {
2369 Service
*s
= SERVICE(u
);
2373 return s
->socket_fd
< 0;
2376 static int service_retry_pid_file(Service
*s
) {
2379 assert(s
->pid_file
);
2380 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2382 r
= service_load_pid_file(s
, false);
2386 service_unwatch_pid_file(s
);
2388 service_enter_running(s
, SERVICE_SUCCESS
);
2392 static int service_watch_pid_file(Service
*s
) {
2395 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2397 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2401 /* the pidfile might have appeared just before we set the watch */
2402 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2403 service_retry_pid_file(s
);
2407 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2408 service_unwatch_pid_file(s
);
2412 static int service_demand_pid_file(Service
*s
) {
2415 assert(s
->pid_file
);
2416 assert(!s
->pid_file_pathspec
);
2418 ps
= new0(PathSpec
, 1);
2423 ps
->path
= strdup(s
->pid_file
);
2429 path_kill_slashes(ps
->path
);
2431 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2432 * keep their PID file open all the time. */
2433 ps
->type
= PATH_MODIFIED
;
2434 ps
->inotify_fd
= -1;
2436 s
->pid_file_pathspec
= ps
;
2438 return service_watch_pid_file(s
);
2441 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2442 PathSpec
*p
= userdata
;
2447 s
= SERVICE(p
->unit
);
2451 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2452 assert(s
->pid_file_pathspec
);
2453 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2455 log_unit_debug(UNIT(s
), "inotify event");
2457 if (path_spec_fd_event(p
, events
) < 0)
2460 if (service_retry_pid_file(s
) == 0)
2463 if (service_watch_pid_file(s
) < 0)
2469 service_unwatch_pid_file(s
);
2470 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2474 static void service_notify_cgroup_empty_event(Unit
*u
) {
2475 Service
*s
= SERVICE(u
);
2479 log_unit_debug(u
, "cgroup is empty");
2483 /* Waiting for SIGCHLD is usually more interesting,
2484 * because it includes return codes/signals. Which is
2485 * why we ignore the cgroup events for most cases,
2486 * except when we don't know pid which to expect the
2490 case SERVICE_START_POST
:
2491 /* If we were hoping for the daemon to write its PID file,
2492 * we can give up now. */
2493 if (s
->pid_file_pathspec
) {
2494 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2496 service_unwatch_pid_file(s
);
2497 if (s
->state
== SERVICE_START
)
2498 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2500 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2504 case SERVICE_RUNNING
:
2505 /* service_enter_running() will figure out what to do */
2506 service_enter_running(s
, SERVICE_SUCCESS
);
2509 case SERVICE_STOP_SIGABRT
:
2510 case SERVICE_STOP_SIGTERM
:
2511 case SERVICE_STOP_SIGKILL
:
2513 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2514 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2518 case SERVICE_STOP_POST
:
2519 case SERVICE_FINAL_SIGTERM
:
2520 case SERVICE_FINAL_SIGKILL
:
2521 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2522 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2531 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2532 Service
*s
= SERVICE(u
);
2538 if (UNIT(s
)->fragment_path
? is_clean_exit(code
, status
, &s
->success_status
) :
2539 is_clean_exit_lsb(code
, status
, &s
->success_status
))
2540 f
= SERVICE_SUCCESS
;
2541 else if (code
== CLD_EXITED
)
2542 f
= SERVICE_FAILURE_EXIT_CODE
;
2543 else if (code
== CLD_KILLED
)
2544 f
= SERVICE_FAILURE_SIGNAL
;
2545 else if (code
== CLD_DUMPED
)
2546 f
= SERVICE_FAILURE_CORE_DUMP
;
2548 assert_not_reached("Unknown code");
2550 if (s
->main_pid
== pid
) {
2551 /* Forking services may occasionally move to a new PID.
2552 * As long as they update the PID file before exiting the old
2553 * PID, they're fine. */
2554 if (service_load_pid_file(s
, false) == 0)
2558 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2560 if (s
->main_command
) {
2561 /* If this is not a forking service than the
2562 * main process got started and hence we copy
2563 * the exit status so that it is recorded both
2564 * as main and as control process exit
2567 s
->main_command
->exec_status
= s
->main_exec_status
;
2569 if (s
->main_command
->ignore
)
2570 f
= SERVICE_SUCCESS
;
2571 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
2573 /* If this is a forked process, then we should
2574 * ignore the return value if this was
2575 * configured for the starter process */
2577 if (s
->exec_command
[SERVICE_EXEC_START
]->ignore
)
2578 f
= SERVICE_SUCCESS
;
2581 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
,
2583 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
2584 sigchld_code_to_string(code
), status
,
2585 strna(code
== CLD_EXITED
2586 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
2587 : signal_to_string(status
))),
2588 "EXIT_CODE=%s", sigchld_code_to_string(code
),
2589 "EXIT_STATUS=%i", status
,
2592 if (f
!= SERVICE_SUCCESS
)
2595 if (s
->main_command
&&
2596 s
->main_command
->command_next
&&
2597 f
== SERVICE_SUCCESS
) {
2599 /* There is another command to *
2600 * execute, so let's do that. */
2602 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
2603 service_run_next_main(s
);
2607 /* The service exited, so the service is officially
2609 s
->main_command
= NULL
;
2613 case SERVICE_START_POST
:
2614 case SERVICE_RELOAD
:
2616 /* Need to wait until the operation is
2621 if (s
->type
== SERVICE_ONESHOT
) {
2622 /* This was our main goal, so let's go on */
2623 if (f
== SERVICE_SUCCESS
)
2624 service_enter_start_post(s
);
2626 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2632 case SERVICE_RUNNING
:
2633 service_enter_running(s
, f
);
2636 case SERVICE_STOP_SIGABRT
:
2637 case SERVICE_STOP_SIGTERM
:
2638 case SERVICE_STOP_SIGKILL
:
2640 if (!control_pid_good(s
))
2641 service_enter_stop_post(s
, f
);
2643 /* If there is still a control process, wait for that first */
2646 case SERVICE_STOP_POST
:
2647 case SERVICE_FINAL_SIGTERM
:
2648 case SERVICE_FINAL_SIGKILL
:
2650 if (!control_pid_good(s
))
2651 service_enter_dead(s
, f
, true);
2655 assert_not_reached("Uh, main process died at wrong time.");
2659 } else if (s
->control_pid
== pid
) {
2662 if (s
->control_command
) {
2663 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2665 if (s
->control_command
->ignore
)
2666 f
= SERVICE_SUCCESS
;
2669 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2670 "Control process exited, code=%s status=%i",
2671 sigchld_code_to_string(code
), status
);
2673 if (f
!= SERVICE_SUCCESS
)
2676 /* Immediately get rid of the cgroup, so that the
2677 * kernel doesn't delay the cgroup empty messages for
2678 * the service cgroup any longer than necessary */
2679 service_kill_control_processes(s
);
2681 if (s
->control_command
&&
2682 s
->control_command
->command_next
&&
2683 f
== SERVICE_SUCCESS
) {
2685 /* There is another command to *
2686 * execute, so let's do that. */
2688 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
2689 service_run_next_control(s
);
2692 /* No further commands for this step, so let's
2693 * figure out what to do next */
2695 s
->control_command
= NULL
;
2696 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
2698 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
2702 case SERVICE_START_PRE
:
2703 if (f
== SERVICE_SUCCESS
)
2704 service_enter_start(s
);
2706 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2710 if (s
->type
!= SERVICE_FORKING
)
2711 /* Maybe spurious event due to a reload that changed the type? */
2714 if (f
!= SERVICE_SUCCESS
) {
2715 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2720 bool has_start_post
;
2723 /* Let's try to load the pid file here if we can.
2724 * The PID file might actually be created by a START_POST
2725 * script. In that case don't worry if the loading fails. */
2727 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
2728 r
= service_load_pid_file(s
, !has_start_post
);
2729 if (!has_start_post
&& r
< 0) {
2730 r
= service_demand_pid_file(s
);
2731 if (r
< 0 || !cgroup_good(s
))
2732 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2736 (void) service_search_main_pid(s
);
2738 service_enter_start_post(s
);
2741 case SERVICE_START_POST
:
2742 if (f
!= SERVICE_SUCCESS
) {
2743 service_enter_stop(s
, f
);
2750 r
= service_load_pid_file(s
, true);
2752 r
= service_demand_pid_file(s
);
2753 if (r
< 0 || !cgroup_good(s
))
2754 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2758 (void) service_search_main_pid(s
);
2760 service_enter_running(s
, SERVICE_SUCCESS
);
2763 case SERVICE_RELOAD
:
2764 if (f
== SERVICE_SUCCESS
) {
2765 service_load_pid_file(s
, true);
2766 (void) service_search_main_pid(s
);
2769 s
->reload_result
= f
;
2770 service_enter_running(s
, SERVICE_SUCCESS
);
2774 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
2777 case SERVICE_STOP_SIGABRT
:
2778 case SERVICE_STOP_SIGTERM
:
2779 case SERVICE_STOP_SIGKILL
:
2780 if (main_pid_good(s
) <= 0)
2781 service_enter_stop_post(s
, f
);
2783 /* If there is still a service
2784 * process around, wait until
2785 * that one quit, too */
2788 case SERVICE_STOP_POST
:
2789 case SERVICE_FINAL_SIGTERM
:
2790 case SERVICE_FINAL_SIGKILL
:
2791 if (main_pid_good(s
) <= 0)
2792 service_enter_dead(s
, f
, true);
2796 assert_not_reached("Uh, control process died at wrong time.");
2801 /* Notify clients about changed exit status */
2802 unit_add_to_dbus_queue(u
);
2804 /* We got one SIGCHLD for the service, let's watch all
2805 * processes that are now running of the service, and watch
2806 * that. Among the PIDs we then watch will be children
2807 * reassigned to us, which hopefully allows us to identify
2808 * when all children are gone */
2809 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
2810 unit_watch_all_pids(u
);
2812 /* If the PID set is empty now, then let's finish this off */
2813 if (set_isempty(u
->pids
))
2814 service_notify_cgroup_empty_event(u
);
2817 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2818 Service
*s
= SERVICE(userdata
);
2821 assert(source
== s
->timer_event_source
);
2825 case SERVICE_START_PRE
:
2827 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
2828 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2831 case SERVICE_START_POST
:
2832 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
2833 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
2836 case SERVICE_RELOAD
:
2837 log_unit_warning(UNIT(s
), "Reload operation timed out. Stopping.");
2838 service_unwatch_control_pid(s
);
2839 service_kill_control_processes(s
);
2840 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
2841 service_enter_running(s
, SERVICE_SUCCESS
);
2845 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2846 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2849 case SERVICE_STOP_SIGABRT
:
2850 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
2851 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2854 case SERVICE_STOP_SIGTERM
:
2855 if (s
->kill_context
.send_sigkill
) {
2856 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
2857 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2859 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
2860 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2865 case SERVICE_STOP_SIGKILL
:
2866 /* Uh, we sent a SIGKILL and it is still not gone?
2867 * Must be something we cannot kill, so let's just be
2868 * weirded out and continue */
2870 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2871 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2874 case SERVICE_STOP_POST
:
2875 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
2876 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2879 case SERVICE_FINAL_SIGTERM
:
2880 if (s
->kill_context
.send_sigkill
) {
2881 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
2882 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2884 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
2885 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
2890 case SERVICE_FINAL_SIGKILL
:
2891 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
2892 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
2895 case SERVICE_AUTO_RESTART
:
2896 log_unit_info(UNIT(s
),
2897 s
->restart_usec
> 0 ?
2898 "Service hold-off time over, scheduling restart." :
2899 "Service has no hold-off time, scheduling restart.");
2900 service_enter_restart(s
);
2904 assert_not_reached("Timeout at wrong time.");
2910 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2911 Service
*s
= SERVICE(userdata
);
2912 char t
[FORMAT_TIMESPAN_MAX
];
2915 assert(source
== s
->watchdog_event_source
);
2917 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
2918 format_timespan(t
, sizeof(t
), s
->watchdog_usec
, 1));
2920 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
2925 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
2926 Service
*s
= SERVICE(u
);
2927 _cleanup_free_
char *cc
= NULL
;
2928 bool notify_dbus
= false;
2933 cc
= strv_join(tags
, ", ");
2935 if (s
->notify_access
== NOTIFY_NONE
) {
2936 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
2938 } else if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
2939 if (s
->main_pid
!= 0)
2940 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
2942 log_unit_debug(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID which is currently not known", pid
);
2945 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
2947 /* Interpret MAINPID= */
2948 e
= strv_find_startswith(tags
, "MAINPID=");
2949 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
2950 if (parse_pid(e
, &pid
) < 0)
2951 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
2953 service_set_main_pid(s
, pid
);
2954 unit_watch_pid(UNIT(s
), pid
);
2959 /* Interpret RELOADING= */
2960 if (strv_find(tags
, "RELOADING=1")) {
2962 s
->notify_state
= NOTIFY_RELOADING
;
2964 if (s
->state
== SERVICE_RUNNING
)
2965 service_enter_reload_by_notify(s
);
2970 /* Interpret READY= */
2971 if (strv_find(tags
, "READY=1")) {
2973 s
->notify_state
= NOTIFY_READY
;
2975 /* Type=notify services inform us about completed
2976 * initialization with READY=1 */
2977 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
2978 service_enter_start_post(s
);
2980 /* Sending READY=1 while we are reloading informs us
2981 * that the reloading is complete */
2982 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
2983 service_enter_running(s
, SERVICE_SUCCESS
);
2988 /* Interpret STOPPING= */
2989 if (strv_find(tags
, "STOPPING=1")) {
2991 s
->notify_state
= NOTIFY_STOPPING
;
2993 if (s
->state
== SERVICE_RUNNING
)
2994 service_enter_stop_by_notify(s
);
2999 /* Interpret STATUS= */
3000 e
= strv_find_startswith(tags
, "STATUS=");
3002 _cleanup_free_
char *t
= NULL
;
3005 if (!utf8_is_valid(e
))
3006 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3014 if (!streq_ptr(s
->status_text
, t
)) {
3016 free(s
->status_text
);
3024 /* Interpret ERRNO= */
3025 e
= strv_find_startswith(tags
, "ERRNO=");
3029 if (safe_atoi(e
, &status_errno
) < 0 || status_errno
< 0)
3030 log_unit_warning(u
, "Failed to parse ERRNO= field in notification message: %s", e
);
3032 if (s
->status_errno
!= status_errno
) {
3033 s
->status_errno
= status_errno
;
3039 /* Interpret WATCHDOG= */
3040 if (strv_find(tags
, "WATCHDOG=1"))
3041 service_reset_watchdog(s
);
3043 if (strv_find(tags
, "FDSTORE=1")) {
3046 name
= strv_find_startswith(tags
, "FDNAME=");
3047 if (name
&& !fdname_is_valid(name
)) {
3048 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3052 service_add_fd_store_set(s
, fds
, name
);
3055 /* Notify clients about changed status or main pid */
3057 unit_add_to_dbus_queue(u
);
3060 static int service_get_timeout(Unit
*u
, uint64_t *timeout
) {
3061 Service
*s
= SERVICE(u
);
3064 if (!s
->timer_event_source
)
3067 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
3074 static void service_bus_name_owner_change(
3077 const char *old_owner
,
3078 const char *new_owner
) {
3080 Service
*s
= SERVICE(u
);
3086 assert(streq(s
->bus_name
, name
));
3087 assert(old_owner
|| new_owner
);
3089 if (old_owner
&& new_owner
)
3090 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3092 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3094 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3096 s
->bus_name_good
= !!new_owner
;
3098 if (s
->type
== SERVICE_DBUS
) {
3100 /* service_enter_running() will figure out what to
3102 if (s
->state
== SERVICE_RUNNING
)
3103 service_enter_running(s
, SERVICE_SUCCESS
);
3104 else if (s
->state
== SERVICE_START
&& new_owner
)
3105 service_enter_start_post(s
);
3107 } else if (new_owner
&&
3109 (s
->state
== SERVICE_START
||
3110 s
->state
== SERVICE_START_POST
||
3111 s
->state
== SERVICE_RUNNING
||
3112 s
->state
== SERVICE_RELOAD
)) {
3114 _cleanup_bus_creds_unref_ sd_bus_creds
*creds
= NULL
;
3117 /* Try to acquire PID from bus service */
3119 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3121 r
= sd_bus_creds_get_pid(creds
, &pid
);
3123 log_unit_debug(u
, "D-Bus name %s is now owned by process %u", name
, (unsigned) pid
);
3125 service_set_main_pid(s
, pid
);
3126 unit_watch_pid(UNIT(s
), pid
);
3131 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3132 _cleanup_free_
char *peer
= NULL
;
3138 /* This is called by the socket code when instantiating a new
3139 * service for a stream socket and the socket needs to be
3142 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3145 if (s
->socket_fd
>= 0)
3148 if (s
->state
!= SERVICE_DEAD
)
3151 if (getpeername_pretty(fd
, &peer
) >= 0) {
3153 if (UNIT(s
)->description
) {
3154 _cleanup_free_
char *a
;
3156 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")", NULL
);
3160 r
= unit_set_description(UNIT(s
), a
);
3162 r
= unit_set_description(UNIT(s
), peer
);
3169 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3171 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3173 return unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false);
3176 static void service_reset_failed(Unit
*u
) {
3177 Service
*s
= SERVICE(u
);
3181 if (s
->state
== SERVICE_FAILED
)
3182 service_set_state(s
, SERVICE_DEAD
);
3184 s
->result
= SERVICE_SUCCESS
;
3185 s
->reload_result
= SERVICE_SUCCESS
;
3187 RATELIMIT_RESET(s
->start_limit
);
3190 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3191 Service
*s
= SERVICE(u
);
3193 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3196 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3197 [SERVICE_RESTART_NO
] = "no",
3198 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3199 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3200 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3201 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3202 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3203 [SERVICE_RESTART_ALWAYS
] = "always",
3206 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3208 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3209 [SERVICE_SIMPLE
] = "simple",
3210 [SERVICE_FORKING
] = "forking",
3211 [SERVICE_ONESHOT
] = "oneshot",
3212 [SERVICE_DBUS
] = "dbus",
3213 [SERVICE_NOTIFY
] = "notify",
3214 [SERVICE_IDLE
] = "idle"
3217 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3219 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3220 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3221 [SERVICE_EXEC_START
] = "ExecStart",
3222 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3223 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3224 [SERVICE_EXEC_STOP
] = "ExecStop",
3225 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3228 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3230 static const char* const notify_access_table
[_NOTIFY_ACCESS_MAX
] = {
3231 [NOTIFY_NONE
] = "none",
3232 [NOTIFY_MAIN
] = "main",
3233 [NOTIFY_ALL
] = "all"
3236 DEFINE_STRING_TABLE_LOOKUP(notify_access
, NotifyAccess
);
3238 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3239 [NOTIFY_UNKNOWN
] = "unknown",
3240 [NOTIFY_READY
] = "ready",
3241 [NOTIFY_RELOADING
] = "reloading",
3242 [NOTIFY_STOPPING
] = "stopping",
3245 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3247 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3248 [SERVICE_SUCCESS
] = "success",
3249 [SERVICE_FAILURE_RESOURCES
] = "resources",
3250 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3251 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3252 [SERVICE_FAILURE_SIGNAL
] = "signal",
3253 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3254 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3255 [SERVICE_FAILURE_START_LIMIT
] = "start-limit"
3258 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3260 const UnitVTable service_vtable
= {
3261 .object_size
= sizeof(Service
),
3262 .exec_context_offset
= offsetof(Service
, exec_context
),
3263 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3264 .kill_context_offset
= offsetof(Service
, kill_context
),
3265 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3271 .private_section
= "Service",
3273 .init
= service_init
,
3274 .done
= service_done
,
3275 .load
= service_load
,
3276 .release_resources
= service_release_resources
,
3278 .coldplug
= service_coldplug
,
3280 .dump
= service_dump
,
3282 .start
= service_start
,
3283 .stop
= service_stop
,
3284 .reload
= service_reload
,
3286 .can_reload
= service_can_reload
,
3288 .kill
= service_kill
,
3290 .serialize
= service_serialize
,
3291 .deserialize_item
= service_deserialize_item
,
3293 .active_state
= service_active_state
,
3294 .sub_state_to_string
= service_sub_state_to_string
,
3296 .check_gc
= service_check_gc
,
3297 .check_snapshot
= service_check_snapshot
,
3299 .sigchld_event
= service_sigchld_event
,
3301 .reset_failed
= service_reset_failed
,
3303 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3304 .notify_message
= service_notify_message
,
3306 .bus_name_owner_change
= service_bus_name_owner_change
,
3308 .bus_vtable
= bus_service_vtable
,
3309 .bus_set_property
= bus_service_set_property
,
3310 .bus_commit_properties
= bus_service_commit_properties
,
3312 .get_timeout
= service_get_timeout
,
3313 .can_transient
= true,
3315 .status_message_formats
= {
3316 .starting_stopping
= {
3317 [0] = "Starting %s...",
3318 [1] = "Stopping %s...",
3320 .finished_start_job
= {
3321 [JOB_DONE
] = "Started %s.",
3322 [JOB_FAILED
] = "Failed to start %s.",
3324 .finished_stop_job
= {
3325 [JOB_DONE
] = "Stopped %s.",
3326 [JOB_FAILED
] = "Stopped (with error) %s.",