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 if (!UNIT(s
)->default_dependencies
)
521 /* Add a number of automatic dependencies useful for the
522 * majority of services. */
524 if (UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
) {
525 /* First, pull in the really early boot stuff, and
526 * require it, so that we fail if we can't acquire
529 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true);
534 /* In the --user instance there's no sysinit.target,
535 * in that case require basic.target instead. */
537 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_BASIC_TARGET
, NULL
, true);
542 /* Second, if the rest of the base system is in the same
543 * transaction, order us after it, but do not pull it in or
544 * even require it. */
545 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_BASIC_TARGET
, NULL
, true);
549 /* Third, add us in for normal shutdown. */
550 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
553 static void service_fix_output(Service
*s
) {
556 /* If nothing has been explicitly configured, patch default
557 * output in. If input is socket/tty we avoid this however,
558 * since in that case we want output to default to the same
559 * place as we read input from. */
561 if (s
->exec_context
.std_error
== EXEC_OUTPUT_INHERIT
&&
562 s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
563 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
564 s
->exec_context
.std_error
= UNIT(s
)->manager
->default_std_error
;
566 if (s
->exec_context
.std_output
== EXEC_OUTPUT_INHERIT
&&
567 s
->exec_context
.std_input
== EXEC_INPUT_NULL
)
568 s
->exec_context
.std_output
= UNIT(s
)->manager
->default_std_output
;
571 static int service_setup_bus_name(Service
*s
) {
579 if (is_kdbus_available()) {
582 n
= strjoina(s
->bus_name
, ".busname");
583 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, n
, NULL
, true);
585 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency to .busname unit: %m");
588 /* If kdbus is not available, we know the dbus socket is required, hence pull it in, and require it */
589 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_REQUIRES
, SPECIAL_DBUS_SOCKET
, NULL
, true);
591 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
594 /* Regardless if kdbus is used or not, we always want to be ordered against dbus.socket if both are in the transaction. */
595 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_DBUS_SOCKET
, NULL
, true);
597 return log_unit_error_errno(UNIT(s
), r
, "Failed to add dependency on " SPECIAL_DBUS_SOCKET
": %m");
599 r
= unit_watch_bus_name(UNIT(s
), s
->bus_name
);
601 return log_unit_error_errno(UNIT(s
), r
, "Two services allocated for the same bus name %s, refusing operation.", s
->bus_name
);
603 return log_unit_error_errno(UNIT(s
), r
, "Cannot watch bus name %s: %m", s
->bus_name
);
608 static int service_add_extras(Service
*s
) {
613 if (s
->type
== _SERVICE_TYPE_INVALID
) {
614 /* Figure out a type automatically */
616 s
->type
= SERVICE_DBUS
;
617 else if (s
->exec_command
[SERVICE_EXEC_START
])
618 s
->type
= SERVICE_SIMPLE
;
620 s
->type
= SERVICE_ONESHOT
;
623 /* Oneshot services have disabled start timeout by default */
624 if (s
->type
== SERVICE_ONESHOT
&& !s
->start_timeout_defined
)
625 s
->timeout_start_usec
= 0;
627 service_fix_output(s
);
629 r
= unit_patch_contexts(UNIT(s
));
633 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
637 r
= unit_set_default_slice(UNIT(s
));
641 if (s
->type
== SERVICE_NOTIFY
&& s
->notify_access
== NOTIFY_NONE
)
642 s
->notify_access
= NOTIFY_MAIN
;
644 if (s
->watchdog_usec
> 0 && s
->notify_access
== NOTIFY_NONE
)
645 s
->notify_access
= NOTIFY_MAIN
;
647 r
= service_add_default_dependencies(s
);
651 r
= service_setup_bus_name(s
);
658 static int service_load(Unit
*u
) {
659 Service
*s
= SERVICE(u
);
664 /* Load a .service file */
665 r
= unit_load_fragment(u
);
669 /* Still nothing found? Then let's give up */
670 if (u
->load_state
== UNIT_STUB
)
673 /* This is a new unit? Then let's add in some extras */
674 if (u
->load_state
== UNIT_LOADED
) {
676 /* We were able to load something, then let's add in
677 * the dropin directories. */
678 r
= unit_load_dropin(u
);
682 /* This is a new unit? Then let's add in some
684 r
= service_add_extras(s
);
689 return service_verify(s
);
692 static void service_dump(Unit
*u
, FILE *f
, const char *prefix
) {
693 ServiceExecCommand c
;
694 Service
*s
= SERVICE(u
);
699 prefix
= strempty(prefix
);
700 prefix2
= strjoina(prefix
, "\t");
703 "%sService State: %s\n"
705 "%sReload Result: %s\n"
706 "%sPermissionsStartOnly: %s\n"
707 "%sRootDirectoryStartOnly: %s\n"
708 "%sRemainAfterExit: %s\n"
709 "%sGuessMainPID: %s\n"
712 "%sNotifyAccess: %s\n"
713 "%sNotifyState: %s\n",
714 prefix
, service_state_to_string(s
->state
),
715 prefix
, service_result_to_string(s
->result
),
716 prefix
, service_result_to_string(s
->reload_result
),
717 prefix
, yes_no(s
->permissions_start_only
),
718 prefix
, yes_no(s
->root_directory_start_only
),
719 prefix
, yes_no(s
->remain_after_exit
),
720 prefix
, yes_no(s
->guess_main_pid
),
721 prefix
, service_type_to_string(s
->type
),
722 prefix
, service_restart_to_string(s
->restart
),
723 prefix
, notify_access_to_string(s
->notify_access
),
724 prefix
, notify_state_to_string(s
->notify_state
));
726 if (s
->control_pid
> 0)
728 "%sControl PID: "PID_FMT
"\n",
729 prefix
, s
->control_pid
);
733 "%sMain PID: "PID_FMT
"\n"
734 "%sMain PID Known: %s\n"
735 "%sMain PID Alien: %s\n",
737 prefix
, yes_no(s
->main_pid_known
),
738 prefix
, yes_no(s
->main_pid_alien
));
743 prefix
, s
->pid_file
);
748 "%sBus Name Good: %s\n",
750 prefix
, yes_no(s
->bus_name_good
));
752 kill_context_dump(&s
->kill_context
, f
, prefix
);
753 exec_context_dump(&s
->exec_context
, f
, prefix
);
755 for (c
= 0; c
< _SERVICE_EXEC_COMMAND_MAX
; c
++) {
757 if (!s
->exec_command
[c
])
760 fprintf(f
, "%s-> %s:\n",
761 prefix
, service_exec_command_to_string(c
));
763 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
767 fprintf(f
, "%sStatus Text: %s\n",
768 prefix
, s
->status_text
);
770 if (s
->n_fd_store_max
> 0)
772 "%sFile Descriptor Store Max: %u\n"
773 "%sFile Descriptor Store Current: %u\n",
774 prefix
, s
->n_fd_store_max
,
775 prefix
, s
->n_fd_store
);
778 static int service_load_pid_file(Service
*s
, bool may_warn
) {
779 _cleanup_free_
char *k
= NULL
;
788 r
= read_one_line_file(s
->pid_file
, &k
);
791 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
));
795 r
= parse_pid(k
, &pid
);
798 log_unit_info_errno(UNIT(s
), r
, "Failed to read PID from file %s: %m", s
->pid_file
);
802 if (!pid_is_alive(pid
)) {
804 log_unit_info(UNIT(s
), "PID "PID_FMT
" read from file %s does not exist or is a zombie.", pid
, s
->pid_file
);
808 if (s
->main_pid_known
) {
809 if (pid
== s
->main_pid
)
812 log_unit_debug(UNIT(s
), "Main PID changing: "PID_FMT
" -> "PID_FMT
, s
->main_pid
, pid
);
814 service_unwatch_main_pid(s
);
815 s
->main_pid_known
= false;
817 log_unit_debug(UNIT(s
), "Main PID loaded: "PID_FMT
, pid
);
819 r
= service_set_main_pid(s
, pid
);
823 r
= unit_watch_pid(UNIT(s
), pid
);
825 /* FIXME: we need to do something here */
826 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" for service: %m", pid
);
833 static int service_search_main_pid(Service
*s
) {
839 /* If we know it anyway, don't ever fallback to unreliable
841 if (s
->main_pid_known
)
844 if (!s
->guess_main_pid
)
847 assert(s
->main_pid
<= 0);
849 r
= unit_search_main_pid(UNIT(s
), &pid
);
853 log_unit_debug(UNIT(s
), "Main PID guessed: "PID_FMT
, pid
);
854 r
= service_set_main_pid(s
, pid
);
858 r
= unit_watch_pid(UNIT(s
), pid
);
860 /* FIXME: we need to do something here */
861 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch PID "PID_FMT
" from: %m", pid
);
868 static void service_set_state(Service
*s
, ServiceState state
) {
869 ServiceState old_state
;
870 const UnitActiveState
*table
;
874 table
= s
->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
876 old_state
= s
->state
;
879 service_unwatch_pid_file(s
);
882 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
884 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
885 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
886 SERVICE_AUTO_RESTART
))
887 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
890 SERVICE_START
, SERVICE_START_POST
,
891 SERVICE_RUNNING
, SERVICE_RELOAD
,
892 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
893 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
894 service_unwatch_main_pid(s
);
895 s
->main_command
= NULL
;
899 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
901 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
902 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
903 service_unwatch_control_pid(s
);
904 s
->control_command
= NULL
;
905 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
908 if (IN_SET(state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
909 unit_unwatch_all_pids(UNIT(s
));
912 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
913 SERVICE_RUNNING
, SERVICE_RELOAD
,
914 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
915 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
) &&
916 !(state
== SERVICE_DEAD
&& UNIT(s
)->job
)) {
917 service_close_socket_fd(s
);
918 service_connection_unref(s
);
921 if (!IN_SET(state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
922 service_stop_watchdog(s
);
924 /* For the inactive states unit_notify() will trim the cgroup,
925 * but for exit we have to do that ourselves... */
926 if (state
== SERVICE_EXITED
&& UNIT(s
)->manager
->n_reloading
<= 0)
927 unit_prune_cgroup(UNIT(s
));
929 /* For remain_after_exit services, let's see if we can "release" the
930 * hold on the console, since unit_notify() only does that in case of
932 if (state
== SERVICE_EXITED
&&
933 s
->remain_after_exit
&&
934 UNIT(s
)->manager
->n_on_console
> 0) {
938 ec
= unit_get_exec_context(UNIT(s
));
939 if (ec
&& exec_context_may_touch_console(ec
)) {
940 Manager
*m
= UNIT(s
)->manager
;
943 if (m
->n_on_console
== 0)
944 /* unset no_console_output flag, since the console is free */
945 m
->no_console_output
= false;
949 if (old_state
!= state
)
950 log_unit_debug(UNIT(s
), "Changed %s -> %s", service_state_to_string(old_state
), service_state_to_string(state
));
952 unit_notify(UNIT(s
), table
[old_state
], table
[state
], s
->reload_result
== SERVICE_SUCCESS
);
955 static int service_coldplug(Unit
*u
) {
956 Service
*s
= SERVICE(u
);
960 assert(s
->state
== SERVICE_DEAD
);
962 if (s
->deserialized_state
== s
->state
)
965 if (IN_SET(s
->deserialized_state
,
966 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
968 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
969 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
973 k
= IN_SET(s
->deserialized_state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
;
975 /* For the start/stop timeouts 0 means off */
977 r
= service_arm_timer(s
, k
);
983 if (s
->deserialized_state
== SERVICE_AUTO_RESTART
) {
985 /* The restart timeouts 0 means immediately */
986 r
= service_arm_timer(s
, s
->restart_usec
);
991 if (s
->main_pid
> 0 &&
992 pid_is_unwaited(s
->main_pid
) &&
993 ((s
->deserialized_state
== SERVICE_START
&& IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_ONESHOT
, SERVICE_NOTIFY
)) ||
994 IN_SET(s
->deserialized_state
,
995 SERVICE_START
, SERVICE_START_POST
,
996 SERVICE_RUNNING
, SERVICE_RELOAD
,
997 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
998 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))) {
999 r
= unit_watch_pid(UNIT(s
), s
->main_pid
);
1004 if (s
->control_pid
> 0 &&
1005 pid_is_unwaited(s
->control_pid
) &&
1006 IN_SET(s
->deserialized_state
,
1007 SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
,
1009 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
1010 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
)) {
1011 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1016 if (!IN_SET(s
->deserialized_state
, SERVICE_DEAD
, SERVICE_FAILED
, SERVICE_AUTO_RESTART
))
1017 unit_watch_all_pids(UNIT(s
));
1019 if (IN_SET(s
->deserialized_state
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
))
1020 service_start_watchdog(s
);
1022 service_set_state(s
, s
->deserialized_state
);
1026 static int service_collect_fds(Service
*s
, int **fds
, char ***fd_names
) {
1027 _cleanup_strv_free_
char **rfd_names
= NULL
;
1028 _cleanup_free_
int *rfds
= NULL
;
1035 if (s
->socket_fd
>= 0) {
1037 /* Pass the per-connection socket */
1042 rfds
[0] = s
->socket_fd
;
1044 rfd_names
= strv_new("connection", NULL
);
1053 /* Pass all our configured sockets for singleton services */
1055 SET_FOREACH(u
, UNIT(s
)->dependencies
[UNIT_TRIGGERED_BY
], i
) {
1056 _cleanup_free_
int *cfds
= NULL
;
1060 if (u
->type
!= UNIT_SOCKET
)
1065 cn_fds
= socket_collect_fds(sock
, &cfds
);
1080 t
= realloc(rfds
, (rn_fds
+ cn_fds
) * sizeof(int));
1084 memcpy(t
+ rn_fds
, cfds
, cn_fds
* sizeof(int));
1090 r
= strv_extend_n(&rfd_names
, socket_fdname(sock
), cn_fds
);
1096 if (s
->n_fd_store
> 0) {
1101 t
= realloc(rfds
, (rn_fds
+ s
->n_fd_store
) * sizeof(int));
1107 nl
= realloc(rfd_names
, (rn_fds
+ s
->n_fd_store
+ 1) * sizeof(char*));
1113 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
1114 rfds
[rn_fds
] = fs
->fd
;
1115 rfd_names
[rn_fds
] = strdup(strempty(fs
->fdname
));
1116 if (!rfd_names
[rn_fds
])
1122 rfd_names
[rn_fds
] = NULL
;
1126 *fd_names
= rfd_names
;
1134 static int service_spawn(
1139 bool apply_permissions
,
1141 bool apply_tty_stdin
,
1145 _cleanup_strv_free_
char **argv
= NULL
, **final_env
= NULL
, **our_env
= NULL
, **fd_names
= NULL
;
1146 _cleanup_free_
char *bus_endpoint_path
= NULL
;
1147 _cleanup_free_
int *fds
= NULL
;
1148 unsigned n_fds
= 0, n_env
= 0;
1152 ExecParameters exec_params
= {
1153 .apply_permissions
= apply_permissions
,
1154 .apply_chroot
= apply_chroot
,
1155 .apply_tty_stdin
= apply_tty_stdin
,
1156 .bus_endpoint_fd
= -1,
1168 (void) unit_realize_cgroup(UNIT(s
));
1169 if (s
->reset_cpu_usage
) {
1170 (void) unit_reset_cpu_usage(UNIT(s
));
1171 s
->reset_cpu_usage
= false;
1174 r
= unit_setup_exec_runtime(UNIT(s
));
1179 s
->exec_context
.std_input
== EXEC_INPUT_SOCKET
||
1180 s
->exec_context
.std_output
== EXEC_OUTPUT_SOCKET
||
1181 s
->exec_context
.std_error
== EXEC_OUTPUT_SOCKET
) {
1183 r
= service_collect_fds(s
, &fds
, &fd_names
);
1191 r
= service_arm_timer(s
, timeout
);
1195 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1197 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1201 our_env
= new0(char*, 6);
1207 if (is_control
? s
->notify_access
== NOTIFY_ALL
: s
->notify_access
!= NOTIFY_NONE
)
1208 if (asprintf(our_env
+ n_env
++, "NOTIFY_SOCKET=%s", UNIT(s
)->manager
->notify_socket
) < 0) {
1213 if (s
->main_pid
> 0)
1214 if (asprintf(our_env
+ n_env
++, "MAINPID="PID_FMT
, s
->main_pid
) < 0) {
1219 if (UNIT(s
)->manager
->running_as
!= MANAGER_SYSTEM
)
1220 if (asprintf(our_env
+ n_env
++, "MANAGERPID="PID_FMT
, getpid()) < 0) {
1225 if (s
->socket_fd
>= 0) {
1226 union sockaddr_union sa
;
1227 socklen_t salen
= sizeof(sa
);
1229 r
= getpeername(s
->socket_fd
, &sa
.sa
, &salen
);
1235 if (IN_SET(sa
.sa
.sa_family
, AF_INET
, AF_INET6
)) {
1236 _cleanup_free_
char *addr
= NULL
;
1240 r
= sockaddr_pretty(&sa
.sa
, salen
, true, false, &addr
);
1244 t
= strappend("REMOTE_ADDR=", addr
);
1249 our_env
[n_env
++] = t
;
1251 port
= sockaddr_port(&sa
.sa
);
1257 if (asprintf(&t
, "REMOTE_PORT=%u", port
) < 0) {
1261 our_env
[n_env
++] = t
;
1265 final_env
= strv_env_merge(2, UNIT(s
)->manager
->environment
, our_env
, NULL
);
1271 if (is_control
&& UNIT(s
)->cgroup_path
) {
1272 path
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1273 (void) cg_create(SYSTEMD_CGROUP_CONTROLLER
, path
);
1275 path
= UNIT(s
)->cgroup_path
;
1277 if (s
->exec_context
.bus_endpoint
) {
1278 r
= bus_kernel_create_endpoint(UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
? "system" : "user",
1279 UNIT(s
)->id
, &bus_endpoint_path
);
1283 /* Pass the fd to the exec_params so that the child process can upload the policy.
1284 * Keep a reference to the fd in the service, so the endpoint is kept alive as long
1285 * as the service is running. */
1286 exec_params
.bus_endpoint_fd
= s
->bus_endpoint_fd
= r
;
1289 exec_params
.argv
= argv
;
1290 exec_params
.fds
= fds
;
1291 exec_params
.fd_names
= fd_names
;
1292 exec_params
.n_fds
= n_fds
;
1293 exec_params
.environment
= final_env
;
1294 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1295 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1296 exec_params
.cgroup_path
= path
;
1297 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1298 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1299 exec_params
.watchdog_usec
= s
->watchdog_usec
;
1300 exec_params
.bus_endpoint_path
= bus_endpoint_path
;
1301 exec_params
.selinux_context_net
= s
->socket_fd_selinux_context_net
;
1302 if (s
->type
== SERVICE_IDLE
)
1303 exec_params
.idle_pipe
= UNIT(s
)->manager
->idle_pipe
;
1304 exec_params
.stdin_fd
= s
->stdin_fd
;
1305 exec_params
.stdout_fd
= s
->stdout_fd
;
1306 exec_params
.stderr_fd
= s
->stderr_fd
;
1308 r
= exec_spawn(UNIT(s
),
1317 r
= unit_watch_pid(UNIT(s
), pid
);
1319 /* FIXME: we need to do something here */
1328 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1333 static int main_pid_good(Service
*s
) {
1336 /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1339 /* If we know the pid file, then let's just check if it is
1341 if (s
->main_pid_known
) {
1343 /* If it's an alien child let's check if it is still
1345 if (s
->main_pid_alien
&& s
->main_pid
> 0)
1346 return pid_is_alive(s
->main_pid
);
1348 /* .. otherwise assume we'll get a SIGCHLD for it,
1349 * which we really should wait for to collect exit
1350 * status and code */
1351 return s
->main_pid
> 0;
1354 /* We don't know the pid */
1358 _pure_
static int control_pid_good(Service
*s
) {
1361 return s
->control_pid
> 0;
1364 static int cgroup_good(Service
*s
) {
1369 if (!UNIT(s
)->cgroup_path
)
1372 r
= cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, UNIT(s
)->cgroup_path
);
1379 static bool service_shall_restart(Service
*s
) {
1382 /* Don't restart after manual stops */
1383 if (s
->forbid_restart
)
1386 /* Never restart if this is configured as special exception */
1387 if (exit_status_set_test(&s
->restart_prevent_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1390 /* Restart if the exit code/status are configured as restart triggers */
1391 if (exit_status_set_test(&s
->restart_force_status
, s
->main_exec_status
.code
, s
->main_exec_status
.status
))
1394 switch (s
->restart
) {
1396 case SERVICE_RESTART_NO
:
1399 case SERVICE_RESTART_ALWAYS
:
1402 case SERVICE_RESTART_ON_SUCCESS
:
1403 return s
->result
== SERVICE_SUCCESS
;
1405 case SERVICE_RESTART_ON_FAILURE
:
1406 return s
->result
!= SERVICE_SUCCESS
;
1408 case SERVICE_RESTART_ON_ABNORMAL
:
1409 return !IN_SET(s
->result
, SERVICE_SUCCESS
, SERVICE_FAILURE_EXIT_CODE
);
1411 case SERVICE_RESTART_ON_WATCHDOG
:
1412 return s
->result
== SERVICE_FAILURE_WATCHDOG
;
1414 case SERVICE_RESTART_ON_ABORT
:
1415 return IN_SET(s
->result
, SERVICE_FAILURE_SIGNAL
, SERVICE_FAILURE_CORE_DUMP
);
1418 assert_not_reached("unknown restart setting");
1422 static void service_enter_dead(Service
*s
, ServiceResult f
, bool allow_restart
) {
1426 if (f
!= SERVICE_SUCCESS
)
1429 service_set_state(s
, s
->result
!= SERVICE_SUCCESS
? SERVICE_FAILED
: SERVICE_DEAD
);
1431 if (s
->result
!= SERVICE_SUCCESS
) {
1432 log_unit_warning(UNIT(s
), "Failed with result '%s'.", service_result_to_string(s
->result
));
1433 failure_action(UNIT(s
)->manager
, s
->failure_action
, s
->reboot_arg
);
1436 if (allow_restart
&& service_shall_restart(s
)) {
1438 r
= service_arm_timer(s
, s
->restart_usec
);
1442 service_set_state(s
, SERVICE_AUTO_RESTART
);
1445 /* The next restart might not be a manual stop, hence reset the flag indicating manual stops */
1446 s
->forbid_restart
= false;
1448 /* We want fresh tmpdirs in case service is started again immediately */
1449 exec_runtime_destroy(s
->exec_runtime
);
1450 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1452 /* Also, remove the runtime directory in */
1453 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1455 /* Try to delete the pid file. At this point it will be
1456 * out-of-date, and some software might be confused by it, so
1457 * let's remove it. */
1459 unlink_noerrno(s
->pid_file
);
1464 log_unit_warning_errno(UNIT(s
), r
, "Failed to run install restart timer: %m");
1465 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1468 static void service_enter_stop_post(Service
*s
, ServiceResult f
) {
1472 if (f
!= SERVICE_SUCCESS
)
1475 service_unwatch_control_pid(s
);
1476 unit_watch_all_pids(UNIT(s
));
1478 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP_POST
];
1479 if (s
->control_command
) {
1480 s
->control_command_id
= SERVICE_EXEC_STOP_POST
;
1482 r
= service_spawn(s
,
1484 s
->timeout_stop_usec
,
1486 !s
->permissions_start_only
,
1487 !s
->root_directory_start_only
,
1494 service_set_state(s
, SERVICE_STOP_POST
);
1496 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_SUCCESS
);
1501 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1502 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1505 static int state_to_kill_operation(ServiceState state
) {
1508 case SERVICE_STOP_SIGABRT
:
1511 case SERVICE_STOP_SIGTERM
:
1512 case SERVICE_FINAL_SIGTERM
:
1513 return KILL_TERMINATE
;
1515 case SERVICE_STOP_SIGKILL
:
1516 case SERVICE_FINAL_SIGKILL
:
1520 return _KILL_OPERATION_INVALID
;
1524 static void service_enter_signal(Service
*s
, ServiceState state
, ServiceResult f
) {
1529 if (f
!= SERVICE_SUCCESS
)
1532 unit_watch_all_pids(UNIT(s
));
1534 r
= unit_kill_context(
1537 state_to_kill_operation(state
),
1546 if (s
->timeout_stop_usec
> 0) {
1547 r
= service_arm_timer(s
, s
->timeout_stop_usec
);
1552 service_set_state(s
, state
);
1553 } else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
) && s
->kill_context
.send_sigkill
)
1554 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_SUCCESS
);
1555 else if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1556 service_enter_stop_post(s
, SERVICE_SUCCESS
);
1557 else if (state
== SERVICE_FINAL_SIGTERM
&& s
->kill_context
.send_sigkill
)
1558 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_SUCCESS
);
1560 service_enter_dead(s
, SERVICE_SUCCESS
, true);
1565 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1567 if (IN_SET(state
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
))
1568 service_enter_stop_post(s
, SERVICE_FAILURE_RESOURCES
);
1570 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1573 static void service_enter_stop_by_notify(Service
*s
) {
1576 unit_watch_all_pids(UNIT(s
));
1578 if (s
->timeout_stop_usec
> 0)
1579 service_arm_timer(s
, s
->timeout_stop_usec
);
1581 /* The service told us it's stopping, so it's as if we SIGTERM'd it. */
1582 service_set_state(s
, SERVICE_STOP_SIGTERM
);
1585 static void service_enter_stop(Service
*s
, ServiceResult f
) {
1590 if (f
!= SERVICE_SUCCESS
)
1593 service_unwatch_control_pid(s
);
1594 unit_watch_all_pids(UNIT(s
));
1596 s
->control_command
= s
->exec_command
[SERVICE_EXEC_STOP
];
1597 if (s
->control_command
) {
1598 s
->control_command_id
= SERVICE_EXEC_STOP
;
1600 r
= service_spawn(s
,
1602 s
->timeout_stop_usec
,
1604 !s
->permissions_start_only
,
1605 !s
->root_directory_start_only
,
1612 service_set_state(s
, SERVICE_STOP
);
1614 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
1619 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop' task: %m");
1620 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1623 static bool service_good(Service
*s
) {
1627 if (s
->type
== SERVICE_DBUS
&& !s
->bus_name_good
)
1630 main_pid_ok
= main_pid_good(s
);
1631 if (main_pid_ok
> 0) /* It's alive */
1633 if (main_pid_ok
== 0) /* It's dead */
1636 /* OK, we don't know anything about the main PID, maybe
1637 * because there is none. Let's check the control group
1640 return cgroup_good(s
) != 0;
1643 static void service_enter_running(Service
*s
, ServiceResult f
) {
1646 if (f
!= SERVICE_SUCCESS
)
1649 if (service_good(s
)) {
1651 /* If there are any queued up sd_notify()
1652 * notifications, process them now */
1653 if (s
->notify_state
== NOTIFY_RELOADING
)
1654 service_enter_reload_by_notify(s
);
1655 else if (s
->notify_state
== NOTIFY_STOPPING
)
1656 service_enter_stop_by_notify(s
);
1658 service_set_state(s
, SERVICE_RUNNING
);
1660 } else if (s
->remain_after_exit
)
1661 service_set_state(s
, SERVICE_EXITED
);
1663 service_enter_stop(s
, SERVICE_SUCCESS
);
1666 static void service_enter_start_post(Service
*s
) {
1670 service_unwatch_control_pid(s
);
1671 service_reset_watchdog(s
);
1673 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_POST
];
1674 if (s
->control_command
) {
1675 s
->control_command_id
= SERVICE_EXEC_START_POST
;
1677 r
= service_spawn(s
,
1679 s
->timeout_start_usec
,
1681 !s
->permissions_start_only
,
1682 !s
->root_directory_start_only
,
1689 service_set_state(s
, SERVICE_START_POST
);
1691 service_enter_running(s
, SERVICE_SUCCESS
);
1696 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1697 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1700 static void service_kill_control_processes(Service
*s
) {
1703 if (!UNIT(s
)->cgroup_path
)
1706 p
= strjoina(UNIT(s
)->cgroup_path
, "/control");
1707 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER
, p
, SIGKILL
, true, true, true, NULL
);
1710 static void service_enter_start(Service
*s
) {
1717 service_unwatch_control_pid(s
);
1718 service_unwatch_main_pid(s
);
1720 /* We want to ensure that nobody leaks processes from
1721 * START_PRE here, so let's go on a killing spree, People
1722 * should not spawn long running processes from START_PRE. */
1723 service_kill_control_processes(s
);
1725 if (s
->type
== SERVICE_FORKING
) {
1726 s
->control_command_id
= SERVICE_EXEC_START
;
1727 c
= s
->control_command
= s
->exec_command
[SERVICE_EXEC_START
];
1729 s
->main_command
= NULL
;
1731 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
1732 s
->control_command
= NULL
;
1734 c
= s
->main_command
= s
->exec_command
[SERVICE_EXEC_START
];
1738 assert(s
->type
== SERVICE_ONESHOT
);
1739 service_enter_start_post(s
);
1743 r
= service_spawn(s
,
1745 IN_SET(s
->type
, SERVICE_FORKING
, SERVICE_DBUS
, SERVICE_NOTIFY
, SERVICE_ONESHOT
) ? s
->timeout_start_usec
: 0,
1755 if (s
->type
== SERVICE_SIMPLE
|| s
->type
== SERVICE_IDLE
) {
1756 /* For simple services we immediately start
1757 * the START_POST binaries. */
1759 service_set_main_pid(s
, pid
);
1760 service_enter_start_post(s
);
1762 } else if (s
->type
== SERVICE_FORKING
) {
1764 /* For forking services we wait until the start
1765 * process exited. */
1767 s
->control_pid
= pid
;
1768 service_set_state(s
, SERVICE_START
);
1770 } else if (s
->type
== SERVICE_ONESHOT
||
1771 s
->type
== SERVICE_DBUS
||
1772 s
->type
== SERVICE_NOTIFY
) {
1774 /* For oneshot services we wait until the start
1775 * process exited, too, but it is our main process. */
1777 /* For D-Bus services we know the main pid right away,
1778 * but wait for the bus name to appear on the
1779 * bus. Notify services are similar. */
1781 service_set_main_pid(s
, pid
);
1782 service_set_state(s
, SERVICE_START
);
1784 assert_not_reached("Unknown service type");
1789 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start' task: %m");
1790 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1793 static void service_enter_start_pre(Service
*s
) {
1798 service_unwatch_control_pid(s
);
1800 s
->control_command
= s
->exec_command
[SERVICE_EXEC_START_PRE
];
1801 if (s
->control_command
) {
1802 /* Before we start anything, let's clear up what might
1803 * be left from previous runs. */
1804 service_kill_control_processes(s
);
1806 s
->control_command_id
= SERVICE_EXEC_START_PRE
;
1808 r
= service_spawn(s
,
1810 s
->timeout_start_usec
,
1812 !s
->permissions_start_only
,
1813 !s
->root_directory_start_only
,
1820 service_set_state(s
, SERVICE_START_PRE
);
1822 service_enter_start(s
);
1827 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1828 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1831 static void service_enter_restart(Service
*s
) {
1832 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1837 if (UNIT(s
)->job
&& UNIT(s
)->job
->type
== JOB_STOP
) {
1838 /* Don't restart things if we are going down anyway */
1839 log_unit_info(UNIT(s
), "Stop job pending for unit, delaying automatic restart.");
1841 r
= service_arm_timer(s
, s
->restart_usec
);
1848 /* Any units that are bound to this service must also be
1849 * restarted. We use JOB_RESTART (instead of the more obvious
1850 * JOB_START) here so that those dependency jobs will be added
1852 r
= manager_add_job(UNIT(s
)->manager
, JOB_RESTART
, UNIT(s
), JOB_FAIL
, &error
, NULL
);
1856 /* Note that we stay in the SERVICE_AUTO_RESTART state here,
1857 * it will be canceled as part of the service_stop() call that
1858 * is executed as part of JOB_RESTART. */
1860 log_unit_debug(UNIT(s
), "Scheduled restart job.");
1864 log_unit_warning(UNIT(s
), "Failed to schedule restart job: %s", bus_error_message(&error
, -r
));
1865 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, false);
1868 static void service_enter_reload_by_notify(Service
*s
) {
1871 if (s
->timeout_start_usec
> 0)
1872 service_arm_timer(s
, s
->timeout_start_usec
);
1874 service_set_state(s
, SERVICE_RELOAD
);
1877 static void service_enter_reload(Service
*s
) {
1882 service_unwatch_control_pid(s
);
1883 s
->reload_result
= SERVICE_SUCCESS
;
1885 s
->control_command
= s
->exec_command
[SERVICE_EXEC_RELOAD
];
1886 if (s
->control_command
) {
1887 s
->control_command_id
= SERVICE_EXEC_RELOAD
;
1889 r
= service_spawn(s
,
1891 s
->timeout_start_usec
,
1893 !s
->permissions_start_only
,
1894 !s
->root_directory_start_only
,
1901 service_set_state(s
, SERVICE_RELOAD
);
1903 service_enter_running(s
, SERVICE_SUCCESS
);
1908 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'reload' task: %m");
1909 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1910 service_enter_running(s
, SERVICE_SUCCESS
);
1913 static void service_run_next_control(Service
*s
) {
1917 assert(s
->control_command
);
1918 assert(s
->control_command
->command_next
);
1920 assert(s
->control_command_id
!= SERVICE_EXEC_START
);
1922 s
->control_command
= s
->control_command
->command_next
;
1923 service_unwatch_control_pid(s
);
1925 r
= service_spawn(s
,
1927 IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
) ? s
->timeout_start_usec
: s
->timeout_stop_usec
,
1929 !s
->permissions_start_only
,
1930 !s
->root_directory_start_only
,
1931 s
->control_command_id
== SERVICE_EXEC_START_PRE
||
1932 s
->control_command_id
== SERVICE_EXEC_STOP_POST
,
1941 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next control task: %m");
1943 if (s
->state
== SERVICE_START_PRE
)
1944 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1945 else if (s
->state
== SERVICE_STOP
)
1946 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
1947 else if (s
->state
== SERVICE_STOP_POST
)
1948 service_enter_dead(s
, SERVICE_FAILURE_RESOURCES
, true);
1949 else if (s
->state
== SERVICE_RELOAD
) {
1950 s
->reload_result
= SERVICE_FAILURE_RESOURCES
;
1951 service_enter_running(s
, SERVICE_SUCCESS
);
1953 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1956 static void service_run_next_main(Service
*s
) {
1961 assert(s
->main_command
);
1962 assert(s
->main_command
->command_next
);
1963 assert(s
->type
== SERVICE_ONESHOT
);
1965 s
->main_command
= s
->main_command
->command_next
;
1966 service_unwatch_main_pid(s
);
1968 r
= service_spawn(s
,
1970 s
->timeout_start_usec
,
1980 service_set_main_pid(s
, pid
);
1985 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next main task: %m");
1986 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
1989 static int service_start_limit_test(Service
*s
) {
1992 if (ratelimit_test(&s
->start_limit
))
1995 log_unit_warning(UNIT(s
), "Start request repeated too quickly.");
1997 return failure_action(UNIT(s
)->manager
, s
->start_limit_action
, s
->reboot_arg
);
2000 static int service_start(Unit
*u
) {
2001 Service
*s
= SERVICE(u
);
2006 /* We cannot fulfill this request right now, try again later
2008 if (IN_SET(s
->state
,
2009 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2010 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2013 /* Already on it! */
2014 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
))
2017 /* A service that will be restarted must be stopped first to
2018 * trigger BindsTo and/or OnFailure dependencies. If a user
2019 * does not want to wait for the holdoff time to elapse, the
2020 * service should be manually restarted, not started. We
2021 * simply return EAGAIN here, so that any start jobs stay
2022 * queued, and assume that the auto restart timer will
2023 * eventually trigger the restart. */
2024 if (s
->state
== SERVICE_AUTO_RESTART
)
2027 assert(IN_SET(s
->state
, SERVICE_DEAD
, SERVICE_FAILED
));
2029 /* Make sure we don't enter a busy loop of some kind. */
2030 r
= service_start_limit_test(s
);
2032 service_enter_dead(s
, SERVICE_FAILURE_START_LIMIT
, false);
2036 s
->result
= SERVICE_SUCCESS
;
2037 s
->reload_result
= SERVICE_SUCCESS
;
2038 s
->main_pid_known
= false;
2039 s
->main_pid_alien
= false;
2040 s
->forbid_restart
= false;
2041 s
->reset_cpu_usage
= true;
2043 s
->status_text
= mfree(s
->status_text
);
2044 s
->status_errno
= 0;
2046 s
->notify_state
= NOTIFY_UNKNOWN
;
2048 service_enter_start_pre(s
);
2052 static int service_stop(Unit
*u
) {
2053 Service
*s
= SERVICE(u
);
2057 /* Don't create restart jobs from manual stops. */
2058 s
->forbid_restart
= true;
2061 if (IN_SET(s
->state
,
2062 SERVICE_STOP
, SERVICE_STOP_SIGABRT
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
, SERVICE_STOP_POST
,
2063 SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
))
2066 /* A restart will be scheduled or is in progress. */
2067 if (s
->state
== SERVICE_AUTO_RESTART
) {
2068 service_set_state(s
, SERVICE_DEAD
);
2072 /* If there's already something running we go directly into
2074 if (IN_SET(s
->state
, SERVICE_START_PRE
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RELOAD
)) {
2075 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_SUCCESS
);
2079 assert(IN_SET(s
->state
, SERVICE_RUNNING
, SERVICE_EXITED
));
2081 service_enter_stop(s
, SERVICE_SUCCESS
);
2085 static int service_reload(Unit
*u
) {
2086 Service
*s
= SERVICE(u
);
2090 assert(s
->state
== SERVICE_RUNNING
|| s
->state
== SERVICE_EXITED
);
2092 service_enter_reload(s
);
2096 _pure_
static bool service_can_reload(Unit
*u
) {
2097 Service
*s
= SERVICE(u
);
2101 return !!s
->exec_command
[SERVICE_EXEC_RELOAD
];
2104 static int service_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2105 Service
*s
= SERVICE(u
);
2113 unit_serialize_item(u
, f
, "state", service_state_to_string(s
->state
));
2114 unit_serialize_item(u
, f
, "result", service_result_to_string(s
->result
));
2115 unit_serialize_item(u
, f
, "reload-result", service_result_to_string(s
->reload_result
));
2117 if (s
->control_pid
> 0)
2118 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2120 if (s
->main_pid_known
&& s
->main_pid
> 0)
2121 unit_serialize_item_format(u
, f
, "main-pid", PID_FMT
, s
->main_pid
);
2123 unit_serialize_item(u
, f
, "main-pid-known", yes_no(s
->main_pid_known
));
2124 unit_serialize_item(u
, f
, "bus-name-good", yes_no(s
->bus_name_good
));
2126 r
= unit_serialize_item_escaped(u
, f
, "status-text", s
->status_text
);
2130 /* FIXME: There's a minor uncleanliness here: if there are
2131 * multiple commands attached here, we will start from the
2132 * first one again */
2133 if (s
->control_command_id
>= 0)
2134 unit_serialize_item(u
, f
, "control-command", service_exec_command_to_string(s
->control_command_id
));
2136 r
= unit_serialize_item_fd(u
, f
, fds
, "stdin-fd", s
->stdin_fd
);
2139 r
= unit_serialize_item_fd(u
, f
, fds
, "stdout-fd", s
->stdout_fd
);
2142 r
= unit_serialize_item_fd(u
, f
, fds
, "stderr-fd", s
->stderr_fd
);
2146 r
= unit_serialize_item_fd(u
, f
, fds
, "socket-fd", s
->socket_fd
);
2149 r
= unit_serialize_item_fd(u
, f
, fds
, "endpoint-fd", s
->bus_endpoint_fd
);
2153 LIST_FOREACH(fd_store
, fs
, s
->fd_store
) {
2154 _cleanup_free_
char *c
= NULL
;
2157 copy
= fdset_put_dup(fds
, fs
->fd
);
2161 c
= cescape(fs
->fdname
);
2163 unit_serialize_item_format(u
, f
, "fd-store-fd", "%i %s", copy
, strempty(c
));
2166 if (s
->main_exec_status
.pid
> 0) {
2167 unit_serialize_item_format(u
, f
, "main-exec-status-pid", PID_FMT
, s
->main_exec_status
.pid
);
2168 dual_timestamp_serialize(f
, "main-exec-status-start", &s
->main_exec_status
.start_timestamp
);
2169 dual_timestamp_serialize(f
, "main-exec-status-exit", &s
->main_exec_status
.exit_timestamp
);
2171 if (dual_timestamp_is_set(&s
->main_exec_status
.exit_timestamp
)) {
2172 unit_serialize_item_format(u
, f
, "main-exec-status-code", "%i", s
->main_exec_status
.code
);
2173 unit_serialize_item_format(u
, f
, "main-exec-status-status", "%i", s
->main_exec_status
.status
);
2177 if (dual_timestamp_is_set(&s
->watchdog_timestamp
))
2178 dual_timestamp_serialize(f
, "watchdog-timestamp", &s
->watchdog_timestamp
);
2180 unit_serialize_item(u
, f
, "forbid-restart", yes_no(s
->forbid_restart
));
2185 static int service_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2186 Service
*s
= SERVICE(u
);
2194 if (streq(key
, "state")) {
2197 state
= service_state_from_string(value
);
2199 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2201 s
->deserialized_state
= state
;
2202 } else if (streq(key
, "result")) {
2205 f
= service_result_from_string(value
);
2207 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2208 else if (f
!= SERVICE_SUCCESS
)
2211 } else if (streq(key
, "reload-result")) {
2214 f
= service_result_from_string(value
);
2216 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
2217 else if (f
!= SERVICE_SUCCESS
)
2218 s
->reload_result
= f
;
2220 } else if (streq(key
, "control-pid")) {
2223 if (parse_pid(value
, &pid
) < 0)
2224 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2226 s
->control_pid
= pid
;
2227 } else if (streq(key
, "main-pid")) {
2230 if (parse_pid(value
, &pid
) < 0)
2231 log_unit_debug(u
, "Failed to parse main-pid value: %s", value
);
2233 service_set_main_pid(s
, pid
);
2234 unit_watch_pid(UNIT(s
), pid
);
2236 } else if (streq(key
, "main-pid-known")) {
2239 b
= parse_boolean(value
);
2241 log_unit_debug(u
, "Failed to parse main-pid-known value: %s", value
);
2243 s
->main_pid_known
= b
;
2244 } else if (streq(key
, "bus-name-good")) {
2247 b
= parse_boolean(value
);
2249 log_unit_debug(u
, "Failed to parse bus-name-good value: %s", value
);
2251 s
->bus_name_good
= b
;
2252 } else if (streq(key
, "status-text")) {
2255 r
= cunescape(value
, 0, &t
);
2257 log_unit_debug_errno(u
, r
, "Failed to unescape status text: %s", value
);
2259 free(s
->status_text
);
2263 } else if (streq(key
, "control-command")) {
2264 ServiceExecCommand id
;
2266 id
= service_exec_command_from_string(value
);
2268 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2270 s
->control_command_id
= id
;
2271 s
->control_command
= s
->exec_command
[id
];
2273 } else if (streq(key
, "socket-fd")) {
2276 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2277 log_unit_debug(u
, "Failed to parse socket-fd value: %s", value
);
2279 asynchronous_close(s
->socket_fd
);
2280 s
->socket_fd
= fdset_remove(fds
, fd
);
2282 } else if (streq(key
, "endpoint-fd")) {
2285 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2286 log_unit_debug(u
, "Failed to parse endpoint-fd value: %s", value
);
2288 safe_close(s
->bus_endpoint_fd
);
2289 s
->bus_endpoint_fd
= fdset_remove(fds
, fd
);
2291 } else if (streq(key
, "fd-store-fd")) {
2296 pf
= strcspn(value
, WHITESPACE
);
2297 fdv
= strndupa(value
, pf
);
2299 if (safe_atoi(fdv
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2300 log_unit_debug(u
, "Failed to parse fd-store-fd value: %s", value
);
2302 _cleanup_free_
char *t
= NULL
;
2306 fdn
+= strspn(fdn
, WHITESPACE
);
2307 (void) cunescape(fdn
, 0, &t
);
2309 r
= service_add_fd_store(s
, fd
, t
);
2311 log_unit_error_errno(u
, r
, "Failed to add fd to store: %m");
2313 fdset_remove(fds
, fd
);
2316 } else if (streq(key
, "main-exec-status-pid")) {
2319 if (parse_pid(value
, &pid
) < 0)
2320 log_unit_debug(u
, "Failed to parse main-exec-status-pid value: %s", value
);
2322 s
->main_exec_status
.pid
= pid
;
2323 } else if (streq(key
, "main-exec-status-code")) {
2326 if (safe_atoi(value
, &i
) < 0)
2327 log_unit_debug(u
, "Failed to parse main-exec-status-code value: %s", value
);
2329 s
->main_exec_status
.code
= i
;
2330 } else if (streq(key
, "main-exec-status-status")) {
2333 if (safe_atoi(value
, &i
) < 0)
2334 log_unit_debug(u
, "Failed to parse main-exec-status-status value: %s", value
);
2336 s
->main_exec_status
.status
= i
;
2337 } else if (streq(key
, "main-exec-status-start"))
2338 dual_timestamp_deserialize(value
, &s
->main_exec_status
.start_timestamp
);
2339 else if (streq(key
, "main-exec-status-exit"))
2340 dual_timestamp_deserialize(value
, &s
->main_exec_status
.exit_timestamp
);
2341 else if (streq(key
, "watchdog-timestamp"))
2342 dual_timestamp_deserialize(value
, &s
->watchdog_timestamp
);
2343 else if (streq(key
, "forbid-restart")) {
2346 b
= parse_boolean(value
);
2348 log_unit_debug(u
, "Failed to parse forbid-restart value: %s", value
);
2350 s
->forbid_restart
= b
;
2351 } else if (streq(key
, "stdin-fd")) {
2354 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2355 log_unit_debug(u
, "Failed to parse stdin-fd value: %s", value
);
2357 asynchronous_close(s
->stdin_fd
);
2358 s
->stdin_fd
= fdset_remove(fds
, fd
);
2360 } else if (streq(key
, "stdout-fd")) {
2363 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2364 log_unit_debug(u
, "Failed to parse stdout-fd value: %s", value
);
2366 asynchronous_close(s
->stdout_fd
);
2367 s
->stdout_fd
= fdset_remove(fds
, fd
);
2369 } else if (streq(key
, "stderr-fd")) {
2372 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
2373 log_unit_debug(u
, "Failed to parse stderr-fd value: %s", value
);
2375 asynchronous_close(s
->stderr_fd
);
2376 s
->stderr_fd
= fdset_remove(fds
, fd
);
2379 log_unit_debug(u
, "Unknown serialization key: %s", key
);
2384 _pure_
static UnitActiveState
service_active_state(Unit
*u
) {
2385 const UnitActiveState
*table
;
2389 table
= SERVICE(u
)->type
== SERVICE_IDLE
? state_translation_table_idle
: state_translation_table
;
2391 return table
[SERVICE(u
)->state
];
2394 static const char *service_sub_state_to_string(Unit
*u
) {
2397 return service_state_to_string(SERVICE(u
)->state
);
2400 static bool service_check_gc(Unit
*u
) {
2401 Service
*s
= SERVICE(u
);
2405 /* Never clean up services that still have a process around,
2406 * even if the service is formally dead. */
2407 if (cgroup_good(s
) > 0 ||
2408 main_pid_good(s
) > 0 ||
2409 control_pid_good(s
) > 0)
2415 static int service_retry_pid_file(Service
*s
) {
2418 assert(s
->pid_file
);
2419 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2421 r
= service_load_pid_file(s
, false);
2425 service_unwatch_pid_file(s
);
2427 service_enter_running(s
, SERVICE_SUCCESS
);
2431 static int service_watch_pid_file(Service
*s
) {
2434 log_unit_debug(UNIT(s
), "Setting watch for PID file %s", s
->pid_file_pathspec
->path
);
2436 r
= path_spec_watch(s
->pid_file_pathspec
, service_dispatch_io
);
2440 /* the pidfile might have appeared just before we set the watch */
2441 log_unit_debug(UNIT(s
), "Trying to read PID file %s in case it changed", s
->pid_file_pathspec
->path
);
2442 service_retry_pid_file(s
);
2446 log_unit_error_errno(UNIT(s
), r
, "Failed to set a watch for PID file %s: %m", s
->pid_file_pathspec
->path
);
2447 service_unwatch_pid_file(s
);
2451 static int service_demand_pid_file(Service
*s
) {
2454 assert(s
->pid_file
);
2455 assert(!s
->pid_file_pathspec
);
2457 ps
= new0(PathSpec
, 1);
2462 ps
->path
= strdup(s
->pid_file
);
2468 path_kill_slashes(ps
->path
);
2470 /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2471 * keep their PID file open all the time. */
2472 ps
->type
= PATH_MODIFIED
;
2473 ps
->inotify_fd
= -1;
2475 s
->pid_file_pathspec
= ps
;
2477 return service_watch_pid_file(s
);
2480 static int service_dispatch_io(sd_event_source
*source
, int fd
, uint32_t events
, void *userdata
) {
2481 PathSpec
*p
= userdata
;
2486 s
= SERVICE(p
->unit
);
2490 assert(s
->state
== SERVICE_START
|| s
->state
== SERVICE_START_POST
);
2491 assert(s
->pid_file_pathspec
);
2492 assert(path_spec_owns_inotify_fd(s
->pid_file_pathspec
, fd
));
2494 log_unit_debug(UNIT(s
), "inotify event");
2496 if (path_spec_fd_event(p
, events
) < 0)
2499 if (service_retry_pid_file(s
) == 0)
2502 if (service_watch_pid_file(s
) < 0)
2508 service_unwatch_pid_file(s
);
2509 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2513 static void service_notify_cgroup_empty_event(Unit
*u
) {
2514 Service
*s
= SERVICE(u
);
2518 log_unit_debug(u
, "cgroup is empty");
2522 /* Waiting for SIGCHLD is usually more interesting,
2523 * because it includes return codes/signals. Which is
2524 * why we ignore the cgroup events for most cases,
2525 * except when we don't know pid which to expect the
2529 case SERVICE_START_POST
:
2530 /* If we were hoping for the daemon to write its PID file,
2531 * we can give up now. */
2532 if (s
->pid_file_pathspec
) {
2533 log_unit_warning(u
, "Daemon never wrote its PID file. Failing.");
2535 service_unwatch_pid_file(s
);
2536 if (s
->state
== SERVICE_START
)
2537 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2539 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2543 case SERVICE_RUNNING
:
2544 /* service_enter_running() will figure out what to do */
2545 service_enter_running(s
, SERVICE_SUCCESS
);
2548 case SERVICE_STOP_SIGABRT
:
2549 case SERVICE_STOP_SIGTERM
:
2550 case SERVICE_STOP_SIGKILL
:
2552 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2553 service_enter_stop_post(s
, SERVICE_SUCCESS
);
2557 case SERVICE_STOP_POST
:
2558 case SERVICE_FINAL_SIGTERM
:
2559 case SERVICE_FINAL_SIGKILL
:
2560 if (main_pid_good(s
) <= 0 && !control_pid_good(s
))
2561 service_enter_dead(s
, SERVICE_SUCCESS
, true);
2570 static void service_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2571 Service
*s
= SERVICE(u
);
2577 if (UNIT(s
)->fragment_path
? is_clean_exit(code
, status
, &s
->success_status
) :
2578 is_clean_exit_lsb(code
, status
, &s
->success_status
))
2579 f
= SERVICE_SUCCESS
;
2580 else if (code
== CLD_EXITED
)
2581 f
= SERVICE_FAILURE_EXIT_CODE
;
2582 else if (code
== CLD_KILLED
)
2583 f
= SERVICE_FAILURE_SIGNAL
;
2584 else if (code
== CLD_DUMPED
)
2585 f
= SERVICE_FAILURE_CORE_DUMP
;
2587 assert_not_reached("Unknown code");
2589 if (s
->main_pid
== pid
) {
2590 /* Forking services may occasionally move to a new PID.
2591 * As long as they update the PID file before exiting the old
2592 * PID, they're fine. */
2593 if (service_load_pid_file(s
, false) == 0)
2597 exec_status_exit(&s
->main_exec_status
, &s
->exec_context
, pid
, code
, status
);
2599 if (s
->main_command
) {
2600 /* If this is not a forking service than the
2601 * main process got started and hence we copy
2602 * the exit status so that it is recorded both
2603 * as main and as control process exit
2606 s
->main_command
->exec_status
= s
->main_exec_status
;
2608 if (s
->main_command
->ignore
)
2609 f
= SERVICE_SUCCESS
;
2610 } else if (s
->exec_command
[SERVICE_EXEC_START
]) {
2612 /* If this is a forked process, then we should
2613 * ignore the return value if this was
2614 * configured for the starter process */
2616 if (s
->exec_command
[SERVICE_EXEC_START
]->ignore
)
2617 f
= SERVICE_SUCCESS
;
2620 log_struct(f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
,
2622 LOG_UNIT_MESSAGE(u
, "Main process exited, code=%s, status=%i/%s",
2623 sigchld_code_to_string(code
), status
,
2624 strna(code
== CLD_EXITED
2625 ? exit_status_to_string(status
, EXIT_STATUS_FULL
)
2626 : signal_to_string(status
))),
2627 "EXIT_CODE=%s", sigchld_code_to_string(code
),
2628 "EXIT_STATUS=%i", status
,
2631 if (f
!= SERVICE_SUCCESS
)
2634 if (s
->main_command
&&
2635 s
->main_command
->command_next
&&
2636 f
== SERVICE_SUCCESS
) {
2638 /* There is another command to *
2639 * execute, so let's do that. */
2641 log_unit_debug(u
, "Running next main command for state %s.", service_state_to_string(s
->state
));
2642 service_run_next_main(s
);
2646 /* The service exited, so the service is officially
2648 s
->main_command
= NULL
;
2652 case SERVICE_START_POST
:
2653 case SERVICE_RELOAD
:
2655 /* Need to wait until the operation is
2660 if (s
->type
== SERVICE_ONESHOT
) {
2661 /* This was our main goal, so let's go on */
2662 if (f
== SERVICE_SUCCESS
)
2663 service_enter_start_post(s
);
2665 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2671 case SERVICE_RUNNING
:
2672 service_enter_running(s
, f
);
2675 case SERVICE_STOP_SIGABRT
:
2676 case SERVICE_STOP_SIGTERM
:
2677 case SERVICE_STOP_SIGKILL
:
2679 if (!control_pid_good(s
))
2680 service_enter_stop_post(s
, f
);
2682 /* If there is still a control process, wait for that first */
2685 case SERVICE_STOP_POST
:
2686 case SERVICE_FINAL_SIGTERM
:
2687 case SERVICE_FINAL_SIGKILL
:
2689 if (!control_pid_good(s
))
2690 service_enter_dead(s
, f
, true);
2694 assert_not_reached("Uh, main process died at wrong time.");
2698 } else if (s
->control_pid
== pid
) {
2701 if (s
->control_command
) {
2702 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2704 if (s
->control_command
->ignore
)
2705 f
= SERVICE_SUCCESS
;
2708 log_unit_full(u
, f
== SERVICE_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2709 "Control process exited, code=%s status=%i",
2710 sigchld_code_to_string(code
), status
);
2712 if (f
!= SERVICE_SUCCESS
)
2715 /* Immediately get rid of the cgroup, so that the
2716 * kernel doesn't delay the cgroup empty messages for
2717 * the service cgroup any longer than necessary */
2718 service_kill_control_processes(s
);
2720 if (s
->control_command
&&
2721 s
->control_command
->command_next
&&
2722 f
== SERVICE_SUCCESS
) {
2724 /* There is another command to *
2725 * execute, so let's do that. */
2727 log_unit_debug(u
, "Running next control command for state %s.", service_state_to_string(s
->state
));
2728 service_run_next_control(s
);
2731 /* No further commands for this step, so let's
2732 * figure out what to do next */
2734 s
->control_command
= NULL
;
2735 s
->control_command_id
= _SERVICE_EXEC_COMMAND_INVALID
;
2737 log_unit_debug(u
, "Got final SIGCHLD for state %s.", service_state_to_string(s
->state
));
2741 case SERVICE_START_PRE
:
2742 if (f
== SERVICE_SUCCESS
)
2743 service_enter_start(s
);
2745 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2749 if (s
->type
!= SERVICE_FORKING
)
2750 /* Maybe spurious event due to a reload that changed the type? */
2753 if (f
!= SERVICE_SUCCESS
) {
2754 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, f
);
2759 bool has_start_post
;
2762 /* Let's try to load the pid file here if we can.
2763 * The PID file might actually be created by a START_POST
2764 * script. In that case don't worry if the loading fails. */
2766 has_start_post
= !!s
->exec_command
[SERVICE_EXEC_START_POST
];
2767 r
= service_load_pid_file(s
, !has_start_post
);
2768 if (!has_start_post
&& r
< 0) {
2769 r
= service_demand_pid_file(s
);
2770 if (r
< 0 || !cgroup_good(s
))
2771 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_RESOURCES
);
2775 (void) service_search_main_pid(s
);
2777 service_enter_start_post(s
);
2780 case SERVICE_START_POST
:
2781 if (f
!= SERVICE_SUCCESS
) {
2782 service_enter_stop(s
, f
);
2789 r
= service_load_pid_file(s
, true);
2791 r
= service_demand_pid_file(s
);
2792 if (r
< 0 || !cgroup_good(s
))
2793 service_enter_stop(s
, SERVICE_FAILURE_RESOURCES
);
2797 (void) service_search_main_pid(s
);
2799 service_enter_running(s
, SERVICE_SUCCESS
);
2802 case SERVICE_RELOAD
:
2803 if (f
== SERVICE_SUCCESS
) {
2804 service_load_pid_file(s
, true);
2805 (void) service_search_main_pid(s
);
2808 s
->reload_result
= f
;
2809 service_enter_running(s
, SERVICE_SUCCESS
);
2813 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, f
);
2816 case SERVICE_STOP_SIGABRT
:
2817 case SERVICE_STOP_SIGTERM
:
2818 case SERVICE_STOP_SIGKILL
:
2819 if (main_pid_good(s
) <= 0)
2820 service_enter_stop_post(s
, f
);
2822 /* If there is still a service
2823 * process around, wait until
2824 * that one quit, too */
2827 case SERVICE_STOP_POST
:
2828 case SERVICE_FINAL_SIGTERM
:
2829 case SERVICE_FINAL_SIGKILL
:
2830 if (main_pid_good(s
) <= 0)
2831 service_enter_dead(s
, f
, true);
2835 assert_not_reached("Uh, control process died at wrong time.");
2840 /* Notify clients about changed exit status */
2841 unit_add_to_dbus_queue(u
);
2843 /* We got one SIGCHLD for the service, let's watch all
2844 * processes that are now running of the service, and watch
2845 * that. Among the PIDs we then watch will be children
2846 * reassigned to us, which hopefully allows us to identify
2847 * when all children are gone */
2848 unit_tidy_watch_pids(u
, s
->main_pid
, s
->control_pid
);
2849 unit_watch_all_pids(u
);
2851 /* If the PID set is empty now, then let's finish this off */
2852 if (set_isempty(u
->pids
))
2853 service_notify_cgroup_empty_event(u
);
2856 static int service_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2857 Service
*s
= SERVICE(userdata
);
2860 assert(source
== s
->timer_event_source
);
2864 case SERVICE_START_PRE
:
2866 log_unit_warning(UNIT(s
), "%s operation timed out. Terminating.", s
->state
== SERVICE_START
? "Start" : "Start-pre");
2867 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2870 case SERVICE_START_POST
:
2871 log_unit_warning(UNIT(s
), "Start-post operation timed out. Stopping.");
2872 service_enter_stop(s
, SERVICE_FAILURE_TIMEOUT
);
2875 case SERVICE_RELOAD
:
2876 log_unit_warning(UNIT(s
), "Reload operation timed out. Stopping.");
2877 service_unwatch_control_pid(s
);
2878 service_kill_control_processes(s
);
2879 s
->reload_result
= SERVICE_FAILURE_TIMEOUT
;
2880 service_enter_running(s
, SERVICE_SUCCESS
);
2884 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2885 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2888 case SERVICE_STOP_SIGABRT
:
2889 log_unit_warning(UNIT(s
), "State 'stop-sigabrt' timed out. Terminating.");
2890 service_enter_signal(s
, SERVICE_STOP_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2893 case SERVICE_STOP_SIGTERM
:
2894 if (s
->kill_context
.send_sigkill
) {
2895 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Killing.");
2896 service_enter_signal(s
, SERVICE_STOP_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2898 log_unit_warning(UNIT(s
), "State 'stop-sigterm' timed out. Skipping SIGKILL.");
2899 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2904 case SERVICE_STOP_SIGKILL
:
2905 /* Uh, we sent a SIGKILL and it is still not gone?
2906 * Must be something we cannot kill, so let's just be
2907 * weirded out and continue */
2909 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2910 service_enter_stop_post(s
, SERVICE_FAILURE_TIMEOUT
);
2913 case SERVICE_STOP_POST
:
2914 log_unit_warning(UNIT(s
), "State 'stop-post' timed out. Terminating.");
2915 service_enter_signal(s
, SERVICE_FINAL_SIGTERM
, SERVICE_FAILURE_TIMEOUT
);
2918 case SERVICE_FINAL_SIGTERM
:
2919 if (s
->kill_context
.send_sigkill
) {
2920 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Killing.");
2921 service_enter_signal(s
, SERVICE_FINAL_SIGKILL
, SERVICE_FAILURE_TIMEOUT
);
2923 log_unit_warning(UNIT(s
), "State 'stop-final-sigterm' timed out. Skipping SIGKILL. Entering failed mode.");
2924 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, false);
2929 case SERVICE_FINAL_SIGKILL
:
2930 log_unit_warning(UNIT(s
), "Processes still around after final SIGKILL. Entering failed mode.");
2931 service_enter_dead(s
, SERVICE_FAILURE_TIMEOUT
, true);
2934 case SERVICE_AUTO_RESTART
:
2935 log_unit_info(UNIT(s
),
2936 s
->restart_usec
> 0 ?
2937 "Service hold-off time over, scheduling restart." :
2938 "Service has no hold-off time, scheduling restart.");
2939 service_enter_restart(s
);
2943 assert_not_reached("Timeout at wrong time.");
2949 static int service_dispatch_watchdog(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2950 Service
*s
= SERVICE(userdata
);
2951 char t
[FORMAT_TIMESPAN_MAX
];
2954 assert(source
== s
->watchdog_event_source
);
2956 log_unit_error(UNIT(s
), "Watchdog timeout (limit %s)!",
2957 format_timespan(t
, sizeof(t
), s
->watchdog_usec
, 1));
2959 service_enter_signal(s
, SERVICE_STOP_SIGABRT
, SERVICE_FAILURE_WATCHDOG
);
2964 static void service_notify_message(Unit
*u
, pid_t pid
, char **tags
, FDSet
*fds
) {
2965 Service
*s
= SERVICE(u
);
2966 _cleanup_free_
char *cc
= NULL
;
2967 bool notify_dbus
= false;
2972 cc
= strv_join(tags
, ", ");
2974 if (s
->notify_access
== NOTIFY_NONE
) {
2975 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception is disabled.", pid
);
2977 } else if (s
->notify_access
== NOTIFY_MAIN
&& pid
!= s
->main_pid
) {
2978 if (s
->main_pid
!= 0)
2979 log_unit_warning(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID "PID_FMT
, pid
, s
->main_pid
);
2981 log_unit_debug(u
, "Got notification message from PID "PID_FMT
", but reception only permitted for main PID which is currently not known", pid
);
2984 log_unit_debug(u
, "Got notification message from PID "PID_FMT
" (%s)", pid
, isempty(cc
) ? "n/a" : cc
);
2986 /* Interpret MAINPID= */
2987 e
= strv_find_startswith(tags
, "MAINPID=");
2988 if (e
&& IN_SET(s
->state
, SERVICE_START
, SERVICE_START_POST
, SERVICE_RUNNING
, SERVICE_RELOAD
)) {
2989 if (parse_pid(e
, &pid
) < 0)
2990 log_unit_warning(u
, "Failed to parse MAINPID= field in notification message: %s", e
);
2992 service_set_main_pid(s
, pid
);
2993 unit_watch_pid(UNIT(s
), pid
);
2998 /* Interpret RELOADING= */
2999 if (strv_find(tags
, "RELOADING=1")) {
3001 s
->notify_state
= NOTIFY_RELOADING
;
3003 if (s
->state
== SERVICE_RUNNING
)
3004 service_enter_reload_by_notify(s
);
3009 /* Interpret READY= */
3010 if (strv_find(tags
, "READY=1")) {
3012 s
->notify_state
= NOTIFY_READY
;
3014 /* Type=notify services inform us about completed
3015 * initialization with READY=1 */
3016 if (s
->type
== SERVICE_NOTIFY
&& s
->state
== SERVICE_START
)
3017 service_enter_start_post(s
);
3019 /* Sending READY=1 while we are reloading informs us
3020 * that the reloading is complete */
3021 if (s
->state
== SERVICE_RELOAD
&& s
->control_pid
== 0)
3022 service_enter_running(s
, SERVICE_SUCCESS
);
3027 /* Interpret STOPPING= */
3028 if (strv_find(tags
, "STOPPING=1")) {
3030 s
->notify_state
= NOTIFY_STOPPING
;
3032 if (s
->state
== SERVICE_RUNNING
)
3033 service_enter_stop_by_notify(s
);
3038 /* Interpret STATUS= */
3039 e
= strv_find_startswith(tags
, "STATUS=");
3041 _cleanup_free_
char *t
= NULL
;
3044 if (!utf8_is_valid(e
))
3045 log_unit_warning(u
, "Status message in notification message is not UTF-8 clean.");
3053 if (!streq_ptr(s
->status_text
, t
)) {
3055 free(s
->status_text
);
3063 /* Interpret ERRNO= */
3064 e
= strv_find_startswith(tags
, "ERRNO=");
3068 if (safe_atoi(e
, &status_errno
) < 0 || status_errno
< 0)
3069 log_unit_warning(u
, "Failed to parse ERRNO= field in notification message: %s", e
);
3071 if (s
->status_errno
!= status_errno
) {
3072 s
->status_errno
= status_errno
;
3078 /* Interpret WATCHDOG= */
3079 if (strv_find(tags
, "WATCHDOG=1"))
3080 service_reset_watchdog(s
);
3082 if (strv_find(tags
, "FDSTORE=1")) {
3085 name
= strv_find_startswith(tags
, "FDNAME=");
3086 if (name
&& !fdname_is_valid(name
)) {
3087 log_unit_warning(u
, "Passed FDNAME= name is invalid, ignoring.");
3091 service_add_fd_store_set(s
, fds
, name
);
3094 /* Notify clients about changed status or main pid */
3096 unit_add_to_dbus_queue(u
);
3099 static int service_get_timeout(Unit
*u
, uint64_t *timeout
) {
3100 Service
*s
= SERVICE(u
);
3103 if (!s
->timer_event_source
)
3106 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
3113 static void service_bus_name_owner_change(
3116 const char *old_owner
,
3117 const char *new_owner
) {
3119 Service
*s
= SERVICE(u
);
3125 assert(streq(s
->bus_name
, name
));
3126 assert(old_owner
|| new_owner
);
3128 if (old_owner
&& new_owner
)
3129 log_unit_debug(u
, "D-Bus name %s changed owner from %s to %s", name
, old_owner
, new_owner
);
3131 log_unit_debug(u
, "D-Bus name %s no longer registered by %s", name
, old_owner
);
3133 log_unit_debug(u
, "D-Bus name %s now registered by %s", name
, new_owner
);
3135 s
->bus_name_good
= !!new_owner
;
3137 if (s
->type
== SERVICE_DBUS
) {
3139 /* service_enter_running() will figure out what to
3141 if (s
->state
== SERVICE_RUNNING
)
3142 service_enter_running(s
, SERVICE_SUCCESS
);
3143 else if (s
->state
== SERVICE_START
&& new_owner
)
3144 service_enter_start_post(s
);
3146 } else if (new_owner
&&
3148 (s
->state
== SERVICE_START
||
3149 s
->state
== SERVICE_START_POST
||
3150 s
->state
== SERVICE_RUNNING
||
3151 s
->state
== SERVICE_RELOAD
)) {
3153 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
3156 /* Try to acquire PID from bus service */
3158 r
= sd_bus_get_name_creds(u
->manager
->api_bus
, name
, SD_BUS_CREDS_PID
, &creds
);
3160 r
= sd_bus_creds_get_pid(creds
, &pid
);
3162 log_unit_debug(u
, "D-Bus name %s is now owned by process %u", name
, (unsigned) pid
);
3164 service_set_main_pid(s
, pid
);
3165 unit_watch_pid(UNIT(s
), pid
);
3170 int service_set_socket_fd(Service
*s
, int fd
, Socket
*sock
, bool selinux_context_net
) {
3171 _cleanup_free_
char *peer
= NULL
;
3177 /* This is called by the socket code when instantiating a new
3178 * service for a stream socket and the socket needs to be
3181 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
3184 if (s
->socket_fd
>= 0)
3187 if (s
->state
!= SERVICE_DEAD
)
3190 if (getpeername_pretty(fd
, true, &peer
) >= 0) {
3192 if (UNIT(s
)->description
) {
3193 _cleanup_free_
char *a
;
3195 a
= strjoin(UNIT(s
)->description
, " (", peer
, ")", NULL
);
3199 r
= unit_set_description(UNIT(s
), a
);
3201 r
= unit_set_description(UNIT(s
), peer
);
3208 s
->socket_fd_selinux_context_net
= selinux_context_net
;
3210 unit_ref_set(&s
->accept_socket
, UNIT(sock
));
3212 return unit_add_two_dependencies(UNIT(sock
), UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT(s
), false);
3215 static void service_reset_failed(Unit
*u
) {
3216 Service
*s
= SERVICE(u
);
3220 if (s
->state
== SERVICE_FAILED
)
3221 service_set_state(s
, SERVICE_DEAD
);
3223 s
->result
= SERVICE_SUCCESS
;
3224 s
->reload_result
= SERVICE_SUCCESS
;
3226 RATELIMIT_RESET(s
->start_limit
);
3229 static int service_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
3230 Service
*s
= SERVICE(u
);
3232 return unit_kill_common(u
, who
, signo
, s
->main_pid
, s
->control_pid
, error
);
3235 static const char* const service_restart_table
[_SERVICE_RESTART_MAX
] = {
3236 [SERVICE_RESTART_NO
] = "no",
3237 [SERVICE_RESTART_ON_SUCCESS
] = "on-success",
3238 [SERVICE_RESTART_ON_FAILURE
] = "on-failure",
3239 [SERVICE_RESTART_ON_ABNORMAL
] = "on-abnormal",
3240 [SERVICE_RESTART_ON_WATCHDOG
] = "on-watchdog",
3241 [SERVICE_RESTART_ON_ABORT
] = "on-abort",
3242 [SERVICE_RESTART_ALWAYS
] = "always",
3245 DEFINE_STRING_TABLE_LOOKUP(service_restart
, ServiceRestart
);
3247 static const char* const service_type_table
[_SERVICE_TYPE_MAX
] = {
3248 [SERVICE_SIMPLE
] = "simple",
3249 [SERVICE_FORKING
] = "forking",
3250 [SERVICE_ONESHOT
] = "oneshot",
3251 [SERVICE_DBUS
] = "dbus",
3252 [SERVICE_NOTIFY
] = "notify",
3253 [SERVICE_IDLE
] = "idle"
3256 DEFINE_STRING_TABLE_LOOKUP(service_type
, ServiceType
);
3258 static const char* const service_exec_command_table
[_SERVICE_EXEC_COMMAND_MAX
] = {
3259 [SERVICE_EXEC_START_PRE
] = "ExecStartPre",
3260 [SERVICE_EXEC_START
] = "ExecStart",
3261 [SERVICE_EXEC_START_POST
] = "ExecStartPost",
3262 [SERVICE_EXEC_RELOAD
] = "ExecReload",
3263 [SERVICE_EXEC_STOP
] = "ExecStop",
3264 [SERVICE_EXEC_STOP_POST
] = "ExecStopPost",
3267 DEFINE_STRING_TABLE_LOOKUP(service_exec_command
, ServiceExecCommand
);
3269 static const char* const notify_access_table
[_NOTIFY_ACCESS_MAX
] = {
3270 [NOTIFY_NONE
] = "none",
3271 [NOTIFY_MAIN
] = "main",
3272 [NOTIFY_ALL
] = "all"
3275 DEFINE_STRING_TABLE_LOOKUP(notify_access
, NotifyAccess
);
3277 static const char* const notify_state_table
[_NOTIFY_STATE_MAX
] = {
3278 [NOTIFY_UNKNOWN
] = "unknown",
3279 [NOTIFY_READY
] = "ready",
3280 [NOTIFY_RELOADING
] = "reloading",
3281 [NOTIFY_STOPPING
] = "stopping",
3284 DEFINE_STRING_TABLE_LOOKUP(notify_state
, NotifyState
);
3286 static const char* const service_result_table
[_SERVICE_RESULT_MAX
] = {
3287 [SERVICE_SUCCESS
] = "success",
3288 [SERVICE_FAILURE_RESOURCES
] = "resources",
3289 [SERVICE_FAILURE_TIMEOUT
] = "timeout",
3290 [SERVICE_FAILURE_EXIT_CODE
] = "exit-code",
3291 [SERVICE_FAILURE_SIGNAL
] = "signal",
3292 [SERVICE_FAILURE_CORE_DUMP
] = "core-dump",
3293 [SERVICE_FAILURE_WATCHDOG
] = "watchdog",
3294 [SERVICE_FAILURE_START_LIMIT
] = "start-limit"
3297 DEFINE_STRING_TABLE_LOOKUP(service_result
, ServiceResult
);
3299 const UnitVTable service_vtable
= {
3300 .object_size
= sizeof(Service
),
3301 .exec_context_offset
= offsetof(Service
, exec_context
),
3302 .cgroup_context_offset
= offsetof(Service
, cgroup_context
),
3303 .kill_context_offset
= offsetof(Service
, kill_context
),
3304 .exec_runtime_offset
= offsetof(Service
, exec_runtime
),
3310 .private_section
= "Service",
3312 .init
= service_init
,
3313 .done
= service_done
,
3314 .load
= service_load
,
3315 .release_resources
= service_release_resources
,
3317 .coldplug
= service_coldplug
,
3319 .dump
= service_dump
,
3321 .start
= service_start
,
3322 .stop
= service_stop
,
3323 .reload
= service_reload
,
3325 .can_reload
= service_can_reload
,
3327 .kill
= service_kill
,
3329 .serialize
= service_serialize
,
3330 .deserialize_item
= service_deserialize_item
,
3332 .active_state
= service_active_state
,
3333 .sub_state_to_string
= service_sub_state_to_string
,
3335 .check_gc
= service_check_gc
,
3337 .sigchld_event
= service_sigchld_event
,
3339 .reset_failed
= service_reset_failed
,
3341 .notify_cgroup_empty
= service_notify_cgroup_empty_event
,
3342 .notify_message
= service_notify_message
,
3344 .bus_name_owner_change
= service_bus_name_owner_change
,
3346 .bus_vtable
= bus_service_vtable
,
3347 .bus_set_property
= bus_service_set_property
,
3348 .bus_commit_properties
= bus_service_commit_properties
,
3350 .get_timeout
= service_get_timeout
,
3351 .can_transient
= true,
3353 .status_message_formats
= {
3354 .starting_stopping
= {
3355 [0] = "Starting %s...",
3356 [1] = "Stopping %s...",
3358 .finished_start_job
= {
3359 [JOB_DONE
] = "Started %s.",
3360 [JOB_FAILED
] = "Failed to start %s.",
3362 .finished_stop_job
= {
3363 [JOB_DONE
] = "Stopped %s.",
3364 [JOB_FAILED
] = "Stopped (with error) %s.",