[Qemu-devel] [PATCH v4 0/6] tests: enable virtio tests on SPAPR

All of lore.kernel.org
 help / color / mirror / Atom feed

* [Qemu-devel] [PATCH v4 0/6] tests: enable virtio tests on SPAPR
@ 2016-10-14  8:58 Laurent Vivier
  2016-10-14  8:58 ` [Qemu-devel] [PATCH v4 1/6] tests: fix memory leak in virtio-scsi-test Laurent Vivier
                   ` (5 more replies)
  0 siblings, 6 replies; 12+ messages in thread
From: Laurent Vivier @ 2016-10-14  8:58 UTC (permalink / raw)
  To: qemu-devel; +Cc: dgibson, thuth, qemu-ppc, Greg Kurz, Laurent Vivier

This series enables virtio tests on SPAPR by starting
machines using qtest_pc_boot() or qtest_spapr_boot() to
use the good libqos PCI framework (pc or spapr).

It adds also some byte-swapping in virtio-pci.c as
PCI is always little-endian and the endianness of
the virtio device depends on the endianness of the
guest.

This series does not enable virtio PCI MSI-X tests on
SPAPR as this needs more work and will be the aim
of another series.

v4:
- rebase on papr/ppc-for-2.8
- add a patch to rename target_big_endian() to qvirtio_is_big_endian()
- Add a patch to remove the QVirtioBus arguments from all virtio functions

v3:
- remove "ppc" from allowed archs for virtio-blk-test
- remove g_assert_nonnull() after g_malloc()
- add a patch to fix "vs" memory leak in virtio-scsi-test
- add a patch to remove g_assert() after qtest_spapr_boot()
  and update comment qtest_vboot() to explain it never
  returns NULL.

v2:
- update comments (virtio-1.0, log)
- move g_assert_nonnull() to qtest_boot()
- exit gracefully if the architecture is not supported
- replace qtest_pc_shutdown() by qtest_shutdown()
- move qvirtio_scsi_stop() to qvirtio_scsi_pci_free()

Laurent Vivier (6):
  tests: fix memory leak in virtio-scsi-test
  tests: don't check if qtest_spapr_boot() returns NULL
  tests: move QVirtioBus pointer into QVirtioDevice
  tests: rename target_big_endian() as qvirtio_is_big_endian()
  tests: use qtest_pc_boot()/qtest_shutdown() in virtio tests
  tests: enable virtio tests on SPAPR

 tests/Makefile.include     |   3 +-
 tests/libqos/libqos.c      |   1 +
 tests/libqos/virtio-mmio.c |   1 +
 tests/libqos/virtio-pci.c  |  28 +++-
 tests/libqos/virtio.c      |  77 +++++------
 tests/libqos/virtio.h      |  57 ++++----
 tests/libqtest.h           |  10 --
 tests/rtas-test.c          |   1 -
 tests/vhost-user-test.c    |  33 +++--
 tests/virtio-9p-test.c     |  70 +++++-----
 tests/virtio-blk-test.c    | 322 +++++++++++++++++++++------------------------
 tests/virtio-net-test.c    | 106 +++++++--------
 tests/virtio-rng-test.c    |   7 +-
 tests/virtio-scsi-test.c   |  91 ++++++-------
 14 files changed, 399 insertions(+), 408 deletions(-)

-- 
2.7.4

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [Qemu-devel] [PATCH v4 1/6] tests: fix memory leak in virtio-scsi-test
  2016-10-14  8:58 [Qemu-devel] [PATCH v4 0/6] tests: enable virtio tests on SPAPR Laurent Vivier
@ 2016-10-14  8:58 ` 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
                   ` (4 subsequent siblings)
  5 siblings, 1 reply; 12+ messages in thread
From: Laurent Vivier @ 2016-10-14  8:58 UTC (permalink / raw)
  To: qemu-devel; +Cc: dgibson, thuth, qemu-ppc, Greg Kurz, Laurent Vivier

vs is allocated in qvirtio_scsi_pci_init() and never freed.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
---
 tests/virtio-scsi-test.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
index 79088bb..94d75b1 100644
--- a/tests/virtio-scsi-test.c
+++ b/tests/virtio-scsi-test.c
@@ -64,6 +64,7 @@ static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs)
     qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev));
     g_free(vs->dev);
     qpci_free_pc(vs->bus);
+    g_free(vs);
 }
 
 static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size,
-- 
2.7.4

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* Re: [Qemu-devel] [PATCH v4 1/6] tests: fix memory leak in virtio-scsi-test
  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
  0 siblings, 0 replies; 12+ messages in thread
From: Greg Kurz @ 2016-10-14 16:18 UTC (permalink / raw)
  To: Laurent Vivier; +Cc: qemu-devel, dgibson, thuth, qemu-ppc

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

> vs is allocated in qvirtio_scsi_pci_init() and never freed.
> 
> Signed-off-by: Laurent Vivier <lvivier@redhat.com>
> ---

Reviewed-by: Greg Kurz <groug@kaod.org>

>  tests/virtio-scsi-test.c | 1 +
>  1 file changed, 1 insertion(+)
> 
> diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
> index 79088bb..94d75b1 100644
> --- a/tests/virtio-scsi-test.c
> +++ b/tests/virtio-scsi-test.c
> @@ -64,6 +64,7 @@ static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs)
>      qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev));
>      g_free(vs->dev);
>      qpci_free_pc(vs->bus);
> +    g_free(vs);
>  }
>  
>  static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size,

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [Qemu-devel] [PATCH v4 2/6] tests: don't check if qtest_spapr_boot() returns NULL
  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  8:58 ` 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
                   ` (3 subsequent siblings)
  5 siblings, 1 reply; 12+ messages in thread
From: Laurent Vivier @ 2016-10-14  8:58 UTC (permalink / raw)
  To: qemu-devel; +Cc: dgibson, thuth, qemu-ppc, Greg Kurz, Laurent Vivier

qtest_spapr_boot()/qtest_pc_boot()/qtest_boot() call qtest_vboot()
and qtest_vboot() calls g_malloc(),
and g_malloc() never fails:
if memory allocation fails, the application is terminated.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
---
 tests/libqos/libqos.c | 1 +
 tests/rtas-test.c     | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/libqos/libqos.c b/tests/libqos/libqos.c
index 7abb482..65d6296 100644
--- a/tests/libqos/libqos.c
+++ b/tests/libqos/libqos.c
@@ -10,6 +10,7 @@
 /**
  * Launch QEMU with the given command line,
  * and then set up interrupts and our guest malloc interface.
+ * Never return NULL as the application is terminated if g_malloc() fails.
  */
 QOSState *qtest_vboot(QOSOps *ops, const char *cmdline_fmt, va_list ap)
 {
diff --git a/tests/rtas-test.c b/tests/rtas-test.c
index ba0867a..276c87e 100644
--- a/tests/rtas-test.c
+++ b/tests/rtas-test.c
@@ -14,7 +14,6 @@ static void test_rtas_get_time_of_day(void)
     time_t t1, t2;
 
     qs = qtest_spapr_boot("-machine pseries");
-    g_assert(qs != NULL);
 
     t1 = time(NULL);
     ret = qrtas_get_time_of_day(qs->alloc, &tm, &ns);
-- 
2.7.4

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* Re: [Qemu-devel] [PATCH v4 2/6] tests: don't check if qtest_spapr_boot() returns NULL
  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
  0 siblings, 0 replies; 12+ messages in thread
From: Greg Kurz @ 2016-10-14 16:46 UTC (permalink / raw)
  To: Laurent Vivier; +Cc: qemu-devel, dgibson, thuth, qemu-ppc

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

> qtest_spapr_boot()/qtest_pc_boot()/qtest_boot() call qtest_vboot()
> and qtest_vboot() calls g_malloc(),
> and g_malloc() never fails:
> if memory allocation fails, the application is terminated.
> 

And even if qtest_vboot() would be using g_try_malloc(), it would crash
anyway:

    qs->qts = qtest_start(cmdline);
    qs->ops = ops;

> Signed-off-by: Laurent Vivier <lvivier@redhat.com>
> ---
>  tests/libqos/libqos.c | 1 +
>  tests/rtas-test.c     | 1 -
>  2 files changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/tests/libqos/libqos.c b/tests/libqos/libqos.c
> index 7abb482..65d6296 100644
> --- a/tests/libqos/libqos.c
> +++ b/tests/libqos/libqos.c
> @@ -10,6 +10,7 @@
>  /**
>   * Launch QEMU with the given command line,
>   * and then set up interrupts and our guest malloc interface.
> + * Never return NULL as the application is terminated if g_malloc() fails.

True, but my point was that qtest_vboot() should never return NULL in any
case: how could the caller (i.e. a test program) could possibly recover
from such a failure ?

>   */
>  QOSState *qtest_vboot(QOSOps *ops, const char *cmdline_fmt, va_list ap)
>  {
> diff --git a/tests/rtas-test.c b/tests/rtas-test.c
> index ba0867a..276c87e 100644
> --- a/tests/rtas-test.c
> +++ b/tests/rtas-test.c
> @@ -14,7 +14,6 @@ static void test_rtas_get_time_of_day(void)
>      time_t t1, t2;
>  
>      qs = qtest_spapr_boot("-machine pseries");
> -    g_assert(qs != NULL);
>  
>      t1 = time(NULL);
>      ret = qrtas_get_time_of_day(qs->alloc, &tm, &ns);

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [Qemu-devel] [PATCH v4 3/6] tests: move QVirtioBus pointer into QVirtioDevice
  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  8:58 ` [Qemu-devel] [PATCH v4 2/6] tests: don't check if qtest_spapr_boot() returns NULL Laurent Vivier
@ 2016-10-14  8:58 ` Laurent Vivier
  2016-10-14 22:19   ` Greg Kurz
  2016-10-14  8:58 ` [Qemu-devel] [PATCH v4 4/6] tests: rename target_big_endian() as qvirtio_is_big_endian() Laurent Vivier
                   ` (2 subsequent siblings)
  5 siblings, 1 reply; 12+ messages in thread
From: Laurent Vivier @ 2016-10-14  8:58 UTC (permalink / raw)
  To: qemu-devel; +Cc: dgibson, thuth, qemu-ppc, Greg Kurz, Laurent Vivier

This allows to not have to pass bus and device for every virtio functions.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
---
 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 */
-- 
2.7.4

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* Re: [Qemu-devel] [PATCH v4 3/6] tests: move QVirtioBus pointer into QVirtioDevice
  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
  0 siblings, 0 replies; 12+ messages in thread
From: Greg Kurz @ 2016-10-14 22:19 UTC (permalink / raw)
  To: Laurent Vivier; +Cc: qemu-devel, dgibson, thuth, qemu-ppc

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 */

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [Qemu-devel] [PATCH v4 4/6] tests: rename target_big_endian() as qvirtio_is_big_endian()
  2016-10-14  8:58 [Qemu-devel] [PATCH v4 0/6] tests: enable virtio tests on SPAPR Laurent Vivier
                   ` (2 preceding siblings ...)
  2016-10-14  8:58 ` [Qemu-devel] [PATCH v4 3/6] tests: move QVirtioBus pointer into QVirtioDevice Laurent Vivier
@ 2016-10-14  8:58 ` 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  8:58 ` [Qemu-devel] [PATCH v4 6/6] tests: enable virtio tests on SPAPR Laurent Vivier
  5 siblings, 1 reply; 12+ messages in thread
From: Laurent Vivier @ 2016-10-14  8:58 UTC (permalink / raw)
  To: qemu-devel; +Cc: dgibson, thuth, qemu-ppc, Greg Kurz, Laurent Vivier

Move the definition to libqos/virtio.h as it must be used
only with virtio functions.

Add a QVirtioDevice parameter as it will be needed to
know if the virtio device is using virtio 1.0 specification
and thus is always little-endian (to do)

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
---
 tests/libqos/virtio-pci.c |  2 +-
 tests/libqos/virtio.h     |  6 ++++++
 tests/libqtest.h          | 10 ----------
 tests/virtio-blk-test.c   | 36 ++++++++++++++++++------------------
 4 files changed, 25 insertions(+), 29 deletions(-)

diff --git a/tests/libqos/virtio-pci.c b/tests/libqos/virtio-pci.c
index bbfed58..7aa29b1 100644
--- a/tests/libqos/virtio-pci.c
+++ b/tests/libqos/virtio-pci.c
@@ -86,7 +86,7 @@ static uint64_t qvirtio_pci_config_readq(QVirtioDevice *d, uint64_t addr)
     int i;
     uint64_t u64 = 0;
 
-    if (target_big_endian()) {
+    if (qvirtio_is_big_endian(d)) {
         for (i = 0; i < 8; ++i) {
             u64 |= (uint64_t)qpci_io_readb(dev->pdev,
                                 (void *)(uintptr_t)addr + i) << (7 - i) * 8;
diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h
index ac4669a..3397a08 100644
--- a/tests/libqos/virtio.h
+++ b/tests/libqos/virtio.h
@@ -89,6 +89,12 @@ struct QVirtioBus {
     void (*virtqueue_kick)(QVirtioDevice *d, QVirtQueue *vq);
 };
 
+static inline bool qvirtio_is_big_endian(QVirtioDevice *d)
+{
+    /* FIXME: virtio 1.0 is always little-endian */
+    return qtest_big_endian(global_qtest);
+}
+
 static inline uint32_t qvring_size(uint32_t num, uint32_t align)
 {
     return ((sizeof(struct vring_desc) * num + sizeof(uint16_t) * (3 + num)
diff --git a/tests/libqtest.h b/tests/libqtest.h
index 4be1f77..0224f06 100644
--- a/tests/libqtest.h
+++ b/tests/libqtest.h
@@ -881,16 +881,6 @@ static inline int64_t clock_set(int64_t val)
     return qtest_clock_set(global_qtest, val);
 }
 
-/**
- * target_big_endian:
- *
- * Returns: True if the architecture under test has a big endian configuration.
- */
-static inline bool target_big_endian(void)
-{
-    return qtest_big_endian(global_qtest);
-}
-
 QDict *qmp_fd_receive(int fd);
 void qmp_fd_sendv(int fd, const char *fmt, va_list ap);
 void qmp_fd_send(int fd, const char *fmt, ...);
diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
index 9a6f2cf..79e21c5 100644
--- a/tests/virtio-blk-test.c
+++ b/tests/virtio-blk-test.c
@@ -117,23 +117,23 @@ static QVirtioPCIDevice *virtio_blk_pci_init(QPCIBus *bus, int slot)
     return dev;
 }
 
-static inline void virtio_blk_fix_request(QVirtioBlkReq *req)
+static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
 {
 #ifdef HOST_WORDS_BIGENDIAN
-    bool host_endian = true;
+    const bool host_is_big_endian = true;
 #else
-    bool host_endian = false;
+    const bool host_is_big_endian = false;
 #endif
 
-    if (target_big_endian() != host_endian) {
+    if (qvirtio_is_big_endian(d) != host_is_big_endian) {
         req->type = bswap32(req->type);
         req->ioprio = bswap32(req->ioprio);
         req->sector = bswap64(req->sector);
     }
 }
 
-static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioBlkReq *req,
-                                                            uint64_t data_size)
+static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
+                                   QVirtioBlkReq *req, uint64_t data_size)
 {
     uint64_t addr;
     uint8_t status = 0xFF;
@@ -141,7 +141,7 @@ static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioBlkReq *req,
     g_assert_cmpuint(data_size % 512, ==, 0);
     addr = guest_alloc(alloc, sizeof(*req) + data_size);
 
-    virtio_blk_fix_request(req);
+    virtio_blk_fix_request(d, req);
 
     memwrite(addr, req, 16);
     memwrite(addr + 16, req->data, data_size);
@@ -182,7 +182,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, dev, &req, 512);
 
     g_free(req.data);
 
@@ -204,7 +204,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
     req.sector = 0;
     req.data = g_malloc0(512);
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, dev, &req, 512);
 
     g_free(req.data);
 
@@ -234,7 +234,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
         req.data = g_malloc0(512);
         strcpy(req.data, "TEST");
 
-        req_addr = virtio_blk_request(alloc, &req, 512);
+        req_addr = virtio_blk_request(alloc, dev, &req, 512);
 
         g_free(req.data);
 
@@ -254,7 +254,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
         req.sector = 1;
         req.data = g_malloc0(512);
 
-        req_addr = virtio_blk_request(alloc, &req, 512);
+        req_addr = virtio_blk_request(alloc, dev, &req, 512);
 
         g_free(req.data);
 
@@ -348,7 +348,7 @@ static void pci_indirect(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -373,7 +373,7 @@ static void pci_indirect(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -495,7 +495,7 @@ static void pci_msix(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -518,7 +518,7 @@ static void pci_msix(void)
     req.sector = 0;
     req.data = g_malloc0(512);
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -600,7 +600,7 @@ static void pci_idx(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -618,7 +618,7 @@ static void pci_idx(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -643,7 +643,7 @@ static void pci_idx(void)
     req.sector = 1;
     req.data = g_malloc0(512);
 
-    req_addr = virtio_blk_request(alloc, &req, 512);
+    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
-- 
2.7.4

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* Re: [Qemu-devel] [PATCH v4 4/6] tests: rename target_big_endian() as qvirtio_is_big_endian()
  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
  0 siblings, 0 replies; 12+ messages in thread
From: Greg Kurz @ 2016-10-14 21:11 UTC (permalink / raw)
  To: Laurent Vivier; +Cc: qemu-devel, dgibson, thuth, qemu-ppc

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

> Move the definition to libqos/virtio.h as it must be used
> only with virtio functions.
> 
> Add a QVirtioDevice parameter as it will be needed to
> know if the virtio device is using virtio 1.0 specification
> and thus is always little-endian (to do)
> 
> Signed-off-by: Laurent Vivier <lvivier@redhat.com>
> ---

Reviewed-by: Greg Kurz <groug@kaod.org>

>  tests/libqos/virtio-pci.c |  2 +-
>  tests/libqos/virtio.h     |  6 ++++++
>  tests/libqtest.h          | 10 ----------
>  tests/virtio-blk-test.c   | 36 ++++++++++++++++++------------------
>  4 files changed, 25 insertions(+), 29 deletions(-)
> 
> diff --git a/tests/libqos/virtio-pci.c b/tests/libqos/virtio-pci.c
> index bbfed58..7aa29b1 100644
> --- a/tests/libqos/virtio-pci.c
> +++ b/tests/libqos/virtio-pci.c
> @@ -86,7 +86,7 @@ static uint64_t qvirtio_pci_config_readq(QVirtioDevice *d, uint64_t addr)
>      int i;
>      uint64_t u64 = 0;
>  
> -    if (target_big_endian()) {
> +    if (qvirtio_is_big_endian(d)) {
>          for (i = 0; i < 8; ++i) {
>              u64 |= (uint64_t)qpci_io_readb(dev->pdev,
>                                  (void *)(uintptr_t)addr + i) << (7 - i) * 8;
> diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h
> index ac4669a..3397a08 100644
> --- a/tests/libqos/virtio.h
> +++ b/tests/libqos/virtio.h
> @@ -89,6 +89,12 @@ struct QVirtioBus {
>      void (*virtqueue_kick)(QVirtioDevice *d, QVirtQueue *vq);
>  };
>  
> +static inline bool qvirtio_is_big_endian(QVirtioDevice *d)
> +{
> +    /* FIXME: virtio 1.0 is always little-endian */
> +    return qtest_big_endian(global_qtest);
> +}
> +
>  static inline uint32_t qvring_size(uint32_t num, uint32_t align)
>  {
>      return ((sizeof(struct vring_desc) * num + sizeof(uint16_t) * (3 + num)
> diff --git a/tests/libqtest.h b/tests/libqtest.h
> index 4be1f77..0224f06 100644
> --- a/tests/libqtest.h
> +++ b/tests/libqtest.h
> @@ -881,16 +881,6 @@ static inline int64_t clock_set(int64_t val)
>      return qtest_clock_set(global_qtest, val);
>  }
>  
> -/**
> - * target_big_endian:
> - *
> - * Returns: True if the architecture under test has a big endian configuration.
> - */
> -static inline bool target_big_endian(void)
> -{
> -    return qtest_big_endian(global_qtest);
> -}
> -
>  QDict *qmp_fd_receive(int fd);
>  void qmp_fd_sendv(int fd, const char *fmt, va_list ap);
>  void qmp_fd_send(int fd, const char *fmt, ...);
> diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
> index 9a6f2cf..79e21c5 100644
> --- a/tests/virtio-blk-test.c
> +++ b/tests/virtio-blk-test.c
> @@ -117,23 +117,23 @@ static QVirtioPCIDevice *virtio_blk_pci_init(QPCIBus *bus, int slot)
>      return dev;
>  }
>  
> -static inline void virtio_blk_fix_request(QVirtioBlkReq *req)
> +static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
>  {
>  #ifdef HOST_WORDS_BIGENDIAN
> -    bool host_endian = true;
> +    const bool host_is_big_endian = true;
>  #else
> -    bool host_endian = false;
> +    const bool host_is_big_endian = false;
>  #endif
>  
> -    if (target_big_endian() != host_endian) {
> +    if (qvirtio_is_big_endian(d) != host_is_big_endian) {
>          req->type = bswap32(req->type);
>          req->ioprio = bswap32(req->ioprio);
>          req->sector = bswap64(req->sector);
>      }
>  }
>  
> -static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioBlkReq *req,
> -                                                            uint64_t data_size)
> +static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
> +                                   QVirtioBlkReq *req, uint64_t data_size)
>  {
>      uint64_t addr;
>      uint8_t status = 0xFF;
> @@ -141,7 +141,7 @@ static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioBlkReq *req,
>      g_assert_cmpuint(data_size % 512, ==, 0);
>      addr = guest_alloc(alloc, sizeof(*req) + data_size);
>  
> -    virtio_blk_fix_request(req);
> +    virtio_blk_fix_request(d, req);
>  
>      memwrite(addr, req, 16);
>      memwrite(addr + 16, req->data, data_size);
> @@ -182,7 +182,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, dev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -204,7 +204,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
>      req.sector = 0;
>      req.data = g_malloc0(512);
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, dev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -234,7 +234,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
>          req.data = g_malloc0(512);
>          strcpy(req.data, "TEST");
>  
> -        req_addr = virtio_blk_request(alloc, &req, 512);
> +        req_addr = virtio_blk_request(alloc, dev, &req, 512);
>  
>          g_free(req.data);
>  
> @@ -254,7 +254,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
>          req.sector = 1;
>          req.data = g_malloc0(512);
>  
> -        req_addr = virtio_blk_request(alloc, &req, 512);
> +        req_addr = virtio_blk_request(alloc, dev, &req, 512);
>  
>          g_free(req.data);
>  
> @@ -348,7 +348,7 @@ static void pci_indirect(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -373,7 +373,7 @@ static void pci_indirect(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -495,7 +495,7 @@ static void pci_msix(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -518,7 +518,7 @@ static void pci_msix(void)
>      req.sector = 0;
>      req.data = g_malloc0(512);
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -600,7 +600,7 @@ static void pci_idx(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -618,7 +618,7 @@ static void pci_idx(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -643,7 +643,7 @@ static void pci_idx(void)
>      req.sector = 1;
>      req.data = g_malloc0(512);
>  
> -    req_addr = virtio_blk_request(alloc, &req, 512);
> +    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [Qemu-devel] [PATCH v4 5/6] tests: use qtest_pc_boot()/qtest_shutdown() in virtio tests
  2016-10-14  8:58 [Qemu-devel] [PATCH v4 0/6] tests: enable virtio tests on SPAPR Laurent Vivier
                   ` (3 preceding siblings ...)
  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  8:58 ` 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
  5 siblings, 1 reply; 12+ messages in thread
From: Laurent Vivier @ 2016-10-14  8:58 UTC (permalink / raw)
  To: qemu-devel; +Cc: dgibson, thuth, qemu-ppc, Greg Kurz, Laurent Vivier

This patch replaces calls to qtest_start() and qtest_end() by
calls to qtest_pc_boot() and qtest_shutdown().

This allows to initialize memory allocator and PCI interface
functions. This will ease to enable virtio tests on other
architectures by only adding a specific qtest_XXX_boot() (like
qtest_spapr_boot()).

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
---
 tests/virtio-9p-test.c   |  51 +++++++---------
 tests/virtio-blk-test.c  | 148 ++++++++++++++++++++---------------------------
 tests/virtio-net-test.c  |  39 +++++--------
 tests/virtio-scsi-test.c |  67 ++++++++++-----------
 4 files changed, 128 insertions(+), 177 deletions(-)

diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c
index 2341622..4d243b4 100644
--- a/tests/virtio-9p-test.c
+++ b/tests/virtio-9p-test.c
@@ -10,62 +10,56 @@
 #include "qemu/osdep.h"
 #include "libqtest.h"
 #include "qemu-common.h"
-#include "libqos/pci-pc.h"
+#include "libqos/libqos-pc.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
-#include "libqos/malloc.h"
-#include "libqos/malloc-pc.h"
 #include "standard-headers/linux/virtio_ids.h"
 #include "standard-headers/linux/virtio_pci.h"
 
 static const char mount_tag[] = "qtest";
 static char *test_share;
 
-static void qvirtio_9p_start(void)
-{
-    char *args;
 
+static QOSState *qvirtio_9p_start(void)
+{
     test_share = g_strdup("/tmp/qtest.XXXXXX");
     g_assert_nonnull(mkdtemp(test_share));
+    const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s "
+                      "-device virtio-9p-pci,fsdev=fsdev0,mount_tag=%s";
 
-    args = g_strdup_printf("-fsdev local,id=fsdev0,security_model=none,path=%s "
-                           "-device virtio-9p-pci,fsdev=fsdev0,mount_tag=%s",
-                           test_share, mount_tag);
-
-    qtest_start(args);
-    g_free(args);
+    return qtest_pc_boot(cmd, test_share, mount_tag);
 }
 
-static void qvirtio_9p_stop(void)
+static void qvirtio_9p_stop(QOSState *qs)
 {
-    qtest_end();
+    qtest_shutdown(qs);
     rmdir(test_share);
     g_free(test_share);
 }
 
 static void pci_nop(void)
 {
-    qvirtio_9p_start();
-    qvirtio_9p_stop();
+    QOSState *qs;
+
+    qs = qvirtio_9p_start();
+    qvirtio_9p_stop(qs);
 }
 
 typedef struct {
     QVirtioDevice *dev;
-    QGuestAllocator *alloc;
-    QPCIBus *bus;
+    QOSState *qs;
     QVirtQueue *vq;
 } QVirtIO9P;
 
-static QVirtIO9P *qvirtio_9p_pci_init(void)
+static QVirtIO9P *qvirtio_9p_pci_init(QOSState *qs)
 {
     QVirtIO9P *v9p;
     QVirtioPCIDevice *dev;
 
     v9p = g_new0(QVirtIO9P, 1);
-    v9p->alloc = pc_alloc_init();
-    v9p->bus = qpci_init_pc(NULL);
 
-    dev = qvirtio_pci_device_find(v9p->bus, VIRTIO_ID_9P);
+    v9p->qs = qs;
+    dev = qvirtio_pci_device_find(v9p->qs->pcibus, VIRTIO_ID_9P);
     g_assert_nonnull(dev);
     g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P);
     v9p->dev = (QVirtioDevice *) dev;
@@ -75,17 +69,15 @@ static QVirtIO9P *qvirtio_9p_pci_init(void)
     qvirtio_set_acknowledge(v9p->dev);
     qvirtio_set_driver(v9p->dev);
 
-    v9p->vq = qvirtqueue_setup(v9p->dev, v9p->alloc, 0);
+    v9p->vq = qvirtqueue_setup(v9p->dev, v9p->qs->alloc, 0);
     return v9p;
 }
 
 static void qvirtio_9p_pci_free(QVirtIO9P *v9p)
 {
-    qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->alloc);
-    pc_alloc_uninit(v9p->alloc);
+    qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc);
     qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
     g_free(v9p->dev);
-    qpci_free_pc(v9p->bus);
     g_free(v9p);
 }
 
@@ -96,9 +88,10 @@ static void pci_basic_config(void)
     size_t tag_len;
     char *tag;
     int i;
+    QOSState *qs;
 
-    qvirtio_9p_start();
-    v9p = qvirtio_9p_pci_init();
+    qs = qvirtio_9p_start();
+    v9p = qvirtio_9p_pci_init(qs);
 
     addr = ((QVirtioPCIDevice *) v9p->dev)->addr + VIRTIO_PCI_CONFIG_OFF(false);
     tag_len = qvirtio_config_readw(v9p->dev,
@@ -114,7 +107,7 @@ static void pci_basic_config(void)
     g_free(tag);
 
     qvirtio_9p_pci_free(v9p);
-    qvirtio_9p_stop();
+    qvirtio_9p_stop(qs);
 }
 
 int main(int argc, char **argv)
diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
index 79e21c5..2382eb5 100644
--- a/tests/virtio-blk-test.c
+++ b/tests/virtio-blk-test.c
@@ -10,12 +10,10 @@
 
 #include "qemu/osdep.h"
 #include "libqtest.h"
+#include "libqos/libqos-pc.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
 #include "libqos/virtio-mmio.h"
-#include "libqos/pci-pc.h"
-#include "libqos/malloc.h"
-#include "libqos/malloc-pc.h"
 #include "libqos/malloc-generic.h"
 #include "qemu/bswap.h"
 #include "standard-headers/linux/virtio_ids.h"
@@ -58,24 +56,21 @@ static char *drive_create(void)
     return tmp_path;
 }
 
-static QPCIBus *pci_test_start(void)
+static QOSState *pci_test_start(void)
 {
-    char *cmdline;
+    QOSState *qs;
     char *tmp_path;
+    const char *cmd = "-drive if=none,id=drive0,file=%s,format=raw "
+                      "-drive if=none,id=drive1,file=/dev/null,format=raw "
+                      "-device virtio-blk-pci,id=drv0,drive=drive0,"
+                      "addr=%x.%x";
 
     tmp_path = drive_create();
 
-    cmdline = g_strdup_printf("-drive if=none,id=drive0,file=%s,format=raw "
-                        "-drive if=none,id=drive1,file=/dev/null,format=raw "
-                        "-device virtio-blk-pci,id=drv0,drive=drive0,"
-                        "addr=%x.%x",
-                        tmp_path, PCI_SLOT, PCI_FN);
-    qtest_start(cmdline);
+    qs = qtest_pc_boot(cmd, tmp_path, PCI_SLOT, PCI_FN);
     unlink(tmp_path);
     g_free(tmp_path);
-    g_free(cmdline);
-
-    return qpci_init_pc(NULL);
+    return qs;
 }
 
 static void arm_test_start(void)
@@ -279,37 +274,32 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
 static void pci_basic(void)
 {
     QVirtioPCIDevice *dev;
-    QPCIBus *bus;
+    QOSState *qs;
     QVirtQueuePCI *vqpci;
-    QGuestAllocator *alloc;
     void *addr;
 
-    bus = pci_test_start();
-    dev = virtio_blk_pci_init(bus, PCI_SLOT);
+    qs = pci_test_start();
+    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
 
-    alloc = pc_alloc_init();
-    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
+    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
 
     /* MSI-X is not enabled */
     addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
 
-    test_basic(&dev->vdev, alloc, &vqpci->vq, (uint64_t)(uintptr_t)addr);
+    test_basic(&dev->vdev, qs->alloc, &vqpci->vq, (uint64_t)(uintptr_t)addr);
 
     /* End test */
-    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
-    pc_alloc_uninit(alloc);
+    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
     qvirtio_pci_device_disable(dev);
     g_free(dev);
-    qpci_free_pc(bus);
-    test_end();
+    qtest_shutdown(qs);
 }
 
 static void pci_indirect(void)
 {
     QVirtioPCIDevice *dev;
-    QPCIBus *bus;
     QVirtQueuePCI *vqpci;
-    QGuestAllocator *alloc;
+    QOSState *qs;
     QVirtioBlkReq req;
     QVRingIndirectDesc *indirect;
     void *addr;
@@ -320,9 +310,9 @@ static void pci_indirect(void)
     uint8_t status;
     char *data;
 
-    bus = pci_test_start();
+    qs = pci_test_start();
 
-    dev = virtio_blk_pci_init(bus, PCI_SLOT);
+    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
 
     /* MSI-X is not enabled */
     addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
@@ -337,8 +327,7 @@ static void pci_indirect(void)
                             (1u << VIRTIO_BLK_F_SCSI));
     qvirtio_set_features(&dev->vdev, features);
 
-    alloc = pc_alloc_init();
-    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
+    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
     qvirtio_set_driver_ok(&dev->vdev);
 
     /* Write request */
@@ -348,11 +337,11 @@ static void pci_indirect(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
+    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
-    indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
+    indirect = qvring_indirect_desc_setup(&dev->vdev, qs->alloc, 2);
     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);
@@ -364,7 +353,7 @@ static void pci_indirect(void)
     g_assert_cmpint(status, ==, 0);
 
     g_free(indirect);
-    guest_free(alloc, req_addr);
+    guest_free(qs->alloc, req_addr);
 
     /* Read request */
     req.type = VIRTIO_BLK_T_IN;
@@ -373,11 +362,11 @@ static void pci_indirect(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
+    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
-    indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
+    indirect = qvring_indirect_desc_setup(&dev->vdev, qs->alloc, 2);
     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);
@@ -394,28 +383,26 @@ static void pci_indirect(void)
     g_free(data);
 
     g_free(indirect);
-    guest_free(alloc, req_addr);
+    guest_free(qs->alloc, req_addr);
 
     /* End test */
-    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
-    pc_alloc_uninit(alloc);
+    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
     qvirtio_pci_device_disable(dev);
     g_free(dev);
-    qpci_free_pc(bus);
-    test_end();
+    qtest_shutdown(qs);
 }
 
 static void pci_config(void)
 {
     QVirtioPCIDevice *dev;
-    QPCIBus *bus;
+    QOSState *qs;
     int n_size = TEST_IMAGE_SIZE / 2;
     void *addr;
     uint64_t capacity;
 
-    bus = pci_test_start();
+    qs = pci_test_start();
 
-    dev = virtio_blk_pci_init(bus, PCI_SLOT);
+    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
 
     /* MSI-X is not enabled */
     addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
@@ -434,16 +421,15 @@ static void pci_config(void)
 
     qvirtio_pci_device_disable(dev);
     g_free(dev);
-    qpci_free_pc(bus);
-    test_end();
+
+    qtest_shutdown(qs);
 }
 
 static void pci_msix(void)
 {
     QVirtioPCIDevice *dev;
-    QPCIBus *bus;
+    QOSState *qs;
     QVirtQueuePCI *vqpci;
-    QGuestAllocator *alloc;
     QVirtioBlkReq req;
     int n_size = TEST_IMAGE_SIZE / 2;
     void *addr;
@@ -454,13 +440,12 @@ static void pci_msix(void)
     uint8_t status;
     char *data;
 
-    bus = pci_test_start();
-    alloc = pc_alloc_init();
+    qs = pci_test_start();
 
-    dev = virtio_blk_pci_init(bus, PCI_SLOT);
+    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
     qpci_msix_enable(dev->pdev);
 
-    qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);
+    qvirtio_pci_set_msix_configuration_vector(dev, qs->alloc, 0);
 
     /* MSI-X is enabled */
     addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(true);
@@ -475,8 +460,8 @@ static void pci_msix(void)
                             (1u << VIRTIO_BLK_F_SCSI));
     qvirtio_set_features(&dev->vdev, features);
 
-    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
-    qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
+    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
+    qvirtqueue_pci_msix_setup(dev, vqpci, qs->alloc, 1);
 
     qvirtio_set_driver_ok(&dev->vdev);
 
@@ -495,7 +480,7 @@ static void pci_msix(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
+    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -510,7 +495,7 @@ static void pci_msix(void)
     status = readb(req_addr + 528);
     g_assert_cmpint(status, ==, 0);
 
-    guest_free(alloc, req_addr);
+    guest_free(qs->alloc, req_addr);
 
     /* Read request */
     req.type = VIRTIO_BLK_T_IN;
@@ -518,7 +503,7 @@ static void pci_msix(void)
     req.sector = 0;
     req.data = g_malloc0(512);
 
-    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
+    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -540,24 +525,21 @@ static void pci_msix(void)
     g_assert_cmpstr(data, ==, "TEST");
     g_free(data);
 
-    guest_free(alloc, req_addr);
+    guest_free(qs->alloc, req_addr);
 
     /* End test */
-    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
-    pc_alloc_uninit(alloc);
+    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
     qpci_msix_disable(dev->pdev);
     qvirtio_pci_device_disable(dev);
     g_free(dev);
-    qpci_free_pc(bus);
-    test_end();
+    qtest_shutdown(qs);
 }
 
 static void pci_idx(void)
 {
     QVirtioPCIDevice *dev;
-    QPCIBus *bus;
+    QOSState *qs;
     QVirtQueuePCI *vqpci;
-    QGuestAllocator *alloc;
     QVirtioBlkReq req;
     void *addr;
     uint64_t req_addr;
@@ -567,13 +549,12 @@ static void pci_idx(void)
     uint8_t status;
     char *data;
 
-    bus = pci_test_start();
-    alloc = pc_alloc_init();
+    qs = pci_test_start();
 
-    dev = virtio_blk_pci_init(bus, PCI_SLOT);
+    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
     qpci_msix_enable(dev->pdev);
 
-    qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);
+    qvirtio_pci_set_msix_configuration_vector(dev, qs->alloc, 0);
 
     /* MSI-X is enabled */
     addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(true);
@@ -588,8 +569,8 @@ static void pci_idx(void)
                             (1u << VIRTIO_BLK_F_SCSI));
     qvirtio_set_features(&dev->vdev, features);
 
-    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
-    qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
+    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
+    qvirtqueue_pci_msix_setup(dev, vqpci, qs->alloc, 1);
 
     qvirtio_set_driver_ok(&dev->vdev);
 
@@ -600,7 +581,7 @@ static void pci_idx(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
+    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -618,7 +599,7 @@ static void pci_idx(void)
     req.data = g_malloc0(512);
     strcpy(req.data, "TEST");
 
-    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
+    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -635,7 +616,7 @@ static void pci_idx(void)
                                              QVIRTIO_BLK_TIMEOUT_US);
     g_assert_cmpint(status, ==, 0);
 
-    guest_free(alloc, req_addr);
+    guest_free(qs->alloc, req_addr);
 
     /* Read request */
     req.type = VIRTIO_BLK_T_IN;
@@ -643,7 +624,7 @@ static void pci_idx(void)
     req.sector = 1;
     req.data = g_malloc0(512);
 
-    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
+    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
 
     g_free(req.data);
 
@@ -664,38 +645,35 @@ static void pci_idx(void)
     g_assert_cmpstr(data, ==, "TEST");
     g_free(data);
 
-    guest_free(alloc, req_addr);
+    guest_free(qs->alloc, req_addr);
 
     /* End test */
-    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
-    pc_alloc_uninit(alloc);
+    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
     qpci_msix_disable(dev->pdev);
     qvirtio_pci_device_disable(dev);
     g_free(dev);
-    qpci_free_pc(bus);
-    test_end();
+    qtest_shutdown(qs);
 }
 
 static void pci_hotplug(void)
 {
-    QPCIBus *bus;
     QVirtioPCIDevice *dev;
+    QOSState *qs;
 
-    bus = pci_test_start();
+    qs = pci_test_start();
 
     /* plug secondary disk */
     qpci_plug_device_test("virtio-blk-pci", "drv1", PCI_SLOT_HP,
                           "'drive': 'drive1'");
 
-    dev = virtio_blk_pci_init(bus, PCI_SLOT_HP);
+    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT_HP);
     g_assert(dev);
     qvirtio_pci_device_disable(dev);
     g_free(dev);
 
     /* unplug secondary disk */
     qpci_unplug_acpi_device_test("drv1", PCI_SLOT_HP);
-    qpci_free_pc(bus);
-    test_end();
+    qtest_shutdown(qs);
 }
 
 static void mmio_basic(void)
@@ -731,8 +709,8 @@ static void mmio_basic(void)
 
     /* End test */
     qvirtqueue_cleanup(dev->vdev.bus, vq, alloc);
-    generic_alloc_uninit(alloc);
     g_free(dev);
+    generic_alloc_uninit(alloc);
     test_end();
 }
 
diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c
index 6fa385e..6bec784 100644
--- a/tests/virtio-net-test.c
+++ b/tests/virtio-net-test.c
@@ -12,12 +12,9 @@
 #include "qemu-common.h"
 #include "qemu/sockets.h"
 #include "qemu/iov.h"
-#include "libqos/pci-pc.h"
+#include "libqos/libqos-pc.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
-#include "libqos/malloc.h"
-#include "libqos/malloc-pc.h"
-#include "libqos/malloc-generic.h"
 #include "qemu/bswap.h"
 #include "hw/virtio/virtio-net.h"
 #include "standard-headers/linux/virtio_ids.h"
@@ -53,16 +50,12 @@ static QVirtioPCIDevice *virtio_net_pci_init(QPCIBus *bus, int slot)
     return dev;
 }
 
-static QPCIBus *pci_test_start(int socket)
+static QOSState *pci_test_start(int socket)
 {
-    char *cmdline;
+    const char *cmd = "-netdev socket,fd=%d,id=hs0 -device "
+                      "virtio-net-pci,netdev=hs0";
 
-    cmdline = g_strdup_printf("-netdev socket,fd=%d,id=hs0 -device "
-                              "virtio-net-pci,netdev=hs0", socket);
-    qtest_start(cmdline);
-    g_free(cmdline);
-
-    return qpci_init_pc(NULL);
+    return qtest_pc_boot(cmd, socket);
 }
 
 static void driver_init(QVirtioDevice *dev)
@@ -205,9 +198,8 @@ static void stop_cont_test(QVirtioDevice *dev,
 static void pci_basic(gconstpointer data)
 {
     QVirtioPCIDevice *dev;
-    QPCIBus *bus;
+    QOSState *qs;
     QVirtQueuePCI *tx, *rx;
-    QGuestAllocator *alloc;
     void (*func) (QVirtioDevice *dev,
                   QGuestAllocator *alloc,
                   QVirtQueue *rvq,
@@ -218,26 +210,23 @@ static void pci_basic(gconstpointer data)
     ret = socketpair(PF_UNIX, SOCK_STREAM, 0, sv);
     g_assert_cmpint(ret, !=, -1);
 
-    bus = pci_test_start(sv[1]);
-    dev = virtio_net_pci_init(bus, PCI_SLOT);
+    qs = pci_test_start(sv[1]);
+    dev = virtio_net_pci_init(qs->pcibus, PCI_SLOT);
 
-    alloc = pc_alloc_init();
-    rx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
-    tx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 1);
+    rx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
+    tx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 1);
 
     driver_init(&dev->vdev);
-    func(&dev->vdev, alloc, &rx->vq, &tx->vq, sv[0]);
+    func(&dev->vdev, qs->alloc, &rx->vq, &tx->vq, sv[0]);
 
     /* End test */
     close(sv[0]);
-    qvirtqueue_cleanup(dev->vdev.bus, &tx->vq, alloc);
-    qvirtqueue_cleanup(dev->vdev.bus, &rx->vq, alloc);
-    pc_alloc_uninit(alloc);
+    qvirtqueue_cleanup(dev->vdev.bus, &tx->vq, qs->alloc);
+    qvirtqueue_cleanup(dev->vdev.bus, &rx->vq, qs->alloc);
     qvirtio_pci_device_disable(dev);
     g_free(dev->pdev);
     g_free(dev);
-    qpci_free_pc(bus);
-    test_end();
+    qtest_shutdown(qs);
 }
 #endif
 
diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
index 3dbec2f..7d697ab 100644
--- a/tests/virtio-scsi-test.c
+++ b/tests/virtio-scsi-test.c
@@ -11,12 +11,9 @@
 #include "qemu/osdep.h"
 #include "libqtest.h"
 #include "block/scsi.h"
+#include "libqos/libqos-pc.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
-#include "libqos/pci-pc.h"
-#include "libqos/malloc.h"
-#include "libqos/malloc-pc.h"
-#include "libqos/malloc-generic.h"
 #include "standard-headers/linux/virtio_ids.h"
 #include "standard-headers/linux/virtio_pci.h"
 #include "standard-headers/linux/virtio_scsi.h"
@@ -29,28 +26,23 @@
 
 typedef struct {
     QVirtioDevice *dev;
-    QGuestAllocator *alloc;
-    QPCIBus *bus;
+    QOSState *qs;
     int num_queues;
     QVirtQueue *vq[MAX_NUM_QUEUES + 2];
 } QVirtIOSCSI;
 
-static void qvirtio_scsi_start(const char *extra_opts)
+static QOSState *qvirtio_scsi_start(const char *extra_opts)
 {
-    char *cmdline;
-
-    cmdline = g_strdup_printf(
-                "-drive id=drv0,if=none,file=/dev/null,format=raw "
-                "-device virtio-scsi-pci,id=vs0 "
-                "-device scsi-hd,bus=vs0.0,drive=drv0 %s",
-                extra_opts ? : "");
-    qtest_start(cmdline);
-    g_free(cmdline);
+    const char *cmd = "-drive id=drv0,if=none,file=/dev/null,format=raw "
+                      "-device virtio-scsi-pci,id=vs0 "
+                      "-device scsi-hd,bus=vs0.0,drive=drv0 %s";
+
+    return qtest_pc_boot(cmd, extra_opts ? : "");
 }
 
-static void qvirtio_scsi_stop(void)
+static void qvirtio_scsi_stop(QOSState *qs)
 {
-    qtest_end();
+    qtest_shutdown(qs);
 }
 
 static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs)
@@ -58,12 +50,11 @@ static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs)
     int i;
 
     for (i = 0; i < vs->num_queues + 2; i++) {
-        qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->alloc);
+        qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->qs->alloc);
     }
-    pc_alloc_uninit(vs->alloc);
     qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev));
     g_free(vs->dev);
-    qpci_free_pc(vs->bus);
+    qvirtio_scsi_stop(vs->qs);
     g_free(vs);
 }
 
@@ -72,7 +63,7 @@ static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size,
 {
     uint64_t addr;
 
-    addr = guest_alloc(vs->alloc, alloc_size);
+    addr = guest_alloc(vs->qs->alloc, alloc_size);
     if (data) {
         memwrite(addr, data, alloc_size);
     }
@@ -129,10 +120,10 @@ static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb,
         memread(resp_addr, resp_out, sizeof(*resp_out));
     }
 
-    guest_free(vs->alloc, req_addr);
-    guest_free(vs->alloc, resp_addr);
-    guest_free(vs->alloc, data_in_addr);
-    guest_free(vs->alloc, data_out_addr);
+    guest_free(vs->qs->alloc, req_addr);
+    guest_free(vs->qs->alloc, resp_addr);
+    guest_free(vs->qs->alloc, data_in_addr);
+    guest_free(vs->qs->alloc, data_out_addr);
     return response;
 }
 
@@ -146,10 +137,11 @@ static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot)
     int i;
 
     vs = g_new0(QVirtIOSCSI, 1);
-    vs->alloc = pc_alloc_init();
-    vs->bus = qpci_init_pc(NULL);
 
-    dev = qvirtio_pci_device_find(vs->bus, VIRTIO_ID_SCSI);
+    vs->qs = qvirtio_scsi_start("-drive file=blkdebug::null-co://,"
+                                "if=none,id=dr1,format=raw,file.align=4k "
+                                "-device scsi-disk,drive=dr1,lun=0,scsi-id=1");
+    dev = qvirtio_pci_device_find(vs->qs->pcibus, VIRTIO_ID_SCSI);
     vs->dev = (QVirtioDevice *)dev;
     g_assert(dev != NULL);
     g_assert_cmphex(vs->dev->device_type, ==, VIRTIO_ID_SCSI);
@@ -165,7 +157,7 @@ static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot)
     g_assert_cmpint(vs->num_queues, <, MAX_NUM_QUEUES);
 
     for (i = 0; i < vs->num_queues + 2; i++) {
-        vs->vq[i] = qvirtqueue_setup(vs->dev, vs->alloc, i);
+        vs->vq[i] = qvirtqueue_setup(vs->dev, vs->qs->alloc, i);
     }
 
     /* Clear the POWER ON OCCURRED unit attention */
@@ -184,15 +176,18 @@ static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot)
 /* Tests only initialization so far. TODO: Replace with functional tests */
 static void pci_nop(void)
 {
-    qvirtio_scsi_start(NULL);
-    qvirtio_scsi_stop();
+    QOSState *qs;
+
+    qs = qvirtio_scsi_start(NULL);
+    qvirtio_scsi_stop(qs);
 }
 
 static void hotplug(void)
 {
     QDict *response;
+    QOSState *qs;
 
-    qvirtio_scsi_start("-drive id=drv1,if=none,file=/dev/null,format=raw");
+    qs = qvirtio_scsi_start("-drive id=drv1,if=none,file=/dev/null,format=raw");
     response = qmp("{\"execute\": \"device_add\","
                    " \"arguments\": {"
                    "   \"driver\": \"scsi-hd\","
@@ -214,7 +209,7 @@ static void hotplug(void)
     g_assert(qdict_haskey(response, "event"));
     g_assert(!strcmp(qdict_get_str(response, "event"), "DEVICE_DELETED"));
     QDECREF(response);
-    qvirtio_scsi_stop();
+    qvirtio_scsi_stop(qs);
 }
 
 /* Test WRITE SAME with the lba not aligned */
@@ -230,9 +225,6 @@ static void test_unaligned_write_same(void)
         0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x33, 0x00, 0x00
     };
 
-    qvirtio_scsi_start("-drive file=blkdebug::null-co://,if=none,id=dr1"
-                       ",format=raw,file.align=4k "
-                       "-device scsi-disk,drive=dr1,lun=0,scsi-id=1");
     vs = qvirtio_scsi_pci_init(PCI_SLOT);
 
     g_assert_cmphex(0, ==,
@@ -242,7 +234,6 @@ static void test_unaligned_write_same(void)
         virtio_scsi_do_command(vs, write_same_cdb_2, NULL, 0, buf2, 512, NULL));
 
     qvirtio_scsi_pci_free(vs);
-    qvirtio_scsi_stop();
 }
 
 int main(int argc, char **argv)
-- 
2.7.4

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* Re: [Qemu-devel] [PATCH v4 5/6] tests: use qtest_pc_boot()/qtest_shutdown() in virtio tests
  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
  0 siblings, 0 replies; 12+ messages in thread
From: Greg Kurz @ 2016-10-14 21:20 UTC (permalink / raw)
  To: Laurent Vivier; +Cc: qemu-devel, dgibson, thuth, qemu-ppc

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

> This patch replaces calls to qtest_start() and qtest_end() by
> calls to qtest_pc_boot() and qtest_shutdown().
> 
> This allows to initialize memory allocator and PCI interface
> functions. This will ease to enable virtio tests on other
> architectures by only adding a specific qtest_XXX_boot() (like
> qtest_spapr_boot()).
> 
> Signed-off-by: Laurent Vivier <lvivier@redhat.com>
> Reviewed-by: Greg Kurz <groug@kaod.org>
> ---

Heh this still has the...

>  tests/virtio-9p-test.c   |  51 +++++++---------
>  tests/virtio-blk-test.c  | 148 ++++++++++++++++++++---------------------------
>  tests/virtio-net-test.c  |  39 +++++--------
>  tests/virtio-scsi-test.c |  67 ++++++++++-----------
>  4 files changed, 128 insertions(+), 177 deletions(-)
> 
> diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c
> index 2341622..4d243b4 100644
> --- a/tests/virtio-9p-test.c
> +++ b/tests/virtio-9p-test.c
> @@ -10,62 +10,56 @@
>  #include "qemu/osdep.h"
>  #include "libqtest.h"
>  #include "qemu-common.h"
> -#include "libqos/pci-pc.h"
> +#include "libqos/libqos-pc.h"
>  #include "libqos/virtio.h"
>  #include "libqos/virtio-pci.h"
> -#include "libqos/malloc.h"
> -#include "libqos/malloc-pc.h"
>  #include "standard-headers/linux/virtio_ids.h"
>  #include "standard-headers/linux/virtio_pci.h"
>  
>  static const char mount_tag[] = "qtest";
>  static char *test_share;
>  
> -static void qvirtio_9p_start(void)
> -{
> -    char *args;
>  
> +static QOSState *qvirtio_9p_start(void)
> +{
>      test_share = g_strdup("/tmp/qtest.XXXXXX");
>      g_assert_nonnull(mkdtemp(test_share));
> +    const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s "
> +                      "-device virtio-9p-pci,fsdev=fsdev0,mount_tag=%s";
>  

... declaration within the code, but it can be fixed in a followup patch and
does not necessarily call for a v5. My R-b stands.

> -    args = g_strdup_printf("-fsdev local,id=fsdev0,security_model=none,path=%s "
> -                           "-device virtio-9p-pci,fsdev=fsdev0,mount_tag=%s",
> -                           test_share, mount_tag);
> -
> -    qtest_start(args);
> -    g_free(args);
> +    return qtest_pc_boot(cmd, test_share, mount_tag);
>  }
>  
> -static void qvirtio_9p_stop(void)
> +static void qvirtio_9p_stop(QOSState *qs)
>  {
> -    qtest_end();
> +    qtest_shutdown(qs);
>      rmdir(test_share);
>      g_free(test_share);
>  }
>  
>  static void pci_nop(void)
>  {
> -    qvirtio_9p_start();
> -    qvirtio_9p_stop();
> +    QOSState *qs;
> +
> +    qs = qvirtio_9p_start();
> +    qvirtio_9p_stop(qs);
>  }
>  
>  typedef struct {
>      QVirtioDevice *dev;
> -    QGuestAllocator *alloc;
> -    QPCIBus *bus;
> +    QOSState *qs;
>      QVirtQueue *vq;
>  } QVirtIO9P;
>  
> -static QVirtIO9P *qvirtio_9p_pci_init(void)
> +static QVirtIO9P *qvirtio_9p_pci_init(QOSState *qs)
>  {
>      QVirtIO9P *v9p;
>      QVirtioPCIDevice *dev;
>  
>      v9p = g_new0(QVirtIO9P, 1);
> -    v9p->alloc = pc_alloc_init();
> -    v9p->bus = qpci_init_pc(NULL);
>  
> -    dev = qvirtio_pci_device_find(v9p->bus, VIRTIO_ID_9P);
> +    v9p->qs = qs;
> +    dev = qvirtio_pci_device_find(v9p->qs->pcibus, VIRTIO_ID_9P);
>      g_assert_nonnull(dev);
>      g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P);
>      v9p->dev = (QVirtioDevice *) dev;
> @@ -75,17 +69,15 @@ static QVirtIO9P *qvirtio_9p_pci_init(void)
>      qvirtio_set_acknowledge(v9p->dev);
>      qvirtio_set_driver(v9p->dev);
>  
> -    v9p->vq = qvirtqueue_setup(v9p->dev, v9p->alloc, 0);
> +    v9p->vq = qvirtqueue_setup(v9p->dev, v9p->qs->alloc, 0);
>      return v9p;
>  }
>  
>  static void qvirtio_9p_pci_free(QVirtIO9P *v9p)
>  {
> -    qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->alloc);
> -    pc_alloc_uninit(v9p->alloc);
> +    qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc);
>      qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
>      g_free(v9p->dev);
> -    qpci_free_pc(v9p->bus);
>      g_free(v9p);
>  }
>  
> @@ -96,9 +88,10 @@ static void pci_basic_config(void)
>      size_t tag_len;
>      char *tag;
>      int i;
> +    QOSState *qs;
>  
> -    qvirtio_9p_start();
> -    v9p = qvirtio_9p_pci_init();
> +    qs = qvirtio_9p_start();
> +    v9p = qvirtio_9p_pci_init(qs);
>  
>      addr = ((QVirtioPCIDevice *) v9p->dev)->addr + VIRTIO_PCI_CONFIG_OFF(false);
>      tag_len = qvirtio_config_readw(v9p->dev,
> @@ -114,7 +107,7 @@ static void pci_basic_config(void)
>      g_free(tag);
>  
>      qvirtio_9p_pci_free(v9p);
> -    qvirtio_9p_stop();
> +    qvirtio_9p_stop(qs);
>  }
>  
>  int main(int argc, char **argv)
> diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
> index 79e21c5..2382eb5 100644
> --- a/tests/virtio-blk-test.c
> +++ b/tests/virtio-blk-test.c
> @@ -10,12 +10,10 @@
>  
>  #include "qemu/osdep.h"
>  #include "libqtest.h"
> +#include "libqos/libqos-pc.h"
>  #include "libqos/virtio.h"
>  #include "libqos/virtio-pci.h"
>  #include "libqos/virtio-mmio.h"
> -#include "libqos/pci-pc.h"
> -#include "libqos/malloc.h"
> -#include "libqos/malloc-pc.h"
>  #include "libqos/malloc-generic.h"
>  #include "qemu/bswap.h"
>  #include "standard-headers/linux/virtio_ids.h"
> @@ -58,24 +56,21 @@ static char *drive_create(void)
>      return tmp_path;
>  }
>  
> -static QPCIBus *pci_test_start(void)
> +static QOSState *pci_test_start(void)
>  {
> -    char *cmdline;
> +    QOSState *qs;
>      char *tmp_path;
> +    const char *cmd = "-drive if=none,id=drive0,file=%s,format=raw "
> +                      "-drive if=none,id=drive1,file=/dev/null,format=raw "
> +                      "-device virtio-blk-pci,id=drv0,drive=drive0,"
> +                      "addr=%x.%x";
>  
>      tmp_path = drive_create();
>  
> -    cmdline = g_strdup_printf("-drive if=none,id=drive0,file=%s,format=raw "
> -                        "-drive if=none,id=drive1,file=/dev/null,format=raw "
> -                        "-device virtio-blk-pci,id=drv0,drive=drive0,"
> -                        "addr=%x.%x",
> -                        tmp_path, PCI_SLOT, PCI_FN);
> -    qtest_start(cmdline);
> +    qs = qtest_pc_boot(cmd, tmp_path, PCI_SLOT, PCI_FN);
>      unlink(tmp_path);
>      g_free(tmp_path);
> -    g_free(cmdline);
> -
> -    return qpci_init_pc(NULL);
> +    return qs;
>  }
>  
>  static void arm_test_start(void)
> @@ -279,37 +274,32 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
>  static void pci_basic(void)
>  {
>      QVirtioPCIDevice *dev;
> -    QPCIBus *bus;
> +    QOSState *qs;
>      QVirtQueuePCI *vqpci;
> -    QGuestAllocator *alloc;
>      void *addr;
>  
> -    bus = pci_test_start();
> -    dev = virtio_blk_pci_init(bus, PCI_SLOT);
> +    qs = pci_test_start();
> +    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
>  
> -    alloc = pc_alloc_init();
> -    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> +    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
>  
>      /* MSI-X is not enabled */
>      addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
>  
> -    test_basic(&dev->vdev, alloc, &vqpci->vq, (uint64_t)(uintptr_t)addr);
> +    test_basic(&dev->vdev, qs->alloc, &vqpci->vq, (uint64_t)(uintptr_t)addr);
>  
>      /* End test */
> -    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> -    pc_alloc_uninit(alloc);
> +    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
>      qvirtio_pci_device_disable(dev);
>      g_free(dev);
> -    qpci_free_pc(bus);
> -    test_end();
> +    qtest_shutdown(qs);
>  }
>  
>  static void pci_indirect(void)
>  {
>      QVirtioPCIDevice *dev;
> -    QPCIBus *bus;
>      QVirtQueuePCI *vqpci;
> -    QGuestAllocator *alloc;
> +    QOSState *qs;
>      QVirtioBlkReq req;
>      QVRingIndirectDesc *indirect;
>      void *addr;
> @@ -320,9 +310,9 @@ static void pci_indirect(void)
>      uint8_t status;
>      char *data;
>  
> -    bus = pci_test_start();
> +    qs = pci_test_start();
>  
> -    dev = virtio_blk_pci_init(bus, PCI_SLOT);
> +    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
>  
>      /* MSI-X is not enabled */
>      addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
> @@ -337,8 +327,7 @@ static void pci_indirect(void)
>                              (1u << VIRTIO_BLK_F_SCSI));
>      qvirtio_set_features(&dev->vdev, features);
>  
> -    alloc = pc_alloc_init();
> -    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> +    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
>      qvirtio_set_driver_ok(&dev->vdev);
>  
>      /* Write request */
> @@ -348,11 +337,11 @@ static void pci_indirect(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
> +    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> -    indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
> +    indirect = qvring_indirect_desc_setup(&dev->vdev, qs->alloc, 2);
>      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);
> @@ -364,7 +353,7 @@ static void pci_indirect(void)
>      g_assert_cmpint(status, ==, 0);
>  
>      g_free(indirect);
> -    guest_free(alloc, req_addr);
> +    guest_free(qs->alloc, req_addr);
>  
>      /* Read request */
>      req.type = VIRTIO_BLK_T_IN;
> @@ -373,11 +362,11 @@ static void pci_indirect(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
> +    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> -    indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
> +    indirect = qvring_indirect_desc_setup(&dev->vdev, qs->alloc, 2);
>      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);
> @@ -394,28 +383,26 @@ static void pci_indirect(void)
>      g_free(data);
>  
>      g_free(indirect);
> -    guest_free(alloc, req_addr);
> +    guest_free(qs->alloc, req_addr);
>  
>      /* End test */
> -    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> -    pc_alloc_uninit(alloc);
> +    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
>      qvirtio_pci_device_disable(dev);
>      g_free(dev);
> -    qpci_free_pc(bus);
> -    test_end();
> +    qtest_shutdown(qs);
>  }
>  
>  static void pci_config(void)
>  {
>      QVirtioPCIDevice *dev;
> -    QPCIBus *bus;
> +    QOSState *qs;
>      int n_size = TEST_IMAGE_SIZE / 2;
>      void *addr;
>      uint64_t capacity;
>  
> -    bus = pci_test_start();
> +    qs = pci_test_start();
>  
> -    dev = virtio_blk_pci_init(bus, PCI_SLOT);
> +    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
>  
>      /* MSI-X is not enabled */
>      addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false);
> @@ -434,16 +421,15 @@ static void pci_config(void)
>  
>      qvirtio_pci_device_disable(dev);
>      g_free(dev);
> -    qpci_free_pc(bus);
> -    test_end();
> +
> +    qtest_shutdown(qs);
>  }
>  
>  static void pci_msix(void)
>  {
>      QVirtioPCIDevice *dev;
> -    QPCIBus *bus;
> +    QOSState *qs;
>      QVirtQueuePCI *vqpci;
> -    QGuestAllocator *alloc;
>      QVirtioBlkReq req;
>      int n_size = TEST_IMAGE_SIZE / 2;
>      void *addr;
> @@ -454,13 +440,12 @@ static void pci_msix(void)
>      uint8_t status;
>      char *data;
>  
> -    bus = pci_test_start();
> -    alloc = pc_alloc_init();
> +    qs = pci_test_start();
>  
> -    dev = virtio_blk_pci_init(bus, PCI_SLOT);
> +    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
>      qpci_msix_enable(dev->pdev);
>  
> -    qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);
> +    qvirtio_pci_set_msix_configuration_vector(dev, qs->alloc, 0);
>  
>      /* MSI-X is enabled */
>      addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(true);
> @@ -475,8 +460,8 @@ static void pci_msix(void)
>                              (1u << VIRTIO_BLK_F_SCSI));
>      qvirtio_set_features(&dev->vdev, features);
>  
> -    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> -    qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
> +    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
> +    qvirtqueue_pci_msix_setup(dev, vqpci, qs->alloc, 1);
>  
>      qvirtio_set_driver_ok(&dev->vdev);
>  
> @@ -495,7 +480,7 @@ static void pci_msix(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
> +    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -510,7 +495,7 @@ static void pci_msix(void)
>      status = readb(req_addr + 528);
>      g_assert_cmpint(status, ==, 0);
>  
> -    guest_free(alloc, req_addr);
> +    guest_free(qs->alloc, req_addr);
>  
>      /* Read request */
>      req.type = VIRTIO_BLK_T_IN;
> @@ -518,7 +503,7 @@ static void pci_msix(void)
>      req.sector = 0;
>      req.data = g_malloc0(512);
>  
> -    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
> +    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -540,24 +525,21 @@ static void pci_msix(void)
>      g_assert_cmpstr(data, ==, "TEST");
>      g_free(data);
>  
> -    guest_free(alloc, req_addr);
> +    guest_free(qs->alloc, req_addr);
>  
>      /* End test */
> -    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> -    pc_alloc_uninit(alloc);
> +    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
>      qpci_msix_disable(dev->pdev);
>      qvirtio_pci_device_disable(dev);
>      g_free(dev);
> -    qpci_free_pc(bus);
> -    test_end();
> +    qtest_shutdown(qs);
>  }
>  
>  static void pci_idx(void)
>  {
>      QVirtioPCIDevice *dev;
> -    QPCIBus *bus;
> +    QOSState *qs;
>      QVirtQueuePCI *vqpci;
> -    QGuestAllocator *alloc;
>      QVirtioBlkReq req;
>      void *addr;
>      uint64_t req_addr;
> @@ -567,13 +549,12 @@ static void pci_idx(void)
>      uint8_t status;
>      char *data;
>  
> -    bus = pci_test_start();
> -    alloc = pc_alloc_init();
> +    qs = pci_test_start();
>  
> -    dev = virtio_blk_pci_init(bus, PCI_SLOT);
> +    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT);
>      qpci_msix_enable(dev->pdev);
>  
> -    qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);
> +    qvirtio_pci_set_msix_configuration_vector(dev, qs->alloc, 0);
>  
>      /* MSI-X is enabled */
>      addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(true);
> @@ -588,8 +569,8 @@ static void pci_idx(void)
>                              (1u << VIRTIO_BLK_F_SCSI));
>      qvirtio_set_features(&dev->vdev, features);
>  
> -    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> -    qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
> +    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
> +    qvirtqueue_pci_msix_setup(dev, vqpci, qs->alloc, 1);
>  
>      qvirtio_set_driver_ok(&dev->vdev);
>  
> @@ -600,7 +581,7 @@ static void pci_idx(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
> +    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -618,7 +599,7 @@ static void pci_idx(void)
>      req.data = g_malloc0(512);
>      strcpy(req.data, "TEST");
>  
> -    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
> +    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -635,7 +616,7 @@ static void pci_idx(void)
>                                               QVIRTIO_BLK_TIMEOUT_US);
>      g_assert_cmpint(status, ==, 0);
>  
> -    guest_free(alloc, req_addr);
> +    guest_free(qs->alloc, req_addr);
>  
>      /* Read request */
>      req.type = VIRTIO_BLK_T_IN;
> @@ -643,7 +624,7 @@ static void pci_idx(void)
>      req.sector = 1;
>      req.data = g_malloc0(512);
>  
> -    req_addr = virtio_blk_request(alloc, &dev->vdev, &req, 512);
> +    req_addr = virtio_blk_request(qs->alloc, &dev->vdev, &req, 512);
>  
>      g_free(req.data);
>  
> @@ -664,38 +645,35 @@ static void pci_idx(void)
>      g_assert_cmpstr(data, ==, "TEST");
>      g_free(data);
>  
> -    guest_free(alloc, req_addr);
> +    guest_free(qs->alloc, req_addr);
>  
>      /* End test */
> -    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, alloc);
> -    pc_alloc_uninit(alloc);
> +    qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
>      qpci_msix_disable(dev->pdev);
>      qvirtio_pci_device_disable(dev);
>      g_free(dev);
> -    qpci_free_pc(bus);
> -    test_end();
> +    qtest_shutdown(qs);
>  }
>  
>  static void pci_hotplug(void)
>  {
> -    QPCIBus *bus;
>      QVirtioPCIDevice *dev;
> +    QOSState *qs;
>  
> -    bus = pci_test_start();
> +    qs = pci_test_start();
>  
>      /* plug secondary disk */
>      qpci_plug_device_test("virtio-blk-pci", "drv1", PCI_SLOT_HP,
>                            "'drive': 'drive1'");
>  
> -    dev = virtio_blk_pci_init(bus, PCI_SLOT_HP);
> +    dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT_HP);
>      g_assert(dev);
>      qvirtio_pci_device_disable(dev);
>      g_free(dev);
>  
>      /* unplug secondary disk */
>      qpci_unplug_acpi_device_test("drv1", PCI_SLOT_HP);
> -    qpci_free_pc(bus);
> -    test_end();
> +    qtest_shutdown(qs);
>  }
>  
>  static void mmio_basic(void)
> @@ -731,8 +709,8 @@ static void mmio_basic(void)
>  
>      /* End test */
>      qvirtqueue_cleanup(dev->vdev.bus, vq, alloc);
> -    generic_alloc_uninit(alloc);
>      g_free(dev);
> +    generic_alloc_uninit(alloc);
>      test_end();
>  }
>  
> diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c
> index 6fa385e..6bec784 100644
> --- a/tests/virtio-net-test.c
> +++ b/tests/virtio-net-test.c
> @@ -12,12 +12,9 @@
>  #include "qemu-common.h"
>  #include "qemu/sockets.h"
>  #include "qemu/iov.h"
> -#include "libqos/pci-pc.h"
> +#include "libqos/libqos-pc.h"
>  #include "libqos/virtio.h"
>  #include "libqos/virtio-pci.h"
> -#include "libqos/malloc.h"
> -#include "libqos/malloc-pc.h"
> -#include "libqos/malloc-generic.h"
>  #include "qemu/bswap.h"
>  #include "hw/virtio/virtio-net.h"
>  #include "standard-headers/linux/virtio_ids.h"
> @@ -53,16 +50,12 @@ static QVirtioPCIDevice *virtio_net_pci_init(QPCIBus *bus, int slot)
>      return dev;
>  }
>  
> -static QPCIBus *pci_test_start(int socket)
> +static QOSState *pci_test_start(int socket)
>  {
> -    char *cmdline;
> +    const char *cmd = "-netdev socket,fd=%d,id=hs0 -device "
> +                      "virtio-net-pci,netdev=hs0";
>  
> -    cmdline = g_strdup_printf("-netdev socket,fd=%d,id=hs0 -device "
> -                              "virtio-net-pci,netdev=hs0", socket);
> -    qtest_start(cmdline);
> -    g_free(cmdline);
> -
> -    return qpci_init_pc(NULL);
> +    return qtest_pc_boot(cmd, socket);
>  }
>  
>  static void driver_init(QVirtioDevice *dev)
> @@ -205,9 +198,8 @@ static void stop_cont_test(QVirtioDevice *dev,
>  static void pci_basic(gconstpointer data)
>  {
>      QVirtioPCIDevice *dev;
> -    QPCIBus *bus;
> +    QOSState *qs;
>      QVirtQueuePCI *tx, *rx;
> -    QGuestAllocator *alloc;
>      void (*func) (QVirtioDevice *dev,
>                    QGuestAllocator *alloc,
>                    QVirtQueue *rvq,
> @@ -218,26 +210,23 @@ static void pci_basic(gconstpointer data)
>      ret = socketpair(PF_UNIX, SOCK_STREAM, 0, sv);
>      g_assert_cmpint(ret, !=, -1);
>  
> -    bus = pci_test_start(sv[1]);
> -    dev = virtio_net_pci_init(bus, PCI_SLOT);
> +    qs = pci_test_start(sv[1]);
> +    dev = virtio_net_pci_init(qs->pcibus, PCI_SLOT);
>  
> -    alloc = pc_alloc_init();
> -    rx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 0);
> -    tx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, 1);
> +    rx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 0);
> +    tx = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, qs->alloc, 1);
>  
>      driver_init(&dev->vdev);
> -    func(&dev->vdev, alloc, &rx->vq, &tx->vq, sv[0]);
> +    func(&dev->vdev, qs->alloc, &rx->vq, &tx->vq, sv[0]);
>  
>      /* End test */
>      close(sv[0]);
> -    qvirtqueue_cleanup(dev->vdev.bus, &tx->vq, alloc);
> -    qvirtqueue_cleanup(dev->vdev.bus, &rx->vq, alloc);
> -    pc_alloc_uninit(alloc);
> +    qvirtqueue_cleanup(dev->vdev.bus, &tx->vq, qs->alloc);
> +    qvirtqueue_cleanup(dev->vdev.bus, &rx->vq, qs->alloc);
>      qvirtio_pci_device_disable(dev);
>      g_free(dev->pdev);
>      g_free(dev);
> -    qpci_free_pc(bus);
> -    test_end();
> +    qtest_shutdown(qs);
>  }
>  #endif
>  
> diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
> index 3dbec2f..7d697ab 100644
> --- a/tests/virtio-scsi-test.c
> +++ b/tests/virtio-scsi-test.c
> @@ -11,12 +11,9 @@
>  #include "qemu/osdep.h"
>  #include "libqtest.h"
>  #include "block/scsi.h"
> +#include "libqos/libqos-pc.h"
>  #include "libqos/virtio.h"
>  #include "libqos/virtio-pci.h"
> -#include "libqos/pci-pc.h"
> -#include "libqos/malloc.h"
> -#include "libqos/malloc-pc.h"
> -#include "libqos/malloc-generic.h"
>  #include "standard-headers/linux/virtio_ids.h"
>  #include "standard-headers/linux/virtio_pci.h"
>  #include "standard-headers/linux/virtio_scsi.h"
> @@ -29,28 +26,23 @@
>  
>  typedef struct {
>      QVirtioDevice *dev;
> -    QGuestAllocator *alloc;
> -    QPCIBus *bus;
> +    QOSState *qs;
>      int num_queues;
>      QVirtQueue *vq[MAX_NUM_QUEUES + 2];
>  } QVirtIOSCSI;
>  
> -static void qvirtio_scsi_start(const char *extra_opts)
> +static QOSState *qvirtio_scsi_start(const char *extra_opts)
>  {
> -    char *cmdline;
> -
> -    cmdline = g_strdup_printf(
> -                "-drive id=drv0,if=none,file=/dev/null,format=raw "
> -                "-device virtio-scsi-pci,id=vs0 "
> -                "-device scsi-hd,bus=vs0.0,drive=drv0 %s",
> -                extra_opts ? : "");
> -    qtest_start(cmdline);
> -    g_free(cmdline);
> +    const char *cmd = "-drive id=drv0,if=none,file=/dev/null,format=raw "
> +                      "-device virtio-scsi-pci,id=vs0 "
> +                      "-device scsi-hd,bus=vs0.0,drive=drv0 %s";
> +
> +    return qtest_pc_boot(cmd, extra_opts ? : "");
>  }
>  
> -static void qvirtio_scsi_stop(void)
> +static void qvirtio_scsi_stop(QOSState *qs)
>  {
> -    qtest_end();
> +    qtest_shutdown(qs);
>  }
>  
>  static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs)
> @@ -58,12 +50,11 @@ static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs)
>      int i;
>  
>      for (i = 0; i < vs->num_queues + 2; i++) {
> -        qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->alloc);
> +        qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->qs->alloc);
>      }
> -    pc_alloc_uninit(vs->alloc);
>      qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev));
>      g_free(vs->dev);
> -    qpci_free_pc(vs->bus);
> +    qvirtio_scsi_stop(vs->qs);
>      g_free(vs);
>  }
>  
> @@ -72,7 +63,7 @@ static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size,
>  {
>      uint64_t addr;
>  
> -    addr = guest_alloc(vs->alloc, alloc_size);
> +    addr = guest_alloc(vs->qs->alloc, alloc_size);
>      if (data) {
>          memwrite(addr, data, alloc_size);
>      }
> @@ -129,10 +120,10 @@ static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb,
>          memread(resp_addr, resp_out, sizeof(*resp_out));
>      }
>  
> -    guest_free(vs->alloc, req_addr);
> -    guest_free(vs->alloc, resp_addr);
> -    guest_free(vs->alloc, data_in_addr);
> -    guest_free(vs->alloc, data_out_addr);
> +    guest_free(vs->qs->alloc, req_addr);
> +    guest_free(vs->qs->alloc, resp_addr);
> +    guest_free(vs->qs->alloc, data_in_addr);
> +    guest_free(vs->qs->alloc, data_out_addr);
>      return response;
>  }
>  
> @@ -146,10 +137,11 @@ static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot)
>      int i;
>  
>      vs = g_new0(QVirtIOSCSI, 1);
> -    vs->alloc = pc_alloc_init();
> -    vs->bus = qpci_init_pc(NULL);
>  
> -    dev = qvirtio_pci_device_find(vs->bus, VIRTIO_ID_SCSI);
> +    vs->qs = qvirtio_scsi_start("-drive file=blkdebug::null-co://,"
> +                                "if=none,id=dr1,format=raw,file.align=4k "
> +                                "-device scsi-disk,drive=dr1,lun=0,scsi-id=1");
> +    dev = qvirtio_pci_device_find(vs->qs->pcibus, VIRTIO_ID_SCSI);
>      vs->dev = (QVirtioDevice *)dev;
>      g_assert(dev != NULL);
>      g_assert_cmphex(vs->dev->device_type, ==, VIRTIO_ID_SCSI);
> @@ -165,7 +157,7 @@ static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot)
>      g_assert_cmpint(vs->num_queues, <, MAX_NUM_QUEUES);
>  
>      for (i = 0; i < vs->num_queues + 2; i++) {
> -        vs->vq[i] = qvirtqueue_setup(vs->dev, vs->alloc, i);
> +        vs->vq[i] = qvirtqueue_setup(vs->dev, vs->qs->alloc, i);
>      }
>  
>      /* Clear the POWER ON OCCURRED unit attention */
> @@ -184,15 +176,18 @@ static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot)
>  /* Tests only initialization so far. TODO: Replace with functional tests */
>  static void pci_nop(void)
>  {
> -    qvirtio_scsi_start(NULL);
> -    qvirtio_scsi_stop();
> +    QOSState *qs;
> +
> +    qs = qvirtio_scsi_start(NULL);
> +    qvirtio_scsi_stop(qs);
>  }
>  
>  static void hotplug(void)
>  {
>      QDict *response;
> +    QOSState *qs;
>  
> -    qvirtio_scsi_start("-drive id=drv1,if=none,file=/dev/null,format=raw");
> +    qs = qvirtio_scsi_start("-drive id=drv1,if=none,file=/dev/null,format=raw");
>      response = qmp("{\"execute\": \"device_add\","
>                     " \"arguments\": {"
>                     "   \"driver\": \"scsi-hd\","
> @@ -214,7 +209,7 @@ static void hotplug(void)
>      g_assert(qdict_haskey(response, "event"));
>      g_assert(!strcmp(qdict_get_str(response, "event"), "DEVICE_DELETED"));
>      QDECREF(response);
> -    qvirtio_scsi_stop();
> +    qvirtio_scsi_stop(qs);
>  }
>  
>  /* Test WRITE SAME with the lba not aligned */
> @@ -230,9 +225,6 @@ static void test_unaligned_write_same(void)
>          0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x33, 0x00, 0x00
>      };
>  
> -    qvirtio_scsi_start("-drive file=blkdebug::null-co://,if=none,id=dr1"
> -                       ",format=raw,file.align=4k "
> -                       "-device scsi-disk,drive=dr1,lun=0,scsi-id=1");
>      vs = qvirtio_scsi_pci_init(PCI_SLOT);
>  
>      g_assert_cmphex(0, ==,
> @@ -242,7 +234,6 @@ static void test_unaligned_write_same(void)
>          virtio_scsi_do_command(vs, write_same_cdb_2, NULL, 0, buf2, 512, NULL));
>  
>      qvirtio_scsi_pci_free(vs);
> -    qvirtio_scsi_stop();
>  }
>  
>  int main(int argc, char **argv)

^ permalink raw reply	[flat|nested] 12+ messages in thread

* [Qemu-devel] [PATCH v4 6/6] tests: enable virtio tests on SPAPR
  2016-10-14  8:58 [Qemu-devel] [PATCH v4 0/6] tests: enable virtio tests on SPAPR Laurent Vivier
                   ` (4 preceding siblings ...)
  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  8:58 ` Laurent Vivier
  5 siblings, 0 replies; 12+ messages in thread
From: Laurent Vivier @ 2016-10-14  8:58 UTC (permalink / raw)
  To: qemu-devel; +Cc: dgibson, thuth, qemu-ppc, Greg Kurz, Laurent Vivier

but disable MSI-X tests on SPAPR as we can't check the result
(the memory region used on PC is not readable on SPAPR).

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
---
 tests/Makefile.include    |  3 ++-
 tests/libqos/virtio-pci.c | 24 ++++++++++++++++++++++--
 tests/virtio-9p-test.c    | 12 +++++++++++-
 tests/virtio-blk-test.c   | 25 ++++++++++++++++++++-----
 tests/virtio-net-test.c   | 18 ++++++++++++++++--
 tests/virtio-rng-test.c   |  7 ++++++-
 tests/virtio-scsi-test.c  | 12 +++++++++++-
 7 files changed, 88 insertions(+), 13 deletions(-)

diff --git a/tests/Makefile.include b/tests/Makefile.include
index a77777c..4480b08 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -278,6 +278,7 @@ check-qtest-ppc64-y += tests/usb-hcd-uhci-test$(EXESUF)
 gcov-files-ppc64-y += hw/usb/hcd-uhci.c
 check-qtest-ppc64-y += tests/usb-hcd-xhci-test$(EXESUF)
 gcov-files-ppc64-y += hw/usb/hcd-xhci.c
+check-qtest-ppc64-y += $(check-qtest-virtio-y)
 
 check-qtest-sh4-y = tests/endianness-test$(EXESUF)
 
@@ -604,7 +605,7 @@ libqos-pc-obj-y += tests/libqos/ahci.o
 libqos-omap-obj-y = $(libqos-obj-y) tests/libqos/i2c-omap.o
 libqos-imx-obj-y = $(libqos-obj-y) tests/libqos/i2c-imx.o
 libqos-usb-obj-y = $(libqos-spapr-obj-y) $(libqos-pc-obj-y) tests/libqos/usb.o
-libqos-virtio-obj-y = $(libqos-pc-obj-y) tests/libqos/virtio.o tests/libqos/virtio-pci.o tests/libqos/virtio-mmio.o tests/libqos/malloc-generic.o
+libqos-virtio-obj-y = $(libqos-spapr-obj-y) $(libqos-pc-obj-y) tests/libqos/virtio.o tests/libqos/virtio-pci.o tests/libqos/virtio-mmio.o tests/libqos/malloc-generic.o
 
 tests/device-introspect-test$(EXESUF): tests/device-introspect-test.o
 tests/rtc-test$(EXESUF): tests/rtc-test.o
diff --git a/tests/libqos/virtio-pci.c b/tests/libqos/virtio-pci.c
index 7aa29b1..7e60b3a 100644
--- a/tests/libqos/virtio-pci.c
+++ b/tests/libqos/virtio-pci.c
@@ -68,16 +68,36 @@ static uint8_t qvirtio_pci_config_readb(QVirtioDevice *d, uint64_t addr)
     return qpci_io_readb(dev->pdev, (void *)(uintptr_t)addr);
 }
 
+/* PCI is always read in little-endian order
+ * but virtio ( < 1.0) is in guest order
+ * so with a big-endian guest the order has been reversed,
+ * reverse it again
+ * virtio-1.0 is always little-endian, like PCI, but this
+ * case will be managed inside qvirtio_is_big_endian()
+ */
+
 static uint16_t qvirtio_pci_config_readw(QVirtioDevice *d, uint64_t addr)
 {
     QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
-    return qpci_io_readw(dev->pdev, (void *)(uintptr_t)addr);
+    uint16_t value;
+
+    value = qpci_io_readw(dev->pdev, (void *)(uintptr_t)addr);
+    if (qvirtio_is_big_endian(d)) {
+        value = bswap16(value);
+    }
+    return value;
 }
 
 static uint32_t qvirtio_pci_config_readl(QVirtioDevice *d, uint64_t addr)
 {
     QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
-    return qpci_io_readl(dev->pdev, (void *)(uintptr_t)addr);
+    uint32_t value;
+
+    value = qpci_io_readl(dev->pdev, (void *)(uintptr_t)addr);
+    if (qvirtio_is_big_endian(d)) {
+        value = bswap32(value);
+    }
+    return value;
 }
 
 static uint64_t qvirtio_pci_config_readq(QVirtioDevice *d, uint64_t addr)
diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c
index 4d243b4..c690ebf 100644
--- a/tests/virtio-9p-test.c
+++ b/tests/virtio-9p-test.c
@@ -11,6 +11,7 @@
 #include "libqtest.h"
 #include "qemu-common.h"
 #include "libqos/libqos-pc.h"
+#include "libqos/libqos-spapr.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
 #include "standard-headers/linux/virtio_ids.h"
@@ -22,12 +23,21 @@ static char *test_share;
 
 static QOSState *qvirtio_9p_start(void)
 {
+    const char *arch = qtest_get_arch();
     test_share = g_strdup("/tmp/qtest.XXXXXX");
     g_assert_nonnull(mkdtemp(test_share));
     const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s "
                       "-device virtio-9p-pci,fsdev=fsdev0,mount_tag=%s";
 
-    return qtest_pc_boot(cmd, test_share, mount_tag);
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+        return qtest_pc_boot(cmd, test_share, mount_tag);
+    }
+    if (strcmp(arch, "ppc64") == 0) {
+        return qtest_spapr_boot(cmd, test_share, mount_tag);
+    }
+
+    g_printerr("virtio-9p tests are only available on x86 or ppc64\n");
+    exit(EXIT_FAILURE);
 }
 
 static void qvirtio_9p_stop(QOSState *qs)
diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
index 2382eb5..f737c40 100644
--- a/tests/virtio-blk-test.c
+++ b/tests/virtio-blk-test.c
@@ -11,6 +11,7 @@
 #include "qemu/osdep.h"
 #include "libqtest.h"
 #include "libqos/libqos-pc.h"
+#include "libqos/libqos-spapr.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
 #include "libqos/virtio-mmio.h"
@@ -59,6 +60,7 @@ static char *drive_create(void)
 static QOSState *pci_test_start(void)
 {
     QOSState *qs;
+    const char *arch = qtest_get_arch();
     char *tmp_path;
     const char *cmd = "-drive if=none,id=drive0,file=%s,format=raw "
                       "-drive if=none,id=drive1,file=/dev/null,format=raw "
@@ -67,7 +69,14 @@ static QOSState *pci_test_start(void)
 
     tmp_path = drive_create();
 
-    qs = qtest_pc_boot(cmd, tmp_path, PCI_SLOT, PCI_FN);
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+        qs = qtest_pc_boot(cmd, tmp_path, PCI_SLOT, PCI_FN);
+    } else if (strcmp(arch, "ppc64") == 0) {
+        qs = qtest_spapr_boot(cmd, tmp_path, PCI_SLOT, PCI_FN);
+    } else {
+        g_printerr("virtio-blk tests are only available on x86 or ppc64\n");
+        exit(EXIT_FAILURE);
+    }
     unlink(tmp_path);
     g_free(tmp_path);
     return qs;
@@ -659,6 +668,7 @@ static void pci_hotplug(void)
 {
     QVirtioPCIDevice *dev;
     QOSState *qs;
+    const char *arch = qtest_get_arch();
 
     qs = pci_test_start();
 
@@ -672,7 +682,9 @@ static void pci_hotplug(void)
     g_free(dev);
 
     /* unplug secondary disk */
-    qpci_unplug_acpi_device_test("drv1", PCI_SLOT_HP);
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+        qpci_unplug_acpi_device_test("drv1", PCI_SLOT_HP);
+    }
     qtest_shutdown(qs);
 }
 
@@ -720,12 +732,15 @@ int main(int argc, char **argv)
 
     g_test_init(&argc, &argv, NULL);
 
-    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0 ||
+        strcmp(arch, "ppc64") == 0) {
         qtest_add_func("/virtio/blk/pci/basic", pci_basic);
         qtest_add_func("/virtio/blk/pci/indirect", pci_indirect);
         qtest_add_func("/virtio/blk/pci/config", pci_config);
-        qtest_add_func("/virtio/blk/pci/msix", pci_msix);
-        qtest_add_func("/virtio/blk/pci/idx", pci_idx);
+        if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+            qtest_add_func("/virtio/blk/pci/msix", pci_msix);
+            qtest_add_func("/virtio/blk/pci/idx", pci_idx);
+        }
         qtest_add_func("/virtio/blk/pci/hotplug", pci_hotplug);
     } else if (strcmp(arch, "arm") == 0) {
         qtest_add_func("/virtio/blk/mmio/basic", mmio_basic);
diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c
index 6bec784..8f94360 100644
--- a/tests/virtio-net-test.c
+++ b/tests/virtio-net-test.c
@@ -13,6 +13,7 @@
 #include "qemu/sockets.h"
 #include "qemu/iov.h"
 #include "libqos/libqos-pc.h"
+#include "libqos/libqos-spapr.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
 #include "qemu/bswap.h"
@@ -52,10 +53,18 @@ static QVirtioPCIDevice *virtio_net_pci_init(QPCIBus *bus, int slot)
 
 static QOSState *pci_test_start(int socket)
 {
+    const char *arch = qtest_get_arch();
     const char *cmd = "-netdev socket,fd=%d,id=hs0 -device "
                       "virtio-net-pci,netdev=hs0";
 
-    return qtest_pc_boot(cmd, socket);
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+        return qtest_pc_boot(cmd, socket);
+    }
+    if (strcmp(arch, "ppc64") == 0) {
+        return qtest_spapr_boot(cmd, socket);
+    }
+    g_printerr("virtio-net tests are only available on x86 or ppc64\n");
+    exit(EXIT_FAILURE);
 }
 
 static void driver_init(QVirtioDevice *dev)
@@ -232,10 +241,15 @@ static void pci_basic(gconstpointer data)
 
 static void hotplug(void)
 {
+    const char *arch = qtest_get_arch();
+
     qtest_start("-device virtio-net-pci");
 
     qpci_plug_device_test("virtio-net-pci", "net1", PCI_SLOT_HP, NULL);
-    qpci_unplug_acpi_device_test("net1", PCI_SLOT_HP);
+
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+        qpci_unplug_acpi_device_test("net1", PCI_SLOT_HP);
+    }
 
     test_end();
 }
diff --git a/tests/virtio-rng-test.c b/tests/virtio-rng-test.c
index e1b2640..dcecf77 100644
--- a/tests/virtio-rng-test.c
+++ b/tests/virtio-rng-test.c
@@ -20,8 +20,13 @@ static void pci_nop(void)
 
 static void hotplug(void)
 {
+    const char *arch = qtest_get_arch();
+
     qpci_plug_device_test("virtio-rng-pci", "rng1", PCI_SLOT_HP, NULL);
-    qpci_unplug_acpi_device_test("rng1", PCI_SLOT_HP);
+
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+        qpci_unplug_acpi_device_test("rng1", PCI_SLOT_HP);
+    }
 }
 
 int main(int argc, char **argv)
diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
index 7d697ab..60dc9ab 100644
--- a/tests/virtio-scsi-test.c
+++ b/tests/virtio-scsi-test.c
@@ -12,6 +12,7 @@
 #include "libqtest.h"
 #include "block/scsi.h"
 #include "libqos/libqos-pc.h"
+#include "libqos/libqos-spapr.h"
 #include "libqos/virtio.h"
 #include "libqos/virtio-pci.h"
 #include "standard-headers/linux/virtio_ids.h"
@@ -33,11 +34,20 @@ typedef struct {
 
 static QOSState *qvirtio_scsi_start(const char *extra_opts)
 {
+    const char *arch = qtest_get_arch();
     const char *cmd = "-drive id=drv0,if=none,file=/dev/null,format=raw "
                       "-device virtio-scsi-pci,id=vs0 "
                       "-device scsi-hd,bus=vs0.0,drive=drv0 %s";
 
-    return qtest_pc_boot(cmd, extra_opts ? : "");
+    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
+        return qtest_pc_boot(cmd, extra_opts ? : "");
+    }
+    if (strcmp(arch, "ppc64") == 0) {
+        return qtest_spapr_boot(cmd, extra_opts ? : "");
+    }
+
+    g_printerr("virtio-scsi tests are only available on x86 or ppc64\n");
+    exit(EXIT_FAILURE);
 }
 
 static void qvirtio_scsi_stop(QOSState *qs)
-- 
2.7.4

^ permalink raw reply related	[flat|nested] 12+ messages in thread

end of thread, other threads:[~2016-10-14 22:20 UTC | newest]

Thread overview: 12+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
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
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

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.