]>
Commit | Line | Data |
---|---|---|
c7a59bed AF |
1 | /* |
2 | * QTest testcase for VirtIO Block Device | |
3 | * | |
4 | * Copyright (c) 2014 SUSE LINUX Products GmbH | |
311e666a | 5 | * Copyright (c) 2014 Marc Marí |
c7a59bed AF |
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 | ||
681c28a3 | 11 | #include "qemu/osdep.h" |
dd210749 | 12 | #include "libqtest-single.h" |
bf3c63d2 | 13 | #include "qemu/bswap.h" |
0b8fa32f | 14 | #include "qemu/module.h" |
4565a3e0 | 15 | #include "standard-headers/linux/virtio_blk.h" |
c75f4c06 | 16 | #include "standard-headers/linux/virtio_pci.h" |
5cb8f0db PB |
17 | #include "libqos/qgraph.h" |
18 | #include "libqos/virtio-blk.h" | |
bf3c63d2 | 19 | |
055a1efc MA |
20 | /* TODO actually test the results and get rid of this */ |
21 | #define qmp_discard_response(...) qobject_unref(qmp(__VA_ARGS__)) | |
22 | ||
bf3c63d2 | 23 | #define TEST_IMAGE_SIZE (64 * 1024 * 1024) |
e8c81b4d | 24 | #define QVIRTIO_BLK_TIMEOUT_US (30 * 1000 * 1000) |
0a6ed700 | 25 | #define PCI_SLOT_HP 0x06 |
aaf36070 | 26 | |
bf3c63d2 MM |
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; | |
311e666a | 34 | |
5cb8f0db | 35 | |
ca1a9804 SG |
36 | #ifdef HOST_WORDS_BIGENDIAN |
37 | const bool host_is_big_endian = true; | |
38 | #else | |
39 | const bool host_is_big_endian; /* false */ | |
40 | #endif | |
41 | ||
5cb8f0db PB |
42 | static void drive_destroy(void *path) |
43 | { | |
44 | unlink(path); | |
45 | g_free(path); | |
46 | qos_invalidate_command_line(); | |
47 | } | |
48 | ||
38d8364f | 49 | static char *drive_create(void) |
c7a59bed | 50 | { |
311e666a | 51 | int fd, ret; |
5cb8f0db | 52 | char *t_path = g_strdup("/tmp/qtest.XXXXXX"); |
311e666a MM |
53 | |
54 | /* Create a temporary raw image */ | |
5cb8f0db | 55 | fd = mkstemp(t_path); |
311e666a MM |
56 | g_assert_cmpint(fd, >=, 0); |
57 | ret = ftruncate(fd, TEST_IMAGE_SIZE); | |
58 | g_assert_cmpint(ret, ==, 0); | |
59 | close(fd); | |
60 | ||
5cb8f0db PB |
61 | g_test_queue_destroy(drive_destroy, t_path); |
62 | return t_path; | |
46e0cf76 MM |
63 | } |
64 | ||
8b4b80c3 | 65 | static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req) |
bf3c63d2 | 66 | { |
8b4b80c3 | 67 | if (qvirtio_is_big_endian(d) != host_is_big_endian) { |
bf3c63d2 MM |
68 | req->type = bswap32(req->type); |
69 | req->ioprio = bswap32(req->ioprio); | |
70 | req->sector = bswap64(req->sector); | |
71 | } | |
72 | } | |
73 | ||
ca1a9804 SG |
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 | ||
8b4b80c3 LV |
85 | static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d, |
86 | QVirtioBlkReq *req, uint64_t data_size) | |
bf3c63d2 MM |
87 | { |
88 | uint64_t addr; | |
89 | uint8_t status = 0xFF; | |
90 | ||
f6cd8a63 SG |
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 | ||
bf3c63d2 MM |
105 | addr = guest_alloc(alloc, sizeof(*req) + data_size); |
106 | ||
8b4b80c3 | 107 | virtio_blk_fix_request(d, req); |
bf3c63d2 MM |
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 | ||
36d27d21 SH |
116 | /* Returns the request virtqueue so the caller can perform further tests */ |
117 | static QVirtQueue *test_basic(QVirtioDevice *dev, QGuestAllocator *alloc) | |
46e0cf76 | 118 | { |
bf3c63d2 | 119 | QVirtioBlkReq req; |
bf3c63d2 | 120 | uint64_t req_addr; |
46e0cf76 | 121 | uint64_t capacity; |
a9340358 | 122 | uint64_t features; |
bf3c63d2 MM |
123 | uint32_t free_head; |
124 | uint8_t status; | |
125 | char *data; | |
1999a70a | 126 | QTestState *qts = global_qtest; |
36d27d21 | 127 | QVirtQueue *vq; |
46e0cf76 | 128 | |
6b9cdf4c | 129 | features = qvirtio_get_features(dev); |
bf3c63d2 | 130 | features = features & ~(QVIRTIO_F_BAD_FEATURE | |
ee3b850a SH |
131 | (1u << VIRTIO_RING_F_INDIRECT_DESC) | |
132 | (1u << VIRTIO_RING_F_EVENT_IDX) | | |
4565a3e0 | 133 | (1u << VIRTIO_BLK_F_SCSI)); |
6b9cdf4c | 134 | qvirtio_set_features(dev, features); |
bf3c63d2 | 135 | |
c42bf5f2 SH |
136 | capacity = qvirtio_config_readq(dev, 0); |
137 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); | |
138 | ||
36d27d21 SH |
139 | vq = qvirtqueue_setup(dev, alloc, 0); |
140 | ||
6b9cdf4c | 141 | qvirtio_set_driver_ok(dev); |
bf3c63d2 | 142 | |
9b7d2d8b | 143 | /* Write and read with 3 descriptor layout */ |
bf3c63d2 | 144 | /* Write request */ |
4565a3e0 | 145 | req.type = VIRTIO_BLK_T_OUT; |
bf3c63d2 MM |
146 | req.ioprio = 1; |
147 | req.sector = 0; | |
148 | req.data = g_malloc0(512); | |
149 | strcpy(req.data, "TEST"); | |
150 | ||
8b4b80c3 | 151 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 MM |
152 | |
153 | g_free(req.data); | |
154 | ||
1999a70a TH |
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); | |
9b7d2d8b | 158 | |
1999a70a | 159 | qvirtqueue_kick(qts, dev, vq, free_head); |
bf3c63d2 | 160 | |
1999a70a TH |
161 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
162 | QVIRTIO_BLK_TIMEOUT_US); | |
bf3c63d2 MM |
163 | status = readb(req_addr + 528); |
164 | g_assert_cmpint(status, ==, 0); | |
165 | ||
166 | guest_free(alloc, req_addr); | |
167 | ||
168 | /* Read request */ | |
4565a3e0 | 169 | req.type = VIRTIO_BLK_T_IN; |
bf3c63d2 MM |
170 | req.ioprio = 1; |
171 | req.sector = 0; | |
172 | req.data = g_malloc0(512); | |
173 | ||
8b4b80c3 | 174 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 MM |
175 | |
176 | g_free(req.data); | |
177 | ||
1999a70a TH |
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); | |
bf3c63d2 | 181 | |
1999a70a | 182 | qvirtqueue_kick(qts, dev, vq, free_head); |
bf3c63d2 | 183 | |
1999a70a TH |
184 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
185 | QVIRTIO_BLK_TIMEOUT_US); | |
bf3c63d2 MM |
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 | ||
06879094 SG |
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 | ||
1999a70a TH |
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); | |
06879094 | 218 | |
1999a70a | 219 | qvirtqueue_kick(qts, dev, vq, free_head); |
06879094 | 220 | |
1999a70a | 221 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
06879094 SG |
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 | ||
1999a70a TH |
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); | |
06879094 | 241 | |
1999a70a | 242 | qvirtqueue_kick(qts, dev, vq, free_head); |
06879094 | 243 | |
1999a70a | 244 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
06879094 SG |
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 | ||
9a9f4b74 SG |
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 | ||
1999a70a TH |
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); | |
9a9f4b74 | 275 | |
1999a70a | 276 | qvirtqueue_kick(qts, dev, vq, free_head); |
9a9f4b74 | 277 | |
1999a70a | 278 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
9a9f4b74 SG |
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 | ||
1373a4c2 | 286 | if (features & (1u << VIRTIO_F_ANY_LAYOUT)) { |
9b7d2d8b MM |
287 | /* Write and read with 2 descriptor layout */ |
288 | /* Write request */ | |
4565a3e0 | 289 | req.type = VIRTIO_BLK_T_OUT; |
9b7d2d8b MM |
290 | req.ioprio = 1; |
291 | req.sector = 1; | |
292 | req.data = g_malloc0(512); | |
293 | strcpy(req.data, "TEST"); | |
bf3c63d2 | 294 | |
8b4b80c3 | 295 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 | 296 | |
9b7d2d8b | 297 | g_free(req.data); |
bf3c63d2 | 298 | |
1999a70a TH |
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); | |
38d8364f | 302 | |
1999a70a | 303 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
be3a6781 | 304 | QVIRTIO_BLK_TIMEOUT_US); |
9b7d2d8b MM |
305 | status = readb(req_addr + 528); |
306 | g_assert_cmpint(status, ==, 0); | |
bf3c63d2 | 307 | |
9b7d2d8b | 308 | guest_free(alloc, req_addr); |
bf3c63d2 | 309 | |
9b7d2d8b | 310 | /* Read request */ |
4565a3e0 | 311 | req.type = VIRTIO_BLK_T_IN; |
9b7d2d8b MM |
312 | req.ioprio = 1; |
313 | req.sector = 1; | |
314 | req.data = g_malloc0(512); | |
bf3c63d2 | 315 | |
8b4b80c3 | 316 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 | 317 | |
9b7d2d8b | 318 | g_free(req.data); |
bf3c63d2 | 319 | |
1999a70a TH |
320 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
321 | qvirtqueue_add(qts, vq, req_addr + 16, 513, true, false); | |
bf3c63d2 | 322 | |
1999a70a | 323 | qvirtqueue_kick(qts, dev, vq, free_head); |
bf3c63d2 | 324 | |
1999a70a | 325 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
be3a6781 | 326 | QVIRTIO_BLK_TIMEOUT_US); |
9b7d2d8b MM |
327 | status = readb(req_addr + 528); |
328 | g_assert_cmpint(status, ==, 0); | |
bf3c63d2 | 329 | |
9b7d2d8b MM |
330 | data = g_malloc0(512); |
331 | memread(req_addr + 16, data, 512); | |
332 | g_assert_cmpstr(data, ==, "TEST"); | |
333 | g_free(data); | |
bf3c63d2 | 334 | |
9b7d2d8b MM |
335 | guest_free(alloc, req_addr); |
336 | } | |
36d27d21 SH |
337 | |
338 | return vq; | |
38d8364f MM |
339 | } |
340 | ||
5cb8f0db | 341 | static void basic(void *obj, void *data, QGuestAllocator *t_alloc) |
38d8364f | 342 | { |
5cb8f0db PB |
343 | QVirtioBlk *blk_if = obj; |
344 | QVirtQueue *vq; | |
36d27d21 SH |
345 | |
346 | vq = test_basic(blk_if->vdev, t_alloc); | |
5cb8f0db | 347 | qvirtqueue_cleanup(blk_if->vdev->bus, vq, t_alloc); |
bf3c63d2 | 348 | |
c7a59bed AF |
349 | } |
350 | ||
5cb8f0db | 351 | static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc) |
f294b029 | 352 | { |
5cb8f0db PB |
353 | QVirtQueue *vq; |
354 | QVirtioBlk *blk_if = obj; | |
355 | QVirtioDevice *dev = blk_if->vdev; | |
f294b029 MM |
356 | QVirtioBlkReq req; |
357 | QVRingIndirectDesc *indirect; | |
f294b029 MM |
358 | uint64_t req_addr; |
359 | uint64_t capacity; | |
a9340358 | 360 | uint64_t features; |
f294b029 MM |
361 | uint32_t free_head; |
362 | uint8_t status; | |
363 | char *data; | |
1999a70a | 364 | QTestState *qts = global_qtest; |
f294b029 | 365 | |
5cb8f0db | 366 | features = qvirtio_get_features(dev); |
ee3b850a SH |
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) | | |
4565a3e0 | 370 | (1u << VIRTIO_BLK_F_SCSI)); |
5cb8f0db | 371 | qvirtio_set_features(dev, features); |
f294b029 | 372 | |
c42bf5f2 SH |
373 | capacity = qvirtio_config_readq(dev, 0); |
374 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); | |
375 | ||
5cb8f0db PB |
376 | vq = qvirtqueue_setup(dev, t_alloc, 0); |
377 | qvirtio_set_driver_ok(dev); | |
f294b029 MM |
378 | |
379 | /* Write request */ | |
4565a3e0 | 380 | req.type = VIRTIO_BLK_T_OUT; |
f294b029 MM |
381 | req.ioprio = 1; |
382 | req.sector = 0; | |
383 | req.data = g_malloc0(512); | |
384 | strcpy(req.data, "TEST"); | |
385 | ||
5cb8f0db | 386 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
f294b029 MM |
387 | |
388 | g_free(req.data); | |
389 | ||
1999a70a | 390 | indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2); |
bccd82b4 SH |
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); | |
1999a70a TH |
393 | free_head = qvirtqueue_add_indirect(qts, vq, indirect); |
394 | qvirtqueue_kick(qts, dev, vq, free_head); | |
f294b029 | 395 | |
1999a70a | 396 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 397 | QVIRTIO_BLK_TIMEOUT_US); |
f294b029 MM |
398 | status = readb(req_addr + 528); |
399 | g_assert_cmpint(status, ==, 0); | |
400 | ||
401 | g_free(indirect); | |
5cb8f0db | 402 | guest_free(t_alloc, req_addr); |
f294b029 MM |
403 | |
404 | /* Read request */ | |
4565a3e0 | 405 | req.type = VIRTIO_BLK_T_IN; |
f294b029 MM |
406 | req.ioprio = 1; |
407 | req.sector = 0; | |
408 | req.data = g_malloc0(512); | |
409 | strcpy(req.data, "TEST"); | |
410 | ||
5cb8f0db | 411 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
f294b029 MM |
412 | |
413 | g_free(req.data); | |
414 | ||
1999a70a | 415 | indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2); |
bccd82b4 SH |
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); | |
1999a70a TH |
418 | free_head = qvirtqueue_add_indirect(qts, vq, indirect); |
419 | qvirtqueue_kick(qts, dev, vq, free_head); | |
f294b029 | 420 | |
1999a70a | 421 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 422 | QVIRTIO_BLK_TIMEOUT_US); |
f294b029 MM |
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); | |
5cb8f0db PB |
432 | guest_free(t_alloc, req_addr); |
433 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); | |
f294b029 MM |
434 | } |
435 | ||
5cb8f0db | 436 | static void config(void *obj, void *data, QGuestAllocator *t_alloc) |
e1119955 | 437 | { |
5cb8f0db PB |
438 | QVirtioBlk *blk_if = obj; |
439 | QVirtioDevice *dev = blk_if->vdev; | |
e1119955 | 440 | int n_size = TEST_IMAGE_SIZE / 2; |
c42bf5f2 | 441 | uint64_t features; |
e1119955 MM |
442 | uint64_t capacity; |
443 | ||
c42bf5f2 SH |
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 | ||
5cb8f0db | 451 | capacity = qvirtio_config_readq(dev, 0); |
e1119955 MM |
452 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); |
453 | ||
5cb8f0db | 454 | qvirtio_set_driver_ok(dev); |
e1119955 | 455 | |
dc491fea MAL |
456 | qmp_discard_response("{ 'execute': 'block_resize', " |
457 | " 'arguments': { 'device': 'drive0', " | |
458 | " 'size': %d } }", n_size); | |
5cb8f0db | 459 | qvirtio_wait_config_isr(dev, QVIRTIO_BLK_TIMEOUT_US); |
e1119955 | 460 | |
5cb8f0db | 461 | capacity = qvirtio_config_readq(dev, 0); |
e1119955 | 462 | g_assert_cmpint(capacity, ==, n_size / 512); |
e1119955 MM |
463 | } |
464 | ||
5cb8f0db | 465 | static void msix(void *obj, void *u_data, QGuestAllocator *t_alloc) |
58368113 | 466 | { |
5cb8f0db PB |
467 | QVirtQueue *vq; |
468 | QVirtioBlkPCI *blk = obj; | |
469 | QVirtioPCIDevice *pdev = &blk->pci_vdev; | |
470 | QVirtioDevice *dev = &pdev->vdev; | |
58368113 MM |
471 | QVirtioBlkReq req; |
472 | int n_size = TEST_IMAGE_SIZE / 2; | |
58368113 MM |
473 | uint64_t req_addr; |
474 | uint64_t capacity; | |
a9340358 | 475 | uint64_t features; |
58368113 MM |
476 | uint32_t free_head; |
477 | uint8_t status; | |
478 | char *data; | |
5cb8f0db PB |
479 | QOSGraphObject *blk_object = obj; |
480 | QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device"); | |
1999a70a | 481 | QTestState *qts = global_qtest; |
58368113 | 482 | |
5cb8f0db PB |
483 | if (qpci_check_buggy_msi(pci_dev)) { |
484 | return; | |
485 | } | |
58368113 | 486 | |
5cb8f0db PB |
487 | qpci_msix_enable(pdev->pdev); |
488 | qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0); | |
58368113 | 489 | |
5cb8f0db | 490 | features = qvirtio_get_features(dev); |
58368113 | 491 | features = features & ~(QVIRTIO_F_BAD_FEATURE | |
ee3b850a SH |
492 | (1u << VIRTIO_RING_F_INDIRECT_DESC) | |
493 | (1u << VIRTIO_RING_F_EVENT_IDX) | | |
4565a3e0 | 494 | (1u << VIRTIO_BLK_F_SCSI)); |
5cb8f0db | 495 | qvirtio_set_features(dev, features); |
58368113 | 496 | |
c42bf5f2 SH |
497 | capacity = qvirtio_config_readq(dev, 0); |
498 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); | |
499 | ||
5cb8f0db PB |
500 | vq = qvirtqueue_setup(dev, t_alloc, 0); |
501 | qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1); | |
58368113 | 502 | |
5cb8f0db | 503 | qvirtio_set_driver_ok(dev); |
58368113 | 504 | |
dc491fea MAL |
505 | qmp_discard_response("{ 'execute': 'block_resize', " |
506 | " 'arguments': { 'device': 'drive0', " | |
507 | " 'size': %d } }", n_size); | |
58368113 | 508 | |
5cb8f0db | 509 | qvirtio_wait_config_isr(dev, QVIRTIO_BLK_TIMEOUT_US); |
58368113 | 510 | |
5cb8f0db | 511 | capacity = qvirtio_config_readq(dev, 0); |
58368113 MM |
512 | g_assert_cmpint(capacity, ==, n_size / 512); |
513 | ||
514 | /* Write request */ | |
4565a3e0 | 515 | req.type = VIRTIO_BLK_T_OUT; |
58368113 MM |
516 | req.ioprio = 1; |
517 | req.sector = 0; | |
518 | req.data = g_malloc0(512); | |
519 | strcpy(req.data, "TEST"); | |
520 | ||
5cb8f0db | 521 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
58368113 MM |
522 | |
523 | g_free(req.data); | |
524 | ||
1999a70a TH |
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); | |
58368113 | 529 | |
1999a70a | 530 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 531 | QVIRTIO_BLK_TIMEOUT_US); |
58368113 MM |
532 | |
533 | status = readb(req_addr + 528); | |
534 | g_assert_cmpint(status, ==, 0); | |
535 | ||
5cb8f0db | 536 | guest_free(t_alloc, req_addr); |
58368113 MM |
537 | |
538 | /* Read request */ | |
4565a3e0 | 539 | req.type = VIRTIO_BLK_T_IN; |
58368113 MM |
540 | req.ioprio = 1; |
541 | req.sector = 0; | |
542 | req.data = g_malloc0(512); | |
543 | ||
5cb8f0db | 544 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
58368113 MM |
545 | |
546 | g_free(req.data); | |
547 | ||
1999a70a TH |
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); | |
58368113 | 551 | |
1999a70a | 552 | qvirtqueue_kick(qts, dev, vq, free_head); |
58368113 | 553 | |
1053587c | 554 | |
1999a70a | 555 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 556 | QVIRTIO_BLK_TIMEOUT_US); |
1053587c MM |
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 | ||
5cb8f0db | 566 | guest_free(t_alloc, req_addr); |
1053587c MM |
567 | |
568 | /* End test */ | |
5cb8f0db PB |
569 | qpci_msix_disable(pdev->pdev); |
570 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); | |
1053587c MM |
571 | } |
572 | ||
5cb8f0db | 573 | static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc) |
1053587c | 574 | { |
5cb8f0db PB |
575 | QVirtQueue *vq; |
576 | QVirtioBlkPCI *blk = obj; | |
577 | QVirtioPCIDevice *pdev = &blk->pci_vdev; | |
578 | QVirtioDevice *dev = &pdev->vdev; | |
1053587c | 579 | QVirtioBlkReq req; |
1053587c MM |
580 | uint64_t req_addr; |
581 | uint64_t capacity; | |
a9340358 | 582 | uint64_t features; |
1053587c | 583 | uint32_t free_head; |
12dfbdca SH |
584 | uint32_t write_head; |
585 | uint32_t desc_idx; | |
1053587c MM |
586 | uint8_t status; |
587 | char *data; | |
5cb8f0db PB |
588 | QOSGraphObject *blk_object = obj; |
589 | QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device"); | |
1999a70a | 590 | QTestState *qts = global_qtest; |
1053587c | 591 | |
5cb8f0db PB |
592 | if (qpci_check_buggy_msi(pci_dev)) { |
593 | return; | |
594 | } | |
1053587c | 595 | |
5cb8f0db PB |
596 | qpci_msix_enable(pdev->pdev); |
597 | qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0); | |
1053587c | 598 | |
5cb8f0db | 599 | features = qvirtio_get_features(dev); |
1053587c | 600 | features = features & ~(QVIRTIO_F_BAD_FEATURE | |
ee3b850a | 601 | (1u << VIRTIO_RING_F_INDIRECT_DESC) | |
1373a4c2 | 602 | (1u << VIRTIO_F_NOTIFY_ON_EMPTY) | |
4565a3e0 | 603 | (1u << VIRTIO_BLK_F_SCSI)); |
5cb8f0db | 604 | qvirtio_set_features(dev, features); |
1053587c | 605 | |
c42bf5f2 SH |
606 | capacity = qvirtio_config_readq(dev, 0); |
607 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); | |
608 | ||
5cb8f0db PB |
609 | vq = qvirtqueue_setup(dev, t_alloc, 0); |
610 | qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1); | |
1053587c | 611 | |
5cb8f0db | 612 | qvirtio_set_driver_ok(dev); |
1053587c MM |
613 | |
614 | /* Write request */ | |
4565a3e0 | 615 | req.type = VIRTIO_BLK_T_OUT; |
1053587c MM |
616 | req.ioprio = 1; |
617 | req.sector = 0; | |
618 | req.data = g_malloc0(512); | |
619 | strcpy(req.data, "TEST"); | |
620 | ||
5cb8f0db | 621 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
1053587c MM |
622 | |
623 | g_free(req.data); | |
624 | ||
1999a70a TH |
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); | |
1053587c | 629 | |
1999a70a | 630 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
12dfbdca | 631 | QVIRTIO_BLK_TIMEOUT_US); |
1053587c MM |
632 | |
633 | /* Write request */ | |
4565a3e0 | 634 | req.type = VIRTIO_BLK_T_OUT; |
1053587c MM |
635 | req.ioprio = 1; |
636 | req.sector = 1; | |
637 | req.data = g_malloc0(512); | |
638 | strcpy(req.data, "TEST"); | |
639 | ||
5cb8f0db | 640 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
1053587c MM |
641 | |
642 | g_free(req.data); | |
643 | ||
644 | /* Notify after processing the third request */ | |
1999a70a TH |
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); | |
12dfbdca | 650 | write_head = free_head; |
1053587c MM |
651 | |
652 | /* No notification expected */ | |
1999a70a | 653 | status = qvirtio_wait_status_byte_no_isr(qts, dev, |
5cb8f0db | 654 | vq, req_addr + 528, |
e8c81b4d | 655 | QVIRTIO_BLK_TIMEOUT_US); |
1053587c MM |
656 | g_assert_cmpint(status, ==, 0); |
657 | ||
5cb8f0db | 658 | guest_free(t_alloc, req_addr); |
1053587c MM |
659 | |
660 | /* Read request */ | |
4565a3e0 | 661 | req.type = VIRTIO_BLK_T_IN; |
1053587c MM |
662 | req.ioprio = 1; |
663 | req.sector = 1; | |
664 | req.data = g_malloc0(512); | |
665 | ||
5cb8f0db | 666 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
1053587c MM |
667 | |
668 | g_free(req.data); | |
669 | ||
1999a70a TH |
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); | |
1053587c | 673 | |
1999a70a | 674 | qvirtqueue_kick(qts, dev, vq, free_head); |
1053587c | 675 | |
12dfbdca | 676 | /* We get just one notification for both requests */ |
1999a70a | 677 | qvirtio_wait_used_elem(qts, dev, vq, write_head, NULL, |
70556264 | 678 | QVIRTIO_BLK_TIMEOUT_US); |
1999a70a | 679 | g_assert(qvirtqueue_get_buf(qts, vq, &desc_idx, NULL)); |
12dfbdca | 680 | g_assert_cmpint(desc_idx, ==, free_head); |
58368113 MM |
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 | ||
5cb8f0db | 690 | guest_free(t_alloc, req_addr); |
58368113 MM |
691 | |
692 | /* End test */ | |
5cb8f0db PB |
693 | qpci_msix_disable(pdev->pdev); |
694 | ||
695 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); | |
58368113 MM |
696 | } |
697 | ||
5cb8f0db | 698 | static void pci_hotplug(void *obj, void *data, QGuestAllocator *t_alloc) |
aaf36070 | 699 | { |
5cb8f0db | 700 | QVirtioPCIDevice *dev1 = obj; |
aaf36070 | 701 | QVirtioPCIDevice *dev; |
6ebb8d2a | 702 | QTestState *qts = dev1->pdev->bus->qts; |
aaf36070 IM |
703 | |
704 | /* plug secondary disk */ | |
e5758de4 | 705 | qtest_qmp_device_add(qts, "virtio-blk-pci", "drv1", |
82cab70b | 706 | "{'addr': %s, 'drive': 'drive1'}", |
5cb8f0db | 707 | stringify(PCI_SLOT_HP) ".0"); |
aaf36070 | 708 | |
5cb8f0db PB |
709 | dev = virtio_pci_new(dev1->pdev->bus, |
710 | &(QPCIAddress) { .devfn = QPCI_DEVFN(PCI_SLOT_HP, 0) }); | |
711 | g_assert_nonnull(dev); | |
712 | g_assert_cmpint(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK); | |
aaf36070 | 713 | qvirtio_pci_device_disable(dev); |
5cb8f0db | 714 | qos_object_destroy((QOSGraphObject *)dev); |
aaf36070 IM |
715 | |
716 | /* unplug secondary disk */ | |
6ebb8d2a | 717 | qpci_unplug_acpi_device_test(qts, "drv1", PCI_SLOT_HP); |
aaf36070 IM |
718 | } |
719 | ||
4426f061 PP |
720 | /* |
721 | * Check that setting the vring addr on a non-existent virtqueue does | |
722 | * not crash. | |
723 | */ | |
5cb8f0db PB |
724 | static void test_nonexistent_virtqueue(void *obj, void *data, |
725 | QGuestAllocator *t_alloc) | |
4426f061 | 726 | { |
5cb8f0db PB |
727 | QVirtioBlkPCI *blk = obj; |
728 | QVirtioPCIDevice *pdev = &blk->pci_vdev; | |
4426f061 | 729 | QPCIBar bar0; |
4426f061 PP |
730 | QPCIDevice *dev; |
731 | ||
5cb8f0db | 732 | dev = qpci_device_find(pdev->pdev->bus, QPCI_DEVFN(4, 0)); |
4426f061 | 733 | g_assert(dev != NULL); |
4426f061 | 734 | qpci_device_enable(dev); |
5cb8f0db | 735 | |
4426f061 PP |
736 | bar0 = qpci_iomap(dev, 0, NULL); |
737 | ||
738 | qpci_io_writeb(dev, bar0, VIRTIO_PCI_QUEUE_SEL, 2); | |
739 | qpci_io_writel(dev, bar0, VIRTIO_PCI_QUEUE_PFN, 1); | |
740 | ||
5cb8f0db | 741 | |
4426f061 | 742 | g_free(dev); |
4426f061 PP |
743 | } |
744 | ||
5cb8f0db | 745 | static void resize(void *obj, void *data, QGuestAllocator *t_alloc) |
0a6ed700 | 746 | { |
5cb8f0db PB |
747 | QVirtioBlk *blk_if = obj; |
748 | QVirtioDevice *dev = blk_if->vdev; | |
0a6ed700 MM |
749 | int n_size = TEST_IMAGE_SIZE / 2; |
750 | uint64_t capacity; | |
5cb8f0db | 751 | QVirtQueue *vq; |
b57ebd57 | 752 | QTestState *qts = global_qtest; |
0a6ed700 | 753 | |
36d27d21 | 754 | vq = test_basic(dev, t_alloc); |
0a6ed700 | 755 | |
dc491fea MAL |
756 | qmp_discard_response("{ 'execute': 'block_resize', " |
757 | " 'arguments': { 'device': 'drive0', " | |
758 | " 'size': %d } }", n_size); | |
0a6ed700 | 759 | |
b57ebd57 | 760 | qvirtio_wait_queue_isr(qts, dev, vq, QVIRTIO_BLK_TIMEOUT_US); |
0a6ed700 | 761 | |
5cb8f0db | 762 | capacity = qvirtio_config_readq(dev, 0); |
0a6ed700 MM |
763 | g_assert_cmpint(capacity, ==, n_size / 512); |
764 | ||
5cb8f0db PB |
765 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); |
766 | ||
0a6ed700 MM |
767 | } |
768 | ||
5cb8f0db | 769 | static void *virtio_blk_test_setup(GString *cmd_line, void *arg) |
c7a59bed | 770 | { |
5cb8f0db | 771 | char *tmp_path = drive_create(); |
c7a59bed | 772 | |
5cb8f0db | 773 | g_string_append_printf(cmd_line, |
ca1ef1e6 AS |
774 | " -drive if=none,id=drive0,file=%s," |
775 | "format=raw,auto-read-only=off " | |
776 | "-drive if=none,id=drive1,file=null-co://," | |
777 | "file.read-zeroes=on,format=raw ", | |
5cb8f0db PB |
778 | tmp_path); |
779 | ||
780 | return arg; | |
c7a59bed | 781 | } |
5cb8f0db PB |
782 | |
783 | static void register_virtio_blk_test(void) | |
784 | { | |
785 | QOSGraphTestOptions opts = { | |
786 | .before = virtio_blk_test_setup, | |
787 | }; | |
788 | ||
789 | qos_add_test("indirect", "virtio-blk", indirect, &opts); | |
790 | qos_add_test("config", "virtio-blk", config, &opts); | |
791 | qos_add_test("basic", "virtio-blk", basic, &opts); | |
792 | qos_add_test("resize", "virtio-blk", resize, &opts); | |
793 | ||
794 | /* tests just for virtio-blk-pci */ | |
795 | qos_add_test("msix", "virtio-blk-pci", msix, &opts); | |
796 | qos_add_test("idx", "virtio-blk-pci", idx, &opts); | |
797 | qos_add_test("nxvirtq", "virtio-blk-pci", | |
798 | test_nonexistent_virtqueue, &opts); | |
799 | qos_add_test("hotplug", "virtio-blk-pci", pci_hotplug, &opts); | |
800 | } | |
801 | ||
802 | libqos_init(register_virtio_blk_test); |