tests/qtest/vhost-user-blk-test.c

   1 /*
   2  * QTest testcase for Vhost-user Block Device
   3  *
   4  * Based on tests/qtest//virtio-blk-test.c
   5
   6  * Copyright (c) 2014 SUSE LINUX Products GmbH
   7  * Copyright (c) 2014 Marc Marí
   8  * Copyright (c) 2020 Coiby Xu
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  11  * See the COPYING file in the top-level directory.
  12  */
  13
  14 #include "qemu/osdep.h"
  15 #include "libqtest-single.h"
  16 #include "qemu/bswap.h"
  17 #include "qemu/module.h"
  18 #include "standard-headers/linux/virtio_blk.h"
  19 #include "standard-headers/linux/virtio_pci.h"
  20 #include "libqos/qgraph.h"
  21 #include "libqos/vhost-user-blk.h"
  22 #include "libqos/libqos-pc.h"
  23
  24 #define TEST_IMAGE_SIZE         (64 * 1024 * 1024)
  25 #define QVIRTIO_BLK_TIMEOUT_US  (30 * 1000 * 1000)
  26 #define PCI_SLOT_HP             0x06
  27
  28 typedef struct {
  29     pid_t pid;
  30 } QemuStorageDaemonState;
  31
  32 typedef struct QVirtioBlkReq {
  33     uint32_t type;
  34     uint32_t ioprio;
  35     uint64_t sector;
  36     char *data;
  37     uint8_t status;
  38 } QVirtioBlkReq;
  39
  40 #if HOST_BIG_ENDIAN
  41 static const bool host_is_big_endian = true;
  42 #else
  43 static const bool host_is_big_endian; /* false */
  44 #endif
  45
  46 static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
  47 {
  48     if (qvirtio_is_big_endian(d) != host_is_big_endian) {
  49         req->type = bswap32(req->type);
  50         req->ioprio = bswap32(req->ioprio);
  51         req->sector = bswap64(req->sector);
  52     }
  53 }
  54
  55 static inline void virtio_blk_fix_dwz_hdr(QVirtioDevice *d,
  56     struct virtio_blk_discard_write_zeroes *dwz_hdr)
  57 {
  58     if (qvirtio_is_big_endian(d) != host_is_big_endian) {
  59         dwz_hdr->sector = bswap64(dwz_hdr->sector);
  60         dwz_hdr->num_sectors = bswap32(dwz_hdr->num_sectors);
  61         dwz_hdr->flags = bswap32(dwz_hdr->flags);
  62     }
  63 }
  64
  65 static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
  66                                    QVirtioBlkReq *req, uint64_t data_size)
  67 {
  68     uint64_t addr;
  69     uint8_t status = 0xFF;
  70     QTestState *qts = global_qtest;
  71
  72     switch (req->type) {
  73     case VIRTIO_BLK_T_IN:
  74     case VIRTIO_BLK_T_OUT:
  75         g_assert_cmpuint(data_size % 512, ==, 0);
  76         break;
  77     case VIRTIO_BLK_T_DISCARD:
  78     case VIRTIO_BLK_T_WRITE_ZEROES:
  79         g_assert_cmpuint(data_size %
  80                          sizeof(struct virtio_blk_discard_write_zeroes), ==, 0);
  81         break;
  82     default:
  83         g_assert_cmpuint(data_size, ==, 0);
  84     }
  85
  86     addr = guest_alloc(alloc, sizeof(*req) + data_size);
  87
  88     virtio_blk_fix_request(d, req);
  89
  90     qtest_memwrite(qts, addr, req, 16);
  91     qtest_memwrite(qts, addr + 16, req->data, data_size);
  92     qtest_memwrite(qts, addr + 16 + data_size, &status, sizeof(status));
  93
  94     return addr;
  95 }
  96
  97 static void test_invalid_discard_write_zeroes(QVirtioDevice *dev,
  98                                               QGuestAllocator *alloc,
  99                                               QTestState *qts,
 100                                               QVirtQueue *vq,
 101                                               uint32_t type)
 102 {
 103     QVirtioBlkReq req;
 104     struct virtio_blk_discard_write_zeroes dwz_hdr;
 105     struct virtio_blk_discard_write_zeroes dwz_hdr2[2];
 106     uint64_t req_addr;
 107     uint32_t free_head;
 108     uint8_t status;
 109
 110     /* More than one dwz is not supported */
 111     req.type = type;
 112     req.data = (char *) dwz_hdr2;
 113     dwz_hdr2[0].sector = 0;
 114     dwz_hdr2[0].num_sectors = 1;
 115     dwz_hdr2[0].flags = 0;
 116     dwz_hdr2[1].sector = 1;
 117     dwz_hdr2[1].num_sectors = 1;
 118     dwz_hdr2[1].flags = 0;
 119
 120     virtio_blk_fix_dwz_hdr(dev, &dwz_hdr2[0]);
 121     virtio_blk_fix_dwz_hdr(dev, &dwz_hdr2[1]);
 122
 123     req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr2));
 124
 125     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 126     qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr2), false, true);
 127     qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr2), 1, true,
 128                    false);
 129
 130     qvirtqueue_kick(qts, dev, vq, free_head);
 131
 132     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 133                            QVIRTIO_BLK_TIMEOUT_US);
 134     status = readb(req_addr + 16 + sizeof(dwz_hdr2));
 135     g_assert_cmpint(status, ==, VIRTIO_BLK_S_UNSUPP);
 136
 137     guest_free(alloc, req_addr);
 138
 139     /* num_sectors must be less than config->max_write_zeroes_sectors */
 140     req.type = type;
 141     req.data = (char *) &dwz_hdr;
 142     dwz_hdr.sector = 0;
 143     dwz_hdr.num_sectors = 0xffffffff;
 144     dwz_hdr.flags = 0;
 145
 146     virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
 147
 148     req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
 149
 150     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 151     qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true);
 152     qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true,
 153                    false);
 154
 155     qvirtqueue_kick(qts, dev, vq, free_head);
 156
 157     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 158                            QVIRTIO_BLK_TIMEOUT_US);
 159     status = readb(req_addr + 16 + sizeof(dwz_hdr));
 160     g_assert_cmpint(status, ==, VIRTIO_BLK_S_IOERR);
 161
 162     guest_free(alloc, req_addr);
 163
 164     /* sector must be less than the device capacity */
 165     req.type = type;
 166     req.data = (char *) &dwz_hdr;
 167     dwz_hdr.sector = TEST_IMAGE_SIZE / 512 + 1;
 168     dwz_hdr.num_sectors = 1;
 169     dwz_hdr.flags = 0;
 170
 171     virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
 172
 173     req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
 174
 175     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 176     qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true);
 177     qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true,
 178                    false);
 179
 180     qvirtqueue_kick(qts, dev, vq, free_head);
 181
 182     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 183                            QVIRTIO_BLK_TIMEOUT_US);
 184     status = readb(req_addr + 16 + sizeof(dwz_hdr));
 185     g_assert_cmpint(status, ==, VIRTIO_BLK_S_IOERR);
 186
 187     guest_free(alloc, req_addr);
 188
 189     /* reserved flag bits must be zero */
 190     req.type = type;
 191     req.data = (char *) &dwz_hdr;
 192     dwz_hdr.sector = 0;
 193     dwz_hdr.num_sectors = 1;
 194     dwz_hdr.flags = ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP;
 195
 196     virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
 197
 198     req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
 199
 200     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 201     qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true);
 202     qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true,
 203                    false);
 204
 205     qvirtqueue_kick(qts, dev, vq, free_head);
 206
 207     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 208                            QVIRTIO_BLK_TIMEOUT_US);
 209     status = readb(req_addr + 16 + sizeof(dwz_hdr));
 210     g_assert_cmpint(status, ==, VIRTIO_BLK_S_UNSUPP);
 211
 212     guest_free(alloc, req_addr);
 213 }
 214
 215 /* Returns the request virtqueue so the caller can perform further tests */
 216 static QVirtQueue *test_basic(QVirtioDevice *dev, QGuestAllocator *alloc)
 217 {
 218     QVirtioBlkReq req;
 219     uint64_t req_addr;
 220     uint64_t capacity;
 221     uint64_t features;
 222     uint32_t free_head;
 223     uint8_t status;
 224     char *data;
 225     QTestState *qts = global_qtest;
 226     QVirtQueue *vq;
 227
 228     features = qvirtio_get_features(dev);
 229     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 230                     (1u << VIRTIO_RING_F_INDIRECT_DESC) |
 231                     (1u << VIRTIO_RING_F_EVENT_IDX) |
 232                     (1u << VIRTIO_BLK_F_SCSI));
 233     qvirtio_set_features(dev, features);
 234
 235     capacity = qvirtio_config_readq(dev, 0);
 236     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 237
 238     vq = qvirtqueue_setup(dev, alloc, 0);
 239
 240     qvirtio_set_driver_ok(dev);
 241
 242     /* Write and read with 3 descriptor layout */
 243     /* Write request */
 244     req.type = VIRTIO_BLK_T_OUT;
 245     req.ioprio = 1;
 246     req.sector = 0;
 247     req.data = g_malloc0(512);
 248     strcpy(req.data, "TEST");
 249
 250     req_addr = virtio_blk_request(alloc, dev, &req, 512);
 251
 252     g_free(req.data);
 253
 254     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 255     qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true);
 256     qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
 257
 258     qvirtqueue_kick(qts, dev, vq, free_head);
 259
 260     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 261                            QVIRTIO_BLK_TIMEOUT_US);
 262     status = readb(req_addr + 528);
 263     g_assert_cmpint(status, ==, 0);
 264
 265     guest_free(alloc, req_addr);
 266
 267     /* Read request */
 268     req.type = VIRTIO_BLK_T_IN;
 269     req.ioprio = 1;
 270     req.sector = 0;
 271     req.data = g_malloc0(512);
 272
 273     req_addr = virtio_blk_request(alloc, dev, &req, 512);
 274
 275     g_free(req.data);
 276
 277     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 278     qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true);
 279     qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
 280
 281     qvirtqueue_kick(qts, dev, vq, free_head);
 282
 283     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 284                            QVIRTIO_BLK_TIMEOUT_US);
 285     status = readb(req_addr + 528);
 286     g_assert_cmpint(status, ==, 0);
 287
 288     data = g_malloc0(512);
 289     qtest_memread(qts, req_addr + 16, data, 512);
 290     g_assert_cmpstr(data, ==, "TEST");
 291     g_free(data);
 292
 293     guest_free(alloc, req_addr);
 294
 295     if (features & (1u << VIRTIO_BLK_F_WRITE_ZEROES)) {
 296         struct virtio_blk_discard_write_zeroes dwz_hdr;
 297         void *expected;
 298
 299         /*
 300          * WRITE_ZEROES request on the same sector of previous test where
 301          * we wrote "TEST".
 302          */
 303         req.type = VIRTIO_BLK_T_WRITE_ZEROES;
 304         req.data = (char *) &dwz_hdr;
 305         dwz_hdr.sector = 0;
 306         dwz_hdr.num_sectors = 1;
 307         dwz_hdr.flags = 0;
 308
 309         virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
 310
 311         req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
 312
 313         free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 314         qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true);
 315         qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true,
 316                        false);
 317
 318         qvirtqueue_kick(qts, dev, vq, free_head);
 319
 320         qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 321                                QVIRTIO_BLK_TIMEOUT_US);
 322         status = readb(req_addr + 16 + sizeof(dwz_hdr));
 323         g_assert_cmpint(status, ==, 0);
 324
 325         guest_free(alloc, req_addr);
 326
 327         /* Read request to check if the sector contains all zeroes */
 328         req.type = VIRTIO_BLK_T_IN;
 329         req.ioprio = 1;
 330         req.sector = 0;
 331         req.data = g_malloc0(512);
 332
 333         req_addr = virtio_blk_request(alloc, dev, &req, 512);
 334
 335         g_free(req.data);
 336
 337         free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 338         qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true);
 339         qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
 340
 341         qvirtqueue_kick(qts, dev, vq, free_head);
 342
 343         qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 344                                QVIRTIO_BLK_TIMEOUT_US);
 345         status = readb(req_addr + 528);
 346         g_assert_cmpint(status, ==, 0);
 347
 348         data = g_malloc(512);
 349         expected = g_malloc0(512);
 350         qtest_memread(qts, req_addr + 16, data, 512);
 351         g_assert_cmpmem(data, 512, expected, 512);
 352         g_free(expected);
 353         g_free(data);
 354
 355         guest_free(alloc, req_addr);
 356
 357         test_invalid_discard_write_zeroes(dev, alloc, qts, vq,
 358                                           VIRTIO_BLK_T_WRITE_ZEROES);
 359     }
 360
 361     if (features & (1u << VIRTIO_BLK_F_DISCARD)) {
 362         struct virtio_blk_discard_write_zeroes dwz_hdr;
 363
 364         req.type = VIRTIO_BLK_T_DISCARD;
 365         req.data = (char *) &dwz_hdr;
 366         dwz_hdr.sector = 0;
 367         dwz_hdr.num_sectors = 1;
 368         dwz_hdr.flags = 0;
 369
 370         virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
 371
 372         req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
 373
 374         free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 375         qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true);
 376         qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr),
 377                        1, true, false);
 378
 379         qvirtqueue_kick(qts, dev, vq, free_head);
 380
 381         qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 382                                QVIRTIO_BLK_TIMEOUT_US);
 383         status = readb(req_addr + 16 + sizeof(dwz_hdr));
 384         g_assert_cmpint(status, ==, 0);
 385
 386         guest_free(alloc, req_addr);
 387
 388         test_invalid_discard_write_zeroes(dev, alloc, qts, vq,
 389                                           VIRTIO_BLK_T_DISCARD);
 390     }
 391
 392     if (features & (1u << VIRTIO_F_ANY_LAYOUT)) {
 393         /* Write and read with 2 descriptor layout */
 394         /* Write request */
 395         req.type = VIRTIO_BLK_T_OUT;
 396         req.ioprio = 1;
 397         req.sector = 1;
 398         req.data = g_malloc0(512);
 399         strcpy(req.data, "TEST");
 400
 401         req_addr = virtio_blk_request(alloc, dev, &req, 512);
 402
 403         g_free(req.data);
 404
 405         free_head = qvirtqueue_add(qts, vq, req_addr, 528, false, true);
 406         qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
 407         qvirtqueue_kick(qts, dev, vq, free_head);
 408
 409         qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 410                                QVIRTIO_BLK_TIMEOUT_US);
 411         status = readb(req_addr + 528);
 412         g_assert_cmpint(status, ==, 0);
 413
 414         guest_free(alloc, req_addr);
 415
 416         /* Read request */
 417         req.type = VIRTIO_BLK_T_IN;
 418         req.ioprio = 1;
 419         req.sector = 1;
 420         req.data = g_malloc0(512);
 421
 422         req_addr = virtio_blk_request(alloc, dev, &req, 512);
 423
 424         g_free(req.data);
 425
 426         free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 427         qvirtqueue_add(qts, vq, req_addr + 16, 513, true, false);
 428
 429         qvirtqueue_kick(qts, dev, vq, free_head);
 430
 431         qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 432                                QVIRTIO_BLK_TIMEOUT_US);
 433         status = readb(req_addr + 528);
 434         g_assert_cmpint(status, ==, 0);
 435
 436         data = g_malloc0(512);
 437         qtest_memread(qts, req_addr + 16, data, 512);
 438         g_assert_cmpstr(data, ==, "TEST");
 439         g_free(data);
 440
 441         guest_free(alloc, req_addr);
 442     }
 443
 444     return vq;
 445 }
 446
 447 static void basic(void *obj, void *data, QGuestAllocator *t_alloc)
 448 {
 449     QVhostUserBlk *blk_if = obj;
 450     QVirtQueue *vq;
 451
 452     vq = test_basic(blk_if->vdev, t_alloc);
 453     qvirtqueue_cleanup(blk_if->vdev->bus, vq, t_alloc);
 454
 455 }
 456
 457 static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc)
 458 {
 459     QVirtQueue *vq;
 460     QVhostUserBlk *blk_if = obj;
 461     QVirtioDevice *dev = blk_if->vdev;
 462     QVirtioBlkReq req;
 463     QVRingIndirectDesc *indirect;
 464     uint64_t req_addr;
 465     uint64_t capacity;
 466     uint64_t features;
 467     uint32_t free_head;
 468     uint8_t status;
 469     char *data;
 470     QTestState *qts = global_qtest;
 471
 472     features = qvirtio_get_features(dev);
 473     g_assert_cmphex(features & (1u << VIRTIO_RING_F_INDIRECT_DESC), !=, 0);
 474     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 475                             (1u << VIRTIO_RING_F_EVENT_IDX) |
 476                             (1u << VIRTIO_BLK_F_SCSI));
 477     qvirtio_set_features(dev, features);
 478
 479     capacity = qvirtio_config_readq(dev, 0);
 480     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 481
 482     vq = qvirtqueue_setup(dev, t_alloc, 0);
 483     qvirtio_set_driver_ok(dev);
 484
 485     /* Write request */
 486     req.type = VIRTIO_BLK_T_OUT;
 487     req.ioprio = 1;
 488     req.sector = 0;
 489     req.data = g_malloc0(512);
 490     strcpy(req.data, "TEST");
 491
 492     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 493
 494     g_free(req.data);
 495
 496     indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2);
 497     qvring_indirect_desc_add(dev, qts, indirect, req_addr, 528, false);
 498     qvring_indirect_desc_add(dev, qts, indirect, req_addr + 528, 1, true);
 499     free_head = qvirtqueue_add_indirect(qts, vq, indirect);
 500     qvirtqueue_kick(qts, dev, vq, free_head);
 501
 502     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 503                            QVIRTIO_BLK_TIMEOUT_US);
 504     status = readb(req_addr + 528);
 505     g_assert_cmpint(status, ==, 0);
 506
 507     g_free(indirect);
 508     guest_free(t_alloc, req_addr);
 509
 510     /* Read request */
 511     req.type = VIRTIO_BLK_T_IN;
 512     req.ioprio = 1;
 513     req.sector = 0;
 514     req.data = g_malloc0(512);
 515     strcpy(req.data, "TEST");
 516
 517     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 518
 519     g_free(req.data);
 520
 521     indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2);
 522     qvring_indirect_desc_add(dev, qts, indirect, req_addr, 16, false);
 523     qvring_indirect_desc_add(dev, qts, indirect, req_addr + 16, 513, true);
 524     free_head = qvirtqueue_add_indirect(qts, vq, indirect);
 525     qvirtqueue_kick(qts, dev, vq, free_head);
 526
 527     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 528                            QVIRTIO_BLK_TIMEOUT_US);
 529     status = readb(req_addr + 528);
 530     g_assert_cmpint(status, ==, 0);
 531
 532     data = g_malloc0(512);
 533     qtest_memread(qts, req_addr + 16, data, 512);
 534     g_assert_cmpstr(data, ==, "TEST");
 535     g_free(data);
 536
 537     g_free(indirect);
 538     guest_free(t_alloc, req_addr);
 539     qvirtqueue_cleanup(dev->bus, vq, t_alloc);
 540 }
 541
 542 static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc)
 543 {
 544     QVirtQueue *vq;
 545     QVhostUserBlkPCI *blk = obj;
 546     QVirtioPCIDevice *pdev = &blk->pci_vdev;
 547     QVirtioDevice *dev = &pdev->vdev;
 548     QVirtioBlkReq req;
 549     uint64_t req_addr;
 550     uint64_t capacity;
 551     uint64_t features;
 552     uint32_t free_head;
 553     uint32_t write_head;
 554     uint32_t desc_idx;
 555     uint8_t status;
 556     char *data;
 557     QOSGraphObject *blk_object = obj;
 558     QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device");
 559     QTestState *qts = global_qtest;
 560
 561     if (qpci_check_buggy_msi(pci_dev)) {
 562         return;
 563     }
 564
 565     qpci_msix_enable(pdev->pdev);
 566     qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0);
 567
 568     features = qvirtio_get_features(dev);
 569     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 570                             (1u << VIRTIO_RING_F_INDIRECT_DESC) |
 571                             (1u << VIRTIO_F_NOTIFY_ON_EMPTY) |
 572                             (1u << VIRTIO_BLK_F_SCSI));
 573     qvirtio_set_features(dev, features);
 574
 575     capacity = qvirtio_config_readq(dev, 0);
 576     g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
 577
 578     vq = qvirtqueue_setup(dev, t_alloc, 0);
 579     qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1);
 580
 581     qvirtio_set_driver_ok(dev);
 582
 583     /*
 584      * libvhost-user signals the call fd in VHOST_USER_SET_VRING_CALL, make
 585      * sure to wait for the isr here so we don't race and confuse it later on.
 586      */
 587     qvirtio_wait_queue_isr(qts, dev, vq, QVIRTIO_BLK_TIMEOUT_US);
 588
 589     /* Write request */
 590     req.type = VIRTIO_BLK_T_OUT;
 591     req.ioprio = 1;
 592     req.sector = 0;
 593     req.data = g_malloc0(512);
 594     strcpy(req.data, "TEST");
 595
 596     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 597
 598     g_free(req.data);
 599
 600     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 601     qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true);
 602     qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
 603     qvirtqueue_kick(qts, dev, vq, free_head);
 604
 605     qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
 606                            QVIRTIO_BLK_TIMEOUT_US);
 607
 608     /* Write request */
 609     req.type = VIRTIO_BLK_T_OUT;
 610     req.ioprio = 1;
 611     req.sector = 1;
 612     req.data = g_malloc0(512);
 613     strcpy(req.data, "TEST");
 614
 615     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 616
 617     g_free(req.data);
 618
 619     /* Notify after processing the third request */
 620     qvirtqueue_set_used_event(qts, vq, 2);
 621     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 622     qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true);
 623     qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
 624     qvirtqueue_kick(qts, dev, vq, free_head);
 625     write_head = free_head;
 626
 627     /* No notification expected */
 628     status = qvirtio_wait_status_byte_no_isr(qts, dev,
 629                                              vq, req_addr + 528,
 630                                              QVIRTIO_BLK_TIMEOUT_US);
 631     g_assert_cmpint(status, ==, 0);
 632
 633     guest_free(t_alloc, req_addr);
 634
 635     /* Read request */
 636     req.type = VIRTIO_BLK_T_IN;
 637     req.ioprio = 1;
 638     req.sector = 1;
 639     req.data = g_malloc0(512);
 640
 641     req_addr = virtio_blk_request(t_alloc, dev, &req, 512);
 642
 643     g_free(req.data);
 644
 645     free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true);
 646     qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true);
 647     qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false);
 648
 649     qvirtqueue_kick(qts, dev, vq, free_head);
 650
 651     /* We get just one notification for both requests */
 652     qvirtio_wait_used_elem(qts, dev, vq, write_head, NULL,
 653                            QVIRTIO_BLK_TIMEOUT_US);
 654     g_assert(qvirtqueue_get_buf(qts, vq, &desc_idx, NULL));
 655     g_assert_cmpint(desc_idx, ==, free_head);
 656
 657     status = readb(req_addr + 528);
 658     g_assert_cmpint(status, ==, 0);
 659
 660     data = g_malloc0(512);
 661     qtest_memread(qts, req_addr + 16, data, 512);
 662     g_assert_cmpstr(data, ==, "TEST");
 663     g_free(data);
 664
 665     guest_free(t_alloc, req_addr);
 666
 667     /* End test */
 668     qpci_msix_disable(pdev->pdev);
 669
 670     qvirtqueue_cleanup(dev->bus, vq, t_alloc);
 671 }
 672
 673 static void pci_hotplug(void *obj, void *data, QGuestAllocator *t_alloc)
 674 {
 675     QVirtioPCIDevice *dev1 = obj;
 676     QVirtioPCIDevice *dev;
 677     QTestState *qts = dev1->pdev->bus->qts;
 678
 679     if (dev1->pdev->bus->not_hotpluggable) {
 680         g_test_skip("pci bus does not support hotplug");
 681         return;
 682     }
 683
 684     /* plug secondary disk */
 685     qtest_qmp_device_add(qts, "vhost-user-blk-pci", "drv1",
 686                          "{'addr': %s, 'chardev': 'char2'}",
 687                          stringify(PCI_SLOT_HP) ".0");
 688
 689     dev = virtio_pci_new(dev1->pdev->bus,
 690                          &(QPCIAddress) { .devfn = QPCI_DEVFN(PCI_SLOT_HP, 0)
 691                                         });
 692     g_assert_nonnull(dev);
 693     g_assert_cmpint(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK);
 694     qvirtio_pci_device_disable(dev);
 695     qos_object_destroy((QOSGraphObject *)dev);
 696
 697     /* unplug secondary disk */
 698     qpci_unplug_acpi_device_test(qts, "drv1", PCI_SLOT_HP);
 699 }
 700
 701 static void multiqueue(void *obj, void *data, QGuestAllocator *t_alloc)
 702 {
 703     QVirtioPCIDevice *pdev1 = obj;
 704     QVirtioDevice *dev1 = &pdev1->vdev;
 705     QVirtioPCIDevice *pdev8;
 706     QVirtioDevice *dev8;
 707     QTestState *qts = pdev1->pdev->bus->qts;
 708     uint64_t features;
 709     uint16_t num_queues;
 710
 711     if (pdev1->pdev->bus->not_hotpluggable) {
 712         g_test_skip("bus pci.0 does not support hotplug");
 713         return;
 714     }
 715
 716     /*
 717      * The primary device has 1 queue and VIRTIO_BLK_F_MQ is not enabled. The
 718      * VIRTIO specification allows VIRTIO_BLK_F_MQ to be enabled when there is
 719      * only 1 virtqueue, but --device vhost-user-blk-pci doesn't do this (which
 720      * is also spec-compliant).
 721      */
 722     features = qvirtio_get_features(dev1);
 723     g_assert_cmpint(features & (1u << VIRTIO_BLK_F_MQ), ==, 0);
 724     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 725                             (1u << VIRTIO_RING_F_INDIRECT_DESC) |
 726                             (1u << VIRTIO_F_NOTIFY_ON_EMPTY) |
 727                             (1u << VIRTIO_BLK_F_SCSI));
 728     qvirtio_set_features(dev1, features);
 729
 730     /* Hotplug a secondary device with 8 queues */
 731     qtest_qmp_device_add(qts, "vhost-user-blk-pci", "drv1",
 732                          "{'addr': %s, 'chardev': 'char2', 'num-queues': 8}",
 733                          stringify(PCI_SLOT_HP) ".0");
 734
 735     pdev8 = virtio_pci_new(pdev1->pdev->bus,
 736                            &(QPCIAddress) {
 737                                .devfn = QPCI_DEVFN(PCI_SLOT_HP, 0)
 738                            });
 739     g_assert_nonnull(pdev8);
 740     g_assert_cmpint(pdev8->vdev.device_type, ==, VIRTIO_ID_BLOCK);
 741
 742     qos_object_start_hw(&pdev8->obj);
 743
 744     dev8 = &pdev8->vdev;
 745     features = qvirtio_get_features(dev8);
 746     g_assert_cmpint(features & (1u << VIRTIO_BLK_F_MQ),
 747                     ==,
 748                     (1u << VIRTIO_BLK_F_MQ));
 749     features = features & ~(QVIRTIO_F_BAD_FEATURE |
 750                             (1u << VIRTIO_RING_F_INDIRECT_DESC) |
 751                             (1u << VIRTIO_F_NOTIFY_ON_EMPTY) |
 752                             (1u << VIRTIO_BLK_F_SCSI) |
 753                             (1u << VIRTIO_BLK_F_MQ));
 754     qvirtio_set_features(dev8, features);
 755
 756     num_queues = qvirtio_config_readw(dev8,
 757             offsetof(struct virtio_blk_config, num_queues));
 758     g_assert_cmpint(num_queues, ==, 8);
 759
 760     qvirtio_pci_device_disable(pdev8);
 761     qos_object_destroy(&pdev8->obj);
 762
 763     /* unplug secondary disk */
 764     qpci_unplug_acpi_device_test(qts, "drv1", PCI_SLOT_HP);
 765 }
 766
 767 /*
 768  * Check that setting the vring addr on a non-existent virtqueue does
 769  * not crash.
 770  */
 771 static void test_nonexistent_virtqueue(void *obj, void *data,
 772                                        QGuestAllocator *t_alloc)
 773 {
 774     QVhostUserBlkPCI *blk = obj;
 775     QVirtioPCIDevice *pdev = &blk->pci_vdev;
 776     QPCIBar bar0;
 777     QPCIDevice *dev;
 778
 779     dev = qpci_device_find(pdev->pdev->bus, QPCI_DEVFN(4, 0));
 780     g_assert(dev != NULL);
 781     qpci_device_enable(dev);
 782
 783     bar0 = qpci_iomap(dev, 0, NULL);
 784
 785     qpci_io_writeb(dev, bar0, VIRTIO_PCI_QUEUE_SEL, 2);
 786     qpci_io_writel(dev, bar0, VIRTIO_PCI_QUEUE_PFN, 1);
 787
 788     g_free(dev);
 789 }
 790
 791 static const char *qtest_qemu_storage_daemon_binary(void)
 792 {
 793     const char *qemu_storage_daemon_bin;
 794
 795     qemu_storage_daemon_bin = getenv("QTEST_QEMU_STORAGE_DAEMON_BINARY");
 796     if (!qemu_storage_daemon_bin) {
 797         fprintf(stderr, "Environment variable "
 798                         "QTEST_QEMU_STORAGE_DAEMON_BINARY required\n");
 799         exit(0);
 800     }
 801
 802     /* If we've got a path to the binary, check whether we can access it */
 803     if (strchr(qemu_storage_daemon_bin, '/') &&
 804         access(qemu_storage_daemon_bin, X_OK) != 0) {
 805         fprintf(stderr, "ERROR: '%s' is not accessible\n",
 806                 qemu_storage_daemon_bin);
 807         exit(1);
 808     }
 809
 810     return qemu_storage_daemon_bin;
 811 }
 812
 813 /* g_test_queue_destroy() cleanup function for files */
 814 static void destroy_file(void *path)
 815 {
 816     unlink(path);
 817     g_free(path);
 818     qos_invalidate_command_line();
 819 }
 820
 821 static char *drive_create(void)
 822 {
 823     int fd, ret;
 824     /** vhost-user-blk won't recognize drive located in /tmp */
 825     char *t_path = g_strdup("qtest.XXXXXX");
 826
 827     /** Create a temporary raw image */
 828     fd = mkstemp(t_path);
 829     g_assert_cmpint(fd, >=, 0);
 830     ret = ftruncate(fd, TEST_IMAGE_SIZE);
 831     g_assert_cmpint(ret, ==, 0);
 832     close(fd);
 833
 834     g_test_queue_destroy(destroy_file, t_path);
 835     return t_path;
 836 }
 837
 838 static char *create_listen_socket(int *fd)
 839 {
 840     int tmp_fd;
 841     char *path;
 842
 843     /* No race because our pid makes the path unique */
 844     path = g_strdup_printf("%s/qtest-%d-sock.XXXXXX",
 845                            g_get_tmp_dir(), getpid());
 846     tmp_fd = mkstemp(path);
 847     g_assert_cmpint(tmp_fd, >=, 0);
 848     close(tmp_fd);
 849     unlink(path);
 850
 851     *fd = qtest_socket_server(path);
 852     g_test_queue_destroy(destroy_file, path);
 853     return path;
 854 }
 855
 856 /*
 857  * g_test_queue_destroy() and qtest_add_abrt_handler() cleanup function for
 858  * qemu-storage-daemon.
 859  */
 860 static void quit_storage_daemon(void *data)
 861 {
 862     QemuStorageDaemonState *qsd = data;
 863     int wstatus;
 864     pid_t pid;
 865
 866     /*
 867      * If we were invoked as a g_test_queue_destroy() cleanup function we need
 868      * to remove the abrt handler to avoid being called again if the code below
 869      * aborts. Also, we must not leave the abrt handler installed after
 870      * cleanup.
 871      */
 872     qtest_remove_abrt_handler(data);
 873
 874     /* Before quitting storage-daemon, quit qemu to avoid dubious messages */
 875     qtest_kill_qemu(global_qtest);
 876
 877     kill(qsd->pid, SIGTERM);
 878     pid = waitpid(qsd->pid, &wstatus, 0);
 879     g_assert_cmpint(pid, ==, qsd->pid);
 880     if (!WIFEXITED(wstatus)) {
 881         fprintf(stderr, "%s: expected qemu-storage-daemon to exit\n",
 882                 __func__);
 883         abort();
 884     }
 885     if (WEXITSTATUS(wstatus) != 0) {
 886         fprintf(stderr, "%s: expected qemu-storage-daemon to exit "
 887                 "successfully, got %d\n",
 888                 __func__, WEXITSTATUS(wstatus));
 889         abort();
 890     }
 891
 892     g_free(data);
 893 }
 894
 895 static void start_vhost_user_blk(GString *cmd_line, int vus_instances,
 896                                  int num_queues)
 897 {
 898     const char *vhost_user_blk_bin = qtest_qemu_storage_daemon_binary();
 899     int i;
 900     gchar *img_path;
 901     GString *storage_daemon_command = g_string_new(NULL);
 902     QemuStorageDaemonState *qsd;
 903
 904     g_string_append_printf(storage_daemon_command,
 905                            "exec %s ",
 906                            vhost_user_blk_bin);
 907
 908     g_string_append_printf(cmd_line,
 909             " -object memory-backend-shm,id=mem,size=256M "
 910             " -M memory-backend=mem -m 256M ");
 911
 912     for (i = 0; i < vus_instances; i++) {
 913         int fd;
 914         char *sock_path = create_listen_socket(&fd);
 915
 916         /* create image file */
 917         img_path = drive_create();
 918         g_string_append_printf(storage_daemon_command,
 919             "--blockdev driver=file,node-name=disk%d,filename=%s "
 920             "--export type=vhost-user-blk,id=disk%d,addr.type=fd,addr.str=%d,"
 921             "node-name=disk%i,writable=on,num-queues=%d ",
 922             i, img_path, i, fd, i, num_queues);
 923
 924         g_string_append_printf(cmd_line, "-chardev socket,id=char%d,path=%s ",
 925                                i + 1, sock_path);
 926     }
 927
 928     g_test_message("starting vhost-user backend: %s",
 929                    storage_daemon_command->str);
 930     pid_t pid = fork();
 931     if (pid == 0) {
 932         /*
 933          * Close standard file descriptors so tap-driver.pl pipe detects when
 934          * our parent terminates.
 935          */
 936         close(0);
 937         close(1);
 938         open("/dev/null", O_RDONLY);
 939         open("/dev/null", O_WRONLY);
 940
 941         execlp("/bin/sh", "sh", "-c", storage_daemon_command->str, NULL);
 942         exit(1);
 943     }
 944     g_string_free(storage_daemon_command, true);
 945
 946     qsd = g_new(QemuStorageDaemonState, 1);
 947     qsd->pid = pid;
 948
 949     /* Make sure qemu-storage-daemon is stopped */
 950     qtest_add_abrt_handler(quit_storage_daemon, qsd);
 951     g_test_queue_destroy(quit_storage_daemon, qsd);
 952 }
 953
 954 static void *vhost_user_blk_test_setup(GString *cmd_line, void *arg)
 955 {
 956     start_vhost_user_blk(cmd_line, 1, 1);
 957     return arg;
 958 }
 959
 960 /*
 961  * Setup for hotplug.
 962  *
 963  * Since vhost-user server only serves one vhost-user client one time,
 964  * another export
 965  *
 966  */
 967 static void *vhost_user_blk_hotplug_test_setup(GString *cmd_line, void *arg)
 968 {
 969     /* "-chardev socket,id=char2" is used for pci_hotplug*/
 970     start_vhost_user_blk(cmd_line, 2, 1);
 971     return arg;
 972 }
 973
 974 static void *vhost_user_blk_multiqueue_test_setup(GString *cmd_line, void *arg)
 975 {
 976     start_vhost_user_blk(cmd_line, 2, 8);
 977     return arg;
 978 }
 979
 980 static void register_vhost_user_blk_test(void)
 981 {
 982     QOSGraphTestOptions opts = {
 983         .before = vhost_user_blk_test_setup,
 984     };
 985
 986     if (!getenv("QTEST_QEMU_STORAGE_DAEMON_BINARY")) {
 987         g_test_message("QTEST_QEMU_STORAGE_DAEMON_BINARY not defined, "
 988                        "skipping vhost-user-blk-test");
 989         return;
 990     }
 991
 992     /*
 993      * tests for vhost-user-blk and vhost-user-blk-pci
 994      * The tests are borrowed from tests/virtio-blk-test.c. But some tests
 995      * regarding block_resize don't work for vhost-user-blk.
 996      * vhost-user-blk device doesn't have -drive, so tests containing
 997      * block_resize are also abandoned,
 998      *  - config
 999      *  - resize
1000      */
1001     qos_add_test("basic", "vhost-user-blk", basic, &opts);
1002     qos_add_test("indirect", "vhost-user-blk", indirect, &opts);
1003     qos_add_test("idx", "vhost-user-blk-pci", idx, &opts);
1004     qos_add_test("nxvirtq", "vhost-user-blk-pci",
1005                  test_nonexistent_virtqueue, &opts);
1006
1007     opts.before = vhost_user_blk_hotplug_test_setup;
1008     qos_add_test("hotplug", "vhost-user-blk-pci", pci_hotplug, &opts);
1009
1010     opts.before = vhost_user_blk_multiqueue_test_setup;
1011     qos_add_test("multiqueue", "vhost-user-blk-pci", multiqueue, &opts);
1012 }
1013
1014 libqos_init(register_vhost_user_blk_test);