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>
30 #include <sys/prctl.h>
34 #include "memfd-util.h"
35 #include "capability.h"
36 #include "cgroup-util.h"
39 #include "bus-internal.h"
40 #include "bus-message.h"
41 #include "bus-kernel.h"
42 #include "bus-bloom.h"
44 #include "bus-label.h"
46 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
48 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
54 if (!startswith(s, ":1."))
57 r = safe_atou64(s + 3, id);
64 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
70 /* Note that p can be NULL, which encodes a region full of
71 * zeroes, which is useful to optimize certain padding
74 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
75 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
76 (*d)->vec.address = PTR_TO_UINT64(p);
79 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
82 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t start, size_t sz) {
88 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
89 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
90 (*d)->memfd.fd = memfd;
91 (*d)->memfd.start = start;
92 (*d)->memfd.size = sz;
94 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
97 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
103 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
104 (*d)->type = KDBUS_ITEM_DST_NAME;
105 memcpy((*d)->str, s, length + 1);
107 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
110 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
111 struct kdbus_item *i;
117 i->size = offsetof(struct kdbus_item, bloom_filter) +
118 offsetof(struct kdbus_bloom_filter, data) +
120 i->type = KDBUS_ITEM_BLOOM_FILTER;
122 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
124 return &i->bloom_filter;
127 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
133 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
134 (*d)->type = KDBUS_ITEM_FDS;
135 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
137 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
140 static void add_bloom_arg(void *data, size_t size, unsigned n_hash, unsigned i, const char *t) {
141 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
149 e = stpcpy(buf, "arg");
151 *(e++) = '0' + (char) i;
153 *(e++) = '0' + (char) (i / 10);
154 *(e++) = '0' + (char) (i % 10);
158 bloom_add_pair(data, size, n_hash, buf, t);
160 strcpy(e, "-dot-prefix");
161 bloom_add_prefixes(data, size, n_hash, buf, t, '.');
162 strcpy(e, "-slash-prefix");
163 bloom_add_prefixes(data, size, n_hash, buf, t, '/');
166 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
175 memzero(data, m->bus->bloom_size);
176 bloom->generation = 0;
178 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
181 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
183 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
185 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
186 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
187 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
190 r = sd_bus_message_rewind(m, true);
194 for (i = 0; i < 64; i++) {
195 const char *t, *contents;
198 r = sd_bus_message_peek_type(m, &type, &contents);
202 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
204 /* The bloom filter includes simple strings of any kind */
205 r = sd_bus_message_read_basic(m, type, &t);
209 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
210 } if (type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")) {
212 /* As well as array of simple strings of any kinds */
213 r = sd_bus_message_enter_container(m, type, contents);
217 while ((r = sd_bus_message_read_basic(m, contents[0], &t)) > 0)
218 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
222 r = sd_bus_message_exit_container(m);
227 /* Stop adding to bloom filter as soon as we
228 * run into the first argument we cannot add
236 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
237 struct bus_body_part *part;
238 struct kdbus_item *d;
239 const char *destination;
250 /* We put this together only once, if this message is reused
251 * we reuse the earlier-built version */
255 destination = m->destination ?: m->destination_ptr;
258 r = bus_kernel_parse_unique_name(destination, &unique);
266 sz = offsetof(struct kdbus_msg, items);
268 /* Add in fixed header, fields header and payload */
269 sz += (1 + m->n_body_parts) * ALIGN8(offsetof(struct kdbus_item, vec) +
270 MAX(sizeof(struct kdbus_vec),
271 sizeof(struct kdbus_memfd)));
273 /* Add space for bloom filter */
274 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
275 offsetof(struct kdbus_bloom_filter, data) +
278 /* Add in well-known destination header */
280 dl = strlen(destination);
281 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
284 /* Add space for unix fds */
286 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
288 m->kdbus = memalign(8, sz);
294 m->free_kdbus = true;
295 memzero(m->kdbus, sz);
298 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_EXPECT_REPLY) |
299 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0);
302 /* verify_destination_id will usually be 0, which makes the kernel driver only look
303 * at the provided well-known name. Otherwise, the kernel will make sure the provided
304 * destination id matches the owner of the provided weel-known-name, and fail if they
305 * differ. Currently, this is only needed for bus-proxyd. */
306 m->kdbus->dst_id = m->verify_destination_id;
308 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
310 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
311 m->kdbus->cookie = (uint64_t) m->header->serial;
312 m->kdbus->priority = m->priority;
314 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
315 m->kdbus->cookie_reply = m->reply_cookie;
319 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
320 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
321 m->timeout * NSEC_PER_USEC;
327 append_destination(&d, destination, dl);
329 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
331 MESSAGE_FOREACH_PART(part, i, m) {
333 /* If this is padding then simply send a
334 * vector with a NULL data pointer which the
335 * kernel will just pass through. This is the
336 * most efficient way to encode zeroes */
338 append_payload_vec(&d, NULL, part->size);
342 if (part->memfd >= 0 && part->sealed && destination) {
343 /* Try to send a memfd, if the part is
344 * sealed and this is not a broadcast. Since we can only */
346 append_payload_memfd(&d, part->memfd, part->memfd_offset, part->size);
350 /* Otherwise, let's send a vector to the actual data.
351 * For that, we need to map it first. */
352 r = bus_body_part_map(part);
356 append_payload_vec(&d, part->data, part->size);
359 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
360 struct kdbus_bloom_filter *bloom;
362 bloom = append_bloom(&d, m->bus->bloom_size);
363 r = bus_message_setup_bloom(m, bloom);
369 append_fds(&d, m->fds, m->n_fds);
371 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
372 assert(m->kdbus->size <= sz);
381 static void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
385 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
386 m->creds.well_known_names_driver = true;
387 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
390 static void unset_memfds(struct sd_bus_message *m) {
391 struct bus_body_part *part;
396 /* Make sure the memfds are not freed twice */
397 MESSAGE_FOREACH_PART(part, i, m)
398 if (part->memfd >= 0)
402 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
403 sd_bus_message *m = NULL;
404 struct kdbus_item *d;
406 _cleanup_free_ int *fds = NULL;
407 struct bus_header *h = NULL;
408 size_t total, n_bytes = 0, idx = 0;
409 const char *destination = NULL, *seclabel = NULL;
414 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
416 KDBUS_ITEM_FOREACH(d, k, items) {
419 l = d->size - offsetof(struct kdbus_item, data);
423 case KDBUS_ITEM_PAYLOAD_OFF:
425 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
427 if (!bus_header_is_complete(h, d->vec.size))
431 n_bytes += d->vec.size;
434 case KDBUS_ITEM_PAYLOAD_MEMFD:
438 n_bytes += d->memfd.size;
441 case KDBUS_ITEM_FDS: {
446 f = realloc(fds, sizeof(int) * (n_fds + j));
451 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
456 case KDBUS_ITEM_SECLABEL:
465 r = bus_header_message_size(h, &total);
469 if (n_bytes != total)
472 /* on kdbus we only speak native endian gvariant, never dbus1
473 * marshalling or reverse endian */
474 if (h->version != 2 ||
475 h->endian != BUS_NATIVE_ENDIAN)
478 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
482 /* The well-known names list is different from the other
483 credentials. If we asked for it, but nothing is there, this
484 means that the list of well-known names is simply empty, not
485 that we lack any data */
487 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
489 KDBUS_ITEM_FOREACH(d, k, items) {
492 l = d->size - offsetof(struct kdbus_item, data);
496 case KDBUS_ITEM_PAYLOAD_OFF: {
499 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
501 if (idx + d->vec.size > begin_body) {
502 struct bus_body_part *part;
504 /* Contains body material */
506 part = message_append_part(m);
512 /* A -1 offset is NUL padding. */
513 part->is_zero = d->vec.offset == ~0ULL;
515 if (idx >= begin_body) {
517 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
518 part->size = d->vec.size;
521 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
522 part->size = d->vec.size - (begin_body - idx);
532 case KDBUS_ITEM_PAYLOAD_MEMFD: {
533 struct bus_body_part *part;
535 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
540 part = message_append_part(m);
546 part->memfd = d->memfd.fd;
547 part->memfd_offset = d->memfd.start;
548 part->size = d->memfd.size;
551 idx += d->memfd.size;
555 case KDBUS_ITEM_PIDS:
557 /* The PID/TID might be missing, when the data
558 * is faked by some data bus proxy and it
559 * lacks that information about the real
560 * client since SO_PEERCRED is used for
563 if (d->pids.pid > 0) {
564 m->creds.pid = (pid_t) d->pids.pid;
565 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
568 if (d->pids.tid > 0) {
569 m->creds.tid = (pid_t) d->pids.tid;
570 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
575 case KDBUS_ITEM_CREDS:
577 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
579 if ((uid_t) d->creds.uid != UID_INVALID) {
580 m->creds.uid = (uid_t) d->creds.uid;
581 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
584 if ((uid_t) d->creds.euid != UID_INVALID) {
585 m->creds.euid = (uid_t) d->creds.euid;
586 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
589 if ((uid_t) d->creds.suid != UID_INVALID) {
590 m->creds.suid = (uid_t) d->creds.suid;
591 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
594 if ((uid_t) d->creds.fsuid != UID_INVALID) {
595 m->creds.fsuid = (uid_t) d->creds.fsuid;
596 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
599 if ((gid_t) d->creds.gid != GID_INVALID) {
600 m->creds.gid = (gid_t) d->creds.gid;
601 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
604 if ((gid_t) d->creds.egid != GID_INVALID) {
605 m->creds.egid = (gid_t) d->creds.egid;
606 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
609 if ((gid_t) d->creds.sgid != GID_INVALID) {
610 m->creds.sgid = (gid_t) d->creds.sgid;
611 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
614 if ((gid_t) d->creds.fsgid != GID_INVALID) {
615 m->creds.fsgid = (gid_t) d->creds.fsgid;
616 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
621 case KDBUS_ITEM_TIMESTAMP:
623 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
624 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
625 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
626 m->seqnum = d->timestamp.seqnum;
631 case KDBUS_ITEM_PID_COMM:
632 m->creds.comm = d->str;
633 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
636 case KDBUS_ITEM_TID_COMM:
637 m->creds.tid_comm = d->str;
638 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
642 m->creds.exe = d->str;
643 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
646 case KDBUS_ITEM_CMDLINE:
647 m->creds.cmdline = d->str;
648 m->creds.cmdline_size = l;
649 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
652 case KDBUS_ITEM_CGROUP:
653 m->creds.cgroup = d->str;
654 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;
656 r = bus_get_root_path(bus);
660 m->creds.cgroup_root = bus->cgroup_root;
664 case KDBUS_ITEM_AUDIT:
665 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
666 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
667 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
670 if ((uid_t) d->audit.loginuid != UID_INVALID) {
671 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
672 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
676 case KDBUS_ITEM_CAPS:
677 if (d->caps.last_cap != cap_last_cap() ||
678 d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) {
683 m->creds.capability = d->caps.caps;
684 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;
687 case KDBUS_ITEM_DST_NAME:
688 if (!service_name_is_valid(d->str)) {
693 destination = d->str;
696 case KDBUS_ITEM_OWNED_NAME:
697 if (!service_name_is_valid(d->name.name)) {
702 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
706 /* We just extend the array here, but
707 * do not allocate the strings inside
708 * of it, instead we just point to our
709 * buffer directly. */
710 n = strv_length(m->creds.well_known_names);
711 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
717 wkn[n] = d->name.name;
719 m->creds.well_known_names = wkn;
721 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
725 case KDBUS_ITEM_CONN_DESCRIPTION:
726 m->creds.description = d->str;
727 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
730 case KDBUS_ITEM_AUXGROUPS:
732 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
733 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
735 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
736 m->creds.supplementary_gids = (gid_t*) d->data32;
737 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
743 case KDBUS_ITEM_SECLABEL:
747 log_debug("Got unknown field from kernel %llu", d->type);
751 /* If we requested the list of well-known names to be appended
752 * and the sender had none no item for it will be
753 * attached. However, this does *not* mean that the kernel
754 * didn't want to provide this information to us. Hence, let's
755 * explicitly mark this information as available if it was
757 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
759 r = bus_message_parse_fields(m);
763 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
764 if ((uint64_t) m->header->serial != k->cookie) {
769 /* Refuse messages where the reply flag doesn't match up */
770 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) {
775 /* Refuse reply messages where the reply cookie doesn't match up */
776 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
781 /* Refuse messages where the autostart flag doesn't match up */
782 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) {
787 /* Override information from the user header with data from the kernel */
788 if (k->src_id == KDBUS_SRC_ID_KERNEL)
789 bus_message_set_sender_driver(bus, m);
791 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
792 m->sender = m->creds.unique_name = m->sender_buffer;
796 m->destination = destination;
797 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
798 m->destination = NULL;
799 else if (k->dst_id == KDBUS_DST_ID_NAME)
800 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
802 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
803 m->destination = m->destination_buffer;
806 /* We take possession of the kmsg struct now */
808 m->release_kdbus = true;
812 bus->rqueue[bus->rqueue_size++] = m;
818 sd_bus_message_unref(m);
823 int bus_kernel_take_fd(sd_bus *b) {
824 struct kdbus_cmd_free cmd_free = {
825 .size = sizeof(cmd_free),
828 struct kdbus_bloom_parameter *bloom = NULL;
829 struct kdbus_cmd_hello *hello;
830 struct kdbus_item_list *items;
831 struct kdbus_item *item;
832 _cleanup_free_ char *g = NULL;
834 size_t l = 0, m = 0, sz;
844 if (b->description) {
845 g = bus_label_escape(b->description);
853 /* If no name is explicitly set, we'll include a hint
854 * indicating the library implementation, a hint which
855 * kind of bus this is and the thread name */
857 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
860 name = b->is_system ? "sd-system" :
861 b->is_user ? "sd-user" : "sd";
863 _cleanup_free_ char *e = NULL;
865 e = bus_label_escape(pr);
869 g = strappend(b->is_system ? "sd-system-" :
870 b->is_user ? "sd-user-" : "sd-",
878 b->description = bus_label_unescape(name);
885 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
886 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
888 if (b->fake_creds_valid)
889 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
891 if (b->fake_pids_valid)
892 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
895 l = strlen(b->fake_label);
896 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
899 hello = alloca0_align(sz, 8);
901 hello->flags = b->hello_flags;
902 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
903 hello->attach_flags_recv = b->attach_flags;
904 hello->pool_size = KDBUS_POOL_SIZE;
908 item->size = offsetof(struct kdbus_item, str) + m + 1;
909 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
910 memcpy(item->str, name, m + 1);
911 item = KDBUS_ITEM_NEXT(item);
913 if (b->fake_creds_valid) {
914 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
915 item->type = KDBUS_ITEM_CREDS;
916 item->creds = b->fake_creds;
918 item = KDBUS_ITEM_NEXT(item);
921 if (b->fake_pids_valid) {
922 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
923 item->type = KDBUS_ITEM_PIDS;
924 item->pids = b->fake_pids;
926 item = KDBUS_ITEM_NEXT(item);
930 item->size = offsetof(struct kdbus_item, str) + l + 1;
931 item->type = KDBUS_ITEM_SECLABEL;
932 memcpy(item->str, b->fake_label, l+1);
935 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
939 if (!b->kdbus_buffer) {
940 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
941 if (b->kdbus_buffer == MAP_FAILED) {
942 b->kdbus_buffer = NULL;
948 /* The higher 32bit of the bus_flags fields are considered
949 * 'incompatible flags'. Refuse them all for now. */
950 if (hello->bus_flags > 0xFFFFFFFFULL) {
955 /* extract bloom parameters from items */
956 items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
957 KDBUS_ITEM_FOREACH(item, items, items) {
958 switch (item->type) {
959 case KDBUS_ITEM_BLOOM_PARAMETER:
960 bloom = &item->bloom_parameter;
965 if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
970 b->bloom_size = (size_t) bloom->size;
971 b->bloom_n_hash = (unsigned) bloom->n_hash;
973 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
978 b->unique_id = hello->id;
981 b->bus_client = true;
982 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
983 b->message_version = 2;
984 b->message_endian = BUS_NATIVE_ENDIAN;
986 /* the kernel told us the UUID of the underlying bus */
987 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
989 /* free returned items */
990 (void) bus_kernel_cmd_free(b, hello->offset);
992 return bus_start_running(b);
995 cmd_free.offset = hello->offset;
996 (void) ioctl(b->input_fd, KDBUS_CMD_FREE, &cmd_free);
1000 int bus_kernel_connect(sd_bus *b) {
1002 assert(b->input_fd < 0);
1003 assert(b->output_fd < 0);
1009 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1010 if (b->input_fd < 0)
1013 b->output_fd = b->input_fd;
1015 return bus_kernel_take_fd(b);
1018 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1019 struct kdbus_cmd_free cmd = {
1020 .size = sizeof(cmd),
1027 assert(bus->is_kernel);
1029 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1036 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1037 struct kdbus_item *d;
1042 KDBUS_ITEM_FOREACH(d, k, items) {
1043 if (d->type == KDBUS_ITEM_FDS)
1044 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1045 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1046 safe_close(d->memfd.fd);
1049 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1052 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1053 struct kdbus_cmd_send cmd = { };
1058 assert(bus->state == BUS_RUNNING);
1060 /* If we can't deliver, we want room for the error message */
1061 r = bus_rqueue_make_room(bus);
1065 r = bus_message_setup_kmsg(bus, m);
1069 cmd.size = sizeof(cmd);
1070 cmd.msg_address = (uintptr_t)m->kdbus;
1072 /* If this is a synchronous method call, then let's tell the
1073 * kernel, so that it can pass CPU time/scheduling to the
1074 * destination for the time, if it wants to. If we
1075 * synchronously wait for the result anyway, we won't need CPU
1077 if (hint_sync_call) {
1078 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1079 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1082 r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1084 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1085 sd_bus_message *reply;
1087 if (errno == EAGAIN || errno == EINTR)
1089 else if (errno == ENXIO || errno == ESRCH) {
1091 /* ENXIO: unique name not known
1092 * ESRCH: well-known name not known */
1094 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1095 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1097 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1101 } else if (errno == EADDRNOTAVAIL) {
1103 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1105 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1106 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1108 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1114 r = bus_message_new_synthetic_error(
1116 BUS_MESSAGE_COOKIE(m),
1123 r = bus_seal_synthetic_message(bus, reply);
1127 bus->rqueue[bus->rqueue_size++] = reply;
1129 } else if (hint_sync_call) {
1130 struct kdbus_msg *k;
1132 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1135 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1137 r = bus_kernel_make_message(bus, k);
1139 close_kdbus_msg(bus, k);
1141 /* Anybody can send us invalid messages, let's just drop them. */
1142 if (r == -EBADMSG || r == -EPROTOTYPE)
1143 log_debug_errno(r, "Ignoring invalid message: %m");
1148 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1149 close_kdbus_msg(bus, k);
1156 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1157 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1162 r = sd_bus_message_new_signal(
1165 "/org/freedesktop/DBus",
1166 "org.freedesktop.DBus",
1167 "NameOwnerChanged");
1171 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1175 bus_message_set_sender_driver(bus, m);
1177 r = bus_seal_synthetic_message(bus, m);
1181 bus->rqueue[bus->rqueue_size++] = m;
1187 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1188 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1194 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1197 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1199 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1201 if (isempty(old_owner))
1206 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1208 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1211 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1212 char owner[UNIQUE_NAME_MAX];
1218 sprintf(owner, ":1.%llu", d->id_change.id);
1220 return push_name_owner_changed(
1222 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1223 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1226 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1227 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1234 r = bus_message_new_synthetic_error(
1237 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1238 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1239 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1244 bus_message_set_sender_driver(bus, m);
1246 r = bus_seal_synthetic_message(bus, m);
1250 bus->rqueue[bus->rqueue_size++] = m;
1256 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1257 struct kdbus_item *d, *found = NULL;
1259 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1260 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1261 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1262 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1264 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1265 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1267 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1268 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1273 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1275 KDBUS_ITEM_FOREACH(d, k, items) {
1276 if (d->type == KDBUS_ITEM_TIMESTAMP)
1279 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1284 log_debug("Got unknown field from kernel %llu", d->type);
1288 log_debug("Didn't find a kernel message to translate.");
1292 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1295 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1296 struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1297 struct kdbus_msg *k;
1302 r = bus_rqueue_make_room(bus);
1306 if (hint_priority) {
1307 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1308 recv.priority = priority;
1311 r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1313 if (errno == EAGAIN)
1316 if (errno == EOVERFLOW) {
1317 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1324 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.reply.offset);
1325 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1326 r = bus_kernel_make_message(bus, k);
1328 /* Anybody can send us invalid messages, let's just drop them. */
1329 if (r == -EBADMSG || r == -EPROTOTYPE) {
1330 log_debug_errno(r, "Ignoring invalid message: %m");
1334 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1335 r = bus_kernel_translate_message(bus, k);
1337 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1342 close_kdbus_msg(bus, k);
1344 return r < 0 ? r : 1;
1347 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1348 struct memfd_cache *c;
1355 if (!bus || !bus->is_kernel)
1358 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1360 if (bus->n_memfd_cache <= 0) {
1363 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1365 r = memfd_new(bus->description);
1375 c = &bus->memfd_cache[--bus->n_memfd_cache];
1378 assert(c->mapped == 0 || c->address);
1380 *address = c->address;
1381 *mapped = c->mapped;
1382 *allocated = c->allocated;
1385 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1390 static void close_and_munmap(int fd, void *address, size_t size) {
1392 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1397 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1398 struct memfd_cache *c;
1399 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1402 assert(mapped == 0 || address);
1404 if (!bus || !bus->is_kernel) {
1405 close_and_munmap(fd, address, mapped);
1409 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1411 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1412 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1414 close_and_munmap(fd, address, mapped);
1418 c = &bus->memfd_cache[bus->n_memfd_cache++];
1420 c->address = address;
1422 /* If overly long, let's return a bit to the OS */
1423 if (mapped > max_mapped) {
1424 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1425 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1426 c->mapped = c->allocated = max_mapped;
1429 c->allocated = allocated;
1432 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1435 void bus_kernel_flush_memfd(sd_bus *b) {
1440 for (i = 0; i < b->n_memfd_cache; i++)
1441 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1444 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1447 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1448 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1450 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1451 f |= KDBUS_NAME_REPLACE_EXISTING;
1453 if (flags & SD_BUS_NAME_QUEUE)
1454 f |= KDBUS_NAME_QUEUE;
1459 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1462 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1463 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1464 m |= KDBUS_ATTACH_CREDS;
1466 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1467 m |= KDBUS_ATTACH_PIDS;
1469 if (mask & SD_BUS_CREDS_COMM)
1470 m |= KDBUS_ATTACH_PID_COMM;
1472 if (mask & SD_BUS_CREDS_TID_COMM)
1473 m |= KDBUS_ATTACH_TID_COMM;
1475 if (mask & SD_BUS_CREDS_EXE)
1476 m |= KDBUS_ATTACH_EXE;
1478 if (mask & SD_BUS_CREDS_CMDLINE)
1479 m |= KDBUS_ATTACH_CMDLINE;
1481 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))
1482 m |= KDBUS_ATTACH_CGROUP;
1484 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1485 m |= KDBUS_ATTACH_CAPS;
1487 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1488 m |= KDBUS_ATTACH_SECLABEL;
1490 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1491 m |= KDBUS_ATTACH_AUDIT;
1493 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1494 m |= KDBUS_ATTACH_NAMES;
1496 if (mask & SD_BUS_CREDS_DESCRIPTION)
1497 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1499 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1500 m |= KDBUS_ATTACH_AUXGROUPS;
1505 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1506 struct kdbus_cmd_make *make;
1507 struct kdbus_item *n;
1514 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1519 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1520 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1521 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1522 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1523 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1526 make->size = offsetof(struct kdbus_cmd_make, items);
1528 /* Set the bloom parameters */
1530 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1531 sizeof(struct kdbus_bloom_parameter);
1532 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1533 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1534 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1536 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1537 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1539 make->size += ALIGN8(n->size);
1541 /* The busses we create make no restrictions on what metadata
1542 * peers can read from incoming messages. */
1543 n = KDBUS_ITEM_NEXT(n);
1544 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1545 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1546 n->data64[0] = _KDBUS_ATTACH_ANY;
1547 make->size += ALIGN8(n->size);
1549 /* Provide all metadata via bus-owner queries */
1550 n = KDBUS_ITEM_NEXT(n);
1551 n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1552 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1553 n->data64[0] = _KDBUS_ATTACH_ANY;
1554 make->size += ALIGN8(n->size);
1556 /* Set the a good name */
1557 n = KDBUS_ITEM_NEXT(n);
1558 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1559 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1560 n->type = KDBUS_ITEM_MAKE_NAME;
1561 make->size += ALIGN8(n->size);
1563 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1565 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1573 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1585 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1592 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1599 p = newa(char, len);
1601 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1603 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1617 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1618 _cleanup_free_ char *path = NULL;
1619 struct kdbus_cmd_make *make;
1620 struct kdbus_item *n;
1624 fd = bus_kernel_open_bus_fd(bus_name, &path);
1628 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1629 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1631 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1632 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1635 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1636 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1637 n->type = KDBUS_ITEM_MAKE_NAME;
1638 make->size += ALIGN8(n->size);
1641 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1649 p = strjoin(dirname(path), "/", name, NULL);
1661 int bus_kernel_try_close(sd_bus *bus) {
1663 assert(bus->is_kernel);
1665 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1671 int bus_kernel_drop_one(int fd) {
1672 struct kdbus_cmd_recv recv = {
1673 .size = sizeof(recv),
1674 .flags = KDBUS_RECV_DROP,
1679 if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1685 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1686 struct kdbus_cmd_update *update;
1687 struct kdbus_item *n;
1690 assert(bus->is_kernel);
1692 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1693 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1697 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1698 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1699 n->data64[0] = bus->attach_flags;
1702 offsetof(struct kdbus_cmd_update, items) +
1705 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1711 int bus_kernel_fix_attach_mask(void) {
1712 _cleanup_free_ char *mask = NULL;
1713 uint64_t m = (uint64_t) -1;
1717 /* By default we don't want any kdbus metadata fields to be
1718 * suppressed, hence we reset the kernel mask for it to
1719 * (uint64_t) -1. This is overridable via a kernel command
1720 * line option, however. */
1722 r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1724 return log_warning_errno(r, "Failed to read kernel command line: %m");
1727 const char *p = mask;
1729 if (startswith(p, "0x"))
1732 if (sscanf(p, "%" PRIx64, &m) != 1)
1733 log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1736 sprintf(buf, "0x%" PRIx64 "\n", m);
1737 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1739 return log_full_errno(
1740 IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1741 "Failed to write kdbus attach mask: %m");
1746 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1747 struct kdbus_cmd_info cmd = {
1748 .size = sizeof(struct kdbus_cmd_info),
1750 struct kdbus_info *info;
1751 struct kdbus_item *item;
1757 assert(bus->is_kernel);
1759 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1763 info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1765 KDBUS_ITEM_FOREACH(item, info, items)
1766 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1767 r = free_and_strdup(&n, item->str);
1771 bus_kernel_cmd_free(bus, cmd.offset);