block/vpc.c

   1 /*
   2  * Block driver for Connectix / Microsoft Virtual PC images
   3  *
   4  * Copyright (c) 2005 Alex Beregszaszi
   5  * Copyright (c) 2009 Kevin Wolf <[email protected]>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #include "qemu/osdep.h"
  27 #include "qapi/error.h"
  28 #include "block/block_int.h"
  29 #include "block/qdict.h"
  30 #include "sysemu/block-backend.h"
  31 #include "qemu/module.h"
  32 #include "qemu/option.h"
  33 #include "migration/blocker.h"
  34 #include "qemu/bswap.h"
  35 #include "qemu/uuid.h"
  36 #include "qapi/qmp/qdict.h"
  37 #include "qapi/qobject-input-visitor.h"
  38 #include "qapi/qapi-visit-block-core.h"
  39
  40 /**************************************************************/
  41
  42 #define HEADER_SIZE 512
  43
  44 //#define CACHE
  45
  46 enum vhd_type {
  47     VHD_FIXED           = 2,
  48     VHD_DYNAMIC         = 3,
  49     VHD_DIFFERENCING    = 4,
  50 };
  51
  52 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
  53 #define VHD_TIMESTAMP_BASE 946684800
  54
  55 #define VHD_CHS_MAX_C   65535LL
  56 #define VHD_CHS_MAX_H   16
  57 #define VHD_CHS_MAX_S   255
  58
  59 #define VHD_MAX_SECTORS       0xff000000    /* 2040 GiB max image size */
  60 #define VHD_MAX_GEOMETRY      (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S)
  61
  62 #define VPC_OPT_FORCE_SIZE "force_size"
  63
  64 /* always big-endian */
  65 typedef struct vhd_footer {
  66     char        creator[8]; /* "conectix" */
  67     uint32_t    features;
  68     uint32_t    version;
  69
  70     /* Offset of next header structure, 0xFFFFFFFF if none */
  71     uint64_t    data_offset;
  72
  73     /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
  74     uint32_t    timestamp;
  75
  76     char        creator_app[4]; /*  e.g., "vpc " */
  77     uint16_t    major;
  78     uint16_t    minor;
  79     char        creator_os[4]; /* "Wi2k" */
  80
  81     uint64_t    orig_size;
  82     uint64_t    current_size;
  83
  84     uint16_t    cyls;
  85     uint8_t     heads;
  86     uint8_t     secs_per_cyl;
  87
  88     uint32_t    type;
  89
  90     /* Checksum of the Hard Disk Footer ("one's complement of the sum of all
  91        the bytes in the footer without the checksum field") */
  92     uint32_t    checksum;
  93
  94     /* UUID used to identify a parent hard disk (backing file) */
  95     QemuUUID    uuid;
  96
  97     uint8_t     in_saved_state;
  98 } QEMU_PACKED VHDFooter;
  99
 100 typedef struct vhd_dyndisk_header {
 101     char        magic[8]; /* "cxsparse" */
 102
 103     /* Offset of next header structure, 0xFFFFFFFF if none */
 104     uint64_t    data_offset;
 105
 106     /* Offset of the Block Allocation Table (BAT) */
 107     uint64_t    table_offset;
 108
 109     uint32_t    version;
 110     uint32_t    max_table_entries; /* 32bit/entry */
 111
 112     /* 2 MB by default, must be a power of two */
 113     uint32_t    block_size;
 114
 115     uint32_t    checksum;
 116     uint8_t     parent_uuid[16];
 117     uint32_t    parent_timestamp;
 118     uint32_t    reserved;
 119
 120     /* Backing file name (in UTF-16) */
 121     uint8_t     parent_name[512];
 122
 123     struct {
 124         uint32_t    platform;
 125         uint32_t    data_space;
 126         uint32_t    data_length;
 127         uint32_t    reserved;
 128         uint64_t    data_offset;
 129     } parent_locator[8];
 130 } QEMU_PACKED VHDDynDiskHeader;
 131
 132 typedef struct BDRVVPCState {
 133     CoMutex lock;
 134     uint8_t footer_buf[HEADER_SIZE];
 135     uint64_t free_data_block_offset;
 136     int max_table_entries;
 137     uint32_t *pagetable;
 138     uint64_t bat_offset;
 139     uint64_t last_bitmap_offset;
 140
 141     uint32_t block_size;
 142     uint32_t bitmap_size;
 143     bool force_use_chs;
 144     bool force_use_sz;
 145
 146 #ifdef CACHE
 147     uint8_t *pageentry_u8;
 148     uint32_t *pageentry_u32;
 149     uint16_t *pageentry_u16;
 150
 151     uint64_t last_bitmap;
 152 #endif
 153
 154     Error *migration_blocker;
 155 } BDRVVPCState;
 156
 157 #define VPC_OPT_SIZE_CALC "force_size_calc"
 158 static QemuOptsList vpc_runtime_opts = {
 159     .name = "vpc-runtime-opts",
 160     .head = QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts.head),
 161     .desc = {
 162         {
 163             .name = VPC_OPT_SIZE_CALC,
 164             .type = QEMU_OPT_STRING,
 165             .help = "Force disk size calculation to use either CHS geometry, "
 166                     "or use the disk current_size specified in the VHD footer. "
 167                     "{chs, current_size}"
 168         },
 169         { /* end of list */ }
 170     }
 171 };
 172
 173 static QemuOptsList vpc_create_opts;
 174
 175 static uint32_t vpc_checksum(uint8_t *buf, size_t size)
 176 {
 177     uint32_t res = 0;
 178     int i;
 179
 180     for (i = 0; i < size; i++)
 181         res += buf[i];
 182
 183     return ~res;
 184 }
 185
 186
 187 static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
 188 {
 189     if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
 190         return 100;
 191     return 0;
 192 }
 193
 194 static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
 195                               Error **errp)
 196 {
 197     BDRVVPCState *s = bs->opaque;
 198     const char *size_calc;
 199
 200     size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC);
 201
 202     if (!size_calc) {
 203        /* no override, use autodetect only */
 204     } else if (!strcmp(size_calc, "current_size")) {
 205         s->force_use_sz = true;
 206     } else if (!strcmp(size_calc, "chs")) {
 207         s->force_use_chs = true;
 208     } else {
 209         error_setg(errp, "Invalid size calculation mode: '%s'", size_calc);
 210     }
 211 }
 212
 213 static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
 214                     Error **errp)
 215 {
 216     BDRVVPCState *s = bs->opaque;
 217     int i;
 218     VHDFooter *footer;
 219     VHDDynDiskHeader *dyndisk_header;
 220     QemuOpts *opts = NULL;
 221     Error *local_err = NULL;
 222     bool use_chs;
 223     uint8_t dyndisk_header_buf[1024];
 224     uint32_t checksum;
 225     uint64_t computed_size;
 226     uint64_t pagetable_size;
 227     int disk_type = VHD_DYNAMIC;
 228     int ret;
 229     int64_t bs_size;
 230
 231     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
 232                                BDRV_CHILD_IMAGE, false, errp);
 233     if (!bs->file) {
 234         return -EINVAL;
 235     }
 236
 237     opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
 238     if (!qemu_opts_absorb_qdict(opts, options, errp)) {
 239         ret = -EINVAL;
 240         goto fail;
 241     }
 242
 243     vpc_parse_options(bs, opts, &local_err);
 244     if (local_err) {
 245         error_propagate(errp, local_err);
 246         ret = -EINVAL;
 247         goto fail;
 248     }
 249
 250     ret = bdrv_pread(bs->file, 0, s->footer_buf, HEADER_SIZE);
 251     if (ret < 0) {
 252         error_setg(errp, "Unable to read VHD header");
 253         goto fail;
 254     }
 255
 256     footer = (VHDFooter *) s->footer_buf;
 257     if (strncmp(footer->creator, "conectix", 8)) {
 258         int64_t offset = bdrv_getlength(bs->file->bs);
 259         if (offset < 0) {
 260             ret = offset;
 261             error_setg(errp, "Invalid file size");
 262             goto fail;
 263         } else if (offset < HEADER_SIZE) {
 264             ret = -EINVAL;
 265             error_setg(errp, "File too small for a VHD header");
 266             goto fail;
 267         }
 268
 269         /* If a fixed disk, the footer is found only at the end of the file */
 270         ret = bdrv_pread(bs->file, offset-HEADER_SIZE, s->footer_buf,
 271                          HEADER_SIZE);
 272         if (ret < 0) {
 273             goto fail;
 274         }
 275         if (strncmp(footer->creator, "conectix", 8)) {
 276             error_setg(errp, "invalid VPC image");
 277             ret = -EINVAL;
 278             goto fail;
 279         }
 280         disk_type = VHD_FIXED;
 281     }
 282
 283     checksum = be32_to_cpu(footer->checksum);
 284     footer->checksum = 0;
 285     if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum) {
 286         error_setg(errp, "Incorrect header checksum");
 287         ret = -EINVAL;
 288         goto fail;
 289     }
 290
 291     /* Write 'checksum' back to footer, or else will leave it with zero. */
 292     footer->checksum = cpu_to_be32(checksum);
 293
 294     /* The visible size of a image in Virtual PC depends on the geometry
 295        rather than on the size stored in the footer (the size in the footer
 296        is too large usually) */
 297     bs->total_sectors = (int64_t)
 298         be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
 299
 300     /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
 301      * VHD image sizes differently.  VPC will rely on CHS geometry,
 302      * while Hyper-V and disk2vhd use the size specified in the footer.
 303      *
 304      * We use a couple of approaches to try and determine the correct method:
 305      * look at the Creator App field, and look for images that have CHS
 306      * geometry that is the maximum value.
 307      *
 308      * If the CHS geometry is the maximum CHS geometry, then we assume that
 309      * the size is the footer->current_size to avoid truncation.  Otherwise,
 310      * we follow the table based on footer->creator_app:
 311      *
 312      *  Known creator apps:
 313      *      'vpc '  :  CHS              Virtual PC (uses disk geometry)
 314      *      'qemu'  :  CHS              QEMU (uses disk geometry)
 315      *      'qem2'  :  current_size     QEMU (uses current_size)
 316      *      'win '  :  current_size     Hyper-V
 317      *      'd2v '  :  current_size     Disk2vhd
 318      *      'tap\0' :  current_size     XenServer
 319      *      'CTXS'  :  current_size     XenConverter
 320      *
 321      *  The user can override the table values via drive options, however
 322      *  even with an override we will still use current_size for images
 323      *  that have CHS geometry of the maximum size.
 324      */
 325     use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
 326                !!strncmp(footer->creator_app, "qem2", 4) &&
 327                !!strncmp(footer->creator_app, "d2v ", 4) &&
 328                !!strncmp(footer->creator_app, "CTXS", 4) &&
 329                !!memcmp(footer->creator_app, "tap", 4)) || s->force_use_chs;
 330
 331     if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
 332         bs->total_sectors = be64_to_cpu(footer->current_size) /
 333                                         BDRV_SECTOR_SIZE;
 334     }
 335
 336     /* Allow a maximum disk size of 2040 GiB */
 337     if (bs->total_sectors > VHD_MAX_SECTORS) {
 338         ret = -EFBIG;
 339         goto fail;
 340     }
 341
 342     if (disk_type == VHD_DYNAMIC) {
 343         ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset),
 344                          dyndisk_header_buf, 1024);
 345         if (ret < 0) {
 346             error_setg(errp, "Error reading dynamic VHD header");
 347             goto fail;
 348         }
 349
 350         dyndisk_header = (VHDDynDiskHeader *)dyndisk_header_buf;
 351
 352         if (strncmp(dyndisk_header->magic, "cxsparse", 8)) {
 353             error_setg(errp, "Invalid header magic");
 354             ret = -EINVAL;
 355             goto fail;
 356         }
 357
 358         s->block_size = be32_to_cpu(dyndisk_header->block_size);
 359         if (!is_power_of_2(s->block_size) || s->block_size < BDRV_SECTOR_SIZE) {
 360             error_setg(errp, "Invalid block size %" PRIu32, s->block_size);
 361             ret = -EINVAL;
 362             goto fail;
 363         }
 364         s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511;
 365
 366         s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries);
 367
 368         if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) {
 369             error_setg(errp, "Too many blocks");
 370             ret = -EINVAL;
 371             goto fail;
 372         }
 373
 374         computed_size = (uint64_t) s->max_table_entries * s->block_size;
 375         if (computed_size < bs->total_sectors * 512) {
 376             error_setg(errp, "Page table too small");
 377             ret = -EINVAL;
 378             goto fail;
 379         }
 380
 381         if (s->max_table_entries > SIZE_MAX / 4 ||
 382             s->max_table_entries > (int) INT_MAX / 4) {
 383             error_setg(errp, "Max Table Entries too large (%" PRId32 ")",
 384                         s->max_table_entries);
 385             ret = -EINVAL;
 386             goto fail;
 387         }
 388
 389         pagetable_size = (uint64_t) s->max_table_entries * 4;
 390
 391         s->pagetable = qemu_try_blockalign(bs->file->bs, pagetable_size);
 392         if (s->pagetable == NULL) {
 393             error_setg(errp, "Unable to allocate memory for page table");
 394             ret = -ENOMEM;
 395             goto fail;
 396         }
 397
 398         s->bat_offset = be64_to_cpu(dyndisk_header->table_offset);
 399
 400         ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable,
 401                          pagetable_size);
 402         if (ret < 0) {
 403             error_setg(errp, "Error reading pagetable");
 404             goto fail;
 405         }
 406
 407         s->free_data_block_offset =
 408             ROUND_UP(s->bat_offset + pagetable_size, 512);
 409
 410         for (i = 0; i < s->max_table_entries; i++) {
 411             be32_to_cpus(&s->pagetable[i]);
 412             if (s->pagetable[i] != 0xFFFFFFFF) {
 413                 int64_t next = (512 * (int64_t) s->pagetable[i]) +
 414                     s->bitmap_size + s->block_size;
 415
 416                 if (next > s->free_data_block_offset) {
 417                     s->free_data_block_offset = next;
 418                 }
 419             }
 420         }
 421
 422         bs_size = bdrv_getlength(bs->file->bs);
 423         if (bs_size < 0) {
 424             error_setg_errno(errp, -bs_size, "Unable to learn image size");
 425             ret = bs_size;
 426             goto fail;
 427         }
 428         if (s->free_data_block_offset > bs_size) {
 429             error_setg(errp, "block-vpc: free_data_block_offset points after "
 430                              "the end of file. The image has been truncated.");
 431             ret = -EINVAL;
 432             goto fail;
 433         }
 434
 435         s->last_bitmap_offset = (int64_t) -1;
 436
 437 #ifdef CACHE
 438         s->pageentry_u8 = g_malloc(512);
 439         s->pageentry_u32 = s->pageentry_u8;
 440         s->pageentry_u16 = s->pageentry_u8;
 441         s->last_pagetable = -1;
 442 #endif
 443     }
 444
 445     /* Disable migration when VHD images are used */
 446     error_setg(&s->migration_blocker, "The vpc format used by node '%s' "
 447                "does not support live migration",
 448                bdrv_get_device_or_node_name(bs));
 449     ret = migrate_add_blocker(s->migration_blocker, errp);
 450     if (ret < 0) {
 451         error_free(s->migration_blocker);
 452         goto fail;
 453     }
 454
 455     qemu_co_mutex_init(&s->lock);
 456     qemu_opts_del(opts);
 457
 458     return 0;
 459
 460 fail:
 461     qemu_opts_del(opts);
 462     qemu_vfree(s->pagetable);
 463 #ifdef CACHE
 464     g_free(s->pageentry_u8);
 465 #endif
 466     return ret;
 467 }
 468
 469 static int vpc_reopen_prepare(BDRVReopenState *state,
 470                               BlockReopenQueue *queue, Error **errp)
 471 {
 472     return 0;
 473 }
 474
 475 /*
 476  * Returns the absolute byte offset of the given sector in the image file.
 477  * If the sector is not allocated, -1 is returned instead.
 478  * If an error occurred trying to write an updated block bitmap back to
 479  * the file, -2 is returned, and the error value is written to *err.
 480  * This can only happen for a write operation.
 481  *
 482  * The parameter write must be 1 if the offset will be used for a write
 483  * operation (the block bitmaps is updated then), 0 otherwise.
 484  * If write is true then err must not be NULL.
 485  */
 486 static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
 487                                        bool write, int *err)
 488 {
 489     BDRVVPCState *s = bs->opaque;
 490     uint64_t bitmap_offset, block_offset;
 491     uint32_t pagetable_index, offset_in_block;
 492
 493     assert(!(write && err == NULL));
 494
 495     pagetable_index = offset / s->block_size;
 496     offset_in_block = offset % s->block_size;
 497
 498     if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)
 499         return -1; /* not allocated */
 500
 501     bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
 502     block_offset = bitmap_offset + s->bitmap_size + offset_in_block;
 503
 504     /* We must ensure that we don't write to any sectors which are marked as
 505        unused in the bitmap. We get away with setting all bits in the block
 506        bitmap each time we write to a new block. This might cause Virtual PC to
 507        miss sparse read optimization, but it's not a problem in terms of
 508        correctness. */
 509     if (write && (s->last_bitmap_offset != bitmap_offset)) {
 510         uint8_t bitmap[s->bitmap_size];
 511         int r;
 512
 513         s->last_bitmap_offset = bitmap_offset;
 514         memset(bitmap, 0xff, s->bitmap_size);
 515         r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
 516         if (r < 0) {
 517             *err = r;
 518             return -2;
 519         }
 520     }
 521
 522     return block_offset;
 523 }
 524
 525 /*
 526  * Writes the footer to the end of the image file. This is needed when the
 527  * file grows as it overwrites the old footer
 528  *
 529  * Returns 0 on success and < 0 on error
 530  */
 531 static int rewrite_footer(BlockDriverState *bs)
 532 {
 533     int ret;
 534     BDRVVPCState *s = bs->opaque;
 535     int64_t offset = s->free_data_block_offset;
 536
 537     ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE);
 538     if (ret < 0)
 539         return ret;
 540
 541     return 0;
 542 }
 543
 544 /*
 545  * Allocates a new block. This involves writing a new footer and updating
 546  * the Block Allocation Table to use the space at the old end of the image
 547  * file (overwriting the old footer)
 548  *
 549  * Returns the sectors' offset in the image file on success and < 0 on error
 550  */
 551 static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
 552 {
 553     BDRVVPCState *s = bs->opaque;
 554     int64_t bat_offset;
 555     uint32_t index, bat_value;
 556     int ret;
 557     uint8_t bitmap[s->bitmap_size];
 558
 559     /* Check if sector_num is valid */
 560     if ((offset < 0) || (offset > bs->total_sectors * BDRV_SECTOR_SIZE)) {
 561         return -EINVAL;
 562     }
 563
 564     /* Write entry into in-memory BAT */
 565     index = offset / s->block_size;
 566     assert(s->pagetable[index] == 0xFFFFFFFF);
 567     s->pagetable[index] = s->free_data_block_offset / 512;
 568
 569     /* Initialize the block's bitmap */
 570     memset(bitmap, 0xff, s->bitmap_size);
 571     ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
 572         s->bitmap_size);
 573     if (ret < 0) {
 574         return ret;
 575     }
 576
 577     /* Write new footer (the old one will be overwritten) */
 578     s->free_data_block_offset += s->block_size + s->bitmap_size;
 579     ret = rewrite_footer(bs);
 580     if (ret < 0)
 581         goto fail;
 582
 583     /* Write BAT entry to disk */
 584     bat_offset = s->bat_offset + (4 * index);
 585     bat_value = cpu_to_be32(s->pagetable[index]);
 586     ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4);
 587     if (ret < 0)
 588         goto fail;
 589
 590     return get_image_offset(bs, offset, false, NULL);
 591
 592 fail:
 593     s->free_data_block_offset -= (s->block_size + s->bitmap_size);
 594     return ret;
 595 }
 596
 597 static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 598 {
 599     BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
 600     VHDFooter *footer = (VHDFooter *) s->footer_buf;
 601
 602     if (be32_to_cpu(footer->type) != VHD_FIXED) {
 603         bdi->cluster_size = s->block_size;
 604     }
 605
 606     return 0;
 607 }
 608
 609 static int coroutine_fn
 610 vpc_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 611               QEMUIOVector *qiov, int flags)
 612 {
 613     BDRVVPCState *s = bs->opaque;
 614     int ret;
 615     int64_t image_offset;
 616     int64_t n_bytes;
 617     int64_t bytes_done = 0;
 618     VHDFooter *footer = (VHDFooter *) s->footer_buf;
 619     QEMUIOVector local_qiov;
 620
 621     if (be32_to_cpu(footer->type) == VHD_FIXED) {
 622         return bdrv_co_preadv(bs->file, offset, bytes, qiov, 0);
 623     }
 624
 625     qemu_co_mutex_lock(&s->lock);
 626     qemu_iovec_init(&local_qiov, qiov->niov);
 627
 628     while (bytes > 0) {
 629         image_offset = get_image_offset(bs, offset, false, NULL);
 630         n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
 631
 632         if (image_offset == -1) {
 633             qemu_iovec_memset(qiov, bytes_done, 0, n_bytes);
 634         } else {
 635             qemu_iovec_reset(&local_qiov);
 636             qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
 637
 638             qemu_co_mutex_unlock(&s->lock);
 639             ret = bdrv_co_preadv(bs->file, image_offset, n_bytes,
 640                                  &local_qiov, 0);
 641             qemu_co_mutex_lock(&s->lock);
 642             if (ret < 0) {
 643                 goto fail;
 644             }
 645         }
 646
 647         bytes -= n_bytes;
 648         offset += n_bytes;
 649         bytes_done += n_bytes;
 650     }
 651
 652     ret = 0;
 653 fail:
 654     qemu_iovec_destroy(&local_qiov);
 655     qemu_co_mutex_unlock(&s->lock);
 656
 657     return ret;
 658 }
 659
 660 static int coroutine_fn
 661 vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 662                QEMUIOVector *qiov, int flags)
 663 {
 664     BDRVVPCState *s = bs->opaque;
 665     int64_t image_offset;
 666     int64_t n_bytes;
 667     int64_t bytes_done = 0;
 668     int ret = 0;
 669     VHDFooter *footer =  (VHDFooter *) s->footer_buf;
 670     QEMUIOVector local_qiov;
 671
 672     if (be32_to_cpu(footer->type) == VHD_FIXED) {
 673         return bdrv_co_pwritev(bs->file, offset, bytes, qiov, 0);
 674     }
 675
 676     qemu_co_mutex_lock(&s->lock);
 677     qemu_iovec_init(&local_qiov, qiov->niov);
 678
 679     while (bytes > 0) {
 680         image_offset = get_image_offset(bs, offset, true, &ret);
 681         if (image_offset == -2) {
 682             /* Failed to write block bitmap: can't proceed with write */
 683             goto fail;
 684         }
 685         n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
 686
 687         if (image_offset == -1) {
 688             image_offset = alloc_block(bs, offset);
 689             if (image_offset < 0) {
 690                 ret = image_offset;
 691                 goto fail;
 692             }
 693         }
 694
 695         qemu_iovec_reset(&local_qiov);
 696         qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
 697
 698         qemu_co_mutex_unlock(&s->lock);
 699         ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes,
 700                               &local_qiov, 0);
 701         qemu_co_mutex_lock(&s->lock);
 702         if (ret < 0) {
 703             goto fail;
 704         }
 705
 706         bytes -= n_bytes;
 707         offset += n_bytes;
 708         bytes_done += n_bytes;
 709     }
 710
 711     ret = 0;
 712 fail:
 713     qemu_iovec_destroy(&local_qiov);
 714     qemu_co_mutex_unlock(&s->lock);
 715
 716     return ret;
 717 }
 718
 719 static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
 720                                             bool want_zero,
 721                                             int64_t offset, int64_t bytes,
 722                                             int64_t *pnum, int64_t *map,
 723                                             BlockDriverState **file)
 724 {
 725     BDRVVPCState *s = bs->opaque;
 726     VHDFooter *footer = (VHDFooter*) s->footer_buf;
 727     int64_t image_offset;
 728     bool allocated;
 729     int ret;
 730     int64_t n;
 731
 732     if (be32_to_cpu(footer->type) == VHD_FIXED) {
 733         *pnum = bytes;
 734         *map = offset;
 735         *file = bs->file->bs;
 736         return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE;
 737     }
 738
 739     qemu_co_mutex_lock(&s->lock);
 740
 741     image_offset = get_image_offset(bs, offset, false, NULL);
 742     allocated = (image_offset != -1);
 743     *pnum = 0;
 744     ret = BDRV_BLOCK_ZERO;
 745
 746     do {
 747         /* All sectors in a block are contiguous (without using the bitmap) */
 748         n = ROUND_UP(offset + 1, s->block_size) - offset;
 749         n = MIN(n, bytes);
 750
 751         *pnum += n;
 752         offset += n;
 753         bytes -= n;
 754         /* *pnum can't be greater than one block for allocated
 755          * sectors since there is always a bitmap in between. */
 756         if (allocated) {
 757             *file = bs->file->bs;
 758             *map = image_offset;
 759             ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
 760             break;
 761         }
 762         if (bytes == 0) {
 763             break;
 764         }
 765         image_offset = get_image_offset(bs, offset, false, NULL);
 766     } while (image_offset == -1);
 767
 768     qemu_co_mutex_unlock(&s->lock);
 769     return ret;
 770 }
 771
 772 /*
 773  * Calculates the number of cylinders, heads and sectors per cylinder
 774  * based on a given number of sectors. This is the algorithm described
 775  * in the VHD specification.
 776  *
 777  * Note that the geometry doesn't always exactly match total_sectors but
 778  * may round it down.
 779  *
 780  * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
 781  * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
 782  * and instead allow up to 255 heads.
 783  */
 784 static int calculate_geometry(int64_t total_sectors, uint16_t *cyls,
 785     uint8_t *heads, uint8_t *secs_per_cyl)
 786 {
 787     uint32_t cyls_times_heads;
 788
 789     total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY);
 790
 791     if (total_sectors >= 65535LL * 16 * 63) {
 792         *secs_per_cyl = 255;
 793         *heads = 16;
 794         cyls_times_heads = total_sectors / *secs_per_cyl;
 795     } else {
 796         *secs_per_cyl = 17;
 797         cyls_times_heads = total_sectors / *secs_per_cyl;
 798         *heads = DIV_ROUND_UP(cyls_times_heads, 1024);
 799
 800         if (*heads < 4) {
 801             *heads = 4;
 802         }
 803
 804         if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
 805             *secs_per_cyl = 31;
 806             *heads = 16;
 807             cyls_times_heads = total_sectors / *secs_per_cyl;
 808         }
 809
 810         if (cyls_times_heads >= (*heads * 1024)) {
 811             *secs_per_cyl = 63;
 812             *heads = 16;
 813             cyls_times_heads = total_sectors / *secs_per_cyl;
 814         }
 815     }
 816
 817     *cyls = cyls_times_heads / *heads;
 818
 819     return 0;
 820 }
 821
 822 static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf,
 823                                int64_t total_sectors)
 824 {
 825     VHDDynDiskHeader *dyndisk_header =
 826         (VHDDynDiskHeader *) buf;
 827     uint8_t bat_sector[512];
 828     size_t block_size, num_bat_entries;
 829     int i;
 830     int ret;
 831     int64_t offset = 0;
 832
 833     /* Write the footer (twice: at the beginning and at the end) */
 834     block_size = 0x200000;
 835     num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
 836
 837     ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
 838     if (ret < 0) {
 839         goto fail;
 840     }
 841
 842     offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
 843     ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
 844     if (ret < 0) {
 845         goto fail;
 846     }
 847
 848     /* Write the initial BAT */
 849     offset = 3 * 512;
 850
 851     memset(bat_sector, 0xFF, 512);
 852     for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
 853         ret = blk_pwrite(blk, offset, bat_sector, 512, 0);
 854         if (ret < 0) {
 855             goto fail;
 856         }
 857         offset += 512;
 858     }
 859
 860     /* Prepare the Dynamic Disk Header */
 861     memset(buf, 0, 1024);
 862
 863     memcpy(dyndisk_header->magic, "cxsparse", 8);
 864
 865     /*
 866      * Note: The spec is actually wrong here for data_offset, it says
 867      * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
 868      */
 869     dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
 870     dyndisk_header->table_offset = cpu_to_be64(3 * 512);
 871     dyndisk_header->version = cpu_to_be32(0x00010000);
 872     dyndisk_header->block_size = cpu_to_be32(block_size);
 873     dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries);
 874
 875     dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024));
 876
 877     /* Write the header */
 878     offset = 512;
 879
 880     ret = blk_pwrite(blk, offset, buf, 1024, 0);
 881     if (ret < 0) {
 882         goto fail;
 883     }
 884
 885     ret = 0;
 886  fail:
 887     return ret;
 888 }
 889
 890 static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
 891                              int64_t total_size, Error **errp)
 892 {
 893     int ret;
 894
 895     /* Add footer to total size */
 896     total_size += HEADER_SIZE;
 897
 898     ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
 899     if (ret < 0) {
 900         return ret;
 901     }
 902
 903     ret = blk_pwrite(blk, total_size - HEADER_SIZE, buf, HEADER_SIZE, 0);
 904     if (ret < 0) {
 905         error_setg_errno(errp, -ret, "Unable to write VHD header");
 906         return ret;
 907     }
 908
 909     return 0;
 910 }
 911
 912 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
 913                                         uint16_t *out_cyls,
 914                                         uint8_t *out_heads,
 915                                         uint8_t *out_secs_per_cyl,
 916                                         int64_t *out_total_sectors,
 917                                         Error **errp)
 918 {
 919     int64_t total_size = vpc_opts->size;
 920     uint16_t cyls = 0;
 921     uint8_t heads = 0;
 922     uint8_t secs_per_cyl = 0;
 923     int64_t total_sectors;
 924     int i;
 925
 926     /*
 927      * Calculate matching total_size and geometry. Increase the number of
 928      * sectors requested until we get enough (or fail). This ensures that
 929      * qemu-img convert doesn't truncate images, but rather rounds up.
 930      *
 931      * If the image size can't be represented by a spec conformant CHS geometry,
 932      * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
 933      * the image size from the VHD footer to calculate total_sectors.
 934      */
 935     if (vpc_opts->force_size) {
 936         /* This will force the use of total_size for sector count, below */
 937         cyls         = VHD_CHS_MAX_C;
 938         heads        = VHD_CHS_MAX_H;
 939         secs_per_cyl = VHD_CHS_MAX_S;
 940     } else {
 941         total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
 942         for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
 943             calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
 944         }
 945     }
 946
 947     if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
 948         total_sectors = total_size / BDRV_SECTOR_SIZE;
 949         /* Allow a maximum disk size of 2040 GiB */
 950         if (total_sectors > VHD_MAX_SECTORS) {
 951             error_setg(errp, "Disk size is too large, max size is 2040 GiB");
 952             return -EFBIG;
 953         }
 954     } else {
 955         total_sectors = (int64_t) cyls * heads * secs_per_cyl;
 956     }
 957
 958     *out_total_sectors = total_sectors;
 959     if (out_cyls) {
 960         *out_cyls = cyls;
 961         *out_heads = heads;
 962         *out_secs_per_cyl = secs_per_cyl;
 963     }
 964
 965     return 0;
 966 }
 967
 968 static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
 969                                       Error **errp)
 970 {
 971     BlockdevCreateOptionsVpc *vpc_opts;
 972     BlockBackend *blk = NULL;
 973     BlockDriverState *bs = NULL;
 974
 975     uint8_t buf[1024];
 976     VHDFooter *footer = (VHDFooter *) buf;
 977     uint16_t cyls = 0;
 978     uint8_t heads = 0;
 979     uint8_t secs_per_cyl = 0;
 980     int64_t total_sectors;
 981     int64_t total_size;
 982     int disk_type;
 983     int ret = -EIO;
 984     QemuUUID uuid;
 985
 986     assert(opts->driver == BLOCKDEV_DRIVER_VPC);
 987     vpc_opts = &opts->u.vpc;
 988
 989     /* Validate options and set default values */
 990     total_size = vpc_opts->size;
 991
 992     if (!vpc_opts->has_subformat) {
 993         vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC;
 994     }
 995     switch (vpc_opts->subformat) {
 996     case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC:
 997         disk_type = VHD_DYNAMIC;
 998         break;
 999     case BLOCKDEV_VPC_SUBFORMAT_FIXED:
1000         disk_type = VHD_FIXED;
1001         break;
1002     default:
1003         g_assert_not_reached();
1004     }
1005
1006     /* Create BlockBackend to write to the image */
1007     bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
1008     if (bs == NULL) {
1009         return -EIO;
1010     }
1011
1012     blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
1013                           errp);
1014     if (!blk) {
1015         ret = -EPERM;
1016         goto out;
1017     }
1018     blk_set_allow_write_beyond_eof(blk, true);
1019
1020     /* Get geometry and check that it matches the image size*/
1021     ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl,
1022                                        &total_sectors, errp);
1023     if (ret < 0) {
1024         goto out;
1025     }
1026
1027     if (total_size != total_sectors * BDRV_SECTOR_SIZE) {
1028         error_setg(errp, "The requested image size cannot be represented in "
1029                          "CHS geometry");
1030         error_append_hint(errp, "Try size=%llu or force-size=on (the "
1031                                 "latter makes the image incompatible with "
1032                                 "Virtual PC)",
1033                           total_sectors * BDRV_SECTOR_SIZE);
1034         ret = -EINVAL;
1035         goto out;
1036     }
1037
1038     /* Prepare the Hard Disk Footer */
1039     memset(buf, 0, 1024);
1040
1041     memcpy(footer->creator, "conectix", 8);
1042     if (vpc_opts->force_size) {
1043         memcpy(footer->creator_app, "qem2", 4);
1044     } else {
1045         memcpy(footer->creator_app, "qemu", 4);
1046     }
1047     memcpy(footer->creator_os, "Wi2k", 4);
1048
1049     footer->features = cpu_to_be32(0x02);
1050     footer->version = cpu_to_be32(0x00010000);
1051     if (disk_type == VHD_DYNAMIC) {
1052         footer->data_offset = cpu_to_be64(HEADER_SIZE);
1053     } else {
1054         footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
1055     }
1056     footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
1057
1058     /* Version of Virtual PC 2007 */
1059     footer->major = cpu_to_be16(0x0005);
1060     footer->minor = cpu_to_be16(0x0003);
1061     footer->orig_size = cpu_to_be64(total_size);
1062     footer->current_size = cpu_to_be64(total_size);
1063     footer->cyls = cpu_to_be16(cyls);
1064     footer->heads = heads;
1065     footer->secs_per_cyl = secs_per_cyl;
1066
1067     footer->type = cpu_to_be32(disk_type);
1068
1069     qemu_uuid_generate(&uuid);
1070     footer->uuid = uuid;
1071
1072     footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE));
1073
1074     if (disk_type == VHD_DYNAMIC) {
1075         ret = create_dynamic_disk(blk, buf, total_sectors);
1076         if (ret < 0) {
1077             error_setg(errp, "Unable to create or write VHD header");
1078         }
1079     } else {
1080         ret = create_fixed_disk(blk, buf, total_size, errp);
1081     }
1082
1083 out:
1084     blk_unref(blk);
1085     bdrv_unref(bs);
1086     return ret;
1087 }
1088
1089 static int coroutine_fn vpc_co_create_opts(BlockDriver *drv,
1090                                            const char *filename,
1091                                            QemuOpts *opts,
1092                                            Error **errp)
1093 {
1094     BlockdevCreateOptions *create_options = NULL;
1095     QDict *qdict;
1096     Visitor *v;
1097     BlockDriverState *bs = NULL;
1098     int ret;
1099
1100     static const QDictRenames opt_renames[] = {
1101         { VPC_OPT_FORCE_SIZE,           "force-size" },
1102         { NULL, NULL },
1103     };
1104
1105     /* Parse options and convert legacy syntax */
1106     qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true);
1107
1108     if (!qdict_rename_keys(qdict, opt_renames, errp)) {
1109         ret = -EINVAL;
1110         goto fail;
1111     }
1112
1113     /* Create and open the file (protocol layer) */
1114     ret = bdrv_create_file(filename, opts, errp);
1115     if (ret < 0) {
1116         goto fail;
1117     }
1118
1119     bs = bdrv_open(filename, NULL, NULL,
1120                    BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
1121     if (bs == NULL) {
1122         ret = -EIO;
1123         goto fail;
1124     }
1125
1126     /* Now get the QAPI type BlockdevCreateOptions */
1127     qdict_put_str(qdict, "driver", "vpc");
1128     qdict_put_str(qdict, "file", bs->node_name);
1129
1130     v = qobject_input_visitor_new_flat_confused(qdict, errp);
1131     if (!v) {
1132         ret = -EINVAL;
1133         goto fail;
1134     }
1135
1136     visit_type_BlockdevCreateOptions(v, NULL, &create_options, errp);
1137     visit_free(v);
1138     if (!create_options) {
1139         ret = -EINVAL;
1140         goto fail;
1141     }
1142
1143     /* Silently round up size */
1144     assert(create_options->driver == BLOCKDEV_DRIVER_VPC);
1145     create_options->u.vpc.size =
1146         ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
1147
1148     if (!create_options->u.vpc.force_size) {
1149         int64_t total_sectors;
1150         ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL,
1151                                            NULL, &total_sectors, errp);
1152         if (ret < 0) {
1153             goto fail;
1154         }
1155
1156         create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE;
1157     }
1158
1159
1160     /* Create the vpc image (format layer) */
1161     ret = vpc_co_create(create_options, errp);
1162
1163 fail:
1164     qobject_unref(qdict);
1165     bdrv_unref(bs);
1166     qapi_free_BlockdevCreateOptions(create_options);
1167     return ret;
1168 }
1169
1170
1171 static int vpc_has_zero_init(BlockDriverState *bs)
1172 {
1173     BDRVVPCState *s = bs->opaque;
1174     VHDFooter *footer =  (VHDFooter *) s->footer_buf;
1175
1176     if (be32_to_cpu(footer->type) == VHD_FIXED) {
1177         return bdrv_has_zero_init(bs->file->bs);
1178     } else {
1179         return 1;
1180     }
1181 }
1182
1183 static void vpc_close(BlockDriverState *bs)
1184 {
1185     BDRVVPCState *s = bs->opaque;
1186     qemu_vfree(s->pagetable);
1187 #ifdef CACHE
1188     g_free(s->pageentry_u8);
1189 #endif
1190
1191     migrate_del_blocker(s->migration_blocker);
1192     error_free(s->migration_blocker);
1193 }
1194
1195 static QemuOptsList vpc_create_opts = {
1196     .name = "vpc-create-opts",
1197     .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head),
1198     .desc = {
1199         {
1200             .name = BLOCK_OPT_SIZE,
1201             .type = QEMU_OPT_SIZE,
1202             .help = "Virtual disk size"
1203         },
1204         {
1205             .name = BLOCK_OPT_SUBFMT,
1206             .type = QEMU_OPT_STRING,
1207             .help =
1208                 "Type of virtual hard disk format. Supported formats are "
1209                 "{dynamic (default) | fixed} "
1210         },
1211         {
1212             .name = VPC_OPT_FORCE_SIZE,
1213             .type = QEMU_OPT_BOOL,
1214             .help = "Force disk size calculation to use the actual size "
1215                     "specified, rather than using the nearest CHS-based "
1216                     "calculation"
1217         },
1218         { /* end of list */ }
1219     }
1220 };
1221
1222 static const char *const vpc_strong_runtime_opts[] = {
1223     VPC_OPT_SIZE_CALC,
1224
1225     NULL
1226 };
1227
1228 static BlockDriver bdrv_vpc = {
1229     .format_name    = "vpc",
1230     .instance_size  = sizeof(BDRVVPCState),
1231
1232     .bdrv_probe             = vpc_probe,
1233     .bdrv_open              = vpc_open,
1234     .bdrv_close             = vpc_close,
1235     .bdrv_reopen_prepare    = vpc_reopen_prepare,
1236     .bdrv_child_perm        = bdrv_default_perms,
1237     .bdrv_co_create         = vpc_co_create,
1238     .bdrv_co_create_opts    = vpc_co_create_opts,
1239
1240     .bdrv_co_preadv             = vpc_co_preadv,
1241     .bdrv_co_pwritev            = vpc_co_pwritev,
1242     .bdrv_co_block_status       = vpc_co_block_status,
1243
1244     .bdrv_get_info          = vpc_get_info,
1245
1246     .is_format              = true,
1247     .create_opts            = &vpc_create_opts,
1248     .bdrv_has_zero_init     = vpc_has_zero_init,
1249     .strong_runtime_opts    = vpc_strong_runtime_opts,
1250 };
1251
1252 static void bdrv_vpc_init(void)
1253 {
1254     bdrv_register(&bdrv_vpc);
1255 }
1256
1257 block_init(bdrv_vpc_init);