1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
33 #include "bus-internal.h"
34 #include "bus-message.h"
35 #include "bus-kernel.h"
36 #include "bus-bloom.h"
39 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
41 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
47 if (!startswith(s, ":1."))
50 r = safe_atou64(s + 3, id);
57 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
63 /* Note that p can be NULL, which encodes a region full of
64 * zeroes, which is useful to optimize certain padding
67 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
68 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
69 (*d)->vec.address = PTR_TO_UINT64(p);
72 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
75 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
81 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
82 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
83 (*d)->memfd.fd = memfd;
84 (*d)->memfd.size = sz;
86 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
89 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
95 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
96 (*d)->type = KDBUS_ITEM_DST_NAME;
97 memcpy((*d)->str, s, length + 1);
99 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
102 static void* append_bloom(struct kdbus_item **d, size_t length) {
109 (*d)->size = offsetof(struct kdbus_item, data) + length;
110 (*d)->type = KDBUS_ITEM_BLOOM;
113 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
118 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
124 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
125 (*d)->type = KDBUS_ITEM_FDS;
126 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
128 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
131 static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) {
138 memset(bloom, 0, BLOOM_SIZE);
140 bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type));
143 bloom_add_pair(bloom, "interface", m->interface);
145 bloom_add_pair(bloom, "member", m->member);
147 bloom_add_pair(bloom, "path", m->path);
148 bloom_add_pair(bloom, "path-slash-prefix", m->path);
149 bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/');
152 r = sd_bus_message_rewind(m, true);
156 for (i = 0; i < 64; i++) {
159 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
162 r = sd_bus_message_peek_type(m, &type, NULL);
166 if (type != SD_BUS_TYPE_STRING &&
167 type != SD_BUS_TYPE_OBJECT_PATH &&
168 type != SD_BUS_TYPE_SIGNATURE)
171 r = sd_bus_message_read_basic(m, type, &t);
175 e = stpcpy(buf, "arg");
179 *(e++) = '0' + (i / 10);
180 *(e++) = '0' + (i % 10);
184 bloom_add_pair(bloom, buf, t);
186 strcpy(e, "-dot-prefix");
187 bloom_add_prefixes(bloom, buf, t, '.');
188 strcpy(e, "-slash-prefix");
189 bloom_add_prefixes(bloom, buf, t, '/');
195 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
196 struct bus_body_part *part;
197 struct kdbus_item *d;
211 if (m->destination) {
212 r = bus_kernel_parse_unique_name(m->destination, &unique);
220 sz = offsetof(struct kdbus_msg, items);
222 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
223 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
225 /* Add in fixed header, fields header and payload */
226 sz += (1 + m->n_body_parts) *
227 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
229 /* Add space for bloom filter */
230 sz += ALIGN8(offsetof(struct kdbus_item, data) + BLOOM_SIZE);
232 /* Add in well-known destination header */
234 dl = strlen(m->destination);
235 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
238 /* Add space for unix fds */
240 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
242 m->kdbus = memalign(8, sz);
248 m->free_kdbus = true;
249 memset(m->kdbus, 0, sz);
252 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
253 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
256 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
257 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
258 m->kdbus->cookie = m->header->serial;
260 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
265 append_destination(&d, m->destination, dl);
267 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
269 MESSAGE_FOREACH_PART(part, i, m) {
271 /* If this is padding then simply send a
272 * vector with a NULL data pointer which the
273 * kernel will just pass through. This is the
274 * most efficient way to encode zeroes */
276 append_payload_vec(&d, NULL, part->size);
280 if (part->memfd >= 0 && part->sealed && m->destination) {
281 /* Try to send a memfd, if the part is
282 * sealed and this is not a broadcast. Since we can only */
284 append_payload_memfd(&d, part->memfd, part->size);
288 /* Otherwise let's send a vector to the actual data,
289 * for that we need to map it first. */
290 r = bus_body_part_map(part);
294 append_payload_vec(&d, part->data, part->size);
297 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
300 p = append_bloom(&d, BLOOM_SIZE);
301 r = bus_message_setup_bloom(m, p);
307 append_fds(&d, m->fds, m->n_fds);
309 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
310 assert(m->kdbus->size <= sz);
319 int bus_kernel_take_fd(sd_bus *b) {
320 struct kdbus_cmd_hello hello;
331 hello.size = sizeof(hello);
332 hello.conn_flags = b->hello_flags;
333 hello.attach_flags = b->attach_flags;
334 hello.pool_size = KDBUS_POOL_SIZE;
336 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, &hello);
340 if (!b->kdbus_buffer) {
341 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
342 if (b->kdbus_buffer == MAP_FAILED) {
343 b->kdbus_buffer = NULL;
348 /* The higher 32bit of both flags fields are considered
349 * 'incompatible flags'. Refuse them all for now. */
350 if (hello.bus_flags > 0xFFFFFFFFULL ||
351 hello.conn_flags > 0xFFFFFFFFULL)
354 if (hello.bloom_size != BLOOM_SIZE)
357 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello.id) < 0)
360 b->unique_id = hello.id;
363 b->bus_client = true;
364 b->can_fds = !!(hello.conn_flags & KDBUS_HELLO_ACCEPT_FD);
365 b->message_version = 2;
366 b->message_endian = BUS_NATIVE_ENDIAN;
368 /* the kernel told us the UUID of the underlying bus */
369 memcpy(b->server_id.bytes, hello.id128, sizeof(b->server_id.bytes));
371 return bus_start_running(b);
374 int bus_kernel_connect(sd_bus *b) {
376 assert(b->input_fd < 0);
377 assert(b->output_fd < 0);
383 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
387 b->output_fd = b->input_fd;
389 return bus_kernel_take_fd(b);
392 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
397 assert(bus->state == BUS_RUNNING);
399 /* If we can't deliver, we want room for the error message */
400 r = bus_rqueue_make_room(bus);
404 r = bus_message_setup_kmsg(bus, m);
408 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
410 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
411 sd_bus_message *reply;
413 if (errno == EAGAIN || errno == EINTR)
415 else if (errno == ENXIO || errno == ESRCH) {
417 /* ENXIO: unique name not known
418 * ESRCH: well-known name not known */
420 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
421 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
423 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
427 } else if (errno == EADDRNOTAVAIL) {
429 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
431 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
432 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
434 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
440 r = bus_message_new_synthetic_error(
442 BUS_MESSAGE_SERIAL(m),
449 r = bus_seal_synthetic_message(bus, reply);
453 bus->rqueue[bus->rqueue_size++] = reply;
461 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
463 struct kdbus_item *d;
468 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
469 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
471 KDBUS_ITEM_FOREACH(d, k, items) {
473 if (d->type == KDBUS_ITEM_FDS)
474 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
475 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
476 close_nointr_nofail(d->memfd.fd);
480 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
481 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
486 r = sd_bus_message_new_signal(
488 "/org/freedesktop/DBus",
489 "org.freedesktop.DBus",
495 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
499 m->sender = "org.freedesktop.DBus";
501 r = bus_seal_synthetic_message(bus, m);
505 bus->rqueue[bus->rqueue_size++] = m;
511 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
512 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
518 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
521 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
523 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
525 if (isempty(old_owner))
530 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
532 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
535 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
536 char owner[UNIQUE_NAME_MAX];
542 sprintf(owner, ":1.%llu", d->id_change.id);
544 return push_name_owner_changed(
546 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
547 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
550 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
551 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
558 r = bus_message_new_synthetic_error(
561 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
562 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
563 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
568 m->sender = "org.freedesktop.DBus";
570 r = bus_seal_synthetic_message(bus, m);
574 bus->rqueue[bus->rqueue_size++] = m;
580 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
581 struct kdbus_item *d, *found = NULL;
583 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
584 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
585 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
586 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
588 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
589 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
591 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
592 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
597 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
599 KDBUS_ITEM_FOREACH(d, k, items) {
600 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
605 log_debug("Got unknown field from kernel %llu", d->type);
609 log_debug("Didn't find a kernel message to translate.");
613 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
616 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
617 sd_bus_message *m = NULL;
618 struct kdbus_item *d;
620 _cleanup_free_ int *fds = NULL;
621 struct bus_header *h = NULL;
622 size_t total, n_bytes = 0, idx = 0;
623 const char *destination = NULL, *seclabel = NULL;
628 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
630 KDBUS_ITEM_FOREACH(d, k, items) {
633 l = d->size - offsetof(struct kdbus_item, data);
637 case KDBUS_ITEM_PAYLOAD_OFF:
639 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
641 if (!bus_header_is_complete(h, d->vec.size))
645 n_bytes += d->vec.size;
648 case KDBUS_ITEM_PAYLOAD_MEMFD:
652 n_bytes += d->memfd.size;
655 case KDBUS_ITEM_FDS: {
660 f = realloc(fds, sizeof(int) * (n_fds + j));
665 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
670 case KDBUS_ITEM_SECLABEL:
679 r = bus_header_message_size(h, &total);
683 if (n_bytes != total)
686 /* on kdbus we only speak native endian gvariant, never dbus1
687 * marshalling or reverse endian */
688 if (h->version != 2 ||
689 h->endian != BUS_NATIVE_ENDIAN)
692 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
696 /* The well-known names list is different from the other
697 credentials. If we asked for it, but nothing is there, this
698 means that the list of well-known names is simply empty, not
699 that we lack any data */
701 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
703 KDBUS_ITEM_FOREACH(d, k, items) {
706 l = d->size - offsetof(struct kdbus_item, data);
710 case KDBUS_ITEM_PAYLOAD_OFF: {
713 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
715 if (idx + d->vec.size > begin_body) {
716 struct bus_body_part *part;
718 /* Contains body material */
720 part = message_append_part(m);
726 /* A -1 offset is NUL padding. */
727 part->is_zero = d->vec.offset == ~0ULL;
729 if (idx >= begin_body) {
731 part->data = (uint8_t *)k + d->vec.offset;
732 part->size = d->vec.size;
735 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
736 part->size = d->vec.size - (begin_body - idx);
746 case KDBUS_ITEM_PAYLOAD_MEMFD: {
747 struct bus_body_part *part;
749 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
754 part = message_append_part(m);
760 part->memfd = d->memfd.fd;
761 part->size = d->memfd.size;
764 idx += d->memfd.size;
768 case KDBUS_ITEM_CREDS:
769 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
770 m->creds.uid = d->creds.uid;
771 m->creds.gid = d->creds.gid;
772 m->creds.pid = d->creds.pid;
773 m->creds.tid = d->creds.tid;
774 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID) & bus->creds_mask;
777 case KDBUS_ITEM_TIMESTAMP:
778 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
779 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
782 case KDBUS_ITEM_PID_COMM:
783 m->creds.comm = d->str;
784 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
787 case KDBUS_ITEM_TID_COMM:
788 m->creds.tid_comm = d->str;
789 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
793 m->creds.exe = d->str;
794 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
797 case KDBUS_ITEM_CMDLINE:
798 m->creds.cmdline = d->str;
799 m->creds.cmdline_size = l;
800 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
803 case KDBUS_ITEM_CGROUP:
804 m->creds.cgroup = d->str;
805 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;
808 case KDBUS_ITEM_AUDIT:
809 m->creds.audit_session_id = d->audit.sessionid;
810 m->creds.audit_login_uid = d->audit.loginuid;
811 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
814 case KDBUS_ITEM_CAPS:
815 m->creds.capability = d->data;
816 m->creds.capability_size = l;
817 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;
820 case KDBUS_ITEM_DST_NAME:
821 destination = d->str;
824 case KDBUS_ITEM_NAME:
825 r = strv_extend(&m->creds.well_known_names, d->name.name);
831 case KDBUS_ITEM_SECLABEL:
835 log_debug("Got unknown field from kernel %llu", d->type);
839 r = bus_message_parse_fields(m);
843 /* Override information from the user header with data from the kernel */
844 if (k->src_id == KDBUS_SRC_ID_KERNEL)
845 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
847 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
848 m->sender = m->creds.unique_name = m->sender_buffer;
852 m->destination = destination;
853 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
854 m->destination = NULL;
855 else if (k->dst_id == KDBUS_DST_ID_NAME)
856 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
858 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
859 m->destination = m->destination_buffer;
862 /* We take possession of the kmsg struct now */
864 m->release_kdbus = true;
868 bus->rqueue[bus->rqueue_size++] = m;
874 struct bus_body_part *part;
877 /* Make sure the memfds are not freed twice */
878 MESSAGE_FOREACH_PART(part, i, m)
879 if (part->memfd >= 0)
882 sd_bus_message_unref(m);
888 int bus_kernel_read_message(sd_bus *bus) {
895 r = bus_rqueue_make_room(bus);
899 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
906 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
908 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
909 r = bus_kernel_make_message(bus, k);
911 /* Anybody can send us invalid messages, let's just drop them. */
912 if (r == -EBADMSG || r == -EPROTOTYPE) {
913 log_debug("Ignoring invalid message: %s", strerror(-r));
917 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
918 r = bus_kernel_translate_message(bus, k);
923 close_kdbus_msg(bus, k);
925 return r < 0 ? r : 1;
928 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
929 struct memfd_cache *c;
936 if (!bus || !bus->is_kernel)
939 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
941 if (bus->n_memfd_cache <= 0) {
944 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
946 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
956 c = &bus->memfd_cache[--bus->n_memfd_cache];
959 assert(c->mapped == 0 || c->address);
961 *address = c->address;
963 *allocated = c->allocated;
966 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
971 static void close_and_munmap(int fd, void *address, size_t size) {
973 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
975 close_nointr_nofail(fd);
978 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
979 struct memfd_cache *c;
980 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
983 assert(mapped == 0 || address);
985 if (!bus || !bus->is_kernel) {
986 close_and_munmap(fd, address, mapped);
990 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
992 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
993 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
995 close_and_munmap(fd, address, mapped);
999 c = &bus->memfd_cache[bus->n_memfd_cache++];
1001 c->address = address;
1003 /* If overly long, let's return a bit to the OS */
1004 if (mapped > max_mapped) {
1005 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1006 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1007 c->mapped = c->allocated = max_mapped;
1010 c->allocated = allocated;
1013 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1016 void bus_kernel_flush_memfd(sd_bus *b) {
1021 for (i = 0; i < b->n_memfd_cache; i++)
1022 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1025 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1028 assert(kdbus_flags);
1030 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1031 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1033 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1034 f |= KDBUS_NAME_REPLACE_EXISTING;
1036 if (flags & SD_BUS_NAME_QUEUE)
1037 f |= KDBUS_NAME_QUEUE;
1043 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1048 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1049 m |= KDBUS_ATTACH_CREDS;
1051 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1052 m |= KDBUS_ATTACH_COMM;
1054 if (mask & SD_BUS_CREDS_EXE)
1055 m |= KDBUS_ATTACH_EXE;
1057 if (mask & SD_BUS_CREDS_CMDLINE)
1058 m |= KDBUS_ATTACH_CMDLINE;
1060 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))
1061 m |= KDBUS_ATTACH_CGROUP;
1063 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1064 m |= KDBUS_ATTACH_CAPS;
1066 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1067 m |= KDBUS_ATTACH_SECLABEL;
1069 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1070 m |= KDBUS_ATTACH_AUDIT;
1072 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1073 m |= KDBUS_ATTACH_NAMES;
1079 int bus_kernel_create_bus(const char *name, char **s) {
1080 struct kdbus_cmd_make *make;
1081 struct kdbus_item *n;
1087 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1091 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1092 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1093 offsetof(struct kdbus_item, str) +
1094 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1096 make->size = offsetof(struct kdbus_cmd_make, items);
1099 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1100 n->type = KDBUS_ITEM_BLOOM_SIZE;
1101 n->data64[0] = BLOOM_SIZE;
1102 assert_cc(BLOOM_SIZE % 8 == 0);
1103 make->size += ALIGN8(n->size);
1105 n = KDBUS_ITEM_NEXT(n);
1106 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1107 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1108 n->type = KDBUS_ITEM_MAKE_NAME;
1109 make->size += ALIGN8(n->size);
1111 make->flags = KDBUS_MAKE_POLICY_OPEN;
1113 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1114 close_nointr_nofail(fd);
1118 /* The higher 32bit of the flags field are considered
1119 * 'incompatible flags'. Refuse them all for now. */
1120 if (make->flags > 0xFFFFFFFFULL) {
1121 close_nointr_nofail(fd);
1128 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1130 close_nointr_nofail(fd);
1140 int bus_kernel_create_starter(const char *bus, const char *name) {
1141 struct kdbus_cmd_hello *hello;
1142 struct kdbus_item *n;
1149 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1150 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1152 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1156 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1157 offsetof(struct kdbus_item, str) +
1161 strcpy(n->str, name);
1162 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1163 n->type = KDBUS_ITEM_NAME;
1165 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1166 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1167 hello->pool_size = KDBUS_POOL_SIZE;
1169 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1170 close_nointr_nofail(fd);
1174 /* The higher 32bit of both flags fields are considered
1175 * 'incompatible flags'. Refuse them all for now. */
1176 if (hello->bus_flags > 0xFFFFFFFFULL ||
1177 hello->conn_flags > 0xFFFFFFFFULL) {
1178 close_nointr_nofail(fd);
1182 if (hello->bloom_size != BLOOM_SIZE) {
1183 close_nointr_nofail(fd);
1190 int bus_kernel_create_namespace(const char *name, char **s) {
1191 struct kdbus_cmd_make *make;
1192 struct kdbus_item *n;
1198 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1202 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1203 offsetof(struct kdbus_item, str) +
1207 strcpy(n->str, name);
1208 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1209 n->type = KDBUS_ITEM_MAKE_NAME;
1211 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1212 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1214 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1215 close_nointr_nofail(fd);
1219 /* The higher 32bit of the flags field are considered
1220 * 'incompatible flags'. Refuse them all for now. */
1221 if (make->flags > 0xFFFFFFFFULL) {
1222 close_nointr_nofail(fd);
1229 p = strappend("/dev/kdbus/ns/", name);
1231 close_nointr_nofail(fd);
1241 int bus_kernel_create_monitor(const char *bus) {
1242 struct kdbus_cmd_hello *hello;
1248 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1249 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1251 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1255 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1256 hello->size = sizeof(struct kdbus_cmd_hello);
1257 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1258 hello->pool_size = KDBUS_POOL_SIZE;
1260 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1261 close_nointr_nofail(fd);
1265 /* The higher 32bit of both flags fields are considered
1266 * 'incompatible flags'. Refuse them all for now. */
1267 if (hello->bus_flags > 0xFFFFFFFFULL ||
1268 hello->conn_flags > 0xFFFFFFFFULL) {
1269 close_nointr_nofail(fd);
1276 int bus_kernel_try_close(sd_bus *bus) {
1278 assert(bus->is_kernel);
1280 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)