2 * Block protocol for block driver correctness testing
4 * Copyright (C) 2010 IBM, Corp.
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
11 #include "qemu_socket.h" /* for EINPROGRESS on Windows */
12 #include "block_int.h"
15 BlockDriverState
*test_file
;
18 typedef struct BlkverifyAIOCB BlkverifyAIOCB
;
19 struct BlkverifyAIOCB
{
20 BlockDriverAIOCB common
;
23 /* Request metadata */
28 int ret
; /* first completed request's result */
29 unsigned int done
; /* completion counter */
30 bool *finished
; /* completion signal for cancel */
32 QEMUIOVector
*qiov
; /* user I/O vector */
33 QEMUIOVector raw_qiov
; /* cloned I/O vector for raw file */
34 void *buf
; /* buffer for raw file I/O */
36 void (*verify
)(BlkverifyAIOCB
*acb
);
39 static void blkverify_aio_cancel(BlockDriverAIOCB
*blockacb
)
41 BlkverifyAIOCB
*acb
= (BlkverifyAIOCB
*)blockacb
;
42 bool finished
= false;
44 /* Wait until request completes, invokes its callback, and frees itself */
45 acb
->finished
= &finished
;
51 static AIOPool blkverify_aio_pool
= {
52 .aiocb_size
= sizeof(BlkverifyAIOCB
),
53 .cancel
= blkverify_aio_cancel
,
56 static void blkverify_err(BlkverifyAIOCB
*acb
, const char *fmt
, ...)
61 fprintf(stderr
, "blkverify: %s sector_num=%" PRId64
" nb_sectors=%d ",
62 acb
->is_write
? "write" : "read", acb
->sector_num
,
64 vfprintf(stderr
, fmt
, ap
);
65 fprintf(stderr
, "\n");
70 /* Valid blkverify filenames look like blkverify:path/to/raw_image:path/to/image */
71 static int blkverify_open(BlockDriverState
*bs
, const char *filename
, int flags
)
73 BDRVBlkverifyState
*s
= bs
->opaque
;
77 /* Parse the blkverify: prefix */
78 if (strncmp(filename
, "blkverify:", strlen("blkverify:"))) {
81 filename
+= strlen("blkverify:");
83 /* Parse the raw image filename */
84 c
= strchr(filename
, ':');
89 raw
= strdup(filename
);
90 raw
[c
- filename
] = '\0';
91 ret
= bdrv_file_open(&bs
->file
, raw
, flags
);
98 /* Open the test file */
99 s
->test_file
= bdrv_new("");
100 ret
= bdrv_open(s
->test_file
, filename
, flags
, NULL
);
102 bdrv_delete(s
->test_file
);
110 static void blkverify_close(BlockDriverState
*bs
)
112 BDRVBlkverifyState
*s
= bs
->opaque
;
114 bdrv_delete(s
->test_file
);
118 static void blkverify_flush(BlockDriverState
*bs
)
120 BDRVBlkverifyState
*s
= bs
->opaque
;
122 /* Only flush test file, the raw file is not important */
123 bdrv_flush(s
->test_file
);
126 static int64_t blkverify_getlength(BlockDriverState
*bs
)
128 BDRVBlkverifyState
*s
= bs
->opaque
;
130 return bdrv_getlength(s
->test_file
);
134 * Check that I/O vector contents are identical
138 * @ret: Offset to first mismatching byte or -1 if match
140 static ssize_t
blkverify_iovec_compare(QEMUIOVector
*a
, QEMUIOVector
*b
)
145 assert(a
->niov
== b
->niov
);
146 for (i
= 0; i
< a
->niov
; i
++) {
148 uint8_t *p
= (uint8_t *)a
->iov
[i
].iov_base
;
149 uint8_t *q
= (uint8_t *)b
->iov
[i
].iov_base
;
151 assert(a
->iov
[i
].iov_len
== b
->iov
[i
].iov_len
);
152 while (len
< a
->iov
[i
].iov_len
&& *p
++ == *q
++) {
158 if (len
!= a
->iov
[i
].iov_len
) {
167 struct iovec
*src_iov
;
171 static int sortelem_cmp_src_base(const void *a
, const void *b
)
173 const IOVectorSortElem
*elem_a
= a
;
174 const IOVectorSortElem
*elem_b
= b
;
177 if (elem_a
->src_iov
->iov_base
< elem_b
->src_iov
->iov_base
) {
179 } else if (elem_a
->src_iov
->iov_base
> elem_b
->src_iov
->iov_base
) {
186 static int sortelem_cmp_src_index(const void *a
, const void *b
)
188 const IOVectorSortElem
*elem_a
= a
;
189 const IOVectorSortElem
*elem_b
= b
;
191 return elem_a
->src_index
- elem_b
->src_index
;
195 * Copy contents of I/O vector
197 * The relative relationships of overlapping iovecs are preserved. This is
198 * necessary to ensure identical semantics in the cloned I/O vector.
200 static void blkverify_iovec_clone(QEMUIOVector
*dest
, const QEMUIOVector
*src
,
203 IOVectorSortElem sortelems
[src
->niov
];
207 /* Sort by source iovecs by base address */
208 for (i
= 0; i
< src
->niov
; i
++) {
209 sortelems
[i
].src_index
= i
;
210 sortelems
[i
].src_iov
= &src
->iov
[i
];
212 qsort(sortelems
, src
->niov
, sizeof(sortelems
[0]), sortelem_cmp_src_base
);
214 /* Allocate buffer space taking into account overlapping iovecs */
216 for (i
= 0; i
< src
->niov
; i
++) {
217 struct iovec
*cur
= sortelems
[i
].src_iov
;
218 ptrdiff_t rewind
= 0;
221 if (last_end
&& last_end
> cur
->iov_base
) {
222 rewind
= last_end
- cur
->iov_base
;
225 sortelems
[i
].dest_base
= buf
- rewind
;
226 buf
+= cur
->iov_len
- MIN(rewind
, cur
->iov_len
);
227 last_end
= MAX(cur
->iov_base
+ cur
->iov_len
, last_end
);
230 /* Sort by source iovec index and build destination iovec */
231 qsort(sortelems
, src
->niov
, sizeof(sortelems
[0]), sortelem_cmp_src_index
);
232 for (i
= 0; i
< src
->niov
; i
++) {
233 qemu_iovec_add(dest
, sortelems
[i
].dest_base
, src
->iov
[i
].iov_len
);
237 static BlkverifyAIOCB
*blkverify_aio_get(BlockDriverState
*bs
, bool is_write
,
238 int64_t sector_num
, QEMUIOVector
*qiov
,
240 BlockDriverCompletionFunc
*cb
,
243 BlkverifyAIOCB
*acb
= qemu_aio_get(&blkverify_aio_pool
, bs
, cb
, opaque
);
246 acb
->is_write
= is_write
;
247 acb
->sector_num
= sector_num
;
248 acb
->nb_sectors
= nb_sectors
;
249 acb
->ret
= -EINPROGRESS
;
254 acb
->finished
= NULL
;
258 static void blkverify_aio_bh(void *opaque
)
260 BlkverifyAIOCB
*acb
= opaque
;
262 qemu_bh_delete(acb
->bh
);
264 qemu_iovec_destroy(&acb
->raw_qiov
);
265 qemu_vfree(acb
->buf
);
267 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
269 *acb
->finished
= true;
271 qemu_aio_release(acb
);
274 static void blkverify_aio_cb(void *opaque
, int ret
)
276 BlkverifyAIOCB
*acb
= opaque
;
278 switch (++acb
->done
) {
284 if (acb
->ret
!= ret
) {
285 blkverify_err(acb
, "return value mismatch %d != %d", acb
->ret
, ret
);
292 acb
->bh
= qemu_bh_new(blkverify_aio_bh
, acb
);
293 qemu_bh_schedule(acb
->bh
);
298 static void blkverify_verify_readv(BlkverifyAIOCB
*acb
)
300 ssize_t offset
= blkverify_iovec_compare(acb
->qiov
, &acb
->raw_qiov
);
302 blkverify_err(acb
, "contents mismatch in sector %ld",
303 acb
->sector_num
+ (offset
/ BDRV_SECTOR_SIZE
));
307 static BlockDriverAIOCB
*blkverify_aio_readv(BlockDriverState
*bs
,
308 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
309 BlockDriverCompletionFunc
*cb
, void *opaque
)
311 BDRVBlkverifyState
*s
= bs
->opaque
;
312 BlkverifyAIOCB
*acb
= blkverify_aio_get(bs
, false, sector_num
, qiov
,
313 nb_sectors
, cb
, opaque
);
315 acb
->verify
= blkverify_verify_readv
;
316 acb
->buf
= qemu_blockalign(bs
->file
, qiov
->size
);
317 qemu_iovec_init(&acb
->raw_qiov
, acb
->qiov
->niov
);
318 blkverify_iovec_clone(&acb
->raw_qiov
, qiov
, acb
->buf
);
320 if (!bdrv_aio_readv(s
->test_file
, sector_num
, qiov
, nb_sectors
,
321 blkverify_aio_cb
, acb
)) {
322 blkverify_aio_cb(acb
, -EIO
);
324 if (!bdrv_aio_readv(bs
->file
, sector_num
, &acb
->raw_qiov
, nb_sectors
,
325 blkverify_aio_cb
, acb
)) {
326 blkverify_aio_cb(acb
, -EIO
);
331 static BlockDriverAIOCB
*blkverify_aio_writev(BlockDriverState
*bs
,
332 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
333 BlockDriverCompletionFunc
*cb
, void *opaque
)
335 BDRVBlkverifyState
*s
= bs
->opaque
;
336 BlkverifyAIOCB
*acb
= blkverify_aio_get(bs
, true, sector_num
, qiov
,
337 nb_sectors
, cb
, opaque
);
339 if (!bdrv_aio_writev(s
->test_file
, sector_num
, qiov
, nb_sectors
,
340 blkverify_aio_cb
, acb
)) {
341 blkverify_aio_cb(acb
, -EIO
);
343 if (!bdrv_aio_writev(bs
->file
, sector_num
, qiov
, nb_sectors
,
344 blkverify_aio_cb
, acb
)) {
345 blkverify_aio_cb(acb
, -EIO
);
350 static BlockDriverAIOCB
*blkverify_aio_flush(BlockDriverState
*bs
,
351 BlockDriverCompletionFunc
*cb
,
354 BDRVBlkverifyState
*s
= bs
->opaque
;
356 /* Only flush test file, the raw file is not important */
357 return bdrv_aio_flush(s
->test_file
, cb
, opaque
);
360 static BlockDriver bdrv_blkverify
= {
361 .format_name
= "blkverify",
362 .protocol_name
= "blkverify",
364 .instance_size
= sizeof(BDRVBlkverifyState
),
366 .bdrv_getlength
= blkverify_getlength
,
368 .bdrv_file_open
= blkverify_open
,
369 .bdrv_close
= blkverify_close
,
370 .bdrv_flush
= blkverify_flush
,
372 .bdrv_aio_readv
= blkverify_aio_readv
,
373 .bdrv_aio_writev
= blkverify_aio_writev
,
374 .bdrv_aio_flush
= blkverify_aio_flush
,
377 static void bdrv_blkverify_init(void)
379 bdrv_register(&bdrv_blkverify
);
382 block_init(bdrv_blkverify_init
);