2 * QTest testcase for VirtIO Block Device
4 * Copyright (c) 2014 SUSE LINUX Products GmbH
5 * Copyright (c) 2014 Marc MarĂ
7 * This work is licensed under the terms of the GNU GPL, version 2 or later.
8 * See the COPYING file in the top-level directory.
11 #include "qemu/osdep.h"
13 #include "libqos/virtio.h"
14 #include "libqos/virtio-pci.h"
15 #include "libqos/virtio-mmio.h"
16 #include "libqos/pci-pc.h"
17 #include "libqos/malloc.h"
18 #include "libqos/malloc-pc.h"
19 #include "libqos/malloc-generic.h"
20 #include "qemu/bswap.h"
21 #include "standard-headers/linux/virtio_ids.h"
22 #include "standard-headers/linux/virtio_config.h"
23 #include "standard-headers/linux/virtio_ring.h"
24 #include "standard-headers/linux/virtio_blk.h"
25 #include "standard-headers/linux/virtio_pci.h"
27 #define TEST_IMAGE_SIZE (64 * 1024 * 1024)
28 #define QVIRTIO_BLK_TIMEOUT_US (30 * 1000 * 1000)
29 #define PCI_SLOT_HP 0x06
33 #define MMIO_PAGE_SIZE 4096
34 #define MMIO_DEV_BASE_ADDR 0x0A003E00
35 #define MMIO_RAM_ADDR 0x40000000
36 #define MMIO_RAM_SIZE 0x20000000
38 typedef struct QVirtioBlkReq
{
46 static char *drive_create(void)
49 char *tmp_path
= g_strdup("/tmp/qtest.XXXXXX");
51 /* Create a temporary raw image */
52 fd
= mkstemp(tmp_path
);
53 g_assert_cmpint(fd
, >=, 0);
54 ret
= ftruncate(fd
, TEST_IMAGE_SIZE
);
55 g_assert_cmpint(ret
, ==, 0);
61 static QPCIBus
*pci_test_start(void)
66 tmp_path
= drive_create();
68 cmdline
= g_strdup_printf("-drive if=none,id=drive0,file=%s,format=raw "
69 "-drive if=none,id=drive1,file=/dev/null,format=raw "
70 "-device virtio-blk-pci,id=drv0,drive=drive0,"
72 tmp_path
, PCI_SLOT
, PCI_FN
);
78 return qpci_init_pc(NULL
);
81 static void arm_test_start(void)
86 tmp_path
= drive_create();
88 cmdline
= g_strdup_printf("-machine virt "
89 "-drive if=none,id=drive0,file=%s,format=raw "
90 "-device virtio-blk-device,drive=drive0",
98 static void test_end(void)
103 static QVirtioPCIDevice
*virtio_blk_pci_init(QPCIBus
*bus
, int slot
)
105 QVirtioPCIDevice
*dev
;
107 dev
= qvirtio_pci_device_find(bus
, VIRTIO_ID_BLOCK
);
108 g_assert(dev
!= NULL
);
109 g_assert_cmphex(dev
->vdev
.device_type
, ==, VIRTIO_ID_BLOCK
);
110 g_assert_cmphex(dev
->pdev
->devfn
, ==, ((slot
<< 3) | PCI_FN
));
112 qvirtio_pci_device_enable(dev
);
113 qvirtio_reset(&dev
->vdev
);
114 qvirtio_set_acknowledge(&dev
->vdev
);
115 qvirtio_set_driver(&dev
->vdev
);
120 static inline void virtio_blk_fix_request(QVirtioBlkReq
*req
)
122 #ifdef HOST_WORDS_BIGENDIAN
123 bool host_endian
= true;
125 bool host_endian
= false;
128 if (target_big_endian() != host_endian
) {
129 req
->type
= bswap32(req
->type
);
130 req
->ioprio
= bswap32(req
->ioprio
);
131 req
->sector
= bswap64(req
->sector
);
135 static uint64_t virtio_blk_request(QGuestAllocator
*alloc
, QVirtioBlkReq
*req
,
139 uint8_t status
= 0xFF;
141 g_assert_cmpuint(data_size
% 512, ==, 0);
142 addr
= guest_alloc(alloc
, sizeof(*req
) + data_size
);
144 virtio_blk_fix_request(req
);
146 memwrite(addr
, req
, 16);
147 memwrite(addr
+ 16, req
->data
, data_size
);
148 memwrite(addr
+ 16 + data_size
, &status
, sizeof(status
));
153 static void test_basic(QVirtioDevice
*dev
, QGuestAllocator
*alloc
,
154 QVirtQueue
*vq
, uint64_t device_specific
)
164 capacity
= qvirtio_config_readq(dev
, device_specific
);
166 g_assert_cmpint(capacity
, ==, TEST_IMAGE_SIZE
/ 512);
168 features
= qvirtio_get_features(dev
);
169 features
= features
& ~(QVIRTIO_F_BAD_FEATURE
|
170 (1u << VIRTIO_RING_F_INDIRECT_DESC
) |
171 (1u << VIRTIO_RING_F_EVENT_IDX
) |
172 (1u << VIRTIO_BLK_F_SCSI
));
173 qvirtio_set_features(dev
, features
);
175 qvirtio_set_driver_ok(dev
);
177 /* Write and read with 3 descriptor layout */
179 req
.type
= VIRTIO_BLK_T_OUT
;
182 req
.data
= g_malloc0(512);
183 strcpy(req
.data
, "TEST");
185 req_addr
= virtio_blk_request(alloc
, &req
, 512);
189 free_head
= qvirtqueue_add(vq
, req_addr
, 16, false, true);
190 qvirtqueue_add(vq
, req_addr
+ 16, 512, false, true);
191 qvirtqueue_add(vq
, req_addr
+ 528, 1, true, false);
193 qvirtqueue_kick(dev
, vq
, free_head
);
195 qvirtio_wait_queue_isr(dev
, vq
, QVIRTIO_BLK_TIMEOUT_US
);
196 status
= readb(req_addr
+ 528);
197 g_assert_cmpint(status
, ==, 0);
199 guest_free(alloc
, req_addr
);
202 req
.type
= VIRTIO_BLK_T_IN
;
205 req
.data
= g_malloc0(512);
207 req_addr
= virtio_blk_request(alloc
, &req
, 512);
211 free_head
= qvirtqueue_add(vq
, req_addr
, 16, false, true);
212 qvirtqueue_add(vq
, req_addr
+ 16, 512, true, true);
213 qvirtqueue_add(vq
, req_addr
+ 528, 1, true, false);
215 qvirtqueue_kick(dev
, vq
, free_head
);
217 qvirtio_wait_queue_isr(dev
, vq
, QVIRTIO_BLK_TIMEOUT_US
);
218 status
= readb(req_addr
+ 528);
219 g_assert_cmpint(status
, ==, 0);
221 data
= g_malloc0(512);
222 memread(req_addr
+ 16, data
, 512);
223 g_assert_cmpstr(data
, ==, "TEST");
226 guest_free(alloc
, req_addr
);
228 if (features
& (1u << VIRTIO_F_ANY_LAYOUT
)) {
229 /* Write and read with 2 descriptor layout */
231 req
.type
= VIRTIO_BLK_T_OUT
;
234 req
.data
= g_malloc0(512);
235 strcpy(req
.data
, "TEST");
237 req_addr
= virtio_blk_request(alloc
, &req
, 512);
241 free_head
= qvirtqueue_add(vq
, req_addr
, 528, false, true);
242 qvirtqueue_add(vq
, req_addr
+ 528, 1, true, false);
243 qvirtqueue_kick(dev
, vq
, free_head
);
245 qvirtio_wait_queue_isr(dev
, vq
, QVIRTIO_BLK_TIMEOUT_US
);
246 status
= readb(req_addr
+ 528);
247 g_assert_cmpint(status
, ==, 0);
249 guest_free(alloc
, req_addr
);
252 req
.type
= VIRTIO_BLK_T_IN
;
255 req
.data
= g_malloc0(512);
257 req_addr
= virtio_blk_request(alloc
, &req
, 512);
261 free_head
= qvirtqueue_add(vq
, req_addr
, 16, false, true);
262 qvirtqueue_add(vq
, req_addr
+ 16, 513, true, false);
264 qvirtqueue_kick(dev
, vq
, free_head
);
266 qvirtio_wait_queue_isr(dev
, vq
, QVIRTIO_BLK_TIMEOUT_US
);
267 status
= readb(req_addr
+ 528);
268 g_assert_cmpint(status
, ==, 0);
270 data
= g_malloc0(512);
271 memread(req_addr
+ 16, data
, 512);
272 g_assert_cmpstr(data
, ==, "TEST");
275 guest_free(alloc
, req_addr
);
279 static void pci_basic(void)
281 QVirtioPCIDevice
*dev
;
283 QVirtQueuePCI
*vqpci
;
284 QGuestAllocator
*alloc
;
287 bus
= pci_test_start();
288 dev
= virtio_blk_pci_init(bus
, PCI_SLOT
);
290 alloc
= pc_alloc_init();
291 vqpci
= (QVirtQueuePCI
*)qvirtqueue_setup(&dev
->vdev
, alloc
, 0);
293 /* MSI-X is not enabled */
294 addr
= dev
->addr
+ VIRTIO_PCI_CONFIG_OFF(false);
296 test_basic(&dev
->vdev
, alloc
, &vqpci
->vq
, (uint64_t)(uintptr_t)addr
);
299 qvirtqueue_cleanup(dev
->vdev
.bus
, &vqpci
->vq
, alloc
);
300 pc_alloc_uninit(alloc
);
301 qvirtio_pci_device_disable(dev
);
307 static void pci_indirect(void)
309 QVirtioPCIDevice
*dev
;
311 QVirtQueuePCI
*vqpci
;
312 QGuestAllocator
*alloc
;
314 QVRingIndirectDesc
*indirect
;
323 bus
= pci_test_start();
325 dev
= virtio_blk_pci_init(bus
, PCI_SLOT
);
327 /* MSI-X is not enabled */
328 addr
= dev
->addr
+ VIRTIO_PCI_CONFIG_OFF(false);
330 capacity
= qvirtio_config_readq(&dev
->vdev
, (uint64_t)(uintptr_t)addr
);
331 g_assert_cmpint(capacity
, ==, TEST_IMAGE_SIZE
/ 512);
333 features
= qvirtio_get_features(&dev
->vdev
);
334 g_assert_cmphex(features
& (1u << VIRTIO_RING_F_INDIRECT_DESC
), !=, 0);
335 features
= features
& ~(QVIRTIO_F_BAD_FEATURE
|
336 (1u << VIRTIO_RING_F_EVENT_IDX
) |
337 (1u << VIRTIO_BLK_F_SCSI
));
338 qvirtio_set_features(&dev
->vdev
, features
);
340 alloc
= pc_alloc_init();
341 vqpci
= (QVirtQueuePCI
*)qvirtqueue_setup(&dev
->vdev
, alloc
, 0);
342 qvirtio_set_driver_ok(&dev
->vdev
);
345 req
.type
= VIRTIO_BLK_T_OUT
;
348 req
.data
= g_malloc0(512);
349 strcpy(req
.data
, "TEST");
351 req_addr
= virtio_blk_request(alloc
, &req
, 512);
355 indirect
= qvring_indirect_desc_setup(&dev
->vdev
, alloc
, 2);
356 qvring_indirect_desc_add(indirect
, req_addr
, 528, false);
357 qvring_indirect_desc_add(indirect
, req_addr
+ 528, 1, true);
358 free_head
= qvirtqueue_add_indirect(&vqpci
->vq
, indirect
);
359 qvirtqueue_kick(&dev
->vdev
, &vqpci
->vq
, free_head
);
361 qvirtio_wait_queue_isr(&dev
->vdev
, &vqpci
->vq
,
362 QVIRTIO_BLK_TIMEOUT_US
);
363 status
= readb(req_addr
+ 528);
364 g_assert_cmpint(status
, ==, 0);
367 guest_free(alloc
, req_addr
);
370 req
.type
= VIRTIO_BLK_T_IN
;
373 req
.data
= g_malloc0(512);
374 strcpy(req
.data
, "TEST");
376 req_addr
= virtio_blk_request(alloc
, &req
, 512);
380 indirect
= qvring_indirect_desc_setup(&dev
->vdev
, alloc
, 2);
381 qvring_indirect_desc_add(indirect
, req_addr
, 16, false);
382 qvring_indirect_desc_add(indirect
, req_addr
+ 16, 513, true);
383 free_head
= qvirtqueue_add_indirect(&vqpci
->vq
, indirect
);
384 qvirtqueue_kick(&dev
->vdev
, &vqpci
->vq
, free_head
);
386 qvirtio_wait_queue_isr(&dev
->vdev
, &vqpci
->vq
,
387 QVIRTIO_BLK_TIMEOUT_US
);
388 status
= readb(req_addr
+ 528);
389 g_assert_cmpint(status
, ==, 0);
391 data
= g_malloc0(512);
392 memread(req_addr
+ 16, data
, 512);
393 g_assert_cmpstr(data
, ==, "TEST");
397 guest_free(alloc
, req_addr
);
400 qvirtqueue_cleanup(dev
->vdev
.bus
, &vqpci
->vq
, alloc
);
401 pc_alloc_uninit(alloc
);
402 qvirtio_pci_device_disable(dev
);
408 static void pci_config(void)
410 QVirtioPCIDevice
*dev
;
412 int n_size
= TEST_IMAGE_SIZE
/ 2;
416 bus
= pci_test_start();
418 dev
= virtio_blk_pci_init(bus
, PCI_SLOT
);
420 /* MSI-X is not enabled */
421 addr
= dev
->addr
+ VIRTIO_PCI_CONFIG_OFF(false);
423 capacity
= qvirtio_config_readq(&dev
->vdev
, (uint64_t)(uintptr_t)addr
);
424 g_assert_cmpint(capacity
, ==, TEST_IMAGE_SIZE
/ 512);
426 qvirtio_set_driver_ok(&dev
->vdev
);
428 qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
429 " 'size': %d } }", n_size
);
430 qvirtio_wait_config_isr(&dev
->vdev
, QVIRTIO_BLK_TIMEOUT_US
);
432 capacity
= qvirtio_config_readq(&dev
->vdev
, (uint64_t)(uintptr_t)addr
);
433 g_assert_cmpint(capacity
, ==, n_size
/ 512);
435 qvirtio_pci_device_disable(dev
);
441 static void pci_msix(void)
443 QVirtioPCIDevice
*dev
;
445 QVirtQueuePCI
*vqpci
;
446 QGuestAllocator
*alloc
;
448 int n_size
= TEST_IMAGE_SIZE
/ 2;
457 bus
= pci_test_start();
458 alloc
= pc_alloc_init();
460 dev
= virtio_blk_pci_init(bus
, PCI_SLOT
);
461 qpci_msix_enable(dev
->pdev
);
463 qvirtio_pci_set_msix_configuration_vector(dev
, alloc
, 0);
465 /* MSI-X is enabled */
466 addr
= dev
->addr
+ VIRTIO_PCI_CONFIG_OFF(true);
468 capacity
= qvirtio_config_readq(&dev
->vdev
, (uint64_t)(uintptr_t)addr
);
469 g_assert_cmpint(capacity
, ==, TEST_IMAGE_SIZE
/ 512);
471 features
= qvirtio_get_features(&dev
->vdev
);
472 features
= features
& ~(QVIRTIO_F_BAD_FEATURE
|
473 (1u << VIRTIO_RING_F_INDIRECT_DESC
) |
474 (1u << VIRTIO_RING_F_EVENT_IDX
) |
475 (1u << VIRTIO_BLK_F_SCSI
));
476 qvirtio_set_features(&dev
->vdev
, features
);
478 vqpci
= (QVirtQueuePCI
*)qvirtqueue_setup(&dev
->vdev
, alloc
, 0);
479 qvirtqueue_pci_msix_setup(dev
, vqpci
, alloc
, 1);
481 qvirtio_set_driver_ok(&dev
->vdev
);
483 qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
484 " 'size': %d } }", n_size
);
486 qvirtio_wait_config_isr(&dev
->vdev
, QVIRTIO_BLK_TIMEOUT_US
);
488 capacity
= qvirtio_config_readq(&dev
->vdev
, (uintptr_t)addr
);
489 g_assert_cmpint(capacity
, ==, n_size
/ 512);
492 req
.type
= VIRTIO_BLK_T_OUT
;
495 req
.data
= g_malloc0(512);
496 strcpy(req
.data
, "TEST");
498 req_addr
= virtio_blk_request(alloc
, &req
, 512);
502 free_head
= qvirtqueue_add(&vqpci
->vq
, req_addr
, 16, false, true);
503 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 16, 512, false, true);
504 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 528, 1, true, false);
505 qvirtqueue_kick(&dev
->vdev
, &vqpci
->vq
, free_head
);
507 qvirtio_wait_queue_isr(&dev
->vdev
, &vqpci
->vq
,
508 QVIRTIO_BLK_TIMEOUT_US
);
510 status
= readb(req_addr
+ 528);
511 g_assert_cmpint(status
, ==, 0);
513 guest_free(alloc
, req_addr
);
516 req
.type
= VIRTIO_BLK_T_IN
;
519 req
.data
= g_malloc0(512);
521 req_addr
= virtio_blk_request(alloc
, &req
, 512);
525 free_head
= qvirtqueue_add(&vqpci
->vq
, req_addr
, 16, false, true);
526 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 16, 512, true, true);
527 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 528, 1, true, false);
529 qvirtqueue_kick(&dev
->vdev
, &vqpci
->vq
, free_head
);
532 qvirtio_wait_queue_isr(&dev
->vdev
, &vqpci
->vq
,
533 QVIRTIO_BLK_TIMEOUT_US
);
535 status
= readb(req_addr
+ 528);
536 g_assert_cmpint(status
, ==, 0);
538 data
= g_malloc0(512);
539 memread(req_addr
+ 16, data
, 512);
540 g_assert_cmpstr(data
, ==, "TEST");
543 guest_free(alloc
, req_addr
);
546 qvirtqueue_cleanup(dev
->vdev
.bus
, &vqpci
->vq
, alloc
);
547 pc_alloc_uninit(alloc
);
548 qpci_msix_disable(dev
->pdev
);
549 qvirtio_pci_device_disable(dev
);
555 static void pci_idx(void)
557 QVirtioPCIDevice
*dev
;
559 QVirtQueuePCI
*vqpci
;
560 QGuestAllocator
*alloc
;
570 bus
= pci_test_start();
571 alloc
= pc_alloc_init();
573 dev
= virtio_blk_pci_init(bus
, PCI_SLOT
);
574 qpci_msix_enable(dev
->pdev
);
576 qvirtio_pci_set_msix_configuration_vector(dev
, alloc
, 0);
578 /* MSI-X is enabled */
579 addr
= dev
->addr
+ VIRTIO_PCI_CONFIG_OFF(true);
581 capacity
= qvirtio_config_readq(&dev
->vdev
, (uint64_t)(uintptr_t)addr
);
582 g_assert_cmpint(capacity
, ==, TEST_IMAGE_SIZE
/ 512);
584 features
= qvirtio_get_features(&dev
->vdev
);
585 features
= features
& ~(QVIRTIO_F_BAD_FEATURE
|
586 (1u << VIRTIO_RING_F_INDIRECT_DESC
) |
587 (1u << VIRTIO_F_NOTIFY_ON_EMPTY
) |
588 (1u << VIRTIO_BLK_F_SCSI
));
589 qvirtio_set_features(&dev
->vdev
, features
);
591 vqpci
= (QVirtQueuePCI
*)qvirtqueue_setup(&dev
->vdev
, alloc
, 0);
592 qvirtqueue_pci_msix_setup(dev
, vqpci
, alloc
, 1);
594 qvirtio_set_driver_ok(&dev
->vdev
);
597 req
.type
= VIRTIO_BLK_T_OUT
;
600 req
.data
= g_malloc0(512);
601 strcpy(req
.data
, "TEST");
603 req_addr
= virtio_blk_request(alloc
, &req
, 512);
607 free_head
= qvirtqueue_add(&vqpci
->vq
, req_addr
, 16, false, true);
608 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 16, 512, false, true);
609 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 528, 1, true, false);
610 qvirtqueue_kick(&dev
->vdev
, &vqpci
->vq
, free_head
);
612 qvirtio_wait_queue_isr(&dev
->vdev
, &vqpci
->vq
, QVIRTIO_BLK_TIMEOUT_US
);
615 req
.type
= VIRTIO_BLK_T_OUT
;
618 req
.data
= g_malloc0(512);
619 strcpy(req
.data
, "TEST");
621 req_addr
= virtio_blk_request(alloc
, &req
, 512);
625 /* Notify after processing the third request */
626 qvirtqueue_set_used_event(&vqpci
->vq
, 2);
627 free_head
= qvirtqueue_add(&vqpci
->vq
, req_addr
, 16, false, true);
628 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 16, 512, false, true);
629 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 528, 1, true, false);
630 qvirtqueue_kick(&dev
->vdev
, &vqpci
->vq
, free_head
);
632 /* No notification expected */
633 status
= qvirtio_wait_status_byte_no_isr(&dev
->vdev
,
634 &vqpci
->vq
, req_addr
+ 528,
635 QVIRTIO_BLK_TIMEOUT_US
);
636 g_assert_cmpint(status
, ==, 0);
638 guest_free(alloc
, req_addr
);
641 req
.type
= VIRTIO_BLK_T_IN
;
644 req
.data
= g_malloc0(512);
646 req_addr
= virtio_blk_request(alloc
, &req
, 512);
650 free_head
= qvirtqueue_add(&vqpci
->vq
, req_addr
, 16, false, true);
651 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 16, 512, true, true);
652 qvirtqueue_add(&vqpci
->vq
, req_addr
+ 528, 1, true, false);
654 qvirtqueue_kick(&dev
->vdev
, &vqpci
->vq
, free_head
);
656 qvirtio_wait_queue_isr(&dev
->vdev
, &vqpci
->vq
,
657 QVIRTIO_BLK_TIMEOUT_US
);
659 status
= readb(req_addr
+ 528);
660 g_assert_cmpint(status
, ==, 0);
662 data
= g_malloc0(512);
663 memread(req_addr
+ 16, data
, 512);
664 g_assert_cmpstr(data
, ==, "TEST");
667 guest_free(alloc
, req_addr
);
670 qvirtqueue_cleanup(dev
->vdev
.bus
, &vqpci
->vq
, alloc
);
671 pc_alloc_uninit(alloc
);
672 qpci_msix_disable(dev
->pdev
);
673 qvirtio_pci_device_disable(dev
);
679 static void pci_hotplug(void)
682 QVirtioPCIDevice
*dev
;
684 bus
= pci_test_start();
686 /* plug secondary disk */
687 qpci_plug_device_test("virtio-blk-pci", "drv1", PCI_SLOT_HP
,
688 "'drive': 'drive1'");
690 dev
= virtio_blk_pci_init(bus
, PCI_SLOT_HP
);
692 qvirtio_pci_device_disable(dev
);
695 /* unplug secondary disk */
696 qpci_unplug_acpi_device_test("drv1", PCI_SLOT_HP
);
701 static void mmio_basic(void)
703 QVirtioMMIODevice
*dev
;
705 QGuestAllocator
*alloc
;
706 int n_size
= TEST_IMAGE_SIZE
/ 2;
711 dev
= qvirtio_mmio_init_device(MMIO_DEV_BASE_ADDR
, MMIO_PAGE_SIZE
);
712 g_assert(dev
!= NULL
);
713 g_assert_cmphex(dev
->vdev
.device_type
, ==, VIRTIO_ID_BLOCK
);
715 qvirtio_reset(&dev
->vdev
);
716 qvirtio_set_acknowledge(&dev
->vdev
);
717 qvirtio_set_driver(&dev
->vdev
);
719 alloc
= generic_alloc_init(MMIO_RAM_ADDR
, MMIO_RAM_SIZE
, MMIO_PAGE_SIZE
);
720 vq
= qvirtqueue_setup(&dev
->vdev
, alloc
, 0);
722 test_basic(&dev
->vdev
, alloc
, vq
, QVIRTIO_MMIO_DEVICE_SPECIFIC
);
724 qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
725 " 'size': %d } }", n_size
);
727 qvirtio_wait_queue_isr(&dev
->vdev
, vq
, QVIRTIO_BLK_TIMEOUT_US
);
729 capacity
= qvirtio_config_readq(&dev
->vdev
, QVIRTIO_MMIO_DEVICE_SPECIFIC
);
730 g_assert_cmpint(capacity
, ==, n_size
/ 512);
733 qvirtqueue_cleanup(dev
->vdev
.bus
, vq
, alloc
);
734 generic_alloc_uninit(alloc
);
739 int main(int argc
, char **argv
)
741 const char *arch
= qtest_get_arch();
743 g_test_init(&argc
, &argv
, NULL
);
745 if (strcmp(arch
, "i386") == 0 || strcmp(arch
, "x86_64") == 0) {
746 qtest_add_func("/virtio/blk/pci/basic", pci_basic
);
747 qtest_add_func("/virtio/blk/pci/indirect", pci_indirect
);
748 qtest_add_func("/virtio/blk/pci/config", pci_config
);
749 qtest_add_func("/virtio/blk/pci/msix", pci_msix
);
750 qtest_add_func("/virtio/blk/pci/idx", pci_idx
);
751 qtest_add_func("/virtio/blk/pci/hotplug", pci_hotplug
);
752 } else if (strcmp(arch
, "arm") == 0) {
753 qtest_add_func("/virtio/blk/mmio/basic", mmio_basic
);