block: Rewrite the snapshot authorization mechanism for block filters.
[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/sockets.h" /* for EINPROGRESS on Windows */
12 #include "block/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 const AIOCBInfo blkverify_aiocb_info = {
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 void blkverify_parse_filename(const char *filename, QDict *options,
73 Error **errp)
74 {
75 const char *c;
76 QString *raw_path;
77
78
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));
84 return;
85 }
86
87 /* Parse the raw image filename */
88 c = strchr(filename, ':');
89 if (c == NULL) {
90 error_setg(errp, "blkverify requires raw copy and original image path");
91 return;
92 }
93
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);
97
98 /* TODO Allow multi-level nesting and set file.filename here */
99 filename = c + 1;
100 qdict_put(options, "x-image", qstring_from_str(filename));
101 }
102
103 static QemuOptsList runtime_opts = {
104 .name = "blkverify",
105 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
106 .desc = {
107 {
108 .name = "x-raw",
109 .type = QEMU_OPT_STRING,
110 .help = "[internal use only, will be removed]",
111 },
112 {
113 .name = "x-image",
114 .type = QEMU_OPT_STRING,
115 .help = "[internal use only, will be removed]",
116 },
117 { /* end of list */ }
118 },
119 };
120
121 static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,
122 Error **errp)
123 {
124 BDRVBlkverifyState *s = bs->opaque;
125 QemuOpts *opts;
126 Error *local_err = NULL;
127 int ret;
128
129 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
130 qemu_opts_absorb_qdict(opts, options, &local_err);
131 if (local_err) {
132 error_propagate(errp, local_err);
133 ret = -EINVAL;
134 goto fail;
135 }
136
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);
141 if (ret < 0) {
142 error_propagate(errp, local_err);
143 goto fail;
144 }
145
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);
150 if (ret < 0) {
151 error_propagate(errp, local_err);
152 s->test_file = NULL;
153 goto fail;
154 }
155
156 ret = 0;
157 fail:
158 return ret;
159 }
160
161 static void blkverify_close(BlockDriverState *bs)
162 {
163 BDRVBlkverifyState *s = bs->opaque;
164
165 bdrv_unref(s->test_file);
166 s->test_file = NULL;
167 }
168
169 static int64_t blkverify_getlength(BlockDriverState *bs)
170 {
171 BDRVBlkverifyState *s = bs->opaque;
172
173 return bdrv_getlength(s->test_file);
174 }
175
176 static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write,
177 int64_t sector_num, QEMUIOVector *qiov,
178 int nb_sectors,
179 BlockDriverCompletionFunc *cb,
180 void *opaque)
181 {
182 BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aiocb_info, bs, cb, opaque);
183
184 acb->bh = NULL;
185 acb->is_write = is_write;
186 acb->sector_num = sector_num;
187 acb->nb_sectors = nb_sectors;
188 acb->ret = -EINPROGRESS;
189 acb->done = 0;
190 acb->qiov = qiov;
191 acb->buf = NULL;
192 acb->verify = NULL;
193 acb->finished = NULL;
194 return acb;
195 }
196
197 static void blkverify_aio_bh(void *opaque)
198 {
199 BlkverifyAIOCB *acb = opaque;
200
201 qemu_bh_delete(acb->bh);
202 if (acb->buf) {
203 qemu_iovec_destroy(&acb->raw_qiov);
204 qemu_vfree(acb->buf);
205 }
206 acb->common.cb(acb->common.opaque, acb->ret);
207 if (acb->finished) {
208 *acb->finished = true;
209 }
210 qemu_aio_release(acb);
211 }
212
213 static void blkverify_aio_cb(void *opaque, int ret)
214 {
215 BlkverifyAIOCB *acb = opaque;
216
217 switch (++acb->done) {
218 case 1:
219 acb->ret = ret;
220 break;
221
222 case 2:
223 if (acb->ret != ret) {
224 blkverify_err(acb, "return value mismatch %d != %d", acb->ret, ret);
225 }
226
227 if (acb->verify) {
228 acb->verify(acb);
229 }
230
231 acb->bh = qemu_bh_new(blkverify_aio_bh, acb);
232 qemu_bh_schedule(acb->bh);
233 break;
234 }
235 }
236
237 static void blkverify_verify_readv(BlkverifyAIOCB *acb)
238 {
239 ssize_t offset = qemu_iovec_compare(acb->qiov, &acb->raw_qiov);
240 if (offset != -1) {
241 blkverify_err(acb, "contents mismatch in sector %" PRId64,
242 acb->sector_num + (int64_t)(offset / BDRV_SECTOR_SIZE));
243 }
244 }
245
246 static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs,
247 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
248 BlockDriverCompletionFunc *cb, void *opaque)
249 {
250 BDRVBlkverifyState *s = bs->opaque;
251 BlkverifyAIOCB *acb = blkverify_aio_get(bs, false, sector_num, qiov,
252 nb_sectors, cb, opaque);
253
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);
258
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);
263 return &acb->common;
264 }
265
266 static BlockDriverAIOCB *blkverify_aio_writev(BlockDriverState *bs,
267 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
268 BlockDriverCompletionFunc *cb, void *opaque)
269 {
270 BDRVBlkverifyState *s = bs->opaque;
271 BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov,
272 nb_sectors, cb, opaque);
273
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);
278 return &acb->common;
279 }
280
281 static BlockDriverAIOCB *blkverify_aio_flush(BlockDriverState *bs,
282 BlockDriverCompletionFunc *cb,
283 void *opaque)
284 {
285 BDRVBlkverifyState *s = bs->opaque;
286
287 /* Only flush test file, the raw file is not important */
288 return bdrv_aio_flush(s->test_file, cb, opaque);
289 }
290
291 static bool blkverify_recurse_is_first_non_filter(BlockDriverState *bs,
292 BlockDriverState *candidate)
293 {
294 BDRVBlkverifyState *s = bs->opaque;
295
296 bool perm = bdrv_recurse_is_first_non_filter(bs->file, candidate);
297
298 if (perm) {
299 return true;
300 }
301
302 return bdrv_recurse_is_first_non_filter(s->test_file, candidate);
303 }
304
305 static BlockDriver bdrv_blkverify = {
306 .format_name = "blkverify",
307 .protocol_name = "blkverify",
308 .instance_size = sizeof(BDRVBlkverifyState),
309
310 .bdrv_parse_filename = blkverify_parse_filename,
311 .bdrv_file_open = blkverify_open,
312 .bdrv_close = blkverify_close,
313 .bdrv_getlength = blkverify_getlength,
314
315 .bdrv_aio_readv = blkverify_aio_readv,
316 .bdrv_aio_writev = blkverify_aio_writev,
317 .bdrv_aio_flush = blkverify_aio_flush,
318
319 .is_filter = true,
320 .bdrv_recurse_is_first_non_filter = blkverify_recurse_is_first_non_filter,
321 };
322
323 static void bdrv_blkverify_init(void)
324 {
325 bdrv_register(&bdrv_blkverify);
326 }
327
328 block_init(bdrv_blkverify_init);