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/>.
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
33 #include "bus-internal.h"
34 #include "bus-message.h"
35 #include "bus-kernel.h"
36 #include "bus-bloom.h"
39 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
41 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
47 if (!startswith(s, ":1."))
50 r = safe_atou64(s + 3, id);
57 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
63 /* Note that p can be NULL, which encodes a region full of
64 * zeroes, which is useful to optimize certain padding
67 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
68 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
69 (*d)->vec.address = PTR_TO_UINT64(p);
72 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
75 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
81 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
82 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
83 (*d)->memfd.fd = memfd;
84 (*d)->memfd.size = sz;
86 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
89 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
95 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
96 (*d)->type = KDBUS_ITEM_DST_NAME;
97 memcpy((*d)->str, s, length + 1);
99 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
102 static void* append_bloom(struct kdbus_item **d, size_t length) {
109 (*d)->size = offsetof(struct kdbus_item, data) + length;
110 (*d)->type = KDBUS_ITEM_BLOOM;
113 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
118 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
124 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
125 (*d)->type = KDBUS_ITEM_FDS;
126 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
128 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
131 static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) {
138 memset(bloom, 0, BLOOM_SIZE);
140 bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type));
143 bloom_add_pair(bloom, "interface", m->interface);
145 bloom_add_pair(bloom, "member", m->member);
147 bloom_add_pair(bloom, "path", m->path);
148 bloom_add_pair(bloom, "path-slash-prefix", m->path);
149 bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/');
152 r = sd_bus_message_rewind(m, true);
156 for (i = 0; i < 64; i++) {
159 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
162 r = sd_bus_message_peek_type(m, &type, NULL);
166 if (type != SD_BUS_TYPE_STRING &&
167 type != SD_BUS_TYPE_OBJECT_PATH &&
168 type != SD_BUS_TYPE_SIGNATURE)
171 r = sd_bus_message_read_basic(m, type, &t);
175 e = stpcpy(buf, "arg");
179 *(e++) = '0' + (i / 10);
180 *(e++) = '0' + (i % 10);
184 bloom_add_pair(bloom, buf, t);
186 strcpy(e, "-dot-prefix");
187 bloom_add_prefixes(bloom, buf, t, '.');
188 strcpy(e, "-slash-prefix");
189 bloom_add_prefixes(bloom, buf, t, '/');
195 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
196 struct bus_body_part *part;
197 struct kdbus_item *d;
211 if (m->destination) {
212 r = bus_kernel_parse_unique_name(m->destination, &unique);
220 sz = offsetof(struct kdbus_msg, items);
222 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
223 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
225 /* Add in fixed header, fields header and payload */
226 sz += (1 + m->n_body_parts) *
227 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
229 /* Add space for bloom filter */
230 sz += ALIGN8(offsetof(struct kdbus_item, data) + BLOOM_SIZE);
232 /* Add in well-known destination header */
234 dl = strlen(m->destination);
235 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
238 /* Add space for unix fds */
240 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
242 m->kdbus = memalign(8, sz);
248 m->free_kdbus = true;
249 memset(m->kdbus, 0, sz);
252 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
253 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
256 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
257 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
258 m->kdbus->cookie = m->header->serial;
260 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
265 append_destination(&d, m->destination, dl);
267 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
269 MESSAGE_FOREACH_PART(part, i, m) {
271 /* If this is padding then simply send a
272 * vector with a NULL data pointer which the
273 * kernel will just pass through. This is the
274 * most efficient way to encode zeroes */
276 append_payload_vec(&d, NULL, part->size);
280 if (part->memfd >= 0 && part->sealed && m->destination) {
281 /* Try to send a memfd, if the part is
282 * sealed and this is not a broadcast. Since we can only */
284 append_payload_memfd(&d, part->memfd, part->size);
288 /* Otherwise let's send a vector to the actual data,
289 * for that we need to map it first. */
290 r = bus_body_part_map(part);
294 append_payload_vec(&d, part->data, part->size);
297 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
300 p = append_bloom(&d, BLOOM_SIZE);
301 r = bus_message_setup_bloom(m, p);
307 append_fds(&d, m->fds, m->n_fds);
309 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
310 assert(m->kdbus->size <= sz);
319 int bus_kernel_take_fd(sd_bus *b) {
320 struct kdbus_cmd_hello *hello;
321 struct kdbus_item *item;
332 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items));
334 if (b->fake_creds_valid)
335 sz += ALIGN8(offsetof(struct kdbus_item, creds)) + sizeof(struct kdbus_creds);
338 l = strlen(b->fake_label);
339 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
344 hello->conn_flags = b->hello_flags;
345 hello->attach_flags = b->attach_flags;
346 hello->pool_size = KDBUS_POOL_SIZE;
350 if (b->fake_creds_valid) {
351 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
352 item->type = KDBUS_ITEM_CREDS;
353 item->creds = b->fake_creds;
355 item = KDBUS_ITEM_NEXT(item);
359 item->size = offsetof(struct kdbus_item, str) + l + 1;
360 memcpy(item->str, b->fake_label, l+1);
363 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
367 if (!b->kdbus_buffer) {
368 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
369 if (b->kdbus_buffer == MAP_FAILED) {
370 b->kdbus_buffer = NULL;
375 /* The higher 32bit of both flags fields are considered
376 * 'incompatible flags'. Refuse them all for now. */
377 if (hello->bus_flags > 0xFFFFFFFFULL ||
378 hello->conn_flags > 0xFFFFFFFFULL)
381 if (hello->bloom_size != BLOOM_SIZE)
384 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
387 b->unique_id = hello->id;
390 b->bus_client = true;
391 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
392 b->message_version = 2;
393 b->message_endian = BUS_NATIVE_ENDIAN;
395 /* the kernel told us the UUID of the underlying bus */
396 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
398 return bus_start_running(b);
401 int bus_kernel_connect(sd_bus *b) {
403 assert(b->input_fd < 0);
404 assert(b->output_fd < 0);
410 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
414 b->output_fd = b->input_fd;
416 return bus_kernel_take_fd(b);
419 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
424 assert(bus->state == BUS_RUNNING);
426 /* If we can't deliver, we want room for the error message */
427 r = bus_rqueue_make_room(bus);
431 r = bus_message_setup_kmsg(bus, m);
435 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
437 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
438 sd_bus_message *reply;
440 if (errno == EAGAIN || errno == EINTR)
442 else if (errno == ENXIO || errno == ESRCH) {
444 /* ENXIO: unique name not known
445 * ESRCH: well-known name not known */
447 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
448 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
450 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
454 } else if (errno == EADDRNOTAVAIL) {
456 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
458 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
459 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
461 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
467 r = bus_message_new_synthetic_error(
469 BUS_MESSAGE_SERIAL(m),
476 r = bus_seal_synthetic_message(bus, reply);
480 bus->rqueue[bus->rqueue_size++] = reply;
488 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
490 struct kdbus_item *d;
495 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
496 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
498 KDBUS_ITEM_FOREACH(d, k, items) {
500 if (d->type == KDBUS_ITEM_FDS)
501 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
502 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
503 close_nointr_nofail(d->memfd.fd);
507 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
508 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
513 r = sd_bus_message_new_signal(
515 "/org/freedesktop/DBus",
516 "org.freedesktop.DBus",
522 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
526 m->sender = "org.freedesktop.DBus";
528 r = bus_seal_synthetic_message(bus, m);
532 bus->rqueue[bus->rqueue_size++] = m;
538 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
539 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
545 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
548 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
550 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
552 if (isempty(old_owner))
557 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
559 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
562 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
563 char owner[UNIQUE_NAME_MAX];
569 sprintf(owner, ":1.%llu", d->id_change.id);
571 return push_name_owner_changed(
573 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
574 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
577 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
578 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
585 r = bus_message_new_synthetic_error(
588 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
589 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
590 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
595 m->sender = "org.freedesktop.DBus";
597 r = bus_seal_synthetic_message(bus, m);
601 bus->rqueue[bus->rqueue_size++] = m;
607 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
608 struct kdbus_item *d, *found = NULL;
610 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
611 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
612 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
613 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
615 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
616 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
618 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
619 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
624 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
626 KDBUS_ITEM_FOREACH(d, k, items) {
627 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
632 log_debug("Got unknown field from kernel %llu", d->type);
636 log_debug("Didn't find a kernel message to translate.");
640 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
643 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
644 sd_bus_message *m = NULL;
645 struct kdbus_item *d;
647 _cleanup_free_ int *fds = NULL;
648 struct bus_header *h = NULL;
649 size_t total, n_bytes = 0, idx = 0;
650 const char *destination = NULL, *seclabel = NULL;
655 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
657 KDBUS_ITEM_FOREACH(d, k, items) {
660 l = d->size - offsetof(struct kdbus_item, data);
664 case KDBUS_ITEM_PAYLOAD_OFF:
666 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
668 if (!bus_header_is_complete(h, d->vec.size))
672 n_bytes += d->vec.size;
675 case KDBUS_ITEM_PAYLOAD_MEMFD:
679 n_bytes += d->memfd.size;
682 case KDBUS_ITEM_FDS: {
687 f = realloc(fds, sizeof(int) * (n_fds + j));
692 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
697 case KDBUS_ITEM_SECLABEL:
706 r = bus_header_message_size(h, &total);
710 if (n_bytes != total)
713 /* on kdbus we only speak native endian gvariant, never dbus1
714 * marshalling or reverse endian */
715 if (h->version != 2 ||
716 h->endian != BUS_NATIVE_ENDIAN)
719 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
723 /* The well-known names list is different from the other
724 credentials. If we asked for it, but nothing is there, this
725 means that the list of well-known names is simply empty, not
726 that we lack any data */
728 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
730 KDBUS_ITEM_FOREACH(d, k, items) {
733 l = d->size - offsetof(struct kdbus_item, data);
737 case KDBUS_ITEM_PAYLOAD_OFF: {
740 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
742 if (idx + d->vec.size > begin_body) {
743 struct bus_body_part *part;
745 /* Contains body material */
747 part = message_append_part(m);
753 /* A -1 offset is NUL padding. */
754 part->is_zero = d->vec.offset == ~0ULL;
756 if (idx >= begin_body) {
758 part->data = (uint8_t *)k + d->vec.offset;
759 part->size = d->vec.size;
762 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
763 part->size = d->vec.size - (begin_body - idx);
773 case KDBUS_ITEM_PAYLOAD_MEMFD: {
774 struct bus_body_part *part;
776 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
781 part = message_append_part(m);
787 part->memfd = d->memfd.fd;
788 part->size = d->memfd.size;
791 idx += d->memfd.size;
795 case KDBUS_ITEM_CREDS:
796 /* UID/GID/PID are always valid */
797 m->creds.uid = d->creds.uid;
798 m->creds.gid = d->creds.gid;
799 m->creds.pid = d->creds.pid;
800 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
802 /* The PID starttime/TID might be missing
803 * however, when the data is faked by some
804 * data bus proxy and it lacks that
805 * information about the real client since
806 * SO_PEERCRED is used for that */
808 if (d->creds.starttime > 0) {
809 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
810 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
813 if (d->creds.tid > 0) {
814 m->creds.tid = d->creds.tid;
815 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
819 case KDBUS_ITEM_TIMESTAMP:
820 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
821 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
824 case KDBUS_ITEM_PID_COMM:
825 m->creds.comm = d->str;
826 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
829 case KDBUS_ITEM_TID_COMM:
830 m->creds.tid_comm = d->str;
831 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
835 m->creds.exe = d->str;
836 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
839 case KDBUS_ITEM_CMDLINE:
840 m->creds.cmdline = d->str;
841 m->creds.cmdline_size = l;
842 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
845 case KDBUS_ITEM_CGROUP:
846 m->creds.cgroup = d->str;
847 m->creds.mask |= (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID) & bus->creds_mask;
850 case KDBUS_ITEM_AUDIT:
851 m->creds.audit_session_id = d->audit.sessionid;
852 m->creds.audit_login_uid = d->audit.loginuid;
853 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
856 case KDBUS_ITEM_CAPS:
857 m->creds.capability = d->data;
858 m->creds.capability_size = l;
859 m->creds.mask |= (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS) & bus->creds_mask;
862 case KDBUS_ITEM_DST_NAME:
863 destination = d->str;
866 case KDBUS_ITEM_NAME:
867 r = strv_extend(&m->creds.well_known_names, d->name.name);
873 case KDBUS_ITEM_SECLABEL:
877 log_debug("Got unknown field from kernel %llu", d->type);
881 r = bus_message_parse_fields(m);
885 /* Override information from the user header with data from the kernel */
886 if (k->src_id == KDBUS_SRC_ID_KERNEL)
887 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
889 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
890 m->sender = m->creds.unique_name = m->sender_buffer;
894 m->destination = destination;
895 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
896 m->destination = NULL;
897 else if (k->dst_id == KDBUS_DST_ID_NAME)
898 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
900 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
901 m->destination = m->destination_buffer;
904 /* We take possession of the kmsg struct now */
906 m->release_kdbus = true;
910 bus->rqueue[bus->rqueue_size++] = m;
916 struct bus_body_part *part;
919 /* Make sure the memfds are not freed twice */
920 MESSAGE_FOREACH_PART(part, i, m)
921 if (part->memfd >= 0)
924 sd_bus_message_unref(m);
930 int bus_kernel_read_message(sd_bus *bus) {
937 r = bus_rqueue_make_room(bus);
941 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
948 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
950 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
951 r = bus_kernel_make_message(bus, k);
953 /* Anybody can send us invalid messages, let's just drop them. */
954 if (r == -EBADMSG || r == -EPROTOTYPE) {
955 log_debug("Ignoring invalid message: %s", strerror(-r));
959 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
960 r = bus_kernel_translate_message(bus, k);
965 close_kdbus_msg(bus, k);
967 return r < 0 ? r : 1;
970 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
971 struct memfd_cache *c;
978 if (!bus || !bus->is_kernel)
981 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
983 if (bus->n_memfd_cache <= 0) {
986 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
988 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
998 c = &bus->memfd_cache[--bus->n_memfd_cache];
1001 assert(c->mapped == 0 || c->address);
1003 *address = c->address;
1004 *mapped = c->mapped;
1005 *allocated = c->allocated;
1008 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1013 static void close_and_munmap(int fd, void *address, size_t size) {
1015 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1017 close_nointr_nofail(fd);
1020 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1021 struct memfd_cache *c;
1022 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1025 assert(mapped == 0 || address);
1027 if (!bus || !bus->is_kernel) {
1028 close_and_munmap(fd, address, mapped);
1032 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1034 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1035 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1037 close_and_munmap(fd, address, mapped);
1041 c = &bus->memfd_cache[bus->n_memfd_cache++];
1043 c->address = address;
1045 /* If overly long, let's return a bit to the OS */
1046 if (mapped > max_mapped) {
1047 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1048 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1049 c->mapped = c->allocated = max_mapped;
1052 c->allocated = allocated;
1055 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1058 void bus_kernel_flush_memfd(sd_bus *b) {
1063 for (i = 0; i < b->n_memfd_cache; i++)
1064 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1067 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1070 assert(kdbus_flags);
1072 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1073 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1075 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1076 f |= KDBUS_NAME_REPLACE_EXISTING;
1078 if (flags & SD_BUS_NAME_QUEUE)
1079 f |= KDBUS_NAME_QUEUE;
1085 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1090 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1091 m |= KDBUS_ATTACH_CREDS;
1093 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1094 m |= KDBUS_ATTACH_COMM;
1096 if (mask & SD_BUS_CREDS_EXE)
1097 m |= KDBUS_ATTACH_EXE;
1099 if (mask & SD_BUS_CREDS_CMDLINE)
1100 m |= KDBUS_ATTACH_CMDLINE;
1102 if (mask & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID))
1103 m |= KDBUS_ATTACH_CGROUP;
1105 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1106 m |= KDBUS_ATTACH_CAPS;
1108 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1109 m |= KDBUS_ATTACH_SECLABEL;
1111 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1112 m |= KDBUS_ATTACH_AUDIT;
1114 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1115 m |= KDBUS_ATTACH_NAMES;
1121 int bus_kernel_create_bus(const char *name, char **s) {
1122 struct kdbus_cmd_make *make;
1123 struct kdbus_item *n;
1129 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1133 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1134 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1135 offsetof(struct kdbus_item, str) +
1136 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1138 make->size = offsetof(struct kdbus_cmd_make, items);
1141 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1142 n->type = KDBUS_ITEM_BLOOM_SIZE;
1143 n->data64[0] = BLOOM_SIZE;
1144 assert_cc(BLOOM_SIZE % 8 == 0);
1145 make->size += ALIGN8(n->size);
1147 n = KDBUS_ITEM_NEXT(n);
1148 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1149 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1150 n->type = KDBUS_ITEM_MAKE_NAME;
1151 make->size += ALIGN8(n->size);
1153 make->flags = KDBUS_MAKE_POLICY_OPEN;
1155 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1156 close_nointr_nofail(fd);
1160 /* The higher 32bit of the flags field are considered
1161 * 'incompatible flags'. Refuse them all for now. */
1162 if (make->flags > 0xFFFFFFFFULL) {
1163 close_nointr_nofail(fd);
1170 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1172 close_nointr_nofail(fd);
1182 int bus_kernel_create_starter(const char *bus, const char *name) {
1183 struct kdbus_cmd_hello *hello;
1184 struct kdbus_item *n;
1191 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1192 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1194 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1198 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1199 offsetof(struct kdbus_item, str) +
1203 strcpy(n->str, name);
1204 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1205 n->type = KDBUS_ITEM_NAME;
1207 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1208 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1209 hello->pool_size = KDBUS_POOL_SIZE;
1211 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1212 close_nointr_nofail(fd);
1216 /* The higher 32bit of both flags fields are considered
1217 * 'incompatible flags'. Refuse them all for now. */
1218 if (hello->bus_flags > 0xFFFFFFFFULL ||
1219 hello->conn_flags > 0xFFFFFFFFULL) {
1220 close_nointr_nofail(fd);
1224 if (hello->bloom_size != BLOOM_SIZE) {
1225 close_nointr_nofail(fd);
1232 int bus_kernel_create_namespace(const char *name, char **s) {
1233 struct kdbus_cmd_make *make;
1234 struct kdbus_item *n;
1240 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1244 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1245 offsetof(struct kdbus_item, str) +
1249 strcpy(n->str, name);
1250 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1251 n->type = KDBUS_ITEM_MAKE_NAME;
1253 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1254 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1256 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1257 close_nointr_nofail(fd);
1261 /* The higher 32bit of the flags field are considered
1262 * 'incompatible flags'. Refuse them all for now. */
1263 if (make->flags > 0xFFFFFFFFULL) {
1264 close_nointr_nofail(fd);
1271 p = strappend("/dev/kdbus/ns/", name);
1273 close_nointr_nofail(fd);
1283 int bus_kernel_create_monitor(const char *bus) {
1284 struct kdbus_cmd_hello *hello;
1290 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1291 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1293 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1297 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1298 hello->size = sizeof(struct kdbus_cmd_hello);
1299 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1300 hello->pool_size = KDBUS_POOL_SIZE;
1302 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1303 close_nointr_nofail(fd);
1307 /* The higher 32bit of both flags fields are considered
1308 * 'incompatible flags'. Refuse them all for now. */
1309 if (hello->bus_flags > 0xFFFFFFFFULL ||
1310 hello->conn_flags > 0xFFFFFFFFULL) {
1311 close_nointr_nofail(fd);
1318 int bus_kernel_try_close(sd_bus *bus) {
1320 assert(bus->is_kernel);
1322 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)