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) {
295 if (n->starter_fd >= 0)
298 n->starter_fd = bus_kernel_open_bus_fd(UNIT(n)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user");
299 if (n->starter_fd < 0) {
300 log_warning_unit(UNIT(n)->id, "Failed to create starter fd: %s", strerror(-n->starter_fd));
301 return n->starter_fd;
307 static void busname_set_state(BusName *n, BusNameState state) {
308 BusNameState old_state;
311 old_state = n->state;
314 if (!IN_SET(state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
315 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
316 busname_unwatch_control_pid(n);
319 if (state != BUSNAME_LISTENING)
320 busname_unwatch_fd(n);
322 if (!IN_SET(state, BUSNAME_LISTENING, BUSNAME_MAKING, BUSNAME_REGISTERED, BUSNAME_RUNNING))
325 if (state != old_state)
326 log_debug_unit(UNIT(n)->id, "%s changed %s -> %s",
327 UNIT(n)->id, busname_state_to_string(old_state), busname_state_to_string(state));
329 unit_notify(UNIT(n), state_translation_table[old_state], state_translation_table[state], true);
332 static int busname_coldplug(Unit *u) {
333 BusName *n = BUSNAME(u);
337 assert(n->state == BUSNAME_DEAD);
339 if (n->deserialized_state == n->state)
342 if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
344 if (n->control_pid <= 0)
347 r = unit_watch_pid(UNIT(n), n->control_pid);
351 r = busname_arm_timer(n);
356 if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) {
357 r = busname_open_fd(n);
362 if (n->deserialized_state == BUSNAME_LISTENING) {
363 r = busname_watch_fd(n);
368 busname_set_state(n, n->deserialized_state);
372 static int busname_make_starter(BusName *n, pid_t *_pid) {
376 r = busname_arm_timer(n);
380 /* We have to resolve the user/group names out-of-process,
381 * hence let's fork here. It's messy, but well, what can we
391 default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
392 ignore_signals(SIGPIPE, -1);
395 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, n->policy, n->policy_world);
397 ret = EXIT_MAKE_STARTER;
405 log_error("Failed to create starter connection at step %s: %s", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD), strerror(-r));
410 r = unit_watch_pid(UNIT(n), pid);
418 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
422 static void busname_enter_dead(BusName *n, BusNameResult f) {
425 if (f != BUSNAME_SUCCESS)
428 busname_set_state(n, n->result != BUSNAME_SUCCESS ? BUSNAME_FAILED : BUSNAME_DEAD);
431 static void busname_enter_signal(BusName *n, BusNameState state, BusNameResult f) {
432 KillContext kill_context = {};
437 if (f != BUSNAME_SUCCESS)
440 kill_context_init(&kill_context);
442 r = unit_kill_context(UNIT(n),
444 state != BUSNAME_SIGTERM,
449 log_warning_unit(UNIT(n)->id, "%s failed to kill control process: %s", UNIT(n)->id, strerror(-r));
454 r = busname_arm_timer(n);
456 log_warning_unit(UNIT(n)->id, "%s failed to arm timer: %s", UNIT(n)->id, strerror(-r));
460 busname_set_state(n, state);
461 } else if (state == BUSNAME_SIGTERM)
462 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_SUCCESS);
464 busname_enter_dead(n, BUSNAME_SUCCESS);
469 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
472 static void busname_enter_listening(BusName *n) {
478 r = busname_watch_fd(n);
480 log_warning_unit(UNIT(n)->id, "%s failed to watch names: %s", UNIT(n)->id, strerror(-r));
484 busname_set_state(n, BUSNAME_LISTENING);
486 busname_set_state(n, BUSNAME_REGISTERED);
491 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_RESOURCES);
494 static void busname_enter_making(BusName *n) {
499 r = busname_open_fd(n);
504 /* If there's a policy we need to resolve user/group
505 * names, which we can't do from PID1, hence let's
507 busname_unwatch_control_pid(n);
509 r = busname_make_starter(n, &n->control_pid);
511 log_warning_unit(UNIT(n)->id, "%s failed to fork 'making' task: %s", UNIT(n)->id, strerror(-r));
515 busname_set_state(n, BUSNAME_MAKING);
517 /* If there's no policy then we can do everything
518 * directly from PID 1, hence do so. */
520 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, NULL, n->policy_world);
522 log_warning_unit(UNIT(n)->id, "%s failed to make starter: %s", UNIT(n)->id, strerror(-r));
526 busname_enter_listening(n);
532 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
535 static void busname_enter_running(BusName *n) {
536 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
537 bool pending = false;
547 /* We don't take conenctions anymore if we are supposed to
548 * shut down anyway */
550 if (unit_stop_pending(UNIT(n))) {
551 log_debug_unit(UNIT(n)->id, "Suppressing activation request on %s since unit stop is scheduled.", UNIT(n)->id);
553 /* Flush all queued activation reqeuest by closing and reopening the connection */
554 bus_kernel_drop_one(n->starter_fd);
556 busname_enter_listening(n);
560 /* If there's already a start pending don't bother to do
562 SET_FOREACH(other, UNIT(n)->dependencies[UNIT_TRIGGERS], i)
563 if (unit_active_or_pending(other)) {
569 r = manager_add_job(UNIT(n)->manager, JOB_START, UNIT_DEREF(n->service), JOB_REPLACE, true, &error, NULL);
574 busname_set_state(n, BUSNAME_RUNNING);
578 log_warning_unit(UNIT(n)->id, "%s failed to queue service startup job: %s", UNIT(n)->id, bus_error_message(&error, r));
579 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
582 static int busname_start(Unit *u) {
583 BusName *n = BUSNAME(u);
587 /* We cannot fulfill this request right now, try again later
589 if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
593 if (n->state == BUSNAME_MAKING)
596 if (n->activating && UNIT_ISSET(n->service)) {
599 service = SERVICE(UNIT_DEREF(n->service));
601 if (UNIT(service)->load_state != UNIT_LOADED) {
602 log_error_unit(u->id, "Bus service %s not loaded, refusing.", UNIT(service)->id);
607 assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED));
609 n->result = BUSNAME_SUCCESS;
610 busname_enter_making(n);
615 static int busname_stop(Unit *u) {
616 BusName *n = BUSNAME(u);
621 if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
624 /* If there's already something running, we go directly into
627 if (n->state == BUSNAME_MAKING) {
628 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_SUCCESS);
632 assert(IN_SET(n->state, BUSNAME_REGISTERED, BUSNAME_LISTENING, BUSNAME_RUNNING));
634 busname_enter_dead(n, BUSNAME_SUCCESS);
638 static int busname_serialize(Unit *u, FILE *f, FDSet *fds) {
639 BusName *n = BUSNAME(u);
645 unit_serialize_item(u, f, "state", busname_state_to_string(n->state));
646 unit_serialize_item(u, f, "result", busname_result_to_string(n->result));
648 if (n->control_pid > 0)
649 unit_serialize_item_format(u, f, "control-pid", PID_FMT, n->control_pid);
651 if (n->starter_fd >= 0) {
654 copy = fdset_put_dup(fds, n->starter_fd);
658 unit_serialize_item_format(u, f, "starter-fd", "%i", copy);
664 static int busname_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
665 BusName *n = BUSNAME(u);
671 if (streq(key, "state")) {
674 state = busname_state_from_string(value);
676 log_debug_unit(u->id, "Failed to parse state value %s", value);
678 n->deserialized_state = state;
680 } else if (streq(key, "result")) {
683 f = busname_result_from_string(value);
685 log_debug_unit(u->id, "Failed to parse result value %s", value);
686 else if (f != BUSNAME_SUCCESS)
689 } else if (streq(key, "control-pid")) {
692 if (parse_pid(value, &pid) < 0)
693 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
695 n->control_pid = pid;
696 } else if (streq(key, "starter-fd")) {
699 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
700 log_debug_unit(u->id, "Failed to parse starter fd value %s", value);
702 safe_close(n->starter_fd);
703 n->starter_fd = fdset_remove(fds, fd);
706 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
711 _pure_ static UnitActiveState busname_active_state(Unit *u) {
714 return state_translation_table[BUSNAME(u)->state];
717 _pure_ static const char *busname_sub_state_to_string(Unit *u) {
720 return busname_state_to_string(BUSNAME(u)->state);
723 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
724 BusName *n = userdata;
729 if (n->state != BUSNAME_LISTENING)
732 log_debug_unit(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
734 if (revents != EPOLLIN) {
735 log_error_unit(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
736 UNIT(n)->id, revents);
740 busname_enter_running(n);
744 busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
748 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
749 BusName *n = BUSNAME(u);
755 if (pid != n->control_pid)
760 if (is_clean_exit(code, status, NULL))
762 else if (code == CLD_EXITED)
763 f = BUSNAME_FAILURE_EXIT_CODE;
764 else if (code == CLD_KILLED)
765 f = BUSNAME_FAILURE_SIGNAL;
766 else if (code == CLD_KILLED)
767 f = BUSNAME_FAILURE_CORE_DUMP;
769 assert_not_reached("Unknown sigchld code");
771 log_full_unit(f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
772 u->id, "%s control process exited, code=%s status=%i",
773 u->id, sigchld_code_to_string(code), status);
775 if (f != BUSNAME_SUCCESS)
781 if (f == BUSNAME_SUCCESS)
782 busname_enter_listening(n);
784 busname_enter_signal(n, BUSNAME_SIGTERM, f);
787 case BUSNAME_SIGTERM:
788 case BUSNAME_SIGKILL:
789 busname_enter_dead(n, f);
793 assert_not_reached("Uh, control process died at wrong time.");
796 /* Notify clients about changed exit status */
797 unit_add_to_dbus_queue(u);
800 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
801 BusName *n = BUSNAME(userdata);
804 assert(n->timer_event_source == source);
809 log_warning_unit(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
810 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
813 case BUSNAME_SIGTERM:
814 log_warning_unit(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
815 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
818 case BUSNAME_SIGKILL:
819 log_warning_unit(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
820 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
824 assert_not_reached("Timeout at wrong time.");
830 static void busname_reset_failed(Unit *u) {
831 BusName *n = BUSNAME(u);
835 if (n->state == BUSNAME_FAILED)
836 busname_set_state(n, BUSNAME_DEAD);
838 n->result = BUSNAME_SUCCESS;
841 static void busname_trigger_notify(Unit *u, Unit *other) {
842 BusName *n = BUSNAME(u);
848 if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
851 if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
856 if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
857 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
858 else if (IN_SET(s->state,
859 SERVICE_DEAD, SERVICE_FAILED,
860 SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
861 SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
862 SERVICE_AUTO_RESTART))
863 busname_enter_listening(n);
866 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
867 return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
870 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
871 BusName *n = BUSNAME(u);
874 if (!n->timer_event_source)
877 r = sd_event_source_get_time(n->timer_event_source, timeout);
884 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
885 [BUSNAME_DEAD] = "dead",
886 [BUSNAME_MAKING] = "making",
887 [BUSNAME_REGISTERED] = "registered",
888 [BUSNAME_LISTENING] = "listening",
889 [BUSNAME_RUNNING] = "running",
890 [BUSNAME_SIGTERM] = "sigterm",
891 [BUSNAME_SIGKILL] = "sigkill",
892 [BUSNAME_FAILED] = "failed",
895 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
897 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
898 [BUSNAME_SUCCESS] = "success",
899 [BUSNAME_FAILURE_RESOURCES] = "resources",
900 [BUSNAME_FAILURE_TIMEOUT] = "timeout",
901 [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
902 [BUSNAME_FAILURE_SIGNAL] = "signal",
903 [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
904 [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
907 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
909 static const char* const busname_policy_access_table[_BUSNAME_POLICY_ACCESS_MAX] = {
910 [BUSNAME_POLICY_ACCESS_SEE] = "see",
911 [BUSNAME_POLICY_ACCESS_TALK] = "talk",
912 [BUSNAME_POLICY_ACCESS_OWN] = "own",
915 DEFINE_STRING_TABLE_LOOKUP(busname_policy_access, BusNamePolicyAccess);
917 const UnitVTable busname_vtable = {
918 .object_size = sizeof(BusName),
924 .private_section = "BusName",
926 .init = busname_init,
927 .done = busname_done,
928 .load = busname_load,
930 .coldplug = busname_coldplug,
932 .dump = busname_dump,
934 .start = busname_start,
935 .stop = busname_stop,
937 .kill = busname_kill,
939 .get_timeout = busname_get_timeout,
941 .serialize = busname_serialize,
942 .deserialize_item = busname_deserialize_item,
944 .active_state = busname_active_state,
945 .sub_state_to_string = busname_sub_state_to_string,
947 .sigchld_event = busname_sigchld_event,
949 .trigger_notify = busname_trigger_notify,
951 .reset_failed = busname_reset_failed,
953 .bus_interface = "org.freedesktop.systemd1.BusName",
954 .bus_vtable = bus_busname_vtable,
956 .status_message_formats = {
957 .finished_start_job = {
958 [JOB_DONE] = "Listening on %s.",
959 [JOB_FAILED] = "Failed to listen on %s.",
960 [JOB_DEPENDENCY] = "Dependency failed for %s.",
961 [JOB_TIMEOUT] = "Timed out starting %s.",
963 .finished_stop_job = {
964 [JOB_DONE] = "Closed %s.",
965 [JOB_FAILED] = "Failed stopping %s.",
966 [JOB_TIMEOUT] = "Timed out stopping %s.",