chiark / gitweb /
bus: add new sd_bus_creds object to encapsulate process credentials
[elogind.git] / src / libsystemd-bus / bus-kernel.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2013 Lennart Poettering
7
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.
12
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.
17
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/>.
20 ***/
21
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
24 #endif
25
26 #include <fcntl.h>
27 #include <malloc.h>
28 #include <sys/mman.h>
29
30 #include "util.h"
31
32 #include "bus-internal.h"
33 #include "bus-message.h"
34 #include "bus-kernel.h"
35 #include "bus-bloom.h"
36
37 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
38         int r;
39
40         assert(s);
41         assert(id);
42
43         if (!startswith(s, ":1."))
44                 return 0;
45
46         r = safe_atou64(s + 3, id);
47         if (r < 0)
48                 return r;
49
50         return 1;
51 }
52
53 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
54         assert(d);
55         assert(sz > 0);
56
57         *d = ALIGN8_PTR(*d);
58
59         /* Note that p can be NULL, which encodes a region full of
60          * zeroes, which is useful to optimize certain padding
61          * conditions */
62
63         (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
64         (*d)->type = KDBUS_MSG_PAYLOAD_VEC;
65         (*d)->vec.address = PTR_TO_UINT64(p);
66         (*d)->vec.size = sz;
67
68         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
69 }
70
71 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
72         assert(d);
73         assert(memfd >= 0);
74         assert(sz > 0);
75
76         *d = ALIGN8_PTR(*d);
77         (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
78         (*d)->type = KDBUS_MSG_PAYLOAD_MEMFD;
79         (*d)->memfd.fd = memfd;
80         (*d)->memfd.size = sz;
81
82         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
83 }
84
85 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
86         assert(d);
87         assert(s);
88
89         *d = ALIGN8_PTR(*d);
90
91         (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
92         (*d)->type = KDBUS_MSG_DST_NAME;
93         memcpy((*d)->str, s, length + 1);
94
95         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
96 }
97
98 static void* append_bloom(struct kdbus_item **d, size_t length) {
99         void *r;
100
101         assert(d);
102
103         *d = ALIGN8_PTR(*d);
104
105         (*d)->size = offsetof(struct kdbus_item, data) + length;
106         (*d)->type = KDBUS_MSG_BLOOM;
107         r = (*d)->data;
108
109         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
110
111         return r;
112 }
113
114 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
115         assert(d);
116         assert(fds);
117         assert(n_fds > 0);
118
119         *d = ALIGN8_PTR(*d);
120         (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
121         (*d)->type = KDBUS_MSG_FDS;
122         memcpy((*d)->fds, fds, sizeof(int) * n_fds);
123
124         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
125 }
126
127 static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) {
128         unsigned i;
129         int r;
130
131         assert(m);
132         assert(bloom);
133
134         memset(bloom, 0, BLOOM_SIZE);
135
136         bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type));
137
138         if (m->interface)
139                 bloom_add_pair(bloom, "interface", m->interface);
140         if (m->member)
141                 bloom_add_pair(bloom, "member", m->member);
142         if (m->path) {
143                 bloom_add_pair(bloom, "path", m->path);
144                 bloom_add_pair(bloom, "path-slash-prefix", m->path);
145                 bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/');
146         }
147
148         r = sd_bus_message_rewind(m, true);
149         if (r < 0)
150                 return r;
151
152         for (i = 0; i < 64; i++) {
153                 char type;
154                 const char *t;
155                 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
156                 char *e;
157
158                 r = sd_bus_message_peek_type(m, &type, NULL);
159                 if (r < 0)
160                         return r;
161
162                 if (type != SD_BUS_TYPE_STRING &&
163                     type != SD_BUS_TYPE_OBJECT_PATH &&
164                     type != SD_BUS_TYPE_SIGNATURE)
165                         break;
166
167                 r = sd_bus_message_read_basic(m, type, &t);
168                 if (r < 0)
169                         return r;
170
171                 e = stpcpy(buf, "arg");
172                 if (i < 10)
173                         *(e++) = '0' + i;
174                 else {
175                         *(e++) = '0' + (i / 10);
176                         *(e++) = '0' + (i % 10);
177                 }
178
179                 *e = 0;
180                 bloom_add_pair(bloom, buf, t);
181
182                 strcpy(e, "-dot-prefix");
183                 bloom_add_prefixes(bloom, buf, t, '.');
184                 strcpy(e, "-slash-prefix");
185                 bloom_add_prefixes(bloom, buf, t, '/');
186         }
187
188         return 0;
189 }
190
191 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
192         struct bus_body_part *part;
193         struct kdbus_item *d;
194         bool well_known;
195         uint64_t unique;
196         size_t sz, dl;
197         unsigned i;
198         int r;
199
200         assert(b);
201         assert(m);
202         assert(m->sealed);
203
204         if (m->kdbus)
205                 return 0;
206
207         if (m->destination) {
208                 r = bus_kernel_parse_unique_name(m->destination, &unique);
209                 if (r < 0)
210                         return r;
211
212                 well_known = r == 0;
213         } else
214                 well_known = false;
215
216         sz = offsetof(struct kdbus_msg, items);
217
218         assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
219                   ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
220
221         /* Add in fixed header, fields header and payload */
222         sz += (1 + m->n_body_parts) *
223                 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
224
225         /* Add space for bloom filter */
226         sz += ALIGN8(offsetof(struct kdbus_item, data) + BLOOM_SIZE);
227
228         /* Add in well-known destination header */
229         if (well_known) {
230                 dl = strlen(m->destination);
231                 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
232         }
233
234         /* Add space for unix fds */
235         if (m->n_fds > 0)
236                 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
237
238         m->kdbus = memalign(8, sz);
239         if (!m->kdbus) {
240                 r = -ENOMEM;
241                 goto fail;
242         }
243
244         m->free_kdbus = true;
245         memset(m->kdbus, 0, sz);
246
247         m->kdbus->flags =
248                 ((m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
249                 ((m->header->flags & SD_BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
250         m->kdbus->dst_id =
251                 well_known ? 0 :
252                 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
253         m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS1;
254         m->kdbus->cookie = m->header->serial;
255
256         m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
257
258         d = m->kdbus->items;
259
260         if (well_known)
261                 append_destination(&d, m->destination, dl);
262
263         append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
264
265         MESSAGE_FOREACH_PART(part, i, m) {
266                 if (part->is_zero) {
267                         /* If this is padding then simply send a
268                          * vector with a NULL data pointer which the
269                          * kernel will just pass through. This is the
270                          * most efficient way to encode zeroes */
271
272                         append_payload_vec(&d, NULL, part->size);
273                         continue;
274                 }
275
276                 if (part->memfd >= 0 && part->sealed && m->destination) {
277                         /* Try to send a memfd, if the part is
278                          * sealed and this is not a broadcast. Since we can only  */
279
280                         append_payload_memfd(&d, part->memfd, part->size);
281                         continue;
282                 }
283
284                 /* Otherwise let's send a vector to the actual data,
285                  * for that we need to map it first. */
286                 r = bus_body_part_map(part);
287                 if (r < 0)
288                         goto fail;
289
290                 append_payload_vec(&d, part->data, part->size);
291         }
292
293         if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
294                 void *p;
295
296                 p = append_bloom(&d, BLOOM_SIZE);
297                 r = bus_message_setup_bloom(m, p);
298                 if (r < 0)
299                         goto fail;
300         }
301
302         if (m->n_fds > 0)
303                 append_fds(&d, m->fds, m->n_fds);
304
305         m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
306         assert(m->kdbus->size <= sz);
307
308         return 0;
309
310 fail:
311         m->poisoned = true;
312         return r;
313 }
314
315 int bus_kernel_take_fd(sd_bus *b) {
316         struct kdbus_cmd_hello hello;
317         int r;
318
319         assert(b);
320
321         if (b->is_server)
322                 return -EINVAL;
323
324         b->use_memfd = 1;
325
326         zero(hello);
327         hello.size = sizeof(hello);
328         hello.conn_flags = b->hello_flags;
329         hello.pool_size = KDBUS_POOL_SIZE;
330
331         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, &hello);
332         if (r < 0)
333                 return -errno;
334
335         if (!b->kdbus_buffer) {
336                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
337                 if (b->kdbus_buffer == MAP_FAILED) {
338                         b->kdbus_buffer = NULL;
339                         return -errno;
340                 }
341         }
342
343         /* The higher 32bit of both flags fields are considered
344          * 'incompatible flags'. Refuse them all for now. */
345         if (hello.bus_flags > 0xFFFFFFFFULL ||
346             hello.conn_flags > 0xFFFFFFFFULL)
347                 return -ENOTSUP;
348
349         if (hello.bloom_size != BLOOM_SIZE)
350                 return -ENOTSUP;
351
352         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello.id) < 0)
353                 return -ENOMEM;
354
355         b->is_kernel = true;
356         b->bus_client = true;
357         b->can_fds = !!(hello.conn_flags & KDBUS_HELLO_ACCEPT_FD);
358
359         r = bus_start_running(b);
360         if (r < 0)
361                 return r;
362
363         return 1;
364 }
365
366 int bus_kernel_connect(sd_bus *b) {
367         assert(b);
368         assert(b->input_fd < 0);
369         assert(b->output_fd < 0);
370         assert(b->kernel);
371
372         if (b->is_server)
373                 return -EINVAL;
374
375         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
376         if (b->input_fd < 0)
377                 return -errno;
378
379         b->output_fd = b->input_fd;
380
381         return bus_kernel_take_fd(b);
382 }
383
384 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
385         int r;
386
387         assert(bus);
388         assert(m);
389         assert(bus->state == BUS_RUNNING);
390
391         r = bus_message_setup_kmsg(bus, m);
392         if (r < 0)
393                 return r;
394
395         r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
396         if (r < 0)
397                 return errno == EAGAIN ? 0 : -errno;
398
399         return 1;
400 }
401
402 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
403         uint64_t off;
404         struct kdbus_item *d;
405
406         assert(bus);
407         assert(k);
408
409         off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
410         ioctl(bus->input_fd, KDBUS_CMD_MSG_RELEASE, &off);
411
412         KDBUS_ITEM_FOREACH(d, k) {
413
414                 if (d->type == KDBUS_MSG_FDS)
415                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
416                 else if (d->type == KDBUS_MSG_PAYLOAD_MEMFD)
417                         close_nointr_nofail(d->memfd.fd);
418         }
419 }
420
421 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_message **ret) {
422         sd_bus_message *m = NULL;
423         struct kdbus_item *d;
424         unsigned n_fds = 0;
425         _cleanup_free_ int *fds = NULL;
426         struct bus_header *h = NULL;
427         size_t total, n_bytes = 0, idx = 0;
428         const char *destination = NULL, *seclabel = NULL;
429         int r;
430
431         assert(bus);
432         assert(k);
433         assert(ret);
434
435         if (k->payload_type != KDBUS_PAYLOAD_DBUS1)
436                 return 0;
437
438         KDBUS_ITEM_FOREACH(d, k) {
439                 size_t l;
440
441                 l = d->size - offsetof(struct kdbus_item, data);
442
443                 if (d->type == KDBUS_MSG_PAYLOAD_OFF) {
444
445                         if (!h) {
446                                 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
447
448                                 if (!bus_header_is_complete(h, d->vec.size))
449                                         return -EBADMSG;
450                         }
451
452                         n_bytes += d->vec.size;
453
454                 } else if (d->type == KDBUS_MSG_PAYLOAD_MEMFD) {
455
456                         if (!h)
457                                 return -EBADMSG;
458
459                         n_bytes += d->memfd.size;
460
461                 } else if (d->type == KDBUS_MSG_FDS) {
462                         int *f;
463                         unsigned j;
464
465                         j = l / sizeof(int);
466                         f = realloc(fds, sizeof(int) * (n_fds + j));
467                         if (!f)
468                                 return -ENOMEM;
469
470                         fds = f;
471                         memcpy(fds + n_fds, d->fds, sizeof(int) * j);
472                         n_fds += j;
473
474                 } else if (d->type == KDBUS_MSG_SRC_SECLABEL)
475                         seclabel = d->str;
476         }
477
478         if (!h)
479                 return -EBADMSG;
480
481         r = bus_header_message_size(h, &total);
482         if (r < 0)
483                 return r;
484
485         if (n_bytes != total)
486                 return -EBADMSG;
487
488         r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
489         if (r < 0)
490                 return r;
491
492         KDBUS_ITEM_FOREACH(d, k) {
493                 size_t l;
494
495                 l = d->size - offsetof(struct kdbus_item, data);
496
497                 if (d->type == KDBUS_MSG_PAYLOAD_OFF) {
498                         size_t begin_body;
499
500                         begin_body = BUS_MESSAGE_BODY_BEGIN(m);
501
502                         if (idx + d->vec.size > begin_body) {
503                                 struct bus_body_part *part;
504
505                                 /* Contains body material */
506
507                                 part = message_append_part(m);
508                                 if (!part) {
509                                         r = -ENOMEM;
510                                         goto fail;
511                                 }
512
513                                 /* A -1 offset is NUL padding. */
514                                 part->is_zero = d->vec.offset == ~0ULL;
515
516                                 if (idx >= begin_body) {
517                                         if (!part->is_zero)
518                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
519                                         part->size = d->vec.size;
520                                 } else {
521                                         if (!part->is_zero)
522                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
523                                         part->size = d->vec.size - (begin_body - idx);
524                                 }
525
526                                 part->sealed = true;
527                         }
528
529                         idx += d->vec.size;
530                 } else if (d->type == KDBUS_MSG_PAYLOAD_MEMFD) {
531                         struct bus_body_part *part;
532
533                         if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
534                                 r = -EBADMSG;
535                                 goto fail;
536                         }
537
538                         part = message_append_part(m);
539                         if (!part) {
540                                 r = -ENOMEM;
541                                 goto fail;
542                         }
543
544                         part->memfd = d->memfd.fd;
545                         part->size = d->memfd.size;
546                         part->sealed = true;
547
548                         idx += d->memfd.size;
549
550                 } else if (d->type == KDBUS_MSG_SRC_CREDS) {
551                         m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
552                         m->creds.uid = d->creds.uid;
553                         m->creds.gid = d->creds.gid;
554                         m->creds.pid = d->creds.pid;
555                         m->creds.tid = d->creds.tid;
556                         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;
557
558                 } else if (d->type == KDBUS_MSG_TIMESTAMP) {
559                         m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
560                         m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
561
562                 } else if (d->type == KDBUS_MSG_SRC_PID_COMM) {
563                         m->creds.comm = d->str;
564                         m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
565
566                 } else if (d->type == KDBUS_MSG_SRC_TID_COMM) {
567                         m->creds.tid_comm = d->str;
568                         m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
569
570                 } else if (d->type == KDBUS_MSG_SRC_EXE) {
571                         m->creds.exe = d->str;
572                         m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
573
574                 } else if (d->type == KDBUS_MSG_SRC_CMDLINE) {
575                         m->creds.cmdline = d->str;
576                         m->creds.cmdline_length = l;
577                         m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
578
579                 } else if (d->type == KDBUS_MSG_SRC_CGROUP) {
580                         m->creds.cgroup = d->str;
581                         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;
582
583                 } else if (d->type == KDBUS_MSG_SRC_AUDIT) {
584                         m->creds.audit_session_id = d->audit.sessionid;
585                         m->creds.audit_login_uid = d->audit.loginuid;
586                         m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
587
588                 } else if (d->type == KDBUS_MSG_SRC_CAPS) {
589                         m->creds.capability = d->data;
590                         m->creds.capability_size = l;
591                         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;
592
593                 } else if (d->type == KDBUS_MSG_DST_NAME)
594                         destination = d->str;
595                 else if (d->type != KDBUS_MSG_FDS &&
596                            d->type != KDBUS_MSG_SRC_SECLABEL)
597                         log_debug("Got unknown field from kernel %llu", d->type);
598         }
599
600         r = bus_message_parse_fields(m);
601         if (r < 0)
602                 goto fail;
603
604         if (k->src_id == KDBUS_SRC_ID_KERNEL)
605                 m->sender = "org.freedesktop.DBus";
606         else {
607                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
608                 m->sender = m->sender_buffer;
609         }
610
611         if (!m->destination) {
612                 if (destination)
613                         m->destination = destination;
614                 else if (k->dst_id != KDBUS_DST_ID_WELL_KNOWN_NAME &&
615                          k->dst_id != KDBUS_DST_ID_BROADCAST) {
616                         snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
617                         m->destination = m->destination_buffer;
618                 }
619         }
620
621         /* We take possession of the kmsg struct now */
622         m->kdbus = k;
623         m->release_kdbus = true;
624         m->free_fds = true;
625
626         fds = NULL;
627
628         *ret = m;
629         return 1;
630
631 fail:
632         if (m) {
633                 struct bus_body_part *part;
634                 unsigned i;
635
636                 /* Make sure the memfds are not freed twice */
637                 MESSAGE_FOREACH_PART(part, i, m)
638                         if (part->memfd >= 0)
639                                 part->memfd = -1;
640
641                 sd_bus_message_unref(m);
642         }
643
644         return r;
645 }
646
647 int bus_kernel_read_message(sd_bus *bus, sd_bus_message **m) {
648         uint64_t off;
649         struct kdbus_msg *k;
650         int r;
651
652         assert(bus);
653         assert(m);
654
655         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
656         if (r < 0) {
657                 if (errno == EAGAIN)
658                         return 0;
659
660                 return -errno;
661         }
662         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
663
664         r = bus_kernel_make_message(bus, k, m);
665         if (r <= 0)
666                 close_kdbus_msg(bus, k);
667
668         return r < 0 ? r : 1;
669 }
670
671 int bus_kernel_create(const char *name, char **s) {
672         struct kdbus_cmd_bus_make *make;
673         struct kdbus_item *n;
674         size_t l;
675         int fd;
676         char *p;
677
678         assert(name);
679         assert(s);
680
681         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
682         if (fd < 0)
683                 return -errno;
684
685         l = strlen(name);
686         make = alloca0(offsetof(struct kdbus_cmd_bus_make, items) +
687                        KDBUS_ITEM_HEADER_SIZE + sizeof(uint64_t) +
688                        KDBUS_ITEM_HEADER_SIZE + DECIMAL_STR_MAX(uid_t) + 1 + l + 1);
689
690         n = make->items;
691         n->type = KDBUS_MAKE_NAME;
692         sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
693         n->size = KDBUS_ITEM_HEADER_SIZE + strlen(n->str) + 1;
694
695         make->size = offsetof(struct kdbus_cmd_bus_make, items) + n->size;
696         make->flags = KDBUS_MAKE_POLICY_OPEN;
697         make->bus_flags = 0;
698         make->bloom_size = BLOOM_SIZE;
699         assert_cc(BLOOM_SIZE % 8 == 0);
700
701         p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
702         if (!p)
703                 return -ENOMEM;
704
705         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
706                 close_nointr_nofail(fd);
707                 free(p);
708                 return -errno;
709         }
710
711         if (s)
712                 *s = p;
713
714         return fd;
715 }
716
717 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *size) {
718         struct memfd_cache *c;
719         int fd;
720
721         assert(address);
722         assert(size);
723
724         if (!bus || !bus->is_kernel)
725                 return -ENOTSUP;
726
727         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
728
729         if (bus->n_memfd_cache <= 0) {
730                 int r;
731
732                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
733
734                 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
735                 if (r < 0)
736                         return -errno;
737
738                 *address = NULL;
739                 *size = 0;
740                 return fd;
741         }
742
743         c = &bus->memfd_cache[--bus->n_memfd_cache];
744
745         assert(c->fd >= 0);
746         assert(c->size == 0 || c->address);
747
748         *address = c->address;
749         *size = c->size;
750         fd = c->fd;
751
752         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
753
754         return fd;
755 }
756
757 static void close_and_munmap(int fd, void *address, size_t size) {
758         if (size > 0)
759                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
760
761         close_nointr_nofail(fd);
762 }
763
764 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t size) {
765         struct memfd_cache *c;
766         uint64_t max_sz = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
767
768         assert(fd >= 0);
769         assert(size == 0 || address);
770
771         if (!bus || !bus->is_kernel) {
772                 close_and_munmap(fd, address, size);
773                 return;
774         }
775
776         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
777
778         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
779                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
780
781                 close_and_munmap(fd, address, size);
782                 return;
783         }
784
785         c = &bus->memfd_cache[bus->n_memfd_cache++];
786         c->fd = fd;
787         c->address = address;
788
789         /* If overly long, let's return a bit to the OS */
790         if (size > max_sz) {
791                 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_sz) >= 0);
792                 assert_se(munmap((uint8_t*) address + max_sz, PAGE_ALIGN(size - max_sz)) >= 0);
793                 c->size = max_sz;
794         } else
795                 c->size = size;
796
797         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
798 }
799
800 void bus_kernel_flush_memfd(sd_bus *b) {
801         unsigned i;
802
803         assert(b);
804
805         for (i = 0; i < b->n_memfd_cache; i++)
806                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].size);
807 }