]> git.proxmox.com Git - mirror_qemu.git/blob - subprojects/libvhost-user/libvhost-user.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'pull-riscv-to-apply-20231012-1' of https://github.com/alistair23/qemu...
[mirror_qemu.git] / subprojects / libvhost-user / libvhost-user.c
1 /*
2 * Vhost User library
3 *
4 * Copyright IBM, Corp. 2007
5 * Copyright (c) 2016 Red Hat, Inc.
6 *
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Marc-André Lureau <mlureau@redhat.com>
10 * Victor Kaplansky <victork@redhat.com>
11 *
12 * This work is licensed under the terms of the GNU GPL, version 2 or
13 * later. See the COPYING file in the top-level directory.
14 */
15
16 #ifndef _GNU_SOURCE
17 #define _GNU_SOURCE
18 #endif
19
20 /* this code avoids GLib dependency */
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <unistd.h>
24 #include <stdarg.h>
25 #include <errno.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <inttypes.h>
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <sys/eventfd.h>
32 #include <sys/mman.h>
33 #include <endian.h>
34
35 /* Necessary to provide VIRTIO_F_VERSION_1 on system
36 * with older linux headers. Must appear before
37 * <linux/vhost.h> below.
38 */
39 #include "standard-headers/linux/virtio_config.h"
40
41 #if defined(__linux__)
42 #include <sys/syscall.h>
43 #include <fcntl.h>
44 #include <sys/ioctl.h>
45 #include <linux/vhost.h>
46
47 #ifdef __NR_userfaultfd
48 #include <linux/userfaultfd.h>
49 #endif
50
51 #endif
52
53 #include "include/atomic.h"
54
55 #include "libvhost-user.h"
56
57 /* usually provided by GLib */
58 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
59 #if !defined(__clang__) && (__GNUC__ == 4 && __GNUC_MINOR__ == 4)
60 #define G_GNUC_PRINTF(format_idx, arg_idx) \
61 __attribute__((__format__(gnu_printf, format_idx, arg_idx)))
62 #else
63 #define G_GNUC_PRINTF(format_idx, arg_idx) \
64 __attribute__((__format__(__printf__, format_idx, arg_idx)))
65 #endif
66 #else /* !__GNUC__ */
67 #define G_GNUC_PRINTF(format_idx, arg_idx)
68 #endif /* !__GNUC__ */
69 #ifndef MIN
70 #define MIN(x, y) ({ \
71 __typeof__(x) _min1 = (x); \
72 __typeof__(y) _min2 = (y); \
73 (void) (&_min1 == &_min2); \
74 _min1 < _min2 ? _min1 : _min2; })
75 #endif
76
77 /* Round number down to multiple */
78 #define ALIGN_DOWN(n, m) ((n) / (m) * (m))
79
80 /* Round number up to multiple */
81 #define ALIGN_UP(n, m) ALIGN_DOWN((n) + (m) - 1, (m))
82
83 #ifndef unlikely
84 #define unlikely(x) __builtin_expect(!!(x), 0)
85 #endif
86
87 /* Align each region to cache line size in inflight buffer */
88 #define INFLIGHT_ALIGNMENT 64
89
90 /* The version of inflight buffer */
91 #define INFLIGHT_VERSION 1
92
93 /* The version of the protocol we support */
94 #define VHOST_USER_VERSION 1
95 #define LIBVHOST_USER_DEBUG 0
96
97 #define DPRINT(...) \
98 do { \
99 if (LIBVHOST_USER_DEBUG) { \
100 fprintf(stderr, __VA_ARGS__); \
101 } \
102 } while (0)
103
104 static inline
105 bool has_feature(uint64_t features, unsigned int fbit)
106 {
107 assert(fbit < 64);
108 return !!(features & (1ULL << fbit));
109 }
110
111 static inline
112 bool vu_has_feature(VuDev *dev,
113 unsigned int fbit)
114 {
115 return has_feature(dev->features, fbit);
116 }
117
118 static inline bool vu_has_protocol_feature(VuDev *dev, unsigned int fbit)
119 {
120 return has_feature(dev->protocol_features, fbit);
121 }
122
123 const char *
124 vu_request_to_string(unsigned int req)
125 {
126 #define REQ(req) [req] = #req
127 static const char *vu_request_str[] = {
128 REQ(VHOST_USER_NONE),
129 REQ(VHOST_USER_GET_FEATURES),
130 REQ(VHOST_USER_SET_FEATURES),
131 REQ(VHOST_USER_SET_OWNER),
132 REQ(VHOST_USER_RESET_OWNER),
133 REQ(VHOST_USER_SET_MEM_TABLE),
134 REQ(VHOST_USER_SET_LOG_BASE),
135 REQ(VHOST_USER_SET_LOG_FD),
136 REQ(VHOST_USER_SET_VRING_NUM),
137 REQ(VHOST_USER_SET_VRING_ADDR),
138 REQ(VHOST_USER_SET_VRING_BASE),
139 REQ(VHOST_USER_GET_VRING_BASE),
140 REQ(VHOST_USER_SET_VRING_KICK),
141 REQ(VHOST_USER_SET_VRING_CALL),
142 REQ(VHOST_USER_SET_VRING_ERR),
143 REQ(VHOST_USER_GET_PROTOCOL_FEATURES),
144 REQ(VHOST_USER_SET_PROTOCOL_FEATURES),
145 REQ(VHOST_USER_GET_QUEUE_NUM),
146 REQ(VHOST_USER_SET_VRING_ENABLE),
147 REQ(VHOST_USER_SEND_RARP),
148 REQ(VHOST_USER_NET_SET_MTU),
149 REQ(VHOST_USER_SET_BACKEND_REQ_FD),
150 REQ(VHOST_USER_IOTLB_MSG),
151 REQ(VHOST_USER_SET_VRING_ENDIAN),
152 REQ(VHOST_USER_GET_CONFIG),
153 REQ(VHOST_USER_SET_CONFIG),
154 REQ(VHOST_USER_POSTCOPY_ADVISE),
155 REQ(VHOST_USER_POSTCOPY_LISTEN),
156 REQ(VHOST_USER_POSTCOPY_END),
157 REQ(VHOST_USER_GET_INFLIGHT_FD),
158 REQ(VHOST_USER_SET_INFLIGHT_FD),
159 REQ(VHOST_USER_GPU_SET_SOCKET),
160 REQ(VHOST_USER_VRING_KICK),
161 REQ(VHOST_USER_GET_MAX_MEM_SLOTS),
162 REQ(VHOST_USER_ADD_MEM_REG),
163 REQ(VHOST_USER_REM_MEM_REG),
164 REQ(VHOST_USER_GET_SHARED_OBJECT),
165 REQ(VHOST_USER_MAX),
166 };
167 #undef REQ
168
169 if (req < VHOST_USER_MAX) {
170 return vu_request_str[req];
171 } else {
172 return "unknown";
173 }
174 }
175
176 static void G_GNUC_PRINTF(2, 3)
177 vu_panic(VuDev *dev, const char *msg, ...)
178 {
179 char *buf = NULL;
180 va_list ap;
181
182 va_start(ap, msg);
183 if (vasprintf(&buf, msg, ap) < 0) {
184 buf = NULL;
185 }
186 va_end(ap);
187
188 dev->broken = true;
189 dev->panic(dev, buf);
190 free(buf);
191
192 /*
193 * FIXME:
194 * find a way to call virtio_error, or perhaps close the connection?
195 */
196 }
197
198 /* Translate guest physical address to our virtual address. */
199 void *
200 vu_gpa_to_va(VuDev *dev, uint64_t *plen, uint64_t guest_addr)
201 {
202 unsigned int i;
203
204 if (*plen == 0) {
205 return NULL;
206 }
207
208 /* Find matching memory region. */
209 for (i = 0; i < dev->nregions; i++) {
210 VuDevRegion *r = &dev->regions[i];
211
212 if ((guest_addr >= r->gpa) && (guest_addr < (r->gpa + r->size))) {
213 if ((guest_addr + *plen) > (r->gpa + r->size)) {
214 *plen = r->gpa + r->size - guest_addr;
215 }
216 return (void *)(uintptr_t)
217 guest_addr - r->gpa + r->mmap_addr + r->mmap_offset;
218 }
219 }
220
221 return NULL;
222 }
223
224 /* Translate qemu virtual address to our virtual address. */
225 static void *
226 qva_to_va(VuDev *dev, uint64_t qemu_addr)
227 {
228 unsigned int i;
229
230 /* Find matching memory region. */
231 for (i = 0; i < dev->nregions; i++) {
232 VuDevRegion *r = &dev->regions[i];
233
234 if ((qemu_addr >= r->qva) && (qemu_addr < (r->qva + r->size))) {
235 return (void *)(uintptr_t)
236 qemu_addr - r->qva + r->mmap_addr + r->mmap_offset;
237 }
238 }
239
240 return NULL;
241 }
242
243 static void
244 vmsg_close_fds(VhostUserMsg *vmsg)
245 {
246 int i;
247
248 for (i = 0; i < vmsg->fd_num; i++) {
249 close(vmsg->fds[i]);
250 }
251 }
252
253 /* Set reply payload.u64 and clear request flags and fd_num */
254 static void vmsg_set_reply_u64(VhostUserMsg *vmsg, uint64_t val)
255 {
256 vmsg->flags = 0; /* defaults will be set by vu_send_reply() */
257 vmsg->size = sizeof(vmsg->payload.u64);
258 vmsg->payload.u64 = val;
259 vmsg->fd_num = 0;
260 }
261
262 /* A test to see if we have userfault available */
263 static bool
264 have_userfault(void)
265 {
266 #if defined(__linux__) && defined(__NR_userfaultfd) &&\
267 defined(UFFD_FEATURE_MISSING_SHMEM) &&\
268 defined(UFFD_FEATURE_MISSING_HUGETLBFS)
269 /* Now test the kernel we're running on really has the features */
270 int ufd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
271 struct uffdio_api api_struct;
272 if (ufd < 0) {
273 return false;
274 }
275
276 api_struct.api = UFFD_API;
277 api_struct.features = UFFD_FEATURE_MISSING_SHMEM |
278 UFFD_FEATURE_MISSING_HUGETLBFS;
279 if (ioctl(ufd, UFFDIO_API, &api_struct)) {
280 close(ufd);
281 return false;
282 }
283 close(ufd);
284 return true;
285
286 #else
287 return false;
288 #endif
289 }
290
291 static bool
292 vu_message_read_default(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
293 {
294 char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = {};
295 struct iovec iov = {
296 .iov_base = (char *)vmsg,
297 .iov_len = VHOST_USER_HDR_SIZE,
298 };
299 struct msghdr msg = {
300 .msg_iov = &iov,
301 .msg_iovlen = 1,
302 .msg_control = control,
303 .msg_controllen = sizeof(control),
304 };
305 size_t fd_size;
306 struct cmsghdr *cmsg;
307 int rc;
308
309 do {
310 rc = recvmsg(conn_fd, &msg, 0);
311 } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
312
313 if (rc < 0) {
314 vu_panic(dev, "Error while recvmsg: %s", strerror(errno));
315 return false;
316 }
317
318 vmsg->fd_num = 0;
319 for (cmsg = CMSG_FIRSTHDR(&msg);
320 cmsg != NULL;
321 cmsg = CMSG_NXTHDR(&msg, cmsg))
322 {
323 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
324 fd_size = cmsg->cmsg_len - CMSG_LEN(0);
325 vmsg->fd_num = fd_size / sizeof(int);
326 assert(fd_size < VHOST_MEMORY_BASELINE_NREGIONS);
327 memcpy(vmsg->fds, CMSG_DATA(cmsg), fd_size);
328 break;
329 }
330 }
331
332 if (vmsg->size > sizeof(vmsg->payload)) {
333 vu_panic(dev,
334 "Error: too big message request: %d, size: vmsg->size: %u, "
335 "while sizeof(vmsg->payload) = %zu\n",
336 vmsg->request, vmsg->size, sizeof(vmsg->payload));
337 goto fail;
338 }
339
340 if (vmsg->size) {
341 do {
342 rc = read(conn_fd, &vmsg->payload, vmsg->size);
343 } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
344
345 if (rc <= 0) {
346 vu_panic(dev, "Error while reading: %s", strerror(errno));
347 goto fail;
348 }
349
350 assert((uint32_t)rc == vmsg->size);
351 }
352
353 return true;
354
355 fail:
356 vmsg_close_fds(vmsg);
357
358 return false;
359 }
360
361 static bool
362 vu_message_write(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
363 {
364 int rc;
365 uint8_t *p = (uint8_t *)vmsg;
366 char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = {};
367 struct iovec iov = {
368 .iov_base = (char *)vmsg,
369 .iov_len = VHOST_USER_HDR_SIZE,
370 };
371 struct msghdr msg = {
372 .msg_iov = &iov,
373 .msg_iovlen = 1,
374 .msg_control = control,
375 };
376 struct cmsghdr *cmsg;
377
378 memset(control, 0, sizeof(control));
379 assert(vmsg->fd_num <= VHOST_MEMORY_BASELINE_NREGIONS);
380 if (vmsg->fd_num > 0) {
381 size_t fdsize = vmsg->fd_num * sizeof(int);
382 msg.msg_controllen = CMSG_SPACE(fdsize);
383 cmsg = CMSG_FIRSTHDR(&msg);
384 cmsg->cmsg_len = CMSG_LEN(fdsize);
385 cmsg->cmsg_level = SOL_SOCKET;
386 cmsg->cmsg_type = SCM_RIGHTS;
387 memcpy(CMSG_DATA(cmsg), vmsg->fds, fdsize);
388 } else {
389 msg.msg_controllen = 0;
390 }
391
392 do {
393 rc = sendmsg(conn_fd, &msg, 0);
394 } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
395
396 if (vmsg->size) {
397 do {
398 if (vmsg->data) {
399 rc = write(conn_fd, vmsg->data, vmsg->size);
400 } else {
401 rc = write(conn_fd, p + VHOST_USER_HDR_SIZE, vmsg->size);
402 }
403 } while (rc < 0 && (errno == EINTR || errno == EAGAIN));
404 }
405
406 if (rc <= 0) {
407 vu_panic(dev, "Error while writing: %s", strerror(errno));
408 return false;
409 }
410
411 return true;
412 }
413
414 static bool
415 vu_send_reply(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
416 {
417 /* Set the version in the flags when sending the reply */
418 vmsg->flags &= ~VHOST_USER_VERSION_MASK;
419 vmsg->flags |= VHOST_USER_VERSION;
420 vmsg->flags |= VHOST_USER_REPLY_MASK;
421
422 return vu_message_write(dev, conn_fd, vmsg);
423 }
424
425 /*
426 * Processes a reply on the backend channel.
427 * Entered with backend_mutex held and releases it before exit.
428 * Returns true on success.
429 */
430 static bool
431 vu_process_message_reply(VuDev *dev, const VhostUserMsg *vmsg)
432 {
433 VhostUserMsg msg_reply;
434 bool result = false;
435
436 if ((vmsg->flags & VHOST_USER_NEED_REPLY_MASK) == 0) {
437 result = true;
438 goto out;
439 }
440
441 if (!vu_message_read_default(dev, dev->backend_fd, &msg_reply)) {
442 goto out;
443 }
444
445 if (msg_reply.request != vmsg->request) {
446 DPRINT("Received unexpected msg type. Expected %d received %d",
447 vmsg->request, msg_reply.request);
448 goto out;
449 }
450
451 result = msg_reply.payload.u64 == 0;
452
453 out:
454 pthread_mutex_unlock(&dev->backend_mutex);
455 return result;
456 }
457
458 /* Kick the log_call_fd if required. */
459 static void
460 vu_log_kick(VuDev *dev)
461 {
462 if (dev->log_call_fd != -1) {
463 DPRINT("Kicking the QEMU's log...\n");
464 if (eventfd_write(dev->log_call_fd, 1) < 0) {
465 vu_panic(dev, "Error writing eventfd: %s", strerror(errno));
466 }
467 }
468 }
469
470 static void
471 vu_log_page(uint8_t *log_table, uint64_t page)
472 {
473 DPRINT("Logged dirty guest page: %"PRId64"\n", page);
474 qatomic_or(&log_table[page / 8], 1 << (page % 8));
475 }
476
477 static void
478 vu_log_write(VuDev *dev, uint64_t address, uint64_t length)
479 {
480 uint64_t page;
481
482 if (!(dev->features & (1ULL << VHOST_F_LOG_ALL)) ||
483 !dev->log_table || !length) {
484 return;
485 }
486
487 assert(dev->log_size > ((address + length - 1) / VHOST_LOG_PAGE / 8));
488
489 page = address / VHOST_LOG_PAGE;
490 while (page * VHOST_LOG_PAGE < address + length) {
491 vu_log_page(dev->log_table, page);
492 page += 1;
493 }
494
495 vu_log_kick(dev);
496 }
497
498 static void
499 vu_kick_cb(VuDev *dev, int condition, void *data)
500 {
501 int index = (intptr_t)data;
502 VuVirtq *vq = &dev->vq[index];
503 int sock = vq->kick_fd;
504 eventfd_t kick_data;
505 ssize_t rc;
506
507 rc = eventfd_read(sock, &kick_data);
508 if (rc == -1) {
509 vu_panic(dev, "kick eventfd_read(): %s", strerror(errno));
510 dev->remove_watch(dev, dev->vq[index].kick_fd);
511 } else {
512 DPRINT("Got kick_data: %016"PRIx64" handler:%p idx:%d\n",
513 kick_data, vq->handler, index);
514 if (vq->handler) {
515 vq->handler(dev, index);
516 }
517 }
518 }
519
520 static bool
521 vu_get_features_exec(VuDev *dev, VhostUserMsg *vmsg)
522 {
523 vmsg->payload.u64 =
524 /*
525 * The following VIRTIO feature bits are supported by our virtqueue
526 * implementation:
527 */
528 1ULL << VIRTIO_F_NOTIFY_ON_EMPTY |
529 1ULL << VIRTIO_RING_F_INDIRECT_DESC |
530 1ULL << VIRTIO_RING_F_EVENT_IDX |
531 1ULL << VIRTIO_F_VERSION_1 |
532
533 /* vhost-user feature bits */
534 1ULL << VHOST_F_LOG_ALL |
535 1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
536
537 if (dev->iface->get_features) {
538 vmsg->payload.u64 |= dev->iface->get_features(dev);
539 }
540
541 vmsg->size = sizeof(vmsg->payload.u64);
542 vmsg->fd_num = 0;
543
544 DPRINT("Sending back to guest u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
545
546 return true;
547 }
548
549 static void
550 vu_set_enable_all_rings(VuDev *dev, bool enabled)
551 {
552 uint16_t i;
553
554 for (i = 0; i < dev->max_queues; i++) {
555 dev->vq[i].enable = enabled;
556 }
557 }
558
559 static bool
560 vu_set_features_exec(VuDev *dev, VhostUserMsg *vmsg)
561 {
562 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
563
564 dev->features = vmsg->payload.u64;
565 if (!vu_has_feature(dev, VIRTIO_F_VERSION_1)) {
566 /*
567 * We only support devices conforming to VIRTIO 1.0 or
568 * later
569 */
570 vu_panic(dev, "virtio legacy devices aren't supported by libvhost-user");
571 return false;
572 }
573
574 if (!(dev->features & VHOST_USER_F_PROTOCOL_FEATURES)) {
575 vu_set_enable_all_rings(dev, true);
576 }
577
578 if (dev->iface->set_features) {
579 dev->iface->set_features(dev, dev->features);
580 }
581
582 return false;
583 }
584
585 static bool
586 vu_set_owner_exec(VuDev *dev, VhostUserMsg *vmsg)
587 {
588 return false;
589 }
590
591 static void
592 vu_close_log(VuDev *dev)
593 {
594 if (dev->log_table) {
595 if (munmap(dev->log_table, dev->log_size) != 0) {
596 perror("close log munmap() error");
597 }
598
599 dev->log_table = NULL;
600 }
601 if (dev->log_call_fd != -1) {
602 close(dev->log_call_fd);
603 dev->log_call_fd = -1;
604 }
605 }
606
607 static bool
608 vu_reset_device_exec(VuDev *dev, VhostUserMsg *vmsg)
609 {
610 vu_set_enable_all_rings(dev, false);
611
612 return false;
613 }
614
615 static bool
616 map_ring(VuDev *dev, VuVirtq *vq)
617 {
618 vq->vring.desc = qva_to_va(dev, vq->vra.desc_user_addr);
619 vq->vring.used = qva_to_va(dev, vq->vra.used_user_addr);
620 vq->vring.avail = qva_to_va(dev, vq->vra.avail_user_addr);
621
622 DPRINT("Setting virtq addresses:\n");
623 DPRINT(" vring_desc at %p\n", vq->vring.desc);
624 DPRINT(" vring_used at %p\n", vq->vring.used);
625 DPRINT(" vring_avail at %p\n", vq->vring.avail);
626
627 return !(vq->vring.desc && vq->vring.used && vq->vring.avail);
628 }
629
630 static bool
631 generate_faults(VuDev *dev) {
632 unsigned int i;
633 for (i = 0; i < dev->nregions; i++) {
634 #ifdef UFFDIO_REGISTER
635 VuDevRegion *dev_region = &dev->regions[i];
636 int ret;
637 struct uffdio_register reg_struct;
638
639 /*
640 * We should already have an open ufd. Mark each memory
641 * range as ufd.
642 * Discard any mapping we have here; note I can't use MADV_REMOVE
643 * or fallocate to make the hole since I don't want to lose
644 * data that's already arrived in the shared process.
645 * TODO: How to do hugepage
646 */
647 ret = madvise((void *)(uintptr_t)dev_region->mmap_addr,
648 dev_region->size + dev_region->mmap_offset,
649 MADV_DONTNEED);
650 if (ret) {
651 fprintf(stderr,
652 "%s: Failed to madvise(DONTNEED) region %d: %s\n",
653 __func__, i, strerror(errno));
654 }
655 /*
656 * Turn off transparent hugepages so we dont get lose wakeups
657 * in neighbouring pages.
658 * TODO: Turn this backon later.
659 */
660 ret = madvise((void *)(uintptr_t)dev_region->mmap_addr,
661 dev_region->size + dev_region->mmap_offset,
662 MADV_NOHUGEPAGE);
663 if (ret) {
664 /*
665 * Note: This can happen legally on kernels that are configured
666 * without madvise'able hugepages
667 */
668 fprintf(stderr,
669 "%s: Failed to madvise(NOHUGEPAGE) region %d: %s\n",
670 __func__, i, strerror(errno));
671 }
672
673 reg_struct.range.start = (uintptr_t)dev_region->mmap_addr;
674 reg_struct.range.len = dev_region->size + dev_region->mmap_offset;
675 reg_struct.mode = UFFDIO_REGISTER_MODE_MISSING;
676
677 if (ioctl(dev->postcopy_ufd, UFFDIO_REGISTER, &reg_struct)) {
678 vu_panic(dev, "%s: Failed to userfault region %d "
679 "@%" PRIx64 " + size:%" PRIx64 " offset: %" PRIx64
680 ": (ufd=%d)%s\n",
681 __func__, i,
682 dev_region->mmap_addr,
683 dev_region->size, dev_region->mmap_offset,
684 dev->postcopy_ufd, strerror(errno));
685 return false;
686 }
687 if (!(reg_struct.ioctls & ((__u64)1 << _UFFDIO_COPY))) {
688 vu_panic(dev, "%s Region (%d) doesn't support COPY",
689 __func__, i);
690 return false;
691 }
692 DPRINT("%s: region %d: Registered userfault for %"
693 PRIx64 " + %" PRIx64 "\n", __func__, i,
694 (uint64_t)reg_struct.range.start,
695 (uint64_t)reg_struct.range.len);
696 /* Now it's registered we can let the client at it */
697 if (mprotect((void *)(uintptr_t)dev_region->mmap_addr,
698 dev_region->size + dev_region->mmap_offset,
699 PROT_READ | PROT_WRITE)) {
700 vu_panic(dev, "failed to mprotect region %d for postcopy (%s)",
701 i, strerror(errno));
702 return false;
703 }
704 /* TODO: Stash 'zero' support flags somewhere */
705 #endif
706 }
707
708 return true;
709 }
710
711 static bool
712 vu_add_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
713 int i;
714 bool track_ramblocks = dev->postcopy_listening;
715 VhostUserMemoryRegion m = vmsg->payload.memreg.region, *msg_region = &m;
716 VuDevRegion *dev_region = &dev->regions[dev->nregions];
717 void *mmap_addr;
718
719 if (vmsg->fd_num != 1) {
720 vmsg_close_fds(vmsg);
721 vu_panic(dev, "VHOST_USER_ADD_MEM_REG received %d fds - only 1 fd "
722 "should be sent for this message type", vmsg->fd_num);
723 return false;
724 }
725
726 if (vmsg->size < VHOST_USER_MEM_REG_SIZE) {
727 close(vmsg->fds[0]);
728 vu_panic(dev, "VHOST_USER_ADD_MEM_REG requires a message size of at "
729 "least %zu bytes and only %d bytes were received",
730 VHOST_USER_MEM_REG_SIZE, vmsg->size);
731 return false;
732 }
733
734 if (dev->nregions == VHOST_USER_MAX_RAM_SLOTS) {
735 close(vmsg->fds[0]);
736 vu_panic(dev, "failing attempt to hot add memory via "
737 "VHOST_USER_ADD_MEM_REG message because the backend has "
738 "no free ram slots available");
739 return false;
740 }
741
742 /*
743 * If we are in postcopy mode and we receive a u64 payload with a 0 value
744 * we know all the postcopy client bases have been received, and we
745 * should start generating faults.
746 */
747 if (track_ramblocks &&
748 vmsg->size == sizeof(vmsg->payload.u64) &&
749 vmsg->payload.u64 == 0) {
750 (void)generate_faults(dev);
751 return false;
752 }
753
754 DPRINT("Adding region: %u\n", dev->nregions);
755 DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n",
756 msg_region->guest_phys_addr);
757 DPRINT(" memory_size: 0x%016"PRIx64"\n",
758 msg_region->memory_size);
759 DPRINT(" userspace_addr 0x%016"PRIx64"\n",
760 msg_region->userspace_addr);
761 DPRINT(" mmap_offset 0x%016"PRIx64"\n",
762 msg_region->mmap_offset);
763
764 dev_region->gpa = msg_region->guest_phys_addr;
765 dev_region->size = msg_region->memory_size;
766 dev_region->qva = msg_region->userspace_addr;
767 dev_region->mmap_offset = msg_region->mmap_offset;
768
769 /*
770 * We don't use offset argument of mmap() since the
771 * mapped address has to be page aligned, and we use huge
772 * pages.
773 */
774 if (track_ramblocks) {
775 /*
776 * In postcopy we're using PROT_NONE here to catch anyone
777 * accessing it before we userfault.
778 */
779 mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset,
780 PROT_NONE, MAP_SHARED | MAP_NORESERVE,
781 vmsg->fds[0], 0);
782 } else {
783 mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset,
784 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE,
785 vmsg->fds[0], 0);
786 }
787
788 if (mmap_addr == MAP_FAILED) {
789 vu_panic(dev, "region mmap error: %s", strerror(errno));
790 } else {
791 dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr;
792 DPRINT(" mmap_addr: 0x%016"PRIx64"\n",
793 dev_region->mmap_addr);
794 }
795
796 close(vmsg->fds[0]);
797
798 if (track_ramblocks) {
799 /*
800 * Return the address to QEMU so that it can translate the ufd
801 * fault addresses back.
802 */
803 msg_region->userspace_addr = (uintptr_t)(mmap_addr +
804 dev_region->mmap_offset);
805
806 /* Send the message back to qemu with the addresses filled in. */
807 vmsg->fd_num = 0;
808 DPRINT("Successfully added new region in postcopy\n");
809 dev->nregions++;
810 return true;
811 } else {
812 for (i = 0; i < dev->max_queues; i++) {
813 if (dev->vq[i].vring.desc) {
814 if (map_ring(dev, &dev->vq[i])) {
815 vu_panic(dev, "remapping queue %d for new memory region",
816 i);
817 }
818 }
819 }
820
821 DPRINT("Successfully added new region\n");
822 dev->nregions++;
823 return false;
824 }
825 }
826
827 static inline bool reg_equal(VuDevRegion *vudev_reg,
828 VhostUserMemoryRegion *msg_reg)
829 {
830 if (vudev_reg->gpa == msg_reg->guest_phys_addr &&
831 vudev_reg->qva == msg_reg->userspace_addr &&
832 vudev_reg->size == msg_reg->memory_size) {
833 return true;
834 }
835
836 return false;
837 }
838
839 static bool
840 vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
841 VhostUserMemoryRegion m = vmsg->payload.memreg.region, *msg_region = &m;
842 unsigned int i;
843 bool found = false;
844
845 if (vmsg->fd_num > 1) {
846 vmsg_close_fds(vmsg);
847 vu_panic(dev, "VHOST_USER_REM_MEM_REG received %d fds - at most 1 fd "
848 "should be sent for this message type", vmsg->fd_num);
849 return false;
850 }
851
852 if (vmsg->size < VHOST_USER_MEM_REG_SIZE) {
853 vmsg_close_fds(vmsg);
854 vu_panic(dev, "VHOST_USER_REM_MEM_REG requires a message size of at "
855 "least %zu bytes and only %d bytes were received",
856 VHOST_USER_MEM_REG_SIZE, vmsg->size);
857 return false;
858 }
859
860 DPRINT("Removing region:\n");
861 DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n",
862 msg_region->guest_phys_addr);
863 DPRINT(" memory_size: 0x%016"PRIx64"\n",
864 msg_region->memory_size);
865 DPRINT(" userspace_addr 0x%016"PRIx64"\n",
866 msg_region->userspace_addr);
867 DPRINT(" mmap_offset 0x%016"PRIx64"\n",
868 msg_region->mmap_offset);
869
870 for (i = 0; i < dev->nregions; i++) {
871 if (reg_equal(&dev->regions[i], msg_region)) {
872 VuDevRegion *r = &dev->regions[i];
873 void *m = (void *) (uintptr_t) r->mmap_addr;
874
875 if (m) {
876 munmap(m, r->size + r->mmap_offset);
877 }
878
879 /*
880 * Shift all affected entries by 1 to close the hole at index i and
881 * zero out the last entry.
882 */
883 memmove(dev->regions + i, dev->regions + i + 1,
884 sizeof(VuDevRegion) * (dev->nregions - i - 1));
885 memset(dev->regions + dev->nregions - 1, 0, sizeof(VuDevRegion));
886 DPRINT("Successfully removed a region\n");
887 dev->nregions--;
888 i--;
889
890 found = true;
891
892 /* Continue the search for eventual duplicates. */
893 }
894 }
895
896 if (!found) {
897 vu_panic(dev, "Specified region not found\n");
898 }
899
900 vmsg_close_fds(vmsg);
901
902 return false;
903 }
904
905 static bool
906 vu_get_shared_object(VuDev *dev, VhostUserMsg *vmsg)
907 {
908 int fd_num = 0;
909 int dmabuf_fd = -1;
910 if (dev->iface->get_shared_object) {
911 dmabuf_fd = dev->iface->get_shared_object(
912 dev, &vmsg->payload.object.uuid[0]);
913 }
914 if (dmabuf_fd != -1) {
915 DPRINT("dmabuf_fd found for requested UUID\n");
916 vmsg->fds[fd_num++] = dmabuf_fd;
917 }
918 vmsg->fd_num = fd_num;
919
920 return true;
921 }
922
923 static bool
924 vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg)
925 {
926 unsigned int i;
927 VhostUserMemory m = vmsg->payload.memory, *memory = &m;
928 dev->nregions = memory->nregions;
929
930 DPRINT("Nregions: %u\n", memory->nregions);
931 for (i = 0; i < dev->nregions; i++) {
932 void *mmap_addr;
933 VhostUserMemoryRegion *msg_region = &memory->regions[i];
934 VuDevRegion *dev_region = &dev->regions[i];
935
936 DPRINT("Region %d\n", i);
937 DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n",
938 msg_region->guest_phys_addr);
939 DPRINT(" memory_size: 0x%016"PRIx64"\n",
940 msg_region->memory_size);
941 DPRINT(" userspace_addr 0x%016"PRIx64"\n",
942 msg_region->userspace_addr);
943 DPRINT(" mmap_offset 0x%016"PRIx64"\n",
944 msg_region->mmap_offset);
945
946 dev_region->gpa = msg_region->guest_phys_addr;
947 dev_region->size = msg_region->memory_size;
948 dev_region->qva = msg_region->userspace_addr;
949 dev_region->mmap_offset = msg_region->mmap_offset;
950
951 /* We don't use offset argument of mmap() since the
952 * mapped address has to be page aligned, and we use huge
953 * pages.
954 * In postcopy we're using PROT_NONE here to catch anyone
955 * accessing it before we userfault
956 */
957 mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset,
958 PROT_NONE, MAP_SHARED | MAP_NORESERVE,
959 vmsg->fds[i], 0);
960
961 if (mmap_addr == MAP_FAILED) {
962 vu_panic(dev, "region mmap error: %s", strerror(errno));
963 } else {
964 dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr;
965 DPRINT(" mmap_addr: 0x%016"PRIx64"\n",
966 dev_region->mmap_addr);
967 }
968
969 /* Return the address to QEMU so that it can translate the ufd
970 * fault addresses back.
971 */
972 msg_region->userspace_addr = (uintptr_t)(mmap_addr +
973 dev_region->mmap_offset);
974 close(vmsg->fds[i]);
975 }
976
977 /* Send the message back to qemu with the addresses filled in */
978 vmsg->fd_num = 0;
979 if (!vu_send_reply(dev, dev->sock, vmsg)) {
980 vu_panic(dev, "failed to respond to set-mem-table for postcopy");
981 return false;
982 }
983
984 /* Wait for QEMU to confirm that it's registered the handler for the
985 * faults.
986 */
987 if (!dev->read_msg(dev, dev->sock, vmsg) ||
988 vmsg->size != sizeof(vmsg->payload.u64) ||
989 vmsg->payload.u64 != 0) {
990 vu_panic(dev, "failed to receive valid ack for postcopy set-mem-table");
991 return false;
992 }
993
994 /* OK, now we can go and register the memory and generate faults */
995 (void)generate_faults(dev);
996
997 return false;
998 }
999
1000 static bool
1001 vu_set_mem_table_exec(VuDev *dev, VhostUserMsg *vmsg)
1002 {
1003 unsigned int i;
1004 VhostUserMemory m = vmsg->payload.memory, *memory = &m;
1005
1006 for (i = 0; i < dev->nregions; i++) {
1007 VuDevRegion *r = &dev->regions[i];
1008 void *m = (void *) (uintptr_t) r->mmap_addr;
1009
1010 if (m) {
1011 munmap(m, r->size + r->mmap_offset);
1012 }
1013 }
1014 dev->nregions = memory->nregions;
1015
1016 if (dev->postcopy_listening) {
1017 return vu_set_mem_table_exec_postcopy(dev, vmsg);
1018 }
1019
1020 DPRINT("Nregions: %u\n", memory->nregions);
1021 for (i = 0; i < dev->nregions; i++) {
1022 void *mmap_addr;
1023 VhostUserMemoryRegion *msg_region = &memory->regions[i];
1024 VuDevRegion *dev_region = &dev->regions[i];
1025
1026 DPRINT("Region %d\n", i);
1027 DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n",
1028 msg_region->guest_phys_addr);
1029 DPRINT(" memory_size: 0x%016"PRIx64"\n",
1030 msg_region->memory_size);
1031 DPRINT(" userspace_addr 0x%016"PRIx64"\n",
1032 msg_region->userspace_addr);
1033 DPRINT(" mmap_offset 0x%016"PRIx64"\n",
1034 msg_region->mmap_offset);
1035
1036 dev_region->gpa = msg_region->guest_phys_addr;
1037 dev_region->size = msg_region->memory_size;
1038 dev_region->qva = msg_region->userspace_addr;
1039 dev_region->mmap_offset = msg_region->mmap_offset;
1040
1041 /* We don't use offset argument of mmap() since the
1042 * mapped address has to be page aligned, and we use huge
1043 * pages. */
1044 mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset,
1045 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE,
1046 vmsg->fds[i], 0);
1047
1048 if (mmap_addr == MAP_FAILED) {
1049 vu_panic(dev, "region mmap error: %s", strerror(errno));
1050 } else {
1051 dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr;
1052 DPRINT(" mmap_addr: 0x%016"PRIx64"\n",
1053 dev_region->mmap_addr);
1054 }
1055
1056 close(vmsg->fds[i]);
1057 }
1058
1059 for (i = 0; i < dev->max_queues; i++) {
1060 if (dev->vq[i].vring.desc) {
1061 if (map_ring(dev, &dev->vq[i])) {
1062 vu_panic(dev, "remapping queue %d during setmemtable", i);
1063 }
1064 }
1065 }
1066
1067 return false;
1068 }
1069
1070 static bool
1071 vu_set_log_base_exec(VuDev *dev, VhostUserMsg *vmsg)
1072 {
1073 int fd;
1074 uint64_t log_mmap_size, log_mmap_offset;
1075 void *rc;
1076
1077 if (vmsg->fd_num != 1 ||
1078 vmsg->size != sizeof(vmsg->payload.log)) {
1079 vu_panic(dev, "Invalid log_base message");
1080 return true;
1081 }
1082
1083 fd = vmsg->fds[0];
1084 log_mmap_offset = vmsg->payload.log.mmap_offset;
1085 log_mmap_size = vmsg->payload.log.mmap_size;
1086 DPRINT("Log mmap_offset: %"PRId64"\n", log_mmap_offset);
1087 DPRINT("Log mmap_size: %"PRId64"\n", log_mmap_size);
1088
1089 rc = mmap(0, log_mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1090 log_mmap_offset);
1091 close(fd);
1092 if (rc == MAP_FAILED) {
1093 perror("log mmap error");
1094 }
1095
1096 if (dev->log_table) {
1097 munmap(dev->log_table, dev->log_size);
1098 }
1099 dev->log_table = rc;
1100 dev->log_size = log_mmap_size;
1101
1102 vmsg->size = sizeof(vmsg->payload.u64);
1103 vmsg->fd_num = 0;
1104
1105 return true;
1106 }
1107
1108 static bool
1109 vu_set_log_fd_exec(VuDev *dev, VhostUserMsg *vmsg)
1110 {
1111 if (vmsg->fd_num != 1) {
1112 vu_panic(dev, "Invalid log_fd message");
1113 return false;
1114 }
1115
1116 if (dev->log_call_fd != -1) {
1117 close(dev->log_call_fd);
1118 }
1119 dev->log_call_fd = vmsg->fds[0];
1120 DPRINT("Got log_call_fd: %d\n", vmsg->fds[0]);
1121
1122 return false;
1123 }
1124
1125 static bool
1126 vu_set_vring_num_exec(VuDev *dev, VhostUserMsg *vmsg)
1127 {
1128 unsigned int index = vmsg->payload.state.index;
1129 unsigned int num = vmsg->payload.state.num;
1130
1131 DPRINT("State.index: %u\n", index);
1132 DPRINT("State.num: %u\n", num);
1133 dev->vq[index].vring.num = num;
1134
1135 return false;
1136 }
1137
1138 static bool
1139 vu_set_vring_addr_exec(VuDev *dev, VhostUserMsg *vmsg)
1140 {
1141 struct vhost_vring_addr addr = vmsg->payload.addr, *vra = &addr;
1142 unsigned int index = vra->index;
1143 VuVirtq *vq = &dev->vq[index];
1144
1145 DPRINT("vhost_vring_addr:\n");
1146 DPRINT(" index: %d\n", vra->index);
1147 DPRINT(" flags: %d\n", vra->flags);
1148 DPRINT(" desc_user_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->desc_user_addr);
1149 DPRINT(" used_user_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->used_user_addr);
1150 DPRINT(" avail_user_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->avail_user_addr);
1151 DPRINT(" log_guest_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->log_guest_addr);
1152
1153 vq->vra = *vra;
1154 vq->vring.flags = vra->flags;
1155 vq->vring.log_guest_addr = vra->log_guest_addr;
1156
1157
1158 if (map_ring(dev, vq)) {
1159 vu_panic(dev, "Invalid vring_addr message");
1160 return false;
1161 }
1162
1163 vq->used_idx = le16toh(vq->vring.used->idx);
1164
1165 if (vq->last_avail_idx != vq->used_idx) {
1166 bool resume = dev->iface->queue_is_processed_in_order &&
1167 dev->iface->queue_is_processed_in_order(dev, index);
1168
1169 DPRINT("Last avail index != used index: %u != %u%s\n",
1170 vq->last_avail_idx, vq->used_idx,
1171 resume ? ", resuming" : "");
1172
1173 if (resume) {
1174 vq->shadow_avail_idx = vq->last_avail_idx = vq->used_idx;
1175 }
1176 }
1177
1178 return false;
1179 }
1180
1181 static bool
1182 vu_set_vring_base_exec(VuDev *dev, VhostUserMsg *vmsg)
1183 {
1184 unsigned int index = vmsg->payload.state.index;
1185 unsigned int num = vmsg->payload.state.num;
1186
1187 DPRINT("State.index: %u\n", index);
1188 DPRINT("State.num: %u\n", num);
1189 dev->vq[index].shadow_avail_idx = dev->vq[index].last_avail_idx = num;
1190
1191 return false;
1192 }
1193
1194 static bool
1195 vu_get_vring_base_exec(VuDev *dev, VhostUserMsg *vmsg)
1196 {
1197 unsigned int index = vmsg->payload.state.index;
1198
1199 DPRINT("State.index: %u\n", index);
1200 vmsg->payload.state.num = dev->vq[index].last_avail_idx;
1201 vmsg->size = sizeof(vmsg->payload.state);
1202
1203 dev->vq[index].started = false;
1204 if (dev->iface->queue_set_started) {
1205 dev->iface->queue_set_started(dev, index, false);
1206 }
1207
1208 if (dev->vq[index].call_fd != -1) {
1209 close(dev->vq[index].call_fd);
1210 dev->vq[index].call_fd = -1;
1211 }
1212 if (dev->vq[index].kick_fd != -1) {
1213 dev->remove_watch(dev, dev->vq[index].kick_fd);
1214 close(dev->vq[index].kick_fd);
1215 dev->vq[index].kick_fd = -1;
1216 }
1217
1218 return true;
1219 }
1220
1221 static bool
1222 vu_check_queue_msg_file(VuDev *dev, VhostUserMsg *vmsg)
1223 {
1224 int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
1225 bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
1226
1227 if (index >= dev->max_queues) {
1228 vmsg_close_fds(vmsg);
1229 vu_panic(dev, "Invalid queue index: %u", index);
1230 return false;
1231 }
1232
1233 if (nofd) {
1234 vmsg_close_fds(vmsg);
1235 return true;
1236 }
1237
1238 if (vmsg->fd_num != 1) {
1239 vmsg_close_fds(vmsg);
1240 vu_panic(dev, "Invalid fds in request: %d", vmsg->request);
1241 return false;
1242 }
1243
1244 return true;
1245 }
1246
1247 static int
1248 inflight_desc_compare(const void *a, const void *b)
1249 {
1250 VuVirtqInflightDesc *desc0 = (VuVirtqInflightDesc *)a,
1251 *desc1 = (VuVirtqInflightDesc *)b;
1252
1253 if (desc1->counter > desc0->counter &&
1254 (desc1->counter - desc0->counter) < VIRTQUEUE_MAX_SIZE * 2) {
1255 return 1;
1256 }
1257
1258 return -1;
1259 }
1260
1261 static int
1262 vu_check_queue_inflights(VuDev *dev, VuVirtq *vq)
1263 {
1264 int i = 0;
1265
1266 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) {
1267 return 0;
1268 }
1269
1270 if (unlikely(!vq->inflight)) {
1271 return -1;
1272 }
1273
1274 if (unlikely(!vq->inflight->version)) {
1275 /* initialize the buffer */
1276 vq->inflight->version = INFLIGHT_VERSION;
1277 return 0;
1278 }
1279
1280 vq->used_idx = le16toh(vq->vring.used->idx);
1281 vq->resubmit_num = 0;
1282 vq->resubmit_list = NULL;
1283 vq->counter = 0;
1284
1285 if (unlikely(vq->inflight->used_idx != vq->used_idx)) {
1286 vq->inflight->desc[vq->inflight->last_batch_head].inflight = 0;
1287
1288 barrier();
1289
1290 vq->inflight->used_idx = vq->used_idx;
1291 }
1292
1293 for (i = 0; i < vq->inflight->desc_num; i++) {
1294 if (vq->inflight->desc[i].inflight == 1) {
1295 vq->inuse++;
1296 }
1297 }
1298
1299 vq->shadow_avail_idx = vq->last_avail_idx = vq->inuse + vq->used_idx;
1300
1301 if (vq->inuse) {
1302 vq->resubmit_list = calloc(vq->inuse, sizeof(VuVirtqInflightDesc));
1303 if (!vq->resubmit_list) {
1304 return -1;
1305 }
1306
1307 for (i = 0; i < vq->inflight->desc_num; i++) {
1308 if (vq->inflight->desc[i].inflight) {
1309 vq->resubmit_list[vq->resubmit_num].index = i;
1310 vq->resubmit_list[vq->resubmit_num].counter =
1311 vq->inflight->desc[i].counter;
1312 vq->resubmit_num++;
1313 }
1314 }
1315
1316 if (vq->resubmit_num > 1) {
1317 qsort(vq->resubmit_list, vq->resubmit_num,
1318 sizeof(VuVirtqInflightDesc), inflight_desc_compare);
1319 }
1320 vq->counter = vq->resubmit_list[0].counter + 1;
1321 }
1322
1323 /* in case of I/O hang after reconnecting */
1324 if (eventfd_write(vq->kick_fd, 1)) {
1325 return -1;
1326 }
1327
1328 return 0;
1329 }
1330
1331 static bool
1332 vu_set_vring_kick_exec(VuDev *dev, VhostUserMsg *vmsg)
1333 {
1334 int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
1335 bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
1336
1337 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1338
1339 if (!vu_check_queue_msg_file(dev, vmsg)) {
1340 return false;
1341 }
1342
1343 if (dev->vq[index].kick_fd != -1) {
1344 dev->remove_watch(dev, dev->vq[index].kick_fd);
1345 close(dev->vq[index].kick_fd);
1346 dev->vq[index].kick_fd = -1;
1347 }
1348
1349 dev->vq[index].kick_fd = nofd ? -1 : vmsg->fds[0];
1350 DPRINT("Got kick_fd: %d for vq: %d\n", dev->vq[index].kick_fd, index);
1351
1352 dev->vq[index].started = true;
1353 if (dev->iface->queue_set_started) {
1354 dev->iface->queue_set_started(dev, index, true);
1355 }
1356
1357 if (dev->vq[index].kick_fd != -1 && dev->vq[index].handler) {
1358 dev->set_watch(dev, dev->vq[index].kick_fd, VU_WATCH_IN,
1359 vu_kick_cb, (void *)(long)index);
1360
1361 DPRINT("Waiting for kicks on fd: %d for vq: %d\n",
1362 dev->vq[index].kick_fd, index);
1363 }
1364
1365 if (vu_check_queue_inflights(dev, &dev->vq[index])) {
1366 vu_panic(dev, "Failed to check inflights for vq: %d\n", index);
1367 }
1368
1369 return false;
1370 }
1371
1372 void vu_set_queue_handler(VuDev *dev, VuVirtq *vq,
1373 vu_queue_handler_cb handler)
1374 {
1375 int qidx = vq - dev->vq;
1376
1377 vq->handler = handler;
1378 if (vq->kick_fd >= 0) {
1379 if (handler) {
1380 dev->set_watch(dev, vq->kick_fd, VU_WATCH_IN,
1381 vu_kick_cb, (void *)(long)qidx);
1382 } else {
1383 dev->remove_watch(dev, vq->kick_fd);
1384 }
1385 }
1386 }
1387
1388 bool vu_set_queue_host_notifier(VuDev *dev, VuVirtq *vq, int fd,
1389 int size, int offset)
1390 {
1391 int qidx = vq - dev->vq;
1392 int fd_num = 0;
1393 VhostUserMsg vmsg = {
1394 .request = VHOST_USER_BACKEND_VRING_HOST_NOTIFIER_MSG,
1395 .flags = VHOST_USER_VERSION | VHOST_USER_NEED_REPLY_MASK,
1396 .size = sizeof(vmsg.payload.area),
1397 .payload.area = {
1398 .u64 = qidx & VHOST_USER_VRING_IDX_MASK,
1399 .size = size,
1400 .offset = offset,
1401 },
1402 };
1403
1404 if (fd == -1) {
1405 vmsg.payload.area.u64 |= VHOST_USER_VRING_NOFD_MASK;
1406 } else {
1407 vmsg.fds[fd_num++] = fd;
1408 }
1409
1410 vmsg.fd_num = fd_num;
1411
1412 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_BACKEND_SEND_FD)) {
1413 return false;
1414 }
1415
1416 pthread_mutex_lock(&dev->backend_mutex);
1417 if (!vu_message_write(dev, dev->backend_fd, &vmsg)) {
1418 pthread_mutex_unlock(&dev->backend_mutex);
1419 return false;
1420 }
1421
1422 /* Also unlocks the backend_mutex */
1423 return vu_process_message_reply(dev, &vmsg);
1424 }
1425
1426 bool
1427 vu_lookup_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN],
1428 int *dmabuf_fd)
1429 {
1430 bool result = false;
1431 VhostUserMsg msg_reply;
1432 VhostUserMsg msg = {
1433 .request = VHOST_USER_BACKEND_SHARED_OBJECT_LOOKUP,
1434 .size = sizeof(msg.payload.object),
1435 .flags = VHOST_USER_VERSION | VHOST_USER_NEED_REPLY_MASK,
1436 };
1437
1438 memcpy(msg.payload.object.uuid, uuid, sizeof(uuid[0]) * UUID_LEN);
1439
1440 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SHARED_OBJECT)) {
1441 return false;
1442 }
1443
1444 pthread_mutex_lock(&dev->backend_mutex);
1445 if (!vu_message_write(dev, dev->backend_fd, &msg)) {
1446 goto out;
1447 }
1448
1449 if (!vu_message_read_default(dev, dev->backend_fd, &msg_reply)) {
1450 goto out;
1451 }
1452
1453 if (msg_reply.request != msg.request) {
1454 DPRINT("Received unexpected msg type. Expected %d, received %d",
1455 msg.request, msg_reply.request);
1456 goto out;
1457 }
1458
1459 if (msg_reply.fd_num != 1) {
1460 DPRINT("Received unexpected number of fds. Expected 1, received %d",
1461 msg_reply.fd_num);
1462 goto out;
1463 }
1464
1465 *dmabuf_fd = msg_reply.fds[0];
1466 result = *dmabuf_fd > 0 && msg_reply.payload.u64 == 0;
1467 out:
1468 pthread_mutex_unlock(&dev->backend_mutex);
1469
1470 return result;
1471 }
1472
1473 static bool
1474 vu_send_message(VuDev *dev, VhostUserMsg *vmsg)
1475 {
1476 bool result = false;
1477 pthread_mutex_lock(&dev->backend_mutex);
1478 if (!vu_message_write(dev, dev->backend_fd, vmsg)) {
1479 goto out;
1480 }
1481
1482 result = true;
1483 out:
1484 pthread_mutex_unlock(&dev->backend_mutex);
1485
1486 return result;
1487 }
1488
1489 bool
1490 vu_add_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN])
1491 {
1492 VhostUserMsg msg = {
1493 .request = VHOST_USER_BACKEND_SHARED_OBJECT_ADD,
1494 .size = sizeof(msg.payload.object),
1495 .flags = VHOST_USER_VERSION,
1496 };
1497
1498 memcpy(msg.payload.object.uuid, uuid, sizeof(uuid[0]) * UUID_LEN);
1499
1500 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SHARED_OBJECT)) {
1501 return false;
1502 }
1503
1504 return vu_send_message(dev, &msg);
1505 }
1506
1507 bool
1508 vu_rm_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN])
1509 {
1510 VhostUserMsg msg = {
1511 .request = VHOST_USER_BACKEND_SHARED_OBJECT_REMOVE,
1512 .size = sizeof(msg.payload.object),
1513 .flags = VHOST_USER_VERSION,
1514 };
1515
1516 memcpy(msg.payload.object.uuid, uuid, sizeof(uuid[0]) * UUID_LEN);
1517
1518 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SHARED_OBJECT)) {
1519 return false;
1520 }
1521
1522 return vu_send_message(dev, &msg);
1523 }
1524
1525 static bool
1526 vu_set_vring_call_exec(VuDev *dev, VhostUserMsg *vmsg)
1527 {
1528 int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
1529 bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
1530
1531 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1532
1533 if (!vu_check_queue_msg_file(dev, vmsg)) {
1534 return false;
1535 }
1536
1537 if (dev->vq[index].call_fd != -1) {
1538 close(dev->vq[index].call_fd);
1539 dev->vq[index].call_fd = -1;
1540 }
1541
1542 dev->vq[index].call_fd = nofd ? -1 : vmsg->fds[0];
1543
1544 /* in case of I/O hang after reconnecting */
1545 if (dev->vq[index].call_fd != -1 && eventfd_write(vmsg->fds[0], 1)) {
1546 return -1;
1547 }
1548
1549 DPRINT("Got call_fd: %d for vq: %d\n", dev->vq[index].call_fd, index);
1550
1551 return false;
1552 }
1553
1554 static bool
1555 vu_set_vring_err_exec(VuDev *dev, VhostUserMsg *vmsg)
1556 {
1557 int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
1558 bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
1559
1560 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1561
1562 if (!vu_check_queue_msg_file(dev, vmsg)) {
1563 return false;
1564 }
1565
1566 if (dev->vq[index].err_fd != -1) {
1567 close(dev->vq[index].err_fd);
1568 dev->vq[index].err_fd = -1;
1569 }
1570
1571 dev->vq[index].err_fd = nofd ? -1 : vmsg->fds[0];
1572
1573 return false;
1574 }
1575
1576 static bool
1577 vu_get_protocol_features_exec(VuDev *dev, VhostUserMsg *vmsg)
1578 {
1579 /*
1580 * Note that we support, but intentionally do not set,
1581 * VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS. This means that
1582 * a device implementation can return it in its callback
1583 * (get_protocol_features) if it wants to use this for
1584 * simulation, but it is otherwise not desirable (if even
1585 * implemented by the frontend.)
1586 */
1587 uint64_t features = 1ULL << VHOST_USER_PROTOCOL_F_MQ |
1588 1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD |
1589 1ULL << VHOST_USER_PROTOCOL_F_BACKEND_REQ |
1590 1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER |
1591 1ULL << VHOST_USER_PROTOCOL_F_BACKEND_SEND_FD |
1592 1ULL << VHOST_USER_PROTOCOL_F_REPLY_ACK |
1593 1ULL << VHOST_USER_PROTOCOL_F_CONFIGURE_MEM_SLOTS;
1594
1595 if (have_userfault()) {
1596 features |= 1ULL << VHOST_USER_PROTOCOL_F_PAGEFAULT;
1597 }
1598
1599 if (dev->iface->get_config && dev->iface->set_config) {
1600 features |= 1ULL << VHOST_USER_PROTOCOL_F_CONFIG;
1601 }
1602
1603 if (dev->iface->get_protocol_features) {
1604 features |= dev->iface->get_protocol_features(dev);
1605 }
1606
1607 vmsg_set_reply_u64(vmsg, features);
1608 return true;
1609 }
1610
1611 static bool
1612 vu_set_protocol_features_exec(VuDev *dev, VhostUserMsg *vmsg)
1613 {
1614 uint64_t features = vmsg->payload.u64;
1615
1616 DPRINT("u64: 0x%016"PRIx64"\n", features);
1617
1618 dev->protocol_features = vmsg->payload.u64;
1619
1620 if (vu_has_protocol_feature(dev,
1621 VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS) &&
1622 (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_BACKEND_REQ) ||
1623 !vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_REPLY_ACK))) {
1624 /*
1625 * The use case for using messages for kick/call is simulation, to make
1626 * the kick and call synchronous. To actually get that behaviour, both
1627 * of the other features are required.
1628 * Theoretically, one could use only kick messages, or do them without
1629 * having F_REPLY_ACK, but too many (possibly pending) messages on the
1630 * socket will eventually cause the frontend to hang, to avoid this in
1631 * scenarios where not desired enforce that the settings are in a way
1632 * that actually enables the simulation case.
1633 */
1634 vu_panic(dev,
1635 "F_IN_BAND_NOTIFICATIONS requires F_BACKEND_REQ && F_REPLY_ACK");
1636 return false;
1637 }
1638
1639 if (dev->iface->set_protocol_features) {
1640 dev->iface->set_protocol_features(dev, features);
1641 }
1642
1643 return false;
1644 }
1645
1646 static bool
1647 vu_get_queue_num_exec(VuDev *dev, VhostUserMsg *vmsg)
1648 {
1649 vmsg_set_reply_u64(vmsg, dev->max_queues);
1650 return true;
1651 }
1652
1653 static bool
1654 vu_set_vring_enable_exec(VuDev *dev, VhostUserMsg *vmsg)
1655 {
1656 unsigned int index = vmsg->payload.state.index;
1657 unsigned int enable = vmsg->payload.state.num;
1658
1659 DPRINT("State.index: %u\n", index);
1660 DPRINT("State.enable: %u\n", enable);
1661
1662 if (index >= dev->max_queues) {
1663 vu_panic(dev, "Invalid vring_enable index: %u", index);
1664 return false;
1665 }
1666
1667 dev->vq[index].enable = enable;
1668 return false;
1669 }
1670
1671 static bool
1672 vu_set_backend_req_fd(VuDev *dev, VhostUserMsg *vmsg)
1673 {
1674 if (vmsg->fd_num != 1) {
1675 vu_panic(dev, "Invalid backend_req_fd message (%d fd's)", vmsg->fd_num);
1676 return false;
1677 }
1678
1679 if (dev->backend_fd != -1) {
1680 close(dev->backend_fd);
1681 }
1682 dev->backend_fd = vmsg->fds[0];
1683 DPRINT("Got backend_fd: %d\n", vmsg->fds[0]);
1684
1685 return false;
1686 }
1687
1688 static bool
1689 vu_get_config(VuDev *dev, VhostUserMsg *vmsg)
1690 {
1691 int ret = -1;
1692
1693 if (dev->iface->get_config) {
1694 ret = dev->iface->get_config(dev, vmsg->payload.config.region,
1695 vmsg->payload.config.size);
1696 }
1697
1698 if (ret) {
1699 /* resize to zero to indicate an error to frontend */
1700 vmsg->size = 0;
1701 }
1702
1703 return true;
1704 }
1705
1706 static bool
1707 vu_set_config(VuDev *dev, VhostUserMsg *vmsg)
1708 {
1709 int ret = -1;
1710
1711 if (dev->iface->set_config) {
1712 ret = dev->iface->set_config(dev, vmsg->payload.config.region,
1713 vmsg->payload.config.offset,
1714 vmsg->payload.config.size,
1715 vmsg->payload.config.flags);
1716 if (ret) {
1717 vu_panic(dev, "Set virtio configuration space failed");
1718 }
1719 }
1720
1721 return false;
1722 }
1723
1724 static bool
1725 vu_set_postcopy_advise(VuDev *dev, VhostUserMsg *vmsg)
1726 {
1727 #ifdef UFFDIO_API
1728 struct uffdio_api api_struct;
1729
1730 dev->postcopy_ufd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
1731 vmsg->size = 0;
1732 #else
1733 dev->postcopy_ufd = -1;
1734 #endif
1735
1736 if (dev->postcopy_ufd == -1) {
1737 vu_panic(dev, "Userfaultfd not available: %s", strerror(errno));
1738 goto out;
1739 }
1740
1741 #ifdef UFFDIO_API
1742 api_struct.api = UFFD_API;
1743 api_struct.features = 0;
1744 if (ioctl(dev->postcopy_ufd, UFFDIO_API, &api_struct)) {
1745 vu_panic(dev, "Failed UFFDIO_API: %s", strerror(errno));
1746 close(dev->postcopy_ufd);
1747 dev->postcopy_ufd = -1;
1748 goto out;
1749 }
1750 /* TODO: Stash feature flags somewhere */
1751 #endif
1752
1753 out:
1754 /* Return a ufd to the QEMU */
1755 vmsg->fd_num = 1;
1756 vmsg->fds[0] = dev->postcopy_ufd;
1757 return true; /* = send a reply */
1758 }
1759
1760 static bool
1761 vu_set_postcopy_listen(VuDev *dev, VhostUserMsg *vmsg)
1762 {
1763 if (dev->nregions) {
1764 vu_panic(dev, "Regions already registered at postcopy-listen");
1765 vmsg_set_reply_u64(vmsg, -1);
1766 return true;
1767 }
1768 dev->postcopy_listening = true;
1769
1770 vmsg_set_reply_u64(vmsg, 0);
1771 return true;
1772 }
1773
1774 static bool
1775 vu_set_postcopy_end(VuDev *dev, VhostUserMsg *vmsg)
1776 {
1777 DPRINT("%s: Entry\n", __func__);
1778 dev->postcopy_listening = false;
1779 if (dev->postcopy_ufd > 0) {
1780 close(dev->postcopy_ufd);
1781 dev->postcopy_ufd = -1;
1782 DPRINT("%s: Done close\n", __func__);
1783 }
1784
1785 vmsg_set_reply_u64(vmsg, 0);
1786 DPRINT("%s: exit\n", __func__);
1787 return true;
1788 }
1789
1790 static inline uint64_t
1791 vu_inflight_queue_size(uint16_t queue_size)
1792 {
1793 return ALIGN_UP(sizeof(VuDescStateSplit) * queue_size +
1794 sizeof(uint16_t), INFLIGHT_ALIGNMENT);
1795 }
1796
1797 #ifdef MFD_ALLOW_SEALING
1798 static void *
1799 memfd_alloc(const char *name, size_t size, unsigned int flags, int *fd)
1800 {
1801 void *ptr;
1802 int ret;
1803
1804 *fd = memfd_create(name, MFD_ALLOW_SEALING);
1805 if (*fd < 0) {
1806 return NULL;
1807 }
1808
1809 ret = ftruncate(*fd, size);
1810 if (ret < 0) {
1811 close(*fd);
1812 return NULL;
1813 }
1814
1815 ret = fcntl(*fd, F_ADD_SEALS, flags);
1816 if (ret < 0) {
1817 close(*fd);
1818 return NULL;
1819 }
1820
1821 ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, *fd, 0);
1822 if (ptr == MAP_FAILED) {
1823 close(*fd);
1824 return NULL;
1825 }
1826
1827 return ptr;
1828 }
1829 #endif
1830
1831 static bool
1832 vu_get_inflight_fd(VuDev *dev, VhostUserMsg *vmsg)
1833 {
1834 int fd = -1;
1835 void *addr = NULL;
1836 uint64_t mmap_size;
1837 uint16_t num_queues, queue_size;
1838
1839 if (vmsg->size != sizeof(vmsg->payload.inflight)) {
1840 vu_panic(dev, "Invalid get_inflight_fd message:%d", vmsg->size);
1841 vmsg->payload.inflight.mmap_size = 0;
1842 return true;
1843 }
1844
1845 num_queues = vmsg->payload.inflight.num_queues;
1846 queue_size = vmsg->payload.inflight.queue_size;
1847
1848 DPRINT("set_inflight_fd num_queues: %"PRId16"\n", num_queues);
1849 DPRINT("set_inflight_fd queue_size: %"PRId16"\n", queue_size);
1850
1851 mmap_size = vu_inflight_queue_size(queue_size) * num_queues;
1852
1853 #ifdef MFD_ALLOW_SEALING
1854 addr = memfd_alloc("vhost-inflight", mmap_size,
1855 F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL,
1856 &fd);
1857 #else
1858 vu_panic(dev, "Not implemented: memfd support is missing");
1859 #endif
1860
1861 if (!addr) {
1862 vu_panic(dev, "Failed to alloc vhost inflight area");
1863 vmsg->payload.inflight.mmap_size = 0;
1864 return true;
1865 }
1866
1867 memset(addr, 0, mmap_size);
1868
1869 dev->inflight_info.addr = addr;
1870 dev->inflight_info.size = vmsg->payload.inflight.mmap_size = mmap_size;
1871 dev->inflight_info.fd = vmsg->fds[0] = fd;
1872 vmsg->fd_num = 1;
1873 vmsg->payload.inflight.mmap_offset = 0;
1874
1875 DPRINT("send inflight mmap_size: %"PRId64"\n",
1876 vmsg->payload.inflight.mmap_size);
1877 DPRINT("send inflight mmap offset: %"PRId64"\n",
1878 vmsg->payload.inflight.mmap_offset);
1879
1880 return true;
1881 }
1882
1883 static bool
1884 vu_set_inflight_fd(VuDev *dev, VhostUserMsg *vmsg)
1885 {
1886 int fd, i;
1887 uint64_t mmap_size, mmap_offset;
1888 uint16_t num_queues, queue_size;
1889 void *rc;
1890
1891 if (vmsg->fd_num != 1 ||
1892 vmsg->size != sizeof(vmsg->payload.inflight)) {
1893 vu_panic(dev, "Invalid set_inflight_fd message size:%d fds:%d",
1894 vmsg->size, vmsg->fd_num);
1895 return false;
1896 }
1897
1898 fd = vmsg->fds[0];
1899 mmap_size = vmsg->payload.inflight.mmap_size;
1900 mmap_offset = vmsg->payload.inflight.mmap_offset;
1901 num_queues = vmsg->payload.inflight.num_queues;
1902 queue_size = vmsg->payload.inflight.queue_size;
1903
1904 DPRINT("set_inflight_fd mmap_size: %"PRId64"\n", mmap_size);
1905 DPRINT("set_inflight_fd mmap_offset: %"PRId64"\n", mmap_offset);
1906 DPRINT("set_inflight_fd num_queues: %"PRId16"\n", num_queues);
1907 DPRINT("set_inflight_fd queue_size: %"PRId16"\n", queue_size);
1908
1909 rc = mmap(0, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
1910 fd, mmap_offset);
1911
1912 if (rc == MAP_FAILED) {
1913 vu_panic(dev, "set_inflight_fd mmap error: %s", strerror(errno));
1914 return false;
1915 }
1916
1917 if (dev->inflight_info.fd) {
1918 close(dev->inflight_info.fd);
1919 }
1920
1921 if (dev->inflight_info.addr) {
1922 munmap(dev->inflight_info.addr, dev->inflight_info.size);
1923 }
1924
1925 dev->inflight_info.fd = fd;
1926 dev->inflight_info.addr = rc;
1927 dev->inflight_info.size = mmap_size;
1928
1929 for (i = 0; i < num_queues; i++) {
1930 dev->vq[i].inflight = (VuVirtqInflight *)rc;
1931 dev->vq[i].inflight->desc_num = queue_size;
1932 rc = (void *)((char *)rc + vu_inflight_queue_size(queue_size));
1933 }
1934
1935 return false;
1936 }
1937
1938 static bool
1939 vu_handle_vring_kick(VuDev *dev, VhostUserMsg *vmsg)
1940 {
1941 unsigned int index = vmsg->payload.state.index;
1942
1943 if (index >= dev->max_queues) {
1944 vu_panic(dev, "Invalid queue index: %u", index);
1945 return false;
1946 }
1947
1948 DPRINT("Got kick message: handler:%p idx:%u\n",
1949 dev->vq[index].handler, index);
1950
1951 if (!dev->vq[index].started) {
1952 dev->vq[index].started = true;
1953
1954 if (dev->iface->queue_set_started) {
1955 dev->iface->queue_set_started(dev, index, true);
1956 }
1957 }
1958
1959 if (dev->vq[index].handler) {
1960 dev->vq[index].handler(dev, index);
1961 }
1962
1963 return false;
1964 }
1965
1966 static bool vu_handle_get_max_memslots(VuDev *dev, VhostUserMsg *vmsg)
1967 {
1968 vmsg_set_reply_u64(vmsg, VHOST_USER_MAX_RAM_SLOTS);
1969
1970 DPRINT("u64: 0x%016"PRIx64"\n", (uint64_t) VHOST_USER_MAX_RAM_SLOTS);
1971
1972 return true;
1973 }
1974
1975 static bool
1976 vu_process_message(VuDev *dev, VhostUserMsg *vmsg)
1977 {
1978 int do_reply = 0;
1979
1980 /* Print out generic part of the request. */
1981 DPRINT("================ Vhost user message ================\n");
1982 DPRINT("Request: %s (%d)\n", vu_request_to_string(vmsg->request),
1983 vmsg->request);
1984 DPRINT("Flags: 0x%x\n", vmsg->flags);
1985 DPRINT("Size: %u\n", vmsg->size);
1986
1987 if (vmsg->fd_num) {
1988 int i;
1989 DPRINT("Fds:");
1990 for (i = 0; i < vmsg->fd_num; i++) {
1991 DPRINT(" %d", vmsg->fds[i]);
1992 }
1993 DPRINT("\n");
1994 }
1995
1996 if (dev->iface->process_msg &&
1997 dev->iface->process_msg(dev, vmsg, &do_reply)) {
1998 return do_reply;
1999 }
2000
2001 switch (vmsg->request) {
2002 case VHOST_USER_GET_FEATURES:
2003 return vu_get_features_exec(dev, vmsg);
2004 case VHOST_USER_SET_FEATURES:
2005 return vu_set_features_exec(dev, vmsg);
2006 case VHOST_USER_GET_PROTOCOL_FEATURES:
2007 return vu_get_protocol_features_exec(dev, vmsg);
2008 case VHOST_USER_SET_PROTOCOL_FEATURES:
2009 return vu_set_protocol_features_exec(dev, vmsg);
2010 case VHOST_USER_SET_OWNER:
2011 return vu_set_owner_exec(dev, vmsg);
2012 case VHOST_USER_RESET_OWNER:
2013 return vu_reset_device_exec(dev, vmsg);
2014 case VHOST_USER_SET_MEM_TABLE:
2015 return vu_set_mem_table_exec(dev, vmsg);
2016 case VHOST_USER_SET_LOG_BASE:
2017 return vu_set_log_base_exec(dev, vmsg);
2018 case VHOST_USER_SET_LOG_FD:
2019 return vu_set_log_fd_exec(dev, vmsg);
2020 case VHOST_USER_SET_VRING_NUM:
2021 return vu_set_vring_num_exec(dev, vmsg);
2022 case VHOST_USER_SET_VRING_ADDR:
2023 return vu_set_vring_addr_exec(dev, vmsg);
2024 case VHOST_USER_SET_VRING_BASE:
2025 return vu_set_vring_base_exec(dev, vmsg);
2026 case VHOST_USER_GET_VRING_BASE:
2027 return vu_get_vring_base_exec(dev, vmsg);
2028 case VHOST_USER_SET_VRING_KICK:
2029 return vu_set_vring_kick_exec(dev, vmsg);
2030 case VHOST_USER_SET_VRING_CALL:
2031 return vu_set_vring_call_exec(dev, vmsg);
2032 case VHOST_USER_SET_VRING_ERR:
2033 return vu_set_vring_err_exec(dev, vmsg);
2034 case VHOST_USER_GET_QUEUE_NUM:
2035 return vu_get_queue_num_exec(dev, vmsg);
2036 case VHOST_USER_SET_VRING_ENABLE:
2037 return vu_set_vring_enable_exec(dev, vmsg);
2038 case VHOST_USER_SET_BACKEND_REQ_FD:
2039 return vu_set_backend_req_fd(dev, vmsg);
2040 case VHOST_USER_GET_CONFIG:
2041 return vu_get_config(dev, vmsg);
2042 case VHOST_USER_SET_CONFIG:
2043 return vu_set_config(dev, vmsg);
2044 case VHOST_USER_NONE:
2045 /* if you need processing before exit, override iface->process_msg */
2046 exit(0);
2047 case VHOST_USER_POSTCOPY_ADVISE:
2048 return vu_set_postcopy_advise(dev, vmsg);
2049 case VHOST_USER_POSTCOPY_LISTEN:
2050 return vu_set_postcopy_listen(dev, vmsg);
2051 case VHOST_USER_POSTCOPY_END:
2052 return vu_set_postcopy_end(dev, vmsg);
2053 case VHOST_USER_GET_INFLIGHT_FD:
2054 return vu_get_inflight_fd(dev, vmsg);
2055 case VHOST_USER_SET_INFLIGHT_FD:
2056 return vu_set_inflight_fd(dev, vmsg);
2057 case VHOST_USER_VRING_KICK:
2058 return vu_handle_vring_kick(dev, vmsg);
2059 case VHOST_USER_GET_MAX_MEM_SLOTS:
2060 return vu_handle_get_max_memslots(dev, vmsg);
2061 case VHOST_USER_ADD_MEM_REG:
2062 return vu_add_mem_reg(dev, vmsg);
2063 case VHOST_USER_REM_MEM_REG:
2064 return vu_rem_mem_reg(dev, vmsg);
2065 case VHOST_USER_GET_SHARED_OBJECT:
2066 return vu_get_shared_object(dev, vmsg);
2067 default:
2068 vmsg_close_fds(vmsg);
2069 vu_panic(dev, "Unhandled request: %d", vmsg->request);
2070 }
2071
2072 return false;
2073 }
2074
2075 bool
2076 vu_dispatch(VuDev *dev)
2077 {
2078 VhostUserMsg vmsg = { 0, };
2079 int reply_requested;
2080 bool need_reply, success = false;
2081
2082 if (!dev->read_msg(dev, dev->sock, &vmsg)) {
2083 goto end;
2084 }
2085
2086 need_reply = vmsg.flags & VHOST_USER_NEED_REPLY_MASK;
2087
2088 reply_requested = vu_process_message(dev, &vmsg);
2089 if (!reply_requested && need_reply) {
2090 vmsg_set_reply_u64(&vmsg, 0);
2091 reply_requested = 1;
2092 }
2093
2094 if (!reply_requested) {
2095 success = true;
2096 goto end;
2097 }
2098
2099 if (!vu_send_reply(dev, dev->sock, &vmsg)) {
2100 goto end;
2101 }
2102
2103 success = true;
2104
2105 end:
2106 free(vmsg.data);
2107 return success;
2108 }
2109
2110 void
2111 vu_deinit(VuDev *dev)
2112 {
2113 unsigned int i;
2114
2115 for (i = 0; i < dev->nregions; i++) {
2116 VuDevRegion *r = &dev->regions[i];
2117 void *m = (void *) (uintptr_t) r->mmap_addr;
2118 if (m != MAP_FAILED) {
2119 munmap(m, r->size + r->mmap_offset);
2120 }
2121 }
2122 dev->nregions = 0;
2123
2124 for (i = 0; i < dev->max_queues; i++) {
2125 VuVirtq *vq = &dev->vq[i];
2126
2127 if (vq->call_fd != -1) {
2128 close(vq->call_fd);
2129 vq->call_fd = -1;
2130 }
2131
2132 if (vq->kick_fd != -1) {
2133 dev->remove_watch(dev, vq->kick_fd);
2134 close(vq->kick_fd);
2135 vq->kick_fd = -1;
2136 }
2137
2138 if (vq->err_fd != -1) {
2139 close(vq->err_fd);
2140 vq->err_fd = -1;
2141 }
2142
2143 if (vq->resubmit_list) {
2144 free(vq->resubmit_list);
2145 vq->resubmit_list = NULL;
2146 }
2147
2148 vq->inflight = NULL;
2149 }
2150
2151 if (dev->inflight_info.addr) {
2152 munmap(dev->inflight_info.addr, dev->inflight_info.size);
2153 dev->inflight_info.addr = NULL;
2154 }
2155
2156 if (dev->inflight_info.fd > 0) {
2157 close(dev->inflight_info.fd);
2158 dev->inflight_info.fd = -1;
2159 }
2160
2161 vu_close_log(dev);
2162 if (dev->backend_fd != -1) {
2163 close(dev->backend_fd);
2164 dev->backend_fd = -1;
2165 }
2166 pthread_mutex_destroy(&dev->backend_mutex);
2167
2168 if (dev->sock != -1) {
2169 close(dev->sock);
2170 }
2171
2172 free(dev->vq);
2173 dev->vq = NULL;
2174 }
2175
2176 bool
2177 vu_init(VuDev *dev,
2178 uint16_t max_queues,
2179 int socket,
2180 vu_panic_cb panic,
2181 vu_read_msg_cb read_msg,
2182 vu_set_watch_cb set_watch,
2183 vu_remove_watch_cb remove_watch,
2184 const VuDevIface *iface)
2185 {
2186 uint16_t i;
2187
2188 assert(max_queues > 0);
2189 assert(socket >= 0);
2190 assert(set_watch);
2191 assert(remove_watch);
2192 assert(iface);
2193 assert(panic);
2194
2195 memset(dev, 0, sizeof(*dev));
2196
2197 dev->sock = socket;
2198 dev->panic = panic;
2199 dev->read_msg = read_msg ? read_msg : vu_message_read_default;
2200 dev->set_watch = set_watch;
2201 dev->remove_watch = remove_watch;
2202 dev->iface = iface;
2203 dev->log_call_fd = -1;
2204 pthread_mutex_init(&dev->backend_mutex, NULL);
2205 dev->backend_fd = -1;
2206 dev->max_queues = max_queues;
2207
2208 dev->vq = malloc(max_queues * sizeof(dev->vq[0]));
2209 if (!dev->vq) {
2210 DPRINT("%s: failed to malloc virtqueues\n", __func__);
2211 return false;
2212 }
2213
2214 for (i = 0; i < max_queues; i++) {
2215 dev->vq[i] = (VuVirtq) {
2216 .call_fd = -1, .kick_fd = -1, .err_fd = -1,
2217 .notification = true,
2218 };
2219 }
2220
2221 return true;
2222 }
2223
2224 VuVirtq *
2225 vu_get_queue(VuDev *dev, int qidx)
2226 {
2227 assert(qidx < dev->max_queues);
2228 return &dev->vq[qidx];
2229 }
2230
2231 bool
2232 vu_queue_enabled(VuDev *dev, VuVirtq *vq)
2233 {
2234 return vq->enable;
2235 }
2236
2237 bool
2238 vu_queue_started(const VuDev *dev, const VuVirtq *vq)
2239 {
2240 return vq->started;
2241 }
2242
2243 static inline uint16_t
2244 vring_avail_flags(VuVirtq *vq)
2245 {
2246 return le16toh(vq->vring.avail->flags);
2247 }
2248
2249 static inline uint16_t
2250 vring_avail_idx(VuVirtq *vq)
2251 {
2252 vq->shadow_avail_idx = le16toh(vq->vring.avail->idx);
2253
2254 return vq->shadow_avail_idx;
2255 }
2256
2257 static inline uint16_t
2258 vring_avail_ring(VuVirtq *vq, int i)
2259 {
2260 return le16toh(vq->vring.avail->ring[i]);
2261 }
2262
2263 static inline uint16_t
2264 vring_get_used_event(VuVirtq *vq)
2265 {
2266 return vring_avail_ring(vq, vq->vring.num);
2267 }
2268
2269 static int
2270 virtqueue_num_heads(VuDev *dev, VuVirtq *vq, unsigned int idx)
2271 {
2272 uint16_t num_heads = vring_avail_idx(vq) - idx;
2273
2274 /* Check it isn't doing very strange things with descriptor numbers. */
2275 if (num_heads > vq->vring.num) {
2276 vu_panic(dev, "Guest moved used index from %u to %u",
2277 idx, vq->shadow_avail_idx);
2278 return -1;
2279 }
2280 if (num_heads) {
2281 /* On success, callers read a descriptor at vq->last_avail_idx.
2282 * Make sure descriptor read does not bypass avail index read. */
2283 smp_rmb();
2284 }
2285
2286 return num_heads;
2287 }
2288
2289 static bool
2290 virtqueue_get_head(VuDev *dev, VuVirtq *vq,
2291 unsigned int idx, unsigned int *head)
2292 {
2293 /* Grab the next descriptor number they're advertising, and increment
2294 * the index we've seen. */
2295 *head = vring_avail_ring(vq, idx % vq->vring.num);
2296
2297 /* If their number is silly, that's a fatal mistake. */
2298 if (*head >= vq->vring.num) {
2299 vu_panic(dev, "Guest says index %u is available", *head);
2300 return false;
2301 }
2302
2303 return true;
2304 }
2305
2306 static int
2307 virtqueue_read_indirect_desc(VuDev *dev, struct vring_desc *desc,
2308 uint64_t addr, size_t len)
2309 {
2310 struct vring_desc *ori_desc;
2311 uint64_t read_len;
2312
2313 if (len > (VIRTQUEUE_MAX_SIZE * sizeof(struct vring_desc))) {
2314 return -1;
2315 }
2316
2317 if (len == 0) {
2318 return -1;
2319 }
2320
2321 while (len) {
2322 read_len = len;
2323 ori_desc = vu_gpa_to_va(dev, &read_len, addr);
2324 if (!ori_desc) {
2325 return -1;
2326 }
2327
2328 memcpy(desc, ori_desc, read_len);
2329 len -= read_len;
2330 addr += read_len;
2331 desc += read_len;
2332 }
2333
2334 return 0;
2335 }
2336
2337 enum {
2338 VIRTQUEUE_READ_DESC_ERROR = -1,
2339 VIRTQUEUE_READ_DESC_DONE = 0, /* end of chain */
2340 VIRTQUEUE_READ_DESC_MORE = 1, /* more buffers in chain */
2341 };
2342
2343 static int
2344 virtqueue_read_next_desc(VuDev *dev, struct vring_desc *desc,
2345 int i, unsigned int max, unsigned int *next)
2346 {
2347 /* If this descriptor says it doesn't chain, we're done. */
2348 if (!(le16toh(desc[i].flags) & VRING_DESC_F_NEXT)) {
2349 return VIRTQUEUE_READ_DESC_DONE;
2350 }
2351
2352 /* Check they're not leading us off end of descriptors. */
2353 *next = le16toh(desc[i].next);
2354 /* Make sure compiler knows to grab that: we don't want it changing! */
2355 smp_wmb();
2356
2357 if (*next >= max) {
2358 vu_panic(dev, "Desc next is %u", *next);
2359 return VIRTQUEUE_READ_DESC_ERROR;
2360 }
2361
2362 return VIRTQUEUE_READ_DESC_MORE;
2363 }
2364
2365 void
2366 vu_queue_get_avail_bytes(VuDev *dev, VuVirtq *vq, unsigned int *in_bytes,
2367 unsigned int *out_bytes,
2368 unsigned max_in_bytes, unsigned max_out_bytes)
2369 {
2370 unsigned int idx;
2371 unsigned int total_bufs, in_total, out_total;
2372 int rc;
2373
2374 idx = vq->last_avail_idx;
2375
2376 total_bufs = in_total = out_total = 0;
2377 if (unlikely(dev->broken) ||
2378 unlikely(!vq->vring.avail)) {
2379 goto done;
2380 }
2381
2382 while ((rc = virtqueue_num_heads(dev, vq, idx)) > 0) {
2383 unsigned int max, desc_len, num_bufs, indirect = 0;
2384 uint64_t desc_addr, read_len;
2385 struct vring_desc *desc;
2386 struct vring_desc desc_buf[VIRTQUEUE_MAX_SIZE];
2387 unsigned int i;
2388
2389 max = vq->vring.num;
2390 num_bufs = total_bufs;
2391 if (!virtqueue_get_head(dev, vq, idx++, &i)) {
2392 goto err;
2393 }
2394 desc = vq->vring.desc;
2395
2396 if (le16toh(desc[i].flags) & VRING_DESC_F_INDIRECT) {
2397 if (le32toh(desc[i].len) % sizeof(struct vring_desc)) {
2398 vu_panic(dev, "Invalid size for indirect buffer table");
2399 goto err;
2400 }
2401
2402 /* If we've got too many, that implies a descriptor loop. */
2403 if (num_bufs >= max) {
2404 vu_panic(dev, "Looped descriptor");
2405 goto err;
2406 }
2407
2408 /* loop over the indirect descriptor table */
2409 indirect = 1;
2410 desc_addr = le64toh(desc[i].addr);
2411 desc_len = le32toh(desc[i].len);
2412 max = desc_len / sizeof(struct vring_desc);
2413 read_len = desc_len;
2414 desc = vu_gpa_to_va(dev, &read_len, desc_addr);
2415 if (unlikely(desc && read_len != desc_len)) {
2416 /* Failed to use zero copy */
2417 desc = NULL;
2418 if (!virtqueue_read_indirect_desc(dev, desc_buf,
2419 desc_addr,
2420 desc_len)) {
2421 desc = desc_buf;
2422 }
2423 }
2424 if (!desc) {
2425 vu_panic(dev, "Invalid indirect buffer table");
2426 goto err;
2427 }
2428 num_bufs = i = 0;
2429 }
2430
2431 do {
2432 /* If we've got too many, that implies a descriptor loop. */
2433 if (++num_bufs > max) {
2434 vu_panic(dev, "Looped descriptor");
2435 goto err;
2436 }
2437
2438 if (le16toh(desc[i].flags) & VRING_DESC_F_WRITE) {
2439 in_total += le32toh(desc[i].len);
2440 } else {
2441 out_total += le32toh(desc[i].len);
2442 }
2443 if (in_total >= max_in_bytes && out_total >= max_out_bytes) {
2444 goto done;
2445 }
2446 rc = virtqueue_read_next_desc(dev, desc, i, max, &i);
2447 } while (rc == VIRTQUEUE_READ_DESC_MORE);
2448
2449 if (rc == VIRTQUEUE_READ_DESC_ERROR) {
2450 goto err;
2451 }
2452
2453 if (!indirect) {
2454 total_bufs = num_bufs;
2455 } else {
2456 total_bufs++;
2457 }
2458 }
2459 if (rc < 0) {
2460 goto err;
2461 }
2462 done:
2463 if (in_bytes) {
2464 *in_bytes = in_total;
2465 }
2466 if (out_bytes) {
2467 *out_bytes = out_total;
2468 }
2469 return;
2470
2471 err:
2472 in_total = out_total = 0;
2473 goto done;
2474 }
2475
2476 bool
2477 vu_queue_avail_bytes(VuDev *dev, VuVirtq *vq, unsigned int in_bytes,
2478 unsigned int out_bytes)
2479 {
2480 unsigned int in_total, out_total;
2481
2482 vu_queue_get_avail_bytes(dev, vq, &in_total, &out_total,
2483 in_bytes, out_bytes);
2484
2485 return in_bytes <= in_total && out_bytes <= out_total;
2486 }
2487
2488 /* Fetch avail_idx from VQ memory only when we really need to know if
2489 * guest has added some buffers. */
2490 bool
2491 vu_queue_empty(VuDev *dev, VuVirtq *vq)
2492 {
2493 if (unlikely(dev->broken) ||
2494 unlikely(!vq->vring.avail)) {
2495 return true;
2496 }
2497
2498 if (vq->shadow_avail_idx != vq->last_avail_idx) {
2499 return false;
2500 }
2501
2502 return vring_avail_idx(vq) == vq->last_avail_idx;
2503 }
2504
2505 static bool
2506 vring_notify(VuDev *dev, VuVirtq *vq)
2507 {
2508 uint16_t old, new;
2509 bool v;
2510
2511 /* We need to expose used array entries before checking used event. */
2512 smp_mb();
2513
2514 /* Always notify when queue is empty (when feature acknowledge) */
2515 if (vu_has_feature(dev, VIRTIO_F_NOTIFY_ON_EMPTY) &&
2516 !vq->inuse && vu_queue_empty(dev, vq)) {
2517 return true;
2518 }
2519
2520 if (!vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
2521 return !(vring_avail_flags(vq) & VRING_AVAIL_F_NO_INTERRUPT);
2522 }
2523
2524 v = vq->signalled_used_valid;
2525 vq->signalled_used_valid = true;
2526 old = vq->signalled_used;
2527 new = vq->signalled_used = vq->used_idx;
2528 return !v || vring_need_event(vring_get_used_event(vq), new, old);
2529 }
2530
2531 static void _vu_queue_notify(VuDev *dev, VuVirtq *vq, bool sync)
2532 {
2533 if (unlikely(dev->broken) ||
2534 unlikely(!vq->vring.avail)) {
2535 return;
2536 }
2537
2538 if (!vring_notify(dev, vq)) {
2539 DPRINT("skipped notify...\n");
2540 return;
2541 }
2542
2543 if (vq->call_fd < 0 &&
2544 vu_has_protocol_feature(dev,
2545 VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS) &&
2546 vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_BACKEND_REQ)) {
2547 VhostUserMsg vmsg = {
2548 .request = VHOST_USER_BACKEND_VRING_CALL,
2549 .flags = VHOST_USER_VERSION,
2550 .size = sizeof(vmsg.payload.state),
2551 .payload.state = {
2552 .index = vq - dev->vq,
2553 },
2554 };
2555 bool ack = sync &&
2556 vu_has_protocol_feature(dev,
2557 VHOST_USER_PROTOCOL_F_REPLY_ACK);
2558
2559 if (ack) {
2560 vmsg.flags |= VHOST_USER_NEED_REPLY_MASK;
2561 }
2562
2563 vu_message_write(dev, dev->backend_fd, &vmsg);
2564 if (ack) {
2565 vu_message_read_default(dev, dev->backend_fd, &vmsg);
2566 }
2567 return;
2568 }
2569
2570 if (eventfd_write(vq->call_fd, 1) < 0) {
2571 vu_panic(dev, "Error writing eventfd: %s", strerror(errno));
2572 }
2573 }
2574
2575 void vu_queue_notify(VuDev *dev, VuVirtq *vq)
2576 {
2577 _vu_queue_notify(dev, vq, false);
2578 }
2579
2580 void vu_queue_notify_sync(VuDev *dev, VuVirtq *vq)
2581 {
2582 _vu_queue_notify(dev, vq, true);
2583 }
2584
2585 void vu_config_change_msg(VuDev *dev)
2586 {
2587 VhostUserMsg vmsg = {
2588 .request = VHOST_USER_BACKEND_CONFIG_CHANGE_MSG,
2589 .flags = VHOST_USER_VERSION,
2590 };
2591
2592 vu_message_write(dev, dev->backend_fd, &vmsg);
2593 }
2594
2595 static inline void
2596 vring_used_flags_set_bit(VuVirtq *vq, int mask)
2597 {
2598 uint16_t *flags;
2599
2600 flags = (uint16_t *)((char*)vq->vring.used +
2601 offsetof(struct vring_used, flags));
2602 *flags = htole16(le16toh(*flags) | mask);
2603 }
2604
2605 static inline void
2606 vring_used_flags_unset_bit(VuVirtq *vq, int mask)
2607 {
2608 uint16_t *flags;
2609
2610 flags = (uint16_t *)((char*)vq->vring.used +
2611 offsetof(struct vring_used, flags));
2612 *flags = htole16(le16toh(*flags) & ~mask);
2613 }
2614
2615 static inline void
2616 vring_set_avail_event(VuVirtq *vq, uint16_t val)
2617 {
2618 uint16_t val_le = htole16(val);
2619
2620 if (!vq->notification) {
2621 return;
2622 }
2623
2624 memcpy(&vq->vring.used->ring[vq->vring.num], &val_le, sizeof(uint16_t));
2625 }
2626
2627 void
2628 vu_queue_set_notification(VuDev *dev, VuVirtq *vq, int enable)
2629 {
2630 vq->notification = enable;
2631 if (vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
2632 vring_set_avail_event(vq, vring_avail_idx(vq));
2633 } else if (enable) {
2634 vring_used_flags_unset_bit(vq, VRING_USED_F_NO_NOTIFY);
2635 } else {
2636 vring_used_flags_set_bit(vq, VRING_USED_F_NO_NOTIFY);
2637 }
2638 if (enable) {
2639 /* Expose avail event/used flags before caller checks the avail idx. */
2640 smp_mb();
2641 }
2642 }
2643
2644 static bool
2645 virtqueue_map_desc(VuDev *dev,
2646 unsigned int *p_num_sg, struct iovec *iov,
2647 unsigned int max_num_sg, bool is_write,
2648 uint64_t pa, size_t sz)
2649 {
2650 unsigned num_sg = *p_num_sg;
2651
2652 assert(num_sg <= max_num_sg);
2653
2654 if (!sz) {
2655 vu_panic(dev, "virtio: zero sized buffers are not allowed");
2656 return false;
2657 }
2658
2659 while (sz) {
2660 uint64_t len = sz;
2661
2662 if (num_sg == max_num_sg) {
2663 vu_panic(dev, "virtio: too many descriptors in indirect table");
2664 return false;
2665 }
2666
2667 iov[num_sg].iov_base = vu_gpa_to_va(dev, &len, pa);
2668 if (iov[num_sg].iov_base == NULL) {
2669 vu_panic(dev, "virtio: invalid address for buffers");
2670 return false;
2671 }
2672 iov[num_sg].iov_len = len;
2673 num_sg++;
2674 sz -= len;
2675 pa += len;
2676 }
2677
2678 *p_num_sg = num_sg;
2679 return true;
2680 }
2681
2682 static void *
2683 virtqueue_alloc_element(size_t sz,
2684 unsigned out_num, unsigned in_num)
2685 {
2686 VuVirtqElement *elem;
2687 size_t in_sg_ofs = ALIGN_UP(sz, __alignof__(elem->in_sg[0]));
2688 size_t out_sg_ofs = in_sg_ofs + in_num * sizeof(elem->in_sg[0]);
2689 size_t out_sg_end = out_sg_ofs + out_num * sizeof(elem->out_sg[0]);
2690
2691 assert(sz >= sizeof(VuVirtqElement));
2692 elem = malloc(out_sg_end);
2693 if (!elem) {
2694 DPRINT("%s: failed to malloc virtqueue element\n", __func__);
2695 return NULL;
2696 }
2697 elem->out_num = out_num;
2698 elem->in_num = in_num;
2699 elem->in_sg = (void *)elem + in_sg_ofs;
2700 elem->out_sg = (void *)elem + out_sg_ofs;
2701 return elem;
2702 }
2703
2704 static void *
2705 vu_queue_map_desc(VuDev *dev, VuVirtq *vq, unsigned int idx, size_t sz)
2706 {
2707 struct vring_desc *desc = vq->vring.desc;
2708 uint64_t desc_addr, read_len;
2709 unsigned int desc_len;
2710 unsigned int max = vq->vring.num;
2711 unsigned int i = idx;
2712 VuVirtqElement *elem;
2713 unsigned int out_num = 0, in_num = 0;
2714 struct iovec iov[VIRTQUEUE_MAX_SIZE];
2715 struct vring_desc desc_buf[VIRTQUEUE_MAX_SIZE];
2716 int rc;
2717
2718 if (le16toh(desc[i].flags) & VRING_DESC_F_INDIRECT) {
2719 if (le32toh(desc[i].len) % sizeof(struct vring_desc)) {
2720 vu_panic(dev, "Invalid size for indirect buffer table");
2721 return NULL;
2722 }
2723
2724 /* loop over the indirect descriptor table */
2725 desc_addr = le64toh(desc[i].addr);
2726 desc_len = le32toh(desc[i].len);
2727 max = desc_len / sizeof(struct vring_desc);
2728 read_len = desc_len;
2729 desc = vu_gpa_to_va(dev, &read_len, desc_addr);
2730 if (unlikely(desc && read_len != desc_len)) {
2731 /* Failed to use zero copy */
2732 desc = NULL;
2733 if (!virtqueue_read_indirect_desc(dev, desc_buf,
2734 desc_addr,
2735 desc_len)) {
2736 desc = desc_buf;
2737 }
2738 }
2739 if (!desc) {
2740 vu_panic(dev, "Invalid indirect buffer table");
2741 return NULL;
2742 }
2743 i = 0;
2744 }
2745
2746 /* Collect all the descriptors */
2747 do {
2748 if (le16toh(desc[i].flags) & VRING_DESC_F_WRITE) {
2749 if (!virtqueue_map_desc(dev, &in_num, iov + out_num,
2750 VIRTQUEUE_MAX_SIZE - out_num, true,
2751 le64toh(desc[i].addr),
2752 le32toh(desc[i].len))) {
2753 return NULL;
2754 }
2755 } else {
2756 if (in_num) {
2757 vu_panic(dev, "Incorrect order for descriptors");
2758 return NULL;
2759 }
2760 if (!virtqueue_map_desc(dev, &out_num, iov,
2761 VIRTQUEUE_MAX_SIZE, false,
2762 le64toh(desc[i].addr),
2763 le32toh(desc[i].len))) {
2764 return NULL;
2765 }
2766 }
2767
2768 /* If we've got too many, that implies a descriptor loop. */
2769 if ((in_num + out_num) > max) {
2770 vu_panic(dev, "Looped descriptor");
2771 return NULL;
2772 }
2773 rc = virtqueue_read_next_desc(dev, desc, i, max, &i);
2774 } while (rc == VIRTQUEUE_READ_DESC_MORE);
2775
2776 if (rc == VIRTQUEUE_READ_DESC_ERROR) {
2777 vu_panic(dev, "read descriptor error");
2778 return NULL;
2779 }
2780
2781 /* Now copy what we have collected and mapped */
2782 elem = virtqueue_alloc_element(sz, out_num, in_num);
2783 if (!elem) {
2784 return NULL;
2785 }
2786 elem->index = idx;
2787 for (i = 0; i < out_num; i++) {
2788 elem->out_sg[i] = iov[i];
2789 }
2790 for (i = 0; i < in_num; i++) {
2791 elem->in_sg[i] = iov[out_num + i];
2792 }
2793
2794 return elem;
2795 }
2796
2797 static int
2798 vu_queue_inflight_get(VuDev *dev, VuVirtq *vq, int desc_idx)
2799 {
2800 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) {
2801 return 0;
2802 }
2803
2804 if (unlikely(!vq->inflight)) {
2805 return -1;
2806 }
2807
2808 vq->inflight->desc[desc_idx].counter = vq->counter++;
2809 vq->inflight->desc[desc_idx].inflight = 1;
2810
2811 return 0;
2812 }
2813
2814 static int
2815 vu_queue_inflight_pre_put(VuDev *dev, VuVirtq *vq, int desc_idx)
2816 {
2817 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) {
2818 return 0;
2819 }
2820
2821 if (unlikely(!vq->inflight)) {
2822 return -1;
2823 }
2824
2825 vq->inflight->last_batch_head = desc_idx;
2826
2827 return 0;
2828 }
2829
2830 static int
2831 vu_queue_inflight_post_put(VuDev *dev, VuVirtq *vq, int desc_idx)
2832 {
2833 if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) {
2834 return 0;
2835 }
2836
2837 if (unlikely(!vq->inflight)) {
2838 return -1;
2839 }
2840
2841 barrier();
2842
2843 vq->inflight->desc[desc_idx].inflight = 0;
2844
2845 barrier();
2846
2847 vq->inflight->used_idx = vq->used_idx;
2848
2849 return 0;
2850 }
2851
2852 void *
2853 vu_queue_pop(VuDev *dev, VuVirtq *vq, size_t sz)
2854 {
2855 int i;
2856 unsigned int head;
2857 VuVirtqElement *elem;
2858
2859 if (unlikely(dev->broken) ||
2860 unlikely(!vq->vring.avail)) {
2861 return NULL;
2862 }
2863
2864 if (unlikely(vq->resubmit_list && vq->resubmit_num > 0)) {
2865 i = (--vq->resubmit_num);
2866 elem = vu_queue_map_desc(dev, vq, vq->resubmit_list[i].index, sz);
2867
2868 if (!vq->resubmit_num) {
2869 free(vq->resubmit_list);
2870 vq->resubmit_list = NULL;
2871 }
2872
2873 return elem;
2874 }
2875
2876 if (vu_queue_empty(dev, vq)) {
2877 return NULL;
2878 }
2879 /*
2880 * Needed after virtio_queue_empty(), see comment in
2881 * virtqueue_num_heads().
2882 */
2883 smp_rmb();
2884
2885 if (vq->inuse >= vq->vring.num) {
2886 vu_panic(dev, "Virtqueue size exceeded");
2887 return NULL;
2888 }
2889
2890 if (!virtqueue_get_head(dev, vq, vq->last_avail_idx++, &head)) {
2891 return NULL;
2892 }
2893
2894 if (vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
2895 vring_set_avail_event(vq, vq->last_avail_idx);
2896 }
2897
2898 elem = vu_queue_map_desc(dev, vq, head, sz);
2899
2900 if (!elem) {
2901 return NULL;
2902 }
2903
2904 vq->inuse++;
2905
2906 vu_queue_inflight_get(dev, vq, head);
2907
2908 return elem;
2909 }
2910
2911 static void
2912 vu_queue_detach_element(VuDev *dev, VuVirtq *vq, VuVirtqElement *elem,
2913 size_t len)
2914 {
2915 vq->inuse--;
2916 /* unmap, when DMA support is added */
2917 }
2918
2919 void
2920 vu_queue_unpop(VuDev *dev, VuVirtq *vq, VuVirtqElement *elem,
2921 size_t len)
2922 {
2923 vq->last_avail_idx--;
2924 vu_queue_detach_element(dev, vq, elem, len);
2925 }
2926
2927 bool
2928 vu_queue_rewind(VuDev *dev, VuVirtq *vq, unsigned int num)
2929 {
2930 if (num > vq->inuse) {
2931 return false;
2932 }
2933 vq->last_avail_idx -= num;
2934 vq->inuse -= num;
2935 return true;
2936 }
2937
2938 static inline
2939 void vring_used_write(VuDev *dev, VuVirtq *vq,
2940 struct vring_used_elem *uelem, int i)
2941 {
2942 struct vring_used *used = vq->vring.used;
2943
2944 used->ring[i] = *uelem;
2945 vu_log_write(dev, vq->vring.log_guest_addr +
2946 offsetof(struct vring_used, ring[i]),
2947 sizeof(used->ring[i]));
2948 }
2949
2950
2951 static void
2952 vu_log_queue_fill(VuDev *dev, VuVirtq *vq,
2953 const VuVirtqElement *elem,
2954 unsigned int len)
2955 {
2956 struct vring_desc *desc = vq->vring.desc;
2957 unsigned int i, max, min, desc_len;
2958 uint64_t desc_addr, read_len;
2959 struct vring_desc desc_buf[VIRTQUEUE_MAX_SIZE];
2960 unsigned num_bufs = 0;
2961
2962 max = vq->vring.num;
2963 i = elem->index;
2964
2965 if (le16toh(desc[i].flags) & VRING_DESC_F_INDIRECT) {
2966 if (le32toh(desc[i].len) % sizeof(struct vring_desc)) {
2967 vu_panic(dev, "Invalid size for indirect buffer table");
2968 return;
2969 }
2970
2971 /* loop over the indirect descriptor table */
2972 desc_addr = le64toh(desc[i].addr);
2973 desc_len = le32toh(desc[i].len);
2974 max = desc_len / sizeof(struct vring_desc);
2975 read_len = desc_len;
2976 desc = vu_gpa_to_va(dev, &read_len, desc_addr);
2977 if (unlikely(desc && read_len != desc_len)) {
2978 /* Failed to use zero copy */
2979 desc = NULL;
2980 if (!virtqueue_read_indirect_desc(dev, desc_buf,
2981 desc_addr,
2982 desc_len)) {
2983 desc = desc_buf;
2984 }
2985 }
2986 if (!desc) {
2987 vu_panic(dev, "Invalid indirect buffer table");
2988 return;
2989 }
2990 i = 0;
2991 }
2992
2993 do {
2994 if (++num_bufs > max) {
2995 vu_panic(dev, "Looped descriptor");
2996 return;
2997 }
2998
2999 if (le16toh(desc[i].flags) & VRING_DESC_F_WRITE) {
3000 min = MIN(le32toh(desc[i].len), len);
3001 vu_log_write(dev, le64toh(desc[i].addr), min);
3002 len -= min;
3003 }
3004
3005 } while (len > 0 &&
3006 (virtqueue_read_next_desc(dev, desc, i, max, &i)
3007 == VIRTQUEUE_READ_DESC_MORE));
3008 }
3009
3010 void
3011 vu_queue_fill(VuDev *dev, VuVirtq *vq,
3012 const VuVirtqElement *elem,
3013 unsigned int len, unsigned int idx)
3014 {
3015 struct vring_used_elem uelem;
3016
3017 if (unlikely(dev->broken) ||
3018 unlikely(!vq->vring.avail)) {
3019 return;
3020 }
3021
3022 vu_log_queue_fill(dev, vq, elem, len);
3023
3024 idx = (idx + vq->used_idx) % vq->vring.num;
3025
3026 uelem.id = htole32(elem->index);
3027 uelem.len = htole32(len);
3028 vring_used_write(dev, vq, &uelem, idx);
3029 }
3030
3031 static inline
3032 void vring_used_idx_set(VuDev *dev, VuVirtq *vq, uint16_t val)
3033 {
3034 vq->vring.used->idx = htole16(val);
3035 vu_log_write(dev,
3036 vq->vring.log_guest_addr + offsetof(struct vring_used, idx),
3037 sizeof(vq->vring.used->idx));
3038
3039 vq->used_idx = val;
3040 }
3041
3042 void
3043 vu_queue_flush(VuDev *dev, VuVirtq *vq, unsigned int count)
3044 {
3045 uint16_t old, new;
3046
3047 if (unlikely(dev->broken) ||
3048 unlikely(!vq->vring.avail)) {
3049 return;
3050 }
3051
3052 /* Make sure buffer is written before we update index. */
3053 smp_wmb();
3054
3055 old = vq->used_idx;
3056 new = old + count;
3057 vring_used_idx_set(dev, vq, new);
3058 vq->inuse -= count;
3059 if (unlikely((int16_t)(new - vq->signalled_used) < (uint16_t)(new - old))) {
3060 vq->signalled_used_valid = false;
3061 }
3062 }
3063
3064 void
3065 vu_queue_push(VuDev *dev, VuVirtq *vq,
3066 const VuVirtqElement *elem, unsigned int len)
3067 {
3068 vu_queue_fill(dev, vq, elem, len, 0);
3069 vu_queue_inflight_pre_put(dev, vq, elem->index);
3070 vu_queue_flush(dev, vq, 1);
3071 vu_queue_inflight_post_put(dev, vq, elem->index);
3072 }
QEMU mirror