block/vdi.c

   1 /*
   2  * Block driver for the Virtual Disk Image (VDI) format
   3  *
   4  * Copyright (c) 2009, 2012 Stefan Weil
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 2 of the License, or
   9  * (at your option) version 3 or any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  * Reference:
  20  * http://forums.virtualbox.org/viewtopic.php?t=8046
  21  *
  22  * This driver supports create / read / write operations on VDI images.
  23  *
  24  * Todo (see also TODO in code):
  25  *
  26  * Some features like snapshots are still missing.
  27  *
  28  * Deallocation of zero-filled blocks and shrinking images are missing, too
  29  * (might be added to common block layer).
  30  *
  31  * Allocation of blocks could be optimized (less writes to block map and
  32  * header).
  33  *
  34  * Read and write of adjacent blocks could be done in one operation
  35  * (current code uses one operation per block (1 MiB).
  36  *
  37  * The code is not thread safe (missing locks for changes in header and
  38  * block table, no problem with current QEMU).
  39  *
  40  * Hints:
  41  *
  42  * Blocks (VDI documentation) correspond to clusters (QEMU).
  43  * QEMU's backing files could be implemented using VDI snapshot files (TODO).
  44  * VDI snapshot files may also contain the complete machine state.
  45  * Maybe this machine state can be converted to QEMU PC machine snapshot data.
  46  *
  47  * The driver keeps a block cache (little endian entries) in memory.
  48  * For the standard block size (1 MiB), a 1 TiB disk will use 4 MiB RAM,
  49  * so this seems to be reasonable.
  50  */
  51
  52 #include "qemu/osdep.h"
  53 #include "qemu/units.h"
  54 #include "qapi/error.h"
  55 #include "qapi/qobject-input-visitor.h"
  56 #include "qapi/qapi-visit-block-core.h"
  57 #include "block/block_int.h"
  58 #include "block/qdict.h"
  59 #include "sysemu/block-backend.h"
  60 #include "qemu/module.h"
  61 #include "qemu/option.h"
  62 #include "qemu/bswap.h"
  63 #include "migration/blocker.h"
  64 #include "qemu/coroutine.h"
  65 #include "qemu/cutils.h"
  66 #include "qemu/uuid.h"
  67
  68 /* Code configuration options. */
  69
  70 /* Enable debug messages. */
  71 //~ #define CONFIG_VDI_DEBUG
  72
  73 /* Support write operations on VDI images. */
  74 #define CONFIG_VDI_WRITE
  75
  76 /* Support non-standard block (cluster) size. This is untested.
  77  * Maybe it will be needed for very large images.
  78  */
  79 //~ #define CONFIG_VDI_BLOCK_SIZE
  80
  81 /* Support static (fixed, pre-allocated) images. */
  82 #define CONFIG_VDI_STATIC_IMAGE
  83
  84 /* Command line option for static images. */
  85 #define BLOCK_OPT_STATIC "static"
  86
  87 #define SECTOR_SIZE 512
  88 #define DEFAULT_CLUSTER_SIZE 1048576
  89 /* Note: can't use 1 * MiB, because it's passed to stringify() */
  90
  91 #if defined(CONFIG_VDI_DEBUG)
  92 #define VDI_DEBUG 1
  93 #else
  94 #define VDI_DEBUG 0
  95 #endif
  96
  97 #define logout(fmt, ...) \
  98     do {                                                                \
  99         if (VDI_DEBUG) {                                                \
 100             fprintf(stderr, "vdi\t%-24s" fmt, __func__, ##__VA_ARGS__); \
 101         }                                                               \
 102     } while (0)
 103
 104 /* Image signature. */
 105 #define VDI_SIGNATURE 0xbeda107f
 106
 107 /* Image version. */
 108 #define VDI_VERSION_1_1 0x00010001
 109
 110 /* Image type. */
 111 #define VDI_TYPE_DYNAMIC 1
 112 #define VDI_TYPE_STATIC  2
 113
 114 /* Innotek / SUN images use these strings in header.text:
 115  * "<<< innotek VirtualBox Disk Image >>>\n"
 116  * "<<< Sun xVM VirtualBox Disk Image >>>\n"
 117  * "<<< Sun VirtualBox Disk Image >>>\n"
 118  * The value does not matter, so QEMU created images use a different text.
 119  */
 120 #define VDI_TEXT "<<< QEMU VM Virtual Disk Image >>>\n"
 121
 122 /* A never-allocated block; semantically arbitrary content. */
 123 #define VDI_UNALLOCATED 0xffffffffU
 124
 125 /* A discarded (no longer allocated) block; semantically zero-filled. */
 126 #define VDI_DISCARDED   0xfffffffeU
 127
 128 #define VDI_IS_ALLOCATED(X) ((X) < VDI_DISCARDED)
 129
 130 /* The bmap will take up VDI_BLOCKS_IN_IMAGE_MAX * sizeof(uint32_t) bytes; since
 131  * the bmap is read and written in a single operation, its size needs to be
 132  * limited to INT_MAX; furthermore, when opening an image, the bmap size is
 133  * rounded up to be aligned on BDRV_SECTOR_SIZE.
 134  * Therefore this should satisfy the following:
 135  * VDI_BLOCKS_IN_IMAGE_MAX * sizeof(uint32_t) + BDRV_SECTOR_SIZE == INT_MAX + 1
 136  * (INT_MAX + 1 is the first value not representable as an int)
 137  * This guarantees that any value below or equal to the constant will, when
 138  * multiplied by sizeof(uint32_t) and rounded up to a BDRV_SECTOR_SIZE boundary,
 139  * still be below or equal to INT_MAX. */
 140 #define VDI_BLOCKS_IN_IMAGE_MAX \
 141     ((unsigned)((INT_MAX + 1u - BDRV_SECTOR_SIZE) / sizeof(uint32_t)))
 142 #define VDI_DISK_SIZE_MAX        ((uint64_t)VDI_BLOCKS_IN_IMAGE_MAX * \
 143                                   (uint64_t)DEFAULT_CLUSTER_SIZE)
 144
 145 static QemuOptsList vdi_create_opts;
 146
 147 typedef struct {
 148     char text[0x40];
 149     uint32_t signature;
 150     uint32_t version;
 151     uint32_t header_size;
 152     uint32_t image_type;
 153     uint32_t image_flags;
 154     char description[256];
 155     uint32_t offset_bmap;
 156     uint32_t offset_data;
 157     uint32_t cylinders;         /* disk geometry, unused here */
 158     uint32_t heads;             /* disk geometry, unused here */
 159     uint32_t sectors;           /* disk geometry, unused here */
 160     uint32_t sector_size;
 161     uint32_t unused1;
 162     uint64_t disk_size;
 163     uint32_t block_size;
 164     uint32_t block_extra;       /* unused here */
 165     uint32_t blocks_in_image;
 166     uint32_t blocks_allocated;
 167     QemuUUID uuid_image;
 168     QemuUUID uuid_last_snap;
 169     QemuUUID uuid_link;
 170     QemuUUID uuid_parent;
 171     uint64_t unused2[7];
 172 } QEMU_PACKED VdiHeader;
 173
 174 QEMU_BUILD_BUG_ON(sizeof(VdiHeader) != 512);
 175
 176 typedef struct {
 177     /* The block map entries are little endian (even in memory). */
 178     uint32_t *bmap;
 179     /* Size of block (bytes). */
 180     uint32_t block_size;
 181     /* First sector of block map. */
 182     uint32_t bmap_sector;
 183     /* VDI header (converted to host endianness). */
 184     VdiHeader header;
 185
 186     CoRwlock bmap_lock;
 187
 188     Error *migration_blocker;
 189 } BDRVVdiState;
 190
 191 static void vdi_header_to_cpu(VdiHeader *header)
 192 {
 193     header->signature = le32_to_cpu(header->signature);
 194     header->version = le32_to_cpu(header->version);
 195     header->header_size = le32_to_cpu(header->header_size);
 196     header->image_type = le32_to_cpu(header->image_type);
 197     header->image_flags = le32_to_cpu(header->image_flags);
 198     header->offset_bmap = le32_to_cpu(header->offset_bmap);
 199     header->offset_data = le32_to_cpu(header->offset_data);
 200     header->cylinders = le32_to_cpu(header->cylinders);
 201     header->heads = le32_to_cpu(header->heads);
 202     header->sectors = le32_to_cpu(header->sectors);
 203     header->sector_size = le32_to_cpu(header->sector_size);
 204     header->disk_size = le64_to_cpu(header->disk_size);
 205     header->block_size = le32_to_cpu(header->block_size);
 206     header->block_extra = le32_to_cpu(header->block_extra);
 207     header->blocks_in_image = le32_to_cpu(header->blocks_in_image);
 208     header->blocks_allocated = le32_to_cpu(header->blocks_allocated);
 209     header->uuid_image = qemu_uuid_bswap(header->uuid_image);
 210     header->uuid_last_snap = qemu_uuid_bswap(header->uuid_last_snap);
 211     header->uuid_link = qemu_uuid_bswap(header->uuid_link);
 212     header->uuid_parent = qemu_uuid_bswap(header->uuid_parent);
 213 }
 214
 215 static void vdi_header_to_le(VdiHeader *header)
 216 {
 217     header->signature = cpu_to_le32(header->signature);
 218     header->version = cpu_to_le32(header->version);
 219     header->header_size = cpu_to_le32(header->header_size);
 220     header->image_type = cpu_to_le32(header->image_type);
 221     header->image_flags = cpu_to_le32(header->image_flags);
 222     header->offset_bmap = cpu_to_le32(header->offset_bmap);
 223     header->offset_data = cpu_to_le32(header->offset_data);
 224     header->cylinders = cpu_to_le32(header->cylinders);
 225     header->heads = cpu_to_le32(header->heads);
 226     header->sectors = cpu_to_le32(header->sectors);
 227     header->sector_size = cpu_to_le32(header->sector_size);
 228     header->disk_size = cpu_to_le64(header->disk_size);
 229     header->block_size = cpu_to_le32(header->block_size);
 230     header->block_extra = cpu_to_le32(header->block_extra);
 231     header->blocks_in_image = cpu_to_le32(header->blocks_in_image);
 232     header->blocks_allocated = cpu_to_le32(header->blocks_allocated);
 233     header->uuid_image = qemu_uuid_bswap(header->uuid_image);
 234     header->uuid_last_snap = qemu_uuid_bswap(header->uuid_last_snap);
 235     header->uuid_link = qemu_uuid_bswap(header->uuid_link);
 236     header->uuid_parent = qemu_uuid_bswap(header->uuid_parent);
 237 }
 238
 239 static void vdi_header_print(VdiHeader *header)
 240 {
 241     char uuidstr[37];
 242     QemuUUID uuid;
 243     logout("text        %s", header->text);
 244     logout("signature   0x%08x\n", header->signature);
 245     logout("header size 0x%04x\n", header->header_size);
 246     logout("image type  0x%04x\n", header->image_type);
 247     logout("image flags 0x%04x\n", header->image_flags);
 248     logout("description %s\n", header->description);
 249     logout("offset bmap 0x%04x\n", header->offset_bmap);
 250     logout("offset data 0x%04x\n", header->offset_data);
 251     logout("cylinders   0x%04x\n", header->cylinders);
 252     logout("heads       0x%04x\n", header->heads);
 253     logout("sectors     0x%04x\n", header->sectors);
 254     logout("sector size 0x%04x\n", header->sector_size);
 255     logout("image size  0x%" PRIx64 " B (%" PRIu64 " MiB)\n",
 256            header->disk_size, header->disk_size / MiB);
 257     logout("block size  0x%04x\n", header->block_size);
 258     logout("block extra 0x%04x\n", header->block_extra);
 259     logout("blocks tot. 0x%04x\n", header->blocks_in_image);
 260     logout("blocks all. 0x%04x\n", header->blocks_allocated);
 261     uuid = header->uuid_image;
 262     qemu_uuid_unparse(&uuid, uuidstr);
 263     logout("uuid image  %s\n", uuidstr);
 264     uuid = header->uuid_last_snap;
 265     qemu_uuid_unparse(&uuid, uuidstr);
 266     logout("uuid snap   %s\n", uuidstr);
 267     uuid = header->uuid_link;
 268     qemu_uuid_unparse(&uuid, uuidstr);
 269     logout("uuid link   %s\n", uuidstr);
 270     uuid = header->uuid_parent;
 271     qemu_uuid_unparse(&uuid, uuidstr);
 272     logout("uuid parent %s\n", uuidstr);
 273 }
 274
 275 static int coroutine_fn vdi_co_check(BlockDriverState *bs, BdrvCheckResult *res,
 276                                      BdrvCheckMode fix)
 277 {
 278     /* TODO: additional checks possible. */
 279     BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
 280     uint32_t blocks_allocated = 0;
 281     uint32_t block;
 282     uint32_t *bmap;
 283     logout("\n");
 284
 285     if (fix) {
 286         return -ENOTSUP;
 287     }
 288
 289     bmap = g_try_new(uint32_t, s->header.blocks_in_image);
 290     if (s->header.blocks_in_image && bmap == NULL) {
 291         res->check_errors++;
 292         return -ENOMEM;
 293     }
 294
 295     memset(bmap, 0xff, s->header.blocks_in_image * sizeof(uint32_t));
 296
 297     /* Check block map and value of blocks_allocated. */
 298     for (block = 0; block < s->header.blocks_in_image; block++) {
 299         uint32_t bmap_entry = le32_to_cpu(s->bmap[block]);
 300         if (VDI_IS_ALLOCATED(bmap_entry)) {
 301             if (bmap_entry < s->header.blocks_in_image) {
 302                 blocks_allocated++;
 303                 if (!VDI_IS_ALLOCATED(bmap[bmap_entry])) {
 304                     bmap[bmap_entry] = bmap_entry;
 305                 } else {
 306                     fprintf(stderr, "ERROR: block index %" PRIu32
 307                             " also used by %" PRIu32 "\n", bmap[bmap_entry], bmap_entry);
 308                     res->corruptions++;
 309                 }
 310             } else {
 311                 fprintf(stderr, "ERROR: block index %" PRIu32
 312                         " too large, is %" PRIu32 "\n", block, bmap_entry);
 313                 res->corruptions++;
 314             }
 315         }
 316     }
 317     if (blocks_allocated != s->header.blocks_allocated) {
 318         fprintf(stderr, "ERROR: allocated blocks mismatch, is %" PRIu32
 319                ", should be %" PRIu32 "\n",
 320                blocks_allocated, s->header.blocks_allocated);
 321         res->corruptions++;
 322     }
 323
 324     g_free(bmap);
 325
 326     return 0;
 327 }
 328
 329 static int vdi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 330 {
 331     /* TODO: vdi_get_info would be needed for machine snapshots.
 332        vm_state_offset is still missing. */
 333     BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
 334     logout("\n");
 335     bdi->cluster_size = s->block_size;
 336     bdi->vm_state_offset = 0;
 337     bdi->unallocated_blocks_are_zero = true;
 338     return 0;
 339 }
 340
 341 static int vdi_make_empty(BlockDriverState *bs)
 342 {
 343     /* TODO: missing code. */
 344     logout("\n");
 345     /* The return value for missing code must be 0, see block.c. */
 346     return 0;
 347 }
 348
 349 static int vdi_probe(const uint8_t *buf, int buf_size, const char *filename)
 350 {
 351     const VdiHeader *header = (const VdiHeader *)buf;
 352     int ret = 0;
 353
 354     logout("\n");
 355
 356     if (buf_size < sizeof(*header)) {
 357         /* Header too small, no VDI. */
 358     } else if (le32_to_cpu(header->signature) == VDI_SIGNATURE) {
 359         ret = 100;
 360     }
 361
 362     if (ret == 0) {
 363         logout("no vdi image\n");
 364     } else {
 365         logout("%s", header->text);
 366     }
 367
 368     return ret;
 369 }
 370
 371 static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
 372                     Error **errp)
 373 {
 374     BDRVVdiState *s = bs->opaque;
 375     VdiHeader header;
 376     size_t bmap_size;
 377     int ret;
 378     Error *local_err = NULL;
 379     QemuUUID uuid_link, uuid_parent;
 380
 381     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 382                                false, errp);
 383     if (!bs->file) {
 384         return -EINVAL;
 385     }
 386
 387     logout("\n");
 388
 389     ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
 390     if (ret < 0) {
 391         goto fail;
 392     }
 393
 394     vdi_header_to_cpu(&header);
 395     if (VDI_DEBUG) {
 396         vdi_header_print(&header);
 397     }
 398
 399     if (header.disk_size > VDI_DISK_SIZE_MAX) {
 400         error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
 401                           ", max supported is 0x%" PRIx64 ")",
 402                           header.disk_size, VDI_DISK_SIZE_MAX);
 403         ret = -ENOTSUP;
 404         goto fail;
 405     }
 406
 407     uuid_link = header.uuid_link;
 408     uuid_parent = header.uuid_parent;
 409
 410     if (header.disk_size % SECTOR_SIZE != 0) {
 411         /* 'VBoxManage convertfromraw' can create images with odd disk sizes.
 412            We accept them but round the disk size to the next multiple of
 413            SECTOR_SIZE. */
 414         logout("odd disk size %" PRIu64 " B, round up\n", header.disk_size);
 415         header.disk_size = ROUND_UP(header.disk_size, SECTOR_SIZE);
 416     }
 417
 418     if (header.signature != VDI_SIGNATURE) {
 419         error_setg(errp, "Image not in VDI format (bad signature %08" PRIx32
 420                    ")", header.signature);
 421         ret = -EINVAL;
 422         goto fail;
 423     } else if (header.version != VDI_VERSION_1_1) {
 424         error_setg(errp, "unsupported VDI image (version %" PRIu32 ".%" PRIu32
 425                    ")", header.version >> 16, header.version & 0xffff);
 426         ret = -ENOTSUP;
 427         goto fail;
 428     } else if (header.offset_bmap % SECTOR_SIZE != 0) {
 429         /* We only support block maps which start on a sector boundary. */
 430         error_setg(errp, "unsupported VDI image (unaligned block map offset "
 431                    "0x%" PRIx32 ")", header.offset_bmap);
 432         ret = -ENOTSUP;
 433         goto fail;
 434     } else if (header.offset_data % SECTOR_SIZE != 0) {
 435         /* We only support data blocks which start on a sector boundary. */
 436         error_setg(errp, "unsupported VDI image (unaligned data offset 0x%"
 437                    PRIx32 ")", header.offset_data);
 438         ret = -ENOTSUP;
 439         goto fail;
 440     } else if (header.sector_size != SECTOR_SIZE) {
 441         error_setg(errp, "unsupported VDI image (sector size %" PRIu32
 442                    " is not %u)", header.sector_size, SECTOR_SIZE);
 443         ret = -ENOTSUP;
 444         goto fail;
 445     } else if (header.block_size != DEFAULT_CLUSTER_SIZE) {
 446         error_setg(errp, "unsupported VDI image (block size %" PRIu32
 447                          " is not %" PRIu32 ")",
 448                    header.block_size, DEFAULT_CLUSTER_SIZE);
 449         ret = -ENOTSUP;
 450         goto fail;
 451     } else if (header.disk_size >
 452                (uint64_t)header.blocks_in_image * header.block_size) {
 453         error_setg(errp, "unsupported VDI image (disk size %" PRIu64 ", "
 454                    "image bitmap has room for %" PRIu64 ")",
 455                    header.disk_size,
 456                    (uint64_t)header.blocks_in_image * header.block_size);
 457         ret = -ENOTSUP;
 458         goto fail;
 459     } else if (!qemu_uuid_is_null(&uuid_link)) {
 460         error_setg(errp, "unsupported VDI image (non-NULL link UUID)");
 461         ret = -ENOTSUP;
 462         goto fail;
 463     } else if (!qemu_uuid_is_null(&uuid_parent)) {
 464         error_setg(errp, "unsupported VDI image (non-NULL parent UUID)");
 465         ret = -ENOTSUP;
 466         goto fail;
 467     } else if (header.blocks_in_image > VDI_BLOCKS_IN_IMAGE_MAX) {
 468         error_setg(errp, "unsupported VDI image "
 469                          "(too many blocks %u, max is %u)",
 470                           header.blocks_in_image, VDI_BLOCKS_IN_IMAGE_MAX);
 471         ret = -ENOTSUP;
 472         goto fail;
 473     }
 474
 475     bs->total_sectors = header.disk_size / SECTOR_SIZE;
 476
 477     s->block_size = header.block_size;
 478     s->bmap_sector = header.offset_bmap / SECTOR_SIZE;
 479     s->header = header;
 480
 481     bmap_size = header.blocks_in_image * sizeof(uint32_t);
 482     bmap_size = DIV_ROUND_UP(bmap_size, SECTOR_SIZE);
 483     s->bmap = qemu_try_blockalign(bs->file->bs, bmap_size * SECTOR_SIZE);
 484     if (s->bmap == NULL) {
 485         ret = -ENOMEM;
 486         goto fail;
 487     }
 488
 489     ret = bdrv_pread(bs->file, header.offset_bmap, s->bmap,
 490                      bmap_size * SECTOR_SIZE);
 491     if (ret < 0) {
 492         goto fail_free_bmap;
 493     }
 494
 495     /* Disable migration when vdi images are used */
 496     error_setg(&s->migration_blocker, "The vdi format used by node '%s' "
 497                "does not support live migration",
 498                bdrv_get_device_or_node_name(bs));
 499     ret = migrate_add_blocker(s->migration_blocker, &local_err);
 500     if (local_err) {
 501         error_propagate(errp, local_err);
 502         error_free(s->migration_blocker);
 503         goto fail_free_bmap;
 504     }
 505
 506     qemu_co_rwlock_init(&s->bmap_lock);
 507
 508     return 0;
 509
 510  fail_free_bmap:
 511     qemu_vfree(s->bmap);
 512
 513  fail:
 514     return ret;
 515 }
 516
 517 static int vdi_reopen_prepare(BDRVReopenState *state,
 518                               BlockReopenQueue *queue, Error **errp)
 519 {
 520     return 0;
 521 }
 522
 523 static int coroutine_fn vdi_co_block_status(BlockDriverState *bs,
 524                                             bool want_zero,
 525                                             int64_t offset, int64_t bytes,
 526                                             int64_t *pnum, int64_t *map,
 527                                             BlockDriverState **file)
 528 {
 529     BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
 530     size_t bmap_index = offset / s->block_size;
 531     size_t index_in_block = offset % s->block_size;
 532     uint32_t bmap_entry = le32_to_cpu(s->bmap[bmap_index]);
 533     int result;
 534
 535     logout("%p, %" PRId64 ", %" PRId64 ", %p\n", bs, offset, bytes, pnum);
 536     *pnum = MIN(s->block_size - index_in_block, bytes);
 537     result = VDI_IS_ALLOCATED(bmap_entry);
 538     if (!result) {
 539         return 0;
 540     }
 541
 542     *map = s->header.offset_data + (uint64_t)bmap_entry * s->block_size +
 543         index_in_block;
 544     *file = bs->file->bs;
 545     return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID |
 546         (s->header.image_type == VDI_TYPE_STATIC ? BDRV_BLOCK_RECURSE : 0);
 547 }
 548
 549 static int coroutine_fn
 550 vdi_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 551               QEMUIOVector *qiov, int flags)
 552 {
 553     BDRVVdiState *s = bs->opaque;
 554     QEMUIOVector local_qiov;
 555     uint32_t bmap_entry;
 556     uint32_t block_index;
 557     uint32_t offset_in_block;
 558     uint32_t n_bytes;
 559     uint64_t bytes_done = 0;
 560     int ret = 0;
 561
 562     logout("\n");
 563
 564     qemu_iovec_init(&local_qiov, qiov->niov);
 565
 566     while (ret >= 0 && bytes > 0) {
 567         block_index = offset / s->block_size;
 568         offset_in_block = offset % s->block_size;
 569         n_bytes = MIN(bytes, s->block_size - offset_in_block);
 570
 571         logout("will read %u bytes starting at offset %" PRIu64 "\n",
 572                n_bytes, offset);
 573
 574         /* prepare next AIO request */
 575         qemu_co_rwlock_rdlock(&s->bmap_lock);
 576         bmap_entry = le32_to_cpu(s->bmap[block_index]);
 577         qemu_co_rwlock_unlock(&s->bmap_lock);
 578         if (!VDI_IS_ALLOCATED(bmap_entry)) {
 579             /* Block not allocated, return zeros, no need to wait. */
 580             qemu_iovec_memset(qiov, bytes_done, 0, n_bytes);
 581             ret = 0;
 582         } else {
 583             uint64_t data_offset = s->header.offset_data +
 584                                    (uint64_t)bmap_entry * s->block_size +
 585                                    offset_in_block;
 586
 587             qemu_iovec_reset(&local_qiov);
 588             qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
 589
 590             ret = bdrv_co_preadv(bs->file, data_offset, n_bytes,
 591                                  &local_qiov, 0);
 592         }
 593         logout("%u bytes read\n", n_bytes);
 594
 595         bytes -= n_bytes;
 596         offset += n_bytes;
 597         bytes_done += n_bytes;
 598     }
 599
 600     qemu_iovec_destroy(&local_qiov);
 601
 602     return ret;
 603 }
 604
 605 static int coroutine_fn
 606 vdi_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 607                QEMUIOVector *qiov, int flags)
 608 {
 609     BDRVVdiState *s = bs->opaque;
 610     QEMUIOVector local_qiov;
 611     uint32_t bmap_entry;
 612     uint32_t block_index;
 613     uint32_t offset_in_block;
 614     uint32_t n_bytes;
 615     uint64_t data_offset;
 616     uint32_t bmap_first = VDI_UNALLOCATED;
 617     uint32_t bmap_last = VDI_UNALLOCATED;
 618     uint8_t *block = NULL;
 619     uint64_t bytes_done = 0;
 620     int ret = 0;
 621
 622     logout("\n");
 623
 624     qemu_iovec_init(&local_qiov, qiov->niov);
 625
 626     while (ret >= 0 && bytes > 0) {
 627         block_index = offset / s->block_size;
 628         offset_in_block = offset % s->block_size;
 629         n_bytes = MIN(bytes, s->block_size - offset_in_block);
 630
 631         logout("will write %u bytes starting at offset %" PRIu64 "\n",
 632                n_bytes, offset);
 633
 634         /* prepare next AIO request */
 635         qemu_co_rwlock_rdlock(&s->bmap_lock);
 636         bmap_entry = le32_to_cpu(s->bmap[block_index]);
 637         if (!VDI_IS_ALLOCATED(bmap_entry)) {
 638             /* Allocate new block and write to it. */
 639             uint64_t data_offset;
 640             qemu_co_rwlock_upgrade(&s->bmap_lock);
 641             bmap_entry = le32_to_cpu(s->bmap[block_index]);
 642             if (VDI_IS_ALLOCATED(bmap_entry)) {
 643                 /* A concurrent allocation did the work for us.  */
 644                 qemu_co_rwlock_downgrade(&s->bmap_lock);
 645                 goto nonallocating_write;
 646             }
 647
 648             bmap_entry = s->header.blocks_allocated;
 649             s->bmap[block_index] = cpu_to_le32(bmap_entry);
 650             s->header.blocks_allocated++;
 651             data_offset = s->header.offset_data +
 652                           (uint64_t)bmap_entry * s->block_size;
 653             if (block == NULL) {
 654                 block = g_malloc(s->block_size);
 655                 bmap_first = block_index;
 656             }
 657             bmap_last = block_index;
 658             /* Copy data to be written to new block and zero unused parts. */
 659             memset(block, 0, offset_in_block);
 660             qemu_iovec_to_buf(qiov, bytes_done, block + offset_in_block,
 661                               n_bytes);
 662             memset(block + offset_in_block + n_bytes, 0,
 663                    s->block_size - n_bytes - offset_in_block);
 664
 665             /* Write the new block under CoRwLock write-side protection,
 666              * so this full-cluster write does not overlap a partial write
 667              * of the same cluster, issued from the "else" branch.
 668              */
 669             ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size);
 670             qemu_co_rwlock_unlock(&s->bmap_lock);
 671         } else {
 672 nonallocating_write:
 673             data_offset = s->header.offset_data +
 674                            (uint64_t)bmap_entry * s->block_size +
 675                            offset_in_block;
 676             qemu_co_rwlock_unlock(&s->bmap_lock);
 677
 678             qemu_iovec_reset(&local_qiov);
 679             qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
 680
 681             ret = bdrv_co_pwritev(bs->file, data_offset, n_bytes,
 682                                   &local_qiov, 0);
 683         }
 684
 685         bytes -= n_bytes;
 686         offset += n_bytes;
 687         bytes_done += n_bytes;
 688
 689         logout("%u bytes written\n", n_bytes);
 690     }
 691
 692     qemu_iovec_destroy(&local_qiov);
 693
 694     logout("finished data write\n");
 695     if (ret < 0) {
 696         return ret;
 697     }
 698
 699     if (block) {
 700         /* One or more new blocks were allocated. */
 701         VdiHeader *header = (VdiHeader *) block;
 702         uint8_t *base;
 703         uint64_t offset;
 704         uint32_t n_sectors;
 705
 706         logout("now writing modified header\n");
 707         assert(VDI_IS_ALLOCATED(bmap_first));
 708         *header = s->header;
 709         vdi_header_to_le(header);
 710         ret = bdrv_pwrite(bs->file, 0, block, sizeof(VdiHeader));
 711         g_free(block);
 712         block = NULL;
 713
 714         if (ret < 0) {
 715             return ret;
 716         }
 717
 718         logout("now writing modified block map entry %u...%u\n",
 719                bmap_first, bmap_last);
 720         /* Write modified sectors from block map. */
 721         bmap_first /= (SECTOR_SIZE / sizeof(uint32_t));
 722         bmap_last /= (SECTOR_SIZE / sizeof(uint32_t));
 723         n_sectors = bmap_last - bmap_first + 1;
 724         offset = s->bmap_sector + bmap_first;
 725         base = ((uint8_t *)&s->bmap[0]) + bmap_first * SECTOR_SIZE;
 726         logout("will write %u block map sectors starting from entry %u\n",
 727                n_sectors, bmap_first);
 728         ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE, base,
 729                           n_sectors * SECTOR_SIZE);
 730     }
 731
 732     return ret < 0 ? ret : 0;
 733 }
 734
 735 static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
 736                                          size_t block_size, Error **errp)
 737 {
 738     BlockdevCreateOptionsVdi *vdi_opts;
 739     int ret = 0;
 740     uint64_t bytes = 0;
 741     uint32_t blocks;
 742     uint32_t image_type;
 743     VdiHeader header;
 744     size_t i;
 745     size_t bmap_size;
 746     int64_t offset = 0;
 747     BlockDriverState *bs_file = NULL;
 748     BlockBackend *blk = NULL;
 749     uint32_t *bmap = NULL;
 750     QemuUUID uuid;
 751
 752     assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
 753     vdi_opts = &create_options->u.vdi;
 754
 755     logout("\n");
 756
 757     /* Validate options and set default values */
 758     bytes = vdi_opts->size;
 759
 760     if (!vdi_opts->has_preallocation) {
 761         vdi_opts->preallocation = PREALLOC_MODE_OFF;
 762     }
 763     switch (vdi_opts->preallocation) {
 764     case PREALLOC_MODE_OFF:
 765         image_type = VDI_TYPE_DYNAMIC;
 766         break;
 767     case PREALLOC_MODE_METADATA:
 768         image_type = VDI_TYPE_STATIC;
 769         break;
 770     default:
 771         error_setg(errp, "Preallocation mode not supported for vdi");
 772         return -EINVAL;
 773     }
 774
 775 #ifndef CONFIG_VDI_STATIC_IMAGE
 776     if (image_type == VDI_TYPE_STATIC) {
 777         ret = -ENOTSUP;
 778         error_setg(errp, "Statically allocated images cannot be created in "
 779                    "this build");
 780         goto exit;
 781     }
 782 #endif
 783 #ifndef CONFIG_VDI_BLOCK_SIZE
 784     if (block_size != DEFAULT_CLUSTER_SIZE) {
 785         ret = -ENOTSUP;
 786         error_setg(errp,
 787                    "A non-default cluster size is not supported in this build");
 788         goto exit;
 789     }
 790 #endif
 791
 792     if (bytes > VDI_DISK_SIZE_MAX) {
 793         ret = -ENOTSUP;
 794         error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
 795                           ", max supported is 0x%" PRIx64 ")",
 796                           bytes, VDI_DISK_SIZE_MAX);
 797         goto exit;
 798     }
 799
 800     /* Create BlockBackend to write to the image */
 801     bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
 802     if (!bs_file) {
 803         ret = -EIO;
 804         goto exit;
 805     }
 806
 807     blk = blk_new(bdrv_get_aio_context(bs_file),
 808                   BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
 809     ret = blk_insert_bs(blk, bs_file, errp);
 810     if (ret < 0) {
 811         goto exit;
 812     }
 813
 814     blk_set_allow_write_beyond_eof(blk, true);
 815
 816     /* We need enough blocks to store the given disk size,
 817        so always round up. */
 818     blocks = DIV_ROUND_UP(bytes, block_size);
 819
 820     bmap_size = blocks * sizeof(uint32_t);
 821     bmap_size = ROUND_UP(bmap_size, SECTOR_SIZE);
 822
 823     memset(&header, 0, sizeof(header));
 824     pstrcpy(header.text, sizeof(header.text), VDI_TEXT);
 825     header.signature = VDI_SIGNATURE;
 826     header.version = VDI_VERSION_1_1;
 827     header.header_size = 0x180;
 828     header.image_type = image_type;
 829     header.offset_bmap = 0x200;
 830     header.offset_data = 0x200 + bmap_size;
 831     header.sector_size = SECTOR_SIZE;
 832     header.disk_size = bytes;
 833     header.block_size = block_size;
 834     header.blocks_in_image = blocks;
 835     if (image_type == VDI_TYPE_STATIC) {
 836         header.blocks_allocated = blocks;
 837     }
 838     qemu_uuid_generate(&uuid);
 839     header.uuid_image = uuid;
 840     qemu_uuid_generate(&uuid);
 841     header.uuid_last_snap = uuid;
 842     /* There is no need to set header.uuid_link or header.uuid_parent here. */
 843     if (VDI_DEBUG) {
 844         vdi_header_print(&header);
 845     }
 846     vdi_header_to_le(&header);
 847     ret = blk_pwrite(blk, offset, &header, sizeof(header), 0);
 848     if (ret < 0) {
 849         error_setg(errp, "Error writing header");
 850         goto exit;
 851     }
 852     offset += sizeof(header);
 853
 854     if (bmap_size > 0) {
 855         bmap = g_try_malloc0(bmap_size);
 856         if (bmap == NULL) {
 857             ret = -ENOMEM;
 858             error_setg(errp, "Could not allocate bmap");
 859             goto exit;
 860         }
 861         for (i = 0; i < blocks; i++) {
 862             if (image_type == VDI_TYPE_STATIC) {
 863                 bmap[i] = i;
 864             } else {
 865                 bmap[i] = VDI_UNALLOCATED;
 866             }
 867         }
 868         ret = blk_pwrite(blk, offset, bmap, bmap_size, 0);
 869         if (ret < 0) {
 870             error_setg(errp, "Error writing bmap");
 871             goto exit;
 872         }
 873         offset += bmap_size;
 874     }
 875
 876     if (image_type == VDI_TYPE_STATIC) {
 877         ret = blk_truncate(blk, offset + blocks * block_size,
 878                            PREALLOC_MODE_OFF, errp);
 879         if (ret < 0) {
 880             error_prepend(errp, "Failed to statically allocate file");
 881             goto exit;
 882         }
 883     }
 884
 885     ret = 0;
 886 exit:
 887     blk_unref(blk);
 888     bdrv_unref(bs_file);
 889     g_free(bmap);
 890     return ret;
 891 }
 892
 893 static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
 894                                       Error **errp)
 895 {
 896     return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
 897 }
 898
 899 static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
 900                                            Error **errp)
 901 {
 902     QDict *qdict = NULL;
 903     BlockdevCreateOptions *create_options = NULL;
 904     BlockDriverState *bs_file = NULL;
 905     uint64_t block_size = DEFAULT_CLUSTER_SIZE;
 906     bool is_static = false;
 907     Visitor *v;
 908     Error *local_err = NULL;
 909     int ret;
 910
 911     /* Parse options and convert legacy syntax.
 912      *
 913      * Since CONFIG_VDI_BLOCK_SIZE is disabled by default,
 914      * cluster-size is not part of the QAPI schema; therefore we have
 915      * to parse it before creating the QAPI object. */
 916 #if defined(CONFIG_VDI_BLOCK_SIZE)
 917     block_size = qemu_opt_get_size_del(opts,
 918                                        BLOCK_OPT_CLUSTER_SIZE,
 919                                        DEFAULT_CLUSTER_SIZE);
 920     if (block_size < BDRV_SECTOR_SIZE || block_size > UINT32_MAX ||
 921         !is_power_of_2(block_size))
 922     {
 923         error_setg(errp, "Invalid cluster size");
 924         ret = -EINVAL;
 925         goto done;
 926     }
 927 #endif
 928     if (qemu_opt_get_bool_del(opts, BLOCK_OPT_STATIC, false)) {
 929         is_static = true;
 930     }
 931
 932     qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
 933
 934     /* Create and open the file (protocol layer) */
 935     ret = bdrv_create_file(filename, opts, errp);
 936     if (ret < 0) {
 937         goto done;
 938     }
 939
 940     bs_file = bdrv_open(filename, NULL, NULL,
 941                         BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
 942     if (!bs_file) {
 943         ret = -EIO;
 944         goto done;
 945     }
 946
 947     qdict_put_str(qdict, "driver", "vdi");
 948     qdict_put_str(qdict, "file", bs_file->node_name);
 949     if (is_static) {
 950         qdict_put_str(qdict, "preallocation", "metadata");
 951     }
 952
 953     /* Get the QAPI object */
 954     v = qobject_input_visitor_new_flat_confused(qdict, errp);
 955     if (!v) {
 956         ret = -EINVAL;
 957         goto done;
 958     }
 959     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
 960     visit_free(v);
 961
 962     if (local_err) {
 963         error_propagate(errp, local_err);
 964         ret = -EINVAL;
 965         goto done;
 966     }
 967
 968     /* Silently round up size */
 969     assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
 970     create_options->u.vdi.size = ROUND_UP(create_options->u.vdi.size,
 971                                           BDRV_SECTOR_SIZE);
 972
 973     /* Create the vdi image (format layer) */
 974     ret = vdi_co_do_create(create_options, block_size, errp);
 975 done:
 976     qobject_unref(qdict);
 977     qapi_free_BlockdevCreateOptions(create_options);
 978     bdrv_unref(bs_file);
 979     return ret;
 980 }
 981
 982 static void vdi_close(BlockDriverState *bs)
 983 {
 984     BDRVVdiState *s = bs->opaque;
 985
 986     qemu_vfree(s->bmap);
 987
 988     migrate_del_blocker(s->migration_blocker);
 989     error_free(s->migration_blocker);
 990 }
 991
 992 static int vdi_has_zero_init(BlockDriverState *bs)
 993 {
 994     BDRVVdiState *s = bs->opaque;
 995
 996     if (s->header.image_type == VDI_TYPE_STATIC) {
 997         return bdrv_has_zero_init(bs->file->bs);
 998     } else {
 999         return 1;
1000     }
1001 }
1002
1003 static QemuOptsList vdi_create_opts = {
1004     .name = "vdi-create-opts",
1005     .head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),
1006     .desc = {
1007         {
1008             .name = BLOCK_OPT_SIZE,
1009             .type = QEMU_OPT_SIZE,
1010             .help = "Virtual disk size"
1011         },
1012 #if defined(CONFIG_VDI_BLOCK_SIZE)
1013         {
1014             .name = BLOCK_OPT_CLUSTER_SIZE,
1015             .type = QEMU_OPT_SIZE,
1016             .help = "VDI cluster (block) size",
1017             .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
1018         },
1019 #endif
1020 #if defined(CONFIG_VDI_STATIC_IMAGE)
1021         {
1022             .name = BLOCK_OPT_STATIC,
1023             .type = QEMU_OPT_BOOL,
1024             .help = "VDI static (pre-allocated) image",
1025             .def_value_str = "off"
1026         },
1027 #endif
1028         /* TODO: An additional option to set UUID values might be useful. */
1029         { /* end of list */ }
1030     }
1031 };
1032
1033 static BlockDriver bdrv_vdi = {
1034     .format_name = "vdi",
1035     .instance_size = sizeof(BDRVVdiState),
1036     .bdrv_probe = vdi_probe,
1037     .bdrv_open = vdi_open,
1038     .bdrv_close = vdi_close,
1039     .bdrv_reopen_prepare = vdi_reopen_prepare,
1040     .bdrv_child_perm          = bdrv_format_default_perms,
1041     .bdrv_co_create      = vdi_co_create,
1042     .bdrv_co_create_opts = vdi_co_create_opts,
1043     .bdrv_has_zero_init  = vdi_has_zero_init,
1044     .bdrv_co_block_status = vdi_co_block_status,
1045     .bdrv_make_empty = vdi_make_empty,
1046
1047     .bdrv_co_preadv     = vdi_co_preadv,
1048 #if defined(CONFIG_VDI_WRITE)
1049     .bdrv_co_pwritev    = vdi_co_pwritev,
1050 #endif
1051
1052     .bdrv_get_info = vdi_get_info,
1053
1054     .create_opts = &vdi_create_opts,
1055     .bdrv_co_check = vdi_co_check,
1056 };
1057
1058 static void bdrv_vdi_init(void)
1059 {
1060     logout("\n");
1061     bdrv_register(&bdrv_vdi);
1062 }
1063
1064 block_init(bdrv_vdi_init);