tests/virtio-blk-test.c

   1 /*
   2  * QTest testcase for VirtIO Block Device
   3  *
   4  * Copyright (c) 2014 SUSE LINUX Products GmbH
   5  * Copyright (c) 2014 Marc Marí
   6  *
   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.
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "libqtest.h"
  13 #include "qemu/bswap.h"
  14 #include "standard-headers/linux/virtio_blk.h"
  15 #include "standard-headers/linux/virtio_pci.h"
  16 #include "libqos/qgraph.h"
  17 #include "libqos/virtio-blk.h"
  18
  19 /* TODO actually test the results and get rid of this */
  20 #define qmp_discard_response(...) qobject_unref(qmp(__VA_ARGS__))
  21
  22 #define TEST_IMAGE_SIZE         (64 * 1024 * 1024)
  23 #define QVIRTIO_BLK_TIMEOUT_US  (30 * 1000 * 1000)
  24 #define PCI_SLOT_HP             0x06
  25
  26 typedef struct QVirtioBlkReq {
  27     uint32_t type;
  28     uint32_t ioprio;
  29     uint64_t sector;
  30     char *data;
  31     uint8_t status;
  32 } QVirtioBlkReq;
  33
  34
  35 #ifdef HOST_WORDS_BIGENDIAN
  36 const bool host_is_big_endian = true;
  37 #else
  38 const bool host_is_big_endian; /* false */
  39 #endif
  40
  41 static void drive_destroy(void *path)
  42 {
  43     unlink(path);
  44     g_free(path);
  45     qos_invalidate_command_line();
  46 }
  47
  48 static char *drive_create(void)
  49 {
  50     int fd, ret;
  51     char *t_path = g_strdup("/tmp/qtest.XXXXXX");
  52
  53     /* Create a temporary raw image */
  54     fd = mkstemp(t_path);
  55     g_assert_cmpint(fd, >=, 0);
  56     ret = ftruncate(fd, TEST_IMAGE_SIZE);
  57     g_assert_cmpint(ret, ==, 0);
  58     close(fd);
  59
  60     g_test_queue_destroy(drive_destroy, t_path);
  61     return t_path;
  62 }
  63
  64 static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
  65 {
  66     if (qvirtio_is_big_endian(d) != host_is_big_endian) {
  67         req->type = bswap32(req->type);
  68         req->ioprio = bswap32(req->ioprio);
  69         req->sector = bswap64(req->sector);
  70     }
  71 }
  72
  73
  74 static inline void virtio_blk_fix_dwz_hdr(QVirtioDevice *d,
  75     struct virtio_blk_discard_write_zeroes *dwz_hdr)
  76 {
  77     if (qvirtio_is_big_endian(d) != host_is_big_endian) {
  78         dwz_hdr->sector = bswap64(dwz_hdr->sector);
  79         dwz_hdr->num_sectors = bswap32(dwz_hdr->num_sectors);
  80         dwz_hdr->flags = bswap32(dwz_hdr->flags);
  81     }
  82 }
  83
  84 static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
  85                                    QVirtioBlkReq *req, uint64_t data_size)
  86 {
  87     uint64_t addr;
  88     uint8_t status = 0xFF;
  89
  90     switch (req->type) {
  91     case VIRTIO_BLK_T_IN:
  92     case VIRTIO_BLK_T_OUT:
  93         g_assert_cmpuint(data_size % 512, ==, 0);
  94         break;
  95     case VIRTIO_BLK_T_DISCARD:
  96     case VIRTIO_BLK_T_WRITE_ZEROES:
  97         g_assert_cmpuint(data_size %
  98                          sizeof(struct virtio_blk_discard_write_zeroes), ==, 0);
  99         break;
 100     default:
 101         g_assert_cmpuint(data_size, ==, 0);
 102     }
 103
 104     addr = guest_alloc(alloc, sizeof(*req) + data_size);
 105
 106     virtio_blk_fix_request(d, req);
 107
 108     memwrite(addr, req, 16);
 109     memwrite(addr + 16, req->data, data_size);
 110     memwrite(addr + 16 + data_size, &status, sizeof(status));
 111
 112     return addr;
 113 }
 114
 115 static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
 116                        QVirtQueue *vq)
 117 {
 118     QVirtioBlkReq req;
 119     uint64_t req_addr;
 120     uint64_t capacity;
 121     uint32_t features;
 122     uint32_t free_head;
 123     uint8_t status;
 124     char *data;
 125
 126     capacity = qvirtio_config_readq(dev, 0);
 127
 128     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 129
 130     features = qvirtio_get_features(dev);
 131     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 132                     (1u << VIRTIO_RING_F_INDIRECT_DESC) |
 133                     (1u << VIRTIO_RING_F_EVENT_IDX) |
 134                     (1u << VIRTIO_BLK_F_SCSI));
 135     qvirtio_set_features(dev, features);
 136
 137     qvirtio_set_driver_ok(dev);
 138
 139     /* Write and read with 3 descriptor layout */
 140     /* Write request */
 141     req.type = VIRTIO_BLK_T_OUT;
 142     req.ioprio = 1;
 143     req.sector = 0;
 144     req.data = g_malloc0(512);
 145     strcpy(req.data, "TEST");
 146
 147     req_addr = virtio_blk_request(alloc, dev, &req, 512);
 148
 149     g_free(req.data);
 150
 151     free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 152     qvirtqueue_add(vq, req_addr + 16, 512, false, true);
 153     qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 154
 155     qvirtqueue_kick(dev, vq, free_head);
 156
 157     qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US);
 158     status = readb(req_addr + 528);
 159     g_assert_cmpint(status, ==, 0);
 160
 161     guest_free(alloc, req_addr);
 162
 163     /* Read request */
 164     req.type = VIRTIO_BLK_T_IN;
 165     req.ioprio = 1;
 166     req.sector = 0;
 167     req.data = g_malloc0(512);
 168
 169     req_addr = virtio_blk_request(alloc, dev, &req, 512);
 170
 171     g_free(req.data);
 172
 173     free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 174     qvirtqueue_add(vq, req_addr + 16, 512, true, true);
 175     qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 176
 177     qvirtqueue_kick(dev, vq, free_head);
 178
 179     qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US);
 180     status = readb(req_addr + 528);
 181     g_assert_cmpint(status, ==, 0);
 182
 183     data = g_malloc0(512);
 184     memread(req_addr + 16, data, 512);
 185     g_assert_cmpstr(data, ==, "TEST");
 186     g_free(data);
 187
 188     guest_free(alloc, req_addr);
 189
 190     if (features & (1u << VIRTIO_BLK_F_WRITE_ZEROES)) {
 191         struct virtio_blk_discard_write_zeroes dwz_hdr;
 192         void *expected;
 193
 194         /*
 195          * WRITE_ZEROES request on the same sector of previous test where
 196          * we wrote "TEST".
 197          */
 198         req.type = VIRTIO_BLK_T_WRITE_ZEROES;
 199         req.data = (char *) &dwz_hdr;
 200         dwz_hdr.sector = 0;
 201         dwz_hdr.num_sectors = 1;
 202         dwz_hdr.flags = 0;
 203
 204         virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
 205
 206         req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
 207
 208         free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 209         qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true);
 210         qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
 211
 212         qvirtqueue_kick(dev, vq, free_head);
 213
 214         qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 215                                QVIRTIO_BLK_TIMEOUT_US);
 216         status = readb(req_addr + 16 + sizeof(dwz_hdr));
 217         g_assert_cmpint(status, ==, 0);
 218
 219         guest_free(alloc, req_addr);
 220
 221         /* Read request to check if the sector contains all zeroes */
 222         req.type = VIRTIO_BLK_T_IN;
 223         req.ioprio = 1;
 224         req.sector = 0;
 225         req.data = g_malloc0(512);
 226
 227         req_addr = virtio_blk_request(alloc, dev, &req, 512);
 228
 229         g_free(req.data);
 230
 231         free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 232         qvirtqueue_add(vq, req_addr + 16, 512, true, true);
 233         qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 234
 235         qvirtqueue_kick(dev, vq, free_head);
 236
 237         qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 238                                QVIRTIO_BLK_TIMEOUT_US);
 239         status = readb(req_addr + 528);
 240         g_assert_cmpint(status, ==, 0);
 241
 242         data = g_malloc(512);
 243         expected = g_malloc0(512);
 244         memread(req_addr + 16, data, 512);
 245         g_assert_cmpmem(data, 512, expected, 512);
 246         g_free(expected);
 247         g_free(data);
 248
 249         guest_free(alloc, req_addr);
 250     }
 251
 252     if (features & (1u << VIRTIO_BLK_F_DISCARD)) {
 253         struct virtio_blk_discard_write_zeroes dwz_hdr;
 254
 255         req.type = VIRTIO_BLK_T_DISCARD;
 256         req.data = (char *) &dwz_hdr;
 257         dwz_hdr.sector = 0;
 258         dwz_hdr.num_sectors = 1;
 259         dwz_hdr.flags = 0;
 260
 261         virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
 262
 263         req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
 264
 265         free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 266         qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true);
 267         qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
 268
 269         qvirtqueue_kick(dev, vq, free_head);
 270
 271         qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 272                                QVIRTIO_BLK_TIMEOUT_US);
 273         status = readb(req_addr + 16 + sizeof(dwz_hdr));
 274         g_assert_cmpint(status, ==, 0);
 275
 276         guest_free(alloc, req_addr);
 277     }
 278
 279     if (features & (1u << VIRTIO_F_ANY_LAYOUT)) {
 280         /* Write and read with 2 descriptor layout */
 281         /* Write request */
 282         req.type = VIRTIO_BLK_T_OUT;
 283         req.ioprio = 1;
 284         req.sector = 1;
 285         req.data = g_malloc0(512);
 286         strcpy(req.data, "TEST");
 287
 288         req_addr = virtio_blk_request(alloc, dev, &req, 512);
 289
 290         g_free(req.data);
 291
 292         free_head = qvirtqueue_add(vq, req_addr, 528, false, true);
 293         qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 294         qvirtqueue_kick(dev, vq, free_head);
 295
 296         qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 297                                QVIRTIO_BLK_TIMEOUT_US);
 298         status = readb(req_addr + 528);
 299         g_assert_cmpint(status, ==, 0);
 300
 301         guest_free(alloc, req_addr);
 302
 303         /* Read request */
 304         req.type = VIRTIO_BLK_T_IN;
 305         req.ioprio = 1;
 306         req.sector = 1;
 307         req.data = g_malloc0(512);
 308
 309         req_addr = virtio_blk_request(alloc, dev, &req, 512);
 310
 311         g_free(req.data);
 312
 313         free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 314         qvirtqueue_add(vq, req_addr + 16, 513, true, false);
 315
 316         qvirtqueue_kick(dev, vq, free_head);
 317
 318         qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 319                                QVIRTIO_BLK_TIMEOUT_US);
 320         status = readb(req_addr + 528);
 321         g_assert_cmpint(status, ==, 0);
 322
 323         data = g_malloc0(512);
 324         memread(req_addr + 16, data, 512);
 325         g_assert_cmpstr(data, ==, "TEST");
 326         g_free(data);
 327
 328         guest_free(alloc, req_addr);
 329     }
 330 }
 331
 332 static void basic(void *obj, void *data, QGuestAllocator *t_alloc)
 333 {
 334     QVirtioBlk *blk_if = obj;
 335     QVirtQueue *vq;
 336     vq = qvirtqueue_setup(blk_if->vdev, t_alloc, 0);
 337     test_basic(blk_if->vdev, t_alloc, vq);
 338     qvirtqueue_cleanup(blk_if->vdev->bus, vq, t_alloc);
 339
 340 }
 341
 342 static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc)
 343 {
 344     QVirtQueue *vq;
 345     QVirtioBlk *blk_if = obj;
 346     QVirtioDevice *dev = blk_if->vdev;
 347     QVirtioBlkReq req;
 348     QVRingIndirectDesc *indirect;
 349     uint64_t req_addr;
 350     uint64_t capacity;
 351     uint32_t features;
 352     uint32_t free_head;
 353     uint8_t status;
 354     char *data;
 355
 356     capacity = qvirtio_config_readq(dev, 0);
 357     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 358
 359     features = qvirtio_get_features(dev);
 360     g_assert_cmphex(features & (1u << VIRTIO_RING_F_INDIRECT_DESC), !=, 0);
 361     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 362                             (1u << VIRTIO_RING_F_EVENT_IDX) |
 363                             (1u << VIRTIO_BLK_F_SCSI));
 364     qvirtio_set_features(dev, features);
 365
 366     vq = qvirtqueue_setup(dev, t_alloc, 0);
 367     qvirtio_set_driver_ok(dev);
 368
 369     /* Write request */
 370     req.type = VIRTIO_BLK_T_OUT;
 371     req.ioprio = 1;
 372     req.sector = 0;
 373     req.data = g_malloc0(512);
 374     strcpy(req.data, "TEST");
 375
 376     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 377
 378     g_free(req.data);
 379
 380     indirect = qvring_indirect_desc_setup(dev, t_alloc, 2);
 381     qvring_indirect_desc_add(indirect, req_addr, 528, false);
 382     qvring_indirect_desc_add(indirect, req_addr + 528, 1, true);
 383     free_head = qvirtqueue_add_indirect(vq, indirect);
 384     qvirtqueue_kick(dev, vq, free_head);
 385
 386     qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 387                            QVIRTIO_BLK_TIMEOUT_US);
 388     status = readb(req_addr + 528);
 389     g_assert_cmpint(status, ==, 0);
 390
 391     g_free(indirect);
 392     guest_free(t_alloc, req_addr);
 393
 394     /* Read request */
 395     req.type = VIRTIO_BLK_T_IN;
 396     req.ioprio = 1;
 397     req.sector = 0;
 398     req.data = g_malloc0(512);
 399     strcpy(req.data, "TEST");
 400
 401     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 402
 403     g_free(req.data);
 404
 405     indirect = qvring_indirect_desc_setup(dev, t_alloc, 2);
 406     qvring_indirect_desc_add(indirect, req_addr, 16, false);
 407     qvring_indirect_desc_add(indirect, req_addr + 16, 513, true);
 408     free_head = qvirtqueue_add_indirect(vq, indirect);
 409     qvirtqueue_kick(dev, vq, free_head);
 410
 411     qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 412                            QVIRTIO_BLK_TIMEOUT_US);
 413     status = readb(req_addr + 528);
 414     g_assert_cmpint(status, ==, 0);
 415
 416     data = g_malloc0(512);
 417     memread(req_addr + 16, data, 512);
 418     g_assert_cmpstr(data, ==, "TEST");
 419     g_free(data);
 420
 421     g_free(indirect);
 422     guest_free(t_alloc, req_addr);
 423     qvirtqueue_cleanup(dev->bus, vq, t_alloc);
 424 }
 425
 426 static void config(void *obj, void *data, QGuestAllocator *t_alloc)
 427 {
 428     QVirtioBlk *blk_if = obj;
 429     QVirtioDevice *dev = blk_if->vdev;
 430     int n_size = TEST_IMAGE_SIZE / 2;
 431     uint64_t capacity;
 432
 433     capacity = qvirtio_config_readq(dev, 0);
 434     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 435
 436     qvirtio_set_driver_ok(dev);
 437
 438     qmp_discard_response("{ 'execute': 'block_resize', "
 439                          " 'arguments': { 'device': 'drive0', "
 440                          " 'size': %d } }", n_size);
 441     qvirtio_wait_config_isr(dev, QVIRTIO_BLK_TIMEOUT_US);
 442
 443     capacity = qvirtio_config_readq(dev, 0);
 444     g_assert_cmpint(capacity, ==, n_size / 512);
 445 }
 446
 447 static void msix(void *obj, void *u_data, QGuestAllocator *t_alloc)
 448 {
 449     QVirtQueue *vq;
 450     QVirtioBlkPCI *blk = obj;
 451     QVirtioPCIDevice *pdev = &blk->pci_vdev;
 452     QVirtioDevice *dev = &pdev->vdev;
 453     QVirtioBlkReq req;
 454     int n_size = TEST_IMAGE_SIZE / 2;
 455     uint64_t req_addr;
 456     uint64_t capacity;
 457     uint32_t features;
 458     uint32_t free_head;
 459     uint8_t status;
 460     char *data;
 461     QOSGraphObject *blk_object = obj;
 462     QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device");
 463
 464     if (qpci_check_buggy_msi(pci_dev)) {
 465         return;
 466     }
 467
 468     qpci_msix_enable(pdev->pdev);
 469     qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0);
 470
 471     capacity = qvirtio_config_readq(dev, 0);
 472     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 473
 474     features = qvirtio_get_features(dev);
 475     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 476                             (1u << VIRTIO_RING_F_INDIRECT_DESC) |
 477                             (1u << VIRTIO_RING_F_EVENT_IDX) |
 478                             (1u << VIRTIO_BLK_F_SCSI));
 479     qvirtio_set_features(dev, features);
 480
 481     vq = qvirtqueue_setup(dev, t_alloc, 0);
 482     qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1);
 483
 484     qvirtio_set_driver_ok(dev);
 485
 486     qmp_discard_response("{ 'execute': 'block_resize', "
 487                          " 'arguments': { 'device': 'drive0', "
 488                          " 'size': %d } }", n_size);
 489
 490     qvirtio_wait_config_isr(dev, QVIRTIO_BLK_TIMEOUT_US);
 491
 492     capacity = qvirtio_config_readq(dev, 0);
 493     g_assert_cmpint(capacity, ==, n_size / 512);
 494
 495     /* Write request */
 496     req.type = VIRTIO_BLK_T_OUT;
 497     req.ioprio = 1;
 498     req.sector = 0;
 499     req.data = g_malloc0(512);
 500     strcpy(req.data, "TEST");
 501
 502     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 503
 504     g_free(req.data);
 505
 506     free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 507     qvirtqueue_add(vq, req_addr + 16, 512, false, true);
 508     qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 509     qvirtqueue_kick(dev, vq, free_head);
 510
 511     qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 512                            QVIRTIO_BLK_TIMEOUT_US);
 513
 514     status = readb(req_addr + 528);
 515     g_assert_cmpint(status, ==, 0);
 516
 517     guest_free(t_alloc, req_addr);
 518
 519     /* Read request */
 520     req.type = VIRTIO_BLK_T_IN;
 521     req.ioprio = 1;
 522     req.sector = 0;
 523     req.data = g_malloc0(512);
 524
 525     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 526
 527     g_free(req.data);
 528
 529     free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 530     qvirtqueue_add(vq, req_addr + 16, 512, true, true);
 531     qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 532
 533     qvirtqueue_kick(dev, vq, free_head);
 534
 535
 536     qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 537                            QVIRTIO_BLK_TIMEOUT_US);
 538
 539     status = readb(req_addr + 528);
 540     g_assert_cmpint(status, ==, 0);
 541
 542     data = g_malloc0(512);
 543     memread(req_addr + 16, data, 512);
 544     g_assert_cmpstr(data, ==, "TEST");
 545     g_free(data);
 546
 547     guest_free(t_alloc, req_addr);
 548
 549     /* End test */
 550     qpci_msix_disable(pdev->pdev);
 551     qvirtqueue_cleanup(dev->bus, vq, t_alloc);
 552 }
 553
 554 static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc)
 555 {
 556     QVirtQueue *vq;
 557     QVirtioBlkPCI *blk = obj;
 558     QVirtioPCIDevice *pdev = &blk->pci_vdev;
 559     QVirtioDevice *dev = &pdev->vdev;
 560     QVirtioBlkReq req;
 561     uint64_t req_addr;
 562     uint64_t capacity;
 563     uint32_t features;
 564     uint32_t free_head;
 565     uint32_t write_head;
 566     uint32_t desc_idx;
 567     uint8_t status;
 568     char *data;
 569     QOSGraphObject *blk_object = obj;
 570     QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device");
 571
 572     if (qpci_check_buggy_msi(pci_dev)) {
 573         return;
 574     }
 575
 576     qpci_msix_enable(pdev->pdev);
 577     qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0);
 578
 579     capacity = qvirtio_config_readq(dev, 0);
 580     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 581
 582     features = qvirtio_get_features(dev);
 583     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 584                             (1u << VIRTIO_RING_F_INDIRECT_DESC) |
 585                             (1u << VIRTIO_F_NOTIFY_ON_EMPTY) |
 586                             (1u << VIRTIO_BLK_F_SCSI));
 587     qvirtio_set_features(dev, features);
 588
 589     vq = qvirtqueue_setup(dev, t_alloc, 0);
 590     qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1);
 591
 592     qvirtio_set_driver_ok(dev);
 593
 594     /* Write request */
 595     req.type = VIRTIO_BLK_T_OUT;
 596     req.ioprio = 1;
 597     req.sector = 0;
 598     req.data = g_malloc0(512);
 599     strcpy(req.data, "TEST");
 600
 601     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 602
 603     g_free(req.data);
 604
 605     free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 606     qvirtqueue_add(vq, req_addr + 16, 512, false, true);
 607     qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 608     qvirtqueue_kick(dev, vq, free_head);
 609
 610     qvirtio_wait_used_elem(dev, vq, free_head, NULL,
 611                            QVIRTIO_BLK_TIMEOUT_US);
 612
 613     /* Write request */
 614     req.type = VIRTIO_BLK_T_OUT;
 615     req.ioprio = 1;
 616     req.sector = 1;
 617     req.data = g_malloc0(512);
 618     strcpy(req.data, "TEST");
 619
 620     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 621
 622     g_free(req.data);
 623
 624     /* Notify after processing the third request */
 625     qvirtqueue_set_used_event(vq, 2);
 626     free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 627     qvirtqueue_add(vq, req_addr + 16, 512, false, true);
 628     qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 629     qvirtqueue_kick(dev, vq, free_head);
 630     write_head = free_head;
 631
 632     /* No notification expected */
 633     status = qvirtio_wait_status_byte_no_isr(dev,
 634                                              vq, req_addr + 528,
 635                                              QVIRTIO_BLK_TIMEOUT_US);
 636     g_assert_cmpint(status, ==, 0);
 637
 638     guest_free(t_alloc, req_addr);
 639
 640     /* Read request */
 641     req.type = VIRTIO_BLK_T_IN;
 642     req.ioprio = 1;
 643     req.sector = 1;
 644     req.data = g_malloc0(512);
 645
 646     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 647
 648     g_free(req.data);
 649
 650     free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
 651     qvirtqueue_add(vq, req_addr + 16, 512, true, true);
 652     qvirtqueue_add(vq, req_addr + 528, 1, true, false);
 653
 654     qvirtqueue_kick(dev, vq, free_head);
 655
 656     /* We get just one notification for both requests */
 657     qvirtio_wait_used_elem(dev, vq, write_head, NULL,
 658                            QVIRTIO_BLK_TIMEOUT_US);
 659     g_assert(qvirtqueue_get_buf(vq, &desc_idx, NULL));
 660     g_assert_cmpint(desc_idx, ==, free_head);
 661
 662     status = readb(req_addr + 528);
 663     g_assert_cmpint(status, ==, 0);
 664
 665     data = g_malloc0(512);
 666     memread(req_addr + 16, data, 512);
 667     g_assert_cmpstr(data, ==, "TEST");
 668     g_free(data);
 669
 670     guest_free(t_alloc, req_addr);
 671
 672     /* End test */
 673     qpci_msix_disable(pdev->pdev);
 674
 675     qvirtqueue_cleanup(dev->bus, vq, t_alloc);
 676 }
 677
 678 static void pci_hotplug(void *obj, void *data, QGuestAllocator *t_alloc)
 679 {
 680     QVirtioPCIDevice *dev1 = obj;
 681     QVirtioPCIDevice *dev;
 682
 683     /* plug secondary disk */
 684     qtest_qmp_device_add("virtio-blk-pci", "drv1",
 685                          "{'addr': %s, 'drive': 'drive1'}",
 686                          stringify(PCI_SLOT_HP) ".0");
 687
 688     dev = virtio_pci_new(dev1->pdev->bus,
 689                          &(QPCIAddress) { .devfn = QPCI_DEVFN(PCI_SLOT_HP, 0) });
 690     g_assert_nonnull(dev);
 691     g_assert_cmpint(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK);
 692     qvirtio_pci_device_disable(dev);
 693     qos_object_destroy((QOSGraphObject *)dev);
 694
 695     /* unplug secondary disk */
 696     qpci_unplug_acpi_device_test("drv1", PCI_SLOT_HP);
 697 }
 698
 699 /*
 700  * Check that setting the vring addr on a non-existent virtqueue does
 701  * not crash.
 702  */
 703 static void test_nonexistent_virtqueue(void *obj, void *data,
 704                                        QGuestAllocator *t_alloc)
 705 {
 706     QVirtioBlkPCI *blk = obj;
 707     QVirtioPCIDevice *pdev = &blk->pci_vdev;
 708     QPCIBar bar0;
 709     QPCIDevice *dev;
 710
 711     dev = qpci_device_find(pdev->pdev->bus, QPCI_DEVFN(4, 0));
 712     g_assert(dev != NULL);
 713     qpci_device_enable(dev);
 714
 715     bar0 = qpci_iomap(dev, 0, NULL);
 716
 717     qpci_io_writeb(dev, bar0, VIRTIO_PCI_QUEUE_SEL, 2);
 718     qpci_io_writel(dev, bar0, VIRTIO_PCI_QUEUE_PFN, 1);
 719
 720
 721     g_free(dev);
 722 }
 723
 724 static void resize(void *obj, void *data, QGuestAllocator *t_alloc)
 725 {
 726     QVirtioBlk *blk_if = obj;
 727     QVirtioDevice *dev = blk_if->vdev;
 728     int n_size = TEST_IMAGE_SIZE / 2;
 729     uint64_t capacity;
 730     QVirtQueue *vq;
 731
 732     vq = qvirtqueue_setup(dev, t_alloc, 0);
 733
 734     test_basic(dev, t_alloc, vq);
 735
 736     qmp_discard_response("{ 'execute': 'block_resize', "
 737                          " 'arguments': { 'device': 'drive0', "
 738                          " 'size': %d } }", n_size);
 739
 740     qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
 741
 742     capacity = qvirtio_config_readq(dev, 0);
 743     g_assert_cmpint(capacity, ==, n_size / 512);
 744
 745     qvirtqueue_cleanup(dev->bus, vq, t_alloc);
 746
 747 }
 748
 749 static void *virtio_blk_test_setup(GString *cmd_line, void *arg)
 750 {
 751     char *tmp_path = drive_create();
 752
 753     g_string_append_printf(cmd_line,
 754                            " -drive if=none,id=drive0,file=%s,format=raw,auto-read-only=off "
 755                            "-drive if=none,id=drive1,file=null-co://,format=raw ",
 756                            tmp_path);
 757
 758     return arg;
 759 }
 760
 761 static void register_virtio_blk_test(void)
 762 {
 763     QOSGraphTestOptions opts = {
 764         .before = virtio_blk_test_setup,
 765     };
 766
 767     qos_add_test("indirect", "virtio-blk", indirect, &opts);
 768     qos_add_test("config", "virtio-blk", config, &opts);
 769     qos_add_test("basic", "virtio-blk", basic, &opts);
 770     qos_add_test("resize", "virtio-blk", resize, &opts);
 771
 772     /* tests just for virtio-blk-pci */
 773     qos_add_test("msix", "virtio-blk-pci", msix, &opts);
 774     qos_add_test("idx", "virtio-blk-pci", idx, &opts);
 775     qos_add_test("nxvirtq", "virtio-blk-pci",
 776                       test_nonexistent_virtqueue, &opts);
 777     qos_add_test("hotplug", "virtio-blk-pci", pci_hotplug, &opts);
 778 }
 779
 780 libqos_init(register_virtio_blk_test);