Re: [Qemu-devel] [PATCH 8/8] vring: remove

[Fam Zheng]

On Sun, 02/14 18:17, Paolo Bonzini wrote:
> Signed-off-by: Paolo Bonzini <address@hidden>
> ---
>  hw/virtio/Makefile.objs                       |   1 -
>  hw/virtio/dataplane/Makefile.objs             |   1 -
>  hw/virtio/dataplane/vring.c                   | 548 
> --------------------------
>  include/hw/virtio/dataplane/vring-accessors.h |  75 ----
>  include/hw/virtio/dataplane/vring.h           |  51 ---
>  trace-events                                  |   3 -
>  6 files changed, 679 deletions(-)
>  delete mode 100644 hw/virtio/dataplane/Makefile.objs
>  delete mode 100644 hw/virtio/dataplane/vring.c
>  delete mode 100644 include/hw/virtio/dataplane/vring-accessors.h
>  delete mode 100644 include/hw/virtio/dataplane/vring.h

Bravo!

Reviewed-by: Fam Zheng <address@hidden>

> 
> diff --git a/hw/virtio/Makefile.objs b/hw/virtio/Makefile.objs
> index 19b224a..3e2b175 100644
> --- a/hw/virtio/Makefile.objs
> +++ b/hw/virtio/Makefile.objs
> @@ -2,7 +2,6 @@ common-obj-y += virtio-rng.o
>  common-obj-$(CONFIG_VIRTIO_PCI) += virtio-pci.o
>  common-obj-y += virtio-bus.o
>  common-obj-y += virtio-mmio.o
> -obj-$(CONFIG_VIRTIO) += dataplane/
>  
>  obj-y += virtio.o virtio-balloon.o 
>  obj-$(CONFIG_LINUX) += vhost.o vhost-backend.o vhost-user.o
> diff --git a/hw/virtio/dataplane/Makefile.objs 
> b/hw/virtio/dataplane/Makefile.objs
> deleted file mode 100644
> index 753a9ca..0000000
> --- a/hw/virtio/dataplane/Makefile.objs
> +++ /dev/null
> @@ -1 +0,0 @@
> -obj-y += vring.o
> diff --git a/hw/virtio/dataplane/vring.c b/hw/virtio/dataplane/vring.c
> deleted file mode 100644
> index 157e8b8..0000000
> --- a/hw/virtio/dataplane/vring.c
> +++ /dev/null
> @@ -1,548 +0,0 @@
> -/* Copyright 2012 Red Hat, Inc.
> - * Copyright IBM, Corp. 2012
> - *
> - * Based on Linux 2.6.39 vhost code:
> - * Copyright (C) 2009 Red Hat, Inc.
> - * Copyright (C) 2006 Rusty Russell IBM Corporation
> - *
> - * Author: Michael S. Tsirkin <address@hidden>
> - *         Stefan Hajnoczi <address@hidden>
> - *
> - * Inspiration, some code, and most witty comments come from
> - * Documentation/virtual/lguest/lguest.c, by Rusty Russell
> - *
> - * This work is licensed under the terms of the GNU GPL, version 2.
> - */
> -
> -#include "qemu/osdep.h"
> -#include "trace.h"
> -#include "hw/hw.h"
> -#include "exec/memory.h"
> -#include "exec/address-spaces.h"
> -#include "hw/virtio/virtio-access.h"
> -#include "hw/virtio/dataplane/vring.h"
> -#include "hw/virtio/dataplane/vring-accessors.h"
> -#include "qemu/error-report.h"
> -
> -/* vring_map can be coupled with vring_unmap or (if you still have the
> - * value returned in *mr) memory_region_unref.
> - * Returns NULL on failure.
> - * Callers that can handle a partial mapping must supply mapped_len pointer 
> to
> - * get the actual length mapped.
> - * Passing mapped_len == NULL requires either a full mapping or a failure.
> - */
> -static void *vring_map(MemoryRegion **mr, hwaddr phys,
> -                       hwaddr len, hwaddr *mapped_len,
> -                       bool is_write)
> -{
> -    MemoryRegionSection section = memory_region_find(get_system_memory(), 
> phys, len);
> -    uint64_t size;
> -
> -    if (!section.mr) {
> -        goto out;
> -    }
> -
> -    size = int128_get64(section.size);
> -    assert(size);
> -
> -    /* Passing mapped_len == NULL requires either a full mapping or a 
> failure. */
> -    if (!mapped_len && size < len) {
> -        goto out;
> -    }
> -
> -    if (is_write && section.readonly) {
> -        goto out;
> -    }
> -    if (!memory_region_is_ram(section.mr)) {
> -        goto out;
> -    }
> -
> -    /* Ignore regions with dirty logging, we cannot mark them dirty */
> -    if (memory_region_get_dirty_log_mask(section.mr)) {
> -        goto out;
> -    }
> -
> -    if (mapped_len) {
> -        *mapped_len = MIN(size, len);
> -    }
> -
> -    *mr = section.mr;
> -    return memory_region_get_ram_ptr(section.mr) + 
> section.offset_within_region;
> -
> -out:
> -    memory_region_unref(section.mr);
> -    *mr = NULL;
> -    return NULL;
> -}
> -
> -static void vring_unmap(void *buffer, bool is_write)
> -{
> -    ram_addr_t addr;
> -    MemoryRegion *mr;
> -
> -    mr = qemu_ram_addr_from_host(buffer, &addr);
> -    memory_region_unref(mr);
> -}
> -
> -/* Map the guest's vring to host memory */
> -bool vring_setup(Vring *vring, VirtIODevice *vdev, int n)
> -{
> -    struct vring *vr = &vring->vr;
> -    hwaddr addr;
> -    hwaddr size;
> -    void *ptr;
> -
> -    vring->broken = false;
> -    vr->num = virtio_queue_get_num(vdev, n);
> -
> -    addr = virtio_queue_get_desc_addr(vdev, n);
> -    size = virtio_queue_get_desc_size(vdev, n);
> -    /* Map the descriptor area as read only */
> -    ptr = vring_map(&vring->mr_desc, addr, size, NULL, false);
> -    if (!ptr) {
> -        error_report("Failed to map 0x%" HWADDR_PRIx " byte for vring desc "
> -                     "at 0x%" HWADDR_PRIx,
> -                      size, addr);
> -        goto out_err_desc;
> -    }
> -    vr->desc = ptr;
> -
> -    addr = virtio_queue_get_avail_addr(vdev, n);
> -    size = virtio_queue_get_avail_size(vdev, n);
> -    /* Add the size of the used_event_idx */
> -    size += sizeof(uint16_t);
> -    /* Map the driver area as read only */
> -    ptr = vring_map(&vring->mr_avail, addr, size, NULL, false);
> -    if (!ptr) {
> -        error_report("Failed to map 0x%" HWADDR_PRIx " byte for vring avail "
> -                     "at 0x%" HWADDR_PRIx,
> -                      size, addr);
> -        goto out_err_avail;
> -    }
> -    vr->avail = ptr;
> -
> -    addr = virtio_queue_get_used_addr(vdev, n);
> -    size = virtio_queue_get_used_size(vdev, n);
> -    /* Add the size of the avail_event_idx */
> -    size += sizeof(uint16_t);
> -    /* Map the device area as read-write */
> -    ptr = vring_map(&vring->mr_used, addr, size, NULL, true);
> -    if (!ptr) {
> -        error_report("Failed to map 0x%" HWADDR_PRIx " byte for vring used "
> -                     "at 0x%" HWADDR_PRIx,
> -                      size, addr);
> -        goto out_err_used;
> -    }
> -    vr->used = ptr;
> -
> -    vring->last_avail_idx = virtio_queue_get_last_avail_idx(vdev, n);
> -    vring->last_used_idx = vring_get_used_idx(vdev, vring);
> -    vring->signalled_used = 0;
> -    vring->signalled_used_valid = false;
> -
> -    trace_vring_setup(virtio_queue_get_ring_addr(vdev, n),
> -                      vring->vr.desc, vring->vr.avail, vring->vr.used);
> -    return true;
> -
> -out_err_used:
> -    memory_region_unref(vring->mr_avail);
> -out_err_avail:
> -    memory_region_unref(vring->mr_desc);
> -out_err_desc:
> -    vring->broken = true;
> -    return false;
> -}
> -
> -void vring_teardown(Vring *vring, VirtIODevice *vdev, int n)
> -{
> -    virtio_queue_set_last_avail_idx(vdev, n, vring->last_avail_idx);
> -    virtio_queue_invalidate_signalled_used(vdev, n);
> -
> -    memory_region_unref(vring->mr_desc);
> -    memory_region_unref(vring->mr_avail);
> -    memory_region_unref(vring->mr_used);
> -}
> -
> -/* Disable guest->host notifies */
> -void vring_disable_notification(VirtIODevice *vdev, Vring *vring)
> -{
> -    if (!virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
> -        vring_set_used_flags(vdev, vring, VRING_USED_F_NO_NOTIFY);
> -    }
> -}
> -
> -/* Enable guest->host notifies
> - *
> - * Return true if the vring is empty, false if there are more requests.
> - */
> -void vring_enable_notification(VirtIODevice *vdev, Vring *vring)
> -{
> -    if (virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
> -        vring_avail_event(&vring->vr) = vring->vr.avail->idx;
> -    } else {
> -        vring_clear_used_flags(vdev, vring, VRING_USED_F_NO_NOTIFY);
> -    }
> -    smp_mb(); /* ensure update is seen before reading avail_idx */
> -}
> -
> -/* This is stolen from linux/drivers/vhost/vhost.c:vhost_notify() */
> -bool vring_should_notify(VirtIODevice *vdev, Vring *vring)
> -{
> -    uint16_t old, new;
> -    bool v;
> -    /* Flush out used index updates. This is paired
> -     * with the barrier that the Guest executes when enabling
> -     * interrupts. */
> -    smp_mb();
> -
> -    if (virtio_vdev_has_feature(vdev, VIRTIO_F_NOTIFY_ON_EMPTY) &&
> -        unlikely(!vring_more_avail(vdev, vring))) {
> -        return true;
> -    }
> -
> -    if (!virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
> -        return !(vring_get_avail_flags(vdev, vring) &
> -                 VRING_AVAIL_F_NO_INTERRUPT);
> -    }
> -    old = vring->signalled_used;
> -    v = vring->signalled_used_valid;
> -    new = vring->signalled_used = vring->last_used_idx;
> -    vring->signalled_used_valid = true;
> -
> -    if (unlikely(!v)) {
> -        return true;
> -    }
> -
> -    return vring_need_event(virtio_tswap16(vdev, 
> vring_used_event(&vring->vr)),
> -                            new, old);
> -}
> -
> -typedef struct VirtQueueCurrentElement {
> -    unsigned in_num;
> -    unsigned out_num;
> -    hwaddr addr[VIRTQUEUE_MAX_SIZE];
> -    struct iovec iov[VIRTQUEUE_MAX_SIZE];
> -} VirtQueueCurrentElement;
> -
> -static int get_desc(Vring *vring, VirtQueueCurrentElement *elem,
> -                    struct vring_desc *desc)
> -{
> -    unsigned *num;
> -    struct iovec *iov;
> -    hwaddr *addr;
> -    MemoryRegion *mr;
> -    hwaddr len;
> -
> -    if (desc->flags & VRING_DESC_F_WRITE) {
> -        num = &elem->in_num;
> -        iov = &elem->iov[elem->out_num + *num];
> -        addr = &elem->addr[elem->out_num + *num];
> -    } else {
> -        num = &elem->out_num;
> -        iov = &elem->iov[*num];
> -        addr = &elem->addr[*num];
> -
> -        /* If it's an output descriptor, they're all supposed
> -         * to come before any input descriptors. */
> -        if (unlikely(elem->in_num)) {
> -            error_report("Descriptor has out after in");
> -            return -EFAULT;
> -        }
> -    }
> -
> -    while (desc->len) {
> -        /* Stop for now if there are not enough iovecs available. */
> -        if (*num >= VIRTQUEUE_MAX_SIZE) {
> -            error_report("Invalid SG num: %u", *num);
> -            return -EFAULT;
> -        }
> -
> -        iov->iov_base = vring_map(&mr, desc->addr, desc->len, &len,
> -                                  desc->flags & VRING_DESC_F_WRITE);
> -        if (!iov->iov_base) {
> -            error_report("Failed to map descriptor addr %#" PRIx64 " len %u",
> -                         (uint64_t)desc->addr, desc->len);
> -            return -EFAULT;
> -        }
> -
> -        /* The MemoryRegion is looked up again and unref'ed later, leave the
> -         * ref in place.  */
> -        (iov++)->iov_len = len;
> -        *addr++ = desc->addr;
> -        desc->len -= len;
> -        desc->addr += len;
> -        *num += 1;
> -    }
> -
> -    return 0;
> -}
> -
> -static void copy_in_vring_desc(VirtIODevice *vdev,
> -                               const struct vring_desc *guest,
> -                               struct vring_desc *host)
> -{
> -    host->addr = virtio_ldq_p(vdev, &guest->addr);
> -    host->len = virtio_ldl_p(vdev, &guest->len);
> -    host->flags = virtio_lduw_p(vdev, &guest->flags);
> -    host->next = virtio_lduw_p(vdev, &guest->next);
> -}
> -
> -static bool read_vring_desc(VirtIODevice *vdev,
> -                            hwaddr guest,
> -                            struct vring_desc *host)
> -{
> -    if (address_space_read(&address_space_memory, guest, 
> MEMTXATTRS_UNSPECIFIED,
> -                           (uint8_t *)host, sizeof *host)) {
> -        return false;
> -    }
> -    host->addr = virtio_tswap64(vdev, host->addr);
> -    host->len = virtio_tswap32(vdev, host->len);
> -    host->flags = virtio_tswap16(vdev, host->flags);
> -    host->next = virtio_tswap16(vdev, host->next);
> -    return true;
> -}
> -
> -/* This is stolen from linux/drivers/vhost/vhost.c. */
> -static int get_indirect(VirtIODevice *vdev, Vring *vring,
> -                        VirtQueueCurrentElement *cur_elem,
> -                        struct vring_desc *indirect)
> -{
> -    struct vring_desc desc;
> -    unsigned int i = 0, count, found = 0;
> -    int ret;
> -
> -    /* Sanity check */
> -    if (unlikely(indirect->len % sizeof(desc))) {
> -        error_report("Invalid length in indirect descriptor: "
> -                     "len %#x not multiple of %#zx",
> -                     indirect->len, sizeof(desc));
> -        vring->broken = true;
> -        return -EFAULT;
> -    }
> -
> -    count = indirect->len / sizeof(desc);
> -    /* Buffers are chained via a 16 bit next field, so
> -     * we can have at most 2^16 of these. */
> -    if (unlikely(count > USHRT_MAX + 1)) {
> -        error_report("Indirect buffer length too big: %d", indirect->len);
> -        vring->broken = true;
> -        return -EFAULT;
> -    }
> -
> -    do {
> -        /* Translate indirect descriptor */
> -        if (!read_vring_desc(vdev, indirect->addr + found * sizeof(desc),
> -                             &desc)) {
> -            error_report("Failed to read indirect descriptor "
> -                         "addr %#" PRIx64 " len %zu",
> -                         (uint64_t)indirect->addr + found * sizeof(desc),
> -                         sizeof(desc));
> -            vring->broken = true;
> -            return -EFAULT;
> -        }
> -
> -        /* Ensure descriptor has been loaded before accessing fields */
> -        barrier(); /* read_barrier_depends(); */
> -
> -        if (unlikely(++found > count)) {
> -            error_report("Loop detected: last one at %u "
> -                         "indirect size %u", i, count);
> -            vring->broken = true;
> -            return -EFAULT;
> -        }
> -
> -        if (unlikely(desc.flags & VRING_DESC_F_INDIRECT)) {
> -            error_report("Nested indirect descriptor");
> -            vring->broken = true;
> -            return -EFAULT;
> -        }
> -
> -        ret = get_desc(vring, cur_elem, &desc);
> -        if (ret < 0) {
> -            vring->broken |= (ret == -EFAULT);
> -            return ret;
> -        }
> -        i = desc.next;
> -    } while (desc.flags & VRING_DESC_F_NEXT);
> -    return 0;
> -}
> -
> -static void vring_unmap_element(VirtQueueElement *elem)
> -{
> -    int i;
> -
> -    /* This assumes that the iovecs, if changed, are never moved past
> -     * the end of the valid area.  This is true if iovec manipulations
> -     * are done with iov_discard_front and iov_discard_back.
> -     */
> -    for (i = 0; i < elem->out_num; i++) {
> -        vring_unmap(elem->out_sg[i].iov_base, false);
> -    }
> -
> -    for (i = 0; i < elem->in_num; i++) {
> -        vring_unmap(elem->in_sg[i].iov_base, true);
> -    }
> -}
> -
> -/* This looks in the virtqueue and for the first available buffer, and 
> converts
> - * it to an iovec for convenient access.  Since descriptors consist of some
> - * number of output then some number of input descriptors, it's actually two
> - * iovecs, but we pack them into one and note how many of each there were.
> - *
> - * This function returns the descriptor number found, or vq->num (which is
> - * never a valid descriptor number) if none was found.  A negative code is
> - * returned on error.
> - *
> - * Stolen from linux/drivers/vhost/vhost.c.
> - */
> -void *vring_pop(VirtIODevice *vdev, Vring *vring, size_t sz)
> -{
> -    struct vring_desc desc;
> -    unsigned int i, head, found = 0, num = vring->vr.num;
> -    uint16_t avail_idx, last_avail_idx;
> -    VirtQueueCurrentElement cur_elem;
> -    VirtQueueElement *elem = NULL;
> -    int ret;
> -
> -    /* If there was a fatal error then refuse operation */
> -    if (vring->broken) {
> -        ret = -EFAULT;
> -        goto out;
> -    }
> -
> -    cur_elem.in_num = cur_elem.out_num = 0;
> -
> -    /* Check it isn't doing very strange things with descriptor numbers. */
> -    last_avail_idx = vring->last_avail_idx;
> -    avail_idx = vring_get_avail_idx(vdev, vring);
> -    barrier(); /* load indices now and not again later */
> -
> -    if (unlikely((uint16_t)(avail_idx - last_avail_idx) > num)) {
> -        error_report("Guest moved used index from %u to %u",
> -                     last_avail_idx, avail_idx);
> -        ret = -EFAULT;
> -        goto out;
> -    }
> -
> -    /* If there's nothing new since last we looked. */
> -    if (avail_idx == last_avail_idx) {
> -        ret = -EAGAIN;
> -        goto out;
> -    }
> -
> -    /* Only get avail ring entries after they have been exposed by guest. */
> -    smp_rmb();
> -
> -    /* Grab the next descriptor number they're advertising, and increment
> -     * the index we've seen. */
> -    head = vring_get_avail_ring(vdev, vring, last_avail_idx % num);
> -
> -    /* If their number is silly, that's an error. */
> -    if (unlikely(head >= num)) {
> -        error_report("Guest says index %u > %u is available", head, num);
> -        ret = -EFAULT;
> -        goto out;
> -    }
> -
> -    i = head;
> -    do {
> -        if (unlikely(i >= num)) {
> -            error_report("Desc index is %u > %u, head = %u", i, num, head);
> -            ret = -EFAULT;
> -            goto out;
> -        }
> -        if (unlikely(++found > num)) {
> -            error_report("Loop detected: last one at %u vq size %u head %u",
> -                         i, num, head);
> -            ret = -EFAULT;
> -            goto out;
> -        }
> -        copy_in_vring_desc(vdev, &vring->vr.desc[i], &desc);
> -
> -        /* Ensure descriptor is loaded before accessing fields */
> -        barrier();
> -
> -        if (desc.flags & VRING_DESC_F_INDIRECT) {
> -            ret = get_indirect(vdev, vring, &cur_elem, &desc);
> -            if (ret < 0) {
> -                goto out;
> -            }
> -            continue;
> -        }
> -
> -        ret = get_desc(vring, &cur_elem, &desc);
> -        if (ret < 0) {
> -            goto out;
> -        }
> -
> -        i = desc.next;
> -    } while (desc.flags & VRING_DESC_F_NEXT);
> -
> -    /* On success, increment avail index. */
> -    vring->last_avail_idx++;
> -    if (virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
> -        vring_avail_event(&vring->vr) =
> -            virtio_tswap16(vdev, vring->last_avail_idx);
> -    }
> -
> -    /* Now copy what we have collected and mapped */
> -    elem = virtqueue_alloc_element(sz, cur_elem.out_num, cur_elem.in_num);
> -    elem->index = head;
> -    for (i = 0; i < cur_elem.out_num; i++) {
> -        elem->out_addr[i] = cur_elem.addr[i];
> -        elem->out_sg[i] = cur_elem.iov[i];
> -    }
> -    for (i = 0; i < cur_elem.in_num; i++) {
> -        elem->in_addr[i] = cur_elem.addr[cur_elem.out_num + i];
> -        elem->in_sg[i] = cur_elem.iov[cur_elem.out_num + i];
> -    }
> -
> -    return elem;
> -
> -out:
> -    assert(ret < 0);
> -    if (ret == -EFAULT) {
> -        vring->broken = true;
> -    }
> -
> -    for (i = 0; i < cur_elem.out_num + cur_elem.in_num; i++) {
> -        vring_unmap(cur_elem.iov[i].iov_base, false);
> -    }
> -
> -    g_free(elem);
> -    return NULL;
> -}
> -
> -/* After we've used one of their buffers, we tell them about it.
> - *
> - * Stolen from linux/drivers/vhost/vhost.c.
> - */
> -void vring_push(VirtIODevice *vdev, Vring *vring, VirtQueueElement *elem,
> -                int len)
> -{
> -    unsigned int head = elem->index;
> -    uint16_t new;
> -
> -    vring_unmap_element(elem);
> -
> -    /* Don't touch vring if a fatal error occurred */
> -    if (vring->broken) {
> -        return;
> -    }
> -
> -    /* The virtqueue contains a ring of used buffers.  Get a pointer to the
> -     * next entry in that used ring. */
> -    vring_set_used_ring_id(vdev, vring, vring->last_used_idx % vring->vr.num,
> -                           head);
> -    vring_set_used_ring_len(vdev, vring, vring->last_used_idx % 
> vring->vr.num,
> -                            len);
> -
> -    /* Make sure buffer is written before we update index. */
> -    smp_wmb();
> -
> -    new = ++vring->last_used_idx;
> -    vring_set_used_idx(vdev, vring, new);
> -    if (unlikely((int16_t)(new - vring->signalled_used) < (uint16_t)1)) {
> -        vring->signalled_used_valid = false;
> -    }
> -}
> diff --git a/include/hw/virtio/dataplane/vring-accessors.h 
> b/include/hw/virtio/dataplane/vring-accessors.h
> deleted file mode 100644
> index 815c19b..0000000
> --- a/include/hw/virtio/dataplane/vring-accessors.h
> +++ /dev/null
> @@ -1,75 +0,0 @@
> -#ifndef VRING_ACCESSORS_H
> -#define VRING_ACCESSORS_H
> -
> -#include "standard-headers/linux/virtio_ring.h"
> -#include "hw/virtio/virtio.h"
> -#include "hw/virtio/virtio-access.h"
> -
> -static inline uint16_t vring_get_used_idx(VirtIODevice *vdev, Vring *vring)
> -{
> -    return virtio_tswap16(vdev, vring->vr.used->idx);
> -}
> -
> -static inline void vring_set_used_idx(VirtIODevice *vdev, Vring *vring,
> -                                      uint16_t idx)
> -{
> -    vring->vr.used->idx = virtio_tswap16(vdev, idx);
> -}
> -
> -static inline uint16_t vring_get_avail_idx(VirtIODevice *vdev, Vring *vring)
> -{
> -    return virtio_tswap16(vdev, vring->vr.avail->idx);
> -}
> -
> -static inline uint16_t vring_get_avail_ring(VirtIODevice *vdev, Vring *vring,
> -                                            int i)
> -{
> -    return virtio_tswap16(vdev, vring->vr.avail->ring[i]);
> -}
> -
> -static inline void vring_set_used_ring_id(VirtIODevice *vdev, Vring *vring,
> -                                          int i, uint32_t id)
> -{
> -    vring->vr.used->ring[i].id = virtio_tswap32(vdev, id);
> -}
> -
> -static inline void vring_set_used_ring_len(VirtIODevice *vdev, Vring *vring,
> -                                          int i, uint32_t len)
> -{
> -    vring->vr.used->ring[i].len = virtio_tswap32(vdev, len);
> -}
> -
> -static inline uint16_t vring_get_used_flags(VirtIODevice *vdev, Vring *vring)
> -{
> -    return virtio_tswap16(vdev, vring->vr.used->flags);
> -}
> -
> -static inline uint16_t vring_get_avail_flags(VirtIODevice *vdev, Vring 
> *vring)
> -{
> -    return virtio_tswap16(vdev, vring->vr.avail->flags);
> -}
> -
> -static inline void vring_set_used_flags(VirtIODevice *vdev, Vring *vring,
> -                                        uint16_t flags)
> -{
> -    vring->vr.used->flags |= virtio_tswap16(vdev, flags);
> -}
> -
> -static inline void vring_clear_used_flags(VirtIODevice *vdev, Vring *vring,
> -                                          uint16_t flags)
> -{
> -    vring->vr.used->flags &= virtio_tswap16(vdev, ~flags);
> -}
> -
> -static inline unsigned int vring_get_num(Vring *vring)
> -{
> -    return vring->vr.num;
> -}
> -
> -/* Are there more descriptors available? */
> -static inline bool vring_more_avail(VirtIODevice *vdev, Vring *vring)
> -{
> -    return vring_get_avail_idx(vdev, vring) != vring->last_avail_idx;
> -}
> -
> -#endif
> diff --git a/include/hw/virtio/dataplane/vring.h 
> b/include/hw/virtio/dataplane/vring.h
> deleted file mode 100644
> index e1c2a65..0000000
> --- a/include/hw/virtio/dataplane/vring.h
> +++ /dev/null
> @@ -1,51 +0,0 @@
> -/* Copyright 2012 Red Hat, Inc. and/or its affiliates
> - * Copyright IBM, Corp. 2012
> - *
> - * Based on Linux 2.6.39 vhost code:
> - * Copyright (C) 2009 Red Hat, Inc.
> - * Copyright (C) 2006 Rusty Russell IBM Corporation
> - *
> - * Author: Michael S. Tsirkin <address@hidden>
> - *         Stefan Hajnoczi <address@hidden>
> - *
> - * Inspiration, some code, and most witty comments come from
> - * Documentation/virtual/lguest/lguest.c, by Rusty Russell
> - *
> - * This work is licensed under the terms of the GNU GPL, version 2.
> - */
> -
> -#ifndef VRING_H
> -#define VRING_H
> -
> -#include "qemu-common.h"
> -#include "standard-headers/linux/virtio_ring.h"
> -#include "hw/virtio/virtio.h"
> -
> -typedef struct {
> -    MemoryRegion *mr_desc;          /* memory region for the vring desc */
> -    MemoryRegion *mr_avail;         /* memory region for the vring avail */
> -    MemoryRegion *mr_used;          /* memory region for the vring used */
> -    struct vring vr;                /* virtqueue vring mapped to host memory 
> */
> -    uint16_t last_avail_idx;        /* last processed avail ring index */
> -    uint16_t last_used_idx;         /* last processed used ring index */
> -    uint16_t signalled_used;        /* EVENT_IDX state */
> -    bool signalled_used_valid;
> -    bool broken;                    /* was there a fatal error? */
> -} Vring;
> -
> -/* Fail future vring_pop() and vring_push() calls until reset */
> -static inline void vring_set_broken(Vring *vring)
> -{
> -    vring->broken = true;
> -}
> -
> -bool vring_setup(Vring *vring, VirtIODevice *vdev, int n);
> -void vring_teardown(Vring *vring, VirtIODevice *vdev, int n);
> -void vring_disable_notification(VirtIODevice *vdev, Vring *vring);
> -void vring_enable_notification(VirtIODevice *vdev, Vring *vring);
> -bool vring_should_notify(VirtIODevice *vdev, Vring *vring);
> -void *vring_pop(VirtIODevice *vdev, Vring *vring, size_t sz);
> -void vring_push(VirtIODevice *vdev, Vring *vring, VirtQueueElement *elem,
> -                int len);
> -
> -#endif /* VRING_H */
> diff --git a/trace-events b/trace-events
> index f986c81..61a133f 100644
> --- a/trace-events
> +++ b/trace-events
> @@ -127,9 +127,6 @@ virtio_blk_data_plane_start(void *s) "dataplane %p"
>  virtio_blk_data_plane_stop(void *s) "dataplane %p"
>  virtio_blk_data_plane_process_request(void *s, unsigned int out_num, 
> unsigned int in_num, unsigned int head) "dataplane %p out_num %u in_num %u 
> head %u"
>  
> -# hw/virtio/dataplane/vring.c
> -vring_setup(uint64_t physical, void *desc, void *avail, void *used) "vring 
> physical %#"PRIx64" desc %p avail %p used %p"
> -
>  # thread-pool.c
>  thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p 
> opaque %p"
>  thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p 
> req %p opaque %p ret %d"
> -- 
> 1.8.3.1
> 
>