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 "bus-kernel.h"
26 #include "bus-internal.h"
29 #include "dbus-busname.h"
33 static const UnitActiveState state_translation_table[_BUSNAME_STATE_MAX] = {
34 [BUSNAME_DEAD] = UNIT_INACTIVE,
35 [BUSNAME_MAKING] = UNIT_ACTIVATING,
36 [BUSNAME_REGISTERED] = UNIT_ACTIVE,
37 [BUSNAME_LISTENING] = UNIT_ACTIVE,
38 [BUSNAME_RUNNING] = UNIT_ACTIVE,
39 [BUSNAME_SIGTERM] = UNIT_DEACTIVATING,
40 [BUSNAME_SIGKILL] = UNIT_DEACTIVATING,
41 [BUSNAME_FAILED] = UNIT_FAILED
44 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
45 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
47 static void busname_init(Unit *u) {
48 BusName *n = BUSNAME(u);
51 assert(u->load_state == UNIT_STUB);
57 n->timeout_usec = u->manager->default_timeout_start_usec;
60 static void busname_unwatch_control_pid(BusName *n) {
63 if (n->control_pid <= 0)
66 unit_unwatch_pid(UNIT(n), n->control_pid);
70 static void busname_free_policy(BusName *n) {
75 while ((p = n->policy)) {
76 LIST_REMOVE(policy, n->policy, p);
83 static void busname_close_fd(BusName *n) {
86 n->starter_event_source = sd_event_source_unref(n->starter_event_source);
87 n->starter_fd = safe_close(n->starter_fd);
90 static void busname_done(Unit *u) {
91 BusName *n = BUSNAME(u);
98 busname_free_policy(n);
99 busname_unwatch_control_pid(n);
102 unit_ref_unset(&n->service);
104 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
107 static int busname_arm_timer(BusName *n) {
112 if (n->timeout_usec <= 0) {
113 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
117 if (n->timer_event_source) {
118 r = sd_event_source_set_time(n->timer_event_source, now(CLOCK_MONOTONIC) + n->timeout_usec);
122 return sd_event_source_set_enabled(n->timer_event_source, SD_EVENT_ONESHOT);
125 return sd_event_add_time(
126 UNIT(n)->manager->event,
127 &n->timer_event_source,
129 now(CLOCK_MONOTONIC) + n->timeout_usec, 0,
130 busname_dispatch_timer, n);
133 static int busname_add_default_default_dependencies(BusName *n) {
138 r = unit_add_dependency_by_name(UNIT(n), UNIT_BEFORE, SPECIAL_BUSNAMES_TARGET, NULL, true);
142 if (UNIT(n)->manager->running_as == SYSTEMD_SYSTEM) {
143 r = unit_add_two_dependencies_by_name(UNIT(n), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
148 return unit_add_two_dependencies_by_name(UNIT(n), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
151 static int busname_add_extras(BusName *n) {
158 n->name = unit_name_to_prefix(u->id);
163 if (!u->description) {
164 r = unit_set_description(u, n->name);
170 if (!UNIT_DEREF(n->service)) {
173 r = unit_load_related_unit(u, ".service", &x);
177 unit_ref_set(&n->service, x);
180 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(n->service), true);
185 if (u->default_dependencies) {
186 r = busname_add_default_default_dependencies(n);
194 static int busname_verify(BusName *n) {
199 if (UNIT(n)->load_state != UNIT_LOADED)
202 if (!service_name_is_valid(n->name)) {
203 log_unit_error(UNIT(n)->id, "%s's Name= setting is not a valid service name Refusing.", UNIT(n)->id);
207 e = strappenda(n->name, ".busname");
208 if (!unit_has_name(UNIT(n), e)) {
209 log_unit_error(UNIT(n)->id, "%s's Name= setting doesn't match unit name. Refusing.", UNIT(n)->id);
216 static int busname_load(Unit *u) {
217 BusName *n = BUSNAME(u);
221 assert(u->load_state == UNIT_STUB);
223 r = unit_load_fragment_and_dropin(u);
227 if (u->load_state == UNIT_LOADED) {
228 /* This is a new unit? Then let's add in some extras */
229 r = busname_add_extras(n);
234 return busname_verify(n);
237 static void busname_dump(Unit *u, FILE *f, const char *prefix) {
238 BusName *n = BUSNAME(u);
244 "%sBus Name State: %s\n"
249 prefix, busname_state_to_string(n->state),
250 prefix, busname_result_to_string(n->result),
252 prefix, yes_no(n->activating),
253 prefix, yes_no(n->accept_fd));
255 if (n->control_pid > 0)
257 "%sControl PID: "PID_FMT"\n",
258 prefix, n->control_pid);
261 static void busname_unwatch_fd(BusName *n) {
266 if (!n->starter_event_source)
269 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_OFF);
271 log_unit_debug(UNIT(n)->id, "Failed to disable event source.");
274 static int busname_watch_fd(BusName *n) {
279 if (n->starter_fd < 0)
282 if (n->starter_event_source)
283 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_ON);
285 r = sd_event_add_io(UNIT(n)->manager->event, &n->starter_event_source, n->starter_fd, EPOLLIN, busname_dispatch_io, n);
287 log_unit_warning_errno(UNIT(n)->id, r, "Failed to watch starter fd: %m");
288 busname_unwatch_fd(n);
295 static int busname_open_fd(BusName *n) {
296 _cleanup_free_ char *path = NULL;
301 if (n->starter_fd >= 0)
304 mode = UNIT(n)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user";
305 n->starter_fd = bus_kernel_open_bus_fd(mode, &path);
306 if (n->starter_fd < 0)
307 return log_unit_warning_errno(UNIT(n)->id, n->starter_fd, "Failed to open %s: %m", path ?: "kdbus");
312 static void busname_set_state(BusName *n, BusNameState state) {
313 BusNameState old_state;
316 old_state = n->state;
319 if (!IN_SET(state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
320 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
321 busname_unwatch_control_pid(n);
324 if (state != BUSNAME_LISTENING)
325 busname_unwatch_fd(n);
327 if (!IN_SET(state, BUSNAME_LISTENING, BUSNAME_MAKING, BUSNAME_REGISTERED, BUSNAME_RUNNING))
330 if (state != old_state)
331 log_unit_debug(UNIT(n)->id, "%s changed %s -> %s",
332 UNIT(n)->id, busname_state_to_string(old_state), busname_state_to_string(state));
334 unit_notify(UNIT(n), state_translation_table[old_state], state_translation_table[state], true);
337 static int busname_coldplug(Unit *u) {
338 BusName *n = BUSNAME(u);
342 assert(n->state == BUSNAME_DEAD);
344 if (n->deserialized_state == n->state)
347 if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
349 if (n->control_pid <= 0)
352 r = unit_watch_pid(UNIT(n), n->control_pid);
356 r = busname_arm_timer(n);
361 if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) {
362 r = busname_open_fd(n);
367 if (n->deserialized_state == BUSNAME_LISTENING) {
368 r = busname_watch_fd(n);
373 busname_set_state(n, n->deserialized_state);
377 static int busname_make_starter(BusName *n, pid_t *_pid) {
381 r = busname_arm_timer(n);
385 /* We have to resolve the user/group names out-of-process,
386 * hence let's fork here. It's messy, but well, what can we
396 default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
397 ignore_signals(SIGPIPE, -1);
400 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, n->policy, n->policy_world);
402 ret = EXIT_MAKE_STARTER;
410 log_error_errno(r, "Failed to create starter connection at step %s: %m", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD));
415 r = unit_watch_pid(UNIT(n), pid);
423 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
427 static void busname_enter_dead(BusName *n, BusNameResult f) {
430 if (f != BUSNAME_SUCCESS)
433 busname_set_state(n, n->result != BUSNAME_SUCCESS ? BUSNAME_FAILED : BUSNAME_DEAD);
436 static void busname_enter_signal(BusName *n, BusNameState state, BusNameResult f) {
437 KillContext kill_context = {};
442 if (f != BUSNAME_SUCCESS)
445 kill_context_init(&kill_context);
447 r = unit_kill_context(UNIT(n),
449 state != BUSNAME_SIGTERM ? KILL_KILL : KILL_TERMINATE,
454 log_unit_warning_errno(UNIT(n)->id, r, "%s failed to kill control process: %m", UNIT(n)->id);
459 r = busname_arm_timer(n);
461 log_unit_warning_errno(UNIT(n)->id, r, "%s failed to arm timer: %m", UNIT(n)->id);
465 busname_set_state(n, state);
466 } else if (state == BUSNAME_SIGTERM)
467 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_SUCCESS);
469 busname_enter_dead(n, BUSNAME_SUCCESS);
474 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
477 static void busname_enter_listening(BusName *n) {
483 r = busname_watch_fd(n);
485 log_unit_warning_errno(UNIT(n)->id, r, "%s failed to watch names: %m", UNIT(n)->id);
489 busname_set_state(n, BUSNAME_LISTENING);
491 busname_set_state(n, BUSNAME_REGISTERED);
496 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_RESOURCES);
499 static void busname_enter_making(BusName *n) {
504 r = busname_open_fd(n);
509 /* If there is a policy, we need to resolve user/group
510 * names, which we can't do from PID1, hence let's
512 busname_unwatch_control_pid(n);
514 r = busname_make_starter(n, &n->control_pid);
516 log_unit_warning_errno(UNIT(n)->id, r, "%s failed to fork 'making' task: %m", UNIT(n)->id);
520 busname_set_state(n, BUSNAME_MAKING);
522 /* If there is no policy, we can do everything
523 * directly from PID 1, hence do so. */
525 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, NULL, n->policy_world);
527 log_unit_warning_errno(UNIT(n)->id, r, "%s failed to make starter: %m", UNIT(n)->id);
531 busname_enter_listening(n);
537 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
540 static void busname_enter_running(BusName *n) {
541 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
542 bool pending = false;
552 /* We don't take conenctions anymore if we are supposed to
553 * shut down anyway */
555 if (unit_stop_pending(UNIT(n))) {
556 log_unit_debug(UNIT(n)->id, "Suppressing activation request on %s since unit stop is scheduled.", UNIT(n)->id);
558 /* Flush all queued activation reqeuest by closing and reopening the connection */
559 bus_kernel_drop_one(n->starter_fd);
561 busname_enter_listening(n);
565 /* If there's already a start pending don't bother to do
567 SET_FOREACH(other, UNIT(n)->dependencies[UNIT_TRIGGERS], i)
568 if (unit_active_or_pending(other)) {
574 r = manager_add_job(UNIT(n)->manager, JOB_START, UNIT_DEREF(n->service), JOB_REPLACE, true, &error, NULL);
579 busname_set_state(n, BUSNAME_RUNNING);
583 log_unit_warning(UNIT(n)->id, "%s failed to queue service startup job: %s", UNIT(n)->id, bus_error_message(&error, r));
584 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
587 static int busname_start(Unit *u) {
588 BusName *n = BUSNAME(u);
592 /* We cannot fulfill this request right now, try again later
594 if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
598 if (n->state == BUSNAME_MAKING)
601 if (n->activating && UNIT_ISSET(n->service)) {
604 service = SERVICE(UNIT_DEREF(n->service));
606 if (UNIT(service)->load_state != UNIT_LOADED) {
607 log_unit_error(u->id, "Bus service %s not loaded, refusing.", UNIT(service)->id);
612 assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED));
614 n->result = BUSNAME_SUCCESS;
615 busname_enter_making(n);
620 static int busname_stop(Unit *u) {
621 BusName *n = BUSNAME(u);
626 if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
629 /* If there's already something running, we go directly into
632 if (n->state == BUSNAME_MAKING) {
633 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_SUCCESS);
637 assert(IN_SET(n->state, BUSNAME_REGISTERED, BUSNAME_LISTENING, BUSNAME_RUNNING));
639 busname_enter_dead(n, BUSNAME_SUCCESS);
643 static int busname_serialize(Unit *u, FILE *f, FDSet *fds) {
644 BusName *n = BUSNAME(u);
650 unit_serialize_item(u, f, "state", busname_state_to_string(n->state));
651 unit_serialize_item(u, f, "result", busname_result_to_string(n->result));
653 if (n->control_pid > 0)
654 unit_serialize_item_format(u, f, "control-pid", PID_FMT, n->control_pid);
656 if (n->starter_fd >= 0) {
659 copy = fdset_put_dup(fds, n->starter_fd);
663 unit_serialize_item_format(u, f, "starter-fd", "%i", copy);
669 static int busname_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
670 BusName *n = BUSNAME(u);
676 if (streq(key, "state")) {
679 state = busname_state_from_string(value);
681 log_unit_debug(u->id, "Failed to parse state value %s", value);
683 n->deserialized_state = state;
685 } else if (streq(key, "result")) {
688 f = busname_result_from_string(value);
690 log_unit_debug(u->id, "Failed to parse result value %s", value);
691 else if (f != BUSNAME_SUCCESS)
694 } else if (streq(key, "control-pid")) {
697 if (parse_pid(value, &pid) < 0)
698 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
700 n->control_pid = pid;
701 } else if (streq(key, "starter-fd")) {
704 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
705 log_unit_debug(u->id, "Failed to parse starter fd value %s", value);
707 safe_close(n->starter_fd);
708 n->starter_fd = fdset_remove(fds, fd);
711 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
716 _pure_ static UnitActiveState busname_active_state(Unit *u) {
719 return state_translation_table[BUSNAME(u)->state];
722 _pure_ static const char *busname_sub_state_to_string(Unit *u) {
725 return busname_state_to_string(BUSNAME(u)->state);
728 static int busname_peek_message(BusName *n) {
729 struct kdbus_cmd_recv cmd_recv = {
730 .flags = KDBUS_RECV_PEEK,
732 struct kdbus_cmd_free cmd_free = {};
733 const char *comm = NULL;
734 struct kdbus_item *d;
736 size_t start, ps, sz, delta;
741 /* Generate a friendly debug log message about which process
742 * caused triggering of this bus name. This simply peeks the
743 * metadata of the first queued message and logs it. */
747 /* Let's shortcut things a bit, if debug logging is turned off
750 if (log_get_max_level() < LOG_DEBUG)
753 r = ioctl(n->starter_fd, KDBUS_CMD_MSG_RECV, &cmd_recv);
755 if (errno == EINTR || errno == EAGAIN)
758 log_unit_error(UNIT(n)->id, "%s: Failed to query activation message: %m", UNIT(n)->id);
762 /* We map as late as possible, and unmap imemdiately after
763 * use. On 32bit address space is scarce and we want to be
764 * able to handle a lot of activator connections at the same
765 * time, and hence shouldn't keep the mmap()s around for
766 * longer than necessary. */
769 start = (cmd_recv.offset / ps) * ps;
770 delta = cmd_recv.offset - start;
771 sz = PAGE_ALIGN(delta + cmd_recv.msg_size);
773 p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
774 if (p == MAP_FAILED) {
775 log_unit_error(UNIT(n)->id, "%s: Failed to map activation message: %m", UNIT(n)->id);
780 k = (struct kdbus_msg *) ((uint8_t *) p + delta);
781 KDBUS_ITEM_FOREACH(d, k, items) {
784 case KDBUS_ITEM_PIDS:
788 case KDBUS_ITEM_PID_COMM:
795 log_unit_debug(UNIT(n)->id, "%s: Activation triggered by process " PID_FMT " (%s)", UNIT(n)->id, pid, strna(comm));
801 (void) munmap(p, sz);
803 cmd_free.offset = cmd_recv.offset;
804 if (ioctl(n->starter_fd, KDBUS_CMD_FREE, &cmd_free) < 0)
805 log_unit_warning(UNIT(n)->id, "Failed to free peeked message, ignoring: %m");
810 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
811 BusName *n = userdata;
816 if (n->state != BUSNAME_LISTENING)
819 log_unit_debug(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
821 if (revents != EPOLLIN) {
822 log_unit_error(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
823 UNIT(n)->id, revents);
827 busname_peek_message(n);
828 busname_enter_running(n);
832 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
836 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
837 BusName *n = BUSNAME(u);
843 if (pid != n->control_pid)
848 if (is_clean_exit(code, status, NULL))
850 else if (code == CLD_EXITED)
851 f = BUSNAME_FAILURE_EXIT_CODE;
852 else if (code == CLD_KILLED)
853 f = BUSNAME_FAILURE_SIGNAL;
854 else if (code == CLD_DUMPED)
855 f = BUSNAME_FAILURE_CORE_DUMP;
857 assert_not_reached("Unknown sigchld code");
860 f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
861 "%s control process exited, code=%s status=%i",
862 u->id, sigchld_code_to_string(code), status);
864 if (f != BUSNAME_SUCCESS)
870 if (f == BUSNAME_SUCCESS)
871 busname_enter_listening(n);
873 busname_enter_signal(n, BUSNAME_SIGTERM, f);
876 case BUSNAME_SIGTERM:
877 case BUSNAME_SIGKILL:
878 busname_enter_dead(n, f);
882 assert_not_reached("Uh, control process died at wrong time.");
885 /* Notify clients about changed exit status */
886 unit_add_to_dbus_queue(u);
889 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
890 BusName *n = BUSNAME(userdata);
893 assert(n->timer_event_source == source);
898 log_unit_warning(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
899 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
902 case BUSNAME_SIGTERM:
903 log_unit_warning(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
904 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
907 case BUSNAME_SIGKILL:
908 log_unit_warning(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
909 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
913 assert_not_reached("Timeout at wrong time.");
919 static void busname_reset_failed(Unit *u) {
920 BusName *n = BUSNAME(u);
924 if (n->state == BUSNAME_FAILED)
925 busname_set_state(n, BUSNAME_DEAD);
927 n->result = BUSNAME_SUCCESS;
930 static void busname_trigger_notify(Unit *u, Unit *other) {
931 BusName *n = BUSNAME(u);
937 if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
940 if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
945 if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
946 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
947 else if (IN_SET(s->state,
948 SERVICE_DEAD, SERVICE_FAILED,
949 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
950 SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
951 SERVICE_AUTO_RESTART))
952 busname_enter_listening(n);
955 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
956 return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
959 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
960 BusName *n = BUSNAME(u);
963 if (!n->timer_event_source)
966 r = sd_event_source_get_time(n->timer_event_source, timeout);
973 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
974 [BUSNAME_DEAD] = "dead",
975 [BUSNAME_MAKING] = "making",
976 [BUSNAME_REGISTERED] = "registered",
977 [BUSNAME_LISTENING] = "listening",
978 [BUSNAME_RUNNING] = "running",
979 [BUSNAME_SIGTERM] = "sigterm",
980 [BUSNAME_SIGKILL] = "sigkill",
981 [BUSNAME_FAILED] = "failed",
984 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
986 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
987 [BUSNAME_SUCCESS] = "success",
988 [BUSNAME_FAILURE_RESOURCES] = "resources",
989 [BUSNAME_FAILURE_TIMEOUT] = "timeout",
990 [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
991 [BUSNAME_FAILURE_SIGNAL] = "signal",
992 [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
993 [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
996 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
998 const UnitVTable busname_vtable = {
999 .object_size = sizeof(BusName),
1005 .private_section = "BusName",
1007 .init = busname_init,
1008 .done = busname_done,
1009 .load = busname_load,
1011 .coldplug = busname_coldplug,
1013 .dump = busname_dump,
1015 .start = busname_start,
1016 .stop = busname_stop,
1018 .kill = busname_kill,
1020 .get_timeout = busname_get_timeout,
1022 .serialize = busname_serialize,
1023 .deserialize_item = busname_deserialize_item,
1025 .active_state = busname_active_state,
1026 .sub_state_to_string = busname_sub_state_to_string,
1028 .sigchld_event = busname_sigchld_event,
1030 .trigger_notify = busname_trigger_notify,
1032 .reset_failed = busname_reset_failed,
1034 .bus_interface = "org.freedesktop.systemd1.BusName",
1035 .bus_vtable = bus_busname_vtable,
1037 .status_message_formats = {
1038 .finished_start_job = {
1039 [JOB_DONE] = "Listening on %s.",
1040 [JOB_FAILED] = "Failed to listen on %s.",
1041 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1042 [JOB_TIMEOUT] = "Timed out starting %s.",
1044 .finished_stop_job = {
1045 [JOB_DONE] = "Closed %s.",
1046 [JOB_FAILED] = "Failed stopping %s.",
1047 [JOB_TIMEOUT] = "Timed out stopping %s.",