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