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 #include "qemu/osdep.h"
  26 #include "qemu-common.h"
  27 #include "block/block_int.h"
  28 #include "sysemu/block-backend.h"
  29 #include "qemu/module.h"
  30 #include "migration/migration.h"
  31 #if defined(CONFIG_UUID)
  32 #include <uuid/uuid.h>
  33 #endif
  34
  35 /**************************************************************/
  36
  37 #define HEADER_SIZE 512
  38
  39 //#define CACHE
  40
  41 enum vhd_type {
  42     VHD_FIXED           = 2,
  43     VHD_DYNAMIC         = 3,
  44     VHD_DIFFERENCING    = 4,
  45 };
  46
  47 // Seconds since Jan 1, 2000 0:00:00 (UTC)
  48 #define VHD_TIMESTAMP_BASE 946684800
  49
  50 #define VHD_CHS_MAX_C   65535LL
  51 #define VHD_CHS_MAX_H   16
  52 #define VHD_CHS_MAX_S   255
  53
  54 #define VHD_MAX_SECTORS       (65535LL * 255 * 255)
  55 #define VHD_MAX_GEOMETRY      (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S)
  56
  57 #define VPC_OPT_FORCE_SIZE "force_size"
  58
  59 // always big-endian
  60 typedef struct vhd_footer {
  61     char        creator[8]; // "conectix"
  62     uint32_t    features;
  63     uint32_t    version;
  64
  65     // Offset of next header structure, 0xFFFFFFFF if none
  66     uint64_t    data_offset;
  67
  68     // Seconds since Jan 1, 2000 0:00:00 (UTC)
  69     uint32_t    timestamp;
  70
  71     char        creator_app[4]; // "vpc "
  72     uint16_t    major;
  73     uint16_t    minor;
  74     char        creator_os[4]; // "Wi2k"
  75
  76     uint64_t    orig_size;
  77     uint64_t    current_size;
  78
  79     uint16_t    cyls;
  80     uint8_t     heads;
  81     uint8_t     secs_per_cyl;
  82
  83     uint32_t    type;
  84
  85     // Checksum of the Hard Disk Footer ("one's complement of the sum of all
  86     // the bytes in the footer without the checksum field")
  87     uint32_t    checksum;
  88
  89     // UUID used to identify a parent hard disk (backing file)
  90     uint8_t     uuid[16];
  91
  92     uint8_t     in_saved_state;
  93 } QEMU_PACKED VHDFooter;
  94
  95 typedef struct vhd_dyndisk_header {
  96     char        magic[8]; // "cxsparse"
  97
  98     // Offset of next header structure, 0xFFFFFFFF if none
  99     uint64_t    data_offset;
 100
 101     // Offset of the Block Allocation Table (BAT)
 102     uint64_t    table_offset;
 103
 104     uint32_t    version;
 105     uint32_t    max_table_entries; // 32bit/entry
 106
 107     // 2 MB by default, must be a power of two
 108     uint32_t    block_size;
 109
 110     uint32_t    checksum;
 111     uint8_t     parent_uuid[16];
 112     uint32_t    parent_timestamp;
 113     uint32_t    reserved;
 114
 115     // Backing file name (in UTF-16)
 116     uint8_t     parent_name[512];
 117
 118     struct {
 119         uint32_t    platform;
 120         uint32_t    data_space;
 121         uint32_t    data_length;
 122         uint32_t    reserved;
 123         uint64_t    data_offset;
 124     } parent_locator[8];
 125 } QEMU_PACKED VHDDynDiskHeader;
 126
 127 typedef struct BDRVVPCState {
 128     CoMutex lock;
 129     uint8_t footer_buf[HEADER_SIZE];
 130     uint64_t free_data_block_offset;
 131     int max_table_entries;
 132     uint32_t *pagetable;
 133     uint64_t bat_offset;
 134     uint64_t last_bitmap_offset;
 135
 136     uint32_t block_size;
 137     uint32_t bitmap_size;
 138     bool force_use_chs;
 139     bool force_use_sz;
 140
 141 #ifdef CACHE
 142     uint8_t *pageentry_u8;
 143     uint32_t *pageentry_u32;
 144     uint16_t *pageentry_u16;
 145
 146     uint64_t last_bitmap;
 147 #endif
 148
 149     Error *migration_blocker;
 150 } BDRVVPCState;
 151
 152 #define VPC_OPT_SIZE_CALC "force_size_calc"
 153 static QemuOptsList vpc_runtime_opts = {
 154     .name = "vpc-runtime-opts",
 155     .head = QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts.head),
 156     .desc = {
 157         {
 158             .name = VPC_OPT_SIZE_CALC,
 159             .type = QEMU_OPT_STRING,
 160             .help = "Force disk size calculation to use either CHS geometry, "
 161                     "or use the disk current_size specified in the VHD footer. "
 162                     "{chs, current_size}"
 163         },
 164         { /* end of list */ }
 165     }
 166 };
 167
 168 static uint32_t vpc_checksum(uint8_t* buf, size_t size)
 169 {
 170     uint32_t res = 0;
 171     int i;
 172
 173     for (i = 0; i < size; i++)
 174         res += buf[i];
 175
 176     return ~res;
 177 }
 178
 179
 180 static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
 181 {
 182     if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
 183         return 100;
 184     return 0;
 185 }
 186
 187 static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
 188                               Error **errp)
 189 {
 190     BDRVVPCState *s = bs->opaque;
 191     const char *size_calc;
 192
 193     size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC);
 194
 195     if (!size_calc) {
 196        /* no override, use autodetect only */
 197     } else if (!strcmp(size_calc, "current_size")) {
 198         s->force_use_sz = true;
 199     } else if (!strcmp(size_calc, "chs")) {
 200         s->force_use_chs = true;
 201     } else {
 202         error_setg(errp, "Invalid size calculation mode: '%s'", size_calc);
 203     }
 204 }
 205
 206 static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
 207                     Error **errp)
 208 {
 209     BDRVVPCState *s = bs->opaque;
 210     int i;
 211     VHDFooter *footer;
 212     VHDDynDiskHeader *dyndisk_header;
 213     QemuOpts *opts = NULL;
 214     Error *local_err = NULL;
 215     bool use_chs;
 216     uint8_t buf[HEADER_SIZE];
 217     uint32_t checksum;
 218     uint64_t computed_size;
 219     uint64_t pagetable_size;
 220     int disk_type = VHD_DYNAMIC;
 221     int ret;
 222
 223     opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
 224     qemu_opts_absorb_qdict(opts, options, &local_err);
 225     if (local_err) {
 226         error_propagate(errp, local_err);
 227         ret = -EINVAL;
 228         goto fail;
 229     }
 230
 231     vpc_parse_options(bs, opts, &local_err);
 232     if (local_err) {
 233         error_propagate(errp, local_err);
 234         ret = -EINVAL;
 235         goto fail;
 236     }
 237
 238     ret = bdrv_pread(bs->file->bs, 0, s->footer_buf, HEADER_SIZE);
 239     if (ret < 0) {
 240         goto fail;
 241     }
 242
 243     footer = (VHDFooter *) s->footer_buf;
 244     if (strncmp(footer->creator, "conectix", 8)) {
 245         int64_t offset = bdrv_getlength(bs->file->bs);
 246         if (offset < 0) {
 247             ret = offset;
 248             goto fail;
 249         } else if (offset < HEADER_SIZE) {
 250             ret = -EINVAL;
 251             goto fail;
 252         }
 253
 254         /* If a fixed disk, the footer is found only at the end of the file */
 255         ret = bdrv_pread(bs->file->bs, offset-HEADER_SIZE, s->footer_buf,
 256                          HEADER_SIZE);
 257         if (ret < 0) {
 258             goto fail;
 259         }
 260         if (strncmp(footer->creator, "conectix", 8)) {
 261             error_setg(errp, "invalid VPC image");
 262             ret = -EINVAL;
 263             goto fail;
 264         }
 265         disk_type = VHD_FIXED;
 266     }
 267
 268     checksum = be32_to_cpu(footer->checksum);
 269     footer->checksum = 0;
 270     if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum)
 271         fprintf(stderr, "block-vpc: The header checksum of '%s' is "
 272             "incorrect.\n", bs->filename);
 273
 274     /* Write 'checksum' back to footer, or else will leave it with zero. */
 275     footer->checksum = cpu_to_be32(checksum);
 276
 277     // The visible size of a image in Virtual PC depends on the geometry
 278     // rather than on the size stored in the footer (the size in the footer
 279     // is too large usually)
 280     bs->total_sectors = (int64_t)
 281         be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
 282
 283     /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
 284      * VHD image sizes differently.  VPC will rely on CHS geometry,
 285      * while Hyper-V and disk2vhd use the size specified in the footer.
 286      *
 287      * We use a couple of approaches to try and determine the correct method:
 288      * look at the Creator App field, and look for images that have CHS
 289      * geometry that is the maximum value.
 290      *
 291      * If the CHS geometry is the maximum CHS geometry, then we assume that
 292      * the size is the footer->current_size to avoid truncation.  Otherwise,
 293      * we follow the table based on footer->creator_app:
 294      *
 295      *  Known creator apps:
 296      *      'vpc '  :  CHS              Virtual PC (uses disk geometry)
 297      *      'qemu'  :  CHS              QEMU (uses disk geometry)
 298      *      'qem2'  :  current_size     QEMU (uses current_size)
 299      *      'win '  :  current_size     Hyper-V
 300      *      'd2v '  :  current_size     Disk2vhd
 301      *
 302      *  The user can override the table values via drive options, however
 303      *  even with an override we will still use current_size for images
 304      *  that have CHS geometry of the maximum size.
 305      */
 306     use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
 307                !!strncmp(footer->creator_app, "qem2", 4) &&
 308                !!strncmp(footer->creator_app, "d2v ", 4)) || s->force_use_chs;
 309
 310     if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
 311         bs->total_sectors = be64_to_cpu(footer->current_size) /
 312                                         BDRV_SECTOR_SIZE;
 313     }
 314
 315     /* Allow a maximum disk size of approximately 2 TB */
 316     if (bs->total_sectors >= VHD_MAX_SECTORS) {
 317         ret = -EFBIG;
 318         goto fail;
 319     }
 320
 321     if (disk_type == VHD_DYNAMIC) {
 322         ret = bdrv_pread(bs->file->bs, be64_to_cpu(footer->data_offset), buf,
 323                          HEADER_SIZE);
 324         if (ret < 0) {
 325             goto fail;
 326         }
 327
 328         dyndisk_header = (VHDDynDiskHeader *) buf;
 329
 330         if (strncmp(dyndisk_header->magic, "cxsparse", 8)) {
 331             ret = -EINVAL;
 332             goto fail;
 333         }
 334
 335         s->block_size = be32_to_cpu(dyndisk_header->block_size);
 336         if (!is_power_of_2(s->block_size) || s->block_size < BDRV_SECTOR_SIZE) {
 337             error_setg(errp, "Invalid block size %" PRIu32, s->block_size);
 338             ret = -EINVAL;
 339             goto fail;
 340         }
 341         s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511;
 342
 343         s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries);
 344
 345         if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) {
 346             ret = -EINVAL;
 347             goto fail;
 348         }
 349         if (s->max_table_entries > (VHD_MAX_SECTORS * 512) / s->block_size) {
 350             ret = -EINVAL;
 351             goto fail;
 352         }
 353
 354         computed_size = (uint64_t) s->max_table_entries * s->block_size;
 355         if (computed_size < bs->total_sectors * 512) {
 356             ret = -EINVAL;
 357             goto fail;
 358         }
 359
 360         if (s->max_table_entries > SIZE_MAX / 4 ||
 361             s->max_table_entries > (int) INT_MAX / 4) {
 362             error_setg(errp, "Max Table Entries too large (%" PRId32 ")",
 363                         s->max_table_entries);
 364             ret = -EINVAL;
 365             goto fail;
 366         }
 367
 368         pagetable_size = (uint64_t) s->max_table_entries * 4;
 369
 370         s->pagetable = qemu_try_blockalign(bs->file->bs, pagetable_size);
 371         if (s->pagetable == NULL) {
 372             ret = -ENOMEM;
 373             goto fail;
 374         }
 375
 376         s->bat_offset = be64_to_cpu(dyndisk_header->table_offset);
 377
 378         ret = bdrv_pread(bs->file->bs, s->bat_offset, s->pagetable,
 379                          pagetable_size);
 380         if (ret < 0) {
 381             goto fail;
 382         }
 383
 384         s->free_data_block_offset =
 385             ROUND_UP(s->bat_offset + pagetable_size, 512);
 386
 387         for (i = 0; i < s->max_table_entries; i++) {
 388             be32_to_cpus(&s->pagetable[i]);
 389             if (s->pagetable[i] != 0xFFFFFFFF) {
 390                 int64_t next = (512 * (int64_t) s->pagetable[i]) +
 391                     s->bitmap_size + s->block_size;
 392
 393                 if (next > s->free_data_block_offset) {
 394                     s->free_data_block_offset = next;
 395                 }
 396             }
 397         }
 398
 399         if (s->free_data_block_offset > bdrv_getlength(bs->file->bs)) {
 400             error_setg(errp, "block-vpc: free_data_block_offset points after "
 401                              "the end of file. The image has been truncated.");
 402             ret = -EINVAL;
 403             goto fail;
 404         }
 405
 406         s->last_bitmap_offset = (int64_t) -1;
 407
 408 #ifdef CACHE
 409         s->pageentry_u8 = g_malloc(512);
 410         s->pageentry_u32 = s->pageentry_u8;
 411         s->pageentry_u16 = s->pageentry_u8;
 412         s->last_pagetable = -1;
 413 #endif
 414     }
 415
 416     qemu_co_mutex_init(&s->lock);
 417
 418     /* Disable migration when VHD images are used */
 419     error_setg(&s->migration_blocker, "The vpc format used by node '%s' "
 420                "does not support live migration",
 421                bdrv_get_device_or_node_name(bs));
 422     migrate_add_blocker(s->migration_blocker);
 423
 424     return 0;
 425
 426 fail:
 427     qemu_vfree(s->pagetable);
 428 #ifdef CACHE
 429     g_free(s->pageentry_u8);
 430 #endif
 431     return ret;
 432 }
 433
 434 static int vpc_reopen_prepare(BDRVReopenState *state,
 435                               BlockReopenQueue *queue, Error **errp)
 436 {
 437     return 0;
 438 }
 439
 440 /*
 441  * Returns the absolute byte offset of the given sector in the image file.
 442  * If the sector is not allocated, -1 is returned instead.
 443  *
 444  * The parameter write must be 1 if the offset will be used for a write
 445  * operation (the block bitmaps is updated then), 0 otherwise.
 446  */
 447 static inline int64_t get_sector_offset(BlockDriverState *bs,
 448     int64_t sector_num, int write)
 449 {
 450     BDRVVPCState *s = bs->opaque;
 451     uint64_t offset = sector_num * 512;
 452     uint64_t bitmap_offset, block_offset;
 453     uint32_t pagetable_index, pageentry_index;
 454
 455     pagetable_index = offset / s->block_size;
 456     pageentry_index = (offset % s->block_size) / 512;
 457
 458     if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)
 459         return -1; // not allocated
 460
 461     bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
 462     block_offset = bitmap_offset + s->bitmap_size + (512 * pageentry_index);
 463
 464     // We must ensure that we don't write to any sectors which are marked as
 465     // unused in the bitmap. We get away with setting all bits in the block
 466     // bitmap each time we write to a new block. This might cause Virtual PC to
 467     // miss sparse read optimization, but it's not a problem in terms of
 468     // correctness.
 469     if (write && (s->last_bitmap_offset != bitmap_offset)) {
 470         uint8_t bitmap[s->bitmap_size];
 471
 472         s->last_bitmap_offset = bitmap_offset;
 473         memset(bitmap, 0xff, s->bitmap_size);
 474         bdrv_pwrite_sync(bs->file->bs, bitmap_offset, bitmap, s->bitmap_size);
 475     }
 476
 477     return block_offset;
 478 }
 479
 480 /*
 481  * Writes the footer to the end of the image file. This is needed when the
 482  * file grows as it overwrites the old footer
 483  *
 484  * Returns 0 on success and < 0 on error
 485  */
 486 static int rewrite_footer(BlockDriverState* bs)
 487 {
 488     int ret;
 489     BDRVVPCState *s = bs->opaque;
 490     int64_t offset = s->free_data_block_offset;
 491
 492     ret = bdrv_pwrite_sync(bs->file->bs, offset, s->footer_buf, HEADER_SIZE);
 493     if (ret < 0)
 494         return ret;
 495
 496     return 0;
 497 }
 498
 499 /*
 500  * Allocates a new block. This involves writing a new footer and updating
 501  * the Block Allocation Table to use the space at the old end of the image
 502  * file (overwriting the old footer)
 503  *
 504  * Returns the sectors' offset in the image file on success and < 0 on error
 505  */
 506 static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
 507 {
 508     BDRVVPCState *s = bs->opaque;
 509     int64_t bat_offset;
 510     uint32_t index, bat_value;
 511     int ret;
 512     uint8_t bitmap[s->bitmap_size];
 513
 514     // Check if sector_num is valid
 515     if ((sector_num < 0) || (sector_num > bs->total_sectors))
 516         return -1;
 517
 518     // Write entry into in-memory BAT
 519     index = (sector_num * 512) / s->block_size;
 520     if (s->pagetable[index] != 0xFFFFFFFF)
 521         return -1;
 522
 523     s->pagetable[index] = s->free_data_block_offset / 512;
 524
 525     // Initialize the block's bitmap
 526     memset(bitmap, 0xff, s->bitmap_size);
 527     ret = bdrv_pwrite_sync(bs->file->bs, s->free_data_block_offset, bitmap,
 528         s->bitmap_size);
 529     if (ret < 0) {
 530         return ret;
 531     }
 532
 533     // Write new footer (the old one will be overwritten)
 534     s->free_data_block_offset += s->block_size + s->bitmap_size;
 535     ret = rewrite_footer(bs);
 536     if (ret < 0)
 537         goto fail;
 538
 539     // Write BAT entry to disk
 540     bat_offset = s->bat_offset + (4 * index);
 541     bat_value = cpu_to_be32(s->pagetable[index]);
 542     ret = bdrv_pwrite_sync(bs->file->bs, bat_offset, &bat_value, 4);
 543     if (ret < 0)
 544         goto fail;
 545
 546     return get_sector_offset(bs, sector_num, 0);
 547
 548 fail:
 549     s->free_data_block_offset -= (s->block_size + s->bitmap_size);
 550     return -1;
 551 }
 552
 553 static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 554 {
 555     BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
 556     VHDFooter *footer = (VHDFooter *) s->footer_buf;
 557
 558     if (be32_to_cpu(footer->type) != VHD_FIXED) {
 559         bdi->cluster_size = s->block_size;
 560     }
 561
 562     bdi->unallocated_blocks_are_zero = true;
 563     return 0;
 564 }
 565
 566 static int vpc_read(BlockDriverState *bs, int64_t sector_num,
 567                     uint8_t *buf, int nb_sectors)
 568 {
 569     BDRVVPCState *s = bs->opaque;
 570     int ret;
 571     int64_t offset;
 572     int64_t sectors, sectors_per_block;
 573     VHDFooter *footer = (VHDFooter *) s->footer_buf;
 574
 575     if (be32_to_cpu(footer->type) == VHD_FIXED) {
 576         return bdrv_read(bs->file->bs, sector_num, buf, nb_sectors);
 577     }
 578     while (nb_sectors > 0) {
 579         offset = get_sector_offset(bs, sector_num, 0);
 580
 581         sectors_per_block = s->block_size >> BDRV_SECTOR_BITS;
 582         sectors = sectors_per_block - (sector_num % sectors_per_block);
 583         if (sectors > nb_sectors) {
 584             sectors = nb_sectors;
 585         }
 586
 587         if (offset == -1) {
 588             memset(buf, 0, sectors * BDRV_SECTOR_SIZE);
 589         } else {
 590             ret = bdrv_pread(bs->file->bs, offset, buf,
 591                 sectors * BDRV_SECTOR_SIZE);
 592             if (ret != sectors * BDRV_SECTOR_SIZE) {
 593                 return -1;
 594             }
 595         }
 596
 597         nb_sectors -= sectors;
 598         sector_num += sectors;
 599         buf += sectors * BDRV_SECTOR_SIZE;
 600     }
 601     return 0;
 602 }
 603
 604 static coroutine_fn int vpc_co_read(BlockDriverState *bs, int64_t sector_num,
 605                                     uint8_t *buf, int nb_sectors)
 606 {
 607     int ret;
 608     BDRVVPCState *s = bs->opaque;
 609     qemu_co_mutex_lock(&s->lock);
 610     ret = vpc_read(bs, sector_num, buf, nb_sectors);
 611     qemu_co_mutex_unlock(&s->lock);
 612     return ret;
 613 }
 614
 615 static int vpc_write(BlockDriverState *bs, int64_t sector_num,
 616     const uint8_t *buf, int nb_sectors)
 617 {
 618     BDRVVPCState *s = bs->opaque;
 619     int64_t offset;
 620     int64_t sectors, sectors_per_block;
 621     int ret;
 622     VHDFooter *footer =  (VHDFooter *) s->footer_buf;
 623
 624     if (be32_to_cpu(footer->type) == VHD_FIXED) {
 625         return bdrv_write(bs->file->bs, sector_num, buf, nb_sectors);
 626     }
 627     while (nb_sectors > 0) {
 628         offset = get_sector_offset(bs, sector_num, 1);
 629
 630         sectors_per_block = s->block_size >> BDRV_SECTOR_BITS;
 631         sectors = sectors_per_block - (sector_num % sectors_per_block);
 632         if (sectors > nb_sectors) {
 633             sectors = nb_sectors;
 634         }
 635
 636         if (offset == -1) {
 637             offset = alloc_block(bs, sector_num);
 638             if (offset < 0)
 639                 return -1;
 640         }
 641
 642         ret = bdrv_pwrite(bs->file->bs, offset, buf,
 643                           sectors * BDRV_SECTOR_SIZE);
 644         if (ret != sectors * BDRV_SECTOR_SIZE) {
 645             return -1;
 646         }
 647
 648         nb_sectors -= sectors;
 649         sector_num += sectors;
 650         buf += sectors * BDRV_SECTOR_SIZE;
 651     }
 652
 653     return 0;
 654 }
 655
 656 static coroutine_fn int vpc_co_write(BlockDriverState *bs, int64_t sector_num,
 657                                      const uint8_t *buf, int nb_sectors)
 658 {
 659     int ret;
 660     BDRVVPCState *s = bs->opaque;
 661     qemu_co_mutex_lock(&s->lock);
 662     ret = vpc_write(bs, sector_num, buf, nb_sectors);
 663     qemu_co_mutex_unlock(&s->lock);
 664     return ret;
 665 }
 666
 667 static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
 668         int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
 669 {
 670     BDRVVPCState *s = bs->opaque;
 671     VHDFooter *footer = (VHDFooter*) s->footer_buf;
 672     int64_t start, offset;
 673     bool allocated;
 674     int n;
 675
 676     if (be32_to_cpu(footer->type) == VHD_FIXED) {
 677         *pnum = nb_sectors;
 678         *file = bs->file->bs;
 679         return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_DATA |
 680                (sector_num << BDRV_SECTOR_BITS);
 681     }
 682
 683     offset = get_sector_offset(bs, sector_num, 0);
 684     start = offset;
 685     allocated = (offset != -1);
 686     *pnum = 0;
 687
 688     do {
 689         /* All sectors in a block are contiguous (without using the bitmap) */
 690         n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)
 691           - sector_num;
 692         n = MIN(n, nb_sectors);
 693
 694         *pnum += n;
 695         sector_num += n;
 696         nb_sectors -= n;
 697         /* *pnum can't be greater than one block for allocated
 698          * sectors since there is always a bitmap in between. */
 699         if (allocated) {
 700             *file = bs->file->bs;
 701             return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
 702         }
 703         if (nb_sectors == 0) {
 704             break;
 705         }
 706         offset = get_sector_offset(bs, sector_num, 0);
 707     } while (offset == -1);
 708
 709     return 0;
 710 }
 711
 712 /*
 713  * Calculates the number of cylinders, heads and sectors per cylinder
 714  * based on a given number of sectors. This is the algorithm described
 715  * in the VHD specification.
 716  *
 717  * Note that the geometry doesn't always exactly match total_sectors but
 718  * may round it down.
 719  *
 720  * Returns 0 on success, -EFBIG if the size is larger than ~2 TB. Override
 721  * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
 722  * and instead allow up to 255 heads.
 723  */
 724 static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
 725     uint8_t* heads, uint8_t* secs_per_cyl)
 726 {
 727     uint32_t cyls_times_heads;
 728
 729     total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY);
 730
 731     if (total_sectors >= 65535LL * 16 * 63) {
 732         *secs_per_cyl = 255;
 733         *heads = 16;
 734         cyls_times_heads = total_sectors / *secs_per_cyl;
 735     } else {
 736         *secs_per_cyl = 17;
 737         cyls_times_heads = total_sectors / *secs_per_cyl;
 738         *heads = (cyls_times_heads + 1023) / 1024;
 739
 740         if (*heads < 4) {
 741             *heads = 4;
 742         }
 743
 744         if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
 745             *secs_per_cyl = 31;
 746             *heads = 16;
 747             cyls_times_heads = total_sectors / *secs_per_cyl;
 748         }
 749
 750         if (cyls_times_heads >= (*heads * 1024)) {
 751             *secs_per_cyl = 63;
 752             *heads = 16;
 753             cyls_times_heads = total_sectors / *secs_per_cyl;
 754         }
 755     }
 756
 757     *cyls = cyls_times_heads / *heads;
 758
 759     return 0;
 760 }
 761
 762 static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf,
 763                                int64_t total_sectors)
 764 {
 765     VHDDynDiskHeader *dyndisk_header =
 766         (VHDDynDiskHeader *) buf;
 767     size_t block_size, num_bat_entries;
 768     int i;
 769     int ret;
 770     int64_t offset = 0;
 771
 772     // Write the footer (twice: at the beginning and at the end)
 773     block_size = 0x200000;
 774     num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512);
 775
 776     ret = blk_pwrite(blk, offset, buf, HEADER_SIZE);
 777     if (ret) {
 778         goto fail;
 779     }
 780
 781     offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
 782     ret = blk_pwrite(blk, offset, buf, HEADER_SIZE);
 783     if (ret < 0) {
 784         goto fail;
 785     }
 786
 787     // Write the initial BAT
 788     offset = 3 * 512;
 789
 790     memset(buf, 0xFF, 512);
 791     for (i = 0; i < (num_bat_entries * 4 + 511) / 512; i++) {
 792         ret = blk_pwrite(blk, offset, buf, 512);
 793         if (ret < 0) {
 794             goto fail;
 795         }
 796         offset += 512;
 797     }
 798
 799     // Prepare the Dynamic Disk Header
 800     memset(buf, 0, 1024);
 801
 802     memcpy(dyndisk_header->magic, "cxsparse", 8);
 803
 804     /*
 805      * Note: The spec is actually wrong here for data_offset, it says
 806      * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
 807      */
 808     dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
 809     dyndisk_header->table_offset = cpu_to_be64(3 * 512);
 810     dyndisk_header->version = cpu_to_be32(0x00010000);
 811     dyndisk_header->block_size = cpu_to_be32(block_size);
 812     dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries);
 813
 814     dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024));
 815
 816     // Write the header
 817     offset = 512;
 818
 819     ret = blk_pwrite(blk, offset, buf, 1024);
 820     if (ret < 0) {
 821         goto fail;
 822     }
 823
 824  fail:
 825     return ret;
 826 }
 827
 828 static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
 829                              int64_t total_size)
 830 {
 831     int ret;
 832
 833     /* Add footer to total size */
 834     total_size += HEADER_SIZE;
 835
 836     ret = blk_truncate(blk, total_size);
 837     if (ret < 0) {
 838         return ret;
 839     }
 840
 841     ret = blk_pwrite(blk, total_size - HEADER_SIZE, buf, HEADER_SIZE);
 842     if (ret < 0) {
 843         return ret;
 844     }
 845
 846     return ret;
 847 }
 848
 849 static int vpc_create(const char *filename, QemuOpts *opts, Error **errp)
 850 {
 851     uint8_t buf[1024];
 852     VHDFooter *footer = (VHDFooter *) buf;
 853     char *disk_type_param;
 854     int i;
 855     uint16_t cyls = 0;
 856     uint8_t heads = 0;
 857     uint8_t secs_per_cyl = 0;
 858     int64_t total_sectors;
 859     int64_t total_size;
 860     int disk_type;
 861     int ret = -EIO;
 862     bool force_size;
 863     Error *local_err = NULL;
 864     BlockBackend *blk = NULL;
 865
 866     /* Read out options */
 867     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 868                           BDRV_SECTOR_SIZE);
 869     disk_type_param = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
 870     if (disk_type_param) {
 871         if (!strcmp(disk_type_param, "dynamic")) {
 872             disk_type = VHD_DYNAMIC;
 873         } else if (!strcmp(disk_type_param, "fixed")) {
 874             disk_type = VHD_FIXED;
 875         } else {
 876             ret = -EINVAL;
 877             goto out;
 878         }
 879     } else {
 880         disk_type = VHD_DYNAMIC;
 881     }
 882
 883     force_size = qemu_opt_get_bool_del(opts, VPC_OPT_FORCE_SIZE, false);
 884
 885     ret = bdrv_create_file(filename, opts, &local_err);
 886     if (ret < 0) {
 887         error_propagate(errp, local_err);
 888         goto out;
 889     }
 890
 891     blk = blk_new_open("image", filename, NULL, NULL,
 892                        BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_PROTOCOL,
 893                        &local_err);
 894     if (blk == NULL) {
 895         error_propagate(errp, local_err);
 896         ret = -EIO;
 897         goto out;
 898     }
 899
 900     blk_set_allow_write_beyond_eof(blk, true);
 901
 902     /*
 903      * Calculate matching total_size and geometry. Increase the number of
 904      * sectors requested until we get enough (or fail). This ensures that
 905      * qemu-img convert doesn't truncate images, but rather rounds up.
 906      *
 907      * If the image size can't be represented by a spec conformant CHS geometry,
 908      * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
 909      * the image size from the VHD footer to calculate total_sectors.
 910      */
 911     if (force_size) {
 912         /* This will force the use of total_size for sector count, below */
 913         cyls         = VHD_CHS_MAX_C;
 914         heads        = VHD_CHS_MAX_H;
 915         secs_per_cyl = VHD_CHS_MAX_S;
 916     } else {
 917         total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
 918         for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
 919             calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
 920         }
 921     }
 922
 923     if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
 924         total_sectors = total_size / BDRV_SECTOR_SIZE;
 925         /* Allow a maximum disk size of approximately 2 TB */
 926         if (total_sectors > VHD_MAX_SECTORS) {
 927             ret = -EFBIG;
 928             goto out;
 929         }
 930     } else {
 931         total_sectors = (int64_t)cyls * heads * secs_per_cyl;
 932         total_size = total_sectors * BDRV_SECTOR_SIZE;
 933     }
 934
 935     /* Prepare the Hard Disk Footer */
 936     memset(buf, 0, 1024);
 937
 938     memcpy(footer->creator, "conectix", 8);
 939     if (force_size) {
 940         memcpy(footer->creator_app, "qem2", 4);
 941     } else {
 942         memcpy(footer->creator_app, "qemu", 4);
 943     }
 944     memcpy(footer->creator_os, "Wi2k", 4);
 945
 946     footer->features = cpu_to_be32(0x02);
 947     footer->version = cpu_to_be32(0x00010000);
 948     if (disk_type == VHD_DYNAMIC) {
 949         footer->data_offset = cpu_to_be64(HEADER_SIZE);
 950     } else {
 951         footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
 952     }
 953     footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
 954
 955     /* Version of Virtual PC 2007 */
 956     footer->major = cpu_to_be16(0x0005);
 957     footer->minor = cpu_to_be16(0x0003);
 958     footer->orig_size = cpu_to_be64(total_size);
 959     footer->current_size = cpu_to_be64(total_size);
 960     footer->cyls = cpu_to_be16(cyls);
 961     footer->heads = heads;
 962     footer->secs_per_cyl = secs_per_cyl;
 963
 964     footer->type = cpu_to_be32(disk_type);
 965
 966 #if defined(CONFIG_UUID)
 967     uuid_generate(footer->uuid);
 968 #endif
 969
 970     footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE));
 971
 972     if (disk_type == VHD_DYNAMIC) {
 973         ret = create_dynamic_disk(blk, buf, total_sectors);
 974     } else {
 975         ret = create_fixed_disk(blk, buf, total_size);
 976     }
 977
 978 out:
 979     blk_unref(blk);
 980     g_free(disk_type_param);
 981     return ret;
 982 }
 983
 984 static int vpc_has_zero_init(BlockDriverState *bs)
 985 {
 986     BDRVVPCState *s = bs->opaque;
 987     VHDFooter *footer =  (VHDFooter *) s->footer_buf;
 988
 989     if (be32_to_cpu(footer->type) == VHD_FIXED) {
 990         return bdrv_has_zero_init(bs->file->bs);
 991     } else {
 992         return 1;
 993     }
 994 }
 995
 996 static void vpc_close(BlockDriverState *bs)
 997 {
 998     BDRVVPCState *s = bs->opaque;
 999     qemu_vfree(s->pagetable);
1000 #ifdef CACHE
1001     g_free(s->pageentry_u8);
1002 #endif
1003
1004     migrate_del_blocker(s->migration_blocker);
1005     error_free(s->migration_blocker);
1006 }
1007
1008 static QemuOptsList vpc_create_opts = {
1009     .name = "vpc-create-opts",
1010     .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head),
1011     .desc = {
1012         {
1013             .name = BLOCK_OPT_SIZE,
1014             .type = QEMU_OPT_SIZE,
1015             .help = "Virtual disk size"
1016         },
1017         {
1018             .name = BLOCK_OPT_SUBFMT,
1019             .type = QEMU_OPT_STRING,
1020             .help =
1021                 "Type of virtual hard disk format. Supported formats are "
1022                 "{dynamic (default) | fixed} "
1023         },
1024         {
1025             .name = VPC_OPT_FORCE_SIZE,
1026             .type = QEMU_OPT_BOOL,
1027             .help = "Force disk size calculation to use the actual size "
1028                     "specified, rather than using the nearest CHS-based "
1029                     "calculation"
1030         },
1031         { /* end of list */ }
1032     }
1033 };
1034
1035 static BlockDriver bdrv_vpc = {
1036     .format_name    = "vpc",
1037     .instance_size  = sizeof(BDRVVPCState),
1038
1039     .bdrv_probe             = vpc_probe,
1040     .bdrv_open              = vpc_open,
1041     .bdrv_close             = vpc_close,
1042     .bdrv_reopen_prepare    = vpc_reopen_prepare,
1043     .bdrv_create            = vpc_create,
1044
1045     .bdrv_read                  = vpc_co_read,
1046     .bdrv_write                 = vpc_co_write,
1047     .bdrv_co_get_block_status   = vpc_co_get_block_status,
1048
1049     .bdrv_get_info          = vpc_get_info,
1050
1051     .create_opts            = &vpc_create_opts,
1052     .bdrv_has_zero_init     = vpc_has_zero_init,
1053 };
1054
1055 static void bdrv_vpc_init(void)
1056 {
1057     bdrv_register(&bdrv_vpc);
1058 }
1059
1060 block_init(bdrv_vpc_init);