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 FDStoreMax=%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
) {
917 if (IN_SET(s
->deserialized_state
,
918 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
920 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
921 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
925 k
= IN_SET(s
->deserialized_state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
;
927 /* For the start/stop timeouts 0 means off */
929 r
= service_arm_timer(s
, k
);
935 if (s
->deserialized_state
== SERVICE_AUTO_RESTART
) {
937 /* The restart timeouts 0 means immediately */
938 r
= service_arm_timer(s
, s
->restart_usec
);
943 if (pid_is_unwaited(s
->main_pid
) &&
944 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
945 IN_SET(s
->deserialized_state
,
946 SERVICE_START
, SERVICE_START_POST
,
947 SERVICE_RUNNING
, SERVICE_RELOAD
,
948 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
949 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
950 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
955 if (pid_is_unwaited(s
->control_pid
) &&
956 IN_SET(s
->deserialized_state
,
957 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
959 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
960 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
961 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
966 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
967 unit_watch_all_pids(UNIT(s
));
969 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
970 service_start_watchdog(s
);
972 service_set_state(s
, s
->deserialized_state
);
978 static int service_collect_fds(Service
*s
, int **fds
, char ***fd_names
) {
979 _cleanup_strv_free_
char **rfd_names
= NULL
;
980 _cleanup_free_
int *rfds
= NULL
;
987 if (s
->socket_fd
>= 0) {
989 /* Pass the per-connection socket */
994 rfds
[0] = s
->socket_fd
;
996 rfd_names
= strv_new("connection", NULL
);
1005 /* Pass all our configured sockets for singleton services */
1007 SET_FOREACH(u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1008 _cleanup_free_
int *cfds
= NULL
;
1012 if (u
->type
!= UNIT_SOCKET
)
1017 cn_fds
= socket_collect_fds(sock
, &cfds
);
1032 t
= realloc(rfds
, (rn_fds
+ cn_fds
) * sizeof(int));
1036 memcpy(t
+ rn_fds
, cfds
, cn_fds
* sizeof(int));
1042 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1048 if (s
->n_fd_store
> 0) {
1053 t
= realloc(rfds
, (rn_fds
+ s
->n_fd_store
) * sizeof(int));
1059 nl
= realloc(rfd_names
, (rn_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1065 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1066 rfds
[rn_fds
] = fs
->fd
;
1067 rfd_names
[rn_fds
] = strdup(strempty(fs
->fdname
));
1068 if (!rfd_names
[rn_fds
])
1074 rfd_names
[rn_fds
] = NULL
;
1078 *fd_names
= rfd_names
;
1086 static int service_spawn(
1091 bool apply_permissions
,
1093 bool apply_tty_stdin
,
1097 _cleanup_strv_free_
char **argv
= NULL
, **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1098 _cleanup_free_
char *bus_endpoint_path
= NULL
;
1099 _cleanup_free_
int *fds
= NULL
;
1100 unsigned n_fds
= 0, n_env
= 0;
1104 ExecParameters exec_params
= {
1105 .apply_permissions
= apply_permissions
,
1106 .apply_chroot
= apply_chroot
,
1107 .apply_tty_stdin
= apply_tty_stdin
,
1108 .bus_endpoint_fd
= -1,
1120 (void) unit_realize_cgroup(UNIT(s
));
1121 if (s
->reset_cpu_usage
) {
1122 (void) unit_reset_cpu_usage(UNIT(s
));
1123 s
->reset_cpu_usage
= false;
1126 r
= unit_setup_exec_runtime(UNIT(s
));
1131 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1132 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1133 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1135 r
= service_collect_fds(s
, &fds
, &fd_names
);
1143 r
= service_arm_timer(s
, timeout
);
1147 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1149 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1153 our_env
= new0(char*, 6);
1159 if (is_control
? s
->notify_access
== NOTIFY_ALL
: s
->notify_access
!= NOTIFY_NONE
)
1160 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0) {
1165 if (s
->main_pid
> 0)
1166 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0) {
1171 if (UNIT(s
)->manager
->running_as
!= MANAGER_SYSTEM
)
1172 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid()) < 0) {
1177 if (s
->socket_fd
>= 0) {
1178 union sockaddr_union sa
;
1179 socklen_t salen
= sizeof(sa
);
1181 r
= getpeername(s
->socket_fd
, &sa
.sa
, &salen
);
1187 if (IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
)) {
1188 _cleanup_free_
char *addr
= NULL
;
1192 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1196 t
= strappend("REMOTE_ADDR=", addr
);
1201 our_env
[n_env
++] = t
;
1203 port
= sockaddr_port(&sa
.sa
);
1209 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0) {
1213 our_env
[n_env
++] = t
;
1217 final_env
= strv_env_merge(2, UNIT(s
)->manager
->environment
, our_env
, NULL
);
1223 if (is_control
&& UNIT(s
)->cgroup_path
) {
1224 path
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1225 (void) cg_create(SYSTEMD_CGROUP_CONTROLLER
, path
);
1227 path
= UNIT(s
)->cgroup_path
;
1229 if (s
->exec_context
.bus_endpoint
) {
1230 r
= bus_kernel_create_endpoint(UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
? "system" : "user",
1231 UNIT(s
)->id
, &bus_endpoint_path
);
1235 /* Pass the fd to the exec_params so that the child process can upload the policy.
1236 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1237 * as the service is running. */
1238 exec_params
.bus_endpoint_fd
= s
->bus_endpoint_fd
= r
;
1241 exec_params
.argv
= argv
;
1242 exec_params
.fds
= fds
;
1243 exec_params
.fd_names
= fd_names
;
1244 exec_params
.n_fds
= n_fds
;
1245 exec_params
.environment
= final_env
;
1246 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1247 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1248 exec_params
.cgroup_path
= path
;
1249 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1250 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1251 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1252 exec_params
.bus_endpoint_path
= bus_endpoint_path
;
1253 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1254 if (s
->type
== SERVICE_IDLE
)
1255 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1256 exec_params
.stdin_fd
= s
->stdin_fd
;
1257 exec_params
.stdout_fd
= s
->stdout_fd
;
1258 exec_params
.stderr_fd
= s
->stderr_fd
;
1260 r
= exec_spawn(UNIT(s
),
1269 r
= unit_watch_pid(UNIT(s
), pid
);
1271 /* FIXME: we need to do something here */
1280 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1285 static int main_pid_good(Service
*s
) {
1288 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1291 /* If we know the pid file, then let's just check if it is
1293 if (s
->main_pid_known
) {
1295 /* If it's an alien child let's check if it is still
1297 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1298 return pid_is_alive(s
->main_pid
);
1300 /* .. otherwise assume we'll get a SIGCHLD for it,
1301 * which we really should wait for to collect exit
1302 * status and code */
1303 return s
->main_pid
> 0;
1306 /* We don't know the pid */
1310 _pure_
static int control_pid_good(Service
*s
) {
1313 return s
->control_pid
> 0;
1316 static int cgroup_good(Service
*s
) {
1321 if (!UNIT(s
)->cgroup_path
)
1324 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1331 static bool service_shall_restart(Service
*s
) {
1334 /* Don't restart after manual stops */
1335 if (s
->forbid_restart
)
1338 /* Never restart if this is configured as special exception */
1339 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1342 /* Restart if the exit code/status are configured as restart triggers */
1343 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1346 switch (s
->restart
) {
1348 case SERVICE_RESTART_NO
:
1351 case SERVICE_RESTART_ALWAYS
:
1354 case SERVICE_RESTART_ON_SUCCESS
:
1355 return s
->result
== SERVICE_SUCCESS
;
1357 case SERVICE_RESTART_ON_FAILURE
:
1358 return s
->result
!= SERVICE_SUCCESS
;
1360 case SERVICE_RESTART_ON_ABNORMAL
:
1361 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1363 case SERVICE_RESTART_ON_WATCHDOG
:
1364 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1366 case SERVICE_RESTART_ON_ABORT
:
1367 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1370 assert_not_reached("unknown restart setting");
1374 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1378 if (f
!= SERVICE_SUCCESS
)
1381 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1383 if (s
->result
!= SERVICE_SUCCESS
) {
1384 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1385 failure_action(UNIT(s
)->manager
, s
->failure_action
, s
->reboot_arg
);
1388 if (allow_restart
&& service_shall_restart(s
)) {
1390 r
= service_arm_timer(s
, s
->restart_usec
);
1394 service_set_state(s
, SERVICE_AUTO_RESTART
);
1397 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1398 s
->forbid_restart
= false;
1400 /* We want fresh tmpdirs in case service is started again immediately */
1401 exec_runtime_destroy(s
->exec_runtime
);
1402 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1404 /* Also, remove the runtime directory in */
1405 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1407 /* Try to delete the pid file. At this point it will be
1408 * out-of-date, and some software might be confused by it, so
1409 * let's remove it. */
1411 unlink_noerrno(s
->pid_file
);
1416 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1417 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1420 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1424 if (f
!= SERVICE_SUCCESS
)
1427 service_unwatch_control_pid(s
);
1428 unit_watch_all_pids(UNIT(s
));
1430 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1431 if (s
->control_command
) {
1432 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1434 r
= service_spawn(s
,
1436 s
->timeout_stop_usec
,
1438 !s
->permissions_start_only
,
1439 !s
->root_directory_start_only
,
1446 service_set_state(s
, SERVICE_STOP_POST
);
1448 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1453 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1454 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1457 static int state_to_kill_operation(ServiceState state
) {
1460 case SERVICE_STOP_SIGABRT
:
1463 case SERVICE_STOP_SIGTERM
:
1464 case SERVICE_FINAL_SIGTERM
:
1465 return KILL_TERMINATE
;
1467 case SERVICE_STOP_SIGKILL
:
1468 case SERVICE_FINAL_SIGKILL
:
1472 return _KILL_OPERATION_INVALID
;
1476 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1481 if (f
!= SERVICE_SUCCESS
)
1484 unit_watch_all_pids(UNIT(s
));
1486 r
= unit_kill_context(
1489 state_to_kill_operation(state
),
1498 if (s
->timeout_stop_usec
> 0) {
1499 r
= service_arm_timer(s
, s
->timeout_stop_usec
);
1504 service_set_state(s
, state
);
1505 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1506 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1507 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1508 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1509 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1510 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1512 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1517 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1519 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1520 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1522 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1525 static void service_enter_stop_by_notify(Service
*s
) {
1528 unit_watch_all_pids(UNIT(s
));
1530 if (s
->timeout_stop_usec
> 0)
1531 service_arm_timer(s
, s
->timeout_stop_usec
);
1533 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1534 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1537 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1542 if (f
!= SERVICE_SUCCESS
)
1545 service_unwatch_control_pid(s
);
1546 unit_watch_all_pids(UNIT(s
));
1548 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1549 if (s
->control_command
) {
1550 s
->control_command_id
= SERVICE_EXEC_STOP
;
1552 r
= service_spawn(s
,
1554 s
->timeout_stop_usec
,
1556 !s
->permissions_start_only
,
1557 !s
->root_directory_start_only
,
1564 service_set_state(s
, SERVICE_STOP
);
1566 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1571 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1572 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1575 static bool service_good(Service
*s
) {
1579 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1582 main_pid_ok
= main_pid_good(s
);
1583 if (main_pid_ok
> 0) /* It's alive */
1585 if (main_pid_ok
== 0) /* It's dead */
1588 /* OK, we don't know anything about the main PID, maybe
1589 * because there is none. Let's check the control group
1592 return cgroup_good(s
) != 0;
1595 static void service_enter_running(Service
*s
, ServiceResult f
) {
1598 if (f
!= SERVICE_SUCCESS
)
1601 if (service_good(s
)) {
1603 /* If there are any queued up sd_notify()
1604 * notifications, process them now */
1605 if (s
->notify_state
== NOTIFY_RELOADING
)
1606 service_enter_reload_by_notify(s
);
1607 else if (s
->notify_state
== NOTIFY_STOPPING
)
1608 service_enter_stop_by_notify(s
);
1610 service_set_state(s
, SERVICE_RUNNING
);
1612 } else if (s
->remain_after_exit
)
1613 service_set_state(s
, SERVICE_EXITED
);
1615 service_enter_stop(s
, SERVICE_SUCCESS
);
1618 static void service_enter_start_post(Service
*s
) {
1622 service_unwatch_control_pid(s
);
1623 service_reset_watchdog(s
);
1625 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1626 if (s
->control_command
) {
1627 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1629 r
= service_spawn(s
,
1631 s
->timeout_start_usec
,
1633 !s
->permissions_start_only
,
1634 !s
->root_directory_start_only
,
1641 service_set_state(s
, SERVICE_START_POST
);
1643 service_enter_running(s
, SERVICE_SUCCESS
);
1648 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1649 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1652 static void service_kill_control_processes(Service
*s
) {
1655 if (!UNIT(s
)->cgroup_path
)
1658 p
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1659 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, p
, SIGKILL
, true, true, true, NULL
);
1662 static void service_enter_start(Service
*s
) {
1669 service_unwatch_control_pid(s
);
1670 service_unwatch_main_pid(s
);
1672 /* We want to ensure that nobody leaks processes from
1673 * START_PRE here, so let's go on a killing spree, People
1674 * should not spawn long running processes from START_PRE. */
1675 service_kill_control_processes(s
);
1677 if (s
->type
== SERVICE_FORKING
) {
1678 s
->control_command_id
= SERVICE_EXEC_START
;
1679 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1681 s
->main_command
= NULL
;
1683 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1684 s
->control_command
= NULL
;
1686 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1690 assert(s
->type
== SERVICE_ONESHOT
);
1691 service_enter_start_post(s
);
1695 r
= service_spawn(s
,
1697 IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_NOTIFY
, SERVICE_ONESHOT
) ? s
->timeout_start_usec
: 0,
1707 if (s
->type
== SERVICE_SIMPLE
|| s
->type
== SERVICE_IDLE
) {
1708 /* For simple services we immediately start
1709 * the START_POST binaries. */
1711 service_set_main_pid(s
, pid
);
1712 service_enter_start_post(s
);
1714 } else if (s
->type
== SERVICE_FORKING
) {
1716 /* For forking services we wait until the start
1717 * process exited. */
1719 s
->control_pid
= pid
;
1720 service_set_state(s
, SERVICE_START
);
1722 } else if (s
->type
== SERVICE_ONESHOT
||
1723 s
->type
== SERVICE_DBUS
||
1724 s
->type
== SERVICE_NOTIFY
) {
1726 /* For oneshot services we wait until the start
1727 * process exited, too, but it is our main process. */
1729 /* For D-Bus services we know the main pid right away,
1730 * but wait for the bus name to appear on the
1731 * bus. Notify services are similar. */
1733 service_set_main_pid(s
, pid
);
1734 service_set_state(s
, SERVICE_START
);
1736 assert_not_reached("Unknown service type");
1741 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1742 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1745 static void service_enter_start_pre(Service
*s
) {
1750 service_unwatch_control_pid(s
);
1752 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1753 if (s
->control_command
) {
1754 /* Before we start anything, let's clear up what might
1755 * be left from previous runs. */
1756 service_kill_control_processes(s
);
1758 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1760 r
= service_spawn(s
,
1762 s
->timeout_start_usec
,
1764 !s
->permissions_start_only
,
1765 !s
->root_directory_start_only
,
1772 service_set_state(s
, SERVICE_START_PRE
);
1774 service_enter_start(s
);
1779 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1780 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1783 static void service_enter_restart(Service
*s
) {
1784 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1789 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1790 /* Don't restart things if we are going down anyway */
1791 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
1793 r
= service_arm_timer(s
, s
->restart_usec
);
1800 /* Any units that are bound to this service must also be
1801 * restarted. We use JOB_RESTART (instead of the more obvious
1802 * JOB_START) here so that those dependency jobs will be added
1804 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, false, &error
, NULL
);
1808 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1809 * it will be canceled as part of the service_stop() call that
1810 * is executed as part of JOB_RESTART. */
1812 log_unit_debug(UNIT(s
), "Scheduled restart job.");
1816 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
1817 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1820 static void service_enter_reload_by_notify(Service
*s
) {
1823 if (s
->timeout_start_usec
> 0)
1824 service_arm_timer(s
, s
->timeout_start_usec
);
1826 service_set_state(s
, SERVICE_RELOAD
);
1829 static void service_enter_reload(Service
*s
) {
1834 service_unwatch_control_pid(s
);
1835 s
->reload_result
= SERVICE_SUCCESS
;
1837 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
1838 if (s
->control_command
) {
1839 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
1841 r
= service_spawn(s
,
1843 s
->timeout_start_usec
,
1845 !s
->permissions_start_only
,
1846 !s
->root_directory_start_only
,
1853 service_set_state(s
, SERVICE_RELOAD
);
1855 service_enter_running(s
, SERVICE_SUCCESS
);
1860 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
1861 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1862 service_enter_running(s
, SERVICE_SUCCESS
);
1865 static void service_run_next_control(Service
*s
) {
1869 assert(s
->control_command
);
1870 assert(s
->control_command
->command_next
);
1872 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
1874 s
->control_command
= s
->control_command
->command_next
;
1875 service_unwatch_control_pid(s
);
1877 r
= service_spawn(s
,
1879 IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
,
1881 !s
->permissions_start_only
,
1882 !s
->root_directory_start_only
,
1883 s
->control_command_id
== SERVICE_EXEC_START_PRE
||
1884 s
->control_command_id
== SERVICE_EXEC_STOP_POST
,
1893 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
1895 if (s
->state
== SERVICE_START_PRE
)
1896 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1897 else if (s
->state
== SERVICE_STOP
)
1898 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1899 else if (s
->state
== SERVICE_STOP_POST
)
1900 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1901 else if (s
->state
== SERVICE_RELOAD
) {
1902 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1903 service_enter_running(s
, SERVICE_SUCCESS
);
1905 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1908 static void service_run_next_main(Service
*s
) {
1913 assert(s
->main_command
);
1914 assert(s
->main_command
->command_next
);
1915 assert(s
->type
== SERVICE_ONESHOT
);
1917 s
->main_command
= s
->main_command
->command_next
;
1918 service_unwatch_main_pid(s
);
1920 r
= service_spawn(s
,
1922 s
->timeout_start_usec
,
1932 service_set_main_pid(s
, pid
);
1937 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
1938 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1941 static int service_start_limit_test(Service
*s
) {
1944 if (ratelimit_test(&s
->start_limit
))
1947 log_unit_warning(UNIT(s
), "Start request repeated too quickly.");
1949 return failure_action(UNIT(s
)->manager
, s
->start_limit_action
, s
->reboot_arg
);
1952 static int service_start(Unit
*u
) {
1953 Service
*s
= SERVICE(u
);
1958 /* We cannot fulfill this request right now, try again later
1960 if (IN_SET(s
->state
,
1961 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1962 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
1965 /* Already on it! */
1966 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
1969 /* A service that will be restarted must be stopped first to
1970 * trigger BindsTo and/or OnFailure dependencies. If a user
1971 * does not want to wait for the holdoff time to elapse, the
1972 * service should be manually restarted, not started. We
1973 * simply return EAGAIN here, so that any start jobs stay
1974 * queued, and assume that the auto restart timer will
1975 * eventually trigger the restart. */
1976 if (s
->state
== SERVICE_AUTO_RESTART
)
1979 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
1981 /* Make sure we don't enter a busy loop of some kind. */
1982 r
= service_start_limit_test(s
);
1984 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT
, false);
1988 s
->result
= SERVICE_SUCCESS
;
1989 s
->reload_result
= SERVICE_SUCCESS
;
1990 s
->main_pid_known
= false;
1991 s
->main_pid_alien
= false;
1992 s
->forbid_restart
= false;
1993 s
->reset_cpu_usage
= true;
1995 s
->status_text
= mfree(s
->status_text
);
1996 s
->status_errno
= 0;
1998 s
->notify_state
= NOTIFY_UNKNOWN
;
2000 service_enter_start_pre(s
);
2004 static int service_stop(Unit
*u
) {
2005 Service
*s
= SERVICE(u
);
2009 /* Don't create restart jobs from manual stops. */
2010 s
->forbid_restart
= true;
2013 if (IN_SET(s
->state
,
2014 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2015 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2018 /* A restart will be scheduled or is in progress. */
2019 if (s
->state
== SERVICE_AUTO_RESTART
) {
2020 service_set_state(s
, SERVICE_DEAD
);
2024 /* If there's already something running we go directly into
2026 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2027 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2031 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2033 service_enter_stop(s
, SERVICE_SUCCESS
);
2037 static int service_reload(Unit
*u
) {
2038 Service
*s
= SERVICE(u
);
2042 assert(s
->state
== SERVICE_RUNNING
|| s
->state
== SERVICE_EXITED
);
2044 service_enter_reload(s
);
2048 _pure_
static bool service_can_reload(Unit
*u
) {
2049 Service
*s
= SERVICE(u
);
2053 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2056 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2057 Service
*s
= SERVICE(u
);
2065 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2066 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2067 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2069 if (s
->control_pid
> 0)
2070 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2072 if (s
->main_pid_known
&& s
->main_pid
> 0)
2073 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2075 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2076 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2078 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2082 /* FIXME: There's a minor uncleanliness here: if there are
2083 * multiple commands attached here, we will start from the
2084 * first one again */
2085 if (s
->control_command_id
>= 0)
2086 unit_serialize_item(u
, f
, "control-command", service_exec_command_to_string(s
->control_command_id
));
2088 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2091 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2094 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2098 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2101 r
= unit_serialize_item_fd(u
, f
, fds
, "endpoint-fd", s
->bus_endpoint_fd
);
2105 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2106 _cleanup_free_
char *c
= NULL
;
2109 copy
= fdset_put_dup(fds
, fs
->fd
);
2113 c
= cescape(fs
->fdname
);
2115 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2118 if (s
->main_exec_status
.pid
> 0) {
2119 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2120 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2121 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2123 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2124 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2125 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2129 if (dual_timestamp_is_set(&s
->watchdog_timestamp
))
2130 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2132 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2137 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2138 Service
*s
= SERVICE(u
);
2146 if (streq(key
, "state")) {
2149 state
= service_state_from_string(value
);
2151 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2153 s
->deserialized_state
= state
;
2154 } else if (streq(key
, "result")) {
2157 f
= service_result_from_string(value
);
2159 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2160 else if (f
!= SERVICE_SUCCESS
)
2163 } else if (streq(key
, "reload-result")) {
2166 f
= service_result_from_string(value
);
2168 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2169 else if (f
!= SERVICE_SUCCESS
)
2170 s
->reload_result
= f
;
2172 } else if (streq(key
, "control-pid")) {
2175 if (parse_pid(value
, &pid
) < 0)
2176 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2178 s
->control_pid
= pid
;
2179 } else if (streq(key
, "main-pid")) {
2182 if (parse_pid(value
, &pid
) < 0)
2183 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2185 service_set_main_pid(s
, pid
);
2186 unit_watch_pid(UNIT(s
), pid
);
2188 } else if (streq(key
, "main-pid-known")) {
2191 b
= parse_boolean(value
);
2193 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2195 s
->main_pid_known
= b
;
2196 } else if (streq(key
, "bus-name-good")) {
2199 b
= parse_boolean(value
);
2201 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2203 s
->bus_name_good
= b
;
2204 } else if (streq(key
, "status-text")) {
2207 r
= cunescape(value
, 0, &t
);
2209 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2211 free(s
->status_text
);
2215 } else if (streq(key
, "control-command")) {
2216 ServiceExecCommand id
;
2218 id
= service_exec_command_from_string(value
);
2220 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2222 s
->control_command_id
= id
;
2223 s
->control_command
= s
->exec_command
[id
];
2225 } else if (streq(key
, "socket-fd")) {
2228 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2229 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2231 asynchronous_close(s
->socket_fd
);
2232 s
->socket_fd
= fdset_remove(fds
, fd
);
2234 } else if (streq(key
, "endpoint-fd")) {
2237 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2238 log_unit_debug(u
, "Failed to parse endpoint-fd value: %s", value
);
2240 safe_close(s
->bus_endpoint_fd
);
2241 s
->bus_endpoint_fd
= fdset_remove(fds
, fd
);
2243 } else if (streq(key
, "fd-store-fd")) {
2248 pf
= strcspn(value
, WHITESPACE
);
2249 fdv
= strndupa(value
, pf
);
2251 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2252 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2254 _cleanup_free_
char *t
= NULL
;
2258 fdn
+= strspn(fdn
, WHITESPACE
);
2259 (void) cunescape(fdn
, 0, &t
);
2261 r
= service_add_fd_store(s
, fd
, t
);
2263 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2265 fdset_remove(fds
, fd
);
2268 } else if (streq(key
, "main-exec-status-pid")) {
2271 if (parse_pid(value
, &pid
) < 0)
2272 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2274 s
->main_exec_status
.pid
= pid
;
2275 } else if (streq(key
, "main-exec-status-code")) {
2278 if (safe_atoi(value
, &i
) < 0)
2279 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2281 s
->main_exec_status
.code
= i
;
2282 } else if (streq(key
, "main-exec-status-status")) {
2285 if (safe_atoi(value
, &i
) < 0)
2286 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2288 s
->main_exec_status
.status
= i
;
2289 } else if (streq(key
, "main-exec-status-start"))
2290 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2291 else if (streq(key
, "main-exec-status-exit"))
2292 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2293 else if (streq(key
, "watchdog-timestamp"))
2294 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2295 else if (streq(key
, "forbid-restart")) {
2298 b
= parse_boolean(value
);
2300 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2302 s
->forbid_restart
= b
;
2303 } else if (streq(key
, "stdin-fd")) {
2306 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2307 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2309 asynchronous_close(s
->stdin_fd
);
2310 s
->stdin_fd
= fdset_remove(fds
, fd
);
2312 } else if (streq(key
, "stdout-fd")) {
2315 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2316 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2318 asynchronous_close(s
->stdout_fd
);
2319 s
->stdout_fd
= fdset_remove(fds
, fd
);
2321 } else if (streq(key
, "stderr-fd")) {
2324 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2325 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2327 asynchronous_close(s
->stderr_fd
);
2328 s
->stderr_fd
= fdset_remove(fds
, fd
);
2331 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2336 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2337 const UnitActiveState
*table
;
2341 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2343 return table
[SERVICE(u
)->state
];
2346 static const char *service_sub_state_to_string(Unit
*u
) {
2349 return service_state_to_string(SERVICE(u
)->state
);
2352 static bool service_check_gc(Unit
*u
) {
2353 Service
*s
= SERVICE(u
);
2357 /* Never clean up services that still have a process around,
2358 * even if the service is formally dead. */
2359 if (cgroup_good(s
) > 0 ||
2360 main_pid_good(s
) > 0 ||
2361 control_pid_good(s
) > 0)
2367 _pure_
static bool service_check_snapshot(Unit
*u
) {
2368 Service
*s
= SERVICE(u
);
2372 return s
->socket_fd
< 0;
2375 static int service_retry_pid_file(Service
*s
) {
2378 assert(s
->pid_file
);
2379 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2381 r
= service_load_pid_file(s
, false);
2385 service_unwatch_pid_file(s
);
2387 service_enter_running(s
, SERVICE_SUCCESS
);
2391 static int service_watch_pid_file(Service
*s
) {
2394 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2396 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2400 /* the pidfile might have appeared just before we set the watch */
2401 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2402 service_retry_pid_file(s
);
2406 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2407 service_unwatch_pid_file(s
);
2411 static int service_demand_pid_file(Service
*s
) {
2414 assert(s
->pid_file
);
2415 assert(!s
->pid_file_pathspec
);
2417 ps
= new0(PathSpec
, 1);
2422 ps
->path
= strdup(s
->pid_file
);
2428 path_kill_slashes(ps
->path
);
2430 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2431 * keep their PID file open all the time. */
2432 ps
->type
= PATH_MODIFIED
;
2433 ps
->inotify_fd
= -1;
2435 s
->pid_file_pathspec
= ps
;
2437 return service_watch_pid_file(s
);
2440 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2441 PathSpec
*p
= userdata
;
2446 s
= SERVICE(p
->unit
);
2450 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2451 assert(s
->pid_file_pathspec
);
2452 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2454 log_unit_debug(UNIT(s
), "inotify event");
2456 if (path_spec_fd_event(p
, events
) < 0)
2459 if (service_retry_pid_file(s
) == 0)
2462 if (service_watch_pid_file(s
) < 0)
2468 service_unwatch_pid_file(s
);
2469 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2473 static void service_notify_cgroup_empty_event(Unit
*u
) {
2474 Service
*s
= SERVICE(u
);
2478 log_unit_debug(u
, "cgroup is empty");
2482 /* Waiting for SIGCHLD is usually more interesting,
2483 * because it includes return codes/signals. Which is
2484 * why we ignore the cgroup events for most cases,
2485 * except when we don't know pid which to expect the
2489 case SERVICE_START_POST
:
2490 /* If we were hoping for the daemon to write its PID file,
2491 * we can give up now. */
2492 if (s
->pid_file_pathspec
) {
2493 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2495 service_unwatch_pid_file(s
);
2496 if (s
->state
== SERVICE_START
)
2497 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2499 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2503 case SERVICE_RUNNING
:
2504 /* service_enter_running() will figure out what to do */
2505 service_enter_running(s
, SERVICE_SUCCESS
);
2508 case SERVICE_STOP_SIGABRT
:
2509 case SERVICE_STOP_SIGTERM
:
2510 case SERVICE_STOP_SIGKILL
:
2512 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2513 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2517 case SERVICE_STOP_POST
:
2518 case SERVICE_FINAL_SIGTERM
:
2519 case SERVICE_FINAL_SIGKILL
:
2520 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2521 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2530 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2531 Service
*s
= SERVICE(u
);
2537 if (UNIT(s
)->fragment_path
? is_clean_exit(code
, status
, &s
->success_status
) :
2538 is_clean_exit_lsb(code
, status
, &s
->success_status
))
2539 f
= SERVICE_SUCCESS
;
2540 else if (code
== CLD_EXITED
)
2541 f
= SERVICE_FAILURE_EXIT_CODE
;
2542 else if (code
== CLD_KILLED
)
2543 f
= SERVICE_FAILURE_SIGNAL
;
2544 else if (code
== CLD_DUMPED
)
2545 f
= SERVICE_FAILURE_CORE_DUMP
;
2547 assert_not_reached("Unknown code");
2549 if (s
->main_pid
== pid
) {
2550 /* Forking services may occasionally move to a new PID.
2551 * As long as they update the PID file before exiting the old
2552 * PID, they're fine. */
2553 if (service_load_pid_file(s
, false) == 0)
2557 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2559 if (s
->main_command
) {
2560 /* If this is not a forking service than the
2561 * main process got started and hence we copy
2562 * the exit status so that it is recorded both
2563 * as main and as control process exit
2566 s
->main_command
->exec_status
= s
->main_exec_status
;
2568 if (s
->main_command
->ignore
)
2569 f
= SERVICE_SUCCESS
;
2570 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
2572 /* If this is a forked process, then we should
2573 * ignore the return value if this was
2574 * configured for the starter process */
2576 if (s
->exec_command
[SERVICE_EXEC_START
]->ignore
)
2577 f
= SERVICE_SUCCESS
;
2580 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
,
2582 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
2583 sigchld_code_to_string(code
), status
,
2584 strna(code
== CLD_EXITED
2585 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
2586 : signal_to_string(status
))),
2587 "EXIT_CODE=%s", sigchld_code_to_string(code
),
2588 "EXIT_STATUS=%i", status
,
2591 if (f
!= SERVICE_SUCCESS
)
2594 if (s
->main_command
&&
2595 s
->main_command
->command_next
&&
2596 f
== SERVICE_SUCCESS
) {
2598 /* There is another command to *
2599 * execute, so let's do that. */
2601 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
2602 service_run_next_main(s
);
2606 /* The service exited, so the service is officially
2608 s
->main_command
= NULL
;
2612 case SERVICE_START_POST
:
2613 case SERVICE_RELOAD
:
2615 /* Need to wait until the operation is
2620 if (s
->type
== SERVICE_ONESHOT
) {
2621 /* This was our main goal, so let's go on */
2622 if (f
== SERVICE_SUCCESS
)
2623 service_enter_start_post(s
);
2625 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2631 case SERVICE_RUNNING
:
2632 service_enter_running(s
, f
);
2635 case SERVICE_STOP_SIGABRT
:
2636 case SERVICE_STOP_SIGTERM
:
2637 case SERVICE_STOP_SIGKILL
:
2639 if (!control_pid_good(s
))
2640 service_enter_stop_post(s
, f
);
2642 /* If there is still a control process, wait for that first */
2645 case SERVICE_STOP_POST
:
2646 case SERVICE_FINAL_SIGTERM
:
2647 case SERVICE_FINAL_SIGKILL
:
2649 if (!control_pid_good(s
))
2650 service_enter_dead(s
, f
, true);
2654 assert_not_reached("Uh, main process died at wrong time.");
2658 } else if (s
->control_pid
== pid
) {
2661 if (s
->control_command
) {
2662 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2664 if (s
->control_command
->ignore
)
2665 f
= SERVICE_SUCCESS
;
2668 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2669 "Control process exited, code=%s status=%i",
2670 sigchld_code_to_string(code
), status
);
2672 if (f
!= SERVICE_SUCCESS
)
2675 /* Immediately get rid of the cgroup, so that the
2676 * kernel doesn't delay the cgroup empty messages for
2677 * the service cgroup any longer than necessary */
2678 service_kill_control_processes(s
);
2680 if (s
->control_command
&&
2681 s
->control_command
->command_next
&&
2682 f
== SERVICE_SUCCESS
) {
2684 /* There is another command to *
2685 * execute, so let's do that. */
2687 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
2688 service_run_next_control(s
);
2691 /* No further commands for this step, so let's
2692 * figure out what to do next */
2694 s
->control_command
= NULL
;
2695 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
2697 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
2701 case SERVICE_START_PRE
:
2702 if (f
== SERVICE_SUCCESS
)
2703 service_enter_start(s
);
2705 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2709 if (s
->type
!= SERVICE_FORKING
)
2710 /* Maybe spurious event due to a reload that changed the type? */
2713 if (f
!= SERVICE_SUCCESS
) {
2714 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2719 bool has_start_post
;
2722 /* Let's try to load the pid file here if we can.
2723 * The PID file might actually be created by a START_POST
2724 * script. In that case don't worry if the loading fails. */
2726 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
2727 r
= service_load_pid_file(s
, !has_start_post
);
2728 if (!has_start_post
&& r
< 0) {
2729 r
= service_demand_pid_file(s
);
2730 if (r
< 0 || !cgroup_good(s
))
2731 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2735 (void) service_search_main_pid(s
);
2737 service_enter_start_post(s
);
2740 case SERVICE_START_POST
:
2741 if (f
!= SERVICE_SUCCESS
) {
2742 service_enter_stop(s
, f
);
2749 r
= service_load_pid_file(s
, true);
2751 r
= service_demand_pid_file(s
);
2752 if (r
< 0 || !cgroup_good(s
))
2753 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2757 (void) service_search_main_pid(s
);
2759 service_enter_running(s
, SERVICE_SUCCESS
);
2762 case SERVICE_RELOAD
:
2763 if (f
== SERVICE_SUCCESS
) {
2764 service_load_pid_file(s
, true);
2765 (void) service_search_main_pid(s
);
2768 s
->reload_result
= f
;
2769 service_enter_running(s
, SERVICE_SUCCESS
);
2773 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
2776 case SERVICE_STOP_SIGABRT
:
2777 case SERVICE_STOP_SIGTERM
:
2778 case SERVICE_STOP_SIGKILL
:
2779 if (main_pid_good(s
) <= 0)
2780 service_enter_stop_post(s
, f
);
2782 /* If there is still a service
2783 * process around, wait until
2784 * that one quit, too */
2787 case SERVICE_STOP_POST
:
2788 case SERVICE_FINAL_SIGTERM
:
2789 case SERVICE_FINAL_SIGKILL
:
2790 if (main_pid_good(s
) <= 0)
2791 service_enter_dead(s
, f
, true);
2795 assert_not_reached("Uh, control process died at wrong time.");
2800 /* Notify clients about changed exit status */
2801 unit_add_to_dbus_queue(u
);
2803 /* We got one SIGCHLD for the service, let's watch all
2804 * processes that are now running of the service, and watch
2805 * that. Among the PIDs we then watch will be children
2806 * reassigned to us, which hopefully allows us to identify
2807 * when all children are gone */
2808 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
2809 unit_watch_all_pids(u
);
2811 /* If the PID set is empty now, then let's finish this off */
2812 if (set_isempty(u
->pids
))
2813 service_notify_cgroup_empty_event(u
);
2816 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2817 Service
*s
= SERVICE(userdata
);
2820 assert(source
== s
->timer_event_source
);
2824 case SERVICE_START_PRE
:
2826 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
2827 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2830 case SERVICE_START_POST
:
2831 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
2832 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
2835 case SERVICE_RELOAD
:
2836 log_unit_warning(UNIT(s
), "Reload operation timed out. Stopping.");
2837 service_unwatch_control_pid(s
);
2838 service_kill_control_processes(s
);
2839 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
2840 service_enter_running(s
, SERVICE_SUCCESS
);
2844 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2845 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2848 case SERVICE_STOP_SIGABRT
:
2849 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
2850 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2853 case SERVICE_STOP_SIGTERM
:
2854 if (s
->kill_context
.send_sigkill
) {
2855 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
2856 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2858 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
2859 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2864 case SERVICE_STOP_SIGKILL
:
2865 /* Uh, we sent a SIGKILL and it is still not gone?
2866 * Must be something we cannot kill, so let's just be
2867 * weirded out and continue */
2869 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2870 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2873 case SERVICE_STOP_POST
:
2874 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
2875 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2878 case SERVICE_FINAL_SIGTERM
:
2879 if (s
->kill_context
.send_sigkill
) {
2880 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
2881 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2883 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
2884 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
2889 case SERVICE_FINAL_SIGKILL
:
2890 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
2891 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
2894 case SERVICE_AUTO_RESTART
:
2895 log_unit_info(UNIT(s
),
2896 s
->restart_usec
> 0 ?
2897 "Service hold-off time over, scheduling restart." :
2898 "Service has no hold-off time, scheduling restart.");
2899 service_enter_restart(s
);
2903 assert_not_reached("Timeout at wrong time.");
2909 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2910 Service
*s
= SERVICE(userdata
);
2911 char t
[FORMAT_TIMESPAN_MAX
];
2914 assert(source
== s
->watchdog_event_source
);
2916 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
2917 format_timespan(t
, sizeof(t
), s
->watchdog_usec
, 1));
2919 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
2924 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
2925 Service
*s
= SERVICE(u
);
2926 _cleanup_free_
char *cc
= NULL
;
2927 bool notify_dbus
= false;
2932 cc
= strv_join(tags
, ", ");
2934 if (s
->notify_access
== NOTIFY_NONE
) {
2935 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
2937 } else if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
2938 if (s
->main_pid
!= 0)
2939 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
2941 log_unit_debug(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID which is currently not known", pid
);
2944 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
2946 /* Interpret MAINPID= */
2947 e
= strv_find_startswith(tags
, "MAINPID=");
2948 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
2949 if (parse_pid(e
, &pid
) < 0)
2950 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
2952 service_set_main_pid(s
, pid
);
2953 unit_watch_pid(UNIT(s
), pid
);
2958 /* Interpret RELOADING= */
2959 if (strv_find(tags
, "RELOADING=1")) {
2961 s
->notify_state
= NOTIFY_RELOADING
;
2963 if (s
->state
== SERVICE_RUNNING
)
2964 service_enter_reload_by_notify(s
);
2969 /* Interpret READY= */
2970 if (strv_find(tags
, "READY=1")) {
2972 s
->notify_state
= NOTIFY_READY
;
2974 /* Type=notify services inform us about completed
2975 * initialization with READY=1 */
2976 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
2977 service_enter_start_post(s
);
2979 /* Sending READY=1 while we are reloading informs us
2980 * that the reloading is complete */
2981 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
2982 service_enter_running(s
, SERVICE_SUCCESS
);
2987 /* Interpret STOPPING= */
2988 if (strv_find(tags
, "STOPPING=1")) {
2990 s
->notify_state
= NOTIFY_STOPPING
;
2992 if (s
->state
== SERVICE_RUNNING
)
2993 service_enter_stop_by_notify(s
);
2998 /* Interpret STATUS= */
2999 e
= strv_find_startswith(tags
, "STATUS=");
3001 _cleanup_free_
char *t
= NULL
;
3004 if (!utf8_is_valid(e
))
3005 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3013 if (!streq_ptr(s
->status_text
, t
)) {
3015 free(s
->status_text
);
3023 /* Interpret ERRNO= */
3024 e
= strv_find_startswith(tags
, "ERRNO=");
3028 if (safe_atoi(e
, &status_errno
) < 0 || status_errno
< 0)
3029 log_unit_warning(u
, "Failed to parse ERRNO= field in notification message: %s", e
);
3031 if (s
->status_errno
!= status_errno
) {
3032 s
->status_errno
= status_errno
;
3038 /* Interpret WATCHDOG= */
3039 if (strv_find(tags
, "WATCHDOG=1"))
3040 service_reset_watchdog(s
);
3042 if (strv_find(tags
, "FDSTORE=1")) {
3045 name
= strv_find_startswith(tags
, "FDNAME=");
3046 if (name
&& !fdname_is_valid(name
)) {
3047 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3051 service_add_fd_store_set(s
, fds
, name
);
3054 /* Notify clients about changed status or main pid */
3056 unit_add_to_dbus_queue(u
);
3059 static int service_get_timeout(Unit
*u
, uint64_t *timeout
) {
3060 Service
*s
= SERVICE(u
);
3063 if (!s
->timer_event_source
)
3066 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
3073 static void service_bus_name_owner_change(
3076 const char *old_owner
,
3077 const char *new_owner
) {
3079 Service
*s
= SERVICE(u
);
3085 assert(streq(s
->bus_name
, name
));
3086 assert(old_owner
|| new_owner
);
3088 if (old_owner
&& new_owner
)
3089 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3091 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3093 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3095 s
->bus_name_good
= !!new_owner
;
3097 if (s
->type
== SERVICE_DBUS
) {
3099 /* service_enter_running() will figure out what to
3101 if (s
->state
== SERVICE_RUNNING
)
3102 service_enter_running(s
, SERVICE_SUCCESS
);
3103 else if (s
->state
== SERVICE_START
&& new_owner
)
3104 service_enter_start_post(s
);
3106 } else if (new_owner
&&
3108 (s
->state
== SERVICE_START
||
3109 s
->state
== SERVICE_START_POST
||
3110 s
->state
== SERVICE_RUNNING
||
3111 s
->state
== SERVICE_RELOAD
)) {
3113 _cleanup_bus_creds_unref_ sd_bus_creds
*creds
= NULL
;
3116 /* Try to acquire PID from bus service */
3118 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3120 r
= sd_bus_creds_get_pid(creds
, &pid
);
3122 log_unit_debug(u
, "D-Bus name %s is now owned by process %u", name
, (unsigned) pid
);
3124 service_set_main_pid(s
, pid
);
3125 unit_watch_pid(UNIT(s
), pid
);
3130 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3131 _cleanup_free_
char *peer
= NULL
;
3137 /* This is called by the socket code when instantiating a new
3138 * service for a stream socket and the socket needs to be
3141 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3144 if (s
->socket_fd
>= 0)
3147 if (s
->state
!= SERVICE_DEAD
)
3150 if (getpeername_pretty(fd
, &peer
) >= 0) {
3152 if (UNIT(s
)->description
) {
3153 _cleanup_free_
char *a
;
3155 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")", NULL
);
3159 r
= unit_set_description(UNIT(s
), a
);
3161 r
= unit_set_description(UNIT(s
), peer
);
3168 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3170 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3172 return unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false);
3175 static void service_reset_failed(Unit
*u
) {
3176 Service
*s
= SERVICE(u
);
3180 if (s
->state
== SERVICE_FAILED
)
3181 service_set_state(s
, SERVICE_DEAD
);
3183 s
->result
= SERVICE_SUCCESS
;
3184 s
->reload_result
= SERVICE_SUCCESS
;
3186 RATELIMIT_RESET(s
->start_limit
);
3189 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3190 Service
*s
= SERVICE(u
);
3192 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3195 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3196 [SERVICE_RESTART_NO
] = "no",
3197 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3198 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3199 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3200 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3201 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3202 [SERVICE_RESTART_ALWAYS
] = "always",
3205 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3207 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3208 [SERVICE_SIMPLE
] = "simple",
3209 [SERVICE_FORKING
] = "forking",
3210 [SERVICE_ONESHOT
] = "oneshot",
3211 [SERVICE_DBUS
] = "dbus",
3212 [SERVICE_NOTIFY
] = "notify",
3213 [SERVICE_IDLE
] = "idle"
3216 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3218 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3219 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3220 [SERVICE_EXEC_START
] = "ExecStart",
3221 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3222 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3223 [SERVICE_EXEC_STOP
] = "ExecStop",
3224 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3227 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3229 static const char* const notify_access_table
[_NOTIFY_ACCESS_MAX
] = {
3230 [NOTIFY_NONE
] = "none",
3231 [NOTIFY_MAIN
] = "main",
3232 [NOTIFY_ALL
] = "all"
3235 DEFINE_STRING_TABLE_LOOKUP(notify_access
, NotifyAccess
);
3237 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3238 [NOTIFY_UNKNOWN
] = "unknown",
3239 [NOTIFY_READY
] = "ready",
3240 [NOTIFY_RELOADING
] = "reloading",
3241 [NOTIFY_STOPPING
] = "stopping",
3244 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3246 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3247 [SERVICE_SUCCESS
] = "success",
3248 [SERVICE_FAILURE_RESOURCES
] = "resources",
3249 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3250 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3251 [SERVICE_FAILURE_SIGNAL
] = "signal",
3252 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3253 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3254 [SERVICE_FAILURE_START_LIMIT
] = "start-limit"
3257 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3259 const UnitVTable service_vtable
= {
3260 .object_size
= sizeof(Service
),
3261 .exec_context_offset
= offsetof(Service
, exec_context
),
3262 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3263 .kill_context_offset
= offsetof(Service
, kill_context
),
3264 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3270 .private_section
= "Service",
3272 .init
= service_init
,
3273 .done
= service_done
,
3274 .load
= service_load
,
3275 .release_resources
= service_release_resources
,
3277 .coldplug
= service_coldplug
,
3279 .dump
= service_dump
,
3281 .start
= service_start
,
3282 .stop
= service_stop
,
3283 .reload
= service_reload
,
3285 .can_reload
= service_can_reload
,
3287 .kill
= service_kill
,
3289 .serialize
= service_serialize
,
3290 .deserialize_item
= service_deserialize_item
,
3292 .active_state
= service_active_state
,
3293 .sub_state_to_string
= service_sub_state_to_string
,
3295 .check_gc
= service_check_gc
,
3296 .check_snapshot
= service_check_snapshot
,
3298 .sigchld_event
= service_sigchld_event
,
3300 .reset_failed
= service_reset_failed
,
3302 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3303 .notify_message
= service_notify_message
,
3305 .bus_name_owner_change
= service_bus_name_owner_change
,
3307 .bus_vtable
= bus_service_vtable
,
3308 .bus_set_property
= bus_service_set_property
,
3309 .bus_commit_properties
= bus_service_commit_properties
,
3311 .get_timeout
= service_get_timeout
,
3312 .can_transient
= true,
3314 .status_message_formats
= {
3315 .starting_stopping
= {
3316 [0] = "Starting %s...",
3317 [1] = "Stopping %s...",
3319 .finished_start_job
= {
3320 [JOB_DONE
] = "Started %s.",
3321 [JOB_FAILED
] = "Failed to start %s.",
3323 .finished_stop_job
= {
3324 [JOB_DONE
] = "Stopped %s.",
3325 [JOB_FAILED
] = "Stopped (with error) %s.",