4 * Copyright IBM, Corp. 2007
5 * Copyright (c) 2016 Red Hat, Inc.
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Marc-André Lureau <mlureau@redhat.com>
10 * Victor Kaplansky <victork@redhat.com>
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.
16 /* this code avoids GLib dependency */
25 #include <sys/types.h>
26 #include <sys/socket.h>
27 #include <sys/eventfd.h>
29 #include "qemu/compiler.h"
31 #if defined(__linux__)
32 #include <sys/syscall.h>
34 #include <sys/ioctl.h>
35 #include <linux/vhost.h>
37 #ifdef __NR_userfaultfd
38 #include <linux/userfaultfd.h>
43 #include "qemu/atomic.h"
44 #include "qemu/osdep.h"
45 #include "qemu/memfd.h"
47 #include "libvhost-user.h"
49 /* usually provided by GLib */
51 #define MIN(x, y) ({ \
52 typeof(x) _min1 = (x); \
53 typeof(y) _min2 = (y); \
54 (void) (&_min1 == &_min2); \
55 _min1 < _min2 ? _min1 : _min2; })
58 /* Round number down to multiple */
59 #define ALIGN_DOWN(n, m) ((n) / (m) * (m))
61 /* Round number up to multiple */
62 #define ALIGN_UP(n, m) ALIGN_DOWN((n) + (m) - 1, (m))
64 /* Align each region to cache line size in inflight buffer */
65 #define INFLIGHT_ALIGNMENT 64
67 /* The version of inflight buffer */
68 #define INFLIGHT_VERSION 1
70 #define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
72 /* The version of the protocol we support */
73 #define VHOST_USER_VERSION 1
74 #define LIBVHOST_USER_DEBUG 0
78 if (LIBVHOST_USER_DEBUG) { \
79 fprintf(stderr, __VA_ARGS__); \
84 bool has_feature(uint64_t features
, unsigned int fbit
)
87 return !!(features
& (1ULL << fbit
));
91 bool vu_has_feature(VuDev
*dev
,
94 return has_feature(dev
->features
, fbit
);
97 static inline bool vu_has_protocol_feature(VuDev
*dev
, unsigned int fbit
)
99 return has_feature(dev
->protocol_features
, fbit
);
103 vu_request_to_string(unsigned int req
)
105 #define REQ(req) [req] = #req
106 static const char *vu_request_str
[] = {
107 REQ(VHOST_USER_NONE
),
108 REQ(VHOST_USER_GET_FEATURES
),
109 REQ(VHOST_USER_SET_FEATURES
),
110 REQ(VHOST_USER_SET_OWNER
),
111 REQ(VHOST_USER_RESET_OWNER
),
112 REQ(VHOST_USER_SET_MEM_TABLE
),
113 REQ(VHOST_USER_SET_LOG_BASE
),
114 REQ(VHOST_USER_SET_LOG_FD
),
115 REQ(VHOST_USER_SET_VRING_NUM
),
116 REQ(VHOST_USER_SET_VRING_ADDR
),
117 REQ(VHOST_USER_SET_VRING_BASE
),
118 REQ(VHOST_USER_GET_VRING_BASE
),
119 REQ(VHOST_USER_SET_VRING_KICK
),
120 REQ(VHOST_USER_SET_VRING_CALL
),
121 REQ(VHOST_USER_SET_VRING_ERR
),
122 REQ(VHOST_USER_GET_PROTOCOL_FEATURES
),
123 REQ(VHOST_USER_SET_PROTOCOL_FEATURES
),
124 REQ(VHOST_USER_GET_QUEUE_NUM
),
125 REQ(VHOST_USER_SET_VRING_ENABLE
),
126 REQ(VHOST_USER_SEND_RARP
),
127 REQ(VHOST_USER_NET_SET_MTU
),
128 REQ(VHOST_USER_SET_SLAVE_REQ_FD
),
129 REQ(VHOST_USER_IOTLB_MSG
),
130 REQ(VHOST_USER_SET_VRING_ENDIAN
),
131 REQ(VHOST_USER_GET_CONFIG
),
132 REQ(VHOST_USER_SET_CONFIG
),
133 REQ(VHOST_USER_POSTCOPY_ADVISE
),
134 REQ(VHOST_USER_POSTCOPY_LISTEN
),
135 REQ(VHOST_USER_POSTCOPY_END
),
136 REQ(VHOST_USER_GET_INFLIGHT_FD
),
137 REQ(VHOST_USER_SET_INFLIGHT_FD
),
138 REQ(VHOST_USER_GPU_SET_SOCKET
),
143 if (req
< VHOST_USER_MAX
) {
144 return vu_request_str
[req
];
150 static void GCC_FMT_ATTR(2, 3)
151 vu_panic(VuDev
*dev
, const char *msg
, ...)
157 if (vasprintf(&buf
, msg
, ap
) < 0) {
163 dev
->panic(dev
, buf
);
166 /* FIXME: find a way to call virtio_error? */
169 /* Translate guest physical address to our virtual address. */
171 vu_gpa_to_va(VuDev
*dev
, uint64_t *plen
, uint64_t guest_addr
)
179 /* Find matching memory region. */
180 for (i
= 0; i
< dev
->nregions
; i
++) {
181 VuDevRegion
*r
= &dev
->regions
[i
];
183 if ((guest_addr
>= r
->gpa
) && (guest_addr
< (r
->gpa
+ r
->size
))) {
184 if ((guest_addr
+ *plen
) > (r
->gpa
+ r
->size
)) {
185 *plen
= r
->gpa
+ r
->size
- guest_addr
;
187 return (void *)(uintptr_t)
188 guest_addr
- r
->gpa
+ r
->mmap_addr
+ r
->mmap_offset
;
195 /* Translate qemu virtual address to our virtual address. */
197 qva_to_va(VuDev
*dev
, uint64_t qemu_addr
)
201 /* Find matching memory region. */
202 for (i
= 0; i
< dev
->nregions
; i
++) {
203 VuDevRegion
*r
= &dev
->regions
[i
];
205 if ((qemu_addr
>= r
->qva
) && (qemu_addr
< (r
->qva
+ r
->size
))) {
206 return (void *)(uintptr_t)
207 qemu_addr
- r
->qva
+ r
->mmap_addr
+ r
->mmap_offset
;
215 vmsg_close_fds(VhostUserMsg
*vmsg
)
219 for (i
= 0; i
< vmsg
->fd_num
; i
++) {
224 /* Set reply payload.u64 and clear request flags and fd_num */
225 static void vmsg_set_reply_u64(VhostUserMsg
*vmsg
, uint64_t val
)
227 vmsg
->flags
= 0; /* defaults will be set by vu_send_reply() */
228 vmsg
->size
= sizeof(vmsg
->payload
.u64
);
229 vmsg
->payload
.u64
= val
;
233 /* A test to see if we have userfault available */
237 #if defined(__linux__) && defined(__NR_userfaultfd) &&\
238 defined(UFFD_FEATURE_MISSING_SHMEM) &&\
239 defined(UFFD_FEATURE_MISSING_HUGETLBFS)
240 /* Now test the kernel we're running on really has the features */
241 int ufd
= syscall(__NR_userfaultfd
, O_CLOEXEC
| O_NONBLOCK
);
242 struct uffdio_api api_struct
;
247 api_struct
.api
= UFFD_API
;
248 api_struct
.features
= UFFD_FEATURE_MISSING_SHMEM
|
249 UFFD_FEATURE_MISSING_HUGETLBFS
;
250 if (ioctl(ufd
, UFFDIO_API
, &api_struct
)) {
263 vu_message_read(VuDev
*dev
, int conn_fd
, VhostUserMsg
*vmsg
)
265 char control
[CMSG_SPACE(VHOST_MEMORY_MAX_NREGIONS
* sizeof(int))] = { };
267 .iov_base
= (char *)vmsg
,
268 .iov_len
= VHOST_USER_HDR_SIZE
,
270 struct msghdr msg
= {
273 .msg_control
= control
,
274 .msg_controllen
= sizeof(control
),
277 struct cmsghdr
*cmsg
;
281 rc
= recvmsg(conn_fd
, &msg
, 0);
282 } while (rc
< 0 && (errno
== EINTR
|| errno
== EAGAIN
));
285 vu_panic(dev
, "Error while recvmsg: %s", strerror(errno
));
290 for (cmsg
= CMSG_FIRSTHDR(&msg
);
292 cmsg
= CMSG_NXTHDR(&msg
, cmsg
))
294 if (cmsg
->cmsg_level
== SOL_SOCKET
&& cmsg
->cmsg_type
== SCM_RIGHTS
) {
295 fd_size
= cmsg
->cmsg_len
- CMSG_LEN(0);
296 vmsg
->fd_num
= fd_size
/ sizeof(int);
297 memcpy(vmsg
->fds
, CMSG_DATA(cmsg
), fd_size
);
302 if (vmsg
->size
> sizeof(vmsg
->payload
)) {
304 "Error: too big message request: %d, size: vmsg->size: %u, "
305 "while sizeof(vmsg->payload) = %zu\n",
306 vmsg
->request
, vmsg
->size
, sizeof(vmsg
->payload
));
312 rc
= read(conn_fd
, &vmsg
->payload
, vmsg
->size
);
313 } while (rc
< 0 && (errno
== EINTR
|| errno
== EAGAIN
));
316 vu_panic(dev
, "Error while reading: %s", strerror(errno
));
320 assert(rc
== vmsg
->size
);
326 vmsg_close_fds(vmsg
);
332 vu_message_write(VuDev
*dev
, int conn_fd
, VhostUserMsg
*vmsg
)
335 uint8_t *p
= (uint8_t *)vmsg
;
336 char control
[CMSG_SPACE(VHOST_MEMORY_MAX_NREGIONS
* sizeof(int))] = { };
338 .iov_base
= (char *)vmsg
,
339 .iov_len
= VHOST_USER_HDR_SIZE
,
341 struct msghdr msg
= {
344 .msg_control
= control
,
346 struct cmsghdr
*cmsg
;
348 memset(control
, 0, sizeof(control
));
349 assert(vmsg
->fd_num
<= VHOST_MEMORY_MAX_NREGIONS
);
350 if (vmsg
->fd_num
> 0) {
351 size_t fdsize
= vmsg
->fd_num
* sizeof(int);
352 msg
.msg_controllen
= CMSG_SPACE(fdsize
);
353 cmsg
= CMSG_FIRSTHDR(&msg
);
354 cmsg
->cmsg_len
= CMSG_LEN(fdsize
);
355 cmsg
->cmsg_level
= SOL_SOCKET
;
356 cmsg
->cmsg_type
= SCM_RIGHTS
;
357 memcpy(CMSG_DATA(cmsg
), vmsg
->fds
, fdsize
);
359 msg
.msg_controllen
= 0;
363 rc
= sendmsg(conn_fd
, &msg
, 0);
364 } while (rc
< 0 && (errno
== EINTR
|| errno
== EAGAIN
));
369 rc
= write(conn_fd
, vmsg
->data
, vmsg
->size
);
371 rc
= write(conn_fd
, p
+ VHOST_USER_HDR_SIZE
, vmsg
->size
);
373 } while (rc
< 0 && (errno
== EINTR
|| errno
== EAGAIN
));
377 vu_panic(dev
, "Error while writing: %s", strerror(errno
));
385 vu_send_reply(VuDev
*dev
, int conn_fd
, VhostUserMsg
*vmsg
)
387 /* Set the version in the flags when sending the reply */
388 vmsg
->flags
&= ~VHOST_USER_VERSION_MASK
;
389 vmsg
->flags
|= VHOST_USER_VERSION
;
390 vmsg
->flags
|= VHOST_USER_REPLY_MASK
;
392 return vu_message_write(dev
, conn_fd
, vmsg
);
396 vu_process_message_reply(VuDev
*dev
, const VhostUserMsg
*vmsg
)
398 VhostUserMsg msg_reply
;
400 if ((vmsg
->flags
& VHOST_USER_NEED_REPLY_MASK
) == 0) {
404 if (!vu_message_read(dev
, dev
->slave_fd
, &msg_reply
)) {
408 if (msg_reply
.request
!= vmsg
->request
) {
409 DPRINT("Received unexpected msg type. Expected %d received %d",
410 vmsg
->request
, msg_reply
.request
);
414 return msg_reply
.payload
.u64
== 0;
417 /* Kick the log_call_fd if required. */
419 vu_log_kick(VuDev
*dev
)
421 if (dev
->log_call_fd
!= -1) {
422 DPRINT("Kicking the QEMU's log...\n");
423 if (eventfd_write(dev
->log_call_fd
, 1) < 0) {
424 vu_panic(dev
, "Error writing eventfd: %s", strerror(errno
));
430 vu_log_page(uint8_t *log_table
, uint64_t page
)
432 DPRINT("Logged dirty guest page: %"PRId64
"\n", page
);
433 atomic_or(&log_table
[page
/ 8], 1 << (page
% 8));
437 vu_log_write(VuDev
*dev
, uint64_t address
, uint64_t length
)
441 if (!(dev
->features
& (1ULL << VHOST_F_LOG_ALL
)) ||
442 !dev
->log_table
|| !length
) {
446 assert(dev
->log_size
> ((address
+ length
- 1) / VHOST_LOG_PAGE
/ 8));
448 page
= address
/ VHOST_LOG_PAGE
;
449 while (page
* VHOST_LOG_PAGE
< address
+ length
) {
450 vu_log_page(dev
->log_table
, page
);
458 vu_kick_cb(VuDev
*dev
, int condition
, void *data
)
460 int index
= (intptr_t)data
;
461 VuVirtq
*vq
= &dev
->vq
[index
];
462 int sock
= vq
->kick_fd
;
466 rc
= eventfd_read(sock
, &kick_data
);
468 vu_panic(dev
, "kick eventfd_read(): %s", strerror(errno
));
469 dev
->remove_watch(dev
, dev
->vq
[index
].kick_fd
);
471 DPRINT("Got kick_data: %016"PRIx64
" handler:%p idx:%d\n",
472 kick_data
, vq
->handler
, index
);
474 vq
->handler(dev
, index
);
480 vu_get_features_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
483 1ULL << VHOST_F_LOG_ALL
|
484 1ULL << VHOST_USER_F_PROTOCOL_FEATURES
;
486 if (dev
->iface
->get_features
) {
487 vmsg
->payload
.u64
|= dev
->iface
->get_features(dev
);
490 vmsg
->size
= sizeof(vmsg
->payload
.u64
);
493 DPRINT("Sending back to guest u64: 0x%016"PRIx64
"\n", vmsg
->payload
.u64
);
499 vu_set_enable_all_rings(VuDev
*dev
, bool enabled
)
503 for (i
= 0; i
< dev
->max_queues
; i
++) {
504 dev
->vq
[i
].enable
= enabled
;
509 vu_set_features_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
511 DPRINT("u64: 0x%016"PRIx64
"\n", vmsg
->payload
.u64
);
513 dev
->features
= vmsg
->payload
.u64
;
515 if (!(dev
->features
& VHOST_USER_F_PROTOCOL_FEATURES
)) {
516 vu_set_enable_all_rings(dev
, true);
519 if (dev
->iface
->set_features
) {
520 dev
->iface
->set_features(dev
, dev
->features
);
527 vu_set_owner_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
533 vu_close_log(VuDev
*dev
)
535 if (dev
->log_table
) {
536 if (munmap(dev
->log_table
, dev
->log_size
) != 0) {
537 perror("close log munmap() error");
540 dev
->log_table
= NULL
;
542 if (dev
->log_call_fd
!= -1) {
543 close(dev
->log_call_fd
);
544 dev
->log_call_fd
= -1;
549 vu_reset_device_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
551 vu_set_enable_all_rings(dev
, false);
557 vu_set_mem_table_exec_postcopy(VuDev
*dev
, VhostUserMsg
*vmsg
)
560 VhostUserMemory m
= vmsg
->payload
.memory
, *memory
= &m
;
561 dev
->nregions
= memory
->nregions
;
563 DPRINT("Nregions: %d\n", memory
->nregions
);
564 for (i
= 0; i
< dev
->nregions
; i
++) {
566 VhostUserMemoryRegion
*msg_region
= &memory
->regions
[i
];
567 VuDevRegion
*dev_region
= &dev
->regions
[i
];
569 DPRINT("Region %d\n", i
);
570 DPRINT(" guest_phys_addr: 0x%016"PRIx64
"\n",
571 msg_region
->guest_phys_addr
);
572 DPRINT(" memory_size: 0x%016"PRIx64
"\n",
573 msg_region
->memory_size
);
574 DPRINT(" userspace_addr 0x%016"PRIx64
"\n",
575 msg_region
->userspace_addr
);
576 DPRINT(" mmap_offset 0x%016"PRIx64
"\n",
577 msg_region
->mmap_offset
);
579 dev_region
->gpa
= msg_region
->guest_phys_addr
;
580 dev_region
->size
= msg_region
->memory_size
;
581 dev_region
->qva
= msg_region
->userspace_addr
;
582 dev_region
->mmap_offset
= msg_region
->mmap_offset
;
584 /* We don't use offset argument of mmap() since the
585 * mapped address has to be page aligned, and we use huge
587 * In postcopy we're using PROT_NONE here to catch anyone
588 * accessing it before we userfault
590 mmap_addr
= mmap(0, dev_region
->size
+ dev_region
->mmap_offset
,
591 PROT_NONE
, MAP_SHARED
,
594 if (mmap_addr
== MAP_FAILED
) {
595 vu_panic(dev
, "region mmap error: %s", strerror(errno
));
597 dev_region
->mmap_addr
= (uint64_t)(uintptr_t)mmap_addr
;
598 DPRINT(" mmap_addr: 0x%016"PRIx64
"\n",
599 dev_region
->mmap_addr
);
602 /* Return the address to QEMU so that it can translate the ufd
603 * fault addresses back.
605 msg_region
->userspace_addr
= (uintptr_t)(mmap_addr
+
606 dev_region
->mmap_offset
);
610 /* Send the message back to qemu with the addresses filled in */
612 if (!vu_send_reply(dev
, dev
->sock
, vmsg
)) {
613 vu_panic(dev
, "failed to respond to set-mem-table for postcopy");
617 /* Wait for QEMU to confirm that it's registered the handler for the
620 if (!vu_message_read(dev
, dev
->sock
, vmsg
) ||
621 vmsg
->size
!= sizeof(vmsg
->payload
.u64
) ||
622 vmsg
->payload
.u64
!= 0) {
623 vu_panic(dev
, "failed to receive valid ack for postcopy set-mem-table");
627 /* OK, now we can go and register the memory and generate faults */
628 for (i
= 0; i
< dev
->nregions
; i
++) {
629 VuDevRegion
*dev_region
= &dev
->regions
[i
];
631 #ifdef UFFDIO_REGISTER
632 /* We should already have an open ufd. Mark each memory
634 * Discard any mapping we have here; note I can't use MADV_REMOVE
635 * or fallocate to make the hole since I don't want to lose
636 * data that's already arrived in the shared process.
637 * TODO: How to do hugepage
639 ret
= madvise((void *)(uintptr_t)dev_region
->mmap_addr
,
640 dev_region
->size
+ dev_region
->mmap_offset
,
644 "%s: Failed to madvise(DONTNEED) region %d: %s\n",
645 __func__
, i
, strerror(errno
));
647 /* Turn off transparent hugepages so we dont get lose wakeups
648 * in neighbouring pages.
649 * TODO: Turn this backon later.
651 ret
= madvise((void *)(uintptr_t)dev_region
->mmap_addr
,
652 dev_region
->size
+ dev_region
->mmap_offset
,
655 /* Note: This can happen legally on kernels that are configured
656 * without madvise'able hugepages
659 "%s: Failed to madvise(NOHUGEPAGE) region %d: %s\n",
660 __func__
, i
, strerror(errno
));
662 struct uffdio_register reg_struct
;
663 reg_struct
.range
.start
= (uintptr_t)dev_region
->mmap_addr
;
664 reg_struct
.range
.len
= dev_region
->size
+ dev_region
->mmap_offset
;
665 reg_struct
.mode
= UFFDIO_REGISTER_MODE_MISSING
;
667 if (ioctl(dev
->postcopy_ufd
, UFFDIO_REGISTER
, ®_struct
)) {
668 vu_panic(dev
, "%s: Failed to userfault region %d "
669 "@%" PRIx64
" + size:%" PRIx64
670 " offset: %" PRIx64
": (ufd=%d)%s\n",
672 dev_region
->mmap_addr
,
673 dev_region
->size
, dev_region
->mmap_offset
,
674 dev
->postcopy_ufd
, strerror(errno
));
677 if (!(reg_struct
.ioctls
& ((__u64
)1 << _UFFDIO_COPY
))) {
678 vu_panic(dev
, "%s Region (%d) doesn't support COPY",
682 DPRINT("%s: region %d: Registered userfault for %"
683 PRIx64
" + %" PRIx64
"\n", __func__
, i
,
684 (uint64_t)reg_struct
.range
.start
,
685 (uint64_t)reg_struct
.range
.len
);
686 /* Now it's registered we can let the client at it */
687 if (mprotect((void *)(uintptr_t)dev_region
->mmap_addr
,
688 dev_region
->size
+ dev_region
->mmap_offset
,
689 PROT_READ
| PROT_WRITE
)) {
690 vu_panic(dev
, "failed to mprotect region %d for postcopy (%s)",
694 /* TODO: Stash 'zero' support flags somewhere */
702 vu_set_mem_table_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
705 VhostUserMemory m
= vmsg
->payload
.memory
, *memory
= &m
;
707 for (i
= 0; i
< dev
->nregions
; i
++) {
708 VuDevRegion
*r
= &dev
->regions
[i
];
709 void *m
= (void *) (uintptr_t) r
->mmap_addr
;
712 munmap(m
, r
->size
+ r
->mmap_offset
);
715 dev
->nregions
= memory
->nregions
;
717 if (dev
->postcopy_listening
) {
718 return vu_set_mem_table_exec_postcopy(dev
, vmsg
);
721 DPRINT("Nregions: %d\n", memory
->nregions
);
722 for (i
= 0; i
< dev
->nregions
; i
++) {
724 VhostUserMemoryRegion
*msg_region
= &memory
->regions
[i
];
725 VuDevRegion
*dev_region
= &dev
->regions
[i
];
727 DPRINT("Region %d\n", i
);
728 DPRINT(" guest_phys_addr: 0x%016"PRIx64
"\n",
729 msg_region
->guest_phys_addr
);
730 DPRINT(" memory_size: 0x%016"PRIx64
"\n",
731 msg_region
->memory_size
);
732 DPRINT(" userspace_addr 0x%016"PRIx64
"\n",
733 msg_region
->userspace_addr
);
734 DPRINT(" mmap_offset 0x%016"PRIx64
"\n",
735 msg_region
->mmap_offset
);
737 dev_region
->gpa
= msg_region
->guest_phys_addr
;
738 dev_region
->size
= msg_region
->memory_size
;
739 dev_region
->qva
= msg_region
->userspace_addr
;
740 dev_region
->mmap_offset
= msg_region
->mmap_offset
;
742 /* We don't use offset argument of mmap() since the
743 * mapped address has to be page aligned, and we use huge
745 mmap_addr
= mmap(0, dev_region
->size
+ dev_region
->mmap_offset
,
746 PROT_READ
| PROT_WRITE
, MAP_SHARED
,
749 if (mmap_addr
== MAP_FAILED
) {
750 vu_panic(dev
, "region mmap error: %s", strerror(errno
));
752 dev_region
->mmap_addr
= (uint64_t)(uintptr_t)mmap_addr
;
753 DPRINT(" mmap_addr: 0x%016"PRIx64
"\n",
754 dev_region
->mmap_addr
);
764 vu_set_log_base_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
767 uint64_t log_mmap_size
, log_mmap_offset
;
770 if (vmsg
->fd_num
!= 1 ||
771 vmsg
->size
!= sizeof(vmsg
->payload
.log
)) {
772 vu_panic(dev
, "Invalid log_base message");
777 log_mmap_offset
= vmsg
->payload
.log
.mmap_offset
;
778 log_mmap_size
= vmsg
->payload
.log
.mmap_size
;
779 DPRINT("Log mmap_offset: %"PRId64
"\n", log_mmap_offset
);
780 DPRINT("Log mmap_size: %"PRId64
"\n", log_mmap_size
);
782 rc
= mmap(0, log_mmap_size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
, fd
,
785 if (rc
== MAP_FAILED
) {
786 perror("log mmap error");
789 if (dev
->log_table
) {
790 munmap(dev
->log_table
, dev
->log_size
);
793 dev
->log_size
= log_mmap_size
;
795 vmsg
->size
= sizeof(vmsg
->payload
.u64
);
802 vu_set_log_fd_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
804 if (vmsg
->fd_num
!= 1) {
805 vu_panic(dev
, "Invalid log_fd message");
809 if (dev
->log_call_fd
!= -1) {
810 close(dev
->log_call_fd
);
812 dev
->log_call_fd
= vmsg
->fds
[0];
813 DPRINT("Got log_call_fd: %d\n", vmsg
->fds
[0]);
819 vu_set_vring_num_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
821 unsigned int index
= vmsg
->payload
.state
.index
;
822 unsigned int num
= vmsg
->payload
.state
.num
;
824 DPRINT("State.index: %d\n", index
);
825 DPRINT("State.num: %d\n", num
);
826 dev
->vq
[index
].vring
.num
= num
;
832 vu_set_vring_addr_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
834 struct vhost_vring_addr addr
= vmsg
->payload
.addr
, *vra
= &addr
;
835 unsigned int index
= vra
->index
;
836 VuVirtq
*vq
= &dev
->vq
[index
];
838 DPRINT("vhost_vring_addr:\n");
839 DPRINT(" index: %d\n", vra
->index
);
840 DPRINT(" flags: %d\n", vra
->flags
);
841 DPRINT(" desc_user_addr: 0x%016" PRIx64
"\n", vra
->desc_user_addr
);
842 DPRINT(" used_user_addr: 0x%016" PRIx64
"\n", vra
->used_user_addr
);
843 DPRINT(" avail_user_addr: 0x%016" PRIx64
"\n", vra
->avail_user_addr
);
844 DPRINT(" log_guest_addr: 0x%016" PRIx64
"\n", vra
->log_guest_addr
);
846 vq
->vring
.flags
= vra
->flags
;
847 vq
->vring
.desc
= qva_to_va(dev
, vra
->desc_user_addr
);
848 vq
->vring
.used
= qva_to_va(dev
, vra
->used_user_addr
);
849 vq
->vring
.avail
= qva_to_va(dev
, vra
->avail_user_addr
);
850 vq
->vring
.log_guest_addr
= vra
->log_guest_addr
;
852 DPRINT("Setting virtq addresses:\n");
853 DPRINT(" vring_desc at %p\n", vq
->vring
.desc
);
854 DPRINT(" vring_used at %p\n", vq
->vring
.used
);
855 DPRINT(" vring_avail at %p\n", vq
->vring
.avail
);
857 if (!(vq
->vring
.desc
&& vq
->vring
.used
&& vq
->vring
.avail
)) {
858 vu_panic(dev
, "Invalid vring_addr message");
862 vq
->used_idx
= vq
->vring
.used
->idx
;
864 if (vq
->last_avail_idx
!= vq
->used_idx
) {
865 bool resume
= dev
->iface
->queue_is_processed_in_order
&&
866 dev
->iface
->queue_is_processed_in_order(dev
, index
);
868 DPRINT("Last avail index != used index: %u != %u%s\n",
869 vq
->last_avail_idx
, vq
->used_idx
,
870 resume
? ", resuming" : "");
873 vq
->shadow_avail_idx
= vq
->last_avail_idx
= vq
->used_idx
;
881 vu_set_vring_base_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
883 unsigned int index
= vmsg
->payload
.state
.index
;
884 unsigned int num
= vmsg
->payload
.state
.num
;
886 DPRINT("State.index: %d\n", index
);
887 DPRINT("State.num: %d\n", num
);
888 dev
->vq
[index
].shadow_avail_idx
= dev
->vq
[index
].last_avail_idx
= num
;
894 vu_get_vring_base_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
896 unsigned int index
= vmsg
->payload
.state
.index
;
898 DPRINT("State.index: %d\n", index
);
899 vmsg
->payload
.state
.num
= dev
->vq
[index
].last_avail_idx
;
900 vmsg
->size
= sizeof(vmsg
->payload
.state
);
902 dev
->vq
[index
].started
= false;
903 if (dev
->iface
->queue_set_started
) {
904 dev
->iface
->queue_set_started(dev
, index
, false);
907 if (dev
->vq
[index
].call_fd
!= -1) {
908 close(dev
->vq
[index
].call_fd
);
909 dev
->vq
[index
].call_fd
= -1;
911 if (dev
->vq
[index
].kick_fd
!= -1) {
912 dev
->remove_watch(dev
, dev
->vq
[index
].kick_fd
);
913 close(dev
->vq
[index
].kick_fd
);
914 dev
->vq
[index
].kick_fd
= -1;
921 vu_check_queue_msg_file(VuDev
*dev
, VhostUserMsg
*vmsg
)
923 int index
= vmsg
->payload
.u64
& VHOST_USER_VRING_IDX_MASK
;
925 if (index
>= dev
->max_queues
) {
926 vmsg_close_fds(vmsg
);
927 vu_panic(dev
, "Invalid queue index: %u", index
);
931 if (vmsg
->payload
.u64
& VHOST_USER_VRING_NOFD_MASK
||
933 vmsg_close_fds(vmsg
);
934 vu_panic(dev
, "Invalid fds in request: %d", vmsg
->request
);
942 inflight_desc_compare(const void *a
, const void *b
)
944 VuVirtqInflightDesc
*desc0
= (VuVirtqInflightDesc
*)a
,
945 *desc1
= (VuVirtqInflightDesc
*)b
;
947 if (desc1
->counter
> desc0
->counter
&&
948 (desc1
->counter
- desc0
->counter
) < VIRTQUEUE_MAX_SIZE
* 2) {
956 vu_check_queue_inflights(VuDev
*dev
, VuVirtq
*vq
)
960 if (!vu_has_protocol_feature(dev
, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD
)) {
964 if (unlikely(!vq
->inflight
)) {
968 if (unlikely(!vq
->inflight
->version
)) {
969 /* initialize the buffer */
970 vq
->inflight
->version
= INFLIGHT_VERSION
;
974 vq
->used_idx
= vq
->vring
.used
->idx
;
975 vq
->resubmit_num
= 0;
976 vq
->resubmit_list
= NULL
;
979 if (unlikely(vq
->inflight
->used_idx
!= vq
->used_idx
)) {
980 vq
->inflight
->desc
[vq
->inflight
->last_batch_head
].inflight
= 0;
984 vq
->inflight
->used_idx
= vq
->used_idx
;
987 for (i
= 0; i
< vq
->inflight
->desc_num
; i
++) {
988 if (vq
->inflight
->desc
[i
].inflight
== 1) {
993 vq
->shadow_avail_idx
= vq
->last_avail_idx
= vq
->inuse
+ vq
->used_idx
;
996 vq
->resubmit_list
= malloc(sizeof(VuVirtqInflightDesc
) * vq
->inuse
);
997 if (!vq
->resubmit_list
) {
1001 for (i
= 0; i
< vq
->inflight
->desc_num
; i
++) {
1002 if (vq
->inflight
->desc
[i
].inflight
) {
1003 vq
->resubmit_list
[vq
->resubmit_num
].index
= i
;
1004 vq
->resubmit_list
[vq
->resubmit_num
].counter
=
1005 vq
->inflight
->desc
[i
].counter
;
1010 if (vq
->resubmit_num
> 1) {
1011 qsort(vq
->resubmit_list
, vq
->resubmit_num
,
1012 sizeof(VuVirtqInflightDesc
), inflight_desc_compare
);
1014 vq
->counter
= vq
->resubmit_list
[0].counter
+ 1;
1017 /* in case of I/O hang after reconnecting */
1018 if (eventfd_write(vq
->kick_fd
, 1)) {
1026 vu_set_vring_kick_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
1028 int index
= vmsg
->payload
.u64
& VHOST_USER_VRING_IDX_MASK
;
1030 DPRINT("u64: 0x%016"PRIx64
"\n", vmsg
->payload
.u64
);
1032 if (!vu_check_queue_msg_file(dev
, vmsg
)) {
1036 if (dev
->vq
[index
].kick_fd
!= -1) {
1037 dev
->remove_watch(dev
, dev
->vq
[index
].kick_fd
);
1038 close(dev
->vq
[index
].kick_fd
);
1039 dev
->vq
[index
].kick_fd
= -1;
1042 dev
->vq
[index
].kick_fd
= vmsg
->fds
[0];
1043 DPRINT("Got kick_fd: %d for vq: %d\n", vmsg
->fds
[0], index
);
1045 dev
->vq
[index
].started
= true;
1046 if (dev
->iface
->queue_set_started
) {
1047 dev
->iface
->queue_set_started(dev
, index
, true);
1050 if (dev
->vq
[index
].kick_fd
!= -1 && dev
->vq
[index
].handler
) {
1051 dev
->set_watch(dev
, dev
->vq
[index
].kick_fd
, VU_WATCH_IN
,
1052 vu_kick_cb
, (void *)(long)index
);
1054 DPRINT("Waiting for kicks on fd: %d for vq: %d\n",
1055 dev
->vq
[index
].kick_fd
, index
);
1058 if (vu_check_queue_inflights(dev
, &dev
->vq
[index
])) {
1059 vu_panic(dev
, "Failed to check inflights for vq: %d\n", index
);
1065 void vu_set_queue_handler(VuDev
*dev
, VuVirtq
*vq
,
1066 vu_queue_handler_cb handler
)
1068 int qidx
= vq
- dev
->vq
;
1070 vq
->handler
= handler
;
1071 if (vq
->kick_fd
>= 0) {
1073 dev
->set_watch(dev
, vq
->kick_fd
, VU_WATCH_IN
,
1074 vu_kick_cb
, (void *)(long)qidx
);
1076 dev
->remove_watch(dev
, vq
->kick_fd
);
1081 bool vu_set_queue_host_notifier(VuDev
*dev
, VuVirtq
*vq
, int fd
,
1082 int size
, int offset
)
1084 int qidx
= vq
- dev
->vq
;
1086 VhostUserMsg vmsg
= {
1087 .request
= VHOST_USER_SLAVE_VRING_HOST_NOTIFIER_MSG
,
1088 .flags
= VHOST_USER_VERSION
| VHOST_USER_NEED_REPLY_MASK
,
1089 .size
= sizeof(vmsg
.payload
.area
),
1091 .u64
= qidx
& VHOST_USER_VRING_IDX_MASK
,
1098 vmsg
.payload
.area
.u64
|= VHOST_USER_VRING_NOFD_MASK
;
1100 vmsg
.fds
[fd_num
++] = fd
;
1103 vmsg
.fd_num
= fd_num
;
1105 if (!vu_has_protocol_feature(dev
, VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD
)) {
1109 if (!vu_message_write(dev
, dev
->slave_fd
, &vmsg
)) {
1113 return vu_process_message_reply(dev
, &vmsg
);
1117 vu_set_vring_call_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
1119 int index
= vmsg
->payload
.u64
& VHOST_USER_VRING_IDX_MASK
;
1121 DPRINT("u64: 0x%016"PRIx64
"\n", vmsg
->payload
.u64
);
1123 if (!vu_check_queue_msg_file(dev
, vmsg
)) {
1127 if (dev
->vq
[index
].call_fd
!= -1) {
1128 close(dev
->vq
[index
].call_fd
);
1129 dev
->vq
[index
].call_fd
= -1;
1132 dev
->vq
[index
].call_fd
= vmsg
->fds
[0];
1134 /* in case of I/O hang after reconnecting */
1135 if (eventfd_write(vmsg
->fds
[0], 1)) {
1139 DPRINT("Got call_fd: %d for vq: %d\n", vmsg
->fds
[0], index
);
1145 vu_set_vring_err_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
1147 int index
= vmsg
->payload
.u64
& VHOST_USER_VRING_IDX_MASK
;
1149 DPRINT("u64: 0x%016"PRIx64
"\n", vmsg
->payload
.u64
);
1151 if (!vu_check_queue_msg_file(dev
, vmsg
)) {
1155 if (dev
->vq
[index
].err_fd
!= -1) {
1156 close(dev
->vq
[index
].err_fd
);
1157 dev
->vq
[index
].err_fd
= -1;
1160 dev
->vq
[index
].err_fd
= vmsg
->fds
[0];
1166 vu_get_protocol_features_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
1168 uint64_t features
= 1ULL << VHOST_USER_PROTOCOL_F_MQ
|
1169 1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD
|
1170 1ULL << VHOST_USER_PROTOCOL_F_SLAVE_REQ
|
1171 1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER
|
1172 1ULL << VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD
;
1174 if (have_userfault()) {
1175 features
|= 1ULL << VHOST_USER_PROTOCOL_F_PAGEFAULT
;
1178 if (dev
->iface
->get_config
&& dev
->iface
->set_config
) {
1179 features
|= 1ULL << VHOST_USER_PROTOCOL_F_CONFIG
;
1182 if (dev
->iface
->get_protocol_features
) {
1183 features
|= dev
->iface
->get_protocol_features(dev
);
1186 vmsg_set_reply_u64(vmsg
, features
);
1191 vu_set_protocol_features_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
1193 uint64_t features
= vmsg
->payload
.u64
;
1195 DPRINT("u64: 0x%016"PRIx64
"\n", features
);
1197 dev
->protocol_features
= vmsg
->payload
.u64
;
1199 if (dev
->iface
->set_protocol_features
) {
1200 dev
->iface
->set_protocol_features(dev
, features
);
1207 vu_get_queue_num_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
1209 vmsg_set_reply_u64(vmsg
, dev
->max_queues
);
1214 vu_set_vring_enable_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
1216 unsigned int index
= vmsg
->payload
.state
.index
;
1217 unsigned int enable
= vmsg
->payload
.state
.num
;
1219 DPRINT("State.index: %d\n", index
);
1220 DPRINT("State.enable: %d\n", enable
);
1222 if (index
>= dev
->max_queues
) {
1223 vu_panic(dev
, "Invalid vring_enable index: %u", index
);
1227 dev
->vq
[index
].enable
= enable
;
1232 vu_set_slave_req_fd(VuDev
*dev
, VhostUserMsg
*vmsg
)
1234 if (vmsg
->fd_num
!= 1) {
1235 vu_panic(dev
, "Invalid slave_req_fd message (%d fd's)", vmsg
->fd_num
);
1239 if (dev
->slave_fd
!= -1) {
1240 close(dev
->slave_fd
);
1242 dev
->slave_fd
= vmsg
->fds
[0];
1243 DPRINT("Got slave_fd: %d\n", vmsg
->fds
[0]);
1249 vu_get_config(VuDev
*dev
, VhostUserMsg
*vmsg
)
1253 if (dev
->iface
->get_config
) {
1254 ret
= dev
->iface
->get_config(dev
, vmsg
->payload
.config
.region
,
1255 vmsg
->payload
.config
.size
);
1259 /* resize to zero to indicate an error to master */
1267 vu_set_config(VuDev
*dev
, VhostUserMsg
*vmsg
)
1271 if (dev
->iface
->set_config
) {
1272 ret
= dev
->iface
->set_config(dev
, vmsg
->payload
.config
.region
,
1273 vmsg
->payload
.config
.offset
,
1274 vmsg
->payload
.config
.size
,
1275 vmsg
->payload
.config
.flags
);
1277 vu_panic(dev
, "Set virtio configuration space failed");
1285 vu_set_postcopy_advise(VuDev
*dev
, VhostUserMsg
*vmsg
)
1287 dev
->postcopy_ufd
= -1;
1289 struct uffdio_api api_struct
;
1291 dev
->postcopy_ufd
= syscall(__NR_userfaultfd
, O_CLOEXEC
| O_NONBLOCK
);
1295 if (dev
->postcopy_ufd
== -1) {
1296 vu_panic(dev
, "Userfaultfd not available: %s", strerror(errno
));
1301 api_struct
.api
= UFFD_API
;
1302 api_struct
.features
= 0;
1303 if (ioctl(dev
->postcopy_ufd
, UFFDIO_API
, &api_struct
)) {
1304 vu_panic(dev
, "Failed UFFDIO_API: %s", strerror(errno
));
1305 close(dev
->postcopy_ufd
);
1306 dev
->postcopy_ufd
= -1;
1309 /* TODO: Stash feature flags somewhere */
1313 /* Return a ufd to the QEMU */
1315 vmsg
->fds
[0] = dev
->postcopy_ufd
;
1316 return true; /* = send a reply */
1320 vu_set_postcopy_listen(VuDev
*dev
, VhostUserMsg
*vmsg
)
1322 if (dev
->nregions
) {
1323 vu_panic(dev
, "Regions already registered at postcopy-listen");
1324 vmsg_set_reply_u64(vmsg
, -1);
1327 dev
->postcopy_listening
= true;
1329 vmsg_set_reply_u64(vmsg
, 0);
1334 vu_set_postcopy_end(VuDev
*dev
, VhostUserMsg
*vmsg
)
1336 DPRINT("%s: Entry\n", __func__
);
1337 dev
->postcopy_listening
= false;
1338 if (dev
->postcopy_ufd
> 0) {
1339 close(dev
->postcopy_ufd
);
1340 dev
->postcopy_ufd
= -1;
1341 DPRINT("%s: Done close\n", __func__
);
1344 vmsg_set_reply_u64(vmsg
, 0);
1345 DPRINT("%s: exit\n", __func__
);
1349 static inline uint64_t
1350 vu_inflight_queue_size(uint16_t queue_size
)
1352 return ALIGN_UP(sizeof(VuDescStateSplit
) * queue_size
+
1353 sizeof(uint16_t), INFLIGHT_ALIGNMENT
);
1357 vu_get_inflight_fd(VuDev
*dev
, VhostUserMsg
*vmsg
)
1362 uint16_t num_queues
, queue_size
;
1364 if (vmsg
->size
!= sizeof(vmsg
->payload
.inflight
)) {
1365 vu_panic(dev
, "Invalid get_inflight_fd message:%d", vmsg
->size
);
1366 vmsg
->payload
.inflight
.mmap_size
= 0;
1370 num_queues
= vmsg
->payload
.inflight
.num_queues
;
1371 queue_size
= vmsg
->payload
.inflight
.queue_size
;
1373 DPRINT("set_inflight_fd num_queues: %"PRId16
"\n", num_queues
);
1374 DPRINT("set_inflight_fd queue_size: %"PRId16
"\n", queue_size
);
1376 mmap_size
= vu_inflight_queue_size(queue_size
) * num_queues
;
1378 addr
= qemu_memfd_alloc("vhost-inflight", mmap_size
,
1379 F_SEAL_GROW
| F_SEAL_SHRINK
| F_SEAL_SEAL
,
1383 vu_panic(dev
, "Failed to alloc vhost inflight area");
1384 vmsg
->payload
.inflight
.mmap_size
= 0;
1388 memset(addr
, 0, mmap_size
);
1390 dev
->inflight_info
.addr
= addr
;
1391 dev
->inflight_info
.size
= vmsg
->payload
.inflight
.mmap_size
= mmap_size
;
1392 dev
->inflight_info
.fd
= vmsg
->fds
[0] = fd
;
1394 vmsg
->payload
.inflight
.mmap_offset
= 0;
1396 DPRINT("send inflight mmap_size: %"PRId64
"\n",
1397 vmsg
->payload
.inflight
.mmap_size
);
1398 DPRINT("send inflight mmap offset: %"PRId64
"\n",
1399 vmsg
->payload
.inflight
.mmap_offset
);
1405 vu_set_inflight_fd(VuDev
*dev
, VhostUserMsg
*vmsg
)
1408 uint64_t mmap_size
, mmap_offset
;
1409 uint16_t num_queues
, queue_size
;
1412 if (vmsg
->fd_num
!= 1 ||
1413 vmsg
->size
!= sizeof(vmsg
->payload
.inflight
)) {
1414 vu_panic(dev
, "Invalid set_inflight_fd message size:%d fds:%d",
1415 vmsg
->size
, vmsg
->fd_num
);
1420 mmap_size
= vmsg
->payload
.inflight
.mmap_size
;
1421 mmap_offset
= vmsg
->payload
.inflight
.mmap_offset
;
1422 num_queues
= vmsg
->payload
.inflight
.num_queues
;
1423 queue_size
= vmsg
->payload
.inflight
.queue_size
;
1425 DPRINT("set_inflight_fd mmap_size: %"PRId64
"\n", mmap_size
);
1426 DPRINT("set_inflight_fd mmap_offset: %"PRId64
"\n", mmap_offset
);
1427 DPRINT("set_inflight_fd num_queues: %"PRId16
"\n", num_queues
);
1428 DPRINT("set_inflight_fd queue_size: %"PRId16
"\n", queue_size
);
1430 rc
= mmap(0, mmap_size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
,
1433 if (rc
== MAP_FAILED
) {
1434 vu_panic(dev
, "set_inflight_fd mmap error: %s", strerror(errno
));
1438 if (dev
->inflight_info
.fd
) {
1439 close(dev
->inflight_info
.fd
);
1442 if (dev
->inflight_info
.addr
) {
1443 munmap(dev
->inflight_info
.addr
, dev
->inflight_info
.size
);
1446 dev
->inflight_info
.fd
= fd
;
1447 dev
->inflight_info
.addr
= rc
;
1448 dev
->inflight_info
.size
= mmap_size
;
1450 for (i
= 0; i
< num_queues
; i
++) {
1451 dev
->vq
[i
].inflight
= (VuVirtqInflight
*)rc
;
1452 dev
->vq
[i
].inflight
->desc_num
= queue_size
;
1453 rc
= (void *)((char *)rc
+ vu_inflight_queue_size(queue_size
));
1460 vu_process_message(VuDev
*dev
, VhostUserMsg
*vmsg
)
1464 /* Print out generic part of the request. */
1465 DPRINT("================ Vhost user message ================\n");
1466 DPRINT("Request: %s (%d)\n", vu_request_to_string(vmsg
->request
),
1468 DPRINT("Flags: 0x%x\n", vmsg
->flags
);
1469 DPRINT("Size: %d\n", vmsg
->size
);
1474 for (i
= 0; i
< vmsg
->fd_num
; i
++) {
1475 DPRINT(" %d", vmsg
->fds
[i
]);
1480 if (dev
->iface
->process_msg
&&
1481 dev
->iface
->process_msg(dev
, vmsg
, &do_reply
)) {
1485 switch (vmsg
->request
) {
1486 case VHOST_USER_GET_FEATURES
:
1487 return vu_get_features_exec(dev
, vmsg
);
1488 case VHOST_USER_SET_FEATURES
:
1489 return vu_set_features_exec(dev
, vmsg
);
1490 case VHOST_USER_GET_PROTOCOL_FEATURES
:
1491 return vu_get_protocol_features_exec(dev
, vmsg
);
1492 case VHOST_USER_SET_PROTOCOL_FEATURES
:
1493 return vu_set_protocol_features_exec(dev
, vmsg
);
1494 case VHOST_USER_SET_OWNER
:
1495 return vu_set_owner_exec(dev
, vmsg
);
1496 case VHOST_USER_RESET_OWNER
:
1497 return vu_reset_device_exec(dev
, vmsg
);
1498 case VHOST_USER_SET_MEM_TABLE
:
1499 return vu_set_mem_table_exec(dev
, vmsg
);
1500 case VHOST_USER_SET_LOG_BASE
:
1501 return vu_set_log_base_exec(dev
, vmsg
);
1502 case VHOST_USER_SET_LOG_FD
:
1503 return vu_set_log_fd_exec(dev
, vmsg
);
1504 case VHOST_USER_SET_VRING_NUM
:
1505 return vu_set_vring_num_exec(dev
, vmsg
);
1506 case VHOST_USER_SET_VRING_ADDR
:
1507 return vu_set_vring_addr_exec(dev
, vmsg
);
1508 case VHOST_USER_SET_VRING_BASE
:
1509 return vu_set_vring_base_exec(dev
, vmsg
);
1510 case VHOST_USER_GET_VRING_BASE
:
1511 return vu_get_vring_base_exec(dev
, vmsg
);
1512 case VHOST_USER_SET_VRING_KICK
:
1513 return vu_set_vring_kick_exec(dev
, vmsg
);
1514 case VHOST_USER_SET_VRING_CALL
:
1515 return vu_set_vring_call_exec(dev
, vmsg
);
1516 case VHOST_USER_SET_VRING_ERR
:
1517 return vu_set_vring_err_exec(dev
, vmsg
);
1518 case VHOST_USER_GET_QUEUE_NUM
:
1519 return vu_get_queue_num_exec(dev
, vmsg
);
1520 case VHOST_USER_SET_VRING_ENABLE
:
1521 return vu_set_vring_enable_exec(dev
, vmsg
);
1522 case VHOST_USER_SET_SLAVE_REQ_FD
:
1523 return vu_set_slave_req_fd(dev
, vmsg
);
1524 case VHOST_USER_GET_CONFIG
:
1525 return vu_get_config(dev
, vmsg
);
1526 case VHOST_USER_SET_CONFIG
:
1527 return vu_set_config(dev
, vmsg
);
1528 case VHOST_USER_NONE
:
1529 /* if you need processing before exit, override iface->process_msg */
1531 case VHOST_USER_POSTCOPY_ADVISE
:
1532 return vu_set_postcopy_advise(dev
, vmsg
);
1533 case VHOST_USER_POSTCOPY_LISTEN
:
1534 return vu_set_postcopy_listen(dev
, vmsg
);
1535 case VHOST_USER_POSTCOPY_END
:
1536 return vu_set_postcopy_end(dev
, vmsg
);
1537 case VHOST_USER_GET_INFLIGHT_FD
:
1538 return vu_get_inflight_fd(dev
, vmsg
);
1539 case VHOST_USER_SET_INFLIGHT_FD
:
1540 return vu_set_inflight_fd(dev
, vmsg
);
1542 vmsg_close_fds(vmsg
);
1543 vu_panic(dev
, "Unhandled request: %d", vmsg
->request
);
1550 vu_dispatch(VuDev
*dev
)
1552 VhostUserMsg vmsg
= { 0, };
1553 int reply_requested
;
1554 bool success
= false;
1556 if (!vu_message_read(dev
, dev
->sock
, &vmsg
)) {
1560 reply_requested
= vu_process_message(dev
, &vmsg
);
1561 if (!reply_requested
) {
1566 if (!vu_send_reply(dev
, dev
->sock
, &vmsg
)) {
1578 vu_deinit(VuDev
*dev
)
1582 for (i
= 0; i
< dev
->nregions
; i
++) {
1583 VuDevRegion
*r
= &dev
->regions
[i
];
1584 void *m
= (void *) (uintptr_t) r
->mmap_addr
;
1585 if (m
!= MAP_FAILED
) {
1586 munmap(m
, r
->size
+ r
->mmap_offset
);
1591 for (i
= 0; i
< dev
->max_queues
; i
++) {
1592 VuVirtq
*vq
= &dev
->vq
[i
];
1594 if (vq
->call_fd
!= -1) {
1599 if (vq
->kick_fd
!= -1) {
1604 if (vq
->err_fd
!= -1) {
1609 if (vq
->resubmit_list
) {
1610 free(vq
->resubmit_list
);
1611 vq
->resubmit_list
= NULL
;
1614 vq
->inflight
= NULL
;
1617 if (dev
->inflight_info
.addr
) {
1618 munmap(dev
->inflight_info
.addr
, dev
->inflight_info
.size
);
1619 dev
->inflight_info
.addr
= NULL
;
1622 if (dev
->inflight_info
.fd
> 0) {
1623 close(dev
->inflight_info
.fd
);
1624 dev
->inflight_info
.fd
= -1;
1628 if (dev
->slave_fd
!= -1) {
1629 close(dev
->slave_fd
);
1633 if (dev
->sock
!= -1) {
1643 uint16_t max_queues
,
1646 vu_set_watch_cb set_watch
,
1647 vu_remove_watch_cb remove_watch
,
1648 const VuDevIface
*iface
)
1652 assert(max_queues
> 0);
1653 assert(socket
>= 0);
1655 assert(remove_watch
);
1659 memset(dev
, 0, sizeof(*dev
));
1663 dev
->set_watch
= set_watch
;
1664 dev
->remove_watch
= remove_watch
;
1666 dev
->log_call_fd
= -1;
1668 dev
->max_queues
= max_queues
;
1670 dev
->vq
= malloc(max_queues
* sizeof(dev
->vq
[0]));
1672 DPRINT("%s: failed to malloc virtqueues\n", __func__
);
1676 for (i
= 0; i
< max_queues
; i
++) {
1677 dev
->vq
[i
] = (VuVirtq
) {
1678 .call_fd
= -1, .kick_fd
= -1, .err_fd
= -1,
1679 .notification
= true,
1687 vu_get_queue(VuDev
*dev
, int qidx
)
1689 assert(qidx
< dev
->max_queues
);
1690 return &dev
->vq
[qidx
];
1694 vu_queue_enabled(VuDev
*dev
, VuVirtq
*vq
)
1700 vu_queue_started(const VuDev
*dev
, const VuVirtq
*vq
)
1705 static inline uint16_t
1706 vring_avail_flags(VuVirtq
*vq
)
1708 return vq
->vring
.avail
->flags
;
1711 static inline uint16_t
1712 vring_avail_idx(VuVirtq
*vq
)
1714 vq
->shadow_avail_idx
= vq
->vring
.avail
->idx
;
1716 return vq
->shadow_avail_idx
;
1719 static inline uint16_t
1720 vring_avail_ring(VuVirtq
*vq
, int i
)
1722 return vq
->vring
.avail
->ring
[i
];
1725 static inline uint16_t
1726 vring_get_used_event(VuVirtq
*vq
)
1728 return vring_avail_ring(vq
, vq
->vring
.num
);
1732 virtqueue_num_heads(VuDev
*dev
, VuVirtq
*vq
, unsigned int idx
)
1734 uint16_t num_heads
= vring_avail_idx(vq
) - idx
;
1736 /* Check it isn't doing very strange things with descriptor numbers. */
1737 if (num_heads
> vq
->vring
.num
) {
1738 vu_panic(dev
, "Guest moved used index from %u to %u",
1739 idx
, vq
->shadow_avail_idx
);
1743 /* On success, callers read a descriptor at vq->last_avail_idx.
1744 * Make sure descriptor read does not bypass avail index read. */
1752 virtqueue_get_head(VuDev
*dev
, VuVirtq
*vq
,
1753 unsigned int idx
, unsigned int *head
)
1755 /* Grab the next descriptor number they're advertising, and increment
1756 * the index we've seen. */
1757 *head
= vring_avail_ring(vq
, idx
% vq
->vring
.num
);
1759 /* If their number is silly, that's a fatal mistake. */
1760 if (*head
>= vq
->vring
.num
) {
1761 vu_panic(dev
, "Guest says index %u is available", *head
);
1769 virtqueue_read_indirect_desc(VuDev
*dev
, struct vring_desc
*desc
,
1770 uint64_t addr
, size_t len
)
1772 struct vring_desc
*ori_desc
;
1775 if (len
> (VIRTQUEUE_MAX_SIZE
* sizeof(struct vring_desc
))) {
1785 ori_desc
= vu_gpa_to_va(dev
, &read_len
, addr
);
1790 memcpy(desc
, ori_desc
, read_len
);
1800 VIRTQUEUE_READ_DESC_ERROR
= -1,
1801 VIRTQUEUE_READ_DESC_DONE
= 0, /* end of chain */
1802 VIRTQUEUE_READ_DESC_MORE
= 1, /* more buffers in chain */
1806 virtqueue_read_next_desc(VuDev
*dev
, struct vring_desc
*desc
,
1807 int i
, unsigned int max
, unsigned int *next
)
1809 /* If this descriptor says it doesn't chain, we're done. */
1810 if (!(desc
[i
].flags
& VRING_DESC_F_NEXT
)) {
1811 return VIRTQUEUE_READ_DESC_DONE
;
1814 /* Check they're not leading us off end of descriptors. */
1815 *next
= desc
[i
].next
;
1816 /* Make sure compiler knows to grab that: we don't want it changing! */
1820 vu_panic(dev
, "Desc next is %u", *next
);
1821 return VIRTQUEUE_READ_DESC_ERROR
;
1824 return VIRTQUEUE_READ_DESC_MORE
;
1828 vu_queue_get_avail_bytes(VuDev
*dev
, VuVirtq
*vq
, unsigned int *in_bytes
,
1829 unsigned int *out_bytes
,
1830 unsigned max_in_bytes
, unsigned max_out_bytes
)
1833 unsigned int total_bufs
, in_total
, out_total
;
1836 idx
= vq
->last_avail_idx
;
1838 total_bufs
= in_total
= out_total
= 0;
1839 if (unlikely(dev
->broken
) ||
1840 unlikely(!vq
->vring
.avail
)) {
1844 while ((rc
= virtqueue_num_heads(dev
, vq
, idx
)) > 0) {
1845 unsigned int max
, desc_len
, num_bufs
, indirect
= 0;
1846 uint64_t desc_addr
, read_len
;
1847 struct vring_desc
*desc
;
1848 struct vring_desc desc_buf
[VIRTQUEUE_MAX_SIZE
];
1851 max
= vq
->vring
.num
;
1852 num_bufs
= total_bufs
;
1853 if (!virtqueue_get_head(dev
, vq
, idx
++, &i
)) {
1856 desc
= vq
->vring
.desc
;
1858 if (desc
[i
].flags
& VRING_DESC_F_INDIRECT
) {
1859 if (desc
[i
].len
% sizeof(struct vring_desc
)) {
1860 vu_panic(dev
, "Invalid size for indirect buffer table");
1864 /* If we've got too many, that implies a descriptor loop. */
1865 if (num_bufs
>= max
) {
1866 vu_panic(dev
, "Looped descriptor");
1870 /* loop over the indirect descriptor table */
1872 desc_addr
= desc
[i
].addr
;
1873 desc_len
= desc
[i
].len
;
1874 max
= desc_len
/ sizeof(struct vring_desc
);
1875 read_len
= desc_len
;
1876 desc
= vu_gpa_to_va(dev
, &read_len
, desc_addr
);
1877 if (unlikely(desc
&& read_len
!= desc_len
)) {
1878 /* Failed to use zero copy */
1880 if (!virtqueue_read_indirect_desc(dev
, desc_buf
,
1887 vu_panic(dev
, "Invalid indirect buffer table");
1894 /* If we've got too many, that implies a descriptor loop. */
1895 if (++num_bufs
> max
) {
1896 vu_panic(dev
, "Looped descriptor");
1900 if (desc
[i
].flags
& VRING_DESC_F_WRITE
) {
1901 in_total
+= desc
[i
].len
;
1903 out_total
+= desc
[i
].len
;
1905 if (in_total
>= max_in_bytes
&& out_total
>= max_out_bytes
) {
1908 rc
= virtqueue_read_next_desc(dev
, desc
, i
, max
, &i
);
1909 } while (rc
== VIRTQUEUE_READ_DESC_MORE
);
1911 if (rc
== VIRTQUEUE_READ_DESC_ERROR
) {
1916 total_bufs
= num_bufs
;
1926 *in_bytes
= in_total
;
1929 *out_bytes
= out_total
;
1934 in_total
= out_total
= 0;
1939 vu_queue_avail_bytes(VuDev
*dev
, VuVirtq
*vq
, unsigned int in_bytes
,
1940 unsigned int out_bytes
)
1942 unsigned int in_total
, out_total
;
1944 vu_queue_get_avail_bytes(dev
, vq
, &in_total
, &out_total
,
1945 in_bytes
, out_bytes
);
1947 return in_bytes
<= in_total
&& out_bytes
<= out_total
;
1950 /* Fetch avail_idx from VQ memory only when we really need to know if
1951 * guest has added some buffers. */
1953 vu_queue_empty(VuDev
*dev
, VuVirtq
*vq
)
1955 if (unlikely(dev
->broken
) ||
1956 unlikely(!vq
->vring
.avail
)) {
1960 if (vq
->shadow_avail_idx
!= vq
->last_avail_idx
) {
1964 return vring_avail_idx(vq
) == vq
->last_avail_idx
;
1968 vring_notify(VuDev
*dev
, VuVirtq
*vq
)
1973 /* We need to expose used array entries before checking used event. */
1976 /* Always notify when queue is empty (when feature acknowledge) */
1977 if (vu_has_feature(dev
, VIRTIO_F_NOTIFY_ON_EMPTY
) &&
1978 !vq
->inuse
&& vu_queue_empty(dev
, vq
)) {
1982 if (!vu_has_feature(dev
, VIRTIO_RING_F_EVENT_IDX
)) {
1983 return !(vring_avail_flags(vq
) & VRING_AVAIL_F_NO_INTERRUPT
);
1986 v
= vq
->signalled_used_valid
;
1987 vq
->signalled_used_valid
= true;
1988 old
= vq
->signalled_used
;
1989 new = vq
->signalled_used
= vq
->used_idx
;
1990 return !v
|| vring_need_event(vring_get_used_event(vq
), new, old
);
1994 vu_queue_notify(VuDev
*dev
, VuVirtq
*vq
)
1996 if (unlikely(dev
->broken
) ||
1997 unlikely(!vq
->vring
.avail
)) {
2001 if (!vring_notify(dev
, vq
)) {
2002 DPRINT("skipped notify...\n");
2006 if (eventfd_write(vq
->call_fd
, 1) < 0) {
2007 vu_panic(dev
, "Error writing eventfd: %s", strerror(errno
));
2012 vring_used_flags_set_bit(VuVirtq
*vq
, int mask
)
2016 flags
= (uint16_t *)((char*)vq
->vring
.used
+
2017 offsetof(struct vring_used
, flags
));
2022 vring_used_flags_unset_bit(VuVirtq
*vq
, int mask
)
2026 flags
= (uint16_t *)((char*)vq
->vring
.used
+
2027 offsetof(struct vring_used
, flags
));
2032 vring_set_avail_event(VuVirtq
*vq
, uint16_t val
)
2034 if (!vq
->notification
) {
2038 *((uint16_t *) &vq
->vring
.used
->ring
[vq
->vring
.num
]) = val
;
2042 vu_queue_set_notification(VuDev
*dev
, VuVirtq
*vq
, int enable
)
2044 vq
->notification
= enable
;
2045 if (vu_has_feature(dev
, VIRTIO_RING_F_EVENT_IDX
)) {
2046 vring_set_avail_event(vq
, vring_avail_idx(vq
));
2047 } else if (enable
) {
2048 vring_used_flags_unset_bit(vq
, VRING_USED_F_NO_NOTIFY
);
2050 vring_used_flags_set_bit(vq
, VRING_USED_F_NO_NOTIFY
);
2053 /* Expose avail event/used flags before caller checks the avail idx. */
2059 virtqueue_map_desc(VuDev
*dev
,
2060 unsigned int *p_num_sg
, struct iovec
*iov
,
2061 unsigned int max_num_sg
, bool is_write
,
2062 uint64_t pa
, size_t sz
)
2064 unsigned num_sg
= *p_num_sg
;
2066 assert(num_sg
<= max_num_sg
);
2069 vu_panic(dev
, "virtio: zero sized buffers are not allowed");
2076 if (num_sg
== max_num_sg
) {
2077 vu_panic(dev
, "virtio: too many descriptors in indirect table");
2081 iov
[num_sg
].iov_base
= vu_gpa_to_va(dev
, &len
, pa
);
2082 if (iov
[num_sg
].iov_base
== NULL
) {
2083 vu_panic(dev
, "virtio: invalid address for buffers");
2086 iov
[num_sg
].iov_len
= len
;
2096 virtqueue_alloc_element(size_t sz
,
2097 unsigned out_num
, unsigned in_num
)
2099 VuVirtqElement
*elem
;
2100 size_t in_sg_ofs
= ALIGN_UP(sz
, __alignof__(elem
->in_sg
[0]));
2101 size_t out_sg_ofs
= in_sg_ofs
+ in_num
* sizeof(elem
->in_sg
[0]);
2102 size_t out_sg_end
= out_sg_ofs
+ out_num
* sizeof(elem
->out_sg
[0]);
2104 assert(sz
>= sizeof(VuVirtqElement
));
2105 elem
= malloc(out_sg_end
);
2106 elem
->out_num
= out_num
;
2107 elem
->in_num
= in_num
;
2108 elem
->in_sg
= (void *)elem
+ in_sg_ofs
;
2109 elem
->out_sg
= (void *)elem
+ out_sg_ofs
;
2114 vu_queue_map_desc(VuDev
*dev
, VuVirtq
*vq
, unsigned int idx
, size_t sz
)
2116 struct vring_desc
*desc
= vq
->vring
.desc
;
2117 uint64_t desc_addr
, read_len
;
2118 unsigned int desc_len
;
2119 unsigned int max
= vq
->vring
.num
;
2120 unsigned int i
= idx
;
2121 VuVirtqElement
*elem
;
2122 unsigned int out_num
= 0, in_num
= 0;
2123 struct iovec iov
[VIRTQUEUE_MAX_SIZE
];
2124 struct vring_desc desc_buf
[VIRTQUEUE_MAX_SIZE
];
2127 if (desc
[i
].flags
& VRING_DESC_F_INDIRECT
) {
2128 if (desc
[i
].len
% sizeof(struct vring_desc
)) {
2129 vu_panic(dev
, "Invalid size for indirect buffer table");
2132 /* loop over the indirect descriptor table */
2133 desc_addr
= desc
[i
].addr
;
2134 desc_len
= desc
[i
].len
;
2135 max
= desc_len
/ sizeof(struct vring_desc
);
2136 read_len
= desc_len
;
2137 desc
= vu_gpa_to_va(dev
, &read_len
, desc_addr
);
2138 if (unlikely(desc
&& read_len
!= desc_len
)) {
2139 /* Failed to use zero copy */
2141 if (!virtqueue_read_indirect_desc(dev
, desc_buf
,
2148 vu_panic(dev
, "Invalid indirect buffer table");
2154 /* Collect all the descriptors */
2156 if (desc
[i
].flags
& VRING_DESC_F_WRITE
) {
2157 virtqueue_map_desc(dev
, &in_num
, iov
+ out_num
,
2158 VIRTQUEUE_MAX_SIZE
- out_num
, true,
2159 desc
[i
].addr
, desc
[i
].len
);
2162 vu_panic(dev
, "Incorrect order for descriptors");
2165 virtqueue_map_desc(dev
, &out_num
, iov
,
2166 VIRTQUEUE_MAX_SIZE
, false,
2167 desc
[i
].addr
, desc
[i
].len
);
2170 /* If we've got too many, that implies a descriptor loop. */
2171 if ((in_num
+ out_num
) > max
) {
2172 vu_panic(dev
, "Looped descriptor");
2174 rc
= virtqueue_read_next_desc(dev
, desc
, i
, max
, &i
);
2175 } while (rc
== VIRTQUEUE_READ_DESC_MORE
);
2177 if (rc
== VIRTQUEUE_READ_DESC_ERROR
) {
2178 vu_panic(dev
, "read descriptor error");
2182 /* Now copy what we have collected and mapped */
2183 elem
= virtqueue_alloc_element(sz
, out_num
, in_num
);
2185 for (i
= 0; i
< out_num
; i
++) {
2186 elem
->out_sg
[i
] = iov
[i
];
2188 for (i
= 0; i
< in_num
; i
++) {
2189 elem
->in_sg
[i
] = iov
[out_num
+ i
];
2196 vu_queue_inflight_get(VuDev
*dev
, VuVirtq
*vq
, int desc_idx
)
2198 if (!vu_has_protocol_feature(dev
, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD
)) {
2202 if (unlikely(!vq
->inflight
)) {
2206 vq
->inflight
->desc
[desc_idx
].counter
= vq
->counter
++;
2207 vq
->inflight
->desc
[desc_idx
].inflight
= 1;
2213 vu_queue_inflight_pre_put(VuDev
*dev
, VuVirtq
*vq
, int desc_idx
)
2215 if (!vu_has_protocol_feature(dev
, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD
)) {
2219 if (unlikely(!vq
->inflight
)) {
2223 vq
->inflight
->last_batch_head
= desc_idx
;
2229 vu_queue_inflight_post_put(VuDev
*dev
, VuVirtq
*vq
, int desc_idx
)
2231 if (!vu_has_protocol_feature(dev
, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD
)) {
2235 if (unlikely(!vq
->inflight
)) {
2241 vq
->inflight
->desc
[desc_idx
].inflight
= 0;
2245 vq
->inflight
->used_idx
= vq
->used_idx
;
2251 vu_queue_pop(VuDev
*dev
, VuVirtq
*vq
, size_t sz
)
2255 VuVirtqElement
*elem
;
2257 if (unlikely(dev
->broken
) ||
2258 unlikely(!vq
->vring
.avail
)) {
2262 if (unlikely(vq
->resubmit_list
&& vq
->resubmit_num
> 0)) {
2263 i
= (--vq
->resubmit_num
);
2264 elem
= vu_queue_map_desc(dev
, vq
, vq
->resubmit_list
[i
].index
, sz
);
2266 if (!vq
->resubmit_num
) {
2267 free(vq
->resubmit_list
);
2268 vq
->resubmit_list
= NULL
;
2274 if (vu_queue_empty(dev
, vq
)) {
2278 * Needed after virtio_queue_empty(), see comment in
2279 * virtqueue_num_heads().
2283 if (vq
->inuse
>= vq
->vring
.num
) {
2284 vu_panic(dev
, "Virtqueue size exceeded");
2288 if (!virtqueue_get_head(dev
, vq
, vq
->last_avail_idx
++, &head
)) {
2292 if (vu_has_feature(dev
, VIRTIO_RING_F_EVENT_IDX
)) {
2293 vring_set_avail_event(vq
, vq
->last_avail_idx
);
2296 elem
= vu_queue_map_desc(dev
, vq
, head
, sz
);
2304 vu_queue_inflight_get(dev
, vq
, head
);
2310 vu_queue_detach_element(VuDev
*dev
, VuVirtq
*vq
, VuVirtqElement
*elem
,
2314 /* unmap, when DMA support is added */
2318 vu_queue_unpop(VuDev
*dev
, VuVirtq
*vq
, VuVirtqElement
*elem
,
2321 vq
->last_avail_idx
--;
2322 vu_queue_detach_element(dev
, vq
, elem
, len
);
2326 vu_queue_rewind(VuDev
*dev
, VuVirtq
*vq
, unsigned int num
)
2328 if (num
> vq
->inuse
) {
2331 vq
->last_avail_idx
-= num
;
2337 void vring_used_write(VuDev
*dev
, VuVirtq
*vq
,
2338 struct vring_used_elem
*uelem
, int i
)
2340 struct vring_used
*used
= vq
->vring
.used
;
2342 used
->ring
[i
] = *uelem
;
2343 vu_log_write(dev
, vq
->vring
.log_guest_addr
+
2344 offsetof(struct vring_used
, ring
[i
]),
2345 sizeof(used
->ring
[i
]));
2350 vu_log_queue_fill(VuDev
*dev
, VuVirtq
*vq
,
2351 const VuVirtqElement
*elem
,
2354 struct vring_desc
*desc
= vq
->vring
.desc
;
2355 unsigned int i
, max
, min
, desc_len
;
2356 uint64_t desc_addr
, read_len
;
2357 struct vring_desc desc_buf
[VIRTQUEUE_MAX_SIZE
];
2358 unsigned num_bufs
= 0;
2360 max
= vq
->vring
.num
;
2363 if (desc
[i
].flags
& VRING_DESC_F_INDIRECT
) {
2364 if (desc
[i
].len
% sizeof(struct vring_desc
)) {
2365 vu_panic(dev
, "Invalid size for indirect buffer table");
2368 /* loop over the indirect descriptor table */
2369 desc_addr
= desc
[i
].addr
;
2370 desc_len
= desc
[i
].len
;
2371 max
= desc_len
/ sizeof(struct vring_desc
);
2372 read_len
= desc_len
;
2373 desc
= vu_gpa_to_va(dev
, &read_len
, desc_addr
);
2374 if (unlikely(desc
&& read_len
!= desc_len
)) {
2375 /* Failed to use zero copy */
2377 if (!virtqueue_read_indirect_desc(dev
, desc_buf
,
2384 vu_panic(dev
, "Invalid indirect buffer table");
2391 if (++num_bufs
> max
) {
2392 vu_panic(dev
, "Looped descriptor");
2396 if (desc
[i
].flags
& VRING_DESC_F_WRITE
) {
2397 min
= MIN(desc
[i
].len
, len
);
2398 vu_log_write(dev
, desc
[i
].addr
, min
);
2403 (virtqueue_read_next_desc(dev
, desc
, i
, max
, &i
)
2404 == VIRTQUEUE_READ_DESC_MORE
));
2408 vu_queue_fill(VuDev
*dev
, VuVirtq
*vq
,
2409 const VuVirtqElement
*elem
,
2410 unsigned int len
, unsigned int idx
)
2412 struct vring_used_elem uelem
;
2414 if (unlikely(dev
->broken
) ||
2415 unlikely(!vq
->vring
.avail
)) {
2419 vu_log_queue_fill(dev
, vq
, elem
, len
);
2421 idx
= (idx
+ vq
->used_idx
) % vq
->vring
.num
;
2423 uelem
.id
= elem
->index
;
2425 vring_used_write(dev
, vq
, &uelem
, idx
);
2429 void vring_used_idx_set(VuDev
*dev
, VuVirtq
*vq
, uint16_t val
)
2431 vq
->vring
.used
->idx
= val
;
2433 vq
->vring
.log_guest_addr
+ offsetof(struct vring_used
, idx
),
2434 sizeof(vq
->vring
.used
->idx
));
2440 vu_queue_flush(VuDev
*dev
, VuVirtq
*vq
, unsigned int count
)
2444 if (unlikely(dev
->broken
) ||
2445 unlikely(!vq
->vring
.avail
)) {
2449 /* Make sure buffer is written before we update index. */
2454 vring_used_idx_set(dev
, vq
, new);
2456 if (unlikely((int16_t)(new - vq
->signalled_used
) < (uint16_t)(new - old
))) {
2457 vq
->signalled_used_valid
= false;
2462 vu_queue_push(VuDev
*dev
, VuVirtq
*vq
,
2463 const VuVirtqElement
*elem
, unsigned int len
)
2465 vu_queue_fill(dev
, vq
, elem
, len
, 0);
2466 vu_queue_inflight_pre_put(dev
, vq
, elem
->index
);
2467 vu_queue_flush(dev
, vq
, 1);
2468 vu_queue_inflight_post_put(dev
, vq
, elem
->index
);