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 blkverify_err(BlkverifyAIOCB *acb, const char *fmt, ...)
  57 {
  58     va_list ap;
  59
  60     va_start(ap, fmt);
  61     fprintf(stderr, "blkverify: %s sector_num=%" PRId64 " nb_sectors=%d ",
  62             acb->is_write ? "write" : "read", acb->sector_num,
  63             acb->nb_sectors);
  64     vfprintf(stderr, fmt, ap);
  65     fprintf(stderr, "\n");
  66     va_end(ap);
  67     exit(1);
  68 }
  69
  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)
  72 {
  73     BDRVBlkverifyState *s = bs->opaque;
  74     int ret;
  75     char *raw, *c;
  76
  77     /* Parse the blkverify: prefix */
  78     if (strncmp(filename, "blkverify:", strlen("blkverify:"))) {
  79         return -EINVAL;
  80     }
  81     filename += strlen("blkverify:");
  82
  83     /* Parse the raw image filename */
  84     c = strchr(filename, ':');
  85     if (c == NULL) {
  86         return -EINVAL;
  87     }
  88
  89     raw = strdup(filename);
  90     raw[c - filename] = '\0';
  91     ret = bdrv_file_open(&bs->file, raw, flags);
  92     free(raw);
  93     if (ret < 0) {
  94         return ret;
  95     }
  96     filename = c + 1;
  97
  98     /* Open the test file */
  99     s->test_file = bdrv_new("");
 100     ret = bdrv_open(s->test_file, filename, flags, NULL);
 101     if (ret < 0) {
 102         bdrv_delete(s->test_file);
 103         s->test_file = NULL;
 104         return ret;
 105     }
 106
 107     return 0;
 108 }
 109
 110 static void blkverify_close(BlockDriverState *bs)
 111 {
 112     BDRVBlkverifyState *s = bs->opaque;
 113
 114     bdrv_delete(s->test_file);
 115     s->test_file = NULL;
 116 }
 117
 118 static void blkverify_flush(BlockDriverState *bs)
 119 {
 120     BDRVBlkverifyState *s = bs->opaque;
 121
 122     /* Only flush test file, the raw file is not important */
 123     bdrv_flush(s->test_file);
 124 }
 125
 126 static int64_t blkverify_getlength(BlockDriverState *bs)
 127 {
 128     BDRVBlkverifyState *s = bs->opaque;
 129
 130     return bdrv_getlength(s->test_file);
 131 }
 132
 133 /**
 134  * Check that I/O vector contents are identical
 135  *
 136  * @a:          I/O vector
 137  * @b:          I/O vector
 138  * @ret:        Offset to first mismatching byte or -1 if match
 139  */
 140 static ssize_t blkverify_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
 141 {
 142     int i;
 143     ssize_t offset = 0;
 144
 145     assert(a->niov == b->niov);
 146     for (i = 0; i < a->niov; i++) {
 147         size_t len = 0;
 148         uint8_t *p = (uint8_t *)a->iov[i].iov_base;
 149         uint8_t *q = (uint8_t *)b->iov[i].iov_base;
 150
 151         assert(a->iov[i].iov_len == b->iov[i].iov_len);
 152         while (len < a->iov[i].iov_len && *p++ == *q++) {
 153             len++;
 154         }
 155
 156         offset += len;
 157
 158         if (len != a->iov[i].iov_len) {
 159             return offset;
 160         }
 161     }
 162     return -1;
 163 }
 164
 165 typedef struct {
 166     int src_index;
 167     struct iovec *src_iov;
 168     void *dest_base;
 169 } IOVectorSortElem;
 170
 171 static int sortelem_cmp_src_base(const void *a, const void *b)
 172 {
 173     const IOVectorSortElem *elem_a = a;
 174     const IOVectorSortElem *elem_b = b;
 175
 176     /* Don't overflow */
 177     if (elem_a->src_iov->iov_base < elem_b->src_iov->iov_base) {
 178         return -1;
 179     } else if (elem_a->src_iov->iov_base > elem_b->src_iov->iov_base) {
 180         return 1;
 181     } else {
 182         return 0;
 183     }
 184 }
 185
 186 static int sortelem_cmp_src_index(const void *a, const void *b)
 187 {
 188     const IOVectorSortElem *elem_a = a;
 189     const IOVectorSortElem *elem_b = b;
 190
 191     return elem_a->src_index - elem_b->src_index;
 192 }
 193
 194 /**
 195  * Copy contents of I/O vector
 196  *
 197  * The relative relationships of overlapping iovecs are preserved.  This is
 198  * necessary to ensure identical semantics in the cloned I/O vector.
 199  */
 200 static void blkverify_iovec_clone(QEMUIOVector *dest, const QEMUIOVector *src,
 201                                   void *buf)
 202 {
 203     IOVectorSortElem sortelems[src->niov];
 204     void *last_end;
 205     int i;
 206
 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];
 211     }
 212     qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_base);
 213
 214     /* Allocate buffer space taking into account overlapping iovecs */
 215     last_end = NULL;
 216     for (i = 0; i < src->niov; i++) {
 217         struct iovec *cur = sortelems[i].src_iov;
 218         ptrdiff_t rewind = 0;
 219
 220         /* Detect overlap */
 221         if (last_end && last_end > cur->iov_base) {
 222             rewind = last_end - cur->iov_base;
 223         }
 224
 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);
 228     }
 229
 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);
 234     }
 235 }
 236
 237 static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write,
 238                                          int64_t sector_num, QEMUIOVector *qiov,
 239                                          int nb_sectors,
 240                                          BlockDriverCompletionFunc *cb,
 241                                          void *opaque)
 242 {
 243     BlkverifyAIOCB *acb = qemu_aio_get(&blkverify_aio_pool, bs, cb, opaque);
 244
 245     acb->bh = NULL;
 246     acb->is_write = is_write;
 247     acb->sector_num = sector_num;
 248     acb->nb_sectors = nb_sectors;
 249     acb->ret = -EINPROGRESS;
 250     acb->done = 0;
 251     acb->qiov = qiov;
 252     acb->buf = NULL;
 253     acb->verify = NULL;
 254     acb->finished = NULL;
 255     return acb;
 256 }
 257
 258 static void blkverify_aio_bh(void *opaque)
 259 {
 260     BlkverifyAIOCB *acb = opaque;
 261
 262     qemu_bh_delete(acb->bh);
 263     if (acb->buf) {
 264         qemu_iovec_destroy(&acb->raw_qiov);
 265         qemu_vfree(acb->buf);
 266     }
 267     acb->common.cb(acb->common.opaque, acb->ret);
 268     if (acb->finished) {
 269         *acb->finished = true;
 270     }
 271     qemu_aio_release(acb);
 272 }
 273
 274 static void blkverify_aio_cb(void *opaque, int ret)
 275 {
 276     BlkverifyAIOCB *acb = opaque;
 277
 278     switch (++acb->done) {
 279     case 1:
 280         acb->ret = ret;
 281         break;
 282
 283     case 2:
 284         if (acb->ret != ret) {
 285             blkverify_err(acb, "return value mismatch %d != %d", acb->ret, ret);
 286         }
 287
 288         if (acb->verify) {
 289             acb->verify(acb);
 290         }
 291
 292         acb->bh = qemu_bh_new(blkverify_aio_bh, acb);
 293         qemu_bh_schedule(acb->bh);
 294         break;
 295     }
 296 }
 297
 298 static void blkverify_verify_readv(BlkverifyAIOCB *acb)
 299 {
 300     ssize_t offset = blkverify_iovec_compare(acb->qiov, &acb->raw_qiov);
 301     if (offset != -1) {
 302         blkverify_err(acb, "contents mismatch in sector %ld",
 303                       acb->sector_num + (offset / BDRV_SECTOR_SIZE));
 304     }
 305 }
 306
 307 static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs,
 308         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 309         BlockDriverCompletionFunc *cb, void *opaque)
 310 {
 311     BDRVBlkverifyState *s = bs->opaque;
 312     BlkverifyAIOCB *acb = blkverify_aio_get(bs, false, sector_num, qiov,
 313                                             nb_sectors, cb, opaque);
 314
 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);
 319
 320     if (!bdrv_aio_readv(s->test_file, sector_num, qiov, nb_sectors,
 321                         blkverify_aio_cb, acb)) {
 322         blkverify_aio_cb(acb, -EIO);
 323     }
 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);
 327     }
 328     return &acb->common;
 329 }
 330
 331 static BlockDriverAIOCB *blkverify_aio_writev(BlockDriverState *bs,
 332         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 333         BlockDriverCompletionFunc *cb, void *opaque)
 334 {
 335     BDRVBlkverifyState *s = bs->opaque;
 336     BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov,
 337                                             nb_sectors, cb, opaque);
 338
 339     if (!bdrv_aio_writev(s->test_file, sector_num, qiov, nb_sectors,
 340                          blkverify_aio_cb, acb)) {
 341         blkverify_aio_cb(acb, -EIO);
 342     }
 343     if (!bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors,
 344                          blkverify_aio_cb, acb)) {
 345         blkverify_aio_cb(acb, -EIO);
 346     }
 347     return &acb->common;
 348 }
 349
 350 static BlockDriverAIOCB *blkverify_aio_flush(BlockDriverState *bs,
 351                                              BlockDriverCompletionFunc *cb,
 352                                              void *opaque)
 353 {
 354     BDRVBlkverifyState *s = bs->opaque;
 355
 356     /* Only flush test file, the raw file is not important */
 357     return bdrv_aio_flush(s->test_file, cb, opaque);
 358 }
 359
 360 static BlockDriver bdrv_blkverify = {
 361     .format_name        = "blkverify",
 362     .protocol_name      = "blkverify",
 363
 364     .instance_size      = sizeof(BDRVBlkverifyState),
 365
 366     .bdrv_getlength     = blkverify_getlength,
 367
 368     .bdrv_file_open     = blkverify_open,
 369     .bdrv_close         = blkverify_close,
 370     .bdrv_flush         = blkverify_flush,
 371
 372     .bdrv_aio_readv     = blkverify_aio_readv,
 373     .bdrv_aio_writev    = blkverify_aio_writev,
 374     .bdrv_aio_flush     = blkverify_aio_flush,
 375 };
 376
 377 static void bdrv_blkverify_init(void)
 378 {
 379     bdrv_register(&bdrv_blkverify);
 380 }
 381
 382 block_init(bdrv_blkverify_init);