]>
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 | ||
6b9cdf4c | 116 | static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc, |
246fc0fb | 117 | QVirtQueue *vq) |
46e0cf76 | 118 | { |
bf3c63d2 | 119 | QVirtioBlkReq req; |
bf3c63d2 | 120 | uint64_t req_addr; |
46e0cf76 | 121 | uint64_t capacity; |
bf3c63d2 MM |
122 | uint32_t features; |
123 | uint32_t free_head; | |
124 | uint8_t status; | |
125 | char *data; | |
1999a70a | 126 | QTestState *qts = global_qtest; |
46e0cf76 | 127 | |
246fc0fb | 128 | capacity = qvirtio_config_readq(dev, 0); |
50311a81 | 129 | |
46e0cf76 MM |
130 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); |
131 | ||
6b9cdf4c | 132 | features = qvirtio_get_features(dev); |
bf3c63d2 | 133 | features = features & ~(QVIRTIO_F_BAD_FEATURE | |
ee3b850a SH |
134 | (1u << VIRTIO_RING_F_INDIRECT_DESC) | |
135 | (1u << VIRTIO_RING_F_EVENT_IDX) | | |
4565a3e0 | 136 | (1u << VIRTIO_BLK_F_SCSI)); |
6b9cdf4c | 137 | qvirtio_set_features(dev, features); |
bf3c63d2 | 138 | |
6b9cdf4c | 139 | qvirtio_set_driver_ok(dev); |
bf3c63d2 | 140 | |
9b7d2d8b | 141 | /* Write and read with 3 descriptor layout */ |
bf3c63d2 | 142 | /* Write request */ |
4565a3e0 | 143 | req.type = VIRTIO_BLK_T_OUT; |
bf3c63d2 MM |
144 | req.ioprio = 1; |
145 | req.sector = 0; | |
146 | req.data = g_malloc0(512); | |
147 | strcpy(req.data, "TEST"); | |
148 | ||
8b4b80c3 | 149 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 MM |
150 | |
151 | g_free(req.data); | |
152 | ||
1999a70a TH |
153 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
154 | qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true); | |
155 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
9b7d2d8b | 156 | |
1999a70a | 157 | qvirtqueue_kick(qts, dev, vq, free_head); |
bf3c63d2 | 158 | |
1999a70a TH |
159 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
160 | QVIRTIO_BLK_TIMEOUT_US); | |
bf3c63d2 MM |
161 | status = readb(req_addr + 528); |
162 | g_assert_cmpint(status, ==, 0); | |
163 | ||
164 | guest_free(alloc, req_addr); | |
165 | ||
166 | /* Read request */ | |
4565a3e0 | 167 | req.type = VIRTIO_BLK_T_IN; |
bf3c63d2 MM |
168 | req.ioprio = 1; |
169 | req.sector = 0; | |
170 | req.data = g_malloc0(512); | |
171 | ||
8b4b80c3 | 172 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 MM |
173 | |
174 | g_free(req.data); | |
175 | ||
1999a70a TH |
176 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
177 | qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true); | |
178 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
bf3c63d2 | 179 | |
1999a70a | 180 | qvirtqueue_kick(qts, dev, vq, free_head); |
bf3c63d2 | 181 | |
1999a70a TH |
182 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
183 | QVIRTIO_BLK_TIMEOUT_US); | |
bf3c63d2 MM |
184 | status = readb(req_addr + 528); |
185 | g_assert_cmpint(status, ==, 0); | |
186 | ||
187 | data = g_malloc0(512); | |
188 | memread(req_addr + 16, data, 512); | |
189 | g_assert_cmpstr(data, ==, "TEST"); | |
190 | g_free(data); | |
191 | ||
192 | guest_free(alloc, req_addr); | |
193 | ||
06879094 SG |
194 | if (features & (1u << VIRTIO_BLK_F_WRITE_ZEROES)) { |
195 | struct virtio_blk_discard_write_zeroes dwz_hdr; | |
196 | void *expected; | |
197 | ||
198 | /* | |
199 | * WRITE_ZEROES request on the same sector of previous test where | |
200 | * we wrote "TEST". | |
201 | */ | |
202 | req.type = VIRTIO_BLK_T_WRITE_ZEROES; | |
203 | req.data = (char *) &dwz_hdr; | |
204 | dwz_hdr.sector = 0; | |
205 | dwz_hdr.num_sectors = 1; | |
206 | dwz_hdr.flags = 0; | |
207 | ||
208 | virtio_blk_fix_dwz_hdr(dev, &dwz_hdr); | |
209 | ||
210 | req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr)); | |
211 | ||
1999a70a TH |
212 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
213 | qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true); | |
214 | qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, | |
215 | false); | |
06879094 | 216 | |
1999a70a | 217 | qvirtqueue_kick(qts, dev, vq, free_head); |
06879094 | 218 | |
1999a70a | 219 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
06879094 SG |
220 | QVIRTIO_BLK_TIMEOUT_US); |
221 | status = readb(req_addr + 16 + sizeof(dwz_hdr)); | |
222 | g_assert_cmpint(status, ==, 0); | |
223 | ||
224 | guest_free(alloc, req_addr); | |
225 | ||
226 | /* Read request to check if the sector contains all zeroes */ | |
227 | req.type = VIRTIO_BLK_T_IN; | |
228 | req.ioprio = 1; | |
229 | req.sector = 0; | |
230 | req.data = g_malloc0(512); | |
231 | ||
232 | req_addr = virtio_blk_request(alloc, dev, &req, 512); | |
233 | ||
234 | g_free(req.data); | |
235 | ||
1999a70a TH |
236 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
237 | qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true); | |
238 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
06879094 | 239 | |
1999a70a | 240 | qvirtqueue_kick(qts, dev, vq, free_head); |
06879094 | 241 | |
1999a70a | 242 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
06879094 SG |
243 | QVIRTIO_BLK_TIMEOUT_US); |
244 | status = readb(req_addr + 528); | |
245 | g_assert_cmpint(status, ==, 0); | |
246 | ||
247 | data = g_malloc(512); | |
248 | expected = g_malloc0(512); | |
249 | memread(req_addr + 16, data, 512); | |
250 | g_assert_cmpmem(data, 512, expected, 512); | |
251 | g_free(expected); | |
252 | g_free(data); | |
253 | ||
254 | guest_free(alloc, req_addr); | |
255 | } | |
256 | ||
9a9f4b74 SG |
257 | if (features & (1u << VIRTIO_BLK_F_DISCARD)) { |
258 | struct virtio_blk_discard_write_zeroes dwz_hdr; | |
259 | ||
260 | req.type = VIRTIO_BLK_T_DISCARD; | |
261 | req.data = (char *) &dwz_hdr; | |
262 | dwz_hdr.sector = 0; | |
263 | dwz_hdr.num_sectors = 1; | |
264 | dwz_hdr.flags = 0; | |
265 | ||
266 | virtio_blk_fix_dwz_hdr(dev, &dwz_hdr); | |
267 | ||
268 | req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr)); | |
269 | ||
1999a70a TH |
270 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
271 | qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, true); | |
272 | qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false); | |
9a9f4b74 | 273 | |
1999a70a | 274 | qvirtqueue_kick(qts, dev, vq, free_head); |
9a9f4b74 | 275 | |
1999a70a | 276 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
9a9f4b74 SG |
277 | QVIRTIO_BLK_TIMEOUT_US); |
278 | status = readb(req_addr + 16 + sizeof(dwz_hdr)); | |
279 | g_assert_cmpint(status, ==, 0); | |
280 | ||
281 | guest_free(alloc, req_addr); | |
282 | } | |
283 | ||
1373a4c2 | 284 | if (features & (1u << VIRTIO_F_ANY_LAYOUT)) { |
9b7d2d8b MM |
285 | /* Write and read with 2 descriptor layout */ |
286 | /* Write request */ | |
4565a3e0 | 287 | req.type = VIRTIO_BLK_T_OUT; |
9b7d2d8b MM |
288 | req.ioprio = 1; |
289 | req.sector = 1; | |
290 | req.data = g_malloc0(512); | |
291 | strcpy(req.data, "TEST"); | |
bf3c63d2 | 292 | |
8b4b80c3 | 293 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 | 294 | |
9b7d2d8b | 295 | g_free(req.data); |
bf3c63d2 | 296 | |
1999a70a TH |
297 | free_head = qvirtqueue_add(qts, vq, req_addr, 528, false, true); |
298 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
299 | qvirtqueue_kick(qts, dev, vq, free_head); | |
38d8364f | 300 | |
1999a70a | 301 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
be3a6781 | 302 | QVIRTIO_BLK_TIMEOUT_US); |
9b7d2d8b MM |
303 | status = readb(req_addr + 528); |
304 | g_assert_cmpint(status, ==, 0); | |
bf3c63d2 | 305 | |
9b7d2d8b | 306 | guest_free(alloc, req_addr); |
bf3c63d2 | 307 | |
9b7d2d8b | 308 | /* Read request */ |
4565a3e0 | 309 | req.type = VIRTIO_BLK_T_IN; |
9b7d2d8b MM |
310 | req.ioprio = 1; |
311 | req.sector = 1; | |
312 | req.data = g_malloc0(512); | |
bf3c63d2 | 313 | |
8b4b80c3 | 314 | req_addr = virtio_blk_request(alloc, dev, &req, 512); |
bf3c63d2 | 315 | |
9b7d2d8b | 316 | g_free(req.data); |
bf3c63d2 | 317 | |
1999a70a TH |
318 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
319 | qvirtqueue_add(qts, vq, req_addr + 16, 513, true, false); | |
bf3c63d2 | 320 | |
1999a70a | 321 | qvirtqueue_kick(qts, dev, vq, free_head); |
bf3c63d2 | 322 | |
1999a70a | 323 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
be3a6781 | 324 | QVIRTIO_BLK_TIMEOUT_US); |
9b7d2d8b MM |
325 | status = readb(req_addr + 528); |
326 | g_assert_cmpint(status, ==, 0); | |
bf3c63d2 | 327 | |
9b7d2d8b MM |
328 | data = g_malloc0(512); |
329 | memread(req_addr + 16, data, 512); | |
330 | g_assert_cmpstr(data, ==, "TEST"); | |
331 | g_free(data); | |
bf3c63d2 | 332 | |
9b7d2d8b MM |
333 | guest_free(alloc, req_addr); |
334 | } | |
38d8364f MM |
335 | } |
336 | ||
5cb8f0db | 337 | static void basic(void *obj, void *data, QGuestAllocator *t_alloc) |
38d8364f | 338 | { |
5cb8f0db PB |
339 | QVirtioBlk *blk_if = obj; |
340 | QVirtQueue *vq; | |
341 | vq = qvirtqueue_setup(blk_if->vdev, t_alloc, 0); | |
342 | test_basic(blk_if->vdev, t_alloc, vq); | |
343 | qvirtqueue_cleanup(blk_if->vdev->bus, vq, t_alloc); | |
bf3c63d2 | 344 | |
c7a59bed AF |
345 | } |
346 | ||
5cb8f0db | 347 | static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc) |
f294b029 | 348 | { |
5cb8f0db PB |
349 | QVirtQueue *vq; |
350 | QVirtioBlk *blk_if = obj; | |
351 | QVirtioDevice *dev = blk_if->vdev; | |
f294b029 MM |
352 | QVirtioBlkReq req; |
353 | QVRingIndirectDesc *indirect; | |
f294b029 MM |
354 | uint64_t req_addr; |
355 | uint64_t capacity; | |
356 | uint32_t features; | |
357 | uint32_t free_head; | |
358 | uint8_t status; | |
359 | char *data; | |
1999a70a | 360 | QTestState *qts = global_qtest; |
f294b029 | 361 | |
5cb8f0db | 362 | capacity = qvirtio_config_readq(dev, 0); |
f294b029 MM |
363 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); |
364 | ||
5cb8f0db | 365 | features = qvirtio_get_features(dev); |
ee3b850a SH |
366 | g_assert_cmphex(features & (1u << VIRTIO_RING_F_INDIRECT_DESC), !=, 0); |
367 | features = features & ~(QVIRTIO_F_BAD_FEATURE | | |
368 | (1u << VIRTIO_RING_F_EVENT_IDX) | | |
4565a3e0 | 369 | (1u << VIRTIO_BLK_F_SCSI)); |
5cb8f0db | 370 | qvirtio_set_features(dev, features); |
f294b029 | 371 | |
5cb8f0db PB |
372 | vq = qvirtqueue_setup(dev, t_alloc, 0); |
373 | qvirtio_set_driver_ok(dev); | |
f294b029 MM |
374 | |
375 | /* Write request */ | |
4565a3e0 | 376 | req.type = VIRTIO_BLK_T_OUT; |
f294b029 MM |
377 | req.ioprio = 1; |
378 | req.sector = 0; | |
379 | req.data = g_malloc0(512); | |
380 | strcpy(req.data, "TEST"); | |
381 | ||
5cb8f0db | 382 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
f294b029 MM |
383 | |
384 | g_free(req.data); | |
385 | ||
1999a70a TH |
386 | indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2); |
387 | qvring_indirect_desc_add(qts, indirect, req_addr, 528, false); | |
388 | qvring_indirect_desc_add(qts, indirect, req_addr + 528, 1, true); | |
389 | free_head = qvirtqueue_add_indirect(qts, vq, indirect); | |
390 | qvirtqueue_kick(qts, dev, vq, free_head); | |
f294b029 | 391 | |
1999a70a | 392 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 393 | QVIRTIO_BLK_TIMEOUT_US); |
f294b029 MM |
394 | status = readb(req_addr + 528); |
395 | g_assert_cmpint(status, ==, 0); | |
396 | ||
397 | g_free(indirect); | |
5cb8f0db | 398 | guest_free(t_alloc, req_addr); |
f294b029 MM |
399 | |
400 | /* Read request */ | |
4565a3e0 | 401 | req.type = VIRTIO_BLK_T_IN; |
f294b029 MM |
402 | req.ioprio = 1; |
403 | req.sector = 0; | |
404 | req.data = g_malloc0(512); | |
405 | strcpy(req.data, "TEST"); | |
406 | ||
5cb8f0db | 407 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
f294b029 MM |
408 | |
409 | g_free(req.data); | |
410 | ||
1999a70a TH |
411 | indirect = qvring_indirect_desc_setup(qts, dev, t_alloc, 2); |
412 | qvring_indirect_desc_add(qts, indirect, req_addr, 16, false); | |
413 | qvring_indirect_desc_add(qts, indirect, req_addr + 16, 513, true); | |
414 | free_head = qvirtqueue_add_indirect(qts, vq, indirect); | |
415 | qvirtqueue_kick(qts, dev, vq, free_head); | |
f294b029 | 416 | |
1999a70a | 417 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 418 | QVIRTIO_BLK_TIMEOUT_US); |
f294b029 MM |
419 | status = readb(req_addr + 528); |
420 | g_assert_cmpint(status, ==, 0); | |
421 | ||
422 | data = g_malloc0(512); | |
423 | memread(req_addr + 16, data, 512); | |
424 | g_assert_cmpstr(data, ==, "TEST"); | |
425 | g_free(data); | |
426 | ||
427 | g_free(indirect); | |
5cb8f0db PB |
428 | guest_free(t_alloc, req_addr); |
429 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); | |
f294b029 MM |
430 | } |
431 | ||
5cb8f0db | 432 | static void config(void *obj, void *data, QGuestAllocator *t_alloc) |
e1119955 | 433 | { |
5cb8f0db PB |
434 | QVirtioBlk *blk_if = obj; |
435 | QVirtioDevice *dev = blk_if->vdev; | |
e1119955 | 436 | int n_size = TEST_IMAGE_SIZE / 2; |
e1119955 MM |
437 | uint64_t capacity; |
438 | ||
5cb8f0db | 439 | capacity = qvirtio_config_readq(dev, 0); |
e1119955 MM |
440 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); |
441 | ||
5cb8f0db | 442 | qvirtio_set_driver_ok(dev); |
e1119955 | 443 | |
dc491fea MAL |
444 | qmp_discard_response("{ 'execute': 'block_resize', " |
445 | " 'arguments': { 'device': 'drive0', " | |
446 | " 'size': %d } }", n_size); | |
5cb8f0db | 447 | qvirtio_wait_config_isr(dev, QVIRTIO_BLK_TIMEOUT_US); |
e1119955 | 448 | |
5cb8f0db | 449 | capacity = qvirtio_config_readq(dev, 0); |
e1119955 | 450 | g_assert_cmpint(capacity, ==, n_size / 512); |
e1119955 MM |
451 | } |
452 | ||
5cb8f0db | 453 | static void msix(void *obj, void *u_data, QGuestAllocator *t_alloc) |
58368113 | 454 | { |
5cb8f0db PB |
455 | QVirtQueue *vq; |
456 | QVirtioBlkPCI *blk = obj; | |
457 | QVirtioPCIDevice *pdev = &blk->pci_vdev; | |
458 | QVirtioDevice *dev = &pdev->vdev; | |
58368113 MM |
459 | QVirtioBlkReq req; |
460 | int n_size = TEST_IMAGE_SIZE / 2; | |
58368113 MM |
461 | uint64_t req_addr; |
462 | uint64_t capacity; | |
463 | uint32_t features; | |
464 | uint32_t free_head; | |
465 | uint8_t status; | |
466 | char *data; | |
5cb8f0db PB |
467 | QOSGraphObject *blk_object = obj; |
468 | QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device"); | |
1999a70a | 469 | QTestState *qts = global_qtest; |
58368113 | 470 | |
5cb8f0db PB |
471 | if (qpci_check_buggy_msi(pci_dev)) { |
472 | return; | |
473 | } | |
58368113 | 474 | |
5cb8f0db PB |
475 | qpci_msix_enable(pdev->pdev); |
476 | qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0); | |
58368113 | 477 | |
5cb8f0db | 478 | capacity = qvirtio_config_readq(dev, 0); |
58368113 MM |
479 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); |
480 | ||
5cb8f0db | 481 | features = qvirtio_get_features(dev); |
58368113 | 482 | features = features & ~(QVIRTIO_F_BAD_FEATURE | |
ee3b850a SH |
483 | (1u << VIRTIO_RING_F_INDIRECT_DESC) | |
484 | (1u << VIRTIO_RING_F_EVENT_IDX) | | |
4565a3e0 | 485 | (1u << VIRTIO_BLK_F_SCSI)); |
5cb8f0db | 486 | qvirtio_set_features(dev, features); |
58368113 | 487 | |
5cb8f0db PB |
488 | vq = qvirtqueue_setup(dev, t_alloc, 0); |
489 | qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1); | |
58368113 | 490 | |
5cb8f0db | 491 | qvirtio_set_driver_ok(dev); |
58368113 | 492 | |
dc491fea MAL |
493 | qmp_discard_response("{ 'execute': 'block_resize', " |
494 | " 'arguments': { 'device': 'drive0', " | |
495 | " 'size': %d } }", n_size); | |
58368113 | 496 | |
5cb8f0db | 497 | qvirtio_wait_config_isr(dev, QVIRTIO_BLK_TIMEOUT_US); |
58368113 | 498 | |
5cb8f0db | 499 | capacity = qvirtio_config_readq(dev, 0); |
58368113 MM |
500 | g_assert_cmpint(capacity, ==, n_size / 512); |
501 | ||
502 | /* Write request */ | |
4565a3e0 | 503 | req.type = VIRTIO_BLK_T_OUT; |
58368113 MM |
504 | req.ioprio = 1; |
505 | req.sector = 0; | |
506 | req.data = g_malloc0(512); | |
507 | strcpy(req.data, "TEST"); | |
508 | ||
5cb8f0db | 509 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
58368113 MM |
510 | |
511 | g_free(req.data); | |
512 | ||
1999a70a TH |
513 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
514 | qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true); | |
515 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
516 | qvirtqueue_kick(qts, dev, vq, free_head); | |
58368113 | 517 | |
1999a70a | 518 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 519 | QVIRTIO_BLK_TIMEOUT_US); |
58368113 MM |
520 | |
521 | status = readb(req_addr + 528); | |
522 | g_assert_cmpint(status, ==, 0); | |
523 | ||
5cb8f0db | 524 | guest_free(t_alloc, req_addr); |
58368113 MM |
525 | |
526 | /* Read request */ | |
4565a3e0 | 527 | req.type = VIRTIO_BLK_T_IN; |
58368113 MM |
528 | req.ioprio = 1; |
529 | req.sector = 0; | |
530 | req.data = g_malloc0(512); | |
531 | ||
5cb8f0db | 532 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
58368113 MM |
533 | |
534 | g_free(req.data); | |
535 | ||
1999a70a TH |
536 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
537 | qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true); | |
538 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
58368113 | 539 | |
1999a70a | 540 | qvirtqueue_kick(qts, dev, vq, free_head); |
58368113 | 541 | |
1053587c | 542 | |
1999a70a | 543 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
70556264 | 544 | QVIRTIO_BLK_TIMEOUT_US); |
1053587c MM |
545 | |
546 | status = readb(req_addr + 528); | |
547 | g_assert_cmpint(status, ==, 0); | |
548 | ||
549 | data = g_malloc0(512); | |
550 | memread(req_addr + 16, data, 512); | |
551 | g_assert_cmpstr(data, ==, "TEST"); | |
552 | g_free(data); | |
553 | ||
5cb8f0db | 554 | guest_free(t_alloc, req_addr); |
1053587c MM |
555 | |
556 | /* End test */ | |
5cb8f0db PB |
557 | qpci_msix_disable(pdev->pdev); |
558 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); | |
1053587c MM |
559 | } |
560 | ||
5cb8f0db | 561 | static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc) |
1053587c | 562 | { |
5cb8f0db PB |
563 | QVirtQueue *vq; |
564 | QVirtioBlkPCI *blk = obj; | |
565 | QVirtioPCIDevice *pdev = &blk->pci_vdev; | |
566 | QVirtioDevice *dev = &pdev->vdev; | |
1053587c | 567 | QVirtioBlkReq req; |
1053587c MM |
568 | uint64_t req_addr; |
569 | uint64_t capacity; | |
570 | uint32_t features; | |
571 | uint32_t free_head; | |
12dfbdca SH |
572 | uint32_t write_head; |
573 | uint32_t desc_idx; | |
1053587c MM |
574 | uint8_t status; |
575 | char *data; | |
5cb8f0db PB |
576 | QOSGraphObject *blk_object = obj; |
577 | QPCIDevice *pci_dev = blk_object->get_driver(blk_object, "pci-device"); | |
1999a70a | 578 | QTestState *qts = global_qtest; |
1053587c | 579 | |
5cb8f0db PB |
580 | if (qpci_check_buggy_msi(pci_dev)) { |
581 | return; | |
582 | } | |
1053587c | 583 | |
5cb8f0db PB |
584 | qpci_msix_enable(pdev->pdev); |
585 | qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0); | |
1053587c | 586 | |
5cb8f0db | 587 | capacity = qvirtio_config_readq(dev, 0); |
1053587c MM |
588 | g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512); |
589 | ||
5cb8f0db | 590 | features = qvirtio_get_features(dev); |
1053587c | 591 | features = features & ~(QVIRTIO_F_BAD_FEATURE | |
ee3b850a | 592 | (1u << VIRTIO_RING_F_INDIRECT_DESC) | |
1373a4c2 | 593 | (1u << VIRTIO_F_NOTIFY_ON_EMPTY) | |
4565a3e0 | 594 | (1u << VIRTIO_BLK_F_SCSI)); |
5cb8f0db | 595 | qvirtio_set_features(dev, features); |
1053587c | 596 | |
5cb8f0db PB |
597 | vq = qvirtqueue_setup(dev, t_alloc, 0); |
598 | qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1); | |
1053587c | 599 | |
5cb8f0db | 600 | qvirtio_set_driver_ok(dev); |
1053587c MM |
601 | |
602 | /* Write request */ | |
4565a3e0 | 603 | req.type = VIRTIO_BLK_T_OUT; |
1053587c MM |
604 | req.ioprio = 1; |
605 | req.sector = 0; | |
606 | req.data = g_malloc0(512); | |
607 | strcpy(req.data, "TEST"); | |
608 | ||
5cb8f0db | 609 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
1053587c MM |
610 | |
611 | g_free(req.data); | |
612 | ||
1999a70a TH |
613 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
614 | qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true); | |
615 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
616 | qvirtqueue_kick(qts, dev, vq, free_head); | |
1053587c | 617 | |
1999a70a | 618 | qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, |
12dfbdca | 619 | QVIRTIO_BLK_TIMEOUT_US); |
1053587c MM |
620 | |
621 | /* Write request */ | |
4565a3e0 | 622 | req.type = VIRTIO_BLK_T_OUT; |
1053587c MM |
623 | req.ioprio = 1; |
624 | req.sector = 1; | |
625 | req.data = g_malloc0(512); | |
626 | strcpy(req.data, "TEST"); | |
627 | ||
5cb8f0db | 628 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
1053587c MM |
629 | |
630 | g_free(req.data); | |
631 | ||
632 | /* Notify after processing the third request */ | |
1999a70a TH |
633 | qvirtqueue_set_used_event(qts, vq, 2); |
634 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); | |
635 | qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true); | |
636 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
637 | qvirtqueue_kick(qts, dev, vq, free_head); | |
12dfbdca | 638 | write_head = free_head; |
1053587c MM |
639 | |
640 | /* No notification expected */ | |
1999a70a | 641 | status = qvirtio_wait_status_byte_no_isr(qts, dev, |
5cb8f0db | 642 | vq, req_addr + 528, |
e8c81b4d | 643 | QVIRTIO_BLK_TIMEOUT_US); |
1053587c MM |
644 | g_assert_cmpint(status, ==, 0); |
645 | ||
5cb8f0db | 646 | guest_free(t_alloc, req_addr); |
1053587c MM |
647 | |
648 | /* Read request */ | |
4565a3e0 | 649 | req.type = VIRTIO_BLK_T_IN; |
1053587c MM |
650 | req.ioprio = 1; |
651 | req.sector = 1; | |
652 | req.data = g_malloc0(512); | |
653 | ||
5cb8f0db | 654 | req_addr = virtio_blk_request(t_alloc, dev, &req, 512); |
1053587c MM |
655 | |
656 | g_free(req.data); | |
657 | ||
1999a70a TH |
658 | free_head = qvirtqueue_add(qts, vq, req_addr, 16, false, true); |
659 | qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true); | |
660 | qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); | |
1053587c | 661 | |
1999a70a | 662 | qvirtqueue_kick(qts, dev, vq, free_head); |
1053587c | 663 | |
12dfbdca | 664 | /* We get just one notification for both requests */ |
1999a70a | 665 | qvirtio_wait_used_elem(qts, dev, vq, write_head, NULL, |
70556264 | 666 | QVIRTIO_BLK_TIMEOUT_US); |
1999a70a | 667 | g_assert(qvirtqueue_get_buf(qts, vq, &desc_idx, NULL)); |
12dfbdca | 668 | g_assert_cmpint(desc_idx, ==, free_head); |
58368113 MM |
669 | |
670 | status = readb(req_addr + 528); | |
671 | g_assert_cmpint(status, ==, 0); | |
672 | ||
673 | data = g_malloc0(512); | |
674 | memread(req_addr + 16, data, 512); | |
675 | g_assert_cmpstr(data, ==, "TEST"); | |
676 | g_free(data); | |
677 | ||
5cb8f0db | 678 | guest_free(t_alloc, req_addr); |
58368113 MM |
679 | |
680 | /* End test */ | |
5cb8f0db PB |
681 | qpci_msix_disable(pdev->pdev); |
682 | ||
683 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); | |
58368113 MM |
684 | } |
685 | ||
5cb8f0db | 686 | static void pci_hotplug(void *obj, void *data, QGuestAllocator *t_alloc) |
aaf36070 | 687 | { |
5cb8f0db | 688 | QVirtioPCIDevice *dev1 = obj; |
aaf36070 | 689 | QVirtioPCIDevice *dev; |
6ebb8d2a | 690 | QTestState *qts = dev1->pdev->bus->qts; |
aaf36070 IM |
691 | |
692 | /* plug secondary disk */ | |
e5758de4 | 693 | qtest_qmp_device_add(qts, "virtio-blk-pci", "drv1", |
82cab70b | 694 | "{'addr': %s, 'drive': 'drive1'}", |
5cb8f0db | 695 | stringify(PCI_SLOT_HP) ".0"); |
aaf36070 | 696 | |
5cb8f0db PB |
697 | dev = virtio_pci_new(dev1->pdev->bus, |
698 | &(QPCIAddress) { .devfn = QPCI_DEVFN(PCI_SLOT_HP, 0) }); | |
699 | g_assert_nonnull(dev); | |
700 | g_assert_cmpint(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK); | |
aaf36070 | 701 | qvirtio_pci_device_disable(dev); |
5cb8f0db | 702 | qos_object_destroy((QOSGraphObject *)dev); |
aaf36070 IM |
703 | |
704 | /* unplug secondary disk */ | |
6ebb8d2a | 705 | qpci_unplug_acpi_device_test(qts, "drv1", PCI_SLOT_HP); |
aaf36070 IM |
706 | } |
707 | ||
4426f061 PP |
708 | /* |
709 | * Check that setting the vring addr on a non-existent virtqueue does | |
710 | * not crash. | |
711 | */ | |
5cb8f0db PB |
712 | static void test_nonexistent_virtqueue(void *obj, void *data, |
713 | QGuestAllocator *t_alloc) | |
4426f061 | 714 | { |
5cb8f0db PB |
715 | QVirtioBlkPCI *blk = obj; |
716 | QVirtioPCIDevice *pdev = &blk->pci_vdev; | |
4426f061 | 717 | QPCIBar bar0; |
4426f061 PP |
718 | QPCIDevice *dev; |
719 | ||
5cb8f0db | 720 | dev = qpci_device_find(pdev->pdev->bus, QPCI_DEVFN(4, 0)); |
4426f061 | 721 | g_assert(dev != NULL); |
4426f061 | 722 | qpci_device_enable(dev); |
5cb8f0db | 723 | |
4426f061 PP |
724 | bar0 = qpci_iomap(dev, 0, NULL); |
725 | ||
726 | qpci_io_writeb(dev, bar0, VIRTIO_PCI_QUEUE_SEL, 2); | |
727 | qpci_io_writel(dev, bar0, VIRTIO_PCI_QUEUE_PFN, 1); | |
728 | ||
5cb8f0db | 729 | |
4426f061 | 730 | g_free(dev); |
4426f061 PP |
731 | } |
732 | ||
5cb8f0db | 733 | static void resize(void *obj, void *data, QGuestAllocator *t_alloc) |
0a6ed700 | 734 | { |
5cb8f0db PB |
735 | QVirtioBlk *blk_if = obj; |
736 | QVirtioDevice *dev = blk_if->vdev; | |
0a6ed700 MM |
737 | int n_size = TEST_IMAGE_SIZE / 2; |
738 | uint64_t capacity; | |
5cb8f0db | 739 | QVirtQueue *vq; |
b57ebd57 | 740 | QTestState *qts = global_qtest; |
0a6ed700 | 741 | |
5cb8f0db | 742 | vq = qvirtqueue_setup(dev, t_alloc, 0); |
0a6ed700 | 743 | |
5cb8f0db | 744 | test_basic(dev, t_alloc, vq); |
0a6ed700 | 745 | |
dc491fea MAL |
746 | qmp_discard_response("{ 'execute': 'block_resize', " |
747 | " 'arguments': { 'device': 'drive0', " | |
748 | " 'size': %d } }", n_size); | |
0a6ed700 | 749 | |
b57ebd57 | 750 | qvirtio_wait_queue_isr(qts, dev, vq, QVIRTIO_BLK_TIMEOUT_US); |
0a6ed700 | 751 | |
5cb8f0db | 752 | capacity = qvirtio_config_readq(dev, 0); |
0a6ed700 MM |
753 | g_assert_cmpint(capacity, ==, n_size / 512); |
754 | ||
5cb8f0db PB |
755 | qvirtqueue_cleanup(dev->bus, vq, t_alloc); |
756 | ||
0a6ed700 MM |
757 | } |
758 | ||
5cb8f0db | 759 | static void *virtio_blk_test_setup(GString *cmd_line, void *arg) |
c7a59bed | 760 | { |
5cb8f0db | 761 | char *tmp_path = drive_create(); |
c7a59bed | 762 | |
5cb8f0db | 763 | g_string_append_printf(cmd_line, |
ca1ef1e6 AS |
764 | " -drive if=none,id=drive0,file=%s," |
765 | "format=raw,auto-read-only=off " | |
766 | "-drive if=none,id=drive1,file=null-co://," | |
767 | "file.read-zeroes=on,format=raw ", | |
5cb8f0db PB |
768 | tmp_path); |
769 | ||
770 | return arg; | |
c7a59bed | 771 | } |
5cb8f0db PB |
772 | |
773 | static void register_virtio_blk_test(void) | |
774 | { | |
775 | QOSGraphTestOptions opts = { | |
776 | .before = virtio_blk_test_setup, | |
777 | }; | |
778 | ||
779 | qos_add_test("indirect", "virtio-blk", indirect, &opts); | |
780 | qos_add_test("config", "virtio-blk", config, &opts); | |
781 | qos_add_test("basic", "virtio-blk", basic, &opts); | |
782 | qos_add_test("resize", "virtio-blk", resize, &opts); | |
783 | ||
784 | /* tests just for virtio-blk-pci */ | |
785 | qos_add_test("msix", "virtio-blk-pci", msix, &opts); | |
786 | qos_add_test("idx", "virtio-blk-pci", idx, &opts); | |
787 | qos_add_test("nxvirtq", "virtio-blk-pci", | |
788 | test_nonexistent_virtqueue, &opts); | |
789 | qos_add_test("hotplug", "virtio-blk-pci", pci_hotplug, &opts); | |
790 | } | |
791 | ||
792 | libqos_init(register_virtio_blk_test); |