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/sockets.h" /* for EINPROGRESS on Windows */
12 #include "block/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 const AIOCBInfo blkverify_aiocb_info
= {
52 .aiocb_size
= sizeof(BlkverifyAIOCB
),
53 .cancel
= blkverify_aio_cancel
,
56 static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB
*acb
,
62 fprintf(stderr
, "blkverify: %s sector_num=%" PRId64
" nb_sectors=%d ",
63 acb
->is_write
? "write" : "read", acb
->sector_num
,
65 vfprintf(stderr
, fmt
, ap
);
66 fprintf(stderr
, "\n");
71 /* Valid blkverify filenames look like blkverify:path/to/raw_image:path/to/image */
72 static void blkverify_parse_filename(const char *filename
, QDict
*options
,
79 /* Parse the blkverify: prefix */
80 if (!strstart(filename
, "blkverify:", &filename
)) {
81 /* There was no prefix; therefore, all options have to be already
82 present in the QDict (except for the filename) */
83 qdict_put(options
, "x-image", qstring_from_str(filename
));
87 /* Parse the raw image filename */
88 c
= strchr(filename
, ':');
90 error_setg(errp
, "blkverify requires raw copy and original image path");
94 /* TODO Implement option pass-through and set raw.filename here */
95 raw_path
= qstring_from_substr(filename
, 0, c
- filename
- 1);
96 qdict_put(options
, "x-raw", raw_path
);
98 /* TODO Allow multi-level nesting and set file.filename here */
100 qdict_put(options
, "x-image", qstring_from_str(filename
));
103 static QemuOptsList runtime_opts
= {
105 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
109 .type
= QEMU_OPT_STRING
,
110 .help
= "[internal use only, will be removed]",
114 .type
= QEMU_OPT_STRING
,
115 .help
= "[internal use only, will be removed]",
117 { /* end of list */ }
121 static int blkverify_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
124 BDRVBlkverifyState
*s
= bs
->opaque
;
126 Error
*local_err
= NULL
;
129 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
130 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
132 error_propagate(errp
, local_err
);
137 /* Open the raw file */
138 assert(bs
->file
== NULL
);
139 ret
= bdrv_open_image(&bs
->file
, qemu_opt_get(opts
, "x-raw"), options
,
140 "raw", flags
| BDRV_O_PROTOCOL
, false, &local_err
);
142 error_propagate(errp
, local_err
);
146 /* Open the test file */
147 assert(s
->test_file
== NULL
);
148 ret
= bdrv_open_image(&s
->test_file
, qemu_opt_get(opts
, "x-image"), options
,
149 "test", flags
, false, &local_err
);
151 error_propagate(errp
, local_err
);
161 static void blkverify_close(BlockDriverState
*bs
)
163 BDRVBlkverifyState
*s
= bs
->opaque
;
165 bdrv_unref(s
->test_file
);
169 static int64_t blkverify_getlength(BlockDriverState
*bs
)
171 BDRVBlkverifyState
*s
= bs
->opaque
;
173 return bdrv_getlength(s
->test_file
);
176 static BlkverifyAIOCB
*blkverify_aio_get(BlockDriverState
*bs
, bool is_write
,
177 int64_t sector_num
, QEMUIOVector
*qiov
,
179 BlockDriverCompletionFunc
*cb
,
182 BlkverifyAIOCB
*acb
= qemu_aio_get(&blkverify_aiocb_info
, bs
, cb
, opaque
);
185 acb
->is_write
= is_write
;
186 acb
->sector_num
= sector_num
;
187 acb
->nb_sectors
= nb_sectors
;
188 acb
->ret
= -EINPROGRESS
;
193 acb
->finished
= NULL
;
197 static void blkverify_aio_bh(void *opaque
)
199 BlkverifyAIOCB
*acb
= opaque
;
201 qemu_bh_delete(acb
->bh
);
203 qemu_iovec_destroy(&acb
->raw_qiov
);
204 qemu_vfree(acb
->buf
);
206 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
208 *acb
->finished
= true;
210 qemu_aio_release(acb
);
213 static void blkverify_aio_cb(void *opaque
, int ret
)
215 BlkverifyAIOCB
*acb
= opaque
;
217 switch (++acb
->done
) {
223 if (acb
->ret
!= ret
) {
224 blkverify_err(acb
, "return value mismatch %d != %d", acb
->ret
, ret
);
231 acb
->bh
= qemu_bh_new(blkverify_aio_bh
, acb
);
232 qemu_bh_schedule(acb
->bh
);
237 static void blkverify_verify_readv(BlkverifyAIOCB
*acb
)
239 ssize_t offset
= qemu_iovec_compare(acb
->qiov
, &acb
->raw_qiov
);
241 blkverify_err(acb
, "contents mismatch in sector %" PRId64
,
242 acb
->sector_num
+ (int64_t)(offset
/ BDRV_SECTOR_SIZE
));
246 static BlockDriverAIOCB
*blkverify_aio_readv(BlockDriverState
*bs
,
247 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
248 BlockDriverCompletionFunc
*cb
, void *opaque
)
250 BDRVBlkverifyState
*s
= bs
->opaque
;
251 BlkverifyAIOCB
*acb
= blkverify_aio_get(bs
, false, sector_num
, qiov
,
252 nb_sectors
, cb
, opaque
);
254 acb
->verify
= blkverify_verify_readv
;
255 acb
->buf
= qemu_blockalign(bs
->file
, qiov
->size
);
256 qemu_iovec_init(&acb
->raw_qiov
, acb
->qiov
->niov
);
257 qemu_iovec_clone(&acb
->raw_qiov
, qiov
, acb
->buf
);
259 bdrv_aio_readv(s
->test_file
, sector_num
, qiov
, nb_sectors
,
260 blkverify_aio_cb
, acb
);
261 bdrv_aio_readv(bs
->file
, sector_num
, &acb
->raw_qiov
, nb_sectors
,
262 blkverify_aio_cb
, acb
);
266 static BlockDriverAIOCB
*blkverify_aio_writev(BlockDriverState
*bs
,
267 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
268 BlockDriverCompletionFunc
*cb
, void *opaque
)
270 BDRVBlkverifyState
*s
= bs
->opaque
;
271 BlkverifyAIOCB
*acb
= blkverify_aio_get(bs
, true, sector_num
, qiov
,
272 nb_sectors
, cb
, opaque
);
274 bdrv_aio_writev(s
->test_file
, sector_num
, qiov
, nb_sectors
,
275 blkverify_aio_cb
, acb
);
276 bdrv_aio_writev(bs
->file
, sector_num
, qiov
, nb_sectors
,
277 blkverify_aio_cb
, acb
);
281 static BlockDriverAIOCB
*blkverify_aio_flush(BlockDriverState
*bs
,
282 BlockDriverCompletionFunc
*cb
,
285 BDRVBlkverifyState
*s
= bs
->opaque
;
287 /* Only flush test file, the raw file is not important */
288 return bdrv_aio_flush(s
->test_file
, cb
, opaque
);
291 static bool blkverify_recurse_is_first_non_filter(BlockDriverState
*bs
,
292 BlockDriverState
*candidate
)
294 BDRVBlkverifyState
*s
= bs
->opaque
;
296 bool perm
= bdrv_recurse_is_first_non_filter(bs
->file
, candidate
);
302 return bdrv_recurse_is_first_non_filter(s
->test_file
, candidate
);
305 static BlockDriver bdrv_blkverify
= {
306 .format_name
= "blkverify",
307 .protocol_name
= "blkverify",
308 .instance_size
= sizeof(BDRVBlkverifyState
),
310 .bdrv_parse_filename
= blkverify_parse_filename
,
311 .bdrv_file_open
= blkverify_open
,
312 .bdrv_close
= blkverify_close
,
313 .bdrv_getlength
= blkverify_getlength
,
315 .bdrv_aio_readv
= blkverify_aio_readv
,
316 .bdrv_aio_writev
= blkverify_aio_writev
,
317 .bdrv_aio_flush
= blkverify_aio_flush
,
320 .bdrv_recurse_is_first_non_filter
= blkverify_recurse_is_first_non_filter
,
323 static void bdrv_blkverify_init(void)
325 bdrv_register(&bdrv_blkverify
);
328 block_init(bdrv_blkverify_init
);