On Fri, 14 Oct 2016 10:58:52 +0200
Laurent Vivier <lviv...@redhat.com> wrote:

> This allows to not have to pass bus and device for every virtio functions.
> 
> Signed-off-by: Laurent Vivier <lviv...@redhat.com>
> ---

Reviewed-by: Greg Kurz <gr...@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 */


Reply via email to