| /* |
| * Vhost User library |
| * |
| * Copyright IBM, Corp. 2007 |
| * Copyright (c) 2016 Red Hat, Inc. |
| * |
| * Authors: |
| * Anthony Liguori <aliguori@us.ibm.com> |
| * Marc-André Lureau <mlureau@redhat.com> |
| * Victor Kaplansky <victork@redhat.com> |
| * |
| * This work is licensed under the terms of the GNU GPL, version 2 or |
| * later. See the COPYING file in the top-level directory. |
| */ |
| |
| /* this code avoids GLib dependency */ |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <stdarg.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <inttypes.h> |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| #include <sys/eventfd.h> |
| #include <sys/mman.h> |
| #include <endian.h> |
| |
| #if defined(__linux__) |
| #include <sys/syscall.h> |
| #include <fcntl.h> |
| #include <sys/ioctl.h> |
| #include <linux/vhost.h> |
| |
| #ifdef __NR_userfaultfd |
| #include <linux/userfaultfd.h> |
| #endif |
| |
| #endif |
| |
| #include "include/atomic.h" |
| |
| #include "libvhost-user.h" |
| |
| /* usually provided by GLib */ |
| #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4) |
| #if !defined(__clang__) && (__GNUC__ == 4 && __GNUC_MINOR__ == 4) |
| #define G_GNUC_PRINTF(format_idx, arg_idx) \ |
| __attribute__((__format__(gnu_printf, format_idx, arg_idx))) |
| #else |
| #define G_GNUC_PRINTF(format_idx, arg_idx) \ |
| __attribute__((__format__(__printf__, format_idx, arg_idx))) |
| #endif |
| #else /* !__GNUC__ */ |
| #define G_GNUC_PRINTF(format_idx, arg_idx) |
| #endif /* !__GNUC__ */ |
| #ifndef MIN |
| #define MIN(x, y) ({ \ |
| typeof(x) _min1 = (x); \ |
| typeof(y) _min2 = (y); \ |
| (void) (&_min1 == &_min2); \ |
| _min1 < _min2 ? _min1 : _min2; }) |
| #endif |
| |
| /* Round number down to multiple */ |
| #define ALIGN_DOWN(n, m) ((n) / (m) * (m)) |
| |
| /* Round number up to multiple */ |
| #define ALIGN_UP(n, m) ALIGN_DOWN((n) + (m) - 1, (m)) |
| |
| #ifndef unlikely |
| #define unlikely(x) __builtin_expect(!!(x), 0) |
| #endif |
| |
| /* Align each region to cache line size in inflight buffer */ |
| #define INFLIGHT_ALIGNMENT 64 |
| |
| /* The version of inflight buffer */ |
| #define INFLIGHT_VERSION 1 |
| |
| /* The version of the protocol we support */ |
| #define VHOST_USER_VERSION 1 |
| #define LIBVHOST_USER_DEBUG 0 |
| |
| #define DPRINT(...) \ |
| do { \ |
| if (LIBVHOST_USER_DEBUG) { \ |
| fprintf(stderr, __VA_ARGS__); \ |
| } \ |
| } while (0) |
| |
| static inline |
| bool has_feature(uint64_t features, unsigned int fbit) |
| { |
| assert(fbit < 64); |
| return !!(features & (1ULL << fbit)); |
| } |
| |
| static inline |
| bool vu_has_feature(VuDev *dev, |
| unsigned int fbit) |
| { |
| return has_feature(dev->features, fbit); |
| } |
| |
| static inline bool vu_has_protocol_feature(VuDev *dev, unsigned int fbit) |
| { |
| return has_feature(dev->protocol_features, fbit); |
| } |
| |
| const char * |
| vu_request_to_string(unsigned int req) |
| { |
| #define REQ(req) [req] = #req |
| static const char *vu_request_str[] = { |
| REQ(VHOST_USER_NONE), |
| REQ(VHOST_USER_GET_FEATURES), |
| REQ(VHOST_USER_SET_FEATURES), |
| REQ(VHOST_USER_SET_OWNER), |
| REQ(VHOST_USER_RESET_OWNER), |
| REQ(VHOST_USER_SET_MEM_TABLE), |
| REQ(VHOST_USER_SET_LOG_BASE), |
| REQ(VHOST_USER_SET_LOG_FD), |
| REQ(VHOST_USER_SET_VRING_NUM), |
| REQ(VHOST_USER_SET_VRING_ADDR), |
| REQ(VHOST_USER_SET_VRING_BASE), |
| REQ(VHOST_USER_GET_VRING_BASE), |
| REQ(VHOST_USER_SET_VRING_KICK), |
| REQ(VHOST_USER_SET_VRING_CALL), |
| REQ(VHOST_USER_SET_VRING_ERR), |
| REQ(VHOST_USER_GET_PROTOCOL_FEATURES), |
| REQ(VHOST_USER_SET_PROTOCOL_FEATURES), |
| REQ(VHOST_USER_GET_QUEUE_NUM), |
| REQ(VHOST_USER_SET_VRING_ENABLE), |
| REQ(VHOST_USER_SEND_RARP), |
| REQ(VHOST_USER_NET_SET_MTU), |
| REQ(VHOST_USER_SET_SLAVE_REQ_FD), |
| REQ(VHOST_USER_IOTLB_MSG), |
| REQ(VHOST_USER_SET_VRING_ENDIAN), |
| REQ(VHOST_USER_GET_CONFIG), |
| REQ(VHOST_USER_SET_CONFIG), |
| REQ(VHOST_USER_POSTCOPY_ADVISE), |
| REQ(VHOST_USER_POSTCOPY_LISTEN), |
| REQ(VHOST_USER_POSTCOPY_END), |
| REQ(VHOST_USER_GET_INFLIGHT_FD), |
| REQ(VHOST_USER_SET_INFLIGHT_FD), |
| REQ(VHOST_USER_GPU_SET_SOCKET), |
| REQ(VHOST_USER_VRING_KICK), |
| REQ(VHOST_USER_GET_MAX_MEM_SLOTS), |
| REQ(VHOST_USER_ADD_MEM_REG), |
| REQ(VHOST_USER_REM_MEM_REG), |
| REQ(VHOST_USER_MAX), |
| }; |
| #undef REQ |
| |
| if (req < VHOST_USER_MAX) { |
| return vu_request_str[req]; |
| } else { |
| return "unknown"; |
| } |
| } |
| |
| static void G_GNUC_PRINTF(2, 3) |
| vu_panic(VuDev *dev, const char *msg, ...) |
| { |
| char *buf = NULL; |
| va_list ap; |
| |
| va_start(ap, msg); |
| if (vasprintf(&buf, msg, ap) < 0) { |
| buf = NULL; |
| } |
| va_end(ap); |
| |
| dev->broken = true; |
| dev->panic(dev, buf); |
| free(buf); |
| |
| /* |
| * FIXME: |
| * find a way to call virtio_error, or perhaps close the connection? |
| */ |
| } |
| |
| /* Translate guest physical address to our virtual address. */ |
| void * |
| vu_gpa_to_va(VuDev *dev, uint64_t *plen, uint64_t guest_addr) |
| { |
| int i; |
| |
| if (*plen == 0) { |
| return NULL; |
| } |
| |
| /* Find matching memory region. */ |
| for (i = 0; i < dev->nregions; i++) { |
| VuDevRegion *r = &dev->regions[i]; |
| |
| if ((guest_addr >= r->gpa) && (guest_addr < (r->gpa + r->size))) { |
| if ((guest_addr + *plen) > (r->gpa + r->size)) { |
| *plen = r->gpa + r->size - guest_addr; |
| } |
| return (void *)(uintptr_t) |
| guest_addr - r->gpa + r->mmap_addr + r->mmap_offset; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /* Translate qemu virtual address to our virtual address. */ |
| static void * |
| qva_to_va(VuDev *dev, uint64_t qemu_addr) |
| { |
| int i; |
| |
| /* Find matching memory region. */ |
| for (i = 0; i < dev->nregions; i++) { |
| VuDevRegion *r = &dev->regions[i]; |
| |
| if ((qemu_addr >= r->qva) && (qemu_addr < (r->qva + r->size))) { |
| return (void *)(uintptr_t) |
| qemu_addr - r->qva + r->mmap_addr + r->mmap_offset; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| static void |
| vmsg_close_fds(VhostUserMsg *vmsg) |
| { |
| int i; |
| |
| for (i = 0; i < vmsg->fd_num; i++) { |
| close(vmsg->fds[i]); |
| } |
| } |
| |
| /* Set reply payload.u64 and clear request flags and fd_num */ |
| static void vmsg_set_reply_u64(VhostUserMsg *vmsg, uint64_t val) |
| { |
| vmsg->flags = 0; /* defaults will be set by vu_send_reply() */ |
| vmsg->size = sizeof(vmsg->payload.u64); |
| vmsg->payload.u64 = val; |
| vmsg->fd_num = 0; |
| } |
| |
| /* A test to see if we have userfault available */ |
| static bool |
| have_userfault(void) |
| { |
| #if defined(__linux__) && defined(__NR_userfaultfd) &&\ |
| defined(UFFD_FEATURE_MISSING_SHMEM) &&\ |
| defined(UFFD_FEATURE_MISSING_HUGETLBFS) |
| /* Now test the kernel we're running on really has the features */ |
| int ufd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK); |
| struct uffdio_api api_struct; |
| if (ufd < 0) { |
| return false; |
| } |
| |
| api_struct.api = UFFD_API; |
| api_struct.features = UFFD_FEATURE_MISSING_SHMEM | |
| UFFD_FEATURE_MISSING_HUGETLBFS; |
| if (ioctl(ufd, UFFDIO_API, &api_struct)) { |
| close(ufd); |
| return false; |
| } |
| close(ufd); |
| return true; |
| |
| #else |
| return false; |
| #endif |
| } |
| |
| static bool |
| vu_message_read_default(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) |
| { |
| char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = {}; |
| struct iovec iov = { |
| .iov_base = (char *)vmsg, |
| .iov_len = VHOST_USER_HDR_SIZE, |
| }; |
| struct msghdr msg = { |
| .msg_iov = &iov, |
| .msg_iovlen = 1, |
| .msg_control = control, |
| .msg_controllen = sizeof(control), |
| }; |
| size_t fd_size; |
| struct cmsghdr *cmsg; |
| int rc; |
| |
| do { |
| rc = recvmsg(conn_fd, &msg, 0); |
| } while (rc < 0 && (errno == EINTR || errno == EAGAIN)); |
| |
| if (rc < 0) { |
| vu_panic(dev, "Error while recvmsg: %s", strerror(errno)); |
| return false; |
| } |
| |
| vmsg->fd_num = 0; |
| for (cmsg = CMSG_FIRSTHDR(&msg); |
| cmsg != NULL; |
| cmsg = CMSG_NXTHDR(&msg, cmsg)) |
| { |
| if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) { |
| fd_size = cmsg->cmsg_len - CMSG_LEN(0); |
| vmsg->fd_num = fd_size / sizeof(int); |
| memcpy(vmsg->fds, CMSG_DATA(cmsg), fd_size); |
| break; |
| } |
| } |
| |
| if (vmsg->size > sizeof(vmsg->payload)) { |
| vu_panic(dev, |
| "Error: too big message request: %d, size: vmsg->size: %u, " |
| "while sizeof(vmsg->payload) = %zu\n", |
| vmsg->request, vmsg->size, sizeof(vmsg->payload)); |
| goto fail; |
| } |
| |
| if (vmsg->size) { |
| do { |
| rc = read(conn_fd, &vmsg->payload, vmsg->size); |
| } while (rc < 0 && (errno == EINTR || errno == EAGAIN)); |
| |
| if (rc <= 0) { |
| vu_panic(dev, "Error while reading: %s", strerror(errno)); |
| goto fail; |
| } |
| |
| assert(rc == vmsg->size); |
| } |
| |
| return true; |
| |
| fail: |
| vmsg_close_fds(vmsg); |
| |
| return false; |
| } |
| |
| static bool |
| vu_message_write(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) |
| { |
| int rc; |
| uint8_t *p = (uint8_t *)vmsg; |
| char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = {}; |
| struct iovec iov = { |
| .iov_base = (char *)vmsg, |
| .iov_len = VHOST_USER_HDR_SIZE, |
| }; |
| struct msghdr msg = { |
| .msg_iov = &iov, |
| .msg_iovlen = 1, |
| .msg_control = control, |
| }; |
| struct cmsghdr *cmsg; |
| |
| memset(control, 0, sizeof(control)); |
| assert(vmsg->fd_num <= VHOST_MEMORY_BASELINE_NREGIONS); |
| if (vmsg->fd_num > 0) { |
| size_t fdsize = vmsg->fd_num * sizeof(int); |
| msg.msg_controllen = CMSG_SPACE(fdsize); |
| cmsg = CMSG_FIRSTHDR(&msg); |
| cmsg->cmsg_len = CMSG_LEN(fdsize); |
| cmsg->cmsg_level = SOL_SOCKET; |
| cmsg->cmsg_type = SCM_RIGHTS; |
| memcpy(CMSG_DATA(cmsg), vmsg->fds, fdsize); |
| } else { |
| msg.msg_controllen = 0; |
| } |
| |
| do { |
| rc = sendmsg(conn_fd, &msg, 0); |
| } while (rc < 0 && (errno == EINTR || errno == EAGAIN)); |
| |
| if (vmsg->size) { |
| do { |
| if (vmsg->data) { |
| rc = write(conn_fd, vmsg->data, vmsg->size); |
| } else { |
| rc = write(conn_fd, p + VHOST_USER_HDR_SIZE, vmsg->size); |
| } |
| } while (rc < 0 && (errno == EINTR || errno == EAGAIN)); |
| } |
| |
| if (rc <= 0) { |
| vu_panic(dev, "Error while writing: %s", strerror(errno)); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static bool |
| vu_send_reply(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) |
| { |
| /* Set the version in the flags when sending the reply */ |
| vmsg->flags &= ~VHOST_USER_VERSION_MASK; |
| vmsg->flags |= VHOST_USER_VERSION; |
| vmsg->flags |= VHOST_USER_REPLY_MASK; |
| |
| return vu_message_write(dev, conn_fd, vmsg); |
| } |
| |
| /* |
| * Processes a reply on the slave channel. |
| * Entered with slave_mutex held and releases it before exit. |
| * Returns true on success. |
| */ |
| static bool |
| vu_process_message_reply(VuDev *dev, const VhostUserMsg *vmsg) |
| { |
| VhostUserMsg msg_reply; |
| bool result = false; |
| |
| if ((vmsg->flags & VHOST_USER_NEED_REPLY_MASK) == 0) { |
| result = true; |
| goto out; |
| } |
| |
| if (!vu_message_read_default(dev, dev->slave_fd, &msg_reply)) { |
| goto out; |
| } |
| |
| if (msg_reply.request != vmsg->request) { |
| DPRINT("Received unexpected msg type. Expected %d received %d", |
| vmsg->request, msg_reply.request); |
| goto out; |
| } |
| |
| result = msg_reply.payload.u64 == 0; |
| |
| out: |
| pthread_mutex_unlock(&dev->slave_mutex); |
| return result; |
| } |
| |
| /* Kick the log_call_fd if required. */ |
| static void |
| vu_log_kick(VuDev *dev) |
| { |
| if (dev->log_call_fd != -1) { |
| DPRINT("Kicking the QEMU's log...\n"); |
| if (eventfd_write(dev->log_call_fd, 1) < 0) { |
| vu_panic(dev, "Error writing eventfd: %s", strerror(errno)); |
| } |
| } |
| } |
| |
| static void |
| vu_log_page(uint8_t *log_table, uint64_t page) |
| { |
| DPRINT("Logged dirty guest page: %"PRId64"\n", page); |
| qatomic_or(&log_table[page / 8], 1 << (page % 8)); |
| } |
| |
| static void |
| vu_log_write(VuDev *dev, uint64_t address, uint64_t length) |
| { |
| uint64_t page; |
| |
| if (!(dev->features & (1ULL << VHOST_F_LOG_ALL)) || |
| !dev->log_table || !length) { |
| return; |
| } |
| |
| assert(dev->log_size > ((address + length - 1) / VHOST_LOG_PAGE / 8)); |
| |
| page = address / VHOST_LOG_PAGE; |
| while (page * VHOST_LOG_PAGE < address + length) { |
| vu_log_page(dev->log_table, page); |
| page += 1; |
| } |
| |
| vu_log_kick(dev); |
| } |
| |
| static void |
| vu_kick_cb(VuDev *dev, int condition, void *data) |
| { |
| int index = (intptr_t)data; |
| VuVirtq *vq = &dev->vq[index]; |
| int sock = vq->kick_fd; |
| eventfd_t kick_data; |
| ssize_t rc; |
| |
| rc = eventfd_read(sock, &kick_data); |
| if (rc == -1) { |
| vu_panic(dev, "kick eventfd_read(): %s", strerror(errno)); |
| dev->remove_watch(dev, dev->vq[index].kick_fd); |
| } else { |
| DPRINT("Got kick_data: %016"PRIx64" handler:%p idx:%d\n", |
| kick_data, vq->handler, index); |
| if (vq->handler) { |
| vq->handler(dev, index); |
| } |
| } |
| } |
| |
| static bool |
| vu_get_features_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| vmsg->payload.u64 = |
| /* |
| * The following VIRTIO feature bits are supported by our virtqueue |
| * implementation: |
| */ |
| 1ULL << VIRTIO_F_NOTIFY_ON_EMPTY | |
| 1ULL << VIRTIO_RING_F_INDIRECT_DESC | |
| 1ULL << VIRTIO_RING_F_EVENT_IDX | |
| 1ULL << VIRTIO_F_VERSION_1 | |
| |
| /* vhost-user feature bits */ |
| 1ULL << VHOST_F_LOG_ALL | |
| 1ULL << VHOST_USER_F_PROTOCOL_FEATURES; |
| |
| if (dev->iface->get_features) { |
| vmsg->payload.u64 |= dev->iface->get_features(dev); |
| } |
| |
| vmsg->size = sizeof(vmsg->payload.u64); |
| vmsg->fd_num = 0; |
| |
| DPRINT("Sending back to guest u64: 0x%016"PRIx64"\n", vmsg->payload.u64); |
| |
| return true; |
| } |
| |
| static void |
| vu_set_enable_all_rings(VuDev *dev, bool enabled) |
| { |
| uint16_t i; |
| |
| for (i = 0; i < dev->max_queues; i++) { |
| dev->vq[i].enable = enabled; |
| } |
| } |
| |
| static bool |
| vu_set_features_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64); |
| |
| dev->features = vmsg->payload.u64; |
| if (!vu_has_feature(dev, VIRTIO_F_VERSION_1)) { |
| /* |
| * We only support devices conforming to VIRTIO 1.0 or |
| * later |
| */ |
| vu_panic(dev, "virtio legacy devices aren't supported by libvhost-user"); |
| return false; |
| } |
| |
| if (!(dev->features & VHOST_USER_F_PROTOCOL_FEATURES)) { |
| vu_set_enable_all_rings(dev, true); |
| } |
| |
| if (dev->iface->set_features) { |
| dev->iface->set_features(dev, dev->features); |
| } |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_owner_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| return false; |
| } |
| |
| static void |
| vu_close_log(VuDev *dev) |
| { |
| if (dev->log_table) { |
| if (munmap(dev->log_table, dev->log_size) != 0) { |
| perror("close log munmap() error"); |
| } |
| |
| dev->log_table = NULL; |
| } |
| if (dev->log_call_fd != -1) { |
| close(dev->log_call_fd); |
| dev->log_call_fd = -1; |
| } |
| } |
| |
| static bool |
| vu_reset_device_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| vu_set_enable_all_rings(dev, false); |
| |
| return false; |
| } |
| |
| static bool |
| map_ring(VuDev *dev, VuVirtq *vq) |
| { |
| vq->vring.desc = qva_to_va(dev, vq->vra.desc_user_addr); |
| vq->vring.used = qva_to_va(dev, vq->vra.used_user_addr); |
| vq->vring.avail = qva_to_va(dev, vq->vra.avail_user_addr); |
| |
| DPRINT("Setting virtq addresses:\n"); |
| DPRINT(" vring_desc at %p\n", vq->vring.desc); |
| DPRINT(" vring_used at %p\n", vq->vring.used); |
| DPRINT(" vring_avail at %p\n", vq->vring.avail); |
| |
| return !(vq->vring.desc && vq->vring.used && vq->vring.avail); |
| } |
| |
| static bool |
| generate_faults(VuDev *dev) { |
| int i; |
| for (i = 0; i < dev->nregions; i++) { |
| VuDevRegion *dev_region = &dev->regions[i]; |
| int ret; |
| #ifdef UFFDIO_REGISTER |
| /* |
| * We should already have an open ufd. Mark each memory |
| * range as ufd. |
| * Discard any mapping we have here; note I can't use MADV_REMOVE |
| * or fallocate to make the hole since I don't want to lose |
| * data that's already arrived in the shared process. |
| * TODO: How to do hugepage |
| */ |
| ret = madvise((void *)(uintptr_t)dev_region->mmap_addr, |
| dev_region->size + dev_region->mmap_offset, |
| MADV_DONTNEED); |
| if (ret) { |
| fprintf(stderr, |
| "%s: Failed to madvise(DONTNEED) region %d: %s\n", |
| __func__, i, strerror(errno)); |
| } |
| /* |
| * Turn off transparent hugepages so we dont get lose wakeups |
| * in neighbouring pages. |
| * TODO: Turn this backon later. |
| */ |
| ret = madvise((void *)(uintptr_t)dev_region->mmap_addr, |
| dev_region->size + dev_region->mmap_offset, |
| MADV_NOHUGEPAGE); |
| if (ret) { |
| /* |
| * Note: This can happen legally on kernels that are configured |
| * without madvise'able hugepages |
| */ |
| fprintf(stderr, |
| "%s: Failed to madvise(NOHUGEPAGE) region %d: %s\n", |
| __func__, i, strerror(errno)); |
| } |
| struct uffdio_register reg_struct; |
| reg_struct.range.start = (uintptr_t)dev_region->mmap_addr; |
| reg_struct.range.len = dev_region->size + dev_region->mmap_offset; |
| reg_struct.mode = UFFDIO_REGISTER_MODE_MISSING; |
| |
| if (ioctl(dev->postcopy_ufd, UFFDIO_REGISTER, ®_struct)) { |
| vu_panic(dev, "%s: Failed to userfault region %d " |
| "@%" PRIx64 " + size:%" PRIx64 " offset: %" PRIx64 |
| ": (ufd=%d)%s\n", |
| __func__, i, |
| dev_region->mmap_addr, |
| dev_region->size, dev_region->mmap_offset, |
| dev->postcopy_ufd, strerror(errno)); |
| return false; |
| } |
| if (!(reg_struct.ioctls & ((__u64)1 << _UFFDIO_COPY))) { |
| vu_panic(dev, "%s Region (%d) doesn't support COPY", |
| __func__, i); |
| return false; |
| } |
| DPRINT("%s: region %d: Registered userfault for %" |
| PRIx64 " + %" PRIx64 "\n", __func__, i, |
| (uint64_t)reg_struct.range.start, |
| (uint64_t)reg_struct.range.len); |
| /* Now it's registered we can let the client at it */ |
| if (mprotect((void *)(uintptr_t)dev_region->mmap_addr, |
| dev_region->size + dev_region->mmap_offset, |
| PROT_READ | PROT_WRITE)) { |
| vu_panic(dev, "failed to mprotect region %d for postcopy (%s)", |
| i, strerror(errno)); |
| return false; |
| } |
| /* TODO: Stash 'zero' support flags somewhere */ |
| #endif |
| } |
| |
| return true; |
| } |
| |
| static bool |
| vu_add_mem_reg(VuDev *dev, VhostUserMsg *vmsg) { |
| int i; |
| bool track_ramblocks = dev->postcopy_listening; |
| VhostUserMemoryRegion m = vmsg->payload.memreg.region, *msg_region = &m; |
| VuDevRegion *dev_region = &dev->regions[dev->nregions]; |
| void *mmap_addr; |
| |
| if (vmsg->fd_num != 1) { |
| vmsg_close_fds(vmsg); |
| vu_panic(dev, "VHOST_USER_ADD_MEM_REG received %d fds - only 1 fd " |
| "should be sent for this message type", vmsg->fd_num); |
| return false; |
| } |
| |
| if (vmsg->size < VHOST_USER_MEM_REG_SIZE) { |
| close(vmsg->fds[0]); |
| vu_panic(dev, "VHOST_USER_ADD_MEM_REG requires a message size of at " |
| "least %zu bytes and only %d bytes were received", |
| VHOST_USER_MEM_REG_SIZE, vmsg->size); |
| return false; |
| } |
| |
| if (dev->nregions == VHOST_USER_MAX_RAM_SLOTS) { |
| close(vmsg->fds[0]); |
| vu_panic(dev, "failing attempt to hot add memory via " |
| "VHOST_USER_ADD_MEM_REG message because the backend has " |
| "no free ram slots available"); |
| return false; |
| } |
| |
| /* |
| * If we are in postcopy mode and we receive a u64 payload with a 0 value |
| * we know all the postcopy client bases have been received, and we |
| * should start generating faults. |
| */ |
| if (track_ramblocks && |
| vmsg->size == sizeof(vmsg->payload.u64) && |
| vmsg->payload.u64 == 0) { |
| (void)generate_faults(dev); |
| return false; |
| } |
| |
| DPRINT("Adding region: %u\n", dev->nregions); |
| DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n", |
| msg_region->guest_phys_addr); |
| DPRINT(" memory_size: 0x%016"PRIx64"\n", |
| msg_region->memory_size); |
| DPRINT(" userspace_addr 0x%016"PRIx64"\n", |
| msg_region->userspace_addr); |
| DPRINT(" mmap_offset 0x%016"PRIx64"\n", |
| msg_region->mmap_offset); |
| |
| dev_region->gpa = msg_region->guest_phys_addr; |
| dev_region->size = msg_region->memory_size; |
| dev_region->qva = msg_region->userspace_addr; |
| dev_region->mmap_offset = msg_region->mmap_offset; |
| |
| /* |
| * We don't use offset argument of mmap() since the |
| * mapped address has to be page aligned, and we use huge |
| * pages. |
| */ |
| if (track_ramblocks) { |
| /* |
| * In postcopy we're using PROT_NONE here to catch anyone |
| * accessing it before we userfault. |
| */ |
| mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset, |
| PROT_NONE, MAP_SHARED | MAP_NORESERVE, |
| vmsg->fds[0], 0); |
| } else { |
| mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset, |
| PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE, |
| vmsg->fds[0], 0); |
| } |
| |
| if (mmap_addr == MAP_FAILED) { |
| vu_panic(dev, "region mmap error: %s", strerror(errno)); |
| } else { |
| dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr; |
| DPRINT(" mmap_addr: 0x%016"PRIx64"\n", |
| dev_region->mmap_addr); |
| } |
| |
| close(vmsg->fds[0]); |
| |
| if (track_ramblocks) { |
| /* |
| * Return the address to QEMU so that it can translate the ufd |
| * fault addresses back. |
| */ |
| msg_region->userspace_addr = (uintptr_t)(mmap_addr + |
| dev_region->mmap_offset); |
| |
| /* Send the message back to qemu with the addresses filled in. */ |
| vmsg->fd_num = 0; |
| DPRINT("Successfully added new region in postcopy\n"); |
| dev->nregions++; |
| return true; |
| } else { |
| for (i = 0; i < dev->max_queues; i++) { |
| if (dev->vq[i].vring.desc) { |
| if (map_ring(dev, &dev->vq[i])) { |
| vu_panic(dev, "remapping queue %d for new memory region", |
| i); |
| } |
| } |
| } |
| |
| DPRINT("Successfully added new region\n"); |
| dev->nregions++; |
| return false; |
| } |
| } |
| |
| static inline bool reg_equal(VuDevRegion *vudev_reg, |
| VhostUserMemoryRegion *msg_reg) |
| { |
| if (vudev_reg->gpa == msg_reg->guest_phys_addr && |
| vudev_reg->qva == msg_reg->userspace_addr && |
| vudev_reg->size == msg_reg->memory_size) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static bool |
| vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) { |
| VhostUserMemoryRegion m = vmsg->payload.memreg.region, *msg_region = &m; |
| int i; |
| bool found = false; |
| |
| if (vmsg->fd_num > 1) { |
| vmsg_close_fds(vmsg); |
| vu_panic(dev, "VHOST_USER_REM_MEM_REG received %d fds - at most 1 fd " |
| "should be sent for this message type", vmsg->fd_num); |
| return false; |
| } |
| |
| if (vmsg->size < VHOST_USER_MEM_REG_SIZE) { |
| vmsg_close_fds(vmsg); |
| vu_panic(dev, "VHOST_USER_REM_MEM_REG requires a message size of at " |
| "least %zu bytes and only %d bytes were received", |
| VHOST_USER_MEM_REG_SIZE, vmsg->size); |
| return false; |
| } |
| |
| DPRINT("Removing region:\n"); |
| DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n", |
| msg_region->guest_phys_addr); |
| DPRINT(" memory_size: 0x%016"PRIx64"\n", |
| msg_region->memory_size); |
| DPRINT(" userspace_addr 0x%016"PRIx64"\n", |
| msg_region->userspace_addr); |
| DPRINT(" mmap_offset 0x%016"PRIx64"\n", |
| msg_region->mmap_offset); |
| |
| for (i = 0; i < dev->nregions; i++) { |
| if (reg_equal(&dev->regions[i], msg_region)) { |
| VuDevRegion *r = &dev->regions[i]; |
| void *m = (void *) (uintptr_t) r->mmap_addr; |
| |
| if (m) { |
| munmap(m, r->size + r->mmap_offset); |
| } |
| |
| /* |
| * Shift all affected entries by 1 to close the hole at index i and |
| * zero out the last entry. |
| */ |
| memmove(dev->regions + i, dev->regions + i + 1, |
| sizeof(VuDevRegion) * (dev->nregions - i - 1)); |
| memset(dev->regions + dev->nregions - 1, 0, sizeof(VuDevRegion)); |
| DPRINT("Successfully removed a region\n"); |
| dev->nregions--; |
| i--; |
| |
| found = true; |
| |
| /* Continue the search for eventual duplicates. */ |
| } |
| } |
| |
| if (!found) { |
| vu_panic(dev, "Specified region not found\n"); |
| } |
| |
| vmsg_close_fds(vmsg); |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int i; |
| VhostUserMemory m = vmsg->payload.memory, *memory = &m; |
| dev->nregions = memory->nregions; |
| |
| DPRINT("Nregions: %u\n", memory->nregions); |
| for (i = 0; i < dev->nregions; i++) { |
| void *mmap_addr; |
| VhostUserMemoryRegion *msg_region = &memory->regions[i]; |
| VuDevRegion *dev_region = &dev->regions[i]; |
| |
| DPRINT("Region %d\n", i); |
| DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n", |
| msg_region->guest_phys_addr); |
| DPRINT(" memory_size: 0x%016"PRIx64"\n", |
| msg_region->memory_size); |
| DPRINT(" userspace_addr 0x%016"PRIx64"\n", |
| msg_region->userspace_addr); |
| DPRINT(" mmap_offset 0x%016"PRIx64"\n", |
| msg_region->mmap_offset); |
| |
| dev_region->gpa = msg_region->guest_phys_addr; |
| dev_region->size = msg_region->memory_size; |
| dev_region->qva = msg_region->userspace_addr; |
| dev_region->mmap_offset = msg_region->mmap_offset; |
| |
| /* We don't use offset argument of mmap() since the |
| * mapped address has to be page aligned, and we use huge |
| * pages. |
| * In postcopy we're using PROT_NONE here to catch anyone |
| * accessing it before we userfault |
| */ |
| mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset, |
| PROT_NONE, MAP_SHARED | MAP_NORESERVE, |
| vmsg->fds[i], 0); |
| |
| if (mmap_addr == MAP_FAILED) { |
| vu_panic(dev, "region mmap error: %s", strerror(errno)); |
| } else { |
| dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr; |
| DPRINT(" mmap_addr: 0x%016"PRIx64"\n", |
| dev_region->mmap_addr); |
| } |
| |
| /* Return the address to QEMU so that it can translate the ufd |
| * fault addresses back. |
| */ |
| msg_region->userspace_addr = (uintptr_t)(mmap_addr + |
| dev_region->mmap_offset); |
| close(vmsg->fds[i]); |
| } |
| |
| /* Send the message back to qemu with the addresses filled in */ |
| vmsg->fd_num = 0; |
| if (!vu_send_reply(dev, dev->sock, vmsg)) { |
| vu_panic(dev, "failed to respond to set-mem-table for postcopy"); |
| return false; |
| } |
| |
| /* Wait for QEMU to confirm that it's registered the handler for the |
| * faults. |
| */ |
| if (!dev->read_msg(dev, dev->sock, vmsg) || |
| vmsg->size != sizeof(vmsg->payload.u64) || |
| vmsg->payload.u64 != 0) { |
| vu_panic(dev, "failed to receive valid ack for postcopy set-mem-table"); |
| return false; |
| } |
| |
| /* OK, now we can go and register the memory and generate faults */ |
| (void)generate_faults(dev); |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_mem_table_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int i; |
| VhostUserMemory m = vmsg->payload.memory, *memory = &m; |
| |
| for (i = 0; i < dev->nregions; i++) { |
| VuDevRegion *r = &dev->regions[i]; |
| void *m = (void *) (uintptr_t) r->mmap_addr; |
| |
| if (m) { |
| munmap(m, r->size + r->mmap_offset); |
| } |
| } |
| dev->nregions = memory->nregions; |
| |
| if (dev->postcopy_listening) { |
| return vu_set_mem_table_exec_postcopy(dev, vmsg); |
| } |
| |
| DPRINT("Nregions: %u\n", memory->nregions); |
| for (i = 0; i < dev->nregions; i++) { |
| void *mmap_addr; |
| VhostUserMemoryRegion *msg_region = &memory->regions[i]; |
| VuDevRegion *dev_region = &dev->regions[i]; |
| |
| DPRINT("Region %d\n", i); |
| DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n", |
| msg_region->guest_phys_addr); |
| DPRINT(" memory_size: 0x%016"PRIx64"\n", |
| msg_region->memory_size); |
| DPRINT(" userspace_addr 0x%016"PRIx64"\n", |
| msg_region->userspace_addr); |
| DPRINT(" mmap_offset 0x%016"PRIx64"\n", |
| msg_region->mmap_offset); |
| |
| dev_region->gpa = msg_region->guest_phys_addr; |
| dev_region->size = msg_region->memory_size; |
| dev_region->qva = msg_region->userspace_addr; |
| dev_region->mmap_offset = msg_region->mmap_offset; |
| |
| /* We don't use offset argument of mmap() since the |
| * mapped address has to be page aligned, and we use huge |
| * pages. */ |
| mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset, |
| PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE, |
| vmsg->fds[i], 0); |
| |
| if (mmap_addr == MAP_FAILED) { |
| vu_panic(dev, "region mmap error: %s", strerror(errno)); |
| } else { |
| dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr; |
| DPRINT(" mmap_addr: 0x%016"PRIx64"\n", |
| dev_region->mmap_addr); |
| } |
| |
| close(vmsg->fds[i]); |
| } |
| |
| for (i = 0; i < dev->max_queues; i++) { |
| if (dev->vq[i].vring.desc) { |
| if (map_ring(dev, &dev->vq[i])) { |
| vu_panic(dev, "remapping queue %d during setmemtable", i); |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_log_base_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int fd; |
| uint64_t log_mmap_size, log_mmap_offset; |
| void *rc; |
| |
| if (vmsg->fd_num != 1 || |
| vmsg->size != sizeof(vmsg->payload.log)) { |
| vu_panic(dev, "Invalid log_base message"); |
| return true; |
| } |
| |
| fd = vmsg->fds[0]; |
| log_mmap_offset = vmsg->payload.log.mmap_offset; |
| log_mmap_size = vmsg->payload.log.mmap_size; |
| DPRINT("Log mmap_offset: %"PRId64"\n", log_mmap_offset); |
| DPRINT("Log mmap_size: %"PRId64"\n", log_mmap_size); |
| |
| rc = mmap(0, log_mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, |
| log_mmap_offset); |
| close(fd); |
| if (rc == MAP_FAILED) { |
| perror("log mmap error"); |
| } |
| |
| if (dev->log_table) { |
| munmap(dev->log_table, dev->log_size); |
| } |
| dev->log_table = rc; |
| dev->log_size = log_mmap_size; |
| |
| vmsg->size = sizeof(vmsg->payload.u64); |
| vmsg->fd_num = 0; |
| |
| return true; |
| } |
| |
| static bool |
| vu_set_log_fd_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| if (vmsg->fd_num != 1) { |
| vu_panic(dev, "Invalid log_fd message"); |
| return false; |
| } |
| |
| if (dev->log_call_fd != -1) { |
| close(dev->log_call_fd); |
| } |
| dev->log_call_fd = vmsg->fds[0]; |
| DPRINT("Got log_call_fd: %d\n", vmsg->fds[0]); |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_vring_num_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| unsigned int index = vmsg->payload.state.index; |
| unsigned int num = vmsg->payload.state.num; |
| |
| DPRINT("State.index: %u\n", index); |
| DPRINT("State.num: %u\n", num); |
| dev->vq[index].vring.num = num; |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_vring_addr_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| struct vhost_vring_addr addr = vmsg->payload.addr, *vra = &addr; |
| unsigned int index = vra->index; |
| VuVirtq *vq = &dev->vq[index]; |
| |
| DPRINT("vhost_vring_addr:\n"); |
| DPRINT(" index: %d\n", vra->index); |
| DPRINT(" flags: %d\n", vra->flags); |
| DPRINT(" desc_user_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->desc_user_addr); |
| DPRINT(" used_user_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->used_user_addr); |
| DPRINT(" avail_user_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->avail_user_addr); |
| DPRINT(" log_guest_addr: 0x%016" PRIx64 "\n", (uint64_t)vra->log_guest_addr); |
| |
| vq->vra = *vra; |
| vq->vring.flags = vra->flags; |
| vq->vring.log_guest_addr = vra->log_guest_addr; |
| |
| |
| if (map_ring(dev, vq)) { |
| vu_panic(dev, "Invalid vring_addr message"); |
| return false; |
| } |
| |
| vq->used_idx = le16toh(vq->vring.used->idx); |
| |
| if (vq->last_avail_idx != vq->used_idx) { |
| bool resume = dev->iface->queue_is_processed_in_order && |
| dev->iface->queue_is_processed_in_order(dev, index); |
| |
| DPRINT("Last avail index != used index: %u != %u%s\n", |
| vq->last_avail_idx, vq->used_idx, |
| resume ? ", resuming" : ""); |
| |
| if (resume) { |
| vq->shadow_avail_idx = vq->last_avail_idx = vq->used_idx; |
| } |
| } |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_vring_base_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| unsigned int index = vmsg->payload.state.index; |
| unsigned int num = vmsg->payload.state.num; |
| |
| DPRINT("State.index: %u\n", index); |
| DPRINT("State.num: %u\n", num); |
| dev->vq[index].shadow_avail_idx = dev->vq[index].last_avail_idx = num; |
| |
| return false; |
| } |
| |
| static bool |
| vu_get_vring_base_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| unsigned int index = vmsg->payload.state.index; |
| |
| DPRINT("State.index: %u\n", index); |
| vmsg->payload.state.num = dev->vq[index].last_avail_idx; |
| vmsg->size = sizeof(vmsg->payload.state); |
| |
| dev->vq[index].started = false; |
| if (dev->iface->queue_set_started) { |
| dev->iface->queue_set_started(dev, index, false); |
| } |
| |
| if (dev->vq[index].call_fd != -1) { |
| close(dev->vq[index].call_fd); |
| dev->vq[index].call_fd = -1; |
| } |
| if (dev->vq[index].kick_fd != -1) { |
| dev->remove_watch(dev, dev->vq[index].kick_fd); |
| close(dev->vq[index].kick_fd); |
| dev->vq[index].kick_fd = -1; |
| } |
| |
| return true; |
| } |
| |
| static bool |
| vu_check_queue_msg_file(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK; |
| bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK; |
| |
| if (index >= dev->max_queues) { |
| vmsg_close_fds(vmsg); |
| vu_panic(dev, "Invalid queue index: %u", index); |
| return false; |
| } |
| |
| if (nofd) { |
| vmsg_close_fds(vmsg); |
| return true; |
| } |
| |
| if (vmsg->fd_num != 1) { |
| vmsg_close_fds(vmsg); |
| vu_panic(dev, "Invalid fds in request: %d", vmsg->request); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static int |
| inflight_desc_compare(const void *a, const void *b) |
| { |
| VuVirtqInflightDesc *desc0 = (VuVirtqInflightDesc *)a, |
| *desc1 = (VuVirtqInflightDesc *)b; |
| |
| if (desc1->counter > desc0->counter && |
| (desc1->counter - desc0->counter) < VIRTQUEUE_MAX_SIZE * 2) { |
| return 1; |
| } |
| |
| return -1; |
| } |
| |
| static int |
| vu_check_queue_inflights(VuDev *dev, VuVirtq *vq) |
| { |
| int i = 0; |
| |
| if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) { |
| return 0; |
| } |
| |
| if (unlikely(!vq->inflight)) { |
| return -1; |
| } |
| |
| if (unlikely(!vq->inflight->version)) { |
| /* initialize the buffer */ |
| vq->inflight->version = INFLIGHT_VERSION; |
| return 0; |
| } |
| |
| vq->used_idx = le16toh(vq->vring.used->idx); |
| vq->resubmit_num = 0; |
| vq->resubmit_list = NULL; |
| vq->counter = 0; |
| |
| if (unlikely(vq->inflight->used_idx != vq->used_idx)) { |
| vq->inflight->desc[vq->inflight->last_batch_head].inflight = 0; |
| |
| barrier(); |
| |
| vq->inflight->used_idx = vq->used_idx; |
| } |
| |
| for (i = 0; i < vq->inflight->desc_num; i++) { |
| if (vq->inflight->desc[i].inflight == 1) { |
| vq->inuse++; |
| } |
| } |
| |
| vq->shadow_avail_idx = vq->last_avail_idx = vq->inuse + vq->used_idx; |
| |
| if (vq->inuse) { |
| vq->resubmit_list = calloc(vq->inuse, sizeof(VuVirtqInflightDesc)); |
| if (!vq->resubmit_list) { |
| return -1; |
| } |
| |
| for (i = 0; i < vq->inflight->desc_num; i++) { |
| if (vq->inflight->desc[i].inflight) { |
| vq->resubmit_list[vq->resubmit_num].index = i; |
| vq->resubmit_list[vq->resubmit_num].counter = |
| vq->inflight->desc[i].counter; |
| vq->resubmit_num++; |
| } |
| } |
| |
| if (vq->resubmit_num > 1) { |
| qsort(vq->resubmit_list, vq->resubmit_num, |
| sizeof(VuVirtqInflightDesc), inflight_desc_compare); |
| } |
| vq->counter = vq->resubmit_list[0].counter + 1; |
| } |
| |
| /* in case of I/O hang after reconnecting */ |
| if (eventfd_write(vq->kick_fd, 1)) { |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static bool |
| vu_set_vring_kick_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK; |
| bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK; |
| |
| DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64); |
| |
| if (!vu_check_queue_msg_file(dev, vmsg)) { |
| return false; |
| } |
| |
| if (dev->vq[index].kick_fd != -1) { |
| dev->remove_watch(dev, dev->vq[index].kick_fd); |
| close(dev->vq[index].kick_fd); |
| dev->vq[index].kick_fd = -1; |
| } |
| |
| dev->vq[index].kick_fd = nofd ? -1 : vmsg->fds[0]; |
| DPRINT("Got kick_fd: %d for vq: %d\n", dev->vq[index].kick_fd, index); |
| |
| dev->vq[index].started = true; |
| if (dev->iface->queue_set_started) { |
| dev->iface->queue_set_started(dev, index, true); |
| } |
| |
| if (dev->vq[index].kick_fd != -1 && dev->vq[index].handler) { |
| dev->set_watch(dev, dev->vq[index].kick_fd, VU_WATCH_IN, |
| vu_kick_cb, (void *)(long)index); |
| |
| DPRINT("Waiting for kicks on fd: %d for vq: %d\n", |
| dev->vq[index].kick_fd, index); |
| } |
| |
| if (vu_check_queue_inflights(dev, &dev->vq[index])) { |
| vu_panic(dev, "Failed to check inflights for vq: %d\n", index); |
| } |
| |
| return false; |
| } |
| |
| void vu_set_queue_handler(VuDev *dev, VuVirtq *vq, |
| vu_queue_handler_cb handler) |
| { |
| int qidx = vq - dev->vq; |
| |
| vq->handler = handler; |
| if (vq->kick_fd >= 0) { |
| if (handler) { |
| dev->set_watch(dev, vq->kick_fd, VU_WATCH_IN, |
| vu_kick_cb, (void *)(long)qidx); |
| } else { |
| dev->remove_watch(dev, vq->kick_fd); |
| } |
| } |
| } |
| |
| bool vu_set_queue_host_notifier(VuDev *dev, VuVirtq *vq, int fd, |
| int size, int offset) |
| { |
| int qidx = vq - dev->vq; |
| int fd_num = 0; |
| VhostUserMsg vmsg = { |
| .request = VHOST_USER_SLAVE_VRING_HOST_NOTIFIER_MSG, |
| .flags = VHOST_USER_VERSION | VHOST_USER_NEED_REPLY_MASK, |
| .size = sizeof(vmsg.payload.area), |
| .payload.area = { |
| .u64 = qidx & VHOST_USER_VRING_IDX_MASK, |
| .size = size, |
| .offset = offset, |
| }, |
| }; |
| |
| if (fd == -1) { |
| vmsg.payload.area.u64 |= VHOST_USER_VRING_NOFD_MASK; |
| } else { |
| vmsg.fds[fd_num++] = fd; |
| } |
| |
| vmsg.fd_num = fd_num; |
| |
| if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD)) { |
| return false; |
| } |
| |
| pthread_mutex_lock(&dev->slave_mutex); |
| if (!vu_message_write(dev, dev->slave_fd, &vmsg)) { |
| pthread_mutex_unlock(&dev->slave_mutex); |
| return false; |
| } |
| |
| /* Also unlocks the slave_mutex */ |
| return vu_process_message_reply(dev, &vmsg); |
| } |
| |
| static bool |
| vu_set_vring_call_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK; |
| bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK; |
| |
| DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64); |
| |
| if (!vu_check_queue_msg_file(dev, vmsg)) { |
| return false; |
| } |
| |
| if (dev->vq[index].call_fd != -1) { |
| close(dev->vq[index].call_fd); |
| dev->vq[index].call_fd = -1; |
| } |
| |
| dev->vq[index].call_fd = nofd ? -1 : vmsg->fds[0]; |
| |
| /* in case of I/O hang after reconnecting */ |
| if (dev->vq[index].call_fd != -1 && eventfd_write(vmsg->fds[0], 1)) { |
| return -1; |
| } |
| |
| DPRINT("Got call_fd: %d for vq: %d\n", dev->vq[index].call_fd, index); |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_vring_err_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int index = vmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK; |
| bool nofd = vmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK; |
| |
| DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64); |
| |
| if (!vu_check_queue_msg_file(dev, vmsg)) { |
| return false; |
| } |
| |
| if (dev->vq[index].err_fd != -1) { |
| close(dev->vq[index].err_fd); |
| dev->vq[index].err_fd = -1; |
| } |
| |
| dev->vq[index].err_fd = nofd ? -1 : vmsg->fds[0]; |
| |
| return false; |
| } |
| |
| static bool |
| vu_get_protocol_features_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| /* |
| * Note that we support, but intentionally do not set, |
| * VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS. This means that |
| * a device implementation can return it in its callback |
| * (get_protocol_features) if it wants to use this for |
| * simulation, but it is otherwise not desirable (if even |
| * implemented by the master.) |
| */ |
| uint64_t features = 1ULL << VHOST_USER_PROTOCOL_F_MQ | |
| 1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD | |
| 1ULL << VHOST_USER_PROTOCOL_F_SLAVE_REQ | |
| 1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER | |
| 1ULL << VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD | |
| 1ULL << VHOST_USER_PROTOCOL_F_REPLY_ACK | |
| 1ULL << VHOST_USER_PROTOCOL_F_CONFIGURE_MEM_SLOTS; |
| |
| if (have_userfault()) { |
| features |= 1ULL << VHOST_USER_PROTOCOL_F_PAGEFAULT; |
| } |
| |
| if (dev->iface->get_config && dev->iface->set_config) { |
| features |= 1ULL << VHOST_USER_PROTOCOL_F_CONFIG; |
| } |
| |
| if (dev->iface->get_protocol_features) { |
| features |= dev->iface->get_protocol_features(dev); |
| } |
| |
| vmsg_set_reply_u64(vmsg, features); |
| return true; |
| } |
| |
| static bool |
| vu_set_protocol_features_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| uint64_t features = vmsg->payload.u64; |
| |
| DPRINT("u64: 0x%016"PRIx64"\n", features); |
| |
| dev->protocol_features = vmsg->payload.u64; |
| |
| if (vu_has_protocol_feature(dev, |
| VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS) && |
| (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SLAVE_REQ) || |
| !vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_REPLY_ACK))) { |
| /* |
| * The use case for using messages for kick/call is simulation, to make |
| * the kick and call synchronous. To actually get that behaviour, both |
| * of the other features are required. |
| * Theoretically, one could use only kick messages, or do them without |
| * having F_REPLY_ACK, but too many (possibly pending) messages on the |
| * socket will eventually cause the master to hang, to avoid this in |
| * scenarios where not desired enforce that the settings are in a way |
| * that actually enables the simulation case. |
| */ |
| vu_panic(dev, |
| "F_IN_BAND_NOTIFICATIONS requires F_SLAVE_REQ && F_REPLY_ACK"); |
| return false; |
| } |
| |
| if (dev->iface->set_protocol_features) { |
| dev->iface->set_protocol_features(dev, features); |
| } |
| |
| return false; |
| } |
| |
| static bool |
| vu_get_queue_num_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| vmsg_set_reply_u64(vmsg, dev->max_queues); |
| return true; |
| } |
| |
| static bool |
| vu_set_vring_enable_exec(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| unsigned int index = vmsg->payload.state.index; |
| unsigned int enable = vmsg->payload.state.num; |
| |
| DPRINT("State.index: %u\n", index); |
| DPRINT("State.enable: %u\n", enable); |
| |
| if (index >= dev->max_queues) { |
| vu_panic(dev, "Invalid vring_enable index: %u", index); |
| return false; |
| } |
| |
| dev->vq[index].enable = enable; |
| return false; |
| } |
| |
| static bool |
| vu_set_slave_req_fd(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| if (vmsg->fd_num != 1) { |
| vu_panic(dev, "Invalid slave_req_fd message (%d fd's)", vmsg->fd_num); |
| return false; |
| } |
| |
| if (dev->slave_fd != -1) { |
| close(dev->slave_fd); |
| } |
| dev->slave_fd = vmsg->fds[0]; |
| DPRINT("Got slave_fd: %d\n", vmsg->fds[0]); |
| |
| return false; |
| } |
| |
| static bool |
| vu_get_config(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int ret = -1; |
| |
| if (dev->iface->get_config) { |
| ret = dev->iface->get_config(dev, vmsg->payload.config.region, |
| vmsg->payload.config.size); |
| } |
| |
| if (ret) { |
| /* resize to zero to indicate an error to master */ |
| vmsg->size = 0; |
| } |
| |
| return true; |
| } |
| |
| static bool |
| vu_set_config(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int ret = -1; |
| |
| if (dev->iface->set_config) { |
| ret = dev->iface->set_config(dev, vmsg->payload.config.region, |
| vmsg->payload.config.offset, |
| vmsg->payload.config.size, |
| vmsg->payload.config.flags); |
| if (ret) { |
| vu_panic(dev, "Set virtio configuration space failed"); |
| } |
| } |
| |
| return false; |
| } |
| |
| static bool |
| vu_set_postcopy_advise(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| dev->postcopy_ufd = -1; |
| #ifdef UFFDIO_API |
| struct uffdio_api api_struct; |
| |
| dev->postcopy_ufd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK); |
| vmsg->size = 0; |
| #endif |
| |
| if (dev->postcopy_ufd == -1) { |
| vu_panic(dev, "Userfaultfd not available: %s", strerror(errno)); |
| goto out; |
| } |
| |
| #ifdef UFFDIO_API |
| api_struct.api = UFFD_API; |
| api_struct.features = 0; |
| if (ioctl(dev->postcopy_ufd, UFFDIO_API, &api_struct)) { |
| vu_panic(dev, "Failed UFFDIO_API: %s", strerror(errno)); |
| close(dev->postcopy_ufd); |
| dev->postcopy_ufd = -1; |
| goto out; |
| } |
| /* TODO: Stash feature flags somewhere */ |
| #endif |
| |
| out: |
| /* Return a ufd to the QEMU */ |
| vmsg->fd_num = 1; |
| vmsg->fds[0] = dev->postcopy_ufd; |
| return true; /* = send a reply */ |
| } |
| |
| static bool |
| vu_set_postcopy_listen(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| if (dev->nregions) { |
| vu_panic(dev, "Regions already registered at postcopy-listen"); |
| vmsg_set_reply_u64(vmsg, -1); |
| return true; |
| } |
| dev->postcopy_listening = true; |
| |
| vmsg_set_reply_u64(vmsg, 0); |
| return true; |
| } |
| |
| static bool |
| vu_set_postcopy_end(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| DPRINT("%s: Entry\n", __func__); |
| dev->postcopy_listening = false; |
| if (dev->postcopy_ufd > 0) { |
| close(dev->postcopy_ufd); |
| dev->postcopy_ufd = -1; |
| DPRINT("%s: Done close\n", __func__); |
| } |
| |
| vmsg_set_reply_u64(vmsg, 0); |
| DPRINT("%s: exit\n", __func__); |
| return true; |
| } |
| |
| static inline uint64_t |
| vu_inflight_queue_size(uint16_t queue_size) |
| { |
| return ALIGN_UP(sizeof(VuDescStateSplit) * queue_size + |
| sizeof(uint16_t), INFLIGHT_ALIGNMENT); |
| } |
| |
| #ifdef MFD_ALLOW_SEALING |
| static void * |
| memfd_alloc(const char *name, size_t size, unsigned int flags, int *fd) |
| { |
| void *ptr; |
| int ret; |
| |
| *fd = memfd_create(name, MFD_ALLOW_SEALING); |
| if (*fd < 0) { |
| return NULL; |
| } |
| |
| ret = ftruncate(*fd, size); |
| if (ret < 0) { |
| close(*fd); |
| return NULL; |
| } |
| |
| ret = fcntl(*fd, F_ADD_SEALS, flags); |
| if (ret < 0) { |
| close(*fd); |
| return NULL; |
| } |
| |
| ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, *fd, 0); |
| if (ptr == MAP_FAILED) { |
| close(*fd); |
| return NULL; |
| } |
| |
| return ptr; |
| } |
| #endif |
| |
| static bool |
| vu_get_inflight_fd(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int fd = -1; |
| void *addr = NULL; |
| uint64_t mmap_size; |
| uint16_t num_queues, queue_size; |
| |
| if (vmsg->size != sizeof(vmsg->payload.inflight)) { |
| vu_panic(dev, "Invalid get_inflight_fd message:%d", vmsg->size); |
| vmsg->payload.inflight.mmap_size = 0; |
| return true; |
| } |
| |
| num_queues = vmsg->payload.inflight.num_queues; |
| queue_size = vmsg->payload.inflight.queue_size; |
| |
| DPRINT("set_inflight_fd num_queues: %"PRId16"\n", num_queues); |
| DPRINT("set_inflight_fd queue_size: %"PRId16"\n", queue_size); |
| |
| mmap_size = vu_inflight_queue_size(queue_size) * num_queues; |
| |
| #ifdef MFD_ALLOW_SEALING |
| addr = memfd_alloc("vhost-inflight", mmap_size, |
| F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL, |
| &fd); |
| #else |
| vu_panic(dev, "Not implemented: memfd support is missing"); |
| #endif |
| |
| if (!addr) { |
| vu_panic(dev, "Failed to alloc vhost inflight area"); |
| vmsg->payload.inflight.mmap_size = 0; |
| return true; |
| } |
| |
| memset(addr, 0, mmap_size); |
| |
| dev->inflight_info.addr = addr; |
| dev->inflight_info.size = vmsg->payload.inflight.mmap_size = mmap_size; |
| dev->inflight_info.fd = vmsg->fds[0] = fd; |
| vmsg->fd_num = 1; |
| vmsg->payload.inflight.mmap_offset = 0; |
| |
| DPRINT("send inflight mmap_size: %"PRId64"\n", |
| vmsg->payload.inflight.mmap_size); |
| DPRINT("send inflight mmap offset: %"PRId64"\n", |
| vmsg->payload.inflight.mmap_offset); |
| |
| return true; |
| } |
| |
| static bool |
| vu_set_inflight_fd(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int fd, i; |
| uint64_t mmap_size, mmap_offset; |
| uint16_t num_queues, queue_size; |
| void *rc; |
| |
| if (vmsg->fd_num != 1 || |
| vmsg->size != sizeof(vmsg->payload.inflight)) { |
| vu_panic(dev, "Invalid set_inflight_fd message size:%d fds:%d", |
| vmsg->size, vmsg->fd_num); |
| return false; |
| } |
| |
| fd = vmsg->fds[0]; |
| mmap_size = vmsg->payload.inflight.mmap_size; |
| mmap_offset = vmsg->payload.inflight.mmap_offset; |
| num_queues = vmsg->payload.inflight.num_queues; |
| queue_size = vmsg->payload.inflight.queue_size; |
| |
| DPRINT("set_inflight_fd mmap_size: %"PRId64"\n", mmap_size); |
| DPRINT("set_inflight_fd mmap_offset: %"PRId64"\n", mmap_offset); |
| DPRINT("set_inflight_fd num_queues: %"PRId16"\n", num_queues); |
| DPRINT("set_inflight_fd queue_size: %"PRId16"\n", queue_size); |
| |
| rc = mmap(0, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, |
| fd, mmap_offset); |
| |
| if (rc == MAP_FAILED) { |
| vu_panic(dev, "set_inflight_fd mmap error: %s", strerror(errno)); |
| return false; |
| } |
| |
| if (dev->inflight_info.fd) { |
| close(dev->inflight_info.fd); |
| } |
| |
| if (dev->inflight_info.addr) { |
| munmap(dev->inflight_info.addr, dev->inflight_info.size); |
| } |
| |
| dev->inflight_info.fd = fd; |
| dev->inflight_info.addr = rc; |
| dev->inflight_info.size = mmap_size; |
| |
| for (i = 0; i < num_queues; i++) { |
| dev->vq[i].inflight = (VuVirtqInflight *)rc; |
| dev->vq[i].inflight->desc_num = queue_size; |
| rc = (void *)((char *)rc + vu_inflight_queue_size(queue_size)); |
| } |
| |
| return false; |
| } |
| |
| static bool |
| vu_handle_vring_kick(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| unsigned int index = vmsg->payload.state.index; |
| |
| if (index >= dev->max_queues) { |
| vu_panic(dev, "Invalid queue index: %u", index); |
| return false; |
| } |
| |
| DPRINT("Got kick message: handler:%p idx:%u\n", |
| dev->vq[index].handler, index); |
| |
| if (!dev->vq[index].started) { |
| dev->vq[index].started = true; |
| |
| if (dev->iface->queue_set_started) { |
| dev->iface->queue_set_started(dev, index, true); |
| } |
| } |
| |
| if (dev->vq[index].handler) { |
| dev->vq[index].handler(dev, index); |
| } |
| |
| return false; |
| } |
| |
| static bool vu_handle_get_max_memslots(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| vmsg_set_reply_u64(vmsg, VHOST_USER_MAX_RAM_SLOTS); |
| |
| DPRINT("u64: 0x%016"PRIx64"\n", (uint64_t) VHOST_USER_MAX_RAM_SLOTS); |
| |
| return true; |
| } |
| |
| static bool |
| vu_process_message(VuDev *dev, VhostUserMsg *vmsg) |
| { |
| int do_reply = 0; |
| |
| /* Print out generic part of the request. */ |
| DPRINT("================ Vhost user message ================\n"); |
| DPRINT("Request: %s (%d)\n", vu_request_to_string(vmsg->request), |
| vmsg->request); |
| DPRINT("Flags: 0x%x\n", vmsg->flags); |
| DPRINT("Size: %u\n", vmsg->size); |
| |
| if (vmsg->fd_num) { |
| int i; |
| DPRINT("Fds:"); |
| for (i = 0; i < vmsg->fd_num; i++) { |
| DPRINT(" %d", vmsg->fds[i]); |
| } |
| DPRINT("\n"); |
| } |
| |
| if (dev->iface->process_msg && |
| dev->iface->process_msg(dev, vmsg, &do_reply)) { |
| return do_reply; |
| } |
| |
| switch (vmsg->request) { |
| case VHOST_USER_GET_FEATURES: |
| return vu_get_features_exec(dev, vmsg); |
| case VHOST_USER_SET_FEATURES: |
| return vu_set_features_exec(dev, vmsg); |
| case VHOST_USER_GET_PROTOCOL_FEATURES: |
| return vu_get_protocol_features_exec(dev, vmsg); |
| case VHOST_USER_SET_PROTOCOL_FEATURES: |
| return vu_set_protocol_features_exec(dev, vmsg); |
| case VHOST_USER_SET_OWNER: |
| return vu_set_owner_exec(dev, vmsg); |
| case VHOST_USER_RESET_OWNER: |
| return vu_reset_device_exec(dev, vmsg); |
| case VHOST_USER_SET_MEM_TABLE: |
| return vu_set_mem_table_exec(dev, vmsg); |
| case VHOST_USER_SET_LOG_BASE: |
| return vu_set_log_base_exec(dev, vmsg); |
| case VHOST_USER_SET_LOG_FD: |
| return vu_set_log_fd_exec(dev, vmsg); |
| case VHOST_USER_SET_VRING_NUM: |
| return vu_set_vring_num_exec(dev, vmsg); |
| case VHOST_USER_SET_VRING_ADDR: |
| return vu_set_vring_addr_exec(dev, vmsg); |
| case VHOST_USER_SET_VRING_BASE: |
| return vu_set_vring_base_exec(dev, vmsg); |
| case VHOST_USER_GET_VRING_BASE: |
| return vu_get_vring_base_exec(dev, vmsg); |
| case VHOST_USER_SET_VRING_KICK: |
| return vu_set_vring_kick_exec(dev, vmsg); |
| case VHOST_USER_SET_VRING_CALL: |
| return vu_set_vring_call_exec(dev, vmsg); |
| case VHOST_USER_SET_VRING_ERR: |
| return vu_set_vring_err_exec(dev, vmsg); |
| case VHOST_USER_GET_QUEUE_NUM: |
| return vu_get_queue_num_exec(dev, vmsg); |
| case VHOST_USER_SET_VRING_ENABLE: |
| return vu_set_vring_enable_exec(dev, vmsg); |
| case VHOST_USER_SET_SLAVE_REQ_FD: |
| return vu_set_slave_req_fd(dev, vmsg); |
| case VHOST_USER_GET_CONFIG: |
| return vu_get_config(dev, vmsg); |
| case VHOST_USER_SET_CONFIG: |
| return vu_set_config(dev, vmsg); |
| case VHOST_USER_NONE: |
| /* if you need processing before exit, override iface->process_msg */ |
| exit(0); |
| case VHOST_USER_POSTCOPY_ADVISE: |
| return vu_set_postcopy_advise(dev, vmsg); |
| case VHOST_USER_POSTCOPY_LISTEN: |
| return vu_set_postcopy_listen(dev, vmsg); |
| case VHOST_USER_POSTCOPY_END: |
| return vu_set_postcopy_end(dev, vmsg); |
| case VHOST_USER_GET_INFLIGHT_FD: |
| return vu_get_inflight_fd(dev, vmsg); |
| case VHOST_USER_SET_INFLIGHT_FD: |
| return vu_set_inflight_fd(dev, vmsg); |
| case VHOST_USER_VRING_KICK: |
| return vu_handle_vring_kick(dev, vmsg); |
| case VHOST_USER_GET_MAX_MEM_SLOTS: |
| return vu_handle_get_max_memslots(dev, vmsg); |
| case VHOST_USER_ADD_MEM_REG: |
| return vu_add_mem_reg(dev, vmsg); |
| case VHOST_USER_REM_MEM_REG: |
| return vu_rem_mem_reg(dev, vmsg); |
| default: |
| vmsg_close_fds(vmsg); |
| vu_panic(dev, "Unhandled request: %d", vmsg->request); |
| } |
| |
| return false; |
| } |
| |
| bool |
| vu_dispatch(VuDev *dev) |
| { |
| VhostUserMsg vmsg = { 0, }; |
| int reply_requested; |
| bool need_reply, success = false; |
| |
| if (!dev->read_msg(dev, dev->sock, &vmsg)) { |
| goto end; |
| } |
| |
| need_reply = vmsg.flags & VHOST_USER_NEED_REPLY_MASK; |
| |
| reply_requested = vu_process_message(dev, &vmsg); |
| if (!reply_requested && need_reply) { |
| vmsg_set_reply_u64(&vmsg, 0); |
| reply_requested = 1; |
| } |
| |
| if (!reply_requested) { |
| success = true; |
| goto end; |
| } |
| |
| if (!vu_send_reply(dev, dev->sock, &vmsg)) { |
| goto end; |
| } |
| |
| success = true; |
| |
| end: |
| free(vmsg.data); |
| return success; |
| } |
| |
| void |
| vu_deinit(VuDev *dev) |
| { |
| int i; |
| |
| for (i = 0; i < dev->nregions; i++) { |
| VuDevRegion *r = &dev->regions[i]; |
| void *m = (void *) (uintptr_t) r->mmap_addr; |
| if (m != MAP_FAILED) { |
| munmap(m, r->size + r->mmap_offset); |
| } |
| } |
| dev->nregions = 0; |
| |
| for (i = 0; i < dev->max_queues; i++) { |
| VuVirtq *vq = &dev->vq[i]; |
| |
| if (vq->call_fd != -1) { |
| close(vq->call_fd); |
| vq->call_fd = -1; |
| } |
| |
| if (vq->kick_fd != -1) { |
| dev->remove_watch(dev, vq->kick_fd); |
| close(vq->kick_fd); |
| vq->kick_fd = -1; |
| } |
| |
| if (vq->err_fd != -1) { |
| close(vq->err_fd); |
| vq->err_fd = -1; |
| } |
| |
| if (vq->resubmit_list) { |
| free(vq->resubmit_list); |
| vq->resubmit_list = NULL; |
| } |
| |
| vq->inflight = NULL; |
| } |
| |
| if (dev->inflight_info.addr) { |
| munmap(dev->inflight_info.addr, dev->inflight_info.size); |
| dev->inflight_info.addr = NULL; |
| } |
| |
| if (dev->inflight_info.fd > 0) { |
| close(dev->inflight_info.fd); |
| dev->inflight_info.fd = -1; |
| } |
| |
| vu_close_log(dev); |
| if (dev->slave_fd != -1) { |
| close(dev->slave_fd); |
| dev->slave_fd = -1; |
| } |
| pthread_mutex_destroy(&dev->slave_mutex); |
| |
| if (dev->sock != -1) { |
| close(dev->sock); |
| } |
| |
| free(dev->vq); |
| dev->vq = NULL; |
| } |
| |
| bool |
| vu_init(VuDev *dev, |
| uint16_t max_queues, |
| int socket, |
| vu_panic_cb panic, |
| vu_read_msg_cb read_msg, |
| vu_set_watch_cb set_watch, |
| vu_remove_watch_cb remove_watch, |
| const VuDevIface *iface) |
| { |
| uint16_t i; |
| |
| assert(max_queues > 0); |
| assert(socket >= 0); |
| assert(set_watch); |
| assert(remove_watch); |
| assert(iface); |
| assert(panic); |
| |
| memset(dev, 0, sizeof(*dev)); |
| |
| dev->sock = socket; |
| dev->panic = panic; |
| dev->read_msg = read_msg ? read_msg : vu_message_read_default; |
| dev->set_watch = set_watch; |
| dev->remove_watch = remove_watch; |
| dev->iface = iface; |
| dev->log_call_fd = -1; |
| pthread_mutex_init(&dev->slave_mutex, NULL); |
| dev->slave_fd = -1; |
| dev->max_queues = max_queues; |
| |
| dev->vq = malloc(max_queues * sizeof(dev->vq[0])); |
| if (!dev->vq) { |
| DPRINT("%s: failed to malloc virtqueues\n", __func__); |
| return false; |
| } |
| |
| for (i = 0; i < max_queues; i++) { |
| dev->vq[i] = (VuVirtq) { |
| .call_fd = -1, .kick_fd = -1, .err_fd = -1, |
| .notification = true, |
| }; |
| } |
| |
| return true; |
| } |
| |
| VuVirtq * |
| vu_get_queue(VuDev *dev, int qidx) |
| { |
| assert(qidx < dev->max_queues); |
| return &dev->vq[qidx]; |
| } |
| |
| bool |
| vu_queue_enabled(VuDev *dev, VuVirtq *vq) |
| { |
| return vq->enable; |
| } |
| |
| bool |
| vu_queue_started(const VuDev *dev, const VuVirtq *vq) |
| { |
| return vq->started; |
| } |
| |
| static inline uint16_t |
| vring_avail_flags(VuVirtq *vq) |
| { |
| return le16toh(vq->vring.avail->flags); |
| } |
| |
| static inline uint16_t |
| vring_avail_idx(VuVirtq *vq) |
| { |
| vq->shadow_avail_idx = le16toh(vq->vring.avail->idx); |
| |
| return vq->shadow_avail_idx; |
| } |
| |
| static inline uint16_t |
| vring_avail_ring(VuVirtq *vq, int i) |
| { |
| return le16toh(vq->vring.avail->ring[i]); |
| } |
| |
| static inline uint16_t |
| vring_get_used_event(VuVirtq *vq) |
| { |
| return vring_avail_ring(vq, vq->vring.num); |
| } |
| |
| static int |
| virtqueue_num_heads(VuDev *dev, VuVirtq *vq, unsigned int idx) |
| { |
| uint16_t num_heads = vring_avail_idx(vq) - idx; |
| |
| /* Check it isn't doing very strange things with descriptor numbers. */ |
| if (num_heads > vq->vring.num) { |
| vu_panic(dev, "Guest moved used index from %u to %u", |
| idx, vq->shadow_avail_idx); |
| return -1; |
| } |
| if (num_heads) { |
| /* On success, callers read a descriptor at vq->last_avail_idx. |
| * Make sure descriptor read does not bypass avail index read. */ |
| smp_rmb(); |
| } |
| |
| return num_heads; |
| } |
| |
| static bool |
| virtqueue_get_head(VuDev *dev, VuVirtq *vq, |
| unsigned int idx, unsigned int *head) |
| { |
| /* Grab the next descriptor number they're advertising, and increment |
| * the index we've seen. */ |
| *head = vring_avail_ring(vq, idx % vq->vring.num); |
| |
| /* If their number is silly, that's a fatal mistake. */ |
| if (*head >= vq->vring.num) { |
| vu_panic(dev, "Guest says index %u is available", *head); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static int |
| virtqueue_read_indirect_desc(VuDev *dev, struct vring_desc *desc, |
| uint64_t addr, size_t len) |
| { |
| struct vring_desc *ori_desc; |
| uint64_t read_len; |
| |
| if (len > (VIRTQUEUE_MAX_SIZE * sizeof(struct vring_desc))) { |
| return -1; |
| } |
| |
| if (len == 0) { |
| return -1; |
| } |
| |
| while (len) { |
| read_len = len; |
| ori_desc = vu_gpa_to_va(dev, &read_len, addr); |
| if (!ori_desc) { |
| return -1; |
| } |
| |
| memcpy(desc, ori_desc, read_len); |
| len -= read_len; |
| addr += read_len; |
| desc += read_len; |
| } |
| |
| return 0; |
| } |
| |
| enum { |
| VIRTQUEUE_READ_DESC_ERROR = -1, |
| VIRTQUEUE_READ_DESC_DONE = 0, /* end of chain */ |
| VIRTQUEUE_READ_DESC_MORE = 1, /* more buffers in chain */ |
| }; |
| |
| static int |
| virtqueue_read_next_desc(VuDev *dev, struct vring_desc *desc, |
| int i, unsigned int max, unsigned int *next) |
| { |
| /* If this descriptor says it doesn't chain, we're done. */ |
| if (!(le16toh(desc[i].flags) & VRING_DESC_F_NEXT)) { |
| return VIRTQUEUE_READ_DESC_DONE; |
| } |
| |
| /* Check they're not leading us off end of descriptors. */ |
| *next = le16toh(desc[i].next); |
| /* Make sure compiler knows to grab that: we don't want it changing! */ |
| smp_wmb(); |
| |
| if (*next >= max) { |
| vu_panic(dev, "Desc next is %u", *next); |
| return VIRTQUEUE_READ_DESC_ERROR; |
| } |
| |
| return VIRTQUEUE_READ_DESC_MORE; |
| } |
| |
| void |
| vu_queue_get_avail_bytes(VuDev *dev, VuVirtq *vq, unsigned int *in_bytes, |
| unsigned int *out_bytes, |
| unsigned max_in_bytes, unsigned max_out_bytes) |
| { |
| unsigned int idx; |
| unsigned int total_bufs, in_total, out_total; |
| int rc; |
| |
| idx = vq->last_avail_idx; |
| |
| total_bufs = in_total = out_total = 0; |
| if (unlikely(dev->broken) || |
| unlikely(!vq->vring.avail)) { |
| goto done; |
| } |
| |
| while ((rc = virtqueue_num_heads(dev, vq, idx)) > 0) { |
| unsigned int max, desc_len, num_bufs, indirect = 0; |
| uint64_t desc_addr, read_len; |
| struct vring_desc *desc; |
| struct vring_desc desc_buf[VIRTQUEUE_MAX_SIZE]; |
| unsigned int i; |
| |
| max = vq->vring.num; |
| num_bufs = total_bufs; |
| if (!virtqueue_get_head(dev, vq, idx++, &i)) { |
| goto err; |
| } |
| desc = vq->vring.desc; |
| |
| if (le16toh(desc[i].flags) & VRING_DESC_F_INDIRECT) { |
| if (le32toh(desc[i].len) % sizeof(struct vring_desc)) { |
| vu_panic(dev, "Invalid size for indirect buffer table"); |
| goto err; |
| } |
| |
| /* If we've got too many, that implies a descriptor loop. */ |
| if (num_bufs >= max) { |
| vu_panic(dev, "Looped descriptor"); |
| goto err; |
| } |
| |
| /* loop over the indirect descriptor table */ |
| indirect = 1; |
| desc_addr = le64toh(desc[i].addr); |
| desc_len = le32toh(desc[i].len); |
| max = desc_len / sizeof(struct vring_desc); |
| read_len = desc_len; |
| desc = vu_gpa_to_va(dev, &read_len, desc_addr); |
| if (unlikely(desc && read_len != desc_len)) { |
| /* Failed to use zero copy */ |
| desc = NULL; |
| if (!virtqueue_read_indirect_desc(dev, desc_buf, |
| desc_addr, |
| desc_len)) { |
| desc = desc_buf; |
| } |
| } |
| if (!desc) { |
| vu_panic(dev, "Invalid indirect buffer table"); |
| goto err; |
| } |
| num_bufs = i = 0; |
| } |
| |
| do { |
| /* If we've got too many, that implies a descriptor loop. */ |
| if (++num_bufs > max) { |
| vu_panic(dev, "Looped descriptor"); |
| goto err; |
| } |
| |
| if (le16toh(desc[i].flags) & VRING_DESC_F_WRITE) { |
| in_total += le32toh(desc[i].len); |
| } else { |
| out_total += le32toh(desc[i].len); |
| } |
| if (in_total >= max_in_bytes && out_total >= max_out_bytes) { |
| goto done; |
| } |
| rc = virtqueue_read_next_desc(dev, desc, i, max, &i); |
| } while (rc == VIRTQUEUE_READ_DESC_MORE); |
| |
| if (rc == VIRTQUEUE_READ_DESC_ERROR) { |
| goto err; |
| } |
| |
| if (!indirect) { |
| total_bufs = num_bufs; |
| } else { |
| total_bufs++; |
| } |
| } |
| if (rc < 0) { |
| goto err; |
| } |
| done: |
| if (in_bytes) { |
| *in_bytes = in_total; |
| } |
| if (out_bytes) { |
| *out_bytes = out_total; |
| } |
| return; |
| |
| err: |
| in_total = out_total = 0; |
| goto done; |
| } |
| |
| bool |
| vu_queue_avail_bytes(VuDev *dev, VuVirtq *vq, unsigned int in_bytes, |
| unsigned int out_bytes) |
| { |
| unsigned int in_total, out_total; |
| |
| vu_queue_get_avail_bytes(dev, vq, &in_total, &out_total, |
| in_bytes, out_bytes); |
| |
| return in_bytes <= in_total && out_bytes <= out_total; |
| } |
| |
| /* Fetch avail_idx from VQ memory only when we really need to know if |
| * guest has added some buffers. */ |
| bool |
| vu_queue_empty(VuDev *dev, VuVirtq *vq) |
| { |
| if (unlikely(dev->broken) || |
| unlikely(!vq->vring.avail)) { |
| return true; |
| } |
| |
| if (vq->shadow_avail_idx != vq->last_avail_idx) { |
| return false; |
| } |
| |
| return vring_avail_idx(vq) == vq->last_avail_idx; |
| } |
| |
| static bool |
| vring_notify(VuDev *dev, VuVirtq *vq) |
| { |
| uint16_t old, new; |
| bool v; |
| |
| /* We need to expose used array entries before checking used event. */ |
| smp_mb(); |
| |
| /* Always notify when queue is empty (when feature acknowledge) */ |
| if (vu_has_feature(dev, VIRTIO_F_NOTIFY_ON_EMPTY) && |
| !vq->inuse && vu_queue_empty(dev, vq)) { |
| return true; |
| } |
| |
| if (!vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) { |
| return !(vring_avail_flags(vq) & VRING_AVAIL_F_NO_INTERRUPT); |
| } |
| |
| v = vq->signalled_used_valid; |
| vq->signalled_used_valid = true; |
| old = vq->signalled_used; |
| new = vq->signalled_used = vq->used_idx; |
| return !v || vring_need_event(vring_get_used_event(vq), new, old); |
| } |
| |
| static void _vu_queue_notify(VuDev *dev, VuVirtq *vq, bool sync) |
| { |
| if (unlikely(dev->broken) || |
| unlikely(!vq->vring.avail)) { |
| return; |
| } |
| |
| if (!vring_notify(dev, vq)) { |
| DPRINT("skipped notify...\n"); |
| return; |
| } |
| |
| if (vq->call_fd < 0 && |
| vu_has_protocol_feature(dev, |
| VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS) && |
| vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SLAVE_REQ)) { |
| VhostUserMsg vmsg = { |
| .request = VHOST_USER_SLAVE_VRING_CALL, |
| .flags = VHOST_USER_VERSION, |
| .size = sizeof(vmsg.payload.state), |
| .payload.state = { |
| .index = vq - dev->vq, |
| }, |
| }; |
| bool ack = sync && |
| vu_has_protocol_feature(dev, |
| VHOST_USER_PROTOCOL_F_REPLY_ACK); |
| |
| if (ack) { |
| vmsg.flags |= VHOST_USER_NEED_REPLY_MASK; |
| } |
| |
| vu_message_write(dev, dev->slave_fd, &vmsg); |
| if (ack) { |
| vu_message_read_default(dev, dev->slave_fd, &vmsg); |
| } |
| return; |
| } |
| |
| if (eventfd_write(vq->call_fd, 1) < 0) { |
| vu_panic(dev, "Error writing eventfd: %s", strerror(errno)); |
| } |
| } |
| |
| void vu_queue_notify(VuDev *dev, VuVirtq *vq) |
| { |
| _vu_queue_notify(dev, vq, false); |
| } |
| |
| void vu_queue_notify_sync(VuDev *dev, VuVirtq *vq) |
| { |
| _vu_queue_notify(dev, vq, true); |
| } |
| |
| static inline void |
| vring_used_flags_set_bit(VuVirtq *vq, int mask) |
| { |
| uint16_t *flags; |
| |
| flags = (uint16_t *)((char*)vq->vring.used + |
| offsetof(struct vring_used, flags)); |
| *flags = htole16(le16toh(*flags) | mask); |
| } |
| |
| static inline void |
| vring_used_flags_unset_bit(VuVirtq *vq, int mask) |
| { |
| uint16_t *flags; |
| |
| flags = (uint16_t *)((char*)vq->vring.used + |
| offsetof(struct vring_used, flags)); |
| *flags = htole16(le16toh(*flags) & ~mask); |
| } |
| |
| static inline void |
| vring_set_avail_event(VuVirtq *vq, uint16_t val) |
| { |
| uint16_t *avail; |
| |
| if (!vq->notification) { |
| return; |
| } |
| |
| avail = (uint16_t *)&vq->vring.used->ring[vq->vring.num]; |
| *avail = htole16(val); |
| } |
| |
| void |
| vu_queue_set_notification(VuDev *dev, VuVirtq *vq, int enable) |
| { |
| vq->notification = enable; |
| if (vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) { |
| vring_set_avail_event(vq, vring_avail_idx(vq)); |
| } else if (enable) { |
| vring_used_flags_unset_bit(vq, VRING_USED_F_NO_NOTIFY); |
| } else { |
| vring_used_flags_set_bit(vq, VRING_USED_F_NO_NOTIFY); |
| } |
| if (enable) { |
| /* Expose avail event/used flags before caller checks the avail idx. */ |
| smp_mb(); |
| } |
| } |
| |
| static bool |
| virtqueue_map_desc(VuDev *dev, |
| unsigned int *p_num_sg, struct iovec *iov, |
| unsigned int max_num_sg, bool is_write, |
| uint64_t pa, size_t sz) |
| { |
| unsigned num_sg = *p_num_sg; |
| |
| assert(num_sg <= max_num_sg); |
| |
| if (!sz) { |
| vu_panic(dev, "virtio: zero sized buffers are not allowed"); |
| return false; |
| } |
| |
| while (sz) { |
| uint64_t len = sz; |
| |
| if (num_sg == max_num_sg) { |
| vu_panic(dev, "virtio: too many descriptors in indirect table"); |
| return false; |
| } |
| |
| iov[num_sg].iov_base = vu_gpa_to_va(dev, &len, pa); |
| if (iov[num_sg].iov_base == NULL) { |
| vu_panic(dev, "virtio: invalid address for buffers"); |
| return false; |
| } |
| iov[num_sg].iov_len = len; |
| num_sg++; |
| sz -= len; |
| pa += len; |
| } |
| |
| *p_num_sg = num_sg; |
| return true; |
| } |
| |
| static void * |
| virtqueue_alloc_element(size_t sz, |
| unsigned out_num, unsigned in_num) |
| { |
| VuVirtqElement *elem; |
| size_t in_sg_ofs = ALIGN_UP(sz, __alignof__(elem->in_sg[0])); |
| size_t out_sg_ofs = in_sg_ofs + in_num * sizeof(elem->in_sg[0]); |
| size_t out_sg_end = out_sg_ofs + out_num * sizeof(elem->out_sg[0]); |
| |
| assert(sz >= sizeof(VuVirtqElement)); |
| elem = malloc(out_sg_end); |
| if (!elem) { |
| DPRINT("%s: failed to malloc virtqueue element\n", __func__); |
| return NULL; |
| } |
| elem->out_num = out_num; |
| elem->in_num = in_num; |
| elem->in_sg = (void *)elem + in_sg_ofs; |
| elem->out_sg = (void *)elem + out_sg_ofs; |
| return elem; |
| } |
| |
| static void * |
| vu_queue_map_desc(VuDev *dev, VuVirtq *vq, unsigned int idx, size_t sz) |
| { |
| struct vring_desc *desc = vq->vring.desc; |
| uint64_t desc_addr, read_len; |
| unsigned int desc_len; |
| unsigned int max = vq->vring.num; |
| unsigned int i = idx; |
| VuVirtqElement *elem; |
| unsigned int out_num = 0, in_num = 0; |
| struct iovec iov[VIRTQUEUE_MAX_SIZE]; |
| struct vring_desc desc_buf[VIRTQUEUE_MAX_SIZE]; |
| int rc; |
| |
| if (le16toh(desc[i].flags) & VRING_DESC_F_INDIRECT) { |
| if (le32toh(desc[i].len) % sizeof(struct vring_desc)) { |
| vu_panic(dev, "Invalid size for indirect buffer table"); |
| return NULL; |
| } |
| |
| /* loop over the indirect descriptor table */ |
| desc_addr = le64toh(desc[i].addr); |
| desc_len = le32toh(desc[i].len); |
| max = desc_len / sizeof(struct vring_desc); |
| read_len = desc_len; |
| desc = vu_gpa_to_va(dev, &read_len, desc_addr); |
| if (unlikely(desc && read_len != desc_len)) { |
| /* Failed to use zero copy */ |
| desc = NULL; |
| if (!virtqueue_read_indirect_desc(dev, desc_buf, |
| desc_addr, |
| desc_len)) { |
| desc = desc_buf; |
| } |
| } |
| if (!desc) { |
| vu_panic(dev, "Invalid indirect buffer table"); |
| return NULL; |
| } |
| i = 0; |
| } |
| |
| /* Collect all the descriptors */ |
| do { |
| if (le16toh(desc[i].flags) & VRING_DESC_F_WRITE) { |
| if (!virtqueue_map_desc(dev, &in_num, iov + out_num, |
| VIRTQUEUE_MAX_SIZE - out_num, true, |
| le64toh(desc[i].addr), |
| le32toh(desc[i].len))) { |
| return NULL; |
| } |
| } else { |
| if (in_num) { |
| vu_panic(dev, "Incorrect order for descriptors"); |
| return NULL; |
| } |
| if (!virtqueue_map_desc(dev, &out_num, iov, |
| VIRTQUEUE_MAX_SIZE, false, |
| le64toh(desc[i].addr), |
| le32toh(desc[i].len))) { |
| return NULL; |
| } |
| } |
| |
| /* If we've got too many, that implies a descriptor loop. */ |
| if ((in_num + out_num) > max) { |
| vu_panic(dev, "Looped descriptor"); |
| return NULL; |
| } |
| rc = virtqueue_read_next_desc(dev, desc, i, max, &i); |
| } while (rc == VIRTQUEUE_READ_DESC_MORE); |
| |
| if (rc == VIRTQUEUE_READ_DESC_ERROR) { |
| vu_panic(dev, "read descriptor error"); |
| return NULL; |
| } |
| |
| /* Now copy what we have collected and mapped */ |
| elem = virtqueue_alloc_element(sz, out_num, in_num); |
| if (!elem) { |
| return NULL; |
| } |
| elem->index = idx; |
| for (i = 0; i < out_num; i++) { |
| elem->out_sg[i] = iov[i]; |
| } |
| for (i = 0; i < in_num; i++) { |
| elem->in_sg[i] = iov[out_num + i]; |
| } |
| |
| return elem; |
| } |
| |
| static int |
| vu_queue_inflight_get(VuDev *dev, VuVirtq *vq, int desc_idx) |
| { |
| if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) { |
| return 0; |
| } |
| |
| if (unlikely(!vq->inflight)) { |
| return -1; |
| } |
| |
| vq->inflight->desc[desc_idx].counter = vq->counter++; |
| vq->inflight->desc[desc_idx].inflight = 1; |
| |
| return 0; |
| } |
| |
| static int |
| vu_queue_inflight_pre_put(VuDev *dev, VuVirtq *vq, int desc_idx) |
| { |
| if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) { |
| return 0; |
| } |
| |
| if (unlikely(!vq->inflight)) { |
| return -1; |
| } |
| |
| vq->inflight->last_batch_head = desc_idx; |
| |
| return 0; |
| } |
| |
| static int |
| vu_queue_inflight_post_put(VuDev *dev, VuVirtq *vq, int desc_idx) |
| { |
| if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) { |
| return 0; |
| } |
| |
| if (unlikely(!vq->inflight)) { |
| return -1; |
| } |
| |
| barrier(); |
| |
| vq->inflight->desc[desc_idx].inflight = 0; |
| |
| barrier(); |
| |
| vq->inflight->used_idx = vq->used_idx; |
| |
| return 0; |
| } |
| |
| void * |
| vu_queue_pop(VuDev *dev, VuVirtq *vq, size_t sz) |
| { |
| int i; |
| unsigned int head; |
| VuVirtqElement *elem; |
| |
| if (unlikely(dev->broken) || |
| unlikely(!vq->vring.avail)) { |
| return NULL; |
| } |
| |
| if (unlikely(vq->resubmit_list && vq->resubmit_num > 0)) { |
| i = (--vq->resubmit_num); |
| elem = vu_queue_map_desc(dev, vq, vq->resubmit_list[i].index, sz); |
| |
| if (!vq->resubmit_num) { |
| free(vq->resubmit_list); |
| vq->resubmit_list = NULL; |
| } |
| |
| return elem; |
| } |
| |
| if (vu_queue_empty(dev, vq)) { |
| return NULL; |
| } |
| /* |
| * Needed after virtio_queue_empty(), see comment in |
| * virtqueue_num_heads(). |
| */ |
| smp_rmb(); |
| |
| if (vq->inuse >= vq->vring.num) { |
| vu_panic(dev, "Virtqueue size exceeded"); |
| return NULL; |
| } |
| |
| if (!virtqueue_get_head(dev, vq, vq->last_avail_idx++, &head)) { |
| return NULL; |
| } |
| |
| if (vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) { |
| vring_set_avail_event(vq, vq->last_avail_idx); |
| } |
| |
| elem = vu_queue_map_desc(dev, vq, head, sz); |
| |
| if (!elem) { |
| return NULL; |
| } |
| |
| vq->inuse++; |
| |
| vu_queue_inflight_get(dev, vq, head); |
| |
| return elem; |
| } |
| |
| static void |
| vu_queue_detach_element(VuDev *dev, VuVirtq *vq, VuVirtqElement *elem, |
| size_t len) |
| { |
| vq->inuse--; |
| /* unmap, when DMA support is added */ |
| } |
| |
| void |
| vu_queue_unpop(VuDev *dev, VuVirtq *vq, VuVirtqElement *elem, |
| size_t len) |
| { |
| vq->last_avail_idx--; |
| vu_queue_detach_element(dev, vq, elem, len); |
| } |
| |
| bool |
| vu_queue_rewind(VuDev *dev, VuVirtq *vq, unsigned int num) |
| { |
| if (num > vq->inuse) { |
| return false; |
| } |
| vq->last_avail_idx -= num; |
| vq->inuse -= num; |
| return true; |
| } |
| |
| static inline |
| void vring_used_write(VuDev *dev, VuVirtq *vq, |
| struct vring_used_elem *uelem, int i) |
| { |
| struct vring_used *used = vq->vring.used; |
| |
| used->ring[i] = *uelem; |
| vu_log_write(dev, vq->vring.log_guest_addr + |
| offsetof(struct vring_used, ring[i]), |
| sizeof(used->ring[i])); |
| } |
| |
| |
| static void |
| vu_log_queue_fill(VuDev *dev, VuVirtq *vq, |
| const VuVirtqElement *elem, |
| unsigned int len) |
| { |
| struct vring_desc *desc = vq->vring.desc; |
| unsigned int i, max, min, desc_len; |
| uint64_t desc_addr, read_len; |
| struct vring_desc desc_buf[VIRTQUEUE_MAX_SIZE]; |
| unsigned num_bufs = 0; |
| |
| max = vq->vring.num; |
| i = elem->index; |
| |
| if (le16toh(desc[i].flags) & VRING_DESC_F_INDIRECT) { |
| if (le32toh(desc[i].len) % sizeof(struct vring_desc)) { |
| vu_panic(dev, "Invalid size for indirect buffer table"); |
| return; |
| } |
| |
| /* loop over the indirect descriptor table */ |
| desc_addr = le64toh(desc[i].addr); |
| desc_len = le32toh(desc[i].len); |
| max = desc_len / sizeof(struct vring_desc); |
| read_len = desc_len; |
| desc = vu_gpa_to_va(dev, &read_len, desc_addr); |
| if (unlikely(desc && read_len != desc_len)) { |
| /* Failed to use zero copy */ |
| desc = NULL; |
| if (!virtqueue_read_indirect_desc(dev, desc_buf, |
| desc_addr, |
| desc_len)) { |
| desc = desc_buf; |
| } |
| } |
| if (!desc) { |
| vu_panic(dev, "Invalid indirect buffer table"); |
| return; |
| } |
| i = 0; |
| } |
| |
| do { |
| if (++num_bufs > max) { |
| vu_panic(dev, "Looped descriptor"); |
| return; |
| } |
| |
| if (le16toh(desc[i].flags) & VRING_DESC_F_WRITE) { |
| min = MIN(le32toh(desc[i].len), len); |
| vu_log_write(dev, le64toh(desc[i].addr), min); |
| len -= min; |
| } |
| |
| } while (len > 0 && |
| (virtqueue_read_next_desc(dev, desc, i, max, &i) |
| == VIRTQUEUE_READ_DESC_MORE)); |
| } |
| |
| void |
| vu_queue_fill(VuDev *dev, VuVirtq *vq, |
| const VuVirtqElement *elem, |
| unsigned int len, unsigned int idx) |
| { |
| struct vring_used_elem uelem; |
| |
| if (unlikely(dev->broken) || |
| unlikely(!vq->vring.avail)) { |
| return; |
| } |
| |
| vu_log_queue_fill(dev, vq, elem, len); |
| |
| idx = (idx + vq->used_idx) % vq->vring.num; |
| |
| uelem.id = htole32(elem->index); |
| uelem.len = htole32(len); |
| vring_used_write(dev, vq, &uelem, idx); |
| } |
| |
| static inline |
| void vring_used_idx_set(VuDev *dev, VuVirtq *vq, uint16_t val) |
| { |
| vq->vring.used->idx = htole16(val); |
| vu_log_write(dev, |
| vq->vring.log_guest_addr + offsetof(struct vring_used, idx), |
| sizeof(vq->vring.used->idx)); |
| |
| vq->used_idx = val; |
| } |
| |
| void |
| vu_queue_flush(VuDev *dev, VuVirtq *vq, unsigned int count) |
| { |
| uint16_t old, new; |
| |
| if (unlikely(dev->broken) || |
| unlikely(!vq->vring.avail)) { |
| return; |
| } |
| |
| /* Make sure buffer is written before we update index. */ |
| smp_wmb(); |
| |
| old = vq->used_idx; |
| new = old + count; |
| vring_used_idx_set(dev, vq, new); |
| vq->inuse -= count; |
| if (unlikely((int16_t)(new - vq->signalled_used) < (uint16_t)(new - old))) { |
| vq->signalled_used_valid = false; |
| } |
| } |
| |
| void |
| vu_queue_push(VuDev *dev, VuVirtq *vq, |
| const VuVirtqElement *elem, unsigned int len) |
| { |
| vu_queue_fill(dev, vq, elem, len, 0); |
| vu_queue_inflight_pre_put(dev, vq, elem->index); |
| vu_queue_flush(dev, vq, 1); |
| vu_queue_inflight_post_put(dev, vq, elem->index); |
| } |