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 .size = sizeof(cmd_recv),
731 .flags = KDBUS_RECV_PEEK,
733 struct kdbus_cmd_free cmd_free = {};
734 const char *comm = NULL;
735 struct kdbus_item *d;
737 size_t start, ps, sz, delta;
742 /* Generate a friendly debug log message about which process
743 * caused triggering of this bus name. This simply peeks the
744 * metadata of the first queued message and logs it. */
748 /* Let's shortcut things a bit, if debug logging is turned off
751 if (log_get_max_level() < LOG_DEBUG)
754 r = ioctl(n->starter_fd, KDBUS_CMD_RECV, &cmd_recv);
756 if (errno == EINTR || errno == EAGAIN)
759 log_unit_error(UNIT(n)->id, "%s: Failed to query activation message: %m", UNIT(n)->id);
763 /* We map as late as possible, and unmap imemdiately after
764 * use. On 32bit address space is scarce and we want to be
765 * able to handle a lot of activator connections at the same
766 * time, and hence shouldn't keep the mmap()s around for
767 * longer than necessary. */
770 start = (cmd_recv.reply.offset / ps) * ps;
771 delta = cmd_recv.reply.offset - start;
772 sz = PAGE_ALIGN(delta + cmd_recv.reply.msg_size);
774 p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
775 if (p == MAP_FAILED) {
776 log_unit_error(UNIT(n)->id, "%s: Failed to map activation message: %m", UNIT(n)->id);
781 k = (struct kdbus_msg *) ((uint8_t *) p + delta);
782 KDBUS_ITEM_FOREACH(d, k, items) {
785 case KDBUS_ITEM_PIDS:
789 case KDBUS_ITEM_PID_COMM:
796 log_unit_debug(UNIT(n)->id, "%s: Activation triggered by process " PID_FMT " (%s)", UNIT(n)->id, pid, strna(comm));
802 (void) munmap(p, sz);
804 cmd_free.offset = cmd_recv.reply.offset;
805 if (ioctl(n->starter_fd, KDBUS_CMD_FREE, &cmd_free) < 0)
806 log_unit_warning(UNIT(n)->id, "Failed to free peeked message, ignoring: %m");
811 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
812 BusName *n = userdata;
817 if (n->state != BUSNAME_LISTENING)
820 log_unit_debug(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
822 if (revents != EPOLLIN) {
823 log_unit_error(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
824 UNIT(n)->id, revents);
828 busname_peek_message(n);
829 busname_enter_running(n);
833 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
837 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
838 BusName *n = BUSNAME(u);
844 if (pid != n->control_pid)
849 if (is_clean_exit(code, status, NULL))
851 else if (code == CLD_EXITED)
852 f = BUSNAME_FAILURE_EXIT_CODE;
853 else if (code == CLD_KILLED)
854 f = BUSNAME_FAILURE_SIGNAL;
855 else if (code == CLD_DUMPED)
856 f = BUSNAME_FAILURE_CORE_DUMP;
858 assert_not_reached("Unknown sigchld code");
861 f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
862 "%s control process exited, code=%s status=%i",
863 u->id, sigchld_code_to_string(code), status);
865 if (f != BUSNAME_SUCCESS)
871 if (f == BUSNAME_SUCCESS)
872 busname_enter_listening(n);
874 busname_enter_signal(n, BUSNAME_SIGTERM, f);
877 case BUSNAME_SIGTERM:
878 case BUSNAME_SIGKILL:
879 busname_enter_dead(n, f);
883 assert_not_reached("Uh, control process died at wrong time.");
886 /* Notify clients about changed exit status */
887 unit_add_to_dbus_queue(u);
890 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
891 BusName *n = BUSNAME(userdata);
894 assert(n->timer_event_source == source);
899 log_unit_warning(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
900 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
903 case BUSNAME_SIGTERM:
904 log_unit_warning(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
905 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
908 case BUSNAME_SIGKILL:
909 log_unit_warning(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
910 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
914 assert_not_reached("Timeout at wrong time.");
920 static void busname_reset_failed(Unit *u) {
921 BusName *n = BUSNAME(u);
925 if (n->state == BUSNAME_FAILED)
926 busname_set_state(n, BUSNAME_DEAD);
928 n->result = BUSNAME_SUCCESS;
931 static void busname_trigger_notify(Unit *u, Unit *other) {
932 BusName *n = BUSNAME(u);
938 if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
941 if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
946 if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
947 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
948 else if (IN_SET(s->state,
949 SERVICE_DEAD, SERVICE_FAILED,
950 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
951 SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
952 SERVICE_AUTO_RESTART))
953 busname_enter_listening(n);
956 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
957 return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
960 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
961 BusName *n = BUSNAME(u);
964 if (!n->timer_event_source)
967 r = sd_event_source_get_time(n->timer_event_source, timeout);
974 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
975 [BUSNAME_DEAD] = "dead",
976 [BUSNAME_MAKING] = "making",
977 [BUSNAME_REGISTERED] = "registered",
978 [BUSNAME_LISTENING] = "listening",
979 [BUSNAME_RUNNING] = "running",
980 [BUSNAME_SIGTERM] = "sigterm",
981 [BUSNAME_SIGKILL] = "sigkill",
982 [BUSNAME_FAILED] = "failed",
985 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
987 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
988 [BUSNAME_SUCCESS] = "success",
989 [BUSNAME_FAILURE_RESOURCES] = "resources",
990 [BUSNAME_FAILURE_TIMEOUT] = "timeout",
991 [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
992 [BUSNAME_FAILURE_SIGNAL] = "signal",
993 [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
994 [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
997 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
999 const UnitVTable busname_vtable = {
1000 .object_size = sizeof(BusName),
1006 .private_section = "BusName",
1008 .init = busname_init,
1009 .done = busname_done,
1010 .load = busname_load,
1012 .coldplug = busname_coldplug,
1014 .dump = busname_dump,
1016 .start = busname_start,
1017 .stop = busname_stop,
1019 .kill = busname_kill,
1021 .get_timeout = busname_get_timeout,
1023 .serialize = busname_serialize,
1024 .deserialize_item = busname_deserialize_item,
1026 .active_state = busname_active_state,
1027 .sub_state_to_string = busname_sub_state_to_string,
1029 .sigchld_event = busname_sigchld_event,
1031 .trigger_notify = busname_trigger_notify,
1033 .reset_failed = busname_reset_failed,
1035 .bus_interface = "org.freedesktop.systemd1.BusName",
1036 .bus_vtable = bus_busname_vtable,
1038 .status_message_formats = {
1039 .finished_start_job = {
1040 [JOB_DONE] = "Listening on %s.",
1041 [JOB_FAILED] = "Failed to listen on %s.",
1042 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1043 [JOB_TIMEOUT] = "Timed out starting %s.",
1045 .finished_stop_job = {
1046 [JOB_DONE] = "Closed %s.",
1047 [JOB_FAILED] = "Failed stopping %s.",
1048 [JOB_TIMEOUT] = "Timed out stopping %s.",