X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-kernel.c;h=3a9b8af844c6c41abb70bfe8ff96020165e7c261;hp=ed4e189c3ea92a249889c69cd3a0e832ce42a4a1;hb=4a875b6133c9ef0e984547f7ce3b09356be4f7bc;hpb=7211f918ba2b86e0041413b47d51d7593e73cf5d diff --git a/src/libsystemd-bus/bus-kernel.c b/src/libsystemd-bus/bus-kernel.c index ed4e189c3..3a9b8af84 100644 --- a/src/libsystemd-bus/bus-kernel.c +++ b/src/libsystemd-bus/bus-kernel.c @@ -30,6 +30,7 @@ #include "bus-internal.h" #include "bus-message.h" #include "bus-kernel.h" +#include "bus-bloom.h" #define KDBUS_MSG_FOREACH_DATA(d, k) \ for ((d) = (k)->data; \ @@ -57,32 +58,116 @@ static void append_payload_vec(struct kdbus_msg_data **d, const void *p, size_t assert(p); assert(sz > 0); + *d = ALIGN8_PTR(*d); + (*d)->size = offsetof(struct kdbus_msg_data, vec) + sizeof(struct kdbus_vec); (*d)->type = KDBUS_MSG_PAYLOAD_VEC; (*d)->vec.address = (uint64_t) p; (*d)->vec.size = sz; - *d = (struct kdbus_msg_data*) ((uint8_t*) *d + ALIGN8((*d)->size)); + *d = (struct kdbus_msg_data*) ((uint8_t*) *d + (*d)->size); } static void append_destination(struct kdbus_msg_data **d, const char *s, size_t length) { assert(d); - assert(d); + assert(s); - (*d)->size = offsetof(struct kdbus_msg_data, data) + length + 1; + *d = ALIGN8_PTR(*d); + + (*d)->size = offsetof(struct kdbus_msg_data, str) + length + 1; (*d)->type = KDBUS_MSG_DST_NAME; - memcpy((*d)->data, s, length + 1); + memcpy((*d)->str, s, length + 1); - *d = (struct kdbus_msg_data*) ((uint8_t*) *d + ALIGN8((*d)->size)); + *d = (struct kdbus_msg_data*) ((uint8_t*) *d + (*d)->size); } -static int bus_message_setup_kmsg(sd_bus_message *m) { +static void* append_bloom(struct kdbus_msg_data **d, size_t length) { + void *r; + + assert(d); + + *d = ALIGN8_PTR(*d); + + (*d)->size = offsetof(struct kdbus_msg_data, data) + length; + (*d)->type = KDBUS_MSG_BLOOM; + r = (*d)->data; + + *d = (struct kdbus_msg_data*) ((uint8_t*) *d + (*d)->size); + + return r; +} + +static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) { + unsigned i; + int r; + + assert(m); + assert(bloom); + + memset(bloom, 0, BLOOM_SIZE); + + bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type)); + + if (m->interface) + bloom_add_pair(bloom, "interface", m->interface); + if (m->member) + bloom_add_pair(bloom, "member", m->member); + if (m->path) { + bloom_add_pair(bloom, "path", m->path); + bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/'); + } + + r = sd_bus_message_rewind(m, true); + if (r < 0) + return r; + + for (i = 0; i < 64; i++) { + char type; + const char *t; + char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")]; + char *e; + + r = sd_bus_message_peek_type(m, &type, NULL); + if (r < 0) + return r; + + if (type != SD_BUS_TYPE_STRING && + type != SD_BUS_TYPE_OBJECT_PATH && + type != SD_BUS_TYPE_SIGNATURE) + break; + + r = sd_bus_message_read_basic(m, type, &t); + if (r < 0) + return r; + + e = stpcpy(buf, "arg"); + if (i < 10) + *(e++) = '0' + i; + else { + *(e++) = '0' + (i / 10); + *(e++) = '0' + (i % 10); + } + + *e = 0; + bloom_add_pair(bloom, buf, t); + + strcpy(e, "-dot-prefix"); + bloom_add_prefixes(bloom, buf, t, '.'); + strcpy(e, "-slash-prefix"); + bloom_add_prefixes(bloom, buf, t, '/'); + } + + return 0; +} + +static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { struct kdbus_msg_data *d; bool well_known; uint64_t unique; size_t sz, dl; int r; + assert(b); assert(m); assert(m->sealed); @@ -100,25 +185,30 @@ static int bus_message_setup_kmsg(sd_bus_message *m) { sz = offsetof(struct kdbus_msg, data); - /* Add in fixed header, fields header, fields header padding and payload */ - sz += 4 * ALIGN8(offsetof(struct kdbus_msg_data, vec) + sizeof(struct kdbus_vec)); + /* Add in fixed header, fields header and payload */ + sz += 3 * ALIGN8(offsetof(struct kdbus_msg_data, vec) + sizeof(struct kdbus_vec)); + + /* Add space for bloom filter */ + sz += ALIGN8(offsetof(struct kdbus_msg_data, data) + BLOOM_SIZE); /* Add in well-known destination header */ if (well_known) { dl = strlen(m->destination); - sz += ALIGN8(offsetof(struct kdbus_msg, data) + dl + 1); + sz += ALIGN8(offsetof(struct kdbus_msg_data, str) + dl + 1); } - m->kdbus = malloc0(sz); + m->kdbus = aligned_alloc(8, sz); if (!m->kdbus) return -ENOMEM; + memset(m->kdbus, 0, sz); + m->kdbus->flags = ((m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) | ((m->header->flags & SD_BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0); m->kdbus->dst_id = well_known ? 0 : - m->destination ? unique : (uint64_t) -1; + m->destination ? unique : KDBUS_DST_ID_BROADCAST; m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS1; m->kdbus->cookie = m->header->serial; @@ -131,19 +221,25 @@ static int bus_message_setup_kmsg(sd_bus_message *m) { append_payload_vec(&d, m->header, sizeof(*m->header)); - if (m->fields) { - append_payload_vec(&d, m->fields, m->header->fields_size); + if (m->fields) + append_payload_vec(&d, m->fields, ALIGN8(m->header->fields_size)); + + if (m->body) + append_payload_vec(&d, m->body, m->header->body_size); - if (m->header->fields_size % 8 != 0) { - static const uint8_t padding[7] = {}; + if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) { + void *p; - append_payload_vec(&d, padding, 8 - (m->header->fields_size % 8)); + /* For now, let's add a mask all bloom filter */ + p = append_bloom(&d, BLOOM_SIZE); + r = bus_message_setup_bloom(m, p); + if (r < 0) { + free(m->kdbus); + m->kdbus = NULL; + return -r; } } - if (m->body) - append_payload_vec(&d, m->body, m->header->body_size); - m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus; assert(m->kdbus->size <= sz); @@ -153,19 +249,43 @@ static int bus_message_setup_kmsg(sd_bus_message *m) { } int bus_kernel_take_fd(sd_bus *b) { - struct kdbus_cmd_hello hello = {}; + struct kdbus_cmd_hello hello = { + .conn_flags = + KDBUS_CMD_HELLO_ACCEPT_FD| + KDBUS_CMD_HELLO_ACCEPT_MMAP| + KDBUS_CMD_HELLO_ATTACH_COMM| + KDBUS_CMD_HELLO_ATTACH_EXE| + KDBUS_CMD_HELLO_ATTACH_CMDLINE| + KDBUS_CMD_HELLO_ATTACH_CGROUP| + KDBUS_CMD_HELLO_ATTACH_CAPS| + KDBUS_CMD_HELLO_ATTACH_SECLABEL| + KDBUS_CMD_HELLO_ATTACH_AUDIT + }; int r; assert(b); + if (b->is_server) + return -EINVAL; + r = ioctl(b->input_fd, KDBUS_CMD_HELLO, &hello); if (r < 0) return -errno; + /* The higher 32bit of both flags fields are considered + * 'incompatible flags'. Refuse them all for now. */ + if (hello.bus_flags > 0xFFFFFFFFULL || + hello.conn_flags > 0xFFFFFFFFULL) + return -ENOTSUP; + + if (hello.bloom_size != BLOOM_SIZE) + return -ENOTSUP; + if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello.id) < 0) return -ENOMEM; b->is_kernel = true; + b->bus_client = true; r = bus_start_running(b); if (r < 0) @@ -180,6 +300,9 @@ int bus_kernel_connect(sd_bus *b) { assert(b->output_fd < 0); assert(b->kernel); + if (b->is_server) + return -EINVAL; + b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC); if (b->input_fd < 0) return -errno; @@ -196,7 +319,7 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) { assert(m); assert(bus->state == BUS_RUNNING); - r = bus_message_setup_kmsg(m); + r = bus_message_setup_kmsg(bus, m); if (r < 0) return r; @@ -204,7 +327,7 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) { if (r < 0) return errno == EAGAIN ? 0 : -errno; - return 0; + return 1; } static void close_kdbus_msg(struct kdbus_msg *k) { @@ -226,8 +349,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess _cleanup_free_ int *fds = NULL; struct bus_header *h = NULL; size_t total, n_bytes = 0, idx = 0; - struct kdbus_creds *creds = NULL; - uint64_t nsec = 0; + const char *destination = NULL, *seclabel = NULL; int r; assert(bus); @@ -267,10 +389,10 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess memcpy(fds + n_fds, d->fds, j); n_fds += j; - } else if (d->type == KDBUS_MSG_SRC_CREDS) - creds = &d->creds; - else if (d->type == KDBUS_MSG_TIMESTAMP) - nsec = d->ts_ns; + } else if (d->type == KDBUS_MSG_DST_NAME) + destination = d->str; + else if (d->type == KDBUS_MSG_SRC_SECLABEL) + seclabel = d->str; } if (!h) @@ -283,42 +405,53 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess if (n_bytes != total) return -EBADMSG; - r = bus_message_from_header(h, sizeof(struct bus_header), fds, n_fds, NULL, NULL, 0, &m); + r = bus_message_from_header(h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m); if (r < 0) return r; KDBUS_MSG_FOREACH_DATA(d, k) { size_t l; - if (d->type != KDBUS_MSG_PAYLOAD) - continue; - l = d->size - offsetof(struct kdbus_msg_data, data); - if (idx == sizeof(struct bus_header) && - l == BUS_MESSAGE_FIELDS_SIZE(m)) - m->fields = d->data; - else if (idx == sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) && - l == BUS_MESSAGE_BODY_SIZE(m)) - m->body = d->data; - else if (!(idx == 0 && l == sizeof(struct bus_header)) && - !(idx == sizeof(struct bus_header) + BUS_MESSAGE_FIELDS_SIZE(m))) { - sd_bus_message_unref(m); - return -EBADMSG; - } - idx += l; - } + if (d->type == KDBUS_MSG_PAYLOAD) { - if (creds) { - m->pid_starttime = creds->starttime / NSEC_PER_USEC; - m->uid = creds->uid; - m->gid = creds->gid; - m->pid = creds->pid; - m->tid = creds->tid; - m->uid_valid = m->gid_valid = true; - } + if (idx == sizeof(struct bus_header) && + l == ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m))) + m->fields = d->data; + else if (idx == sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) && + l == BUS_MESSAGE_BODY_SIZE(m)) + m->body = d->data; + else if (!(idx == 0 && l == sizeof(struct bus_header))) { + sd_bus_message_unref(m); + return -EBADMSG; + } - m->timestamp = nsec / NSEC_PER_USEC; + idx += l; + } else if (d->type == KDBUS_MSG_SRC_CREDS) { + m->pid_starttime = d->creds.starttime / NSEC_PER_USEC; + m->uid = d->creds.uid; + m->gid = d->creds.gid; + m->pid = d->creds.pid; + m->tid = d->creds.tid; + m->uid_valid = m->gid_valid = true; + } else if (d->type == KDBUS_MSG_TIMESTAMP) { + m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC; + m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC; + } else if (d->type == KDBUS_MSG_SRC_PID_COMM) + m->comm = d->str; + else if (d->type == KDBUS_MSG_SRC_TID_COMM) + m->tid_comm = d->str; + else if (d->type == KDBUS_MSG_SRC_EXE) + m->exe = d->str; + else if (d->type == KDBUS_MSG_SRC_CMDLINE) { + m->cmdline = d->str; + m->cmdline_length = l; + } else if (d->type == KDBUS_MSG_SRC_CGROUP) + m->cgroup = d->str; + else + log_debug("Got unknown field from kernel %llu", d->type); + } r = bus_message_parse_fields(m); if (r < 0) { @@ -326,6 +459,23 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess return r; } + if (k->src_id == KDBUS_SRC_ID_KERNEL) + m->sender = "org.freedesktop.DBus"; + else { + snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id); + m->sender = m->sender_buffer; + } + + if (!m->destination) { + if (destination) + m->destination = destination; + else if (k->dst_id != KDBUS_DST_ID_WELL_KNOWN_NAME && + k->dst_id != KDBUS_DST_ID_BROADCAST) { + snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id); + m->destination = m->destination_buffer; + } + } + /* We take possession of the kmsg struct now */ m->kdbus = k; m->free_kdbus = true; @@ -339,7 +489,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess int bus_kernel_read_message(sd_bus *bus, sd_bus_message **m) { struct kdbus_msg *k; - size_t sz = 128; + size_t sz = 1024; int r; assert(bus); @@ -348,17 +498,20 @@ int bus_kernel_read_message(sd_bus *bus, sd_bus_message **m) { for (;;) { void *q; - q = realloc(bus->rbuffer, sz); + q = aligned_alloc(8, sz); if (!q) return -errno; + free(bus->rbuffer); k = bus->rbuffer = q; k->size = sz; /* Let's tell valgrind that there's really no need to * initialize this fully. This should be removed again * when valgrind learned the kdbus ioctls natively. */ +#ifdef HAVE_VALGRIND_MEMCHECK_H VALGRIND_MAKE_MEM_DEFINED(k, sz); +#endif r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, bus->rbuffer); if (r >= 0) @@ -379,11 +532,11 @@ int bus_kernel_read_message(sd_bus *bus, sd_bus_message **m) { else close_kdbus_msg(k); - return r; + return r < 0 ? r : 1; } int bus_kernel_create(const char *name, char **s) { - struct kdbus_cmd_fname *fname; + struct kdbus_cmd_bus_make *make; size_t l; int fd; char *p; @@ -396,17 +549,20 @@ int bus_kernel_create(const char *name, char **s) { return -errno; l = strlen(name); - fname = alloca(offsetof(struct kdbus_cmd_fname, name) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1); - sprintf(fname->name, "%lu-%s", (unsigned long) getuid(), name); - fname->size = offsetof(struct kdbus_cmd_fname, name) + strlen(fname->name) + 1; - fname->kernel_flags = KDBUS_CMD_FNAME_ACCESS_WORLD; - fname->user_flags = 0; - - p = strjoin("/dev/kdbus/", fname->name, "/bus", NULL); + make = alloca0(offsetof(struct kdbus_cmd_bus_make, name) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1); + sprintf(make->name, "%lu-%s", (unsigned long) getuid(), name); + make->size = offsetof(struct kdbus_cmd_bus_make, name) + strlen(make->name) + 1; + make->flags = KDBUS_ACCESS_WORLD | KDBUS_POLICY_OPEN; + make->bus_flags = 0; + make->bloom_size = BLOOM_SIZE; + make->cgroup_id = 1; + assert_cc(BLOOM_SIZE % 8 == 0); + + p = strjoin("/dev/kdbus/", make->name, "/bus", NULL); if (!p) return -ENOMEM; - if (ioctl(fd, KDBUS_CMD_BUS_MAKE, fname) < 0) { + if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) { close_nointr_nofail(fd); free(p); return -errno;