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>
29 #include <sys/prctl.h>
31 /* When we include libgen.h because we need dirname() we immediately
32 * undefine basename() since libgen.h defines it as a macro to the XDG
33 * version which is really broken. */
39 #include "memfd-util.h"
40 #include "capability.h"
41 #include "cgroup-util.h"
44 #include "bus-internal.h"
45 #include "bus-message.h"
46 #include "bus-kernel.h"
47 #include "bus-bloom.h"
49 #include "bus-label.h"
51 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
53 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
59 if (!startswith(s, ":1."))
62 r = safe_atou64(s + 3, id);
69 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
75 /* Note that p can be NULL, which encodes a region full of
76 * zeroes, which is useful to optimize certain padding
79 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
80 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
81 (*d)->vec.address = PTR_TO_UINT64(p);
84 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
87 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t start, size_t sz) {
93 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
94 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
95 (*d)->memfd.fd = memfd;
96 (*d)->memfd.start = start;
97 (*d)->memfd.size = sz;
99 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
102 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
108 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
109 (*d)->type = KDBUS_ITEM_DST_NAME;
110 memcpy((*d)->str, s, length + 1);
112 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
115 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
116 struct kdbus_item *i;
122 i->size = offsetof(struct kdbus_item, bloom_filter) +
123 offsetof(struct kdbus_bloom_filter, data) +
125 i->type = KDBUS_ITEM_BLOOM_FILTER;
127 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
129 return &i->bloom_filter;
132 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
138 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
139 (*d)->type = KDBUS_ITEM_FDS;
140 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
142 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
145 static void add_bloom_arg(void *data, size_t size, unsigned n_hash, unsigned i, const char *t) {
146 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
154 e = stpcpy(buf, "arg");
156 *(e++) = '0' + (char) i;
158 *(e++) = '0' + (char) (i / 10);
159 *(e++) = '0' + (char) (i % 10);
163 bloom_add_pair(data, size, n_hash, buf, t);
165 strcpy(e, "-dot-prefix");
166 bloom_add_prefixes(data, size, n_hash, buf, t, '.');
167 strcpy(e, "-slash-prefix");
168 bloom_add_prefixes(data, size, n_hash, buf, t, '/');
171 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
180 memzero(data, m->bus->bloom_size);
181 bloom->generation = 0;
183 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
186 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
188 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
190 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
191 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
192 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
195 r = sd_bus_message_rewind(m, true);
199 for (i = 0; i < 64; i++) {
200 const char *t, *contents;
203 r = sd_bus_message_peek_type(m, &type, &contents);
207 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
209 /* The bloom filter includes simple strings of any kind */
210 r = sd_bus_message_read_basic(m, type, &t);
214 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
215 } if (type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")) {
217 /* As well as array of simple strings of any kinds */
218 r = sd_bus_message_enter_container(m, type, contents);
222 while ((r = sd_bus_message_read_basic(m, contents[0], &t)) > 0)
223 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
227 r = sd_bus_message_exit_container(m);
232 /* Stop adding to bloom filter as soon as we
233 * run into the first argument we cannot add
241 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
242 struct bus_body_part *part;
243 struct kdbus_item *d;
244 const char *destination;
255 /* We put this together only once, if this message is reused
256 * we reuse the earlier-built version */
260 destination = m->destination ?: m->destination_ptr;
263 r = bus_kernel_parse_unique_name(destination, &unique);
271 sz = offsetof(struct kdbus_msg, items);
273 /* Add in fixed header, fields header and payload */
274 sz += (1 + m->n_body_parts) * ALIGN8(offsetof(struct kdbus_item, vec) +
275 MAX(sizeof(struct kdbus_vec),
276 sizeof(struct kdbus_memfd)));
278 /* Add space for bloom filter */
279 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
280 offsetof(struct kdbus_bloom_filter, data) +
283 /* Add in well-known destination header */
285 dl = strlen(destination);
286 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
289 /* Add space for unix fds */
291 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
293 m->kdbus = memalign(8, sz);
299 m->free_kdbus = true;
300 memzero(m->kdbus, sz);
303 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_EXPECT_REPLY) |
304 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0) |
305 ((m->header->type == SD_BUS_MESSAGE_SIGNAL) ? KDBUS_MSG_SIGNAL : 0);
308 /* verify_destination_id will usually be 0, which makes the kernel driver only look
309 * at the provided well-known name. Otherwise, the kernel will make sure the provided
310 * destination id matches the owner of the provided weel-known-name, and fail if they
311 * differ. Currently, this is only needed for bus-proxyd. */
312 m->kdbus->dst_id = m->verify_destination_id;
314 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
316 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
317 m->kdbus->cookie = (uint64_t) m->header->serial;
318 m->kdbus->priority = m->priority;
320 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
321 m->kdbus->cookie_reply = m->reply_cookie;
325 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
326 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
327 m->timeout * NSEC_PER_USEC;
333 append_destination(&d, destination, dl);
335 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
337 MESSAGE_FOREACH_PART(part, i, m) {
339 /* If this is padding then simply send a
340 * vector with a NULL data pointer which the
341 * kernel will just pass through. This is the
342 * most efficient way to encode zeroes */
344 append_payload_vec(&d, NULL, part->size);
348 if (part->memfd >= 0 && part->sealed && destination) {
349 /* Try to send a memfd, if the part is
350 * sealed and this is not a broadcast. Since we can only */
352 append_payload_memfd(&d, part->memfd, part->memfd_offset, part->size);
356 /* Otherwise, let's send a vector to the actual data.
357 * For that, we need to map it first. */
358 r = bus_body_part_map(part);
362 append_payload_vec(&d, part->data, part->size);
365 if (m->header->type == SD_BUS_MESSAGE_SIGNAL) {
366 struct kdbus_bloom_filter *bloom;
368 bloom = append_bloom(&d, m->bus->bloom_size);
369 r = bus_message_setup_bloom(m, bloom);
375 append_fds(&d, m->fds, m->n_fds);
377 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
378 assert(m->kdbus->size <= sz);
387 static void unset_memfds(struct sd_bus_message *m) {
388 struct bus_body_part *part;
393 /* Make sure the memfds are not freed twice */
394 MESSAGE_FOREACH_PART(part, i, m)
395 if (part->memfd >= 0)
399 static void message_set_timestamp(sd_bus *bus, sd_bus_message *m, const struct kdbus_timestamp *ts) {
406 if (!(bus->attach_flags & KDBUS_ATTACH_TIMESTAMP))
409 m->realtime = ts->realtime_ns / NSEC_PER_USEC;
410 m->monotonic = ts->monotonic_ns / NSEC_PER_USEC;
411 m->seqnum = ts->seqnum;
414 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
415 sd_bus_message *m = NULL;
416 struct kdbus_item *d;
418 _cleanup_free_ int *fds = NULL;
419 struct bus_header *h = NULL;
420 size_t total, n_bytes = 0, idx = 0;
421 const char *destination = NULL, *seclabel = NULL;
426 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
428 KDBUS_ITEM_FOREACH(d, k, items) {
431 l = d->size - offsetof(struct kdbus_item, data);
435 case KDBUS_ITEM_PAYLOAD_OFF:
437 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
439 if (!bus_header_is_complete(h, d->vec.size))
443 n_bytes += d->vec.size;
446 case KDBUS_ITEM_PAYLOAD_MEMFD:
450 n_bytes += d->memfd.size;
453 case KDBUS_ITEM_FDS: {
458 f = realloc(fds, sizeof(int) * (n_fds + j));
463 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
468 case KDBUS_ITEM_SECLABEL:
477 r = bus_header_message_size(h, &total);
481 if (n_bytes != total)
484 /* on kdbus we only speak native endian gvariant, never dbus1
485 * marshalling or reverse endian */
486 if (h->version != 2 ||
487 h->endian != BUS_NATIVE_ENDIAN)
490 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
494 /* The well-known names list is different from the other
495 credentials. If we asked for it, but nothing is there, this
496 means that the list of well-known names is simply empty, not
497 that we lack any data */
499 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
501 KDBUS_ITEM_FOREACH(d, k, items) {
504 l = d->size - offsetof(struct kdbus_item, data);
508 case KDBUS_ITEM_PAYLOAD_OFF: {
511 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
513 if (idx + d->vec.size > begin_body) {
514 struct bus_body_part *part;
516 /* Contains body material */
518 part = message_append_part(m);
524 /* A -1 offset is NUL padding. */
525 part->is_zero = d->vec.offset == ~0ULL;
527 if (idx >= begin_body) {
529 part->data = (uint8_t *)k + d->vec.offset;
530 part->size = d->vec.size;
533 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
534 part->size = d->vec.size - (begin_body - idx);
544 case KDBUS_ITEM_PAYLOAD_MEMFD: {
545 struct bus_body_part *part;
547 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
552 part = message_append_part(m);
558 part->memfd = d->memfd.fd;
559 part->memfd_offset = d->memfd.start;
560 part->size = d->memfd.size;
563 idx += d->memfd.size;
567 case KDBUS_ITEM_PIDS:
569 /* The PID/TID might be missing, when the data
570 * is faked by some data bus proxy and it
571 * lacks that information about the real
572 * client since SO_PEERCRED is used for
575 if (d->pids.pid > 0) {
576 m->creds.pid = (pid_t) d->pids.pid;
577 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
580 if (d->pids.tid > 0) {
581 m->creds.tid = (pid_t) d->pids.tid;
582 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
587 case KDBUS_ITEM_CREDS:
589 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
591 if ((uid_t) d->creds.uid != UID_INVALID) {
592 m->creds.uid = (uid_t) d->creds.uid;
593 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
596 if ((uid_t) d->creds.euid != UID_INVALID) {
597 m->creds.euid = (uid_t) d->creds.euid;
598 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
601 if ((uid_t) d->creds.suid != UID_INVALID) {
602 m->creds.suid = (uid_t) d->creds.suid;
603 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
606 if ((uid_t) d->creds.fsuid != UID_INVALID) {
607 m->creds.fsuid = (uid_t) d->creds.fsuid;
608 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
611 if ((gid_t) d->creds.gid != GID_INVALID) {
612 m->creds.gid = (gid_t) d->creds.gid;
613 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
616 if ((gid_t) d->creds.egid != GID_INVALID) {
617 m->creds.egid = (gid_t) d->creds.egid;
618 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
621 if ((gid_t) d->creds.sgid != GID_INVALID) {
622 m->creds.sgid = (gid_t) d->creds.sgid;
623 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
626 if ((gid_t) d->creds.fsgid != GID_INVALID) {
627 m->creds.fsgid = (gid_t) d->creds.fsgid;
628 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
633 case KDBUS_ITEM_TIMESTAMP:
634 message_set_timestamp(bus, m, &d->timestamp);
637 case KDBUS_ITEM_PID_COMM:
638 m->creds.comm = d->str;
639 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
642 case KDBUS_ITEM_TID_COMM:
643 m->creds.tid_comm = d->str;
644 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
648 m->creds.exe = d->str;
649 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
652 case KDBUS_ITEM_CMDLINE:
653 m->creds.cmdline = d->str;
654 m->creds.cmdline_size = l;
655 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
658 case KDBUS_ITEM_CGROUP:
659 m->creds.cgroup = d->str;
660 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;
662 r = bus_get_root_path(bus);
666 m->creds.cgroup_root = bus->cgroup_root;
670 case KDBUS_ITEM_AUDIT:
671 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
672 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
673 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
676 if ((uid_t) d->audit.loginuid != UID_INVALID) {
677 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
678 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
682 case KDBUS_ITEM_CAPS:
683 if (d->caps.last_cap != cap_last_cap() ||
684 d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) {
689 m->creds.capability = d->caps.caps;
690 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;
693 case KDBUS_ITEM_DST_NAME:
694 if (!service_name_is_valid(d->str)) {
699 destination = d->str;
702 case KDBUS_ITEM_OWNED_NAME:
703 if (!service_name_is_valid(d->name.name)) {
708 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
712 /* We just extend the array here, but
713 * do not allocate the strings inside
714 * of it, instead we just point to our
715 * buffer directly. */
716 n = strv_length(m->creds.well_known_names);
717 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
723 wkn[n] = d->name.name;
725 m->creds.well_known_names = wkn;
727 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
731 case KDBUS_ITEM_CONN_DESCRIPTION:
732 m->creds.description = d->str;
733 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
736 case KDBUS_ITEM_AUXGROUPS:
738 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
739 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
741 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
742 m->creds.supplementary_gids = (gid_t*) d->data32;
743 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
749 case KDBUS_ITEM_SECLABEL:
753 log_debug("Got unknown field from kernel %llu", d->type);
757 /* If we requested the list of well-known names to be appended
758 * and the sender had none no item for it will be
759 * attached. However, this does *not* mean that the kernel
760 * didn't want to provide this information to us. Hence, let's
761 * explicitly mark this information as available if it was
763 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
765 r = bus_message_parse_fields(m);
769 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
770 if ((uint64_t) m->header->serial != k->cookie) {
775 /* Refuse messages where the reply flag doesn't match up */
776 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) {
781 /* Refuse reply messages where the reply cookie doesn't match up */
782 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
787 /* Refuse messages where the autostart flag doesn't match up */
788 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) {
793 /* Override information from the user header with data from the kernel */
794 if (k->src_id == KDBUS_SRC_ID_KERNEL)
795 bus_message_set_sender_driver(bus, m);
797 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
798 m->sender = m->creds.unique_name = m->sender_buffer;
802 m->destination = destination;
803 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
804 m->destination = NULL;
805 else if (k->dst_id == KDBUS_DST_ID_NAME)
806 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
808 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
809 m->destination = m->destination_buffer;
812 /* We take possession of the kmsg struct now */
814 m->release_kdbus = true;
818 bus->rqueue[bus->rqueue_size++] = m;
824 sd_bus_message_unref(m);
829 int bus_kernel_take_fd(sd_bus *b) {
830 struct kdbus_bloom_parameter *bloom = NULL;
831 struct kdbus_cmd_hello *hello;
832 struct kdbus_item_list *items;
833 struct kdbus_item *item;
834 _cleanup_free_ char *g = NULL;
836 size_t l = 0, m = 0, sz;
846 if (b->description) {
847 g = bus_label_escape(b->description);
855 /* If no name is explicitly set, we'll include a hint
856 * indicating the library implementation, a hint which
857 * kind of bus this is and the thread name */
859 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
862 name = b->is_system ? "sd-system" :
863 b->is_user ? "sd-user" : "sd";
865 _cleanup_free_ char *e = NULL;
867 e = bus_label_escape(pr);
871 g = strappend(b->is_system ? "sd-system-" :
872 b->is_user ? "sd-user-" : "sd-",
880 b->description = bus_label_unescape(name);
887 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
888 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
890 if (b->fake_creds_valid)
891 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
893 if (b->fake_pids_valid)
894 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
897 l = strlen(b->fake_label);
898 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
901 hello = alloca0_align(sz, 8);
903 hello->flags = b->hello_flags;
904 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
905 hello->attach_flags_recv = b->attach_flags;
906 hello->pool_size = KDBUS_POOL_SIZE;
910 item->size = offsetof(struct kdbus_item, str) + m + 1;
911 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
912 memcpy(item->str, name, m + 1);
913 item = KDBUS_ITEM_NEXT(item);
915 if (b->fake_creds_valid) {
916 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
917 item->type = KDBUS_ITEM_CREDS;
918 item->creds = b->fake_creds;
920 item = KDBUS_ITEM_NEXT(item);
923 if (b->fake_pids_valid) {
924 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
925 item->type = KDBUS_ITEM_PIDS;
926 item->pids = b->fake_pids;
928 item = KDBUS_ITEM_NEXT(item);
932 item->size = offsetof(struct kdbus_item, str) + l + 1;
933 item->type = KDBUS_ITEM_SECLABEL;
934 memcpy(item->str, b->fake_label, l+1);
937 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
941 if (!b->kdbus_buffer) {
942 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
943 if (b->kdbus_buffer == MAP_FAILED) {
944 b->kdbus_buffer = NULL;
950 /* The higher 32bit of the bus_flags fields are considered
951 * 'incompatible flags'. Refuse them all for now. */
952 if (hello->bus_flags > 0xFFFFFFFFULL) {
957 /* extract bloom parameters from items */
958 items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
959 KDBUS_ITEM_FOREACH(item, items, items) {
960 switch (item->type) {
961 case KDBUS_ITEM_BLOOM_PARAMETER:
962 bloom = &item->bloom_parameter;
967 if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
972 b->bloom_size = (size_t) bloom->size;
973 b->bloom_n_hash = (unsigned) bloom->n_hash;
975 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
980 b->unique_id = hello->id;
983 b->bus_client = true;
984 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
985 b->message_version = 2;
986 b->message_endian = BUS_NATIVE_ENDIAN;
988 /* the kernel told us the UUID of the underlying bus */
989 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
991 /* free returned items */
992 (void) bus_kernel_cmd_free(b, hello->offset);
993 return bus_start_running(b);
996 (void) bus_kernel_cmd_free(b, hello->offset);
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),
1026 assert(bus->is_kernel);
1028 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1035 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1036 struct kdbus_item *d;
1041 KDBUS_ITEM_FOREACH(d, k, items) {
1042 if (d->type == KDBUS_ITEM_FDS)
1043 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1044 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1045 safe_close(d->memfd.fd);
1048 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1051 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1052 struct kdbus_cmd_send cmd = { };
1057 assert(bus->state == BUS_RUNNING);
1059 /* If we can't deliver, we want room for the error message */
1060 r = bus_rqueue_make_room(bus);
1064 r = bus_message_setup_kmsg(bus, m);
1068 cmd.size = sizeof(cmd);
1069 cmd.msg_address = (uintptr_t)m->kdbus;
1071 /* If this is a synchronous method call, then let's tell the
1072 * kernel, so that it can pass CPU time/scheduling to the
1073 * destination for the time, if it wants to. If we
1074 * synchronously wait for the result anyway, we won't need CPU
1076 if (hint_sync_call) {
1077 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1078 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1081 r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1083 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1084 sd_bus_message *reply;
1086 if (errno == EAGAIN || errno == EINTR)
1088 else if (errno == ENXIO || errno == ESRCH) {
1090 /* ENXIO: unique name not known
1091 * ESRCH: well-known name not known */
1093 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1094 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1096 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1100 } else if (errno == EADDRNOTAVAIL) {
1102 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1104 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1105 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1107 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1113 r = bus_message_new_synthetic_error(
1115 BUS_MESSAGE_COOKIE(m),
1122 r = bus_seal_synthetic_message(bus, reply);
1126 bus->rqueue[bus->rqueue_size++] = reply;
1128 } else if (hint_sync_call) {
1129 struct kdbus_msg *k;
1131 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1134 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1136 r = bus_kernel_make_message(bus, k);
1138 close_kdbus_msg(bus, k);
1140 /* Anybody can send us invalid messages, let's just drop them. */
1141 if (r == -EBADMSG || r == -EPROTOTYPE)
1142 log_debug_errno(r, "Ignoring invalid message: %m");
1147 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1148 close_kdbus_msg(bus, k);
1155 static int push_name_owner_changed(
1158 const char *old_owner,
1159 const char *new_owner,
1160 const struct kdbus_timestamp *ts) {
1162 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1167 r = sd_bus_message_new_signal(
1170 "/org/freedesktop/DBus",
1171 "org.freedesktop.DBus",
1172 "NameOwnerChanged");
1176 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1180 bus_message_set_sender_driver(bus, m);
1181 message_set_timestamp(bus, m, ts);
1183 r = bus_seal_synthetic_message(bus, m);
1187 bus->rqueue[bus->rqueue_size++] = m;
1193 static int translate_name_change(
1195 const struct kdbus_msg *k,
1196 const struct kdbus_item *d,
1197 const struct kdbus_timestamp *ts) {
1199 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1205 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1208 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1210 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1212 if (isempty(old_owner))
1217 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1219 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1222 static int translate_id_change(
1224 const struct kdbus_msg *k,
1225 const struct kdbus_item *d,
1226 const struct kdbus_timestamp *ts) {
1228 char owner[UNIQUE_NAME_MAX];
1234 sprintf(owner, ":1.%llu", d->id_change.id);
1236 return push_name_owner_changed(
1238 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1239 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1243 static int translate_reply(
1245 const struct kdbus_msg *k,
1246 const struct kdbus_item *d,
1247 const struct kdbus_timestamp *ts) {
1249 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1256 r = bus_message_new_synthetic_error(
1259 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1260 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1261 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1266 message_set_timestamp(bus, m, ts);
1268 r = bus_seal_synthetic_message(bus, m);
1272 bus->rqueue[bus->rqueue_size++] = m;
1278 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1279 static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1280 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1281 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1282 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1284 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1285 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1287 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1288 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1291 struct kdbus_item *d, *found = NULL;
1292 struct kdbus_timestamp *ts = NULL;
1296 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1298 KDBUS_ITEM_FOREACH(d, k, items) {
1299 if (d->type == KDBUS_ITEM_TIMESTAMP)
1302 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1307 log_debug("Got unknown field from kernel %llu", d->type);
1311 log_debug("Didn't find a kernel message to translate.");
1315 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1318 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1319 struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1320 struct kdbus_msg *k;
1325 r = bus_rqueue_make_room(bus);
1329 if (hint_priority) {
1330 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1331 recv.priority = priority;
1334 r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1336 if (errno == EAGAIN)
1339 if (errno == EOVERFLOW) {
1340 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1347 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1348 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1349 r = bus_kernel_make_message(bus, k);
1351 /* Anybody can send us invalid messages, let's just drop them. */
1352 if (r == -EBADMSG || r == -EPROTOTYPE) {
1353 log_debug_errno(r, "Ignoring invalid message: %m");
1357 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1358 r = bus_kernel_translate_message(bus, k);
1360 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1365 close_kdbus_msg(bus, k);
1367 return r < 0 ? r : 1;
1370 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1371 struct memfd_cache *c;
1378 if (!bus || !bus->is_kernel)
1381 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1383 if (bus->n_memfd_cache <= 0) {
1386 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1388 r = memfd_new(bus->description);
1398 c = &bus->memfd_cache[--bus->n_memfd_cache];
1401 assert(c->mapped == 0 || c->address);
1403 *address = c->address;
1404 *mapped = c->mapped;
1405 *allocated = c->allocated;
1408 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1413 static void close_and_munmap(int fd, void *address, size_t size) {
1415 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1420 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1421 struct memfd_cache *c;
1422 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1425 assert(mapped == 0 || address);
1427 if (!bus || !bus->is_kernel) {
1428 close_and_munmap(fd, address, mapped);
1432 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1434 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1435 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1437 close_and_munmap(fd, address, mapped);
1441 c = &bus->memfd_cache[bus->n_memfd_cache++];
1443 c->address = address;
1445 /* If overly long, let's return a bit to the OS */
1446 if (mapped > max_mapped) {
1447 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1448 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1449 c->mapped = c->allocated = max_mapped;
1452 c->allocated = allocated;
1455 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1458 void bus_kernel_flush_memfd(sd_bus *b) {
1463 for (i = 0; i < b->n_memfd_cache; i++)
1464 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1467 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1470 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1471 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1473 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1474 f |= KDBUS_NAME_REPLACE_EXISTING;
1476 if (flags & SD_BUS_NAME_QUEUE)
1477 f |= KDBUS_NAME_QUEUE;
1482 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1485 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1486 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1487 m |= KDBUS_ATTACH_CREDS;
1489 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1490 m |= KDBUS_ATTACH_PIDS;
1492 if (mask & SD_BUS_CREDS_COMM)
1493 m |= KDBUS_ATTACH_PID_COMM;
1495 if (mask & SD_BUS_CREDS_TID_COMM)
1496 m |= KDBUS_ATTACH_TID_COMM;
1498 if (mask & SD_BUS_CREDS_EXE)
1499 m |= KDBUS_ATTACH_EXE;
1501 if (mask & SD_BUS_CREDS_CMDLINE)
1502 m |= KDBUS_ATTACH_CMDLINE;
1504 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))
1505 m |= KDBUS_ATTACH_CGROUP;
1507 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1508 m |= KDBUS_ATTACH_CAPS;
1510 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1511 m |= KDBUS_ATTACH_SECLABEL;
1513 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1514 m |= KDBUS_ATTACH_AUDIT;
1516 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1517 m |= KDBUS_ATTACH_NAMES;
1519 if (mask & SD_BUS_CREDS_DESCRIPTION)
1520 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1522 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1523 m |= KDBUS_ATTACH_AUXGROUPS;
1528 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1529 struct kdbus_cmd *make;
1530 struct kdbus_item *n;
1537 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1542 make = alloca0_align(offsetof(struct kdbus_cmd, items) +
1543 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1544 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1545 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1546 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1549 make->size = offsetof(struct kdbus_cmd, items);
1551 /* Set the bloom parameters */
1553 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1554 sizeof(struct kdbus_bloom_parameter);
1555 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1556 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1557 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1559 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1560 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1562 make->size += ALIGN8(n->size);
1564 /* The busses we create make no restrictions on what metadata
1565 * peers can read from incoming messages. */
1566 n = KDBUS_ITEM_NEXT(n);
1567 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1568 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1569 n->data64[0] = _KDBUS_ATTACH_ANY;
1570 make->size += ALIGN8(n->size);
1572 /* Provide all metadata via bus-owner queries */
1573 n = KDBUS_ITEM_NEXT(n);
1574 n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1575 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1576 n->data64[0] = _KDBUS_ATTACH_ANY;
1577 make->size += ALIGN8(n->size);
1579 /* Set the a good name */
1580 n = KDBUS_ITEM_NEXT(n);
1581 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1582 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1583 n->type = KDBUS_ITEM_MAKE_NAME;
1584 make->size += ALIGN8(n->size);
1586 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1588 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1596 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1608 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1615 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1622 p = newa(char, len);
1624 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1626 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1640 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1641 _cleanup_free_ char *path = NULL;
1642 struct kdbus_cmd *make;
1643 struct kdbus_item *n;
1647 fd = bus_kernel_open_bus_fd(bus_name, &path);
1651 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd, items)) +
1652 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1654 make->size = ALIGN8(offsetof(struct kdbus_cmd, items));
1655 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1658 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1659 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1660 n->type = KDBUS_ITEM_MAKE_NAME;
1661 make->size += ALIGN8(n->size);
1664 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1672 p = strjoin(dirname(path), "/", name, NULL);
1684 int bus_kernel_try_close(sd_bus *bus) {
1685 struct kdbus_cmd byebye = { .size = sizeof(byebye) };
1688 assert(bus->is_kernel);
1690 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE, &byebye) < 0)
1696 int bus_kernel_drop_one(int fd) {
1697 struct kdbus_cmd_recv recv = {
1698 .size = sizeof(recv),
1699 .flags = KDBUS_RECV_DROP,
1704 if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1710 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1711 struct kdbus_cmd *update;
1712 struct kdbus_item *n;
1715 assert(bus->is_kernel);
1717 update = alloca0_align(offsetof(struct kdbus_cmd, items) +
1718 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1722 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1723 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1724 n->data64[0] = bus->attach_flags;
1727 offsetof(struct kdbus_cmd, items) +
1730 if (ioctl(bus->input_fd, KDBUS_CMD_UPDATE, update) < 0)
1736 int bus_kernel_fix_attach_mask(void) {
1737 _cleanup_free_ char *mask = NULL;
1738 uint64_t m = (uint64_t) -1;
1742 /* By default we don't want any kdbus metadata fields to be
1743 * suppressed, hence we reset the kernel mask for it to
1744 * (uint64_t) -1. If the module argument was overwritten by
1745 * the kernel cmdline, we leave it as is. */
1747 r = get_proc_cmdline_key("kdbus.attach_flags_mask=", &mask);
1749 return log_warning_errno(r, "Failed to read kernel command line: %m");
1752 sprintf(buf, "0x%" PRIx64 "\n", m);
1753 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1755 return log_full_errno(IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1756 "Failed to write kdbus attach mask: %m");
1762 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1763 struct kdbus_cmd_info cmd = {
1764 .size = sizeof(struct kdbus_cmd_info),
1766 struct kdbus_info *info;
1767 struct kdbus_item *item;
1773 assert(bus->is_kernel);
1775 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1779 info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1781 KDBUS_ITEM_FOREACH(item, info, items)
1782 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1783 r = free_and_strdup(&n, item->str);
1787 bus_kernel_cmd_free(bus, cmd.offset);