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/>.
23 #include "bus-kernel.h"
24 #include "bus-internal.h"
27 #include "dbus-busname.h"
30 static const UnitActiveState state_translation_table[_BUSNAME_STATE_MAX] = {
31 [BUSNAME_DEAD] = UNIT_INACTIVE,
32 [BUSNAME_MAKING] = UNIT_ACTIVATING,
33 [BUSNAME_REGISTERED] = UNIT_ACTIVE,
34 [BUSNAME_LISTENING] = UNIT_ACTIVE,
35 [BUSNAME_RUNNING] = UNIT_ACTIVE,
36 [BUSNAME_SIGTERM] = UNIT_DEACTIVATING,
37 [BUSNAME_SIGKILL] = UNIT_DEACTIVATING,
38 [BUSNAME_FAILED] = UNIT_FAILED
41 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
42 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
44 static void busname_init(Unit *u) {
45 BusName *n = BUSNAME(u);
48 assert(u->load_state == UNIT_STUB);
54 n->timeout_usec = u->manager->default_timeout_start_usec;
57 static void busname_unwatch_control_pid(BusName *n) {
60 if (n->control_pid <= 0)
63 unit_unwatch_pid(UNIT(n), n->control_pid);
67 static void busname_free_policy(BusName *n) {
72 while ((p = n->policy)) {
73 LIST_REMOVE(policy, n->policy, p);
80 static void busname_close_fd(BusName *n) {
83 n->starter_event_source = sd_event_source_unref(n->starter_event_source);
84 n->starter_fd = safe_close(n->starter_fd);
87 static void busname_done(Unit *u) {
88 BusName *n = BUSNAME(u);
95 busname_free_policy(n);
96 busname_unwatch_control_pid(n);
99 unit_ref_unset(&n->service);
101 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
104 static int busname_arm_timer(BusName *n) {
109 if (n->timeout_usec <= 0) {
110 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
114 if (n->timer_event_source) {
115 r = sd_event_source_set_time(n->timer_event_source, now(CLOCK_MONOTONIC) + n->timeout_usec);
119 return sd_event_source_set_enabled(n->timer_event_source, SD_EVENT_ONESHOT);
122 return sd_event_add_time(
123 UNIT(n)->manager->event,
124 &n->timer_event_source,
126 now(CLOCK_MONOTONIC) + n->timeout_usec, 0,
127 busname_dispatch_timer, n);
130 static int busname_add_default_default_dependencies(BusName *n) {
135 r = unit_add_dependency_by_name(UNIT(n), UNIT_BEFORE, SPECIAL_BUSNAMES_TARGET, NULL, true);
139 if (UNIT(n)->manager->running_as == SYSTEMD_SYSTEM) {
140 r = unit_add_two_dependencies_by_name(UNIT(n), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
145 return unit_add_two_dependencies_by_name(UNIT(n), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
148 static int busname_add_extras(BusName *n) {
155 n->name = unit_name_to_prefix(u->id);
160 if (!u->description) {
161 r = unit_set_description(u, n->name);
167 if (!UNIT_DEREF(n->service)) {
170 r = unit_load_related_unit(u, ".service", &x);
174 unit_ref_set(&n->service, x);
177 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(n->service), true);
182 if (u->default_dependencies) {
183 r = busname_add_default_default_dependencies(n);
191 static int busname_verify(BusName *n) {
196 if (UNIT(n)->load_state != UNIT_LOADED)
199 if (!service_name_is_valid(n->name)) {
200 log_error_unit(UNIT(n)->id, "%s's Name= setting is not a valid service name Refusing.", UNIT(n)->id);
204 e = strappenda(n->name, ".busname");
205 if (!unit_has_name(UNIT(n), e)) {
206 log_error_unit(UNIT(n)->id, "%s's Name= setting doesn't match unit name. Refusing.", UNIT(n)->id);
213 static int busname_load(Unit *u) {
214 BusName *n = BUSNAME(u);
218 assert(u->load_state == UNIT_STUB);
220 r = unit_load_fragment_and_dropin(u);
224 if (u->load_state == UNIT_LOADED) {
225 /* This is a new unit? Then let's add in some extras */
226 r = busname_add_extras(n);
231 return busname_verify(n);
234 static void busname_dump(Unit *u, FILE *f, const char *prefix) {
235 BusName *n = BUSNAME(u);
241 "%sBus Name State: %s\n"
246 prefix, busname_state_to_string(n->state),
247 prefix, busname_result_to_string(n->result),
249 prefix, yes_no(n->activating),
250 prefix, yes_no(n->accept_fd));
252 if (n->control_pid > 0)
254 "%sControl PID: "PID_FMT"\n",
255 prefix, n->control_pid);
258 static void busname_unwatch_fd(BusName *n) {
263 if (!n->starter_event_source)
266 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_OFF);
268 log_debug_unit(UNIT(n)->id, "Failed to disable event source.");
271 static int busname_watch_fd(BusName *n) {
276 if (n->starter_fd < 0)
279 if (n->starter_event_source)
280 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_ON);
282 r = sd_event_add_io(UNIT(n)->manager->event, &n->starter_event_source, n->starter_fd, EPOLLIN, busname_dispatch_io, n);
284 log_warning_unit(UNIT(n)->id, "Failed to watch starter fd: %s", strerror(-r));
285 busname_unwatch_fd(n);
292 static int busname_open_fd(BusName *n) {
293 _cleanup_free_ char *path = NULL;
298 if (n->starter_fd >= 0)
301 mode = UNIT(n)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user";
302 n->starter_fd = bus_kernel_open_bus_fd(mode, &path);
303 if (n->starter_fd < 0) {
304 log_warning_unit(UNIT(n)->id, "Failed to open %s: %s",
305 path ?: "kdbus", strerror(-n->starter_fd));
306 return n->starter_fd;
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_debug_unit(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("Failed to create starter connection at step %s: %s", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD), strerror(-r));
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,
454 log_warning_unit(UNIT(n)->id, "%s failed to kill control process: %s", UNIT(n)->id, strerror(-r));
459 r = busname_arm_timer(n);
461 log_warning_unit(UNIT(n)->id, "%s failed to arm timer: %s", UNIT(n)->id, strerror(-r));
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_warning_unit(UNIT(n)->id, "%s failed to watch names: %s", UNIT(n)->id, strerror(-r));
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_warning_unit(UNIT(n)->id, "%s failed to fork 'making' task: %s", UNIT(n)->id, strerror(-r));
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_warning_unit(UNIT(n)->id, "%s failed to make starter: %s", UNIT(n)->id, strerror(-r));
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_debug_unit(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_warning_unit(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_error_unit(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_debug_unit(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_debug_unit(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_debug_unit(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_debug_unit(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_debug_unit(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_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
729 BusName *n = userdata;
734 if (n->state != BUSNAME_LISTENING)
737 log_debug_unit(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
739 if (revents != EPOLLIN) {
740 log_error_unit(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
741 UNIT(n)->id, revents);
745 busname_enter_running(n);
749 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
753 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
754 BusName *n = BUSNAME(u);
760 if (pid != n->control_pid)
765 if (is_clean_exit(code, status, NULL))
767 else if (code == CLD_EXITED)
768 f = BUSNAME_FAILURE_EXIT_CODE;
769 else if (code == CLD_KILLED)
770 f = BUSNAME_FAILURE_SIGNAL;
771 else if (code == CLD_DUMPED)
772 f = BUSNAME_FAILURE_CORE_DUMP;
774 assert_not_reached("Unknown sigchld code");
776 log_full_unit(f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
777 u->id, "%s control process exited, code=%s status=%i",
778 u->id, sigchld_code_to_string(code), status);
780 if (f != BUSNAME_SUCCESS)
786 if (f == BUSNAME_SUCCESS)
787 busname_enter_listening(n);
789 busname_enter_signal(n, BUSNAME_SIGTERM, f);
792 case BUSNAME_SIGTERM:
793 case BUSNAME_SIGKILL:
794 busname_enter_dead(n, f);
798 assert_not_reached("Uh, control process died at wrong time.");
801 /* Notify clients about changed exit status */
802 unit_add_to_dbus_queue(u);
805 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
806 BusName *n = BUSNAME(userdata);
809 assert(n->timer_event_source == source);
814 log_warning_unit(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
815 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
818 case BUSNAME_SIGTERM:
819 log_warning_unit(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
820 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
823 case BUSNAME_SIGKILL:
824 log_warning_unit(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
825 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
829 assert_not_reached("Timeout at wrong time.");
835 static void busname_reset_failed(Unit *u) {
836 BusName *n = BUSNAME(u);
840 if (n->state == BUSNAME_FAILED)
841 busname_set_state(n, BUSNAME_DEAD);
843 n->result = BUSNAME_SUCCESS;
846 static void busname_trigger_notify(Unit *u, Unit *other) {
847 BusName *n = BUSNAME(u);
853 if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
856 if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
861 if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
862 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
863 else if (IN_SET(s->state,
864 SERVICE_DEAD, SERVICE_FAILED,
865 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
866 SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
867 SERVICE_AUTO_RESTART))
868 busname_enter_listening(n);
871 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
872 return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
875 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
876 BusName *n = BUSNAME(u);
879 if (!n->timer_event_source)
882 r = sd_event_source_get_time(n->timer_event_source, timeout);
889 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
890 [BUSNAME_DEAD] = "dead",
891 [BUSNAME_MAKING] = "making",
892 [BUSNAME_REGISTERED] = "registered",
893 [BUSNAME_LISTENING] = "listening",
894 [BUSNAME_RUNNING] = "running",
895 [BUSNAME_SIGTERM] = "sigterm",
896 [BUSNAME_SIGKILL] = "sigkill",
897 [BUSNAME_FAILED] = "failed",
900 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
902 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
903 [BUSNAME_SUCCESS] = "success",
904 [BUSNAME_FAILURE_RESOURCES] = "resources",
905 [BUSNAME_FAILURE_TIMEOUT] = "timeout",
906 [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
907 [BUSNAME_FAILURE_SIGNAL] = "signal",
908 [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
909 [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
912 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
914 static const char* const busname_policy_access_table[_BUSNAME_POLICY_ACCESS_MAX] = {
915 [BUSNAME_POLICY_ACCESS_SEE] = "see",
916 [BUSNAME_POLICY_ACCESS_TALK] = "talk",
917 [BUSNAME_POLICY_ACCESS_OWN] = "own",
920 DEFINE_STRING_TABLE_LOOKUP(busname_policy_access, BusNamePolicyAccess);
922 const UnitVTable busname_vtable = {
923 .object_size = sizeof(BusName),
929 .private_section = "BusName",
931 .init = busname_init,
932 .done = busname_done,
933 .load = busname_load,
935 .coldplug = busname_coldplug,
937 .dump = busname_dump,
939 .start = busname_start,
940 .stop = busname_stop,
942 .kill = busname_kill,
944 .get_timeout = busname_get_timeout,
946 .serialize = busname_serialize,
947 .deserialize_item = busname_deserialize_item,
949 .active_state = busname_active_state,
950 .sub_state_to_string = busname_sub_state_to_string,
952 .sigchld_event = busname_sigchld_event,
954 .trigger_notify = busname_trigger_notify,
956 .reset_failed = busname_reset_failed,
958 .bus_interface = "org.freedesktop.systemd1.BusName",
959 .bus_vtable = bus_busname_vtable,
961 .status_message_formats = {
962 .finished_start_job = {
963 [JOB_DONE] = "Listening on %s.",
964 [JOB_FAILED] = "Failed to listen on %s.",
965 [JOB_DEPENDENCY] = "Dependency failed for %s.",
966 [JOB_TIMEOUT] = "Timed out starting %s.",
968 .finished_stop_job = {
969 [JOB_DONE] = "Closed %s.",
970 [JOB_FAILED] = "Failed stopping %s.",
971 [JOB_TIMEOUT] = "Timed out stopping %s.",