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 #ifdef HOST_WORDS_BIGENDIAN
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     /* plug secondary disk */
680     qtest_qmp_device_add(qts, "vhost-user-blk-pci", "drv1",
681                          "{'addr': %s, 'chardev': 'char2'}",
682                          stringify(PCI_SLOT_HP) ".0");
683 
684     dev = virtio_pci_new(dev1->pdev->bus,
685                          &(QPCIAddress) { .devfn = QPCI_DEVFN(PCI_SLOT_HP, 0)
686                                         });
687     g_assert_nonnull(dev);
688     g_assert_cmpint(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK);
689     qvirtio_pci_device_disable(dev);
690     qos_object_destroy((QOSGraphObject *)dev);
691 
692     /* unplug secondary disk */
693     qpci_unplug_acpi_device_test(qts, "drv1", PCI_SLOT_HP);
694 }
695 
696 static void multiqueue(void *obj, void *data, QGuestAllocator *t_alloc)
697 {
698     QVirtioPCIDevice *pdev1 = obj;
699     QVirtioDevice *dev1 = &pdev1->vdev;
700     QVirtioPCIDevice *pdev8;
701     QVirtioDevice *dev8;
702     QTestState *qts = pdev1->pdev->bus->qts;
703     uint64_t features;
704     uint16_t num_queues;
705 
706     /*
707      * The primary device has 1 queue and VIRTIO_BLK_F_MQ is not enabled. The
708      * VIRTIO specification allows VIRTIO_BLK_F_MQ to be enabled when there is
709      * only 1 virtqueue, but --device vhost-user-blk-pci doesn't do this (which
710      * is also spec-compliant).
711      */
712     features = qvirtio_get_features(dev1);
713     g_assert_cmpint(features & (1u << VIRTIO_BLK_F_MQ), ==, 0);
714     features = features & ~(QVIRTIO_F_BAD_FEATURE |
715                             (1u << VIRTIO_RING_F_INDIRECT_DESC) |
716                             (1u << VIRTIO_F_NOTIFY_ON_EMPTY) |
717                             (1u << VIRTIO_BLK_F_SCSI));
718     qvirtio_set_features(dev1, features);
719 
720     /* Hotplug a secondary device with 8 queues */
721     qtest_qmp_device_add(qts, "vhost-user-blk-pci", "drv1",
722                          "{'addr': %s, 'chardev': 'char2', 'num-queues': 8}",
723                          stringify(PCI_SLOT_HP) ".0");
724 
725     pdev8 = virtio_pci_new(pdev1->pdev->bus,
726                            &(QPCIAddress) {
727                                .devfn = QPCI_DEVFN(PCI_SLOT_HP, 0)
728                            });
729     g_assert_nonnull(pdev8);
730     g_assert_cmpint(pdev8->vdev.device_type, ==, VIRTIO_ID_BLOCK);
731 
732     qos_object_start_hw(&pdev8->obj);
733 
734     dev8 = &pdev8->vdev;
735     features = qvirtio_get_features(dev8);
736     g_assert_cmpint(features & (1u << VIRTIO_BLK_F_MQ),
737                     ==,
738                     (1u << VIRTIO_BLK_F_MQ));
739     features = features & ~(QVIRTIO_F_BAD_FEATURE |
740                             (1u << VIRTIO_RING_F_INDIRECT_DESC) |
741                             (1u << VIRTIO_F_NOTIFY_ON_EMPTY) |
742                             (1u << VIRTIO_BLK_F_SCSI) |
743                             (1u << VIRTIO_BLK_F_MQ));
744     qvirtio_set_features(dev8, features);
745 
746     num_queues = qvirtio_config_readw(dev8,
747             offsetof(struct virtio_blk_config, num_queues));
748     g_assert_cmpint(num_queues, ==, 8);
749 
750     qvirtio_pci_device_disable(pdev8);
751     qos_object_destroy(&pdev8->obj);
752 
753     /* unplug secondary disk */
754     qpci_unplug_acpi_device_test(qts, "drv1", PCI_SLOT_HP);
755 }
756 
757 /*
758  * Check that setting the vring addr on a non-existent virtqueue does
759  * not crash.
760  */
761 static void test_nonexistent_virtqueue(void *obj, void *data,
762                                        QGuestAllocator *t_alloc)
763 {
764     QVhostUserBlkPCI *blk = obj;
765     QVirtioPCIDevice *pdev = &blk->pci_vdev;
766     QPCIBar bar0;
767     QPCIDevice *dev;
768 
769     dev = qpci_device_find(pdev->pdev->bus, QPCI_DEVFN(4, 0));
770     g_assert(dev != NULL);
771     qpci_device_enable(dev);
772 
773     bar0 = qpci_iomap(dev, 0, NULL);
774 
775     qpci_io_writeb(dev, bar0, VIRTIO_PCI_QUEUE_SEL, 2);
776     qpci_io_writel(dev, bar0, VIRTIO_PCI_QUEUE_PFN, 1);
777 
778     g_free(dev);
779 }
780 
781 static const char *qtest_qemu_storage_daemon_binary(void)
782 {
783     const char *qemu_storage_daemon_bin;
784 
785     qemu_storage_daemon_bin = getenv("QTEST_QEMU_STORAGE_DAEMON_BINARY");
786     if (!qemu_storage_daemon_bin) {
787         fprintf(stderr, "Environment variable "
788                         "QTEST_QEMU_STORAGE_DAEMON_BINARY required\n");
789         exit(0);
790     }
791 
792     /* If we've got a path to the binary, check whether we can access it */
793     if (strchr(qemu_storage_daemon_bin, '/') &&
794         access(qemu_storage_daemon_bin, X_OK) != 0) {
795         fprintf(stderr, "ERROR: '%s' is not accessible\n",
796                 qemu_storage_daemon_bin);
797         exit(1);
798     }
799 
800     return qemu_storage_daemon_bin;
801 }
802 
803 /* g_test_queue_destroy() cleanup function for files */
804 static void destroy_file(void *path)
805 {
806     unlink(path);
807     g_free(path);
808     qos_invalidate_command_line();
809 }
810 
811 static char *drive_create(void)
812 {
813     int fd, ret;
814     /** vhost-user-blk won't recognize drive located in /tmp */
815     char *t_path = g_strdup("qtest.XXXXXX");
816 
817     /** Create a temporary raw image */
818     fd = mkstemp(t_path);
819     g_assert_cmpint(fd, >=, 0);
820     ret = ftruncate(fd, TEST_IMAGE_SIZE);
821     g_assert_cmpint(ret, ==, 0);
822     close(fd);
823 
824     g_test_queue_destroy(destroy_file, t_path);
825     return t_path;
826 }
827 
828 static char *create_listen_socket(int *fd)
829 {
830     int tmp_fd;
831     char *path;
832 
833     /* No race because our pid makes the path unique */
834     path = g_strdup_printf("/tmp/qtest-%d-sock.XXXXXX", getpid());
835     tmp_fd = mkstemp(path);
836     g_assert_cmpint(tmp_fd, >=, 0);
837     close(tmp_fd);
838     unlink(path);
839 
840     *fd = qtest_socket_server(path);
841     g_test_queue_destroy(destroy_file, path);
842     return path;
843 }
844 
845 /*
846  * g_test_queue_destroy() and qtest_add_abrt_handler() cleanup function for
847  * qemu-storage-daemon.
848  */
849 static void quit_storage_daemon(void *data)
850 {
851     QemuStorageDaemonState *qsd = data;
852     int wstatus;
853     pid_t pid;
854 
855     /*
856      * If we were invoked as a g_test_queue_destroy() cleanup function we need
857      * to remove the abrt handler to avoid being called again if the code below
858      * aborts. Also, we must not leave the abrt handler installed after
859      * cleanup.
860      */
861     qtest_remove_abrt_handler(data);
862 
863     /* Before quitting storage-daemon, quit qemu to avoid dubious messages */
864     qtest_kill_qemu(global_qtest);
865 
866     kill(qsd->pid, SIGTERM);
867     pid = waitpid(qsd->pid, &wstatus, 0);
868     g_assert_cmpint(pid, ==, qsd->pid);
869     if (!WIFEXITED(wstatus)) {
870         fprintf(stderr, "%s: expected qemu-storage-daemon to exit\n",
871                 __func__);
872         abort();
873     }
874     if (WEXITSTATUS(wstatus) != 0) {
875         fprintf(stderr, "%s: expected qemu-storage-daemon to exit "
876                 "successfully, got %d\n",
877                 __func__, WEXITSTATUS(wstatus));
878         abort();
879     }
880 
881     g_free(data);
882 }
883 
884 static void start_vhost_user_blk(GString *cmd_line, int vus_instances,
885                                  int num_queues)
886 {
887     const char *vhost_user_blk_bin = qtest_qemu_storage_daemon_binary();
888     int i;
889     gchar *img_path;
890     GString *storage_daemon_command = g_string_new(NULL);
891     QemuStorageDaemonState *qsd;
892 
893     g_string_append_printf(storage_daemon_command,
894                            "exec %s ",
895                            vhost_user_blk_bin);
896 
897     g_string_append_printf(cmd_line,
898             " -object memory-backend-memfd,id=mem,size=256M,share=on "
899             " -M memory-backend=mem -m 256M ");
900 
901     for (i = 0; i < vus_instances; i++) {
902         int fd;
903         char *sock_path = create_listen_socket(&fd);
904 
905         /* create image file */
906         img_path = drive_create();
907         g_string_append_printf(storage_daemon_command,
908             "--blockdev driver=file,node-name=disk%d,filename=%s "
909             "--export type=vhost-user-blk,id=disk%d,addr.type=fd,addr.str=%d,"
910             "node-name=disk%i,writable=on,num-queues=%d ",
911             i, img_path, i, fd, i, num_queues);
912 
913         g_string_append_printf(cmd_line, "-chardev socket,id=char%d,path=%s ",
914                                i + 1, sock_path);
915     }
916 
917     g_test_message("starting vhost-user backend: %s",
918                    storage_daemon_command->str);
919     pid_t pid = fork();
920     if (pid == 0) {
921         /*
922          * Close standard file descriptors so tap-driver.pl pipe detects when
923          * our parent terminates.
924          */
925         close(0);
926         close(1);
927         open("/dev/null", O_RDONLY);
928         open("/dev/null", O_WRONLY);
929 
930         execlp("/bin/sh", "sh", "-c", storage_daemon_command->str, NULL);
931         exit(1);
932     }
933     g_string_free(storage_daemon_command, true);
934 
935     qsd = g_new(QemuStorageDaemonState, 1);
936     qsd->pid = pid;
937 
938     /* Make sure qemu-storage-daemon is stopped */
939     qtest_add_abrt_handler(quit_storage_daemon, qsd);
940     g_test_queue_destroy(quit_storage_daemon, qsd);
941 }
942 
943 static void *vhost_user_blk_test_setup(GString *cmd_line, void *arg)
944 {
945     start_vhost_user_blk(cmd_line, 1, 1);
946     return arg;
947 }
948 
949 /*
950  * Setup for hotplug.
951  *
952  * Since vhost-user server only serves one vhost-user client one time,
953  * another exprot
954  *
955  */
956 static void *vhost_user_blk_hotplug_test_setup(GString *cmd_line, void *arg)
957 {
958     /* "-chardev socket,id=char2" is used for pci_hotplug*/
959     start_vhost_user_blk(cmd_line, 2, 1);
960     return arg;
961 }
962 
963 static void *vhost_user_blk_multiqueue_test_setup(GString *cmd_line, void *arg)
964 {
965     start_vhost_user_blk(cmd_line, 2, 8);
966     return arg;
967 }
968 
969 static void register_vhost_user_blk_test(void)
970 {
971     QOSGraphTestOptions opts = {
972         .before = vhost_user_blk_test_setup,
973     };
974 
975     /*
976      * tests for vhost-user-blk and vhost-user-blk-pci
977      * The tests are borrowed from tests/virtio-blk-test.c. But some tests
978      * regarding block_resize don't work for vhost-user-blk.
979      * vhost-user-blk device doesn't have -drive, so tests containing
980      * block_resize are also abandoned,
981      *  - config
982      *  - resize
983      */
984     qos_add_test("basic", "vhost-user-blk", basic, &opts);
985     qos_add_test("indirect", "vhost-user-blk", indirect, &opts);
986     qos_add_test("idx", "vhost-user-blk-pci", idx, &opts);
987     qos_add_test("nxvirtq", "vhost-user-blk-pci",
988                  test_nonexistent_virtqueue, &opts);
989 
990     opts.before = vhost_user_blk_hotplug_test_setup;
991     qos_add_test("hotplug", "vhost-user-blk-pci", pci_hotplug, &opts);
992 
993     opts.before = vhost_user_blk_multiqueue_test_setup;
994     qos_add_test("multiqueue", "vhost-user-blk-pci", multiqueue, &opts);
995 }
996 
997 libqos_init(register_vhost_user_blk_test);
998