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

qemu-devel.nongnu.org archive mirror
 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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).