1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 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/>.
25 #include "formats-util.h"
26 #include "signal-util.h"
27 #include "bus-kernel.h"
28 #include "bus-internal.h"
31 #include "bus-policy.h"
33 #include "dbus-busname.h"
36 static const UnitActiveState state_translation_table
[_BUSNAME_STATE_MAX
] = {
37 [BUSNAME_DEAD
] = UNIT_INACTIVE
,
38 [BUSNAME_MAKING
] = UNIT_ACTIVATING
,
39 [BUSNAME_REGISTERED
] = UNIT_ACTIVE
,
40 [BUSNAME_LISTENING
] = UNIT_ACTIVE
,
41 [BUSNAME_RUNNING
] = UNIT_ACTIVE
,
42 [BUSNAME_SIGTERM
] = UNIT_DEACTIVATING
,
43 [BUSNAME_SIGKILL
] = UNIT_DEACTIVATING
,
44 [BUSNAME_FAILED
] = UNIT_FAILED
47 static int busname_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
48 static int busname_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
50 static void busname_init(Unit
*u
) {
51 BusName
*n
= BUSNAME(u
);
54 assert(u
->load_state
== UNIT_STUB
);
60 n
->timeout_usec
= u
->manager
->default_timeout_start_usec
;
63 static void busname_unwatch_control_pid(BusName
*n
) {
66 if (n
->control_pid
<= 0)
69 unit_unwatch_pid(UNIT(n
), n
->control_pid
);
73 static void busname_free_policy(BusName
*n
) {
78 while ((p
= n
->policy
)) {
79 LIST_REMOVE(policy
, n
->policy
, p
);
86 static void busname_close_fd(BusName
*n
) {
89 n
->starter_event_source
= sd_event_source_unref(n
->starter_event_source
);
90 n
->starter_fd
= safe_close(n
->starter_fd
);
93 static void busname_done(Unit
*u
) {
94 BusName
*n
= BUSNAME(u
);
98 n
->name
= mfree(n
->name
);
100 busname_free_policy(n
);
101 busname_unwatch_control_pid(n
);
104 unit_ref_unset(&n
->service
);
106 n
->timer_event_source
= sd_event_source_unref(n
->timer_event_source
);
109 static int busname_arm_timer(BusName
*n
) {
114 if (n
->timeout_usec
<= 0) {
115 n
->timer_event_source
= sd_event_source_unref(n
->timer_event_source
);
119 if (n
->timer_event_source
) {
120 r
= sd_event_source_set_time(n
->timer_event_source
, now(CLOCK_MONOTONIC
) + n
->timeout_usec
);
124 return sd_event_source_set_enabled(n
->timer_event_source
, SD_EVENT_ONESHOT
);
127 r
= sd_event_add_time(
128 UNIT(n
)->manager
->event
,
129 &n
->timer_event_source
,
131 now(CLOCK_MONOTONIC
) + n
->timeout_usec
, 0,
132 busname_dispatch_timer
, n
);
136 (void) sd_event_source_set_description(n
->timer_event_source
, "busname-timer");
141 static int busname_add_default_default_dependencies(BusName
*n
) {
146 r
= unit_add_dependency_by_name(UNIT(n
), UNIT_BEFORE
, SPECIAL_BUSNAMES_TARGET
, NULL
, true);
150 if (UNIT(n
)->manager
->running_as
== MANAGER_SYSTEM
) {
151 r
= unit_add_two_dependencies_by_name(UNIT(n
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true);
156 return unit_add_two_dependencies_by_name(UNIT(n
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
159 static int busname_add_extras(BusName
*n
) {
166 r
= unit_name_to_prefix(u
->id
, &n
->name
);
171 if (!u
->description
) {
172 r
= unit_set_description(u
, n
->name
);
178 if (!UNIT_DEREF(n
->service
)) {
181 r
= unit_load_related_unit(u
, ".service", &x
);
185 unit_ref_set(&n
->service
, x
);
188 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT_DEREF(n
->service
), true);
193 if (u
->default_dependencies
) {
194 r
= busname_add_default_default_dependencies(n
);
202 static int busname_verify(BusName
*n
) {
207 if (UNIT(n
)->load_state
!= UNIT_LOADED
)
210 if (!service_name_is_valid(n
->name
)) {
211 log_unit_error(UNIT(n
), "Name= setting is not a valid service name Refusing.");
215 e
= strjoina(n
->name
, ".busname");
216 if (!unit_has_name(UNIT(n
), e
)) {
217 log_unit_error(UNIT(n
), "Name= setting doesn't match unit name. Refusing.");
224 static int busname_load(Unit
*u
) {
225 BusName
*n
= BUSNAME(u
);
229 assert(u
->load_state
== UNIT_STUB
);
231 r
= unit_load_fragment_and_dropin(u
);
235 if (u
->load_state
== UNIT_LOADED
) {
236 /* This is a new unit? Then let's add in some extras */
237 r
= busname_add_extras(n
);
242 return busname_verify(n
);
245 static void busname_dump(Unit
*u
, FILE *f
, const char *prefix
) {
246 BusName
*n
= BUSNAME(u
);
252 "%sBus Name State: %s\n"
257 prefix
, busname_state_to_string(n
->state
),
258 prefix
, busname_result_to_string(n
->result
),
260 prefix
, yes_no(n
->activating
),
261 prefix
, yes_no(n
->accept_fd
));
263 if (n
->control_pid
> 0)
265 "%sControl PID: "PID_FMT
"\n",
266 prefix
, n
->control_pid
);
269 static void busname_unwatch_fd(BusName
*n
) {
274 if (!n
->starter_event_source
)
277 r
= sd_event_source_set_enabled(n
->starter_event_source
, SD_EVENT_OFF
);
279 log_unit_debug_errno(UNIT(n
), r
, "Failed to disable event source: %m");
282 static int busname_watch_fd(BusName
*n
) {
287 if (n
->starter_fd
< 0)
290 if (n
->starter_event_source
) {
291 r
= sd_event_source_set_enabled(n
->starter_event_source
, SD_EVENT_ON
);
295 r
= sd_event_add_io(UNIT(n
)->manager
->event
, &n
->starter_event_source
, n
->starter_fd
, EPOLLIN
, busname_dispatch_io
, n
);
299 (void) sd_event_source_set_description(n
->starter_event_source
, "busname-starter");
305 log_unit_warning_errno(UNIT(n
), r
, "Failed to watch starter fd: %m");
306 busname_unwatch_fd(n
);
310 static int busname_open_fd(BusName
*n
) {
311 _cleanup_free_
char *path
= NULL
;
316 if (n
->starter_fd
>= 0)
319 mode
= UNIT(n
)->manager
->running_as
== MANAGER_SYSTEM
? "system" : "user";
320 n
->starter_fd
= bus_kernel_open_bus_fd(mode
, &path
);
321 if (n
->starter_fd
< 0)
322 return log_unit_warning_errno(UNIT(n
), n
->starter_fd
, "Failed to open %s: %m", path
?: "kdbus");
327 static void busname_set_state(BusName
*n
, BusNameState state
) {
328 BusNameState old_state
;
331 old_state
= n
->state
;
334 if (!IN_SET(state
, BUSNAME_MAKING
, BUSNAME_SIGTERM
, BUSNAME_SIGKILL
)) {
335 n
->timer_event_source
= sd_event_source_unref(n
->timer_event_source
);
336 busname_unwatch_control_pid(n
);
339 if (state
!= BUSNAME_LISTENING
)
340 busname_unwatch_fd(n
);
342 if (!IN_SET(state
, BUSNAME_LISTENING
, BUSNAME_MAKING
, BUSNAME_REGISTERED
, BUSNAME_RUNNING
))
345 if (state
!= old_state
)
346 log_unit_debug(UNIT(n
), "Changed %s -> %s", busname_state_to_string(old_state
), busname_state_to_string(state
));
348 unit_notify(UNIT(n
), state_translation_table
[old_state
], state_translation_table
[state
], true);
351 static int busname_coldplug(Unit
*u
) {
352 BusName
*n
= BUSNAME(u
);
356 assert(n
->state
== BUSNAME_DEAD
);
358 if (n
->deserialized_state
== n
->state
)
361 if (IN_SET(n
->deserialized_state
, BUSNAME_MAKING
, BUSNAME_SIGTERM
, BUSNAME_SIGKILL
)) {
363 if (n
->control_pid
<= 0)
366 r
= unit_watch_pid(UNIT(n
), n
->control_pid
);
370 r
= busname_arm_timer(n
);
375 if (IN_SET(n
->deserialized_state
, BUSNAME_MAKING
, BUSNAME_LISTENING
, BUSNAME_REGISTERED
, BUSNAME_RUNNING
)) {
376 r
= busname_open_fd(n
);
381 if (n
->deserialized_state
== BUSNAME_LISTENING
) {
382 r
= busname_watch_fd(n
);
387 busname_set_state(n
, n
->deserialized_state
);
391 static int busname_make_starter(BusName
*n
, pid_t
*_pid
) {
395 r
= busname_arm_timer(n
);
399 /* We have to resolve the user/group names out-of-process,
400 * hence let's fork here. It's messy, but well, what can we
410 (void) default_signals(SIGNALS_CRASH_HANDLER
, SIGNALS_IGNORE
, -1);
411 (void) ignore_signals(SIGPIPE
, -1);
414 r
= bus_kernel_make_starter(n
->starter_fd
, n
->name
, n
->activating
, n
->accept_fd
, n
->policy
, n
->policy_world
);
416 ret
= EXIT_MAKE_STARTER
;
424 log_error_errno(r
, "Failed to create starter connection at step %s: %m", exit_status_to_string(ret
, EXIT_STATUS_SYSTEMD
));
429 r
= unit_watch_pid(UNIT(n
), pid
);
437 n
->timer_event_source
= sd_event_source_unref(n
->timer_event_source
);
441 static void busname_enter_dead(BusName
*n
, BusNameResult f
) {
444 if (f
!= BUSNAME_SUCCESS
)
447 busname_set_state(n
, n
->result
!= BUSNAME_SUCCESS
? BUSNAME_FAILED
: BUSNAME_DEAD
);
450 static void busname_enter_signal(BusName
*n
, BusNameState state
, BusNameResult f
) {
451 KillContext kill_context
= {};
456 if (f
!= BUSNAME_SUCCESS
)
459 kill_context_init(&kill_context
);
461 r
= unit_kill_context(UNIT(n
),
463 state
!= BUSNAME_SIGTERM
? KILL_KILL
: KILL_TERMINATE
,
468 log_unit_warning_errno(UNIT(n
), r
, "Failed to kill control process: %m");
473 r
= busname_arm_timer(n
);
475 log_unit_warning_errno(UNIT(n
), r
, "Failed to arm timer: %m");
479 busname_set_state(n
, state
);
480 } else if (state
== BUSNAME_SIGTERM
)
481 busname_enter_signal(n
, BUSNAME_SIGKILL
, BUSNAME_SUCCESS
);
483 busname_enter_dead(n
, BUSNAME_SUCCESS
);
488 busname_enter_dead(n
, BUSNAME_FAILURE_RESOURCES
);
491 static void busname_enter_listening(BusName
*n
) {
497 r
= busname_watch_fd(n
);
499 log_unit_warning_errno(UNIT(n
), r
, "Failed to watch names: %m");
503 busname_set_state(n
, BUSNAME_LISTENING
);
505 busname_set_state(n
, BUSNAME_REGISTERED
);
510 busname_enter_signal(n
, BUSNAME_SIGTERM
, BUSNAME_FAILURE_RESOURCES
);
513 static void busname_enter_making(BusName
*n
) {
518 r
= busname_open_fd(n
);
523 /* If there is a policy, we need to resolve user/group
524 * names, which we can't do from PID1, hence let's
526 busname_unwatch_control_pid(n
);
528 r
= busname_make_starter(n
, &n
->control_pid
);
530 log_unit_warning_errno(UNIT(n
), r
, "Failed to fork 'making' task: %m");
534 busname_set_state(n
, BUSNAME_MAKING
);
536 /* If there is no policy, we can do everything
537 * directly from PID 1, hence do so. */
539 r
= bus_kernel_make_starter(n
->starter_fd
, n
->name
, n
->activating
, n
->accept_fd
, NULL
, n
->policy_world
);
541 log_unit_warning_errno(UNIT(n
), r
, "Failed to make starter: %m");
545 busname_enter_listening(n
);
551 busname_enter_dead(n
, BUSNAME_FAILURE_RESOURCES
);
554 static void busname_enter_running(BusName
*n
) {
555 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
556 bool pending
= false;
566 /* We don't take connections anymore if we are supposed to
567 * shut down anyway */
569 if (unit_stop_pending(UNIT(n
))) {
570 log_unit_debug(UNIT(n
), "Suppressing activation request since unit stop is scheduled.");
572 /* Flush all queued activation reqeuest by closing and reopening the connection */
573 bus_kernel_drop_one(n
->starter_fd
);
575 busname_enter_listening(n
);
579 /* If there's already a start pending don't bother to do
581 SET_FOREACH(other
, UNIT(n
)->dependencies
[UNIT_TRIGGERS
], i
)
582 if (unit_active_or_pending(other
)) {
588 r
= manager_add_job(UNIT(n
)->manager
, JOB_START
, UNIT_DEREF(n
->service
), JOB_REPLACE
, true, &error
, NULL
);
593 busname_set_state(n
, BUSNAME_RUNNING
);
597 log_unit_warning(UNIT(n
), "Failed to queue service startup job: %s", bus_error_message(&error
, r
));
598 busname_enter_dead(n
, BUSNAME_FAILURE_RESOURCES
);
601 static int busname_start(Unit
*u
) {
602 BusName
*n
= BUSNAME(u
);
606 /* We cannot fulfill this request right now, try again later
608 if (IN_SET(n
->state
, BUSNAME_SIGTERM
, BUSNAME_SIGKILL
))
612 if (n
->state
== BUSNAME_MAKING
)
615 if (n
->activating
&& UNIT_ISSET(n
->service
)) {
618 service
= SERVICE(UNIT_DEREF(n
->service
));
620 if (UNIT(service
)->load_state
!= UNIT_LOADED
) {
621 log_unit_error(u
, "Bus service %s not loaded, refusing.", UNIT(service
)->id
);
626 assert(IN_SET(n
->state
, BUSNAME_DEAD
, BUSNAME_FAILED
));
628 n
->result
= BUSNAME_SUCCESS
;
629 busname_enter_making(n
);
634 static int busname_stop(Unit
*u
) {
635 BusName
*n
= BUSNAME(u
);
640 if (IN_SET(n
->state
, BUSNAME_SIGTERM
, BUSNAME_SIGKILL
))
643 /* If there's already something running, we go directly into
646 if (n
->state
== BUSNAME_MAKING
) {
647 busname_enter_signal(n
, BUSNAME_SIGTERM
, BUSNAME_SUCCESS
);
651 assert(IN_SET(n
->state
, BUSNAME_REGISTERED
, BUSNAME_LISTENING
, BUSNAME_RUNNING
));
653 busname_enter_dead(n
, BUSNAME_SUCCESS
);
657 static int busname_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
658 BusName
*n
= BUSNAME(u
);
665 unit_serialize_item(u
, f
, "state", busname_state_to_string(n
->state
));
666 unit_serialize_item(u
, f
, "result", busname_result_to_string(n
->result
));
668 if (n
->control_pid
> 0)
669 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, n
->control_pid
);
671 r
= unit_serialize_item_fd(u
, f
, fds
, "starter-fd", n
->starter_fd
);
678 static int busname_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
679 BusName
*n
= BUSNAME(u
);
685 if (streq(key
, "state")) {
688 state
= busname_state_from_string(value
);
690 log_unit_debug(u
, "Failed to parse state value: %s", value
);
692 n
->deserialized_state
= state
;
694 } else if (streq(key
, "result")) {
697 f
= busname_result_from_string(value
);
699 log_unit_debug(u
, "Failed to parse result value: %s", value
);
700 else if (f
!= BUSNAME_SUCCESS
)
703 } else if (streq(key
, "control-pid")) {
706 if (parse_pid(value
, &pid
) < 0)
707 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
709 n
->control_pid
= pid
;
710 } else if (streq(key
, "starter-fd")) {
713 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
714 log_unit_debug(u
, "Failed to parse starter fd value: %s", value
);
716 safe_close(n
->starter_fd
);
717 n
->starter_fd
= fdset_remove(fds
, fd
);
720 log_unit_debug(u
, "Unknown serialization key: %s", key
);
725 _pure_
static UnitActiveState
busname_active_state(Unit
*u
) {
728 return state_translation_table
[BUSNAME(u
)->state
];
731 _pure_
static const char *busname_sub_state_to_string(Unit
*u
) {
734 return busname_state_to_string(BUSNAME(u
)->state
);
737 static int busname_peek_message(BusName
*n
) {
738 struct kdbus_cmd_recv cmd_recv
= {
739 .size
= sizeof(cmd_recv
),
740 .flags
= KDBUS_RECV_PEEK
,
742 struct kdbus_cmd_free cmd_free
= {
743 .size
= sizeof(cmd_free
),
745 const char *comm
= NULL
;
746 struct kdbus_item
*d
;
748 size_t start
, ps
, sz
, delta
;
753 /* Generate a friendly debug log message about which process
754 * caused triggering of this bus name. This simply peeks the
755 * metadata of the first queued message and logs it. */
759 /* Let's shortcut things a bit, if debug logging is turned off
762 if (log_get_max_level() < LOG_DEBUG
)
765 r
= ioctl(n
->starter_fd
, KDBUS_CMD_RECV
, &cmd_recv
);
767 if (errno
== EINTR
|| errno
== EAGAIN
)
770 return log_unit_error_errno(UNIT(n
), errno
, "Failed to query activation message: %m");
773 /* We map as late as possible, and unmap imemdiately after
774 * use. On 32bit address space is scarce and we want to be
775 * able to handle a lot of activator connections at the same
776 * time, and hence shouldn't keep the mmap()s around for
777 * longer than necessary. */
780 start
= (cmd_recv
.msg
.offset
/ ps
) * ps
;
781 delta
= cmd_recv
.msg
.offset
- start
;
782 sz
= PAGE_ALIGN(delta
+ cmd_recv
.msg
.msg_size
);
784 p
= mmap(NULL
, sz
, PROT_READ
, MAP_SHARED
, n
->starter_fd
, start
);
785 if (p
== MAP_FAILED
) {
786 r
= log_unit_error_errno(UNIT(n
), errno
, "Failed to map activation message: %m");
790 k
= (struct kdbus_msg
*) ((uint8_t *) p
+ delta
);
791 KDBUS_ITEM_FOREACH(d
, k
, items
) {
794 case KDBUS_ITEM_PIDS
:
798 case KDBUS_ITEM_PID_COMM
:
805 log_unit_debug(UNIT(n
), "Activation triggered by process " PID_FMT
" (%s)", pid
, strna(comm
));
811 (void) munmap(p
, sz
);
813 cmd_free
.offset
= cmd_recv
.msg
.offset
;
814 if (ioctl(n
->starter_fd
, KDBUS_CMD_FREE
, &cmd_free
) < 0)
815 log_unit_warning(UNIT(n
), "Failed to free peeked message, ignoring: %m");
820 static int busname_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
821 BusName
*n
= userdata
;
826 if (n
->state
!= BUSNAME_LISTENING
)
829 log_unit_debug(UNIT(n
), "Activation request");
831 if (revents
!= EPOLLIN
) {
832 log_unit_error(UNIT(n
), "Got unexpected poll event (0x%x) on starter fd.", revents
);
836 busname_peek_message(n
);
837 busname_enter_running(n
);
841 busname_enter_dead(n
, BUSNAME_FAILURE_RESOURCES
);
845 static void busname_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
846 BusName
*n
= BUSNAME(u
);
852 if (pid
!= n
->control_pid
)
857 if (is_clean_exit(code
, status
, NULL
))
859 else if (code
== CLD_EXITED
)
860 f
= BUSNAME_FAILURE_EXIT_CODE
;
861 else if (code
== CLD_KILLED
)
862 f
= BUSNAME_FAILURE_SIGNAL
;
863 else if (code
== CLD_DUMPED
)
864 f
= BUSNAME_FAILURE_CORE_DUMP
;
866 assert_not_reached("Unknown sigchld code");
868 log_unit_full(u
, f
== BUSNAME_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
869 "Control process exited, code=%s status=%i", sigchld_code_to_string(code
), status
);
871 if (f
!= BUSNAME_SUCCESS
)
877 if (f
== BUSNAME_SUCCESS
)
878 busname_enter_listening(n
);
880 busname_enter_signal(n
, BUSNAME_SIGTERM
, f
);
883 case BUSNAME_SIGTERM
:
884 case BUSNAME_SIGKILL
:
885 busname_enter_dead(n
, f
);
889 assert_not_reached("Uh, control process died at wrong time.");
892 /* Notify clients about changed exit status */
893 unit_add_to_dbus_queue(u
);
896 static int busname_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
897 BusName
*n
= BUSNAME(userdata
);
900 assert(n
->timer_event_source
== source
);
905 log_unit_warning(UNIT(n
), "Making timed out. Terminating.");
906 busname_enter_signal(n
, BUSNAME_SIGTERM
, BUSNAME_FAILURE_TIMEOUT
);
909 case BUSNAME_SIGTERM
:
910 log_unit_warning(UNIT(n
), "Stopping timed out. Killing.");
911 busname_enter_signal(n
, BUSNAME_SIGKILL
, BUSNAME_FAILURE_TIMEOUT
);
914 case BUSNAME_SIGKILL
:
915 log_unit_warning(UNIT(n
), "Processes still around after SIGKILL. Ignoring.");
916 busname_enter_dead(n
, BUSNAME_FAILURE_TIMEOUT
);
920 assert_not_reached("Timeout at wrong time.");
926 static void busname_reset_failed(Unit
*u
) {
927 BusName
*n
= BUSNAME(u
);
931 if (n
->state
== BUSNAME_FAILED
)
932 busname_set_state(n
, BUSNAME_DEAD
);
934 n
->result
= BUSNAME_SUCCESS
;
937 static void busname_trigger_notify(Unit
*u
, Unit
*other
) {
938 BusName
*n
= BUSNAME(u
);
944 if (!IN_SET(n
->state
, BUSNAME_RUNNING
, BUSNAME_LISTENING
))
947 if (other
->load_state
!= UNIT_LOADED
|| other
->type
!= UNIT_SERVICE
)
952 if (s
->state
== SERVICE_FAILED
&& s
->result
== SERVICE_FAILURE_START_LIMIT
)
953 busname_enter_dead(n
, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT
);
954 else if (IN_SET(s
->state
,
955 SERVICE_DEAD
, SERVICE_FAILED
,
956 SERVICE_STOP
, SERVICE_STOP_SIGTERM
, SERVICE_STOP_SIGKILL
,
957 SERVICE_STOP_POST
, SERVICE_FINAL_SIGTERM
, SERVICE_FINAL_SIGKILL
,
958 SERVICE_AUTO_RESTART
))
959 busname_enter_listening(n
);
962 static int busname_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
963 return unit_kill_common(u
, who
, signo
, -1, BUSNAME(u
)->control_pid
, error
);
966 static int busname_get_timeout(Unit
*u
, uint64_t *timeout
) {
967 BusName
*n
= BUSNAME(u
);
970 if (!n
->timer_event_source
)
973 r
= sd_event_source_get_time(n
->timer_event_source
, timeout
);
980 static bool busname_supported(void) {
981 static int supported
= -1;
984 supported
= is_kdbus_available();
989 static const char* const busname_result_table
[_BUSNAME_RESULT_MAX
] = {
990 [BUSNAME_SUCCESS
] = "success",
991 [BUSNAME_FAILURE_RESOURCES
] = "resources",
992 [BUSNAME_FAILURE_TIMEOUT
] = "timeout",
993 [BUSNAME_FAILURE_EXIT_CODE
] = "exit-code",
994 [BUSNAME_FAILURE_SIGNAL
] = "signal",
995 [BUSNAME_FAILURE_CORE_DUMP
] = "core-dump",
996 [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT
] = "service-failed-permanent",
999 DEFINE_STRING_TABLE_LOOKUP(busname_result
, BusNameResult
);
1001 const UnitVTable busname_vtable
= {
1002 .object_size
= sizeof(BusName
),
1008 .private_section
= "BusName",
1011 .no_instances
= true,
1013 .init
= busname_init
,
1014 .done
= busname_done
,
1015 .load
= busname_load
,
1017 .coldplug
= busname_coldplug
,
1019 .dump
= busname_dump
,
1021 .start
= busname_start
,
1022 .stop
= busname_stop
,
1024 .kill
= busname_kill
,
1026 .get_timeout
= busname_get_timeout
,
1028 .serialize
= busname_serialize
,
1029 .deserialize_item
= busname_deserialize_item
,
1031 .active_state
= busname_active_state
,
1032 .sub_state_to_string
= busname_sub_state_to_string
,
1034 .sigchld_event
= busname_sigchld_event
,
1036 .trigger_notify
= busname_trigger_notify
,
1038 .reset_failed
= busname_reset_failed
,
1040 .supported
= busname_supported
,
1042 .bus_vtable
= bus_busname_vtable
,
1044 .status_message_formats
= {
1045 .finished_start_job
= {
1046 [JOB_DONE
] = "Listening on %s.",
1047 [JOB_FAILED
] = "Failed to listen on %s.",
1049 .finished_stop_job
= {
1050 [JOB_DONE
] = "Closed %s.",
1051 [JOB_FAILED
] = "Failed stopping %s.",