ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- Fix for ctrl queue in the virtio-net QOS driver 

- Improve Valgrind reports in the tests that use the null-co driver
 - Get rid of global_qtest related code in libqtest and libqos
 -----BEGIN PGP SIGNATURE-----
 
 iQJFBAABCAAvFiEEJ7iIR+7gJQEY8+q5LtnXdP5wLbUFAl1VljARHHRodXRoQHJl
 ZGhhdC5jb20ACgkQLtnXdP5wLbVikQ//cyjJAx7yCgRCa5+7ytY55mcgYHNKGdWU
 uJIQiVkclZAQwBj9ESWBCR85Wn9ynz86XEh6hRcjw++KH8G8XrZRDGKSSMyTNYmi
 b7lfO4EiYHuQhja+eSvtpd/we6K9ofKCAyvNE53bBSV+zTljfLstpd2sxn8f+JTd
 7By0/DIl7NgMYEy2TO72AbcRrexsLgqk0BEhsgbB0hZ/MdshPze9J58YrHjcMCgo
 8rGnKnlCKFceypDvhg3OmcQt6GbHdutQlRYYN+AolS70NrzrF5RvlpMKIdcZmtdZ
 Fc2URFTF6Ll1QNahPHiZBwOsMjs7371q9ErtUuv1s+fSUZxeGQDg4r0O9lNFy04I
 oC+0JWp8ILDgIpk4TROdYyfN+JuAkU27pY2YFr4mgJ60uhwX6AefQKL7KpzZ0IJs
 AXwNw675XqLeaSx/I9tdaFxkonYr5NYpwOE+iHvFpw7GIwOUyLs+vfi5YnLPtWi+
 BgDvR3zeCL3Knu8VdeKceZY1DcSeJzAcofc4Se/S0y//nNM2KHEOl9zyMtDbX8Bs
 7Jn2ZsBmhkGuoOw5B52xxIDEyxHASqJuSVP6yM5G3iy2qOT4w0AJnr6Kodhm552X
 VjTLo5D/+hI8bFRREbzLBFP+02UFsYoVuqb+9u+cuVKCHPi1ZodyTV6uEvmO5v5a
 O8o3h5qSJSw=
 =4w5x
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2019-08-15' into staging

- Fix for ctrl queue in the virtio-net QOS driver
- Improve Valgrind reports in the tests that use the null-co driver
- Get rid of global_qtest related code in libqtest and libqos

# gpg: Signature made Thu 15 Aug 2019 18:28:16 BST
# gpg:                using RSA key 27B88847EEE0250118F3EAB92ED9D774FE702DB5
# gpg:                issuer "thuth@redhat.com"
# gpg: Good signature from "Thomas Huth <th.huth@gmx.de>" [full]
# gpg:                 aka "Thomas Huth <thuth@redhat.com>" [full]
# gpg:                 aka "Thomas Huth <huth@tuxfamily.org>" [full]
# gpg:                 aka "Thomas Huth <th.huth@posteo.de>" [unknown]
# Primary key fingerprint: 27B8 8847 EEE0 2501 18F3  EAB9 2ED9 D774 FE70 2DB5

* remotes/huth-gitlab/tags/pull-request-2019-08-15:
  tests/libqtest: Make qmp_assert_success() independent from global_qtest
  tests/libqtest: Make qtest_qmp_device_add/del independent from global_qtest
  tests/libqtest: Clean up qtest_cb_for_every_machine() wrt global_qtest
  tests/libqtest: Remove unused function hmp()
  tests/libqos: Make virtio-pci code independent from global_qtest
  tests/libqos: Make generic virtio code independent from global_qtest
  tests: Set read-zeroes on for null-co driver
  libqos: Account for the ctrl queue in virtio-net
  qtest: Rename qtest.c:qtest_init()

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2019-08-16 13:58:41 +01:00
parent 27608c7c66 6fc9f3d347
commit 1f3a51f3fe
32 changed files with 299 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/sysemu/qtest.h
View File

@ -24,6 +24,6 @@ static inline bool qtest_enabled(void)
bool qtest_driver(void); bool qtest_driver(void);
void qtest_init(const char *qtest_chrdev, const char *qtest_log, Error **errp); void qtest_server_init(const char *qtest_chrdev, const char *qtest_log, Error **errp);
#endif #endif

3
qtest.c
View File

@ -748,8 +748,7 @@ static void qtest_event(void *opaque, int event)
break; break;
} }
} }
void qtest_server_init(const char *qtest_chrdev, const char *qtest_log, Error **errp)
void qtest_init(const char *qtest_chrdev, const char *qtest_log, Error **errp)
{ {
Chardev *chr; Chardev *chr;

15
tests/cpu-plug-test.c
View File

@ -77,18 +77,19 @@ static void test_plug_with_device_add_x86(gconstpointer data)
const PlugTestData *td = data; const PlugTestData *td = data;
char *args; char *args;
unsigned int s, c, t; unsigned int s, c, t;
QTestState *qts;
args = g_strdup_printf("-machine %s -cpu %s " args = g_strdup_printf("-machine %s -cpu %s "
"-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u", "-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
td->machine, td->cpu_model, td->machine, td->cpu_model,
td->sockets, td->cores, td->threads, td->maxcpus); td->sockets, td->cores, td->threads, td->maxcpus);
qtest_start(args); qts = qtest_init(args);
for (s = 1; s < td->sockets; s++) { for (s = 1; s < td->sockets; s++) {
for (c = 0; c < td->cores; c++) { for (c = 0; c < td->cores; c++) {
for (t = 0; t < td->threads; t++) { for (t = 0; t < td->threads; t++) {
char *id = g_strdup_printf("id-%i-%i-%i", s, c, t); char *id = g_strdup_printf("id-%i-%i-%i", s, c, t);
qtest_qmp_device_add(td->device_model, id, qtest_qmp_device_add(qts, td->device_model, id,
"{'socket-id':%u, 'core-id':%u," "{'socket-id':%u, 'core-id':%u,"
" 'thread-id':%u}", " 'thread-id':%u}",
s, c, t); s, c, t);
@ -97,7 +98,7 @@ static void test_plug_with_device_add_x86(gconstpointer data)
} }
} }
qtest_end(); qtest_quit(qts);
g_free(args); g_free(args);
} }
@ -106,20 +107,22 @@ static void test_plug_with_device_add_coreid(gconstpointer data)
const PlugTestData *td = data; const PlugTestData *td = data;
char *args; char *args;
unsigned int c; unsigned int c;
QTestState *qts;
args = g_strdup_printf("-machine %s -cpu %s " args = g_strdup_printf("-machine %s -cpu %s "
"-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u", "-smp 1,sockets=%u,cores=%u,threads=%u,maxcpus=%u",
td->machine, td->cpu_model, td->machine, td->cpu_model,
td->sockets, td->cores, td->threads, td->maxcpus); td->sockets, td->cores, td->threads, td->maxcpus);
qtest_start(args); qts = qtest_init(args);
for (c = 1; c < td->cores; c++) { for (c = 1; c < td->cores; c++) {
char *id = g_strdup_printf("id-%i", c); char *id = g_strdup_printf("id-%i", c);
qtest_qmp_device_add(td->device_model, id, "{'core-id':%u}", c); qtest_qmp_device_add(qts, td->device_model, id,
"{'core-id':%u}", c);
g_free(id); g_free(id);
} }
qtest_end(); qtest_quit(qts);
g_free(args); g_free(args);
} }

3
tests/drive_del-test.c
View File

@ -121,7 +121,8 @@ static void test_drive_del_device_del(void)
QTestState *qts; QTestState *qts;
/* Start with a drive used by a device that unplugs instantaneously */ /* Start with a drive used by a device that unplugs instantaneously */
qts = qtest_initf("-drive if=none,id=drive0,file=null-co://,format=raw" qts = qtest_initf("-drive if=none,id=drive0,file=null-co://,"
"file.read-zeroes=on,format=raw"
" -device virtio-scsi-%s" " -device virtio-scsi-%s"
" -device scsi-hd,drive=drive0,id=dev0", " -device scsi-hd,drive=drive0,id=dev0",
qvirtio_get_dev_type()); qvirtio_get_dev_type());

2
tests/e1000e-test.c
View File

@ -235,7 +235,7 @@ static void test_e1000e_hotplug(void *obj, void *data, QGuestAllocator * alloc)
{ {
QTestState *qts = global_qtest; /* TODO: get rid of global_qtest here */ QTestState *qts = global_qtest; /* TODO: get rid of global_qtest here */
qtest_qmp_device_add("e1000e", "e1000e_net", "{'addr': '0x06'}"); qtest_qmp_device_add(qts, "e1000e", "e1000e_net", "{'addr': '0x06'}");
qpci_unplug_acpi_device_test(qts, "e1000e_net", 0x06); qpci_unplug_acpi_device_test(qts, "e1000e_net", 0x06);
} }

2
tests/ivshmem-test.c
View File

@ -389,7 +389,7 @@ static void test_ivshmem_hotplug(void)
qts = qtest_init("-object memory-backend-ram,size=1M,id=mb1"); qts = qtest_init("-object memory-backend-ram,size=1M,id=mb1");
global_qtest = qts; /* TODO: Get rid of global_qtest here */ global_qtest = qts; /* TODO: Get rid of global_qtest here */
qtest_qmp_device_add("ivshmem-plain", "iv1", qtest_qmp_device_add(qts, "ivshmem-plain", "iv1",
"{'addr': %s, 'memdev': 'mb1'}", "{'addr': %s, 'memdev': 'mb1'}",
stringify(PCI_SLOT_HP)); stringify(PCI_SLOT_HP));
if (strcmp(arch, "ppc64") != 0) { if (strcmp(arch, "ppc64") != 0) {

6
tests/libqos/usb.c
View File

@ -37,20 +37,20 @@ void uhci_port_test(struct qhc *hc, int port, uint16_t expect)
g_assert((value & mask) == (expect & mask)); g_assert((value & mask) == (expect & mask));
} }
void usb_test_hotplug(const char *hcd_id, const char *port, void usb_test_hotplug(QTestState *qts, const char *hcd_id, const char *port,
void (*port_check)(void)) void (*port_check)(void))
{ {
char *id = g_strdup_printf("usbdev%s", port); char *id = g_strdup_printf("usbdev%s", port);
char *bus = g_strdup_printf("%s.0", hcd_id); char *bus = g_strdup_printf("%s.0", hcd_id);
qtest_qmp_device_add("usb-tablet", id, "{'port': %s, 'bus': %s}", qtest_qmp_device_add(qts, "usb-tablet", id, "{'port': %s, 'bus': %s}",
port, bus); port, bus);
if (port_check) { if (port_check) {
port_check(); port_check();
} }
qtest_qmp_device_del(id); qtest_qmp_device_del(qts, id);
g_free(bus); g_free(bus);
g_free(id); g_free(id);

2
tests/libqos/usb.h
View File

@ -13,6 +13,6 @@ void qusb_pci_init_one(QPCIBus *pcibus, struct qhc *hc,
void uhci_port_test(struct qhc *hc, int port, uint16_t expect); void uhci_port_test(struct qhc *hc, int port, uint16_t expect);
void uhci_deinit(struct qhc *hc); void uhci_deinit(struct qhc *hc);
void usb_test_hotplug(const char *bus_name, const char *port, void usb_test_hotplug(QTestState *qts, const char *bus_name, const char *port,
void (*port_check)(void)); void (*port_check)(void));
#endif #endif

1
tests/libqos/virtio-net.c
View File

@ -53,6 +53,7 @@ static void virtio_net_setup(QVirtioNet *interface)
} else { } else {
interface->n_queues = 2; interface->n_queues = 2;
} }
interface->n_queues++; /* Account for the ctrl queue */
interface->queues = g_new(QVirtQueue *, interface->n_queues); interface->queues = g_new(QVirtQueue *, interface->n_queues);
for (i = 0; i < interface->n_queues; i++) { for (i = 0; i < interface->n_queues; i++) {

2
tests/libqos/virtio-net.h
View File

@ -29,7 +29,7 @@ typedef struct QVirtioNetDevice QVirtioNetDevice;
struct QVirtioNet { struct QVirtioNet {
QVirtioDevice *vdev; QVirtioDevice *vdev;
int n_queues; int n_queues; /* total number of virtqueues (rx, tx, ctrl) */
QVirtQueue **queues; QVirtQueue **queues;
}; };

8
tests/libqos/virtio-pci.c
View File

@ -138,9 +138,9 @@ static bool qvirtio_pci_get_queue_isr_status(QVirtioDevice *d, QVirtQueue *vq)
/* No ISR checking should be done if masked, but read anyway */ /* No ISR checking should be done if masked, but read anyway */
return qpci_msix_pending(dev->pdev, vqpci->msix_entry); return qpci_msix_pending(dev->pdev, vqpci->msix_entry);
} else { } else {
data = readl(vqpci->msix_addr); data = qtest_readl(dev->pdev->bus->qts, vqpci->msix_addr);
if (data == vqpci->msix_data) { if (data == vqpci->msix_data) {
writel(vqpci->msix_addr, 0); qtest_writel(dev->pdev->bus->qts, vqpci->msix_addr, 0);
return true; return true;
} else { } else {
return false; return false;
@ -162,9 +162,9 @@ static bool qvirtio_pci_get_config_isr_status(QVirtioDevice *d)
/* No ISR checking should be done if masked, but read anyway */ /* No ISR checking should be done if masked, but read anyway */
return qpci_msix_pending(dev->pdev, dev->config_msix_entry); return qpci_msix_pending(dev->pdev, dev->config_msix_entry);
} else { } else {
data = readl(dev->config_msix_addr); data = qtest_readl(dev->pdev->bus->qts, dev->config_msix_addr);
if (data == dev->config_msix_data) { if (data == dev->config_msix_data) {
writel(dev->config_msix_addr, 0); qtest_writel(dev->pdev->bus->qts, dev->config_msix_addr, 0);
return true; return true;
} else { } else {
return false; return false;

3
tests/libqos/virtio-scsi.c
View File

@ -95,7 +95,8 @@ static void virtio_scsi_register_nodes(void)
}; };
QOSGraphEdgeOptions opts = { QOSGraphEdgeOptions opts = {
.before_cmd_line = "-drive id=drv0,if=none,file=null-co://,format=raw", .before_cmd_line = "-drive id=drv0,if=none,file=null-co://,"
"file.read-zeroes=on,format=raw",
.after_cmd_line = "-device scsi-hd,bus=vs0.0,drive=drv0", .after_cmd_line = "-device scsi-hd,bus=vs0.0,drive=drv0",
}; };

81
tests/libqos/virtio.c
View File

@ -101,7 +101,7 @@ void qvirtio_wait_queue_isr(QVirtioDevice *d,
* The virtqueue interrupt must not be raised, making this useful for testing * The virtqueue interrupt must not be raised, making this useful for testing
* event_index functionality. * event_index functionality.
*/ */
uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d, uint8_t qvirtio_wait_status_byte_no_isr(QTestState *qts, QVirtioDevice *d,
QVirtQueue *vq, QVirtQueue *vq,
uint64_t addr, uint64_t addr,
gint64 timeout_us) gint64 timeout_us)
@ -126,7 +126,7 @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d,
* *
* This function waits for the next completed request on the used ring. * This function waits for the next completed request on the used ring.
*/ */
void qvirtio_wait_used_elem(QVirtioDevice *d, void qvirtio_wait_used_elem(QTestState *qts, QVirtioDevice *d,
QVirtQueue *vq, QVirtQueue *vq,
uint32_t desc_idx, uint32_t desc_idx,
uint32_t *len, uint32_t *len,
@ -140,7 +140,7 @@ void qvirtio_wait_used_elem(QVirtioDevice *d,
clock_step(100); clock_step(100);
if (d->bus->get_queue_isr_status(d, vq) && if (d->bus->get_queue_isr_status(d, vq) &&
qvirtqueue_get_buf(vq, &got_desc_idx, len)) { qvirtqueue_get_buf(qts, vq, &got_desc_idx, len)) {
g_assert_cmpint(got_desc_idx, ==, desc_idx); g_assert_cmpint(got_desc_idx, ==, desc_idx);
return; return;
} }
@ -193,8 +193,9 @@ void qvring_init(QTestState *qts, const QGuestAllocator *alloc, QVirtQueue *vq,
0); 0);
} }
QVRingIndirectDesc *qvring_indirect_desc_setup(QVirtioDevice *d, QVRingIndirectDesc *qvring_indirect_desc_setup(QTestState *qs, QVirtioDevice *d,
QGuestAllocator *alloc, uint16_t elem) QGuestAllocator *alloc,
uint16_t elem)
{ {
int i; int i;
QVRingIndirectDesc *indirect = g_malloc(sizeof(*indirect)); QVRingIndirectDesc *indirect = g_malloc(sizeof(*indirect));
@ -205,41 +206,41 @@ QVRingIndirectDesc *qvring_indirect_desc_setup(QVirtioDevice *d,
for (i = 0; i < elem - 1; ++i) { for (i = 0; i < elem - 1; ++i) {
/* indirect->desc[i].addr */ /* indirect->desc[i].addr */
writeq(indirect->desc + (16 * i), 0); qtest_writeq(qs, indirect->desc + (16 * i), 0);
/* indirect->desc[i].flags */ /* indirect->desc[i].flags */
writew(indirect->desc + (16 * i) + 12, VRING_DESC_F_NEXT); qtest_writew(qs, indirect->desc + (16 * i) + 12, VRING_DESC_F_NEXT);
/* indirect->desc[i].next */ /* indirect->desc[i].next */
writew(indirect->desc + (16 * i) + 14, i + 1); qtest_writew(qs, indirect->desc + (16 * i) + 14, i + 1);
} }
return indirect; return indirect;
} }
void qvring_indirect_desc_add(QVRingIndirectDesc *indirect, uint64_t data, void qvring_indirect_desc_add(QTestState *qts, QVRingIndirectDesc *indirect,
uint32_t len, bool write) uint64_t data, uint32_t len, bool write)
{ {
uint16_t flags; uint16_t flags;
g_assert_cmpint(indirect->index, <, indirect->elem); g_assert_cmpint(indirect->index, <, indirect->elem);
flags = readw(indirect->desc + (16 * indirect->index) + 12); flags = qtest_readw(qts, indirect->desc + (16 * indirect->index) + 12);
if (write) { if (write) {
flags |= VRING_DESC_F_WRITE; flags |= VRING_DESC_F_WRITE;
} }
/* indirect->desc[indirect->index].addr */ /* indirect->desc[indirect->index].addr */
writeq(indirect->desc + (16 * indirect->index), data); qtest_writeq(qts, indirect->desc + (16 * indirect->index), data);
/* indirect->desc[indirect->index].len */ /* indirect->desc[indirect->index].len */
writel(indirect->desc + (16 * indirect->index) + 8, len); qtest_writel(qts, indirect->desc + (16 * indirect->index) + 8, len);
/* indirect->desc[indirect->index].flags */ /* indirect->desc[indirect->index].flags */
writew(indirect->desc + (16 * indirect->index) + 12, flags); qtest_writew(qts, indirect->desc + (16 * indirect->index) + 12, flags);
indirect->index++; indirect->index++;
} }
uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write, uint32_t qvirtqueue_add(QTestState *qts, QVirtQueue *vq, uint64_t data,
bool next) uint32_t len, bool write, bool next)
{ {
uint16_t flags = 0; uint16_t flags = 0;
vq->num_free--; vq->num_free--;
@ -253,16 +254,17 @@ uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write,
} }
/* vq->desc[vq->free_head].addr */ /* vq->desc[vq->free_head].addr */
writeq(vq->desc + (16 * vq->free_head), data); qtest_writeq(qts, vq->desc + (16 * vq->free_head), data);
/* vq->desc[vq->free_head].len */ /* vq->desc[vq->free_head].len */
writel(vq->desc + (16 * vq->free_head) + 8, len); qtest_writel(qts, vq->desc + (16 * vq->free_head) + 8, len);
/* vq->desc[vq->free_head].flags */ /* vq->desc[vq->free_head].flags */
writew(vq->desc + (16 * vq->free_head) + 12, flags); qtest_writew(qts, vq->desc + (16 * vq->free_head) + 12, flags);
return vq->free_head++; /* Return and increase, in this order */ return vq->free_head++; /* Return and increase, in this order */
} }
uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect) uint32_t qvirtqueue_add_indirect(QTestState *qts, QVirtQueue *vq,
QVRingIndirectDesc *indirect)
{ {
g_assert(vq->indirect); g_assert(vq->indirect);
g_assert_cmpint(vq->size, >=, indirect->elem); g_assert_cmpint(vq->size, >=, indirect->elem);
@ -271,34 +273,36 @@ uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect)
vq->num_free--; vq->num_free--;
/* vq->desc[vq->free_head].addr */ /* vq->desc[vq->free_head].addr */
writeq(vq->desc + (16 * vq->free_head), indirect->desc); qtest_writeq(qts, vq->desc + (16 * vq->free_head), indirect->desc);
/* vq->desc[vq->free_head].len */ /* vq->desc[vq->free_head].len */
writel(vq->desc + (16 * vq->free_head) + 8, qtest_writel(qts, vq->desc + (16 * vq->free_head) + 8,
sizeof(struct vring_desc) * indirect->elem); sizeof(struct vring_desc) * indirect->elem);
/* vq->desc[vq->free_head].flags */ /* vq->desc[vq->free_head].flags */
writew(vq->desc + (16 * vq->free_head) + 12, VRING_DESC_F_INDIRECT); qtest_writew(qts, vq->desc + (16 * vq->free_head) + 12,
VRING_DESC_F_INDIRECT);
return vq->free_head++; /* Return and increase, in this order */ return vq->free_head++; /* Return and increase, in this order */
} }
void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head) void qvirtqueue_kick(QTestState *qts, QVirtioDevice *d, QVirtQueue *vq,
uint32_t free_head)
{ {
/* vq->avail->idx */ /* vq->avail->idx */
uint16_t idx = readw(vq->avail + 2); uint16_t idx = qtest_readw(qts, vq->avail + 2);
/* vq->used->flags */ /* vq->used->flags */
uint16_t flags; uint16_t flags;
/* vq->used->avail_event */ /* vq->used->avail_event */
uint16_t avail_event; uint16_t avail_event;
/* vq->avail->ring[idx % vq->size] */ /* vq->avail->ring[idx % vq->size] */
writew(vq->avail + 4 + (2 * (idx % vq->size)), free_head); qtest_writew(qts, vq->avail + 4 + (2 * (idx % vq->size)), free_head);
/* vq->avail->idx */ /* vq->avail->idx */
writew(vq->avail + 2, idx + 1); qtest_writew(qts, vq->avail + 2, idx + 1);
/* Must read after idx is updated */ /* Must read after idx is updated */
flags = readw(vq->avail); flags = qtest_readw(qts, vq->avail);
avail_event = readw(vq->used + 4 + avail_event = qtest_readw(qts, vq->used + 4 +
sizeof(struct vring_used_elem) * vq->size); sizeof(struct vring_used_elem) * vq->size);
/* < 1 because we add elements to avail queue one by one */ /* < 1 because we add elements to avail queue one by one */
if ((flags & VRING_USED_F_NO_NOTIFY) == 0 && if ((flags & VRING_USED_F_NO_NOTIFY) == 0 &&
@ -317,12 +321,13 @@ void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head)
* *
* Returns: true if an element was ready, false otherwise * Returns: true if an element was ready, false otherwise
*/ */
bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx, uint32_t *len) bool qvirtqueue_get_buf(QTestState *qts, QVirtQueue *vq, uint32_t *desc_idx,
uint32_t *len)
{ {
uint16_t idx; uint16_t idx;
uint64_t elem_addr; uint64_t elem_addr, addr;
idx = readw(vq->used + offsetof(struct vring_used, idx)); idx = qtest_readw(qts, vq->used + offsetof(struct vring_used, idx));
if (idx == vq->last_used_idx) { if (idx == vq->last_used_idx) {
return false; return false;
} }
@ -333,23 +338,25 @@ bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx, uint32_t *len)
sizeof(struct vring_used_elem); sizeof(struct vring_used_elem);
if (desc_idx) { if (desc_idx) {
*desc_idx = readl(elem_addr + offsetof(struct vring_used_elem, id)); addr = elem_addr + offsetof(struct vring_used_elem, id);
*desc_idx = qtest_readl(qts, addr);
} }
if (len) { if (len) {
*len = readw(elem_addr + offsetof(struct vring_used_elem, len)); addr = elem_addr + offsetof(struct vring_used_elem, len);
*len = qtest_readw(qts, addr);
} }
vq->last_used_idx++; vq->last_used_idx++;
return true; return true;
} }
void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx) void qvirtqueue_set_used_event(QTestState *qts, QVirtQueue *vq, uint16_t idx)
{ {
g_assert(vq->event); g_assert(vq->event);
/* vq->avail->used_event */ /* vq->avail->used_event */
writew(vq->avail + 4 + (2 * vq->size), idx); qtest_writew(qts, vq->avail + 4 + (2 * vq->size), idx);
} }
void qvirtio_start_device(QVirtioDevice *vdev) void qvirtio_start_device(QVirtioDevice *vdev)

28
tests/libqos/virtio.h
View File

@ -114,11 +114,11 @@ void qvirtio_set_driver_ok(QVirtioDevice *d);
void qvirtio_wait_queue_isr(QVirtioDevice *d, void qvirtio_wait_queue_isr(QVirtioDevice *d,
QVirtQueue *vq, gint64 timeout_us); QVirtQueue *vq, gint64 timeout_us);
uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d, uint8_t qvirtio_wait_status_byte_no_isr(QTestState *qts, QVirtioDevice *d,
QVirtQueue *vq, QVirtQueue *vq,
uint64_t addr, uint64_t addr,
gint64 timeout_us); gint64 timeout_us);
void qvirtio_wait_used_elem(QVirtioDevice *d, void qvirtio_wait_used_elem(QTestState *qts, QVirtioDevice *d,
QVirtQueue *vq, QVirtQueue *vq,
uint32_t desc_idx, uint32_t desc_idx,
uint32_t *len, uint32_t *len,
@ -131,17 +131,21 @@ void qvirtqueue_cleanup(const QVirtioBus *bus, QVirtQueue *vq,
void qvring_init(QTestState *qts, const QGuestAllocator *alloc, QVirtQueue *vq, void qvring_init(QTestState *qts, const QGuestAllocator *alloc, QVirtQueue *vq,
uint64_t addr); uint64_t addr);
QVRingIndirectDesc *qvring_indirect_desc_setup(QVirtioDevice *d, QVRingIndirectDesc *qvring_indirect_desc_setup(QTestState *qs, QVirtioDevice *d,
QGuestAllocator *alloc, uint16_t elem); QGuestAllocator *alloc,
void qvring_indirect_desc_add(QVRingIndirectDesc *indirect, uint64_t data, uint16_t elem);
uint32_t len, bool write); void qvring_indirect_desc_add(QTestState *qts, QVRingIndirectDesc *indirect,
uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write, uint64_t data, uint32_t len, bool write);
bool next); uint32_t qvirtqueue_add(QTestState *qts, QVirtQueue *vq, uint64_t data,
uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect); uint32_t len, bool write, bool next);
void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head); uint32_t qvirtqueue_add_indirect(QTestState *qts, QVirtQueue *vq,
bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx, uint32_t *len); QVRingIndirectDesc *indirect);
void qvirtqueue_kick(QTestState *qts, QVirtioDevice *d, QVirtQueue *vq,
uint32_t free_head);
bool qvirtqueue_get_buf(QTestState *qts, QVirtQueue *vq, uint32_t *desc_idx,
uint32_t *len);
void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx); void qvirtqueue_set_used_event(QTestState *qts, QVirtQueue *vq, uint16_t idx);
void qvirtio_start_device(QVirtioDevice *vdev); void qvirtio_start_device(QVirtioDevice *vdev);

37
tests/libqtest.c
View File

@ -1111,13 +1111,13 @@ QDict *qmp(const char *fmt, ...)
return response; return response;
} }
void qmp_assert_success(const char *fmt, ...) void qtest_qmp_assert_success(QTestState *qts, const char *fmt, ...)
{ {
va_list ap; va_list ap;
QDict *response; QDict *response;
va_start(ap, fmt); va_start(ap, fmt);
response = qtest_vqmp(global_qtest, fmt, ap); response = qtest_vqmp(qts, fmt, ap);
va_end(ap); va_end(ap);
g_assert(response); g_assert(response);
@ -1130,17 +1130,6 @@ void qmp_assert_success(const char *fmt, ...)
qobject_unref(response); qobject_unref(response);
} }
char *hmp(const char *fmt, ...)
{
va_list ap;
char *ret;
va_start(ap, fmt);
ret = qtest_vhmp(global_qtest, fmt, ap);
va_end(ap);
return ret;
}
bool qtest_big_endian(QTestState *s) bool qtest_big_endian(QTestState *s)
{ {
return s->big_endian; return s->big_endian;
@ -1200,9 +1189,10 @@ void qtest_cb_for_every_machine(void (*cb)(const char *machine),
QObject *qobj; QObject *qobj;
QString *qstr; QString *qstr;
const char *mname; const char *mname;
QTestState *qts;
qtest_start("-machine none"); qts = qtest_init("-machine none");
response = qmp("{ 'execute': 'query-machines' }"); response = qtest_qmp(qts, "{ 'execute': 'query-machines' }");
g_assert(response); g_assert(response);
list = qdict_get_qlist(response, "return"); list = qdict_get_qlist(response, "return");
g_assert(list); g_assert(list);
@ -1220,7 +1210,7 @@ void qtest_cb_for_every_machine(void (*cb)(const char *machine),
} }
} }
qtest_end(); qtest_quit(qts);
qobject_unref(response); qobject_unref(response);
} }
@ -1256,7 +1246,7 @@ QDict *qtest_qmp_receive_success(QTestState *s,
/* /*
* Generic hot-plugging test via the device_add QMP command. * Generic hot-plugging test via the device_add QMP command.
*/ */
void qtest_qmp_device_add(const char *driver, const char *id, void qtest_qmp_device_add(QTestState *qts, const char *driver, const char *id,
const char *fmt, ...) const char *fmt, ...)
{ {
QDict *args, *response; QDict *args, *response;
@ -1270,7 +1260,8 @@ void qtest_qmp_device_add(const char *driver, const char *id,
qdict_put_str(args, "driver", driver); qdict_put_str(args, "driver", driver);
qdict_put_str(args, "id", id); qdict_put_str(args, "id", id);
response = qmp("{'execute': 'device_add', 'arguments': %p}", args); response = qtest_qmp(qts, "{'execute': 'device_add', 'arguments': %p}",
args);
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */ g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
@ -1303,19 +1294,17 @@ static void device_deleted_cb(void *opaque, const char *name, QDict *data)
* *
* But the order of arrival may vary - so we've got to detect both. * But the order of arrival may vary - so we've got to detect both.
*/ */
void qtest_qmp_device_del(const char *id) void qtest_qmp_device_del(QTestState *qts, const char *id)
{ {
bool got_event = false; bool got_event = false;
QDict *rsp; QDict *rsp;
qtest_qmp_send(global_qtest, qtest_qmp_send(qts, "{'execute': 'device_del', 'arguments': {'id': %s}}",
"{'execute': 'device_del', 'arguments': {'id': %s}}",
id); id);
rsp = qtest_qmp_receive_success(global_qtest, device_deleted_cb, rsp = qtest_qmp_receive_success(qts, device_deleted_cb, &got_event);
&got_event);
qobject_unref(rsp); qobject_unref(rsp);
if (!got_event) { if (!got_event) {
rsp = qtest_qmp_receive(global_qtest); rsp = qtest_qmp_receive(qts);
g_assert_cmpstr(qdict_get_try_str(rsp, "event"), g_assert_cmpstr(qdict_get_try_str(rsp, "event"),
==, "DEVICE_DELETED"); ==, "DEVICE_DELETED");
qobject_unref(rsp); qobject_unref(rsp);

24
tests/libqtest.h
View File

@ -666,7 +666,8 @@ static inline void qtest_end(void)
QDict *qmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2); QDict *qmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
/** /**
* qmp_assert_success: * qtest_qmp_assert_success:
* @qts: QTestState instance to operate on
* @fmt...: QMP message to send to qemu, formatted like * @fmt...: QMP message to send to qemu, formatted like
* qobject_from_jsonf_nofail(). See parse_escape() for what's * qobject_from_jsonf_nofail(). See parse_escape() for what's
* supported after '%'. * supported after '%'.
@ -674,7 +675,8 @@ QDict *qmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
* Sends a QMP message to QEMU and asserts that a 'return' key is present in * Sends a QMP message to QEMU and asserts that a 'return' key is present in
* the response. * the response.
*/ */
void qmp_assert_success(const char *fmt, ...) GCC_FMT_ATTR(1, 2); void qtest_qmp_assert_success(QTestState *qts, const char *fmt, ...)
GCC_FMT_ATTR(2, 3);
/* /*
* qmp_eventwait: * qmp_eventwait:
@ -687,16 +689,6 @@ static inline void qmp_eventwait(const char *event)
return qtest_qmp_eventwait(global_qtest, event); return qtest_qmp_eventwait(global_qtest, event);
} }
/**
* hmp:
* @fmt...: HMP command to send to QEMU, formats arguments like sprintf().
*
* Send HMP command to QEMU via QMP's human-monitor-command.
*
* Returns: the command's output. The caller should g_free() it.
*/
char *hmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
/** /**
* get_irq: * get_irq:
* @num: Interrupt to observe. * @num: Interrupt to observe.
@ -956,6 +948,7 @@ void qtest_cb_for_every_machine(void (*cb)(const char *machine),
/** /**
* qtest_qmp_device_add: * qtest_qmp_device_add:
* @qts: QTestState instance to operate on
* @driver: Name of the device that should be added * @driver: Name of the device that should be added
* @id: Identification string * @id: Identification string
* @fmt...: QMP message to send to qemu, formatted like * @fmt...: QMP message to send to qemu, formatted like
@ -964,16 +957,17 @@ void qtest_cb_for_every_machine(void (*cb)(const char *machine),
* *
* Generic hot-plugging test via the device_add QMP command. * Generic hot-plugging test via the device_add QMP command.
*/ */
void qtest_qmp_device_add(const char *driver, const char *id, const char *fmt, void qtest_qmp_device_add(QTestState *qts, const char *driver, const char *id,
...) GCC_FMT_ATTR(3, 4); const char *fmt, ...) GCC_FMT_ATTR(4, 5);
/** /**
* qtest_qmp_device_del: * qtest_qmp_device_del:
* @qts: QTestState instance to operate on
* @id: Identification string * @id: Identification string
* *
* Generic hot-unplugging test via the device_del QMP command. * Generic hot-unplugging test via the device_del QMP command.
*/ */
void qtest_qmp_device_del(const char *id); void qtest_qmp_device_del(QTestState *qts, const char *id);
/** /**
* qmp_rsp_is_err: * qmp_rsp_is_err:

3
tests/megasas-test.c
View File

@ -75,7 +75,8 @@ static void megasas_register_nodes(void)
{ {
QOSGraphEdgeOptions opts = { QOSGraphEdgeOptions opts = {
.extra_device_opts = "addr=04.0,id=scsi0", .extra_device_opts = "addr=04.0,id=scsi0",
.before_cmd_line = "-drive id=drv0,if=none,file=null-co://,format=raw", .before_cmd_line = "-drive id=drv0,if=none,file=null-co://,"
"file.read-zeroes=on,format=raw",
.after_cmd_line = "-device scsi-hd,bus=scsi0.0,drive=drv0", .after_cmd_line = "-device scsi-hd,bus=scsi0.0,drive=drv0",
}; };

3
tests/nvme-test.c
View File

@ -70,7 +70,8 @@ static void nvme_register_nodes(void)
{ {
QOSGraphEdgeOptions opts = { QOSGraphEdgeOptions opts = {
.extra_device_opts = "addr=04.0,drive=drv0,serial=foo", .extra_device_opts = "addr=04.0,drive=drv0,serial=foo",
.before_cmd_line = "-drive id=drv0,if=none,file=null-co://,format=raw", .before_cmd_line = "-drive id=drv0,if=none,file=null-co://,"
"file.read-zeroes=on,format=raw",
}; };
add_qpci_address(&opts, &(QPCIAddress) { .devfn = QPCI_DEVFN(4, 0) }); add_qpci_address(&opts, &(QPCIAddress) { .devfn = QPCI_DEVFN(4, 0) });

2
tests/qmp-test.c
View File

@ -187,7 +187,7 @@ static void send_cmd_that_blocks(QTestState *s, const char *id)
" 'arguments': {" " 'arguments': {"
" 'driver': 'blkdebug', 'node-name': %s," " 'driver': 'blkdebug', 'node-name': %s,"
" 'config': %s," " 'config': %s,"
" 'image': { 'driver': 'null-co' } } }", " 'image': { 'driver': 'null-co', 'read-zeroes': true } } }",
id, id, fifo_name); id, id, fifo_name);
} }

5
tests/test-blockjob-txn.c
View File

@ -15,6 +15,7 @@
#include "qemu/main-loop.h" #include "qemu/main-loop.h"
#include "block/blockjob_int.h" #include "block/blockjob_int.h"
#include "sysemu/block-backend.h" #include "sysemu/block-backend.h"
#include "qapi/qmp/qdict.h"
typedef struct { typedef struct {
BlockJob common; BlockJob common;
@ -96,7 +97,9 @@ static BlockJob *test_block_job_start(unsigned int iterations,
data = g_new0(TestBlockJobCBData, 1); data = g_new0(TestBlockJobCBData, 1);
bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort); QDict *opt = qdict_new();
qdict_put_str(opt, "file.read-zeroes", "on");
bs = bdrv_open("null-co://", NULL, opt, 0, &error_abort);
g_assert_nonnull(bs); g_assert_nonnull(bs);
snprintf(job_id, sizeof(job_id), "job%u", counter++); snprintf(job_id, sizeof(job_id), "job%u", counter++);

5
tests/test-blockjob.c
View File

@ -15,6 +15,7 @@
#include "qemu/main-loop.h" #include "qemu/main-loop.h"
#include "block/blockjob_int.h" #include "block/blockjob_int.h"
#include "sysemu/block-backend.h" #include "sysemu/block-backend.h"
#include "qapi/qmp/qdict.h"
static const BlockJobDriver test_block_job_driver = { static const BlockJobDriver test_block_job_driver = {
.job_driver = { .job_driver = {
@ -71,7 +72,9 @@ static BlockBackend *create_blk(const char *name)
BlockBackend *blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL); BlockBackend *blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
BlockDriverState *bs; BlockDriverState *bs;
bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort); QDict *opt = qdict_new();
qdict_put_str(opt, "file.read-zeroes", "on");
bs = bdrv_open("null-co://", NULL, opt, 0, &error_abort);
g_assert_nonnull(bs); g_assert_nonnull(bs);
blk_insert_bs(blk, bs, &error_abort); blk_insert_bs(blk, bs, &error_abort);

2
tests/usb-hcd-ohci-test.c
View File

@ -23,7 +23,7 @@ struct QOHCI_PCI {
static void test_ohci_hotplug(void *obj, void *data, QGuestAllocator *alloc) static void test_ohci_hotplug(void *obj, void *data, QGuestAllocator *alloc)
{ {
usb_test_hotplug("ohci", "1", NULL); usb_test_hotplug(global_qtest, "ohci", "1", NULL);
} }
static void *ohci_pci_get_driver(void *obj, const char *interface) static void *ohci_pci_get_driver(void *obj, const char *interface)

11
tests/usb-hcd-uhci-test.c
View File

@ -43,21 +43,24 @@ static void test_port_2(void)
static void test_uhci_hotplug(void) static void test_uhci_hotplug(void)
{ {
usb_test_hotplug("uhci", "2", test_port_2); usb_test_hotplug(global_qtest, "uhci", "2", test_port_2);
} }
static void test_usb_storage_hotplug(void) static void test_usb_storage_hotplug(void)
{ {
qtest_qmp_device_add("usb-storage", "usbdev0", "{'drive': 'drive0'}"); QTestState *qts = global_qtest;
qtest_qmp_device_del("usbdev0"); qtest_qmp_device_add(qts, "usb-storage", "usbdev0", "{'drive': 'drive0'}");
qtest_qmp_device_del(qts, "usbdev0");
} }
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
const char *arch = qtest_get_arch(); const char *arch = qtest_get_arch();
const char *cmd = "-device piix3-usb-uhci,id=uhci,addr=1d.0" const char *cmd = "-device piix3-usb-uhci,id=uhci,addr=1d.0"
" -drive id=drive0,if=none,file=null-co://,format=raw" " -drive id=drive0,if=none,file=null-co://,"
"file.read-zeroes=on,format=raw"
" -device usb-tablet,bus=uhci.0,port=1"; " -device usb-tablet,bus=uhci.0,port=1";
int ret; int ret;

25
tests/usb-hcd-xhci-test.c
View File

@ -18,30 +18,34 @@ static void test_xhci_init(void)
static void test_xhci_hotplug(void) static void test_xhci_hotplug(void)
{ {
usb_test_hotplug("xhci", "1", NULL); usb_test_hotplug(global_qtest, "xhci", "1", NULL);
} }
static void test_usb_uas_hotplug(void) static void test_usb_uas_hotplug(void)
{ {
qtest_qmp_device_add("usb-uas", "uas", "{}"); QTestState *qts = global_qtest;
qtest_qmp_device_add("scsi-hd", "scsihd", "{'drive': 'drive0'}");
qtest_qmp_device_add(qts, "usb-uas", "uas", "{}");
qtest_qmp_device_add(qts, "scsi-hd", "scsihd", "{'drive': 'drive0'}");
/* TODO: /* TODO:
UAS HBA driver in libqos, to check that UAS HBA driver in libqos, to check that
added disk is visible after BUS rescan added disk is visible after BUS rescan
*/ */
qtest_qmp_device_del("scsihd"); qtest_qmp_device_del(qts, "scsihd");
qtest_qmp_device_del("uas"); qtest_qmp_device_del(qts, "uas");
} }
static void test_usb_ccid_hotplug(void) static void test_usb_ccid_hotplug(void)
{ {
qtest_qmp_device_add("usb-ccid", "ccid", "{}"); QTestState *qts = global_qtest;
qtest_qmp_device_del("ccid");
qtest_qmp_device_add(qts, "usb-ccid", "ccid", "{}");
qtest_qmp_device_del(qts, "ccid");
/* check the device can be added again */ /* check the device can be added again */
qtest_qmp_device_add("usb-ccid", "ccid", "{}"); qtest_qmp_device_add(qts, "usb-ccid", "ccid", "{}");
qtest_qmp_device_del("ccid"); qtest_qmp_device_del(qts, "ccid");
} }
int main(int argc, char **argv) int main(int argc, char **argv)
@ -56,7 +60,8 @@ int main(int argc, char **argv)
qtest_add_func("/xhci/pci/hotplug/usb-ccid", test_usb_ccid_hotplug); qtest_add_func("/xhci/pci/hotplug/usb-ccid", test_usb_ccid_hotplug);
qtest_start("-device nec-usb-xhci,id=xhci" qtest_start("-device nec-usb-xhci,id=xhci"
" -drive id=drive0,if=none,file=null-co://,format=raw"); " -drive id=drive0,if=none,file=null-co://,"
"file.read-zeroes=on,format=raw");
ret = g_test_run(); ret = g_test_run();
qtest_end(); qtest_end();

16
tests/virtio-9p-test.c
View File

@ -39,6 +39,7 @@ static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc)
#define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */ #define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */
typedef struct { typedef struct {
QTestState *qts;
QVirtio9P *v9p; QVirtio9P *v9p;
uint16_t tag; uint16_t tag;
uint64_t t_msg; uint64_t t_msg;
@ -52,7 +53,7 @@ typedef struct {
static void v9fs_memwrite(P9Req *req, const void *addr, size_t len) static void v9fs_memwrite(P9Req *req, const void *addr, size_t len)
{ {
memwrite(req->t_msg + req->t_off, addr, len); qtest_memwrite(req->qts, req->t_msg + req->t_off, addr, len);
req->t_off += len; req->t_off += len;
} }
@ -63,7 +64,7 @@ static void v9fs_memskip(P9Req *req, size_t len)
static void v9fs_memread(P9Req *req, void *addr, size_t len) static void v9fs_memread(P9Req *req, void *addr, size_t len)
{ {
memread(req->r_msg + req->r_off, addr, len); qtest_memread(req->qts, req->r_msg + req->r_off, addr, len);
req->r_off += len; req->r_off += len;
} }
@ -158,6 +159,7 @@ static P9Req *v9fs_req_init(QVirtio9P *v9p, uint32_t size, uint8_t id,
g_assert_cmpint(total_size, <=, P9_MAX_SIZE); g_assert_cmpint(total_size, <=, P9_MAX_SIZE);
req->qts = global_qtest;
req->v9p = v9p; req->v9p = v9p;
req->t_size = total_size; req->t_size = total_size;
req->t_msg = guest_alloc(alloc, req->t_size); req->t_msg = guest_alloc(alloc, req->t_size);
@ -171,10 +173,10 @@ static void v9fs_req_send(P9Req *req)
QVirtio9P *v9p = req->v9p; QVirtio9P *v9p = req->v9p;
req->r_msg = guest_alloc(alloc, P9_MAX_SIZE); req->r_msg = guest_alloc(alloc, P9_MAX_SIZE);
req->free_head = qvirtqueue_add(v9p->vq, req->t_msg, req->t_size, false, req->free_head = qvirtqueue_add(req->qts, v9p->vq, req->t_msg, req->t_size,
true); false, true);
qvirtqueue_add(v9p->vq, req->r_msg, P9_MAX_SIZE, true, false); qvirtqueue_add(req->qts, v9p->vq, req->r_msg, P9_MAX_SIZE, true, false);
qvirtqueue_kick(v9p->vdev, v9p->vq, req->free_head); qvirtqueue_kick(req->qts, v9p->vdev, v9p->vq, req->free_head);
req->t_off = 0; req->t_off = 0;
} }
@ -195,7 +197,7 @@ static void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len)
{ {
QVirtio9P *v9p = req->v9p; QVirtio9P *v9p = req->v9p;
qvirtio_wait_used_elem(v9p->vdev, v9p->vq, req->free_head, len, qvirtio_wait_used_elem(req->qts, v9p->vdev, v9p->vq, req->free_head, len,
QVIRTIO_9P_TIMEOUT_US); QVIRTIO_9P_TIMEOUT_US);
} }

159
tests/virtio-blk-test.c
View File

@ -123,6 +123,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
uint32_t free_head; uint32_t free_head;
uint8_t status; uint8_t status;
char *data; char *data;
QTestState *qts = global_qtest;
capacity = qvirtio_config_readq(dev, 0); capacity = qvirtio_config_readq(dev, 0);
@ -149,13 +150,14 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, false, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -171,13 +173,14 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, true, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -206,13 +209,14 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr)); req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true); qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true);
qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false); qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true,
false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 16 + sizeof(dwz_hdr)); status = readb(req_addr + 16 + sizeof(dwz_hdr));
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -229,13 +233,13 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, true, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -263,13 +267,13 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr)); req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true); qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true);
qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false); qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 16 + sizeof(dwz_hdr)); status = readb(req_addr + 16 + sizeof(dwz_hdr));
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -290,11 +294,11 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 528, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 528, false, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -311,12 +315,12 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 513, true, false); qvirtqueue_add(qts, vq, req_addr + 16, 513, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -353,6 +357,7 @@ static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc)
uint32_t free_head; uint32_t free_head;
uint8_t status; uint8_t status;
char *data; char *data;
QTestState *qts = global_qtest;
capacity = qvirtio_config_readq(dev, 0); capacity = qvirtio_config_readq(dev, 0);
g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
@ -378,13 +383,13 @@ static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc)
g_free(req.data); g_free(req.data);
indirect = qvring_indirect_desc_setup(dev, t_alloc, 2); indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2);
qvring_indirect_desc_add(indirect, req_addr, 528, false); qvring_indirect_desc_add(qts, indirect, req_addr, 528, false);
qvring_indirect_desc_add(indirect, req_addr + 528, 1, true); qvring_indirect_desc_add(qts, indirect, req_addr + 528, 1, true);
free_head = qvirtqueue_add_indirect(vq, indirect); free_head = qvirtqueue_add_indirect(qts, vq, indirect);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -403,13 +408,13 @@ static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc)
g_free(req.data); g_free(req.data);
indirect = qvring_indirect_desc_setup(dev, t_alloc, 2); indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2);
qvring_indirect_desc_add(indirect, req_addr, 16, false); qvring_indirect_desc_add(qts, indirect, req_addr, 16, false);
qvring_indirect_desc_add(indirect, req_addr + 16, 513, true); qvring_indirect_desc_add(qts, indirect, req_addr + 16, 513, true);
free_head = qvirtqueue_add_indirect(vq, indirect); free_head = qvirtqueue_add_indirect(qts, vq, indirect);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -461,6 +466,7 @@ static void msix(void *obj, void *u_data, QGuestAllocator *t_alloc)
char *data; char *data;
QOSGraphObject *blk_object = obj; QOSGraphObject *blk_object = obj;
QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device"); QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device");
QTestState *qts = global_qtest;
if (qpci_check_buggy_msi(pci_dev)) { if (qpci_check_buggy_msi(pci_dev)) {
return; return;
@ -504,12 +510,12 @@ static void msix(void *obj, void *u_data, QGuestAllocator *t_alloc)
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, false, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
@ -527,14 +533,14 @@ static void msix(void *obj, void *u_data, QGuestAllocator *t_alloc)
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, true, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528); status = readb(req_addr + 528);
@ -569,6 +575,7 @@ static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc)
char *data; char *data;
QOSGraphObject *blk_object = obj; QOSGraphObject *blk_object = obj;
QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device"); QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device");
QTestState *qts = global_qtest;
if (qpci_check_buggy_msi(pci_dev)) { if (qpci_check_buggy_msi(pci_dev)) {
return; return;
@ -603,12 +610,12 @@ static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc)
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, false, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
/* Write request */ /* Write request */
@ -623,15 +630,15 @@ static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc)
g_free(req.data); g_free(req.data);
/* Notify after processing the third request */ /* Notify after processing the third request */
qvirtqueue_set_used_event(vq, 2); qvirtqueue_set_used_event(qts, vq, 2);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, false, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
write_head = free_head; write_head = free_head;
/* No notification expected */ /* No notification expected */
status = qvirtio_wait_status_byte_no_isr(dev, status = qvirtio_wait_status_byte_no_isr(qts, dev,
vq, req_addr + 528, vq, req_addr + 528,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
g_assert_cmpint(status, ==, 0); g_assert_cmpint(status, ==, 0);
@ -648,16 +655,16 @@ static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc)
g_free(req.data); g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, true, true); qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
/* We get just one notification for both requests */ /* We get just one notification for both requests */
qvirtio_wait_used_elem(dev, vq, write_head, NULL, qvirtio_wait_used_elem(qts, dev, vq, write_head, NULL,
QVIRTIO_BLK_TIMEOUT_US); QVIRTIO_BLK_TIMEOUT_US);
g_assert(qvirtqueue_get_buf(vq, &desc_idx, NULL)); g_assert(qvirtqueue_get_buf(qts, vq, &desc_idx, NULL));
g_assert_cmpint(desc_idx, ==, free_head); g_assert_cmpint(desc_idx, ==, free_head);
status = readb(req_addr + 528); status = readb(req_addr + 528);
@ -683,7 +690,7 @@ static void pci_hotplug(void *obj, void *data, QGuestAllocator *t_alloc)
QTestState *qts = dev1->pdev->bus->qts; QTestState *qts = dev1->pdev->bus->qts;
/* plug secondary disk */ /* plug secondary disk */
qtest_qmp_device_add("virtio-blk-pci", "drv1", qtest_qmp_device_add(qts, "virtio-blk-pci", "drv1",
"{'addr': %s, 'drive': 'drive1'}", "{'addr': %s, 'drive': 'drive1'}",
stringify(PCI_SLOT_HP) ".0"); stringify(PCI_SLOT_HP) ".0");
@ -753,8 +760,10 @@ static void *virtio_blk_test_setup(GString *cmd_line, void *arg)
char *tmp_path = drive_create(); char *tmp_path = drive_create();
g_string_append_printf(cmd_line, g_string_append_printf(cmd_line,
" -drive if=none,id=drive0,file=%s,format=raw,auto-read-only=off " " -drive if=none,id=drive0,file=%s,"
"-drive if=none,id=drive1,file=null-co://,format=raw ", "format=raw,auto-read-only=off "
"-drive if=none,id=drive1,file=null-co://,"
"file.read-zeroes=on,format=raw ",
tmp_path); tmp_path);
return arg; return arg;

25
tests/virtio-ccw-test.c
View File

@ -45,15 +45,18 @@ static void virtio_serial_nop(void)
static void virtio_serial_hotplug(void) static void virtio_serial_hotplug(void)
{ {
global_qtest = qtest_initf("-device virtio-serial-ccw"); QTestState *qts = qtest_initf("-device virtio-serial-ccw");
qtest_qmp_device_add("virtserialport", "hp-port", "{}");
qtest_qmp_device_del("hp-port"); qtest_qmp_device_add(qts, "virtserialport", "hp-port", "{}");
qtest_end(); qtest_qmp_device_del(qts, "hp-port");
qtest_quit(qts);
} }
static void virtio_blk_nop(void) static void virtio_blk_nop(void)
{ {
global_qtest = qtest_initf("-drive if=none,id=drv0,file=null-co://,format=raw " global_qtest = qtest_initf("-drive if=none,id=drv0,file=null-co://,"
"file.read-zeroes=on,format=raw "
"-device virtio-blk-ccw,drive=drv0"); "-device virtio-blk-ccw,drive=drv0");
qtest_end(); qtest_end();
} }
@ -78,14 +81,16 @@ static void virtio_scsi_nop(void)
static void virtio_scsi_hotplug(void) static void virtio_scsi_hotplug(void)
{ {
global_qtest = qtest_initf("-drive if=none,id=drv0,file=null-co://,format=raw " QTestState *s = qtest_initf("-drive if=none,id=drv0,file=null-co://,"
"-drive if=none,id=drv1,file=null-co://,format=raw " "file.read-zeroes=on,format=raw "
"-drive if=none,id=drv1,file=null-co://,"
"file.read-zeroes=on,format=raw "
"-device virtio-scsi-ccw " "-device virtio-scsi-ccw "
"-device scsi-hd,drive=drv0"); "-device scsi-hd,drive=drv0");
qtest_qmp_device_add("scsi-hd", "scsihd", "{'drive': 'drv1'}"); qtest_qmp_device_add(s, "scsi-hd", "scsihd", "{'drive': 'drv1'}");
qtest_qmp_device_del("scsihd"); qtest_qmp_device_del(s, "scsihd");
qtest_end(); qtest_quit(s);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

35
tests/virtio-net-test.c
View File

@ -33,6 +33,7 @@ static void rx_test(QVirtioDevice *dev,
QGuestAllocator *alloc, QVirtQueue *vq, QGuestAllocator *alloc, QVirtQueue *vq,
int socket) int socket)
{ {
QTestState *qts = global_qtest;
uint64_t req_addr; uint64_t req_addr;
uint32_t free_head; uint32_t free_head;
char test[] = "TEST"; char test[] = "TEST";
@ -51,13 +52,14 @@ static void rx_test(QVirtioDevice *dev,
req_addr = guest_alloc(alloc, 64); req_addr = guest_alloc(alloc, 64);
free_head = qvirtqueue_add(vq, req_addr, 64, true, false); free_head = qvirtqueue_add(qts, vq, req_addr, 64, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
ret = iov_send(socket, iov, 2, 0, sizeof(len) + sizeof(test)); ret = iov_send(socket, iov, 2, 0, sizeof(len) + sizeof(test));
g_assert_cmpint(ret, ==, sizeof(test) + sizeof(len)); g_assert_cmpint(ret, ==, sizeof(test) + sizeof(len));
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_NET_TIMEOUT_US); qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_NET_TIMEOUT_US);
memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test)); memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
g_assert_cmpstr(buffer, ==, "TEST"); g_assert_cmpstr(buffer, ==, "TEST");
@ -68,6 +70,7 @@ static void tx_test(QVirtioDevice *dev,
QGuestAllocator *alloc, QVirtQueue *vq, QGuestAllocator *alloc, QVirtQueue *vq,
int socket) int socket)
{ {
QTestState *qts = global_qtest;
uint64_t req_addr; uint64_t req_addr;
uint32_t free_head; uint32_t free_head;
uint32_t len; uint32_t len;
@ -77,10 +80,11 @@ static void tx_test(QVirtioDevice *dev,
req_addr = guest_alloc(alloc, 64); req_addr = guest_alloc(alloc, 64);
memwrite(req_addr + VNET_HDR_SIZE, "TEST", 4); memwrite(req_addr + VNET_HDR_SIZE, "TEST", 4);
free_head = qvirtqueue_add(vq, req_addr, 64, false, false); free_head = qvirtqueue_add(qts, vq, req_addr, 64, false, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_NET_TIMEOUT_US); qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_NET_TIMEOUT_US);
guest_free(alloc, req_addr); guest_free(alloc, req_addr);
ret = qemu_recv(socket, &len, sizeof(len), 0); ret = qemu_recv(socket, &len, sizeof(len), 0);
@ -95,6 +99,7 @@ static void rx_stop_cont_test(QVirtioDevice *dev,
QGuestAllocator *alloc, QVirtQueue *vq, QGuestAllocator *alloc, QVirtQueue *vq,
int socket) int socket)
{ {
QTestState *qts = global_qtest;
uint64_t req_addr; uint64_t req_addr;
uint32_t free_head; uint32_t free_head;
char test[] = "TEST"; char test[] = "TEST";
@ -114,8 +119,8 @@ static void rx_stop_cont_test(QVirtioDevice *dev,
req_addr = guest_alloc(alloc, 64); req_addr = guest_alloc(alloc, 64);
free_head = qvirtqueue_add(vq, req_addr, 64, true, false); free_head = qvirtqueue_add(qts, vq, req_addr, 64, true, false);
qvirtqueue_kick(dev, vq, free_head); qvirtqueue_kick(qts, dev, vq, free_head);
rsp = qmp("{ 'execute' : 'stop'}"); rsp = qmp("{ 'execute' : 'stop'}");
qobject_unref(rsp); qobject_unref(rsp);
@ -131,7 +136,8 @@ static void rx_stop_cont_test(QVirtioDevice *dev,
rsp = qmp("{ 'execute' : 'cont'}"); rsp = qmp("{ 'execute' : 'cont'}");
qobject_unref(rsp); qobject_unref(rsp);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_NET_TIMEOUT_US); qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_NET_TIMEOUT_US);
memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test)); memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
g_assert_cmpstr(buffer, ==, "TEST"); g_assert_cmpstr(buffer, ==, "TEST");
@ -168,7 +174,7 @@ static void hotplug(void *obj, void *data, QGuestAllocator *t_alloc)
QTestState *qts = dev->pdev->bus->qts; QTestState *qts = dev->pdev->bus->qts;
const char *arch = qtest_get_arch(); const char *arch = qtest_get_arch();
qtest_qmp_device_add("virtio-net-pci", "net1", qtest_qmp_device_add(qts, "virtio-net-pci", "net1",
"{'addr': %s}", stringify(PCI_SLOT_HP)); "{'addr': %s}", stringify(PCI_SLOT_HP));
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) { if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
@ -283,19 +289,20 @@ static void large_tx(void *obj, void *data, QGuestAllocator *t_alloc)
uint64_t req_addr; uint64_t req_addr;
uint32_t free_head; uint32_t free_head;
size_t alloc_size = (size_t)data / 64; size_t alloc_size = (size_t)data / 64;
QTestState *qts = global_qtest;
int i; int i;
/* Bypass the limitation by pointing several descriptors to a single /* Bypass the limitation by pointing several descriptors to a single
* smaller area */ * smaller area */
req_addr = guest_alloc(t_alloc, alloc_size); req_addr = guest_alloc(t_alloc, alloc_size);
free_head = qvirtqueue_add(vq, req_addr, alloc_size, false, true); free_head = qvirtqueue_add(qts, vq, req_addr, alloc_size, false, true);
for (i = 0; i < 64; i++) { for (i = 0; i < 64; i++) {
qvirtqueue_add(vq, req_addr, alloc_size, false, i != 63); qvirtqueue_add(qts, vq, req_addr, alloc_size, false, i != 63);
} }
qvirtqueue_kick(dev->vdev, vq, free_head); qvirtqueue_kick(qts, dev->vdev, vq, free_head);
qvirtio_wait_used_elem(dev->vdev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, dev->vdev, vq, free_head, NULL,
QVIRTIO_NET_TIMEOUT_US); QVIRTIO_NET_TIMEOUT_US);
guest_free(t_alloc, req_addr); guest_free(t_alloc, req_addr);
} }

2
tests/virtio-rng-test.c
View File

@ -22,7 +22,7 @@ static void rng_hotplug(void *obj, void *data, QGuestAllocator *alloc)
const char *arch = qtest_get_arch(); const char *arch = qtest_get_arch();
qtest_qmp_device_add("virtio-rng-pci", "rng1", qtest_qmp_device_add(qts, "virtio-rng-pci", "rng1",
"{'addr': %s}", stringify(PCI_SLOT_HP)); "{'addr': %s}", stringify(PCI_SLOT_HP));
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) { if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {

35
tests/virtio-scsi-test.c
View File

@ -72,6 +72,7 @@ static uint8_t virtio_scsi_do_command(QVirtioSCSIQueues *vs,
uint64_t req_addr, resp_addr, data_in_addr = 0, data_out_addr = 0; uint64_t req_addr, resp_addr, data_in_addr = 0, data_out_addr = 0;
uint8_t response; uint8_t response;
uint32_t free_head; uint32_t free_head;
QTestState *qts = global_qtest;
vq = vs->vq[2]; vq = vs->vq[2];
@ -83,24 +84,24 @@ static uint8_t virtio_scsi_do_command(QVirtioSCSIQueues *vs,
/* Add request header */ /* Add request header */
req_addr = qvirtio_scsi_alloc(vs, sizeof(req), &req); req_addr = qvirtio_scsi_alloc(vs, sizeof(req), &req);
free_head = qvirtqueue_add(vq, req_addr, sizeof(req), false, true); free_head = qvirtqueue_add(qts, vq, req_addr, sizeof(req), false, true);
if (data_out_len) { if (data_out_len) {
data_out_addr = qvirtio_scsi_alloc(vs, data_out_len, data_out); data_out_addr = qvirtio_scsi_alloc(vs, data_out_len, data_out);
qvirtqueue_add(vq, data_out_addr, data_out_len, false, true); qvirtqueue_add(qts, vq, data_out_addr, data_out_len, false, true);
} }
/* Add response header */ /* Add response header */
resp_addr = qvirtio_scsi_alloc(vs, sizeof(resp), &resp); resp_addr = qvirtio_scsi_alloc(vs, sizeof(resp), &resp);
qvirtqueue_add(vq, resp_addr, sizeof(resp), true, !!data_in_len); qvirtqueue_add(qts, vq, resp_addr, sizeof(resp), true, !!data_in_len);
if (data_in_len) { if (data_in_len) {
data_in_addr = qvirtio_scsi_alloc(vs, data_in_len, data_in); data_in_addr = qvirtio_scsi_alloc(vs, data_in_len, data_in);
qvirtqueue_add(vq, data_in_addr, data_in_len, true, false); qvirtqueue_add(qts, vq, data_in_addr, data_in_len, true, false);
} }
qvirtqueue_kick(vs->dev, vq, free_head); qvirtqueue_kick(qts, vs->dev, vq, free_head);
qvirtio_wait_used_elem(vs->dev, vq, free_head, NULL, qvirtio_wait_used_elem(qts, vs->dev, vq, free_head, NULL,
QVIRTIO_SCSI_TIMEOUT_US); QVIRTIO_SCSI_TIMEOUT_US);
response = readb(resp_addr + response = readb(resp_addr +
@ -149,8 +150,10 @@ static QVirtioSCSIQueues *qvirtio_scsi_init(QVirtioDevice *dev)
static void hotplug(void *obj, void *data, QGuestAllocator *alloc) static void hotplug(void *obj, void *data, QGuestAllocator *alloc)
{ {
qtest_qmp_device_add("scsi-hd", "scsihd", "{'drive': 'drv1'}"); QTestState *qts = global_qtest;
qtest_qmp_device_del("scsihd");
qtest_qmp_device_add(qts, "scsi-hd", "scsihd", "{'drive': 'drv1'}");
qtest_qmp_device_del(qts, "scsihd");
} }
/* Test WRITE SAME with the lba not aligned */ /* Test WRITE SAME with the lba not aligned */
@ -222,10 +225,12 @@ static void test_iothread_attach_node(void *obj, void *data,
mkqcow2(tmp_path, 64); mkqcow2(tmp_path, 64);
/* Attach the overlay to the null0 node */ /* Attach the overlay to the null0 node */
qmp_assert_success("{'execute': 'blockdev-add', 'arguments': {" qtest_qmp_assert_success(scsi_pci->pci_vdev.pdev->bus->qts,
" 'driver': 'qcow2', 'node-name': 'overlay'," "{'execute': 'blockdev-add', 'arguments': {"
" 'backing': 'null0', 'file': {" " 'driver': 'qcow2', 'node-name': 'overlay',"
" 'driver': 'file', 'filename': %s}}}", tmp_path); " 'backing': 'null0', 'file': {"
" 'driver': 'file', 'filename': %s}}}",
tmp_path);
/* Send a request to see if the AioContext is still right */ /* Send a request to see if the AioContext is still right */
ret = virtio_scsi_do_command(vs, write_cdb, NULL, 0, buf, 512, NULL); ret = virtio_scsi_do_command(vs, write_cdb, NULL, 0, buf, 512, NULL);
@ -239,7 +244,8 @@ fail:
static void *virtio_scsi_hotplug_setup(GString *cmd_line, void *arg) static void *virtio_scsi_hotplug_setup(GString *cmd_line, void *arg)
{ {
g_string_append(cmd_line, g_string_append(cmd_line,
" -drive id=drv1,if=none,file=null-co://,format=raw"); " -drive id=drv1,if=none,file=null-co://,"
"file.read-zeroes=on,format=raw");
return arg; return arg;
} }
@ -247,6 +253,7 @@ static void *virtio_scsi_setup(GString *cmd_line, void *arg)
{ {
g_string_append(cmd_line, g_string_append(cmd_line,
" -drive file=blkdebug::null-co://," " -drive file=blkdebug::null-co://,"
"file.image.read-zeroes=on,"
"if=none,id=dr1,format=raw,file.align=4k " "if=none,id=dr1,format=raw,file.align=4k "
"-device scsi-hd,drive=dr1,lun=0,scsi-id=1"); "-device scsi-hd,drive=dr1,lun=0,scsi-id=1");
return arg; return arg;
@ -256,7 +263,7 @@ static void *virtio_scsi_setup_iothread(GString *cmd_line, void *arg)
{ {
g_string_append(cmd_line, g_string_append(cmd_line,
" -object iothread,id=thread0" " -object iothread,id=thread0"
" -blockdev driver=null-co,node-name=null0" " -blockdev driver=null-co,read-zeroes=on,node-name=null0"
" -device scsi-hd,drive=null0"); " -device scsi-hd,drive=null0");
return arg; return arg;
} }

4
tests/virtio-serial-test.c
View File

@ -20,8 +20,8 @@ static void virtio_serial_nop(void *obj, void *data, QGuestAllocator *alloc)
static void serial_hotplug(void *obj, void *data, QGuestAllocator *alloc) static void serial_hotplug(void *obj, void *data, QGuestAllocator *alloc)
{ {
qtest_qmp_device_add("virtserialport", "hp-port", "{}"); qtest_qmp_device_add(global_qtest, "virtserialport", "hp-port", "{}");
qtest_qmp_device_del("hp-port"); qtest_qmp_device_del(global_qtest, "hp-port");
} }
static void register_virtio_serial_test(void) static void register_virtio_serial_test(void)

2
vl.c
View File

@ -4197,7 +4197,7 @@ int main(int argc, char **argv, char **envp)
migration_object_init(); migration_object_init();
if (qtest_chrdev) { if (qtest_chrdev) {
qtest_init(qtest_chrdev, qtest_log, &error_fatal); qtest_server_init(qtest_chrdev, qtest_log, &error_fatal);
} }
machine_opts = qemu_get_machine_opts(); machine_opts = qemu_get_machine_opts();