From: Greg Kurz <groug@kaod.org>
To: Laurent Vivier <lvivier@redhat.com>
Cc: qemu-devel@nongnu.org, dgibson@redhat.com, thuth@redhat.com,
qemu-ppc@nongnu.org
Subject: Re: [Qemu-devel] [PATCH v4 3/6] tests: move QVirtioBus pointer into QVirtioDevice
Date: Sat, 15 Oct 2016 00:19:58 +0200 [thread overview]
Message-ID: <20161015001958.49e4c950@bahia> (raw)
In-Reply-To: <1476435535-9408-4-git-send-email-lvivier@redhat.com>
On Fri, 14 Oct 2016 10:58:52 +0200
Laurent Vivier <lvivier@redhat.com> wrote:
> This allows to not have to pass bus and device for every virtio functions.
>
> Signed-off-by: Laurent Vivier <lvivier@redhat.com>
> ---
Reviewed-by: Greg Kurz <groug@kaod.org>
> tests/libqos/virtio-mmio.c | 1 +
> tests/libqos/virtio-pci.c | 2 +
> tests/libqos/virtio.c | 77 +++++++++++-------------
> tests/libqos/virtio.h | 51 +++++++---------
> tests/vhost-user-test.c | 33 +++++-----
> tests/virtio-9p-test.c | 15 +++--
> tests/virtio-blk-test.c | 147 ++++++++++++++++++++-------------------------
> tests/virtio-net-test.c | 59 +++++++++---------
> tests/virtio-scsi-test.c | 17 +++---
> 9 files changed, 185 insertions(+), 217 deletions(-)
>
> diff --git a/tests/libqos/virtio-mmio.c b/tests/libqos/virtio-mmio.c
> index 0cab38f..bced680 100644
> --- a/tests/libqos/virtio-mmio.c
> +++ b/tests/libqos/virtio-mmio.c
> @@ -199,6 +199,7 @@ QVirtioMMIODevice *qvirtio_mmio_init_device(uint64_t addr, uint32_t page_size)
> dev->addr = addr;
> dev->page_size = page_size;
> dev->vdev.device_type = readl(addr + QVIRTIO_MMIO_DEVICE_ID);
> + dev->vdev.bus = &qvirtio_mmio;
>
> writel(addr + QVIRTIO_MMIO_GUEST_PAGE_SIZE, page_size);
>
> diff --git a/tests/libqos/virtio-pci.c b/tests/libqos/virtio-pci.c
> index 6e005c1..bbfed58 100644
> --- a/tests/libqos/virtio-pci.c
> +++ b/tests/libqos/virtio-pci.c
> @@ -286,6 +286,8 @@ QVirtioPCIDevice *qvirtio_pci_device_find(QPCIBus *bus, uint16_t device_type)
> QVirtioPCIDevice *dev = NULL;
> qvirtio_pci_foreach(bus, device_type, qvirtio_pci_assign_device, &dev);
>
> + dev->vdev.bus = &qvirtio_pci;
> +
> return dev;
> }
>
> diff --git a/tests/libqos/virtio.c b/tests/libqos/virtio.c
> index 105bcce..ffa2ad1 100644
> --- a/tests/libqos/virtio.c
> +++ b/tests/libqos/virtio.c
> @@ -13,45 +13,39 @@
> #include "standard-headers/linux/virtio_config.h"
> #include "standard-headers/linux/virtio_ring.h"
>
> -uint8_t qvirtio_config_readb(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr)
> +uint8_t qvirtio_config_readb(QVirtioDevice *d, uint64_t addr)
> {
> - return bus->config_readb(d, addr);
> + return d->bus->config_readb(d, addr);
> }
>
> -uint16_t qvirtio_config_readw(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr)
> +uint16_t qvirtio_config_readw(QVirtioDevice *d, uint64_t addr)
> {
> - return bus->config_readw(d, addr);
> + return d->bus->config_readw(d, addr);
> }
>
> -uint32_t qvirtio_config_readl(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr)
> +uint32_t qvirtio_config_readl(QVirtioDevice *d, uint64_t addr)
> {
> - return bus->config_readl(d, addr);
> + return d->bus->config_readl(d, addr);
> }
>
> -uint64_t qvirtio_config_readq(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr)
> +uint64_t qvirtio_config_readq(QVirtioDevice *d, uint64_t addr)
> {
> - return bus->config_readq(d, addr);
> + return d->bus->config_readq(d, addr);
> }
>
> -uint32_t qvirtio_get_features(const QVirtioBus *bus, QVirtioDevice *d)
> +uint32_t qvirtio_get_features(QVirtioDevice *d)
> {
> - return bus->get_features(d);
> + return d->bus->get_features(d);
> }
>
> -void qvirtio_set_features(const QVirtioBus *bus, QVirtioDevice *d,
> - uint32_t features)
> +void qvirtio_set_features(QVirtioDevice *d, uint32_t features)
> {
> - bus->set_features(d, features);
> + d->bus->set_features(d, features);
> }
>
> -QVirtQueue *qvirtqueue_setup(const QVirtioBus *bus, QVirtioDevice *d,
> - QGuestAllocator *alloc, uint16_t index)
> +QVirtQueue *qvirtqueue_setup(QVirtioDevice *d, QGuestAllocator *alloc, uint16_t index)
> {
> - return bus->virtqueue_setup(d, alloc, index);
> + return d->bus->virtqueue_setup(d, alloc, index);
> }
>
> void qvirtqueue_cleanup(const QVirtioBus *bus, QVirtQueue *vq,
> @@ -60,40 +54,40 @@ void qvirtqueue_cleanup(const QVirtioBus *bus, QVirtQueue *vq,
> return bus->virtqueue_cleanup(vq, alloc);
> }
>
> -void qvirtio_reset(const QVirtioBus *bus, QVirtioDevice *d)
> +void qvirtio_reset(QVirtioDevice *d)
> {
> - bus->set_status(d, 0);
> - g_assert_cmphex(bus->get_status(d), ==, 0);
> + d->bus->set_status(d, 0);
> + g_assert_cmphex(d->bus->get_status(d), ==, 0);
> }
>
> -void qvirtio_set_acknowledge(const QVirtioBus *bus, QVirtioDevice *d)
> +void qvirtio_set_acknowledge(QVirtioDevice *d)
> {
> - bus->set_status(d, bus->get_status(d) | VIRTIO_CONFIG_S_ACKNOWLEDGE);
> - g_assert_cmphex(bus->get_status(d), ==, VIRTIO_CONFIG_S_ACKNOWLEDGE);
> + d->bus->set_status(d, d->bus->get_status(d) | VIRTIO_CONFIG_S_ACKNOWLEDGE);
> + g_assert_cmphex(d->bus->get_status(d), ==, VIRTIO_CONFIG_S_ACKNOWLEDGE);
> }
>
> -void qvirtio_set_driver(const QVirtioBus *bus, QVirtioDevice *d)
> +void qvirtio_set_driver(QVirtioDevice *d)
> {
> - bus->set_status(d, bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER);
> - g_assert_cmphex(bus->get_status(d), ==,
> + d->bus->set_status(d, d->bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER);
> + g_assert_cmphex(d->bus->get_status(d), ==,
> VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_ACKNOWLEDGE);
> }
>
> -void qvirtio_set_driver_ok(const QVirtioBus *bus, QVirtioDevice *d)
> +void qvirtio_set_driver_ok(QVirtioDevice *d)
> {
> - bus->set_status(d, bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER_OK);
> - g_assert_cmphex(bus->get_status(d), ==, VIRTIO_CONFIG_S_DRIVER_OK |
> + d->bus->set_status(d, d->bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER_OK);
> + g_assert_cmphex(d->bus->get_status(d), ==, VIRTIO_CONFIG_S_DRIVER_OK |
> VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_ACKNOWLEDGE);
> }
>
> -void qvirtio_wait_queue_isr(const QVirtioBus *bus, QVirtioDevice *d,
> +void qvirtio_wait_queue_isr(QVirtioDevice *d,
> QVirtQueue *vq, gint64 timeout_us)
> {
> gint64 start_time = g_get_monotonic_time();
>
> for (;;) {
> clock_step(100);
> - if (bus->get_queue_isr_status(d, vq)) {
> + if (d->bus->get_queue_isr_status(d, vq)) {
> return;
> }
> g_assert(g_get_monotonic_time() - start_time <= timeout_us);
> @@ -105,8 +99,7 @@ void qvirtio_wait_queue_isr(const QVirtioBus *bus, QVirtioDevice *d,
> * The virtqueue interrupt must not be raised, making this useful for testing
> * event_index functionality.
> */
> -uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus *bus,
> - QVirtioDevice *d,
> +uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d,
> QVirtQueue *vq,
> uint64_t addr,
> gint64 timeout_us)
> @@ -116,20 +109,19 @@ uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus *bus,
>
> while ((val = readb(addr)) == 0xff) {
> clock_step(100);
> - g_assert(!bus->get_queue_isr_status(d, vq));
> + g_assert(!d->bus->get_queue_isr_status(d, vq));
> g_assert(g_get_monotonic_time() - start_time <= timeout_us);
> }
> return val;
> }
>
> -void qvirtio_wait_config_isr(const QVirtioBus *bus, QVirtioDevice *d,
> - gint64 timeout_us)
> +void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us)
> {
> gint64 start_time = g_get_monotonic_time();
>
> for (;;) {
> clock_step(100);
> - if (bus->get_config_isr_status(d)) {
> + if (d->bus->get_config_isr_status(d)) {
> return;
> }
> g_assert(g_get_monotonic_time() - start_time <= timeout_us);
> @@ -253,8 +245,7 @@ uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect)
> return vq->free_head++; /* Return and increase, in this order */
> }
>
> -void qvirtqueue_kick(const QVirtioBus *bus, QVirtioDevice *d, QVirtQueue *vq,
> - uint32_t free_head)
> +void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head)
> {
> /* vq->avail->idx */
> uint16_t idx = readw(vq->avail + 2);
> @@ -276,7 +267,7 @@ void qvirtqueue_kick(const QVirtioBus *bus, QVirtioDevice *d, QVirtQueue *vq,
> /* < 1 because we add elements to avail queue one by one */
> if ((flags & VRING_USED_F_NO_NOTIFY) == 0 &&
> (!vq->event || (uint16_t)(idx-avail_event) < 1)) {
> - bus->virtqueue_kick(d, vq);
> + d->bus->virtqueue_kick(d, vq);
> }
> }
>
> diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h
> index 0250842..ac4669a 100644
> --- a/tests/libqos/virtio.h
> +++ b/tests/libqos/virtio.h
> @@ -15,7 +15,10 @@
>
> #define QVIRTIO_F_BAD_FEATURE 0x40000000
>
> +typedef struct QVirtioBus QVirtioBus;
> +
> typedef struct QVirtioDevice {
> + const QVirtioBus *bus;
> /* Device type */
> uint16_t device_type;
> } QVirtioDevice;
> @@ -39,7 +42,7 @@ typedef struct QVRingIndirectDesc {
> uint16_t elem;
> } QVRingIndirectDesc;
>
> -typedef struct QVirtioBus {
> +struct QVirtioBus {
> uint8_t (*config_readb)(QVirtioDevice *d, uint64_t addr);
> uint16_t (*config_readw)(QVirtioDevice *d, uint64_t addr);
> uint32_t (*config_readl)(QVirtioDevice *d, uint64_t addr);
> @@ -84,7 +87,7 @@ typedef struct QVirtioBus {
>
> /* Notify changes in virtqueue */
> void (*virtqueue_kick)(QVirtioDevice *d, QVirtQueue *vq);
> -} QVirtioBus;
> +};
>
> static inline uint32_t qvring_size(uint32_t num, uint32_t align)
> {
> @@ -93,34 +96,27 @@ static inline uint32_t qvring_size(uint32_t num, uint32_t align)
> + sizeof(uint16_t) * 3 + sizeof(struct vring_used_elem) * num;
> }
>
> -uint8_t qvirtio_config_readb(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr);
> -uint16_t qvirtio_config_readw(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr);
> -uint32_t qvirtio_config_readl(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr);
> -uint64_t qvirtio_config_readq(const QVirtioBus *bus, QVirtioDevice *d,
> - uint64_t addr);
> -uint32_t qvirtio_get_features(const QVirtioBus *bus, QVirtioDevice *d);
> -void qvirtio_set_features(const QVirtioBus *bus, QVirtioDevice *d,
> - uint32_t features);
> -
> -void qvirtio_reset(const QVirtioBus *bus, QVirtioDevice *d);
> -void qvirtio_set_acknowledge(const QVirtioBus *bus, QVirtioDevice *d);
> -void qvirtio_set_driver(const QVirtioBus *bus, QVirtioDevice *d);
> -void qvirtio_set_driver_ok(const QVirtioBus *bus, QVirtioDevice *d);
> -
> -void qvirtio_wait_queue_isr(const QVirtioBus *bus, QVirtioDevice *d,
> +uint8_t qvirtio_config_readb(QVirtioDevice *d, uint64_t addr);
> +uint16_t qvirtio_config_readw(QVirtioDevice *d, uint64_t addr);
> +uint32_t qvirtio_config_readl(QVirtioDevice *d, uint64_t addr);
> +uint64_t qvirtio_config_readq(QVirtioDevice *d, uint64_t addr);
> +uint32_t qvirtio_get_features(QVirtioDevice *d);
> +void qvirtio_set_features(QVirtioDevice *d, uint32_t features);
> +
> +void qvirtio_reset(QVirtioDevice *d);
> +void qvirtio_set_acknowledge(QVirtioDevice *d);
> +void qvirtio_set_driver(QVirtioDevice *d);
> +void qvirtio_set_driver_ok(QVirtioDevice *d);
> +
> +void qvirtio_wait_queue_isr(QVirtioDevice *d,
> QVirtQueue *vq, gint64 timeout_us);
> -uint8_t qvirtio_wait_status_byte_no_isr(const QVirtioBus *bus,
> - QVirtioDevice *d,
> +uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d,
> QVirtQueue *vq,
> uint64_t addr,
> gint64 timeout_us);
> -void qvirtio_wait_config_isr(const QVirtioBus *bus, QVirtioDevice *d,
> - gint64 timeout_us);
> -QVirtQueue *qvirtqueue_setup(const QVirtioBus *bus, QVirtioDevice *d,
> - QGuestAllocator *alloc, uint16_t index);
> +void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us);
> +QVirtQueue *qvirtqueue_setup(QVirtioDevice *d,
> + QGuestAllocator *alloc, uint16_t index);
> void qvirtqueue_cleanup(const QVirtioBus *bus, QVirtQueue *vq,
> QGuestAllocator *alloc);
>
> @@ -132,8 +128,7 @@ void qvring_indirect_desc_add(QVRingIndirectDesc *indirect, uint64_t data,
> uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write,
> bool next);
> uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect);
> -void qvirtqueue_kick(const QVirtioBus *bus, QVirtioDevice *d, QVirtQueue *vq,
> - uint32_t free_head);
> +void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head);
>
> void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx);
> #endif
> diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
> index d7c48c5..067b5a2 100644
> --- a/tests/vhost-user-test.c
> +++ b/tests/vhost-user-test.c
> @@ -170,15 +170,15 @@ static void init_virtio_dev(TestServer *s)
> g_assert_nonnull(dev);
>
> qvirtio_pci_device_enable(dev);
> - qvirtio_reset(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_acknowledge(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_driver(&qvirtio_pci, &dev->vdev);
> + qvirtio_reset(&dev->vdev);
> + qvirtio_set_acknowledge(&dev->vdev);
> + qvirtio_set_driver(&dev->vdev);
>
> - features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
> + features = qvirtio_get_features(&dev->vdev);
> features = features & VIRTIO_NET_F_MAC;
> - qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
> + qvirtio_set_features(&dev->vdev, features);
>
> - qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
> + qvirtio_set_driver_ok(&dev->vdev);
> }
>
> static void wait_for_fds(TestServer *s)
> @@ -840,24 +840,24 @@ static QVirtioPCIDevice *virtio_net_pci_init(QPCIBus *bus, int slot)
> g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_NET);
>
> qvirtio_pci_device_enable(dev);
> - qvirtio_reset(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_acknowledge(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_driver(&qvirtio_pci, &dev->vdev);
> + qvirtio_reset(&dev->vdev);
> + qvirtio_set_acknowledge(&dev->vdev);
> + qvirtio_set_driver(&dev->vdev);
>
> return dev;
> }
>
> -static void driver_init(const QVirtioBus *bus, QVirtioDevice *dev)
> +static void driver_init(QVirtioDevice *dev)
> {
> uint32_t features;
>
> - features = qvirtio_get_features(bus, dev);
> + features = qvirtio_get_features(dev);
> features = features & ~(QVIRTIO_F_BAD_FEATURE |
> (1u << VIRTIO_RING_F_INDIRECT_DESC) |
> (1u << VIRTIO_RING_F_EVENT_IDX));
> - qvirtio_set_features(bus, dev, features);
> + qvirtio_set_features(dev, features);
>
> - qvirtio_set_driver_ok(bus, dev);
> + qvirtio_set_driver_ok(dev);
> }
>
> #define PCI_SLOT 0x04
> @@ -889,16 +889,15 @@ static void test_multiqueue(void)
>
> alloc = pc_alloc_init();
> for (i = 0; i < queues * 2; i++) {
> - vq[i] = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
> - alloc, i);
> + vq[i] = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, i);
> }
>
> - driver_init(&qvirtio_pci, &dev->vdev);
> + driver_init(&dev->vdev);
> wait_for_rings_started(s, queues * 2);
>
> /* End test */
> for (i = 0; i < queues * 2; i++) {
> - qvirtqueue_cleanup(&qvirtio_pci, &vq[i]->vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, &vq[i]->vq, alloc);
> }
> pc_alloc_uninit(alloc);
> qvirtio_pci_device_disable(dev);
> diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c
> index e8b2196..2341622 100644
> --- a/tests/virtio-9p-test.c
> +++ b/tests/virtio-9p-test.c
> @@ -71,17 +71,17 @@ static QVirtIO9P *qvirtio_9p_pci_init(void)
> v9p->dev = (QVirtioDevice *) dev;
>
> qvirtio_pci_device_enable(dev);
> - qvirtio_reset(&qvirtio_pci, v9p->dev);
> - qvirtio_set_acknowledge(&qvirtio_pci, v9p->dev);
> - qvirtio_set_driver(&qvirtio_pci, v9p->dev);
> + qvirtio_reset(v9p->dev);
> + qvirtio_set_acknowledge(v9p->dev);
> + qvirtio_set_driver(v9p->dev);
>
> - v9p->vq = qvirtqueue_setup(&qvirtio_pci, v9p->dev, v9p->alloc, 0);
> + v9p->vq = qvirtqueue_setup(v9p->dev, v9p->alloc, 0);
> return v9p;
> }
>
> static void qvirtio_9p_pci_free(QVirtIO9P *v9p)
> {
> - qvirtqueue_cleanup(&qvirtio_pci, v9p->vq, v9p->alloc);
> + qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->alloc);
> pc_alloc_uninit(v9p->alloc);
> qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
> g_free(v9p->dev);
> @@ -101,15 +101,14 @@ static void pci_basic_config(void)
> v9p = qvirtio_9p_pci_init();
>
> addr = ((QVirtioPCIDevice *) v9p->dev)->addr + VIRTIO_PCI_CONFIG_OFF(false);
> - tag_len = qvirtio_config_readw(&qvirtio_pci, v9p->dev,
> + tag_len = qvirtio_config_readw(v9p->dev,
> (uint64_t)(uintptr_t)addr);
> g_assert_cmpint(tag_len, ==, strlen(mount_tag));
> addr += sizeof(uint16_t);
>
> tag = g_malloc(tag_len);
> for (i = 0; i < tag_len; i++) {
> - tag[i] = qvirtio_config_readb(&qvirtio_pci, v9p->dev,
> - (uint64_t)(uintptr_t)addr + i);
> + tag[i] = qvirtio_config_readb(v9p->dev, (uint64_t)(uintptr_t)addr + i);
> }
> g_assert_cmpmem(tag, tag_len, mount_tag, tag_len);
> g_free(tag);
> diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
> index 0506917..9a6f2cf 100644
> --- a/tests/virtio-blk-test.c
> +++ b/tests/virtio-blk-test.c
> @@ -110,9 +110,9 @@ static QVirtioPCIDevice *virtio_blk_pci_init(QPCIBus *bus, int slot)
> g_assert_cmphex(dev->pdev->devfn, ==, ((slot << 3) | PCI_FN));
>
> qvirtio_pci_device_enable(dev);
> - qvirtio_reset(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_acknowledge(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_driver(&qvirtio_pci, &dev->vdev);
> + qvirtio_reset(&dev->vdev);
> + qvirtio_set_acknowledge(&dev->vdev);
> + qvirtio_set_driver(&dev->vdev);
>
> return dev;
> }
> @@ -150,8 +150,8 @@ static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioBlkReq *req,
> return addr;
> }
>
> -static void test_basic(const QVirtioBus *bus, QVirtioDevice *dev,
> - QGuestAllocator *alloc, QVirtQueue *vq, uint64_t device_specific)
> +static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
> + QVirtQueue *vq, uint64_t device_specific)
> {
> QVirtioBlkReq req;
> uint64_t req_addr;
> @@ -161,18 +161,18 @@ static void test_basic(const QVirtioBus *bus, QVirtioDevice *dev,
> uint8_t status;
> char *data;
>
> - capacity = qvirtio_config_readq(bus, dev, device_specific);
> + capacity = qvirtio_config_readq(dev, device_specific);
>
> g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
>
> - features = qvirtio_get_features(bus, dev);
> + features = qvirtio_get_features(dev);
> features = features & ~(QVIRTIO_F_BAD_FEATURE |
> (1u << VIRTIO_RING_F_INDIRECT_DESC) |
> (1u << VIRTIO_RING_F_EVENT_IDX) |
> (1u << VIRTIO_BLK_F_SCSI));
> - qvirtio_set_features(bus, dev, features);
> + qvirtio_set_features(dev, features);
>
> - qvirtio_set_driver_ok(bus, dev);
> + qvirtio_set_driver_ok(dev);
>
> /* Write and read with 3 descriptor layout */
> /* Write request */
> @@ -190,9 +190,9 @@ static void test_basic(const QVirtioBus *bus, QVirtioDevice *dev,
> qvirtqueue_add(vq, req_addr + 16, 512, false, true);
> qvirtqueue_add(vq, req_addr + 528, 1, true, false);
>
> - qvirtqueue_kick(bus, dev, vq, free_head);
> + qvirtqueue_kick(dev, vq, free_head);
>
> - qvirtio_wait_queue_isr(bus, dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> status = readb(req_addr + 528);
> g_assert_cmpint(status, ==, 0);
>
> @@ -212,9 +212,9 @@ static void test_basic(const QVirtioBus *bus, QVirtioDevice *dev,
> qvirtqueue_add(vq, req_addr + 16, 512, true, true);
> qvirtqueue_add(vq, req_addr + 528, 1, true, false);
>
> - qvirtqueue_kick(bus, dev, vq, free_head);
> + qvirtqueue_kick(dev, vq, free_head);
>
> - qvirtio_wait_queue_isr(bus, dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> status = readb(req_addr + 528);
> g_assert_cmpint(status, ==, 0);
>
> @@ -240,9 +240,9 @@ static void test_basic(const QVirtioBus *bus, QVirtioDevice *dev,
>
> free_head = qvirtqueue_add(vq, req_addr, 528, false, true);
> qvirtqueue_add(vq, req_addr + 528, 1, true, false);
> - qvirtqueue_kick(bus, dev, vq, free_head);
> + qvirtqueue_kick(dev, vq, free_head);
>
> - qvirtio_wait_queue_isr(bus, dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> status = readb(req_addr + 528);
> g_assert_cmpint(status, ==, 0);
>
> @@ -261,9 +261,9 @@ static void test_basic(const QVirtioBus *bus, QVirtioDevice *dev,
> free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
> qvirtqueue_add(vq, req_addr + 16, 513, true, false);
>
> - qvirtqueue_kick(bus, dev, vq, free_head);
> + qvirtqueue_kick(dev, vq, free_head);
>
> - qvirtio_wait_queue_isr(bus, dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
> status = readb(req_addr + 528);
> g_assert_cmpint(status, ==, 0);
>
> @@ -288,17 +288,15 @@ static void pci_basic(void)
> dev = virtio_blk_pci_init(bus, PCI_SLOT);
>
> alloc = pc_alloc_init();
> - vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
> - alloc, 0);
> + vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
>
> /* MSI-X is not enabled */
> addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
>
> - test_basic(&qvirtio_pci, &dev->vdev, alloc, &vqpci->vq,
> - (uint64_t)(uintptr_t)addr);
> + test_basic(&dev->vdev, alloc, &vqpci->vq, (uint64_t)(uintptr_t)addr);
>
> /* End test */
> - qvirtqueue_cleanup(&qvirtio_pci, &vqpci->vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> pc_alloc_uninit(alloc);
> qvirtio_pci_device_disable(dev);
> g_free(dev);
> @@ -329,21 +327,19 @@ static void pci_indirect(void)
> /* MSI-X is not enabled */
> addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
>
> - capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev,
> - (uint64_t)(uintptr_t)addr);
> + capacity = qvirtio_config_readq(&dev->vdev, (uint64_t)(uintptr_t)addr);
> g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
>
> - features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
> + features = qvirtio_get_features(&dev->vdev);
> g_assert_cmphex(features & (1u << VIRTIO_RING_F_INDIRECT_DESC), !=, 0);
> features = features & ~(QVIRTIO_F_BAD_FEATURE |
> (1u << VIRTIO_RING_F_EVENT_IDX) |
> (1u << VIRTIO_BLK_F_SCSI));
> - qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
> + qvirtio_set_features(&dev->vdev, features);
>
> alloc = pc_alloc_init();
> - vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
> - alloc, 0);
> - qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
> + vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> + qvirtio_set_driver_ok(&dev->vdev);
>
> /* Write request */
> req.type = VIRTIO_BLK_T_OUT;
> @@ -360,9 +356,9 @@ static void pci_indirect(void)
> qvring_indirect_desc_add(indirect, req_addr, 528, false);
> qvring_indirect_desc_add(indirect, req_addr + 528, 1, true);
> free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
> - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
> + qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
>
> - qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
> + qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
> QVIRTIO_BLK_TIMEOUT_US);
> status = readb(req_addr + 528);
> g_assert_cmpint(status, ==, 0);
> @@ -385,9 +381,9 @@ static void pci_indirect(void)
> qvring_indirect_desc_add(indirect, req_addr, 16, false);
> qvring_indirect_desc_add(indirect, req_addr + 16, 513, true);
> free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
> - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
> + qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
>
> - qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
> + qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
> QVIRTIO_BLK_TIMEOUT_US);
> status = readb(req_addr + 528);
> g_assert_cmpint(status, ==, 0);
> @@ -401,7 +397,7 @@ static void pci_indirect(void)
> guest_free(alloc, req_addr);
>
> /* End test */
> - qvirtqueue_cleanup(&qvirtio_pci, &vqpci->vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> pc_alloc_uninit(alloc);
> qvirtio_pci_device_disable(dev);
> g_free(dev);
> @@ -424,18 +420,16 @@ static void pci_config(void)
> /* MSI-X is not enabled */
> addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
>
> - capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev,
> - (uint64_t)(uintptr_t)addr);
> + capacity = qvirtio_config_readq(&dev->vdev, (uint64_t)(uintptr_t)addr);
> g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
>
> - qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
> + qvirtio_set_driver_ok(&dev->vdev);
>
> qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
> " 'size': %d } }", n_size);
> - qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev, QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_config_isr(&dev->vdev, QVIRTIO_BLK_TIMEOUT_US);
>
> - capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev,
> - (uint64_t)(uintptr_t)addr);
> + capacity = qvirtio_config_readq(&dev->vdev, (uint64_t)(uintptr_t)addr);
> g_assert_cmpint(capacity, ==, n_size / 512);
>
> qvirtio_pci_device_disable(dev);
> @@ -471,30 +465,27 @@ static void pci_msix(void)
> /* MSI-X is enabled */
> addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(true);
>
> - capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev,
> - (uint64_t)(uintptr_t)addr);
> + capacity = qvirtio_config_readq(&dev->vdev, (uint64_t)(uintptr_t)addr);
> g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
>
> - features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
> + features = qvirtio_get_features(&dev->vdev);
> features = features & ~(QVIRTIO_F_BAD_FEATURE |
> (1u << VIRTIO_RING_F_INDIRECT_DESC) |
> (1u << VIRTIO_RING_F_EVENT_IDX) |
> (1u << VIRTIO_BLK_F_SCSI));
> - qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
> + qvirtio_set_features(&dev->vdev, features);
>
> - vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
> - alloc, 0);
> + vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
>
> - qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
> + qvirtio_set_driver_ok(&dev->vdev);
>
> qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
> " 'size': %d } }", n_size);
>
> - qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev, QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_config_isr(&dev->vdev, QVIRTIO_BLK_TIMEOUT_US);
>
> - capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev,
> - (uint64_t)(uintptr_t)addr);
> + capacity = qvirtio_config_readq(&dev->vdev, (uintptr_t)addr);
> g_assert_cmpint(capacity, ==, n_size / 512);
>
> /* Write request */
> @@ -511,9 +502,9 @@ static void pci_msix(void)
> free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
> - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
> + qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
>
> - qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
> + qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
> QVIRTIO_BLK_TIMEOUT_US);
>
> status = readb(req_addr + 528);
> @@ -535,10 +526,10 @@ static void pci_msix(void)
> qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, true, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
>
> - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
> + qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
>
>
> - qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
> + qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
> QVIRTIO_BLK_TIMEOUT_US);
>
> status = readb(req_addr + 528);
> @@ -552,7 +543,7 @@ static void pci_msix(void)
> guest_free(alloc, req_addr);
>
> /* End test */
> - qvirtqueue_cleanup(&qvirtio_pci, &vqpci->vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> pc_alloc_uninit(alloc);
> qpci_msix_disable(dev->pdev);
> qvirtio_pci_device_disable(dev);
> @@ -587,22 +578,20 @@ static void pci_idx(void)
> /* MSI-X is enabled */
> addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(true);
>
> - capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev,
> - (uint64_t)(uintptr_t)addr);
> + capacity = qvirtio_config_readq(&dev->vdev, (uint64_t)(uintptr_t)addr);
> g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
>
> - features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
> + features = qvirtio_get_features(&dev->vdev);
> features = features & ~(QVIRTIO_F_BAD_FEATURE |
> (1u << VIRTIO_RING_F_INDIRECT_DESC) |
> (1u << VIRTIO_F_NOTIFY_ON_EMPTY) |
> (1u << VIRTIO_BLK_F_SCSI));
> - qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
> + qvirtio_set_features(&dev->vdev, features);
>
> - vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
> - alloc, 0);
> + vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
>
> - qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
> + qvirtio_set_driver_ok(&dev->vdev);
>
> /* Write request */
> req.type = VIRTIO_BLK_T_OUT;
> @@ -618,10 +607,9 @@ static void pci_idx(void)
> free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
> - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
> + qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
>
> - qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
> - QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq, QVIRTIO_BLK_TIMEOUT_US);
>
> /* Write request */
> req.type = VIRTIO_BLK_T_OUT;
> @@ -639,10 +627,10 @@ static void pci_idx(void)
> free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
> - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
> + qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
>
> /* No notification expected */
> - status = qvirtio_wait_status_byte_no_isr(&qvirtio_pci, &dev->vdev,
> + status = qvirtio_wait_status_byte_no_isr(&dev->vdev,
> &vqpci->vq, req_addr + 528,
> QVIRTIO_BLK_TIMEOUT_US);
> g_assert_cmpint(status, ==, 0);
> @@ -663,9 +651,9 @@ static void pci_idx(void)
> qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, true, true);
> qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
>
> - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
> + qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
>
> - qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
> + qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
> QVIRTIO_BLK_TIMEOUT_US);
>
> status = readb(req_addr + 528);
> @@ -679,7 +667,7 @@ static void pci_idx(void)
> guest_free(alloc, req_addr);
>
> /* End test */
> - qvirtqueue_cleanup(&qvirtio_pci, &vqpci->vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> pc_alloc_uninit(alloc);
> qpci_msix_disable(dev->pdev);
> qvirtio_pci_device_disable(dev);
> @@ -724,28 +712,25 @@ static void mmio_basic(void)
> g_assert(dev != NULL);
> g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK);
>
> - qvirtio_reset(&qvirtio_mmio, &dev->vdev);
> - qvirtio_set_acknowledge(&qvirtio_mmio, &dev->vdev);
> - qvirtio_set_driver(&qvirtio_mmio, &dev->vdev);
> + qvirtio_reset(&dev->vdev);
> + qvirtio_set_acknowledge(&dev->vdev);
> + qvirtio_set_driver(&dev->vdev);
>
> alloc = generic_alloc_init(MMIO_RAM_ADDR, MMIO_RAM_SIZE, MMIO_PAGE_SIZE);
> - vq = qvirtqueue_setup(&qvirtio_mmio, &dev->vdev, alloc, 0);
> + vq = qvirtqueue_setup(&dev->vdev, alloc, 0);
>
> - test_basic(&qvirtio_mmio, &dev->vdev, alloc, vq,
> - QVIRTIO_MMIO_DEVICE_SPECIFIC);
> + test_basic(&dev->vdev, alloc, vq, QVIRTIO_MMIO_DEVICE_SPECIFIC);
>
> qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
> " 'size': %d } }", n_size);
>
> - qvirtio_wait_queue_isr(&qvirtio_mmio, &dev->vdev, vq,
> - QVIRTIO_BLK_TIMEOUT_US);
> + qvirtio_wait_queue_isr(&dev->vdev, vq, QVIRTIO_BLK_TIMEOUT_US);
>
> - capacity = qvirtio_config_readq(&qvirtio_mmio, &dev->vdev,
> - QVIRTIO_MMIO_DEVICE_SPECIFIC);
> + capacity = qvirtio_config_readq(&dev->vdev, QVIRTIO_MMIO_DEVICE_SPECIFIC);
> g_assert_cmpint(capacity, ==, n_size / 512);
>
> /* End test */
> - qvirtqueue_cleanup(&qvirtio_mmio, vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, vq, alloc);
> generic_alloc_uninit(alloc);
> g_free(dev);
> test_end();
> diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c
> index a343a6b..6fa385e 100644
> --- a/tests/virtio-net-test.c
> +++ b/tests/virtio-net-test.c
> @@ -46,9 +46,9 @@ static QVirtioPCIDevice *virtio_net_pci_init(QPCIBus *bus, int slot)
> g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_NET);
>
> qvirtio_pci_device_enable(dev);
> - qvirtio_reset(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_acknowledge(&qvirtio_pci, &dev->vdev);
> - qvirtio_set_driver(&qvirtio_pci, &dev->vdev);
> + qvirtio_reset(&dev->vdev);
> + qvirtio_set_acknowledge(&dev->vdev);
> + qvirtio_set_driver(&dev->vdev);
>
> return dev;
> }
> @@ -65,20 +65,20 @@ static QPCIBus *pci_test_start(int socket)
> return qpci_init_pc(NULL);
> }
>
> -static void driver_init(const QVirtioBus *bus, QVirtioDevice *dev)
> +static void driver_init(QVirtioDevice *dev)
> {
> uint32_t features;
>
> - features = qvirtio_get_features(bus, dev);
> + features = qvirtio_get_features(dev);
> features = features & ~(QVIRTIO_F_BAD_FEATURE |
> (1u << VIRTIO_RING_F_INDIRECT_DESC) |
> (1u << VIRTIO_RING_F_EVENT_IDX));
> - qvirtio_set_features(bus, dev, features);
> + qvirtio_set_features(dev, features);
>
> - qvirtio_set_driver_ok(bus, dev);
> + qvirtio_set_driver_ok(dev);
> }
>
> -static void rx_test(const QVirtioBus *bus, QVirtioDevice *dev,
> +static void rx_test(QVirtioDevice *dev,
> QGuestAllocator *alloc, QVirtQueue *vq,
> int socket)
> {
> @@ -101,19 +101,19 @@ static void rx_test(const QVirtioBus *bus, QVirtioDevice *dev,
> req_addr = guest_alloc(alloc, 64);
>
> free_head = qvirtqueue_add(vq, req_addr, 64, true, false);
> - qvirtqueue_kick(bus, dev, vq, free_head);
> + qvirtqueue_kick(dev, vq, free_head);
>
> ret = iov_send(socket, iov, 2, 0, sizeof(len) + sizeof(test));
> g_assert_cmpint(ret, ==, sizeof(test) + sizeof(len));
>
> - qvirtio_wait_queue_isr(bus, dev, vq, QVIRTIO_NET_TIMEOUT_US);
> + qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
> memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
> g_assert_cmpstr(buffer, ==, "TEST");
>
> guest_free(alloc, req_addr);
> }
>
> -static void tx_test(const QVirtioBus *bus, QVirtioDevice *dev,
> +static void tx_test(QVirtioDevice *dev,
> QGuestAllocator *alloc, QVirtQueue *vq,
> int socket)
> {
> @@ -127,9 +127,9 @@ static void tx_test(const QVirtioBus *bus, QVirtioDevice *dev,
> memwrite(req_addr + VNET_HDR_SIZE, "TEST", 4);
>
> free_head = qvirtqueue_add(vq, req_addr, 64, false, false);
> - qvirtqueue_kick(bus, dev, vq, free_head);
> + qvirtqueue_kick(dev, vq, free_head);
>
> - qvirtio_wait_queue_isr(bus, dev, vq, QVIRTIO_NET_TIMEOUT_US);
> + qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
> guest_free(alloc, req_addr);
>
> ret = qemu_recv(socket, &len, sizeof(len), 0);
> @@ -140,7 +140,7 @@ static void tx_test(const QVirtioBus *bus, QVirtioDevice *dev,
> g_assert_cmpstr(buffer, ==, "TEST");
> }
>
> -static void rx_stop_cont_test(const QVirtioBus *bus, QVirtioDevice *dev,
> +static void rx_stop_cont_test(QVirtioDevice *dev,
> QGuestAllocator *alloc, QVirtQueue *vq,
> int socket)
> {
> @@ -164,7 +164,7 @@ static void rx_stop_cont_test(const QVirtioBus *bus, QVirtioDevice *dev,
> req_addr = guest_alloc(alloc, 64);
>
> free_head = qvirtqueue_add(vq, req_addr, 64, true, false);
> - qvirtqueue_kick(bus, dev, vq, free_head);
> + qvirtqueue_kick(dev, vq, free_head);
>
> rsp = qmp("{ 'execute' : 'stop'}");
> QDECREF(rsp);
> @@ -180,26 +180,26 @@ static void rx_stop_cont_test(const QVirtioBus *bus, QVirtioDevice *dev,
> rsp = qmp("{ 'execute' : 'cont'}");
> QDECREF(rsp);
>
> - qvirtio_wait_queue_isr(bus, dev, vq, QVIRTIO_NET_TIMEOUT_US);
> + qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
> memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
> g_assert_cmpstr(buffer, ==, "TEST");
>
> guest_free(alloc, req_addr);
> }
>
> -static void send_recv_test(const QVirtioBus *bus, QVirtioDevice *dev,
> +static void send_recv_test(QVirtioDevice *dev,
> QGuestAllocator *alloc, QVirtQueue *rvq,
> QVirtQueue *tvq, int socket)
> {
> - rx_test(bus, dev, alloc, rvq, socket);
> - tx_test(bus, dev, alloc, tvq, socket);
> + rx_test(dev, alloc, rvq, socket);
> + tx_test(dev, alloc, tvq, socket);
> }
>
> -static void stop_cont_test(const QVirtioBus *bus, QVirtioDevice *dev,
> +static void stop_cont_test(QVirtioDevice *dev,
> QGuestAllocator *alloc, QVirtQueue *rvq,
> QVirtQueue *tvq, int socket)
> {
> - rx_stop_cont_test(bus, dev, alloc, rvq, socket);
> + rx_stop_cont_test(dev, alloc, rvq, socket);
> }
>
> static void pci_basic(gconstpointer data)
> @@ -208,8 +208,7 @@ static void pci_basic(gconstpointer data)
> QPCIBus *bus;
> QVirtQueuePCI *tx, *rx;
> QGuestAllocator *alloc;
> - void (*func) (const QVirtioBus *bus,
> - QVirtioDevice *dev,
> + void (*func) (QVirtioDevice *dev,
> QGuestAllocator *alloc,
> QVirtQueue *rvq,
> QVirtQueue *tvq,
> @@ -223,18 +222,16 @@ static void pci_basic(gconstpointer data)
> dev = virtio_net_pci_init(bus, PCI_SLOT);
>
> alloc = pc_alloc_init();
> - rx = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
> - alloc, 0);
> - tx = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
> - alloc, 1);
> + rx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> + tx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 1);
>
> - driver_init(&qvirtio_pci, &dev->vdev);
> - func(&qvirtio_pci, &dev->vdev, alloc, &rx->vq, &tx->vq, sv[0]);
> + driver_init(&dev->vdev);
> + func(&dev->vdev, alloc, &rx->vq, &tx->vq, sv[0]);
>
> /* End test */
> close(sv[0]);
> - qvirtqueue_cleanup(&qvirtio_pci, &tx->vq, alloc);
> - qvirtqueue_cleanup(&qvirtio_pci, &rx->vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, &tx->vq, alloc);
> + qvirtqueue_cleanup(dev->vdev.bus, &rx->vq, alloc);
> pc_alloc_uninit(alloc);
> qvirtio_pci_device_disable(dev);
> g_free(dev->pdev);
> diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
> index 94d75b1..3dbec2f 100644
> --- a/tests/virtio-scsi-test.c
> +++ b/tests/virtio-scsi-test.c
> @@ -58,7 +58,7 @@ static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs)
> int i;
>
> for (i = 0; i < vs->num_queues + 2; i++) {
> - qvirtqueue_cleanup(&qvirtio_pci, vs->vq[i], vs->alloc);
> + qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->alloc);
> }
> pc_alloc_uninit(vs->alloc);
> qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev));
> @@ -119,8 +119,8 @@ static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb,
> qvirtqueue_add(vq, data_in_addr, data_in_len, true, false);
> }
>
> - qvirtqueue_kick(&qvirtio_pci, vs->dev, vq, free_head);
> - qvirtio_wait_queue_isr(&qvirtio_pci, vs->dev, vq, QVIRTIO_SCSI_TIMEOUT_US);
> + qvirtqueue_kick(vs->dev, vq, free_head);
> + qvirtio_wait_queue_isr(vs->dev, vq, QVIRTIO_SCSI_TIMEOUT_US);
>
> response = readb(resp_addr +
> offsetof(struct virtio_scsi_cmd_resp, response));
> @@ -155,18 +155,17 @@ static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot)
> g_assert_cmphex(vs->dev->device_type, ==, VIRTIO_ID_SCSI);
>
> qvirtio_pci_device_enable(dev);
> - qvirtio_reset(&qvirtio_pci, vs->dev);
> - qvirtio_set_acknowledge(&qvirtio_pci, vs->dev);
> - qvirtio_set_driver(&qvirtio_pci, vs->dev);
> + qvirtio_reset(vs->dev);
> + qvirtio_set_acknowledge(vs->dev);
> + qvirtio_set_driver(vs->dev);
>
> addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
> - vs->num_queues = qvirtio_config_readl(&qvirtio_pci, vs->dev,
> - (uint64_t)(uintptr_t)addr);
> + vs->num_queues = qvirtio_config_readl(vs->dev, (uint64_t)(uintptr_t)addr);
>
> g_assert_cmpint(vs->num_queues, <, MAX_NUM_QUEUES);
>
> for (i = 0; i < vs->num_queues + 2; i++) {
> - vs->vq[i] = qvirtqueue_setup(&qvirtio_pci, vs->dev, vs->alloc, i);
> + vs->vq[i] = qvirtqueue_setup(vs->dev, vs->alloc, i);
> }
>
> /* Clear the POWER ON OCCURRED unit attention */
next prev parent reply other threads:[~2016-10-14 22:20 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
2016-10-14 8:58 [Qemu-devel] [PATCH v4 0/6] tests: enable virtio tests on SPAPR Laurent Vivier
2016-10-14 8:58 ` [Qemu-devel] [PATCH v4 1/6] tests: fix memory leak in virtio-scsi-test Laurent Vivier
2016-10-14 16:18 ` Greg Kurz
2016-10-14 8:58 ` [Qemu-devel] [PATCH v4 2/6] tests: don't check if qtest_spapr_boot() returns NULL Laurent Vivier
2016-10-14 16:46 ` Greg Kurz
2016-10-14 8:58 ` [Qemu-devel] [PATCH v4 3/6] tests: move QVirtioBus pointer into QVirtioDevice Laurent Vivier
2016-10-14 22:19 ` Greg Kurz [this message]
2016-10-14 8:58 ` [Qemu-devel] [PATCH v4 4/6] tests: rename target_big_endian() as qvirtio_is_big_endian() Laurent Vivier
2016-10-14 21:11 ` Greg Kurz
2016-10-14 8:58 ` [Qemu-devel] [PATCH v4 5/6] tests: use qtest_pc_boot()/qtest_shutdown() in virtio tests Laurent Vivier
2016-10-14 21:20 ` Greg Kurz
2016-10-14 8:58 ` [Qemu-devel] [PATCH v4 6/6] tests: enable virtio tests on SPAPR Laurent Vivier
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20161015001958.49e4c950@bahia \
--to=groug@kaod.org \
--cc=dgibson@redhat.com \
--cc=lvivier@redhat.com \
--cc=qemu-devel@nongnu.org \
--cc=qemu-ppc@nongnu.org \
--cc=thuth@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.