X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-kernel.c;h=3fb5822a8f4d46bab0bd69cc89b8f4f23c7431db;hb=13019ef5ea284b03a74f25897a49fa5670974568;hp=5172b321139ba9bcf963b1ece2f3eebe48f22998;hpb=a2cef833cf46ee9ec35a4e4e4861944b25cd9a23;p=elogind.git diff --git a/src/libsystemd-bus/bus-kernel.c b/src/libsystemd-bus/bus-kernel.c index 5172b3211..3fb5822a8 100644 --- a/src/libsystemd-bus/bus-kernel.c +++ b/src/libsystemd-bus/bus-kernel.c @@ -25,6 +25,7 @@ #include #include +#include #include "util.h" @@ -35,11 +36,17 @@ #define KDBUS_ITEM_NEXT(item) \ (typeof(item))(((uint8_t *)item) + ALIGN8((item)->size)) + #define KDBUS_ITEM_FOREACH(item, head) \ for (item = (head)->items; \ (uint8_t *)(item) < (uint8_t *)(head) + (head)->size; \ item = KDBUS_ITEM_NEXT(item)) +#define KDBUS_ITEM_HEADER_SIZE offsetof(struct kdbus_item, data) +#define KDBUS_ITEM_SIZE(s) ALIGN8((s) + KDBUS_ITEM_HEADER_SIZE) + +#define KDBUS_POOL_SIZE (4*1024*1024) + static int parse_unique_name(const char *s, uint64_t *id) { int r; @@ -56,50 +63,63 @@ static int parse_unique_name(const char *s, uint64_t *id) { return 1; } -static void append_payload_vec(struct kdbus_msg_item **d, const void *p, size_t sz) { +static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) { assert(d); assert(p); assert(sz > 0); *d = ALIGN8_PTR(*d); - (*d)->size = offsetof(struct kdbus_msg_item, vec) + sizeof(struct kdbus_vec); + (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec); (*d)->type = KDBUS_MSG_PAYLOAD_VEC; - (*d)->vec.address = (uint64_t) p; + (*d)->vec.address = (intptr_t) p; (*d)->vec.size = sz; - *d = (struct kdbus_msg_item *) ((uint8_t*) *d + (*d)->size); + *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size); } -static void append_destination(struct kdbus_msg_item **d, const char *s, size_t length) { +static void append_destination(struct kdbus_item **d, const char *s, size_t length) { assert(d); assert(s); *d = ALIGN8_PTR(*d); - (*d)->size = offsetof(struct kdbus_msg_item, str) + length + 1; + (*d)->size = offsetof(struct kdbus_item, str) + length + 1; (*d)->type = KDBUS_MSG_DST_NAME; memcpy((*d)->str, s, length + 1); - *d = (struct kdbus_msg_item *) ((uint8_t*) *d + (*d)->size); + *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size); } -static void* append_bloom(struct kdbus_msg_item **d, size_t length) { +static void* append_bloom(struct kdbus_item **d, size_t length) { void *r; assert(d); *d = ALIGN8_PTR(*d); - (*d)->size = offsetof(struct kdbus_msg_item, data) + length; + (*d)->size = offsetof(struct kdbus_item, data) + length; (*d)->type = KDBUS_MSG_BLOOM; r = (*d)->data; - *d = (struct kdbus_msg_item *) ((uint8_t*) *d + (*d)->size); + *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size); return r; } +static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) { + assert(d); + assert(fds); + assert(n_fds > 0); + + *d = ALIGN8_PTR(*d); + (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds; + (*d)->type = KDBUS_MSG_FDS; + memcpy((*d)->fds, fds, sizeof(int) * n_fds); + + *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size); +} + static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) { unsigned i; int r; @@ -164,7 +184,7 @@ static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) { } static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { - struct kdbus_msg_item *d; + struct kdbus_item *d; bool well_known; uint64_t unique; size_t sz, dl; @@ -189,17 +209,21 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { sz = offsetof(struct kdbus_msg, items); /* Add in fixed header, fields header and payload */ - sz += 3 * ALIGN8(offsetof(struct kdbus_msg_item, vec) + sizeof(struct kdbus_vec)); + sz += 3 * ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)); /* Add space for bloom filter */ - sz += ALIGN8(offsetof(struct kdbus_msg_item, data) + BLOOM_SIZE); + sz += ALIGN8(offsetof(struct kdbus_item, data) + BLOOM_SIZE); /* Add in well-known destination header */ if (well_known) { dl = strlen(m->destination); - sz += ALIGN8(offsetof(struct kdbus_msg_item, str) + dl + 1); + sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1); } + /* Add space for unix fds */ + if (m->n_fds > 0) + sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds); + m->kdbus = memalign(8, sz); if (!m->kdbus) return -ENOMEM; @@ -233,7 +257,6 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) { void *p; - /* 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) { @@ -243,6 +266,9 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { } } + if (m->n_fds > 0) + append_fds(&d, m->fds, m->n_fds); + m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus; assert(m->kdbus->size <= sz); @@ -252,18 +278,12 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { } int bus_kernel_take_fd(sd_bus *b) { - 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 - }; + uint8_t h[ALIGN8(sizeof(struct kdbus_cmd_hello)) + + ALIGN8(KDBUS_ITEM_HEADER_SIZE) + + ALIGN8(sizeof(struct kdbus_vec))] = {}; + + struct kdbus_cmd_hello *hello = (struct kdbus_cmd_hello*) h; + int r; assert(b); @@ -271,24 +291,49 @@ int bus_kernel_take_fd(sd_bus *b) { if (b->is_server) return -EINVAL; - r = ioctl(b->input_fd, KDBUS_CMD_HELLO, &hello); + if (!b->kdbus_buffer) { + b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); + if (b->kdbus_buffer == MAP_FAILED) { + b->kdbus_buffer = NULL; + return -errno; + } + } + + hello->size = sizeof(h); + hello->conn_flags = + KDBUS_HELLO_ACCEPT_FD| + KDBUS_HELLO_ATTACH_COMM| + KDBUS_HELLO_ATTACH_EXE| + KDBUS_HELLO_ATTACH_CMDLINE| + KDBUS_HELLO_ATTACH_CGROUP| + KDBUS_HELLO_ATTACH_CAPS| + KDBUS_HELLO_ATTACH_SECLABEL| + KDBUS_HELLO_ATTACH_AUDIT; + + hello->items[0].type = KDBUS_HELLO_POOL; + hello->items[0].size = KDBUS_ITEM_HEADER_SIZE + sizeof(struct kdbus_vec); + hello->items[0].vec.address = (uint64_t) b->kdbus_buffer; + hello->items[0].vec.size = KDBUS_POOL_SIZE; + + 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) + if (hello->bus_flags > 0xFFFFFFFFULL || + hello->conn_flags > 0xFFFFFFFFULL) return -ENOTSUP; - if (hello.bloom_size != BLOOM_SIZE) + if (hello->bloom_size != BLOOM_SIZE) return -ENOTSUP; - if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello.id) < 0) + if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) return -ENOMEM; b->is_kernel = true; b->bus_client = true; + b->can_fds = true; r = bus_start_running(b); if (r < 0) @@ -333,21 +378,39 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) { return 1; } -static void close_kdbus_msg(struct kdbus_msg *k) { - struct kdbus_msg_item *d; +static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) { + struct kdbus_item *d; + + assert(bus); + assert(k); + + ioctl(bus->input_fd, KDBUS_CMD_MSG_RELEASE, k); KDBUS_ITEM_FOREACH(d, k) { - if (d->type != KDBUS_MSG_UNIX_FDS) + if (d->type != KDBUS_MSG_FDS) continue; - close_many(d->fds, (d->size - offsetof(struct kdbus_msg_item, fds)) / sizeof(int)); + close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int)); } } +static bool range_contains(size_t astart, size_t asize, size_t bstart, size_t bsize, void *a, void **b) { + + if (bstart < astart) + return false; + + if (bstart + bsize > astart + asize) + return false; + + *b = (uint8_t*) a + (bstart - astart); + + return true; +} + static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_message **ret) { sd_bus_message *m = NULL; - struct kdbus_msg_item *d; + struct kdbus_item *d; unsigned n_payload = 0, n_fds = 0; _cleanup_free_ int *fds = NULL; struct bus_header *h = NULL; @@ -365,21 +428,21 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess KDBUS_ITEM_FOREACH(d, k) { size_t l; - l = d->size - offsetof(struct kdbus_msg_item, data); + l = d->size - offsetof(struct kdbus_item, data); - if (d->type == KDBUS_MSG_PAYLOAD) { + if (d->type == KDBUS_MSG_PAYLOAD_VEC) { if (!h) { - if (l < sizeof(struct bus_header)) + if (d->vec.size < sizeof(struct bus_header)) return -EBADMSG; - h = (struct bus_header*) d->data; + h = (struct bus_header*) d->vec.address; } n_payload++; - n_bytes += l; + n_bytes += d->vec.size; - } else if (d->type == KDBUS_MSG_UNIX_FDS) { + } else if (d->type == KDBUS_MSG_FDS) { int *f; unsigned j; @@ -389,7 +452,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess return -ENOMEM; fds = f; - memcpy(fds + n_fds, d->fds, j); + memcpy(fds + n_fds, d->fds, sizeof(int) * j); n_fds += j; } else if (d->type == KDBUS_MSG_DST_NAME) @@ -408,6 +471,9 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess if (n_bytes != total) return -EBADMSG; + if (n_payload > 2) + return -EBADMSG; + r = bus_message_from_header(h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m); if (r < 0) return r; @@ -415,22 +481,15 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess KDBUS_ITEM_FOREACH(d, k) { size_t l; - l = d->size - offsetof(struct kdbus_msg_item, data); + l = d->size - offsetof(struct kdbus_item, data); - if (d->type == KDBUS_MSG_PAYLOAD) { + if (d->type == KDBUS_MSG_PAYLOAD_VEC) { - 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; - } + range_contains(idx, d->vec.size, ALIGN8(sizeof(struct bus_header)), BUS_MESSAGE_FIELDS_SIZE(m), (void*) d->vec.address, &m->fields); + range_contains(idx, d->vec.size, ALIGN8(sizeof(struct bus_header)) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)), BUS_MESSAGE_BODY_SIZE(m), (void*) d->vec.address, &m->body); + + idx += d->vec.size; - idx += l; } else if (d->type == KDBUS_MSG_SRC_CREDS) { m->pid_starttime = d->creds.starttime / NSEC_PER_USEC; m->uid = d->creds.uid; @@ -452,10 +511,23 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess m->cmdline_length = l; } else if (d->type == KDBUS_MSG_SRC_CGROUP) m->cgroup = d->str; - else + else if (d->type == KDBUS_MSG_SRC_AUDIT) + m->audit = &d->audit; + else if (d->type == KDBUS_MSG_SRC_CAPS) { + m->capability = d->data; + m->capability_size = l; + } else if (d->type != KDBUS_MSG_FDS && + d->type != KDBUS_MSG_DST_NAME && + d->type != KDBUS_MSG_SRC_SECLABEL) log_debug("Got unknown field from kernel %llu", d->type); } + if ((BUS_MESSAGE_FIELDS_SIZE(m) > 0 && !m->fields) || + (BUS_MESSAGE_BODY_SIZE(m) > 0 && !m->body)) { + sd_bus_message_unref(m); + return -EBADMSG; + } + r = bus_message_parse_fields(m); if (r < 0) { sd_bus_message_unref(m); @@ -481,7 +553,8 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess /* We take possession of the kmsg struct now */ m->kdbus = k; - m->free_kdbus = true; + m->bus = sd_bus_ref(bus); + m->release_kdbus = true; m->free_fds = true; fds = NULL; @@ -492,55 +565,38 @@ 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 = 1024; int r; assert(bus); assert(m); - for (;;) { - void *q; - - q = memalign(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) - break; - + r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &k); + if (r < 0) { if (errno == EAGAIN) return 0; - if (errno != ENOBUFS) - return -errno; - - sz *= 2; + return -errno; } + +/* /\* 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 = bus_kernel_make_message(bus, k, m); - if (r > 0) - bus->rbuffer = NULL; - else - close_kdbus_msg(k); + if (r <= 0) + close_kdbus_msg(bus, k); return r < 0 ? r : 1; } int bus_kernel_create(const char *name, char **s) { struct kdbus_cmd_bus_make *make; - struct kdbus_cmd_make_item *n, *cg; + struct kdbus_item *n, *cg; size_t l; int fd; char *p; @@ -554,21 +610,21 @@ int bus_kernel_create(const char *name, char **s) { l = strlen(name); make = alloca0(offsetof(struct kdbus_cmd_bus_make, items) + - sizeof(struct kdbus_cmd_make_item) + sizeof(uint64_t) + - sizeof(struct kdbus_cmd_make_item) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1); + KDBUS_ITEM_HEADER_SIZE + sizeof(uint64_t) + + KDBUS_ITEM_HEADER_SIZE + DECIMAL_STR_MAX(uid_t) + 1 + l + 1); cg = make->items; - cg->type = KDBUS_CMD_MAKE_CGROUP; + cg->type = KDBUS_MAKE_CGROUP; cg->data64[0] = 1; - cg->size = sizeof(struct kdbus_cmd_make_item) + sizeof(uint64_t); + cg->size = KDBUS_ITEM_HEADER_SIZE + sizeof(uint64_t); n = KDBUS_ITEM_NEXT(cg); - n->type = KDBUS_CMD_MAKE_NAME; + n->type = KDBUS_MAKE_NAME; sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name); - n->size = sizeof(struct kdbus_cmd_make_item) + strlen(n->str) + 1; + n->size = KDBUS_ITEM_HEADER_SIZE + strlen(n->str) + 1; make->size = offsetof(struct kdbus_cmd_bus_make, items) + cg->size + n->size; - make->flags = KDBUS_ACCESS_WORLD | KDBUS_POLICY_OPEN; + make->flags = KDBUS_MAKE_ACCESS_WORLD | KDBUS_MAKE_POLICY_OPEN; make->bus_flags = 0; make->bloom_size = BLOOM_SIZE; assert_cc(BLOOM_SIZE % 8 == 0);