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) |
300 ((m->header->type == SD_BUS_MESSAGE_SIGNAL) ? KDBUS_MSG_SIGNAL : 0);
303 /* verify_destination_id will usually be 0, which makes the kernel driver only look
304 * at the provided well-known name. Otherwise, the kernel will make sure the provided
305 * destination id matches the owner of the provided weel-known-name, and fail if they
306 * differ. Currently, this is only needed for bus-proxyd. */
307 m->kdbus->dst_id = m->verify_destination_id;
309 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
311 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
312 m->kdbus->cookie = (uint64_t) m->header->serial;
313 m->kdbus->priority = m->priority;
315 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
316 m->kdbus->cookie_reply = m->reply_cookie;
320 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
321 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
322 m->timeout * NSEC_PER_USEC;
328 append_destination(&d, destination, dl);
330 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
332 MESSAGE_FOREACH_PART(part, i, m) {
334 /* If this is padding then simply send a
335 * vector with a NULL data pointer which the
336 * kernel will just pass through. This is the
337 * most efficient way to encode zeroes */
339 append_payload_vec(&d, NULL, part->size);
343 if (part->memfd >= 0 && part->sealed && destination) {
344 /* Try to send a memfd, if the part is
345 * sealed and this is not a broadcast. Since we can only */
347 append_payload_memfd(&d, part->memfd, part->memfd_offset, part->size);
351 /* Otherwise, let's send a vector to the actual data.
352 * For that, we need to map it first. */
353 r = bus_body_part_map(part);
357 append_payload_vec(&d, part->data, part->size);
360 if (m->header->type == SD_BUS_MESSAGE_SIGNAL) {
361 struct kdbus_bloom_filter *bloom;
363 bloom = append_bloom(&d, m->bus->bloom_size);
364 r = bus_message_setup_bloom(m, bloom);
370 append_fds(&d, m->fds, m->n_fds);
372 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
373 assert(m->kdbus->size <= sz);
382 static void unset_memfds(struct sd_bus_message *m) {
383 struct bus_body_part *part;
388 /* Make sure the memfds are not freed twice */
389 MESSAGE_FOREACH_PART(part, i, m)
390 if (part->memfd >= 0)
394 static void message_set_timestamp(sd_bus *bus, sd_bus_message *m, const struct kdbus_timestamp *ts) {
401 if (!(bus->attach_flags & KDBUS_ATTACH_TIMESTAMP))
404 m->realtime = ts->realtime_ns / NSEC_PER_USEC;
405 m->monotonic = ts->monotonic_ns / NSEC_PER_USEC;
406 m->seqnum = ts->seqnum;
409 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
410 sd_bus_message *m = NULL;
411 struct kdbus_item *d;
413 _cleanup_free_ int *fds = NULL;
414 struct bus_header *h = NULL;
415 size_t total, n_bytes = 0, idx = 0;
416 const char *destination = NULL, *seclabel = NULL;
421 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
423 KDBUS_ITEM_FOREACH(d, k, items) {
426 l = d->size - offsetof(struct kdbus_item, data);
430 case KDBUS_ITEM_PAYLOAD_OFF:
432 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
434 if (!bus_header_is_complete(h, d->vec.size))
438 n_bytes += d->vec.size;
441 case KDBUS_ITEM_PAYLOAD_MEMFD:
445 n_bytes += d->memfd.size;
448 case KDBUS_ITEM_FDS: {
453 f = realloc(fds, sizeof(int) * (n_fds + j));
458 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
463 case KDBUS_ITEM_SECLABEL:
472 r = bus_header_message_size(h, &total);
476 if (n_bytes != total)
479 /* on kdbus we only speak native endian gvariant, never dbus1
480 * marshalling or reverse endian */
481 if (h->version != 2 ||
482 h->endian != BUS_NATIVE_ENDIAN)
485 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
489 /* The well-known names list is different from the other
490 credentials. If we asked for it, but nothing is there, this
491 means that the list of well-known names is simply empty, not
492 that we lack any data */
494 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
496 KDBUS_ITEM_FOREACH(d, k, items) {
499 l = d->size - offsetof(struct kdbus_item, data);
503 case KDBUS_ITEM_PAYLOAD_OFF: {
506 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
508 if (idx + d->vec.size > begin_body) {
509 struct bus_body_part *part;
511 /* Contains body material */
513 part = message_append_part(m);
519 /* A -1 offset is NUL padding. */
520 part->is_zero = d->vec.offset == ~0ULL;
522 if (idx >= begin_body) {
524 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
525 part->size = d->vec.size;
528 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
529 part->size = d->vec.size - (begin_body - idx);
539 case KDBUS_ITEM_PAYLOAD_MEMFD: {
540 struct bus_body_part *part;
542 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
547 part = message_append_part(m);
553 part->memfd = d->memfd.fd;
554 part->memfd_offset = d->memfd.start;
555 part->size = d->memfd.size;
558 idx += d->memfd.size;
562 case KDBUS_ITEM_PIDS:
564 /* The PID/TID might be missing, when the data
565 * is faked by some data bus proxy and it
566 * lacks that information about the real
567 * client since SO_PEERCRED is used for
570 if (d->pids.pid > 0) {
571 m->creds.pid = (pid_t) d->pids.pid;
572 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
575 if (d->pids.tid > 0) {
576 m->creds.tid = (pid_t) d->pids.tid;
577 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
582 case KDBUS_ITEM_CREDS:
584 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
586 if ((uid_t) d->creds.uid != UID_INVALID) {
587 m->creds.uid = (uid_t) d->creds.uid;
588 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
591 if ((uid_t) d->creds.euid != UID_INVALID) {
592 m->creds.euid = (uid_t) d->creds.euid;
593 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
596 if ((uid_t) d->creds.suid != UID_INVALID) {
597 m->creds.suid = (uid_t) d->creds.suid;
598 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
601 if ((uid_t) d->creds.fsuid != UID_INVALID) {
602 m->creds.fsuid = (uid_t) d->creds.fsuid;
603 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
606 if ((gid_t) d->creds.gid != GID_INVALID) {
607 m->creds.gid = (gid_t) d->creds.gid;
608 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
611 if ((gid_t) d->creds.egid != GID_INVALID) {
612 m->creds.egid = (gid_t) d->creds.egid;
613 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
616 if ((gid_t) d->creds.sgid != GID_INVALID) {
617 m->creds.sgid = (gid_t) d->creds.sgid;
618 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
621 if ((gid_t) d->creds.fsgid != GID_INVALID) {
622 m->creds.fsgid = (gid_t) d->creds.fsgid;
623 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
628 case KDBUS_ITEM_TIMESTAMP:
629 message_set_timestamp(bus, m, &d->timestamp);
632 case KDBUS_ITEM_PID_COMM:
633 m->creds.comm = d->str;
634 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
637 case KDBUS_ITEM_TID_COMM:
638 m->creds.tid_comm = d->str;
639 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
643 m->creds.exe = d->str;
644 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
647 case KDBUS_ITEM_CMDLINE:
648 m->creds.cmdline = d->str;
649 m->creds.cmdline_size = l;
650 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
653 case KDBUS_ITEM_CGROUP:
654 m->creds.cgroup = d->str;
655 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;
657 r = bus_get_root_path(bus);
661 m->creds.cgroup_root = bus->cgroup_root;
665 case KDBUS_ITEM_AUDIT:
666 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
667 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
668 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
671 if ((uid_t) d->audit.loginuid != UID_INVALID) {
672 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
673 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
677 case KDBUS_ITEM_CAPS:
678 if (d->caps.last_cap != cap_last_cap() ||
679 d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) {
684 m->creds.capability = d->caps.caps;
685 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;
688 case KDBUS_ITEM_DST_NAME:
689 if (!service_name_is_valid(d->str)) {
694 destination = d->str;
697 case KDBUS_ITEM_OWNED_NAME:
698 if (!service_name_is_valid(d->name.name)) {
703 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
707 /* We just extend the array here, but
708 * do not allocate the strings inside
709 * of it, instead we just point to our
710 * buffer directly. */
711 n = strv_length(m->creds.well_known_names);
712 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
718 wkn[n] = d->name.name;
720 m->creds.well_known_names = wkn;
722 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
726 case KDBUS_ITEM_CONN_DESCRIPTION:
727 m->creds.description = d->str;
728 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
731 case KDBUS_ITEM_AUXGROUPS:
733 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
734 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
736 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
737 m->creds.supplementary_gids = (gid_t*) d->data32;
738 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
744 case KDBUS_ITEM_SECLABEL:
748 log_debug("Got unknown field from kernel %llu", d->type);
752 /* If we requested the list of well-known names to be appended
753 * and the sender had none no item for it will be
754 * attached. However, this does *not* mean that the kernel
755 * didn't want to provide this information to us. Hence, let's
756 * explicitly mark this information as available if it was
758 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
760 r = bus_message_parse_fields(m);
764 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
765 if ((uint64_t) m->header->serial != k->cookie) {
770 /* Refuse messages where the reply flag doesn't match up */
771 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) {
776 /* Refuse reply messages where the reply cookie doesn't match up */
777 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
782 /* Refuse messages where the autostart flag doesn't match up */
783 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) {
788 /* Override information from the user header with data from the kernel */
789 if (k->src_id == KDBUS_SRC_ID_KERNEL)
790 bus_message_set_sender_driver(bus, m);
792 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
793 m->sender = m->creds.unique_name = m->sender_buffer;
797 m->destination = destination;
798 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
799 m->destination = NULL;
800 else if (k->dst_id == KDBUS_DST_ID_NAME)
801 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
803 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
804 m->destination = m->destination_buffer;
807 /* We take possession of the kmsg struct now */
809 m->release_kdbus = true;
813 bus->rqueue[bus->rqueue_size++] = m;
819 sd_bus_message_unref(m);
824 int bus_kernel_take_fd(sd_bus *b) {
825 struct kdbus_cmd_free cmd_free = {
826 .size = sizeof(cmd_free),
829 struct kdbus_bloom_parameter *bloom = NULL;
830 struct kdbus_cmd_hello *hello;
831 struct kdbus_item_list *items;
832 struct kdbus_item *item;
833 _cleanup_free_ char *g = NULL;
835 size_t l = 0, m = 0, sz;
845 if (b->description) {
846 g = bus_label_escape(b->description);
854 /* If no name is explicitly set, we'll include a hint
855 * indicating the library implementation, a hint which
856 * kind of bus this is and the thread name */
858 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
861 name = b->is_system ? "sd-system" :
862 b->is_user ? "sd-user" : "sd";
864 _cleanup_free_ char *e = NULL;
866 e = bus_label_escape(pr);
870 g = strappend(b->is_system ? "sd-system-" :
871 b->is_user ? "sd-user-" : "sd-",
879 b->description = bus_label_unescape(name);
886 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
887 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
889 if (b->fake_creds_valid)
890 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
892 if (b->fake_pids_valid)
893 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
896 l = strlen(b->fake_label);
897 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
900 hello = alloca0_align(sz, 8);
902 hello->flags = b->hello_flags;
903 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
904 hello->attach_flags_recv = b->attach_flags;
905 hello->pool_size = KDBUS_POOL_SIZE;
909 item->size = offsetof(struct kdbus_item, str) + m + 1;
910 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
911 memcpy(item->str, name, m + 1);
912 item = KDBUS_ITEM_NEXT(item);
914 if (b->fake_creds_valid) {
915 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
916 item->type = KDBUS_ITEM_CREDS;
917 item->creds = b->fake_creds;
919 item = KDBUS_ITEM_NEXT(item);
922 if (b->fake_pids_valid) {
923 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
924 item->type = KDBUS_ITEM_PIDS;
925 item->pids = b->fake_pids;
927 item = KDBUS_ITEM_NEXT(item);
931 item->size = offsetof(struct kdbus_item, str) + l + 1;
932 item->type = KDBUS_ITEM_SECLABEL;
933 memcpy(item->str, b->fake_label, l+1);
936 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
940 if (!b->kdbus_buffer) {
941 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
942 if (b->kdbus_buffer == MAP_FAILED) {
943 b->kdbus_buffer = NULL;
949 /* The higher 32bit of the bus_flags fields are considered
950 * 'incompatible flags'. Refuse them all for now. */
951 if (hello->bus_flags > 0xFFFFFFFFULL) {
956 /* extract bloom parameters from items */
957 items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
958 KDBUS_ITEM_FOREACH(item, items, items) {
959 switch (item->type) {
960 case KDBUS_ITEM_BLOOM_PARAMETER:
961 bloom = &item->bloom_parameter;
966 if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
971 b->bloom_size = (size_t) bloom->size;
972 b->bloom_n_hash = (unsigned) bloom->n_hash;
974 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
979 b->unique_id = hello->id;
982 b->bus_client = true;
983 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
984 b->message_version = 2;
985 b->message_endian = BUS_NATIVE_ENDIAN;
987 /* the kernel told us the UUID of the underlying bus */
988 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
990 /* free returned items */
991 (void) bus_kernel_cmd_free(b, hello->offset);
993 return bus_start_running(b);
996 cmd_free.offset = hello->offset;
997 (void) ioctl(b->input_fd, KDBUS_CMD_FREE, &cmd_free);
1001 int bus_kernel_connect(sd_bus *b) {
1003 assert(b->input_fd < 0);
1004 assert(b->output_fd < 0);
1010 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1011 if (b->input_fd < 0)
1014 b->output_fd = b->input_fd;
1016 return bus_kernel_take_fd(b);
1019 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1020 struct kdbus_cmd_free cmd = {
1021 .size = sizeof(cmd),
1028 assert(bus->is_kernel);
1030 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1037 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1038 struct kdbus_item *d;
1043 KDBUS_ITEM_FOREACH(d, k, items) {
1044 if (d->type == KDBUS_ITEM_FDS)
1045 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1046 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1047 safe_close(d->memfd.fd);
1050 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1053 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1054 struct kdbus_cmd_send cmd = { };
1059 assert(bus->state == BUS_RUNNING);
1061 /* If we can't deliver, we want room for the error message */
1062 r = bus_rqueue_make_room(bus);
1066 r = bus_message_setup_kmsg(bus, m);
1070 cmd.size = sizeof(cmd);
1071 cmd.msg_address = (uintptr_t)m->kdbus;
1073 /* If this is a synchronous method call, then let's tell the
1074 * kernel, so that it can pass CPU time/scheduling to the
1075 * destination for the time, if it wants to. If we
1076 * synchronously wait for the result anyway, we won't need CPU
1078 if (hint_sync_call) {
1079 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1080 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1083 r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1085 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1086 sd_bus_message *reply;
1088 if (errno == EAGAIN || errno == EINTR)
1090 else if (errno == ENXIO || errno == ESRCH) {
1092 /* ENXIO: unique name not known
1093 * ESRCH: well-known name not known */
1095 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1096 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1098 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1102 } else if (errno == EADDRNOTAVAIL) {
1104 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1106 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1107 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1109 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1115 r = bus_message_new_synthetic_error(
1117 BUS_MESSAGE_COOKIE(m),
1124 r = bus_seal_synthetic_message(bus, reply);
1128 bus->rqueue[bus->rqueue_size++] = reply;
1130 } else if (hint_sync_call) {
1131 struct kdbus_msg *k;
1133 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1136 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1138 r = bus_kernel_make_message(bus, k);
1140 close_kdbus_msg(bus, k);
1142 /* Anybody can send us invalid messages, let's just drop them. */
1143 if (r == -EBADMSG || r == -EPROTOTYPE)
1144 log_debug_errno(r, "Ignoring invalid message: %m");
1149 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1150 close_kdbus_msg(bus, k);
1157 static int push_name_owner_changed(
1160 const char *old_owner,
1161 const char *new_owner,
1162 const struct kdbus_timestamp *ts) {
1164 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1169 r = sd_bus_message_new_signal(
1172 "/org/freedesktop/DBus",
1173 "org.freedesktop.DBus",
1174 "NameOwnerChanged");
1178 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1182 bus_message_set_sender_driver(bus, m);
1183 message_set_timestamp(bus, m, ts);
1185 r = bus_seal_synthetic_message(bus, m);
1189 bus->rqueue[bus->rqueue_size++] = m;
1195 static int translate_name_change(
1197 const struct kdbus_msg *k,
1198 const struct kdbus_item *d,
1199 const struct kdbus_timestamp *ts) {
1201 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1207 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1210 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1212 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1214 if (isempty(old_owner))
1219 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1221 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1224 static int translate_id_change(
1226 const struct kdbus_msg *k,
1227 const struct kdbus_item *d,
1228 const struct kdbus_timestamp *ts) {
1230 char owner[UNIQUE_NAME_MAX];
1236 sprintf(owner, ":1.%llu", d->id_change.id);
1238 return push_name_owner_changed(
1240 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1241 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1245 static int translate_reply(
1247 const struct kdbus_msg *k,
1248 const struct kdbus_item *d,
1249 const struct kdbus_timestamp *ts) {
1251 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1258 r = bus_message_new_synthetic_error(
1261 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1262 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1263 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1268 message_set_timestamp(bus, m, ts);
1270 r = bus_seal_synthetic_message(bus, m);
1274 bus->rqueue[bus->rqueue_size++] = m;
1280 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1281 static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1282 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1283 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1284 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1286 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1287 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1289 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1290 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1293 struct kdbus_item *d, *found = NULL;
1294 struct kdbus_timestamp *ts = NULL;
1298 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1300 KDBUS_ITEM_FOREACH(d, k, items) {
1301 if (d->type == KDBUS_ITEM_TIMESTAMP)
1304 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1309 log_debug("Got unknown field from kernel %llu", d->type);
1313 log_debug("Didn't find a kernel message to translate.");
1317 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1320 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1321 struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1322 struct kdbus_msg *k;
1327 r = bus_rqueue_make_room(bus);
1331 if (hint_priority) {
1332 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1333 recv.priority = priority;
1336 r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1338 if (errno == EAGAIN)
1341 if (errno == EOVERFLOW) {
1342 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1349 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1350 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1351 r = bus_kernel_make_message(bus, k);
1353 /* Anybody can send us invalid messages, let's just drop them. */
1354 if (r == -EBADMSG || r == -EPROTOTYPE) {
1355 log_debug_errno(r, "Ignoring invalid message: %m");
1359 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1360 r = bus_kernel_translate_message(bus, k);
1362 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1367 close_kdbus_msg(bus, k);
1369 return r < 0 ? r : 1;
1372 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1373 struct memfd_cache *c;
1380 if (!bus || !bus->is_kernel)
1383 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1385 if (bus->n_memfd_cache <= 0) {
1388 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1390 r = memfd_new(bus->description);
1400 c = &bus->memfd_cache[--bus->n_memfd_cache];
1403 assert(c->mapped == 0 || c->address);
1405 *address = c->address;
1406 *mapped = c->mapped;
1407 *allocated = c->allocated;
1410 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1415 static void close_and_munmap(int fd, void *address, size_t size) {
1417 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1422 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1423 struct memfd_cache *c;
1424 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1427 assert(mapped == 0 || address);
1429 if (!bus || !bus->is_kernel) {
1430 close_and_munmap(fd, address, mapped);
1434 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1436 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1437 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1439 close_and_munmap(fd, address, mapped);
1443 c = &bus->memfd_cache[bus->n_memfd_cache++];
1445 c->address = address;
1447 /* If overly long, let's return a bit to the OS */
1448 if (mapped > max_mapped) {
1449 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1450 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1451 c->mapped = c->allocated = max_mapped;
1454 c->allocated = allocated;
1457 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1460 void bus_kernel_flush_memfd(sd_bus *b) {
1465 for (i = 0; i < b->n_memfd_cache; i++)
1466 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1469 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1472 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1473 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1475 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1476 f |= KDBUS_NAME_REPLACE_EXISTING;
1478 if (flags & SD_BUS_NAME_QUEUE)
1479 f |= KDBUS_NAME_QUEUE;
1484 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1487 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1488 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1489 m |= KDBUS_ATTACH_CREDS;
1491 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1492 m |= KDBUS_ATTACH_PIDS;
1494 if (mask & SD_BUS_CREDS_COMM)
1495 m |= KDBUS_ATTACH_PID_COMM;
1497 if (mask & SD_BUS_CREDS_TID_COMM)
1498 m |= KDBUS_ATTACH_TID_COMM;
1500 if (mask & SD_BUS_CREDS_EXE)
1501 m |= KDBUS_ATTACH_EXE;
1503 if (mask & SD_BUS_CREDS_CMDLINE)
1504 m |= KDBUS_ATTACH_CMDLINE;
1506 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))
1507 m |= KDBUS_ATTACH_CGROUP;
1509 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1510 m |= KDBUS_ATTACH_CAPS;
1512 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1513 m |= KDBUS_ATTACH_SECLABEL;
1515 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1516 m |= KDBUS_ATTACH_AUDIT;
1518 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1519 m |= KDBUS_ATTACH_NAMES;
1521 if (mask & SD_BUS_CREDS_DESCRIPTION)
1522 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1524 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1525 m |= KDBUS_ATTACH_AUXGROUPS;
1530 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1531 struct kdbus_cmd_make *make;
1532 struct kdbus_item *n;
1539 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1544 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1545 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1546 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1547 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1548 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1551 make->size = offsetof(struct kdbus_cmd_make, items);
1553 /* Set the bloom parameters */
1555 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1556 sizeof(struct kdbus_bloom_parameter);
1557 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1558 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1559 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1561 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1562 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1564 make->size += ALIGN8(n->size);
1566 /* The busses we create make no restrictions on what metadata
1567 * peers can read from incoming messages. */
1568 n = KDBUS_ITEM_NEXT(n);
1569 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1570 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1571 n->data64[0] = _KDBUS_ATTACH_ANY;
1572 make->size += ALIGN8(n->size);
1574 /* Provide all metadata via bus-owner queries */
1575 n = KDBUS_ITEM_NEXT(n);
1576 n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1577 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1578 n->data64[0] = _KDBUS_ATTACH_ANY;
1579 make->size += ALIGN8(n->size);
1581 /* Set the a good name */
1582 n = KDBUS_ITEM_NEXT(n);
1583 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1584 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1585 n->type = KDBUS_ITEM_MAKE_NAME;
1586 make->size += ALIGN8(n->size);
1588 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1590 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1598 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1610 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1617 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1624 p = newa(char, len);
1626 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1628 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1642 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1643 _cleanup_free_ char *path = NULL;
1644 struct kdbus_cmd_make *make;
1645 struct kdbus_item *n;
1649 fd = bus_kernel_open_bus_fd(bus_name, &path);
1653 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1654 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1656 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1657 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1660 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1661 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1662 n->type = KDBUS_ITEM_MAKE_NAME;
1663 make->size += ALIGN8(n->size);
1666 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1674 p = strjoin(dirname(path), "/", name, NULL);
1686 int bus_kernel_try_close(sd_bus *bus) {
1688 assert(bus->is_kernel);
1690 if (ioctl(bus->input_fd, KDBUS_CMD_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 *update;
1712 struct kdbus_item *n;
1715 assert(bus->is_kernel);
1717 update = alloca0_align(offsetof(struct kdbus_cmd_update, 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_update, items) +
1730 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_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);