2 * Block driver for Connectix / Microsoft Virtual PC images
4 * Copyright (c) 2005 Alex Beregszaszi
5 * Copyright (c) 2009 Kevin Wolf <kwolf@suse.de>
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu-common.h"
28 #include "block/block_int.h"
29 #include "sysemu/block-backend.h"
30 #include "qemu/module.h"
31 #include "migration/migration.h"
32 #if defined(CONFIG_UUID)
33 #include <uuid/uuid.h>
36 /**************************************************************/
38 #define HEADER_SIZE 512
48 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
49 #define VHD_TIMESTAMP_BASE 946684800
51 #define VHD_CHS_MAX_C 65535LL
52 #define VHD_CHS_MAX_H 16
53 #define VHD_CHS_MAX_S 255
55 #define VHD_MAX_SECTORS 0xff000000 /* 2040 GiB max image size */
56 #define VHD_MAX_GEOMETRY (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S)
58 #define VPC_OPT_FORCE_SIZE "force_size"
60 /* always big-endian */
61 typedef struct vhd_footer {
62 char creator[8]; /* "conectix" */
66 /* Offset of next header structure, 0xFFFFFFFF if none */
69 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
72 char creator_app[4]; /* e.g., "vpc " */
75 char creator_os[4]; /* "Wi2k" */
78 uint64_t current_size;
86 /* Checksum of the Hard Disk Footer ("one's complement of the sum of all
87 the bytes in the footer without the checksum field") */
90 /* UUID used to identify a parent hard disk (backing file) */
93 uint8_t in_saved_state;
94 } QEMU_PACKED VHDFooter;
96 typedef struct vhd_dyndisk_header {
97 char magic[8]; /* "cxsparse" */
99 /* Offset of next header structure, 0xFFFFFFFF if none */
100 uint64_t data_offset;
102 /* Offset of the Block Allocation Table (BAT) */
103 uint64_t table_offset;
106 uint32_t max_table_entries; /* 32bit/entry */
108 /* 2 MB by default, must be a power of two */
112 uint8_t parent_uuid[16];
113 uint32_t parent_timestamp;
116 /* Backing file name (in UTF-16) */
117 uint8_t parent_name[512];
122 uint32_t data_length;
124 uint64_t data_offset;
126 } QEMU_PACKED VHDDynDiskHeader;
128 typedef struct BDRVVPCState {
130 uint8_t footer_buf[HEADER_SIZE];
131 uint64_t free_data_block_offset;
132 int max_table_entries;
135 uint64_t last_bitmap_offset;
138 uint32_t bitmap_size;
143 uint8_t *pageentry_u8;
144 uint32_t *pageentry_u32;
145 uint16_t *pageentry_u16;
147 uint64_t last_bitmap;
150 Error *migration_blocker;
153 #define VPC_OPT_SIZE_CALC "force_size_calc"
154 static QemuOptsList vpc_runtime_opts = {
155 .name = "vpc-runtime-opts",
156 .head = QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts.head),
159 .name = VPC_OPT_SIZE_CALC,
160 .type = QEMU_OPT_STRING,
161 .help = "Force disk size calculation to use either CHS geometry, "
162 "or use the disk current_size specified in the VHD footer. "
163 "{chs, current_size}"
165 { /* end of list */ }
169 static uint32_t vpc_checksum(uint8_t* buf, size_t size)
174 for (i = 0; i < size; i++)
181 static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
183 if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
188 static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
191 BDRVVPCState *s = bs->opaque;
192 const char *size_calc;
194 size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC);
197 /* no override, use autodetect only */
198 } else if (!strcmp(size_calc, "current_size")) {
199 s->force_use_sz = true;
200 } else if (!strcmp(size_calc, "chs")) {
201 s->force_use_chs = true;
203 error_setg(errp, "Invalid size calculation mode: '%s'", size_calc);
207 static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
210 BDRVVPCState *s = bs->opaque;
213 VHDDynDiskHeader *dyndisk_header;
214 QemuOpts *opts = NULL;
215 Error *local_err = NULL;
217 uint8_t buf[HEADER_SIZE];
219 uint64_t computed_size;
220 uint64_t pagetable_size;
221 int disk_type = VHD_DYNAMIC;
224 opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
225 qemu_opts_absorb_qdict(opts, options, &local_err);
227 error_propagate(errp, local_err);
232 vpc_parse_options(bs, opts, &local_err);
234 error_propagate(errp, local_err);
239 ret = bdrv_pread(bs->file->bs, 0, s->footer_buf, HEADER_SIZE);
241 error_setg(errp, "Unable to read VHD header");
245 footer = (VHDFooter *) s->footer_buf;
246 if (strncmp(footer->creator, "conectix", 8)) {
247 int64_t offset = bdrv_getlength(bs->file->bs);
250 error_setg(errp, "Invalid file size");
252 } else if (offset < HEADER_SIZE) {
254 error_setg(errp, "File too small for a VHD header");
258 /* If a fixed disk, the footer is found only at the end of the file */
259 ret = bdrv_pread(bs->file->bs, offset-HEADER_SIZE, s->footer_buf,
264 if (strncmp(footer->creator, "conectix", 8)) {
265 error_setg(errp, "invalid VPC image");
269 disk_type = VHD_FIXED;
272 checksum = be32_to_cpu(footer->checksum);
273 footer->checksum = 0;
274 if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum)
275 fprintf(stderr, "block-vpc: The header checksum of '%s' is "
276 "incorrect.\n", bs->filename);
278 /* Write 'checksum' back to footer, or else will leave it with zero. */
279 footer->checksum = cpu_to_be32(checksum);
281 /* The visible size of a image in Virtual PC depends on the geometry
282 rather than on the size stored in the footer (the size in the footer
283 is too large usually) */
284 bs->total_sectors = (int64_t)
285 be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
287 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
288 * VHD image sizes differently. VPC will rely on CHS geometry,
289 * while Hyper-V and disk2vhd use the size specified in the footer.
291 * We use a couple of approaches to try and determine the correct method:
292 * look at the Creator App field, and look for images that have CHS
293 * geometry that is the maximum value.
295 * If the CHS geometry is the maximum CHS geometry, then we assume that
296 * the size is the footer->current_size to avoid truncation. Otherwise,
297 * we follow the table based on footer->creator_app:
299 * Known creator apps:
300 * 'vpc ' : CHS Virtual PC (uses disk geometry)
301 * 'qemu' : CHS QEMU (uses disk geometry)
302 * 'qem2' : current_size QEMU (uses current_size)
303 * 'win ' : current_size Hyper-V
304 * 'd2v ' : current_size Disk2vhd
305 * 'tap\0' : current_size XenServer
306 * 'CTXS' : current_size XenConverter
308 * The user can override the table values via drive options, however
309 * even with an override we will still use current_size for images
310 * that have CHS geometry of the maximum size.
312 use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
313 !!strncmp(footer->creator_app, "qem2", 4) &&
314 !!strncmp(footer->creator_app, "d2v ", 4) &&
315 !!strncmp(footer->creator_app, "CTXS", 4) &&
316 !!memcmp(footer->creator_app, "tap", 4)) || s->force_use_chs;
318 if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
319 bs->total_sectors = be64_to_cpu(footer->current_size) /
323 /* Allow a maximum disk size of 2040 GiB */
324 if (bs->total_sectors > VHD_MAX_SECTORS) {
329 if (disk_type == VHD_DYNAMIC) {
330 ret = bdrv_pread(bs->file->bs, be64_to_cpu(footer->data_offset), buf,
333 error_setg(errp, "Error reading dynamic VHD header");
337 dyndisk_header = (VHDDynDiskHeader *) buf;
339 if (strncmp(dyndisk_header->magic, "cxsparse", 8)) {
340 error_setg(errp, "Invalid header magic");
345 s->block_size = be32_to_cpu(dyndisk_header->block_size);
346 if (!is_power_of_2(s->block_size) || s->block_size < BDRV_SECTOR_SIZE) {
347 error_setg(errp, "Invalid block size %" PRIu32, s->block_size);
351 s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511;
353 s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries);
355 if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) {
356 error_setg(errp, "Too many blocks");
361 computed_size = (uint64_t) s->max_table_entries * s->block_size;
362 if (computed_size < bs->total_sectors * 512) {
363 error_setg(errp, "Page table too small");
368 if (s->max_table_entries > SIZE_MAX / 4 ||
369 s->max_table_entries > (int) INT_MAX / 4) {
370 error_setg(errp, "Max Table Entries too large (%" PRId32 ")",
371 s->max_table_entries);
376 pagetable_size = (uint64_t) s->max_table_entries * 4;
378 s->pagetable = qemu_try_blockalign(bs->file->bs, pagetable_size);
379 if (s->pagetable == NULL) {
380 error_setg(errp, "Unable to allocate memory for page table");
385 s->bat_offset = be64_to_cpu(dyndisk_header->table_offset);
387 ret = bdrv_pread(bs->file->bs, s->bat_offset, s->pagetable,
390 error_setg(errp, "Error reading pagetable");
394 s->free_data_block_offset =
395 ROUND_UP(s->bat_offset + pagetable_size, 512);
397 for (i = 0; i < s->max_table_entries; i++) {
398 be32_to_cpus(&s->pagetable[i]);
399 if (s->pagetable[i] != 0xFFFFFFFF) {
400 int64_t next = (512 * (int64_t) s->pagetable[i]) +
401 s->bitmap_size + s->block_size;
403 if (next > s->free_data_block_offset) {
404 s->free_data_block_offset = next;
409 if (s->free_data_block_offset > bdrv_getlength(bs->file->bs)) {
410 error_setg(errp, "block-vpc: free_data_block_offset points after "
411 "the end of file. The image has been truncated.");
416 s->last_bitmap_offset = (int64_t) -1;
419 s->pageentry_u8 = g_malloc(512);
420 s->pageentry_u32 = s->pageentry_u8;
421 s->pageentry_u16 = s->pageentry_u8;
422 s->last_pagetable = -1;
426 qemu_co_mutex_init(&s->lock);
428 /* Disable migration when VHD images are used */
429 error_setg(&s->migration_blocker, "The vpc format used by node '%s' "
430 "does not support live migration",
431 bdrv_get_device_or_node_name(bs));
432 migrate_add_blocker(s->migration_blocker);
437 qemu_vfree(s->pagetable);
439 g_free(s->pageentry_u8);
444 static int vpc_reopen_prepare(BDRVReopenState *state,
445 BlockReopenQueue *queue, Error **errp)
451 * Returns the absolute byte offset of the given sector in the image file.
452 * If the sector is not allocated, -1 is returned instead.
454 * The parameter write must be 1 if the offset will be used for a write
455 * operation (the block bitmaps is updated then), 0 otherwise.
457 static inline int64_t get_sector_offset(BlockDriverState *bs,
458 int64_t sector_num, int write)
460 BDRVVPCState *s = bs->opaque;
461 uint64_t offset = sector_num * 512;
462 uint64_t bitmap_offset, block_offset;
463 uint32_t pagetable_index, pageentry_index;
465 pagetable_index = offset / s->block_size;
466 pageentry_index = (offset % s->block_size) / 512;
468 if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)
469 return -1; /* not allocated */
471 bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
472 block_offset = bitmap_offset + s->bitmap_size + (512 * pageentry_index);
474 /* We must ensure that we don't write to any sectors which are marked as
475 unused in the bitmap. We get away with setting all bits in the block
476 bitmap each time we write to a new block. This might cause Virtual PC to
477 miss sparse read optimization, but it's not a problem in terms of
479 if (write && (s->last_bitmap_offset != bitmap_offset)) {
480 uint8_t bitmap[s->bitmap_size];
482 s->last_bitmap_offset = bitmap_offset;
483 memset(bitmap, 0xff, s->bitmap_size);
484 bdrv_pwrite_sync(bs->file->bs, bitmap_offset, bitmap, s->bitmap_size);
491 * Writes the footer to the end of the image file. This is needed when the
492 * file grows as it overwrites the old footer
494 * Returns 0 on success and < 0 on error
496 static int rewrite_footer(BlockDriverState* bs)
499 BDRVVPCState *s = bs->opaque;
500 int64_t offset = s->free_data_block_offset;
502 ret = bdrv_pwrite_sync(bs->file->bs, offset, s->footer_buf, HEADER_SIZE);
510 * Allocates a new block. This involves writing a new footer and updating
511 * the Block Allocation Table to use the space at the old end of the image
512 * file (overwriting the old footer)
514 * Returns the sectors' offset in the image file on success and < 0 on error
516 static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
518 BDRVVPCState *s = bs->opaque;
520 uint32_t index, bat_value;
522 uint8_t bitmap[s->bitmap_size];
524 /* Check if sector_num is valid */
525 if ((sector_num < 0) || (sector_num > bs->total_sectors))
528 /* Write entry into in-memory BAT */
529 index = (sector_num * 512) / s->block_size;
530 if (s->pagetable[index] != 0xFFFFFFFF)
533 s->pagetable[index] = s->free_data_block_offset / 512;
535 /* Initialize the block's bitmap */
536 memset(bitmap, 0xff, s->bitmap_size);
537 ret = bdrv_pwrite_sync(bs->file->bs, s->free_data_block_offset, bitmap,
543 /* Write new footer (the old one will be overwritten) */
544 s->free_data_block_offset += s->block_size + s->bitmap_size;
545 ret = rewrite_footer(bs);
549 /* Write BAT entry to disk */
550 bat_offset = s->bat_offset + (4 * index);
551 bat_value = cpu_to_be32(s->pagetable[index]);
552 ret = bdrv_pwrite_sync(bs->file->bs, bat_offset, &bat_value, 4);
556 return get_sector_offset(bs, sector_num, 0);
559 s->free_data_block_offset -= (s->block_size + s->bitmap_size);
563 static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
565 BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
566 VHDFooter *footer = (VHDFooter *) s->footer_buf;
568 if (be32_to_cpu(footer->type) != VHD_FIXED) {
569 bdi->cluster_size = s->block_size;
572 bdi->unallocated_blocks_are_zero = true;
576 static int vpc_read(BlockDriverState *bs, int64_t sector_num,
577 uint8_t *buf, int nb_sectors)
579 BDRVVPCState *s = bs->opaque;
582 int64_t sectors, sectors_per_block;
583 VHDFooter *footer = (VHDFooter *) s->footer_buf;
585 if (be32_to_cpu(footer->type) == VHD_FIXED) {
586 return bdrv_read(bs->file->bs, sector_num, buf, nb_sectors);
588 while (nb_sectors > 0) {
589 offset = get_sector_offset(bs, sector_num, 0);
591 sectors_per_block = s->block_size >> BDRV_SECTOR_BITS;
592 sectors = sectors_per_block - (sector_num % sectors_per_block);
593 if (sectors > nb_sectors) {
594 sectors = nb_sectors;
598 memset(buf, 0, sectors * BDRV_SECTOR_SIZE);
600 ret = bdrv_pread(bs->file->bs, offset, buf,
601 sectors * BDRV_SECTOR_SIZE);
602 if (ret != sectors * BDRV_SECTOR_SIZE) {
607 nb_sectors -= sectors;
608 sector_num += sectors;
609 buf += sectors * BDRV_SECTOR_SIZE;
614 static coroutine_fn int vpc_co_read(BlockDriverState *bs, int64_t sector_num,
615 uint8_t *buf, int nb_sectors)
618 BDRVVPCState *s = bs->opaque;
619 qemu_co_mutex_lock(&s->lock);
620 ret = vpc_read(bs, sector_num, buf, nb_sectors);
621 qemu_co_mutex_unlock(&s->lock);
625 static int vpc_write(BlockDriverState *bs, int64_t sector_num,
626 const uint8_t *buf, int nb_sectors)
628 BDRVVPCState *s = bs->opaque;
630 int64_t sectors, sectors_per_block;
632 VHDFooter *footer = (VHDFooter *) s->footer_buf;
634 if (be32_to_cpu(footer->type) == VHD_FIXED) {
635 return bdrv_write(bs->file->bs, sector_num, buf, nb_sectors);
637 while (nb_sectors > 0) {
638 offset = get_sector_offset(bs, sector_num, 1);
640 sectors_per_block = s->block_size >> BDRV_SECTOR_BITS;
641 sectors = sectors_per_block - (sector_num % sectors_per_block);
642 if (sectors > nb_sectors) {
643 sectors = nb_sectors;
647 offset = alloc_block(bs, sector_num);
652 ret = bdrv_pwrite(bs->file->bs, offset, buf,
653 sectors * BDRV_SECTOR_SIZE);
654 if (ret != sectors * BDRV_SECTOR_SIZE) {
658 nb_sectors -= sectors;
659 sector_num += sectors;
660 buf += sectors * BDRV_SECTOR_SIZE;
666 static coroutine_fn int vpc_co_write(BlockDriverState *bs, int64_t sector_num,
667 const uint8_t *buf, int nb_sectors)
670 BDRVVPCState *s = bs->opaque;
671 qemu_co_mutex_lock(&s->lock);
672 ret = vpc_write(bs, sector_num, buf, nb_sectors);
673 qemu_co_mutex_unlock(&s->lock);
677 static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
678 int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
680 BDRVVPCState *s = bs->opaque;
681 VHDFooter *footer = (VHDFooter*) s->footer_buf;
682 int64_t start, offset;
686 if (be32_to_cpu(footer->type) == VHD_FIXED) {
688 *file = bs->file->bs;
689 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_DATA |
690 (sector_num << BDRV_SECTOR_BITS);
693 offset = get_sector_offset(bs, sector_num, 0);
695 allocated = (offset != -1);
699 /* All sectors in a block are contiguous (without using the bitmap) */
700 n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)
702 n = MIN(n, nb_sectors);
707 /* *pnum can't be greater than one block for allocated
708 * sectors since there is always a bitmap in between. */
710 *file = bs->file->bs;
711 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
713 if (nb_sectors == 0) {
716 offset = get_sector_offset(bs, sector_num, 0);
717 } while (offset == -1);
723 * Calculates the number of cylinders, heads and sectors per cylinder
724 * based on a given number of sectors. This is the algorithm described
725 * in the VHD specification.
727 * Note that the geometry doesn't always exactly match total_sectors but
730 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
731 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
732 * and instead allow up to 255 heads.
734 static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
735 uint8_t* heads, uint8_t* secs_per_cyl)
737 uint32_t cyls_times_heads;
739 total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY);
741 if (total_sectors >= 65535LL * 16 * 63) {
744 cyls_times_heads = total_sectors / *secs_per_cyl;
747 cyls_times_heads = total_sectors / *secs_per_cyl;
748 *heads = (cyls_times_heads + 1023) / 1024;
754 if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
757 cyls_times_heads = total_sectors / *secs_per_cyl;
760 if (cyls_times_heads >= (*heads * 1024)) {
763 cyls_times_heads = total_sectors / *secs_per_cyl;
767 *cyls = cyls_times_heads / *heads;
772 static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf,
773 int64_t total_sectors)
775 VHDDynDiskHeader *dyndisk_header =
776 (VHDDynDiskHeader *) buf;
777 size_t block_size, num_bat_entries;
782 /* Write the footer (twice: at the beginning and at the end) */
783 block_size = 0x200000;
784 num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512);
786 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE);
791 offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
792 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE);
797 /* Write the initial BAT */
800 memset(buf, 0xFF, 512);
801 for (i = 0; i < (num_bat_entries * 4 + 511) / 512; i++) {
802 ret = blk_pwrite(blk, offset, buf, 512);
809 /* Prepare the Dynamic Disk Header */
810 memset(buf, 0, 1024);
812 memcpy(dyndisk_header->magic, "cxsparse", 8);
815 * Note: The spec is actually wrong here for data_offset, it says
816 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
818 dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
819 dyndisk_header->table_offset = cpu_to_be64(3 * 512);
820 dyndisk_header->version = cpu_to_be32(0x00010000);
821 dyndisk_header->block_size = cpu_to_be32(block_size);
822 dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries);
824 dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024));
826 /* Write the header */
829 ret = blk_pwrite(blk, offset, buf, 1024);
838 static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
843 /* Add footer to total size */
844 total_size += HEADER_SIZE;
846 ret = blk_truncate(blk, total_size);
851 ret = blk_pwrite(blk, total_size - HEADER_SIZE, buf, HEADER_SIZE);
859 static int vpc_create(const char *filename, QemuOpts *opts, Error **errp)
862 VHDFooter *footer = (VHDFooter *) buf;
863 char *disk_type_param;
867 uint8_t secs_per_cyl = 0;
868 int64_t total_sectors;
873 Error *local_err = NULL;
874 BlockBackend *blk = NULL;
876 /* Read out options */
877 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
879 disk_type_param = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
880 if (disk_type_param) {
881 if (!strcmp(disk_type_param, "dynamic")) {
882 disk_type = VHD_DYNAMIC;
883 } else if (!strcmp(disk_type_param, "fixed")) {
884 disk_type = VHD_FIXED;
886 error_setg(errp, "Invalid disk type, %s", disk_type_param);
891 disk_type = VHD_DYNAMIC;
894 force_size = qemu_opt_get_bool_del(opts, VPC_OPT_FORCE_SIZE, false);
896 ret = bdrv_create_file(filename, opts, &local_err);
898 error_propagate(errp, local_err);
902 blk = blk_new_open(filename, NULL, NULL,
903 BDRV_O_RDWR | BDRV_O_PROTOCOL, &local_err);
905 error_propagate(errp, local_err);
910 blk_set_allow_write_beyond_eof(blk, true);
913 * Calculate matching total_size and geometry. Increase the number of
914 * sectors requested until we get enough (or fail). This ensures that
915 * qemu-img convert doesn't truncate images, but rather rounds up.
917 * If the image size can't be represented by a spec conformant CHS geometry,
918 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
919 * the image size from the VHD footer to calculate total_sectors.
922 /* This will force the use of total_size for sector count, below */
923 cyls = VHD_CHS_MAX_C;
924 heads = VHD_CHS_MAX_H;
925 secs_per_cyl = VHD_CHS_MAX_S;
927 total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
928 for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
929 calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
933 if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
934 total_sectors = total_size / BDRV_SECTOR_SIZE;
935 /* Allow a maximum disk size of 2040 GiB */
936 if (total_sectors > VHD_MAX_SECTORS) {
937 error_setg(errp, "Disk size is too large, max size is 2040 GiB");
942 total_sectors = (int64_t)cyls * heads * secs_per_cyl;
943 total_size = total_sectors * BDRV_SECTOR_SIZE;
946 /* Prepare the Hard Disk Footer */
947 memset(buf, 0, 1024);
949 memcpy(footer->creator, "conectix", 8);
951 memcpy(footer->creator_app, "qem2", 4);
953 memcpy(footer->creator_app, "qemu", 4);
955 memcpy(footer->creator_os, "Wi2k", 4);
957 footer->features = cpu_to_be32(0x02);
958 footer->version = cpu_to_be32(0x00010000);
959 if (disk_type == VHD_DYNAMIC) {
960 footer->data_offset = cpu_to_be64(HEADER_SIZE);
962 footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
964 footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
966 /* Version of Virtual PC 2007 */
967 footer->major = cpu_to_be16(0x0005);
968 footer->minor = cpu_to_be16(0x0003);
969 footer->orig_size = cpu_to_be64(total_size);
970 footer->current_size = cpu_to_be64(total_size);
971 footer->cyls = cpu_to_be16(cyls);
972 footer->heads = heads;
973 footer->secs_per_cyl = secs_per_cyl;
975 footer->type = cpu_to_be32(disk_type);
977 #if defined(CONFIG_UUID)
978 uuid_generate(footer->uuid);
981 footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE));
983 if (disk_type == VHD_DYNAMIC) {
984 ret = create_dynamic_disk(blk, buf, total_sectors);
986 ret = create_fixed_disk(blk, buf, total_size);
989 error_setg(errp, "Unable to create or write VHD header");
994 g_free(disk_type_param);
998 static int vpc_has_zero_init(BlockDriverState *bs)
1000 BDRVVPCState *s = bs->opaque;
1001 VHDFooter *footer = (VHDFooter *) s->footer_buf;
1003 if (be32_to_cpu(footer->type) == VHD_FIXED) {
1004 return bdrv_has_zero_init(bs->file->bs);
1010 static void vpc_close(BlockDriverState *bs)
1012 BDRVVPCState *s = bs->opaque;
1013 qemu_vfree(s->pagetable);
1015 g_free(s->pageentry_u8);
1018 migrate_del_blocker(s->migration_blocker);
1019 error_free(s->migration_blocker);
1022 static QemuOptsList vpc_create_opts = {
1023 .name = "vpc-create-opts",
1024 .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head),
1027 .name = BLOCK_OPT_SIZE,
1028 .type = QEMU_OPT_SIZE,
1029 .help = "Virtual disk size"
1032 .name = BLOCK_OPT_SUBFMT,
1033 .type = QEMU_OPT_STRING,
1035 "Type of virtual hard disk format. Supported formats are "
1036 "{dynamic (default) | fixed} "
1039 .name = VPC_OPT_FORCE_SIZE,
1040 .type = QEMU_OPT_BOOL,
1041 .help = "Force disk size calculation to use the actual size "
1042 "specified, rather than using the nearest CHS-based "
1045 { /* end of list */ }
1049 static BlockDriver bdrv_vpc = {
1050 .format_name = "vpc",
1051 .instance_size = sizeof(BDRVVPCState),
1053 .bdrv_probe = vpc_probe,
1054 .bdrv_open = vpc_open,
1055 .bdrv_close = vpc_close,
1056 .bdrv_reopen_prepare = vpc_reopen_prepare,
1057 .bdrv_create = vpc_create,
1059 .bdrv_read = vpc_co_read,
1060 .bdrv_write = vpc_co_write,
1061 .bdrv_co_get_block_status = vpc_co_get_block_status,
1063 .bdrv_get_info = vpc_get_info,
1065 .create_opts = &vpc_create_opts,
1066 .bdrv_has_zero_init = vpc_has_zero_init,
1069 static void bdrv_vpc_init(void)
1071 bdrv_register(&bdrv_vpc);
1074 block_init(bdrv_vpc_init);