PPC: e500mc: add missing IVORs to bitmap
[qemu.git] / block / blkverify.c
1 /*
2 * Block protocol for block driver correctness testing
3 *
4 * Copyright (C) 2010 IBM, Corp.
5 *
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.
8 */
9
10 #include <stdarg.h>
11 #include "qemu_socket.h" /* for EINPROGRESS on Windows */
12 #include "block_int.h"
13
14 typedef struct {
15 BlockDriverState *test_file;
16 } BDRVBlkverifyState;
17
18 typedef struct BlkverifyAIOCB BlkverifyAIOCB;
19 struct BlkverifyAIOCB {
20 BlockDriverAIOCB common;
21 QEMUBH *bh;
22
23 /* Request metadata */
24 bool is_write;
25 int64_t sector_num;
26 int nb_sectors;
27
28 int ret; /* first completed request's result */
29 unsigned int done; /* completion counter */
30 bool *finished; /* completion signal for cancel */
31
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 */
35
36 void (*verify)(BlkverifyAIOCB *acb);
37 };
38
39 static void blkverify_aio_cancel(BlockDriverAIOCB *blockacb)
40 {
41 BlkverifyAIOCB *acb = (BlkverifyAIOCB *)blockacb;
42 bool finished = false;
43
44 /* Wait until request completes, invokes its callback, and frees itself */
45 acb->finished = &finished;
46 while (!finished) {
47 qemu_aio_wait();
48 }
49 }
50
51 static AIOPool blkverify_aio_pool = {
52 .aiocb_size = sizeof(BlkverifyAIOCB),
53 .cancel = blkverify_aio_cancel,
54 };
55
56 static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb,
57 const char *fmt, ...)
58 {
59 va_list ap;
60
61 va_start(ap, fmt);
62 fprintf(stderr, "blkverify: %s sector_num=%" PRId64 " nb_sectors=%d ",
63 acb->is_write ? "write" : "read", acb->sector_num,
64 acb->nb_sectors);
65 vfprintf(stderr, fmt, ap);
66 fprintf(stderr, "\n");
67 va_end(ap);
68 exit(1);
69 }
70
71 /* Valid blkverify filenames look like blkverify:path/to/raw_image:path/to/image */
72 static int blkverify_open(BlockDriverState *bs, const char *filename, int flags)
73 {
74 BDRVBlkverifyState *s = bs->opaque;
75 int ret;
76 char *raw, *c;
77
78 /* Parse the blkverify: prefix */
79 if (strncmp(filename, "blkverify:", strlen("blkverify:"))) {
80 return -EINVAL;
81 }
82 filename += strlen("blkverify:");
83
84 /* Parse the raw image filename */
85 c = strchr(filename, ':');
86 if (c == NULL) {
87 return -EINVAL;
88 }
89
90 raw = g_strdup(filename);
91 raw[c - filename] = '\0';
92 ret = bdrv_file_open(&bs->file, raw, flags);
93 g_free(raw);
94 if (ret < 0) {
95 return ret;
96 }
97 filename = c + 1;
98
99 /* Open the test file */
100 s->test_file = bdrv_new("");
101 ret = bdrv_open(s->test_file, filename, flags, NULL);
102 if (ret < 0) {
103 bdrv_delete(s->test_file);
104 s->test_file = NULL;
105 return ret;
106 }
107
108 return 0;
109 }
110
111 static void blkverify_close(BlockDriverState *bs)
112 {
113 BDRVBlkverifyState *s = bs->opaque;
114
115 bdrv_delete(s->test_file);
116 s->test_file = NULL;
117 }
118
119 static int64_t blkverify_getlength(BlockDriverState *bs)
120 {
121 BDRVBlkverifyState *s = bs->opaque;
122
123 return bdrv_getlength(s->test_file);
124 }
125
126 /**
127 * Check that I/O vector contents are identical
128 *
129 * @a: I/O vector
130 * @b: I/O vector
131 * @ret: Offset to first mismatching byte or -1 if match
132 */
133 static ssize_t blkverify_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
134 {
135 int i;
136 ssize_t offset = 0;
137
138 assert(a->niov == b->niov);
139 for (i = 0; i < a->niov; i++) {
140 size_t len = 0;
141 uint8_t *p = (uint8_t *)a->iov[i].iov_base;
142 uint8_t *q = (uint8_t *)b->iov[i].iov_base;
143
144 assert(a->iov[i].iov_len == b->iov[i].iov_len);
145 while (len < a->iov[i].iov_len && *p++ == *q++) {
146 len++;
147 }
148
149 offset += len;
150
151 if (len != a->iov[i].iov_len) {
152 return offset;
153 }
154 }
155 return -1;
156 }
157
158 typedef struct {
159 int src_index;
160 struct iovec *src_iov;
161 void *dest_base;
162 } IOVectorSortElem;
163
164 static int sortelem_cmp_src_base(const void *a, const void *b)
165 {
166 const IOVectorSortElem *elem_a = a;
167 const IOVectorSortElem *elem_b = b;
168
169 /* Don't overflow */
170 if (elem_a->src_iov->iov_base < elem_b->src_iov->iov_base) {
171 return -1;
172 } else if (elem_a->src_iov->iov_base > elem_b->src_iov->iov_base) {
173 return 1;
174 } else {
175 return 0;
176 }
177 }
178
179 static int sortelem_cmp_src_index(const void *a, const void *b)
180 {
181 const IOVectorSortElem *elem_a = a;
182 const IOVectorSortElem *elem_b = b;
183
184 return elem_a->src_index - elem_b->src_index;
185 }
186
187 /**
188 * Copy contents of I/O vector
189 *
190 * The relative relationships of overlapping iovecs are preserved. This is
191 * necessary to ensure identical semantics in the cloned I/O vector.
192 */
193 static void blkverify_iovec_clone(QEMUIOVector *dest, const QEMUIOVector *src,
194 void *buf)
195 {
196 IOVectorSortElem sortelems[src->niov];
197 void *last_end;
198 int i;
199
200 /* Sort by source iovecs by base address */
201 for (i = 0; i < src->niov; i++) {
202 sortelems[i].src_index = i;
203 sortelems[i].src_iov = &src->iov[i];
204 }
205 qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_base);
206
207 /* Allocate buffer space taking into account overlapping iovecs */
208 last_end = NULL;
209 for (i = 0; i < src->niov; i++) {
210 struct iovec *cur = sortelems[i].src_iov;
211 ptrdiff_t rewind = 0;
212
213 /* Detect overlap */
214 if (last_end && last_end > cur->iov_base) {
215 rewind = last_end - cur->iov_base;
216 }
217
218 sortelems[i].dest_base = buf - rewind;
219 buf += cur->iov_len - MIN(rewind, cur->iov_len);
220 last_end = MAX(cur->iov_base + cur->iov_len, last_end);
221 }
222
223 /* Sort by source iovec index and build destination iovec */
224 qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_index);
225 for (i = 0; i < src->niov; i++) {
226 qemu_iovec_add(dest, sortelems[i].dest_base, src->iov[i].iov_len);
227 }
228 }
229
230 static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write,
231 int64_t sector_num, QEMUIOVector *qiov,
232 int nb_sectors,
233 BlockDriverCompletionFunc *cb,
234 void *opaque)
235 {
236 BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aio_pool, bs, cb, opaque);
237
238 acb->bh = NULL;
239 acb->is_write = is_write;
240 acb->sector_num = sector_num;
241 acb->nb_sectors = nb_sectors;
242 acb->ret = -EINPROGRESS;
243 acb->done = 0;
244 acb->qiov = qiov;
245 acb->buf = NULL;
246 acb->verify = NULL;
247 acb->finished = NULL;
248 return acb;
249 }
250
251 static void blkverify_aio_bh(void *opaque)
252 {
253 BlkverifyAIOCB *acb = opaque;
254
255 qemu_bh_delete(acb->bh);
256 if (acb->buf) {
257 qemu_iovec_destroy(&acb->raw_qiov);
258 qemu_vfree(acb->buf);
259 }
260 acb->common.cb(acb->common.opaque, acb->ret);
261 if (acb->finished) {
262 *acb->finished = true;
263 }
264 qemu_aio_release(acb);
265 }
266
267 static void blkverify_aio_cb(void *opaque, int ret)
268 {
269 BlkverifyAIOCB *acb = opaque;
270
271 switch (++acb->done) {
272 case 1:
273 acb->ret = ret;
274 break;
275
276 case 2:
277 if (acb->ret != ret) {
278 blkverify_err(acb, "return value mismatch %d != %d", acb->ret, ret);
279 }
280
281 if (acb->verify) {
282 acb->verify(acb);
283 }
284
285 acb->bh = qemu_bh_new(blkverify_aio_bh, acb);
286 qemu_bh_schedule(acb->bh);
287 break;
288 }
289 }
290
291 static void blkverify_verify_readv(BlkverifyAIOCB *acb)
292 {
293 ssize_t offset = blkverify_iovec_compare(acb->qiov, &acb->raw_qiov);
294 if (offset != -1) {
295 blkverify_err(acb, "contents mismatch in sector %" PRId64,
296 acb->sector_num + (int64_t)(offset / BDRV_SECTOR_SIZE));
297 }
298 }
299
300 static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs,
301 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
302 BlockDriverCompletionFunc *cb, void *opaque)
303 {
304 BDRVBlkverifyState *s = bs->opaque;
305 BlkverifyAIOCB *acb = blkverify_aio_get(bs, false, sector_num, qiov,
306 nb_sectors, cb, opaque);
307
308 acb->verify = blkverify_verify_readv;
309 acb->buf = qemu_blockalign(bs->file, qiov->size);
310 qemu_iovec_init(&acb->raw_qiov, acb->qiov->niov);
311 blkverify_iovec_clone(&acb->raw_qiov, qiov, acb->buf);
312
313 bdrv_aio_readv(s->test_file, sector_num, qiov, nb_sectors,
314 blkverify_aio_cb, acb);
315 bdrv_aio_readv(bs->file, sector_num, &acb->raw_qiov, nb_sectors,
316 blkverify_aio_cb, acb);
317 return &acb->common;
318 }
319
320 static BlockDriverAIOCB *blkverify_aio_writev(BlockDriverState *bs,
321 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
322 BlockDriverCompletionFunc *cb, void *opaque)
323 {
324 BDRVBlkverifyState *s = bs->opaque;
325 BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov,
326 nb_sectors, cb, opaque);
327
328 bdrv_aio_writev(s->test_file, sector_num, qiov, nb_sectors,
329 blkverify_aio_cb, acb);
330 bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors,
331 blkverify_aio_cb, acb);
332 return &acb->common;
333 }
334
335 static BlockDriverAIOCB *blkverify_aio_flush(BlockDriverState *bs,
336 BlockDriverCompletionFunc *cb,
337 void *opaque)
338 {
339 BDRVBlkverifyState *s = bs->opaque;
340
341 /* Only flush test file, the raw file is not important */
342 return bdrv_aio_flush(s->test_file, cb, opaque);
343 }
344
345 static BlockDriver bdrv_blkverify = {
346 .format_name = "blkverify",
347 .protocol_name = "blkverify",
348
349 .instance_size = sizeof(BDRVBlkverifyState),
350
351 .bdrv_getlength = blkverify_getlength,
352
353 .bdrv_file_open = blkverify_open,
354 .bdrv_close = blkverify_close,
355
356 .bdrv_aio_readv = blkverify_aio_readv,
357 .bdrv_aio_writev = blkverify_aio_writev,
358 .bdrv_aio_flush = blkverify_aio_flush,
359 };
360
361 static void bdrv_blkverify_init(void)
362 {
363 bdrv_register(&bdrv_blkverify);
364 }
365
366 block_init(bdrv_blkverify_init);