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