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
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"
40 /**************************************************************/
42 #define HEADER_SIZE 512
52 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
53 #define VHD_TIMESTAMP_BASE 946684800
55 #define VHD_CHS_MAX_C 65535LL
56 #define VHD_CHS_MAX_H 16
57 #define VHD_CHS_MAX_S 255
59 #define VHD_MAX_SECTORS 0xff000000 /* 2040 GiB max image size */
60 #define VHD_MAX_GEOMETRY (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S)
62 #define VPC_OPT_FORCE_SIZE "force_size"
64 /* always big-endian */
65 typedef struct vhd_footer
{
66 char creator
[8]; /* "conectix" */
70 /* Offset of next header structure, 0xFFFFFFFF if none */
73 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
76 char creator_app
[4]; /* e.g., "vpc " */
79 char creator_os
[4]; /* "Wi2k" */
82 uint64_t current_size
;
90 /* Checksum of the Hard Disk Footer ("one's complement of the sum of all
91 the bytes in the footer without the checksum field") */
94 /* UUID used to identify a parent hard disk (backing file) */
97 uint8_t in_saved_state
;
98 uint8_t reserved
[427];
99 } QEMU_PACKED VHDFooter
;
101 QEMU_BUILD_BUG_ON(sizeof(VHDFooter
) != 512);
103 typedef struct vhd_dyndisk_header
{
104 char magic
[8]; /* "cxsparse" */
106 /* Offset of next header structure, 0xFFFFFFFF if none */
107 uint64_t data_offset
;
109 /* Offset of the Block Allocation Table (BAT) */
110 uint64_t table_offset
;
113 uint32_t max_table_entries
; /* 32bit/entry */
115 /* 2 MB by default, must be a power of two */
119 uint8_t parent_uuid
[16];
120 uint32_t parent_timestamp
;
123 /* Backing file name (in UTF-16) */
124 uint8_t parent_name
[512];
129 uint32_t data_length
;
131 uint64_t data_offset
;
133 uint8_t reserved2
[256];
134 } QEMU_PACKED VHDDynDiskHeader
;
136 QEMU_BUILD_BUG_ON(sizeof(VHDDynDiskHeader
) != 1024);
138 typedef struct BDRVVPCState
{
141 uint64_t free_data_block_offset
;
142 int max_table_entries
;
145 uint64_t last_bitmap_offset
;
148 uint32_t bitmap_size
;
153 uint8_t *pageentry_u8
;
154 uint32_t *pageentry_u32
;
155 uint16_t *pageentry_u16
;
157 uint64_t last_bitmap
;
160 Error
*migration_blocker
;
163 #define VPC_OPT_SIZE_CALC "force_size_calc"
164 static QemuOptsList vpc_runtime_opts
= {
165 .name
= "vpc-runtime-opts",
166 .head
= QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts
.head
),
169 .name
= VPC_OPT_SIZE_CALC
,
170 .type
= QEMU_OPT_STRING
,
171 .help
= "Force disk size calculation to use either CHS geometry, "
172 "or use the disk current_size specified in the VHD footer. "
173 "{chs, current_size}"
175 { /* end of list */ }
179 static QemuOptsList vpc_create_opts
;
181 static uint32_t vpc_checksum(void *p
, size_t size
)
187 for (i
= 0; i
< size
; i
++)
194 static int vpc_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
196 if (buf_size
>= 8 && !strncmp((char *)buf
, "conectix", 8))
201 static void vpc_parse_options(BlockDriverState
*bs
, QemuOpts
*opts
,
204 BDRVVPCState
*s
= bs
->opaque
;
205 const char *size_calc
;
207 size_calc
= qemu_opt_get(opts
, VPC_OPT_SIZE_CALC
);
210 /* no override, use autodetect only */
211 } else if (!strcmp(size_calc
, "current_size")) {
212 s
->force_use_sz
= true;
213 } else if (!strcmp(size_calc
, "chs")) {
214 s
->force_use_chs
= true;
216 error_setg(errp
, "Invalid size calculation mode: '%s'", size_calc
);
220 static int vpc_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
223 BDRVVPCState
*s
= bs
->opaque
;
226 QemuOpts
*opts
= NULL
;
227 Error
*local_err
= NULL
;
229 VHDDynDiskHeader dyndisk_header
;
231 uint64_t computed_size
;
232 uint64_t pagetable_size
;
233 int disk_type
= VHD_DYNAMIC
;
237 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_of_bds
,
238 BDRV_CHILD_IMAGE
, false, errp
);
243 opts
= qemu_opts_create(&vpc_runtime_opts
, NULL
, 0, &error_abort
);
244 if (!qemu_opts_absorb_qdict(opts
, options
, errp
)) {
249 vpc_parse_options(bs
, opts
, &local_err
);
251 error_propagate(errp
, local_err
);
256 ret
= bdrv_pread(bs
->file
, 0, &s
->footer
, HEADER_SIZE
);
258 error_setg(errp
, "Unable to read VHD header");
263 if (strncmp(footer
->creator
, "conectix", 8)) {
264 int64_t offset
= bdrv_getlength(bs
->file
->bs
);
267 error_setg(errp
, "Invalid file size");
269 } else if (offset
< HEADER_SIZE
) {
271 error_setg(errp
, "File too small for a VHD header");
275 /* If a fixed disk, the footer is found only at the end of the file */
276 ret
= bdrv_pread(bs
->file
, offset
- HEADER_SIZE
, footer
,
281 if (strncmp(footer
->creator
, "conectix", 8)) {
282 error_setg(errp
, "invalid VPC image");
286 disk_type
= VHD_FIXED
;
289 checksum
= be32_to_cpu(footer
->checksum
);
290 footer
->checksum
= 0;
291 if (vpc_checksum(footer
, HEADER_SIZE
) != checksum
) {
292 error_setg(errp
, "Incorrect header checksum");
297 /* Write 'checksum' back to footer, or else will leave it with zero. */
298 footer
->checksum
= cpu_to_be32(checksum
);
300 /* The visible size of a image in Virtual PC depends on the geometry
301 rather than on the size stored in the footer (the size in the footer
302 is too large usually) */
303 bs
->total_sectors
= (int64_t)
304 be16_to_cpu(footer
->cyls
) * footer
->heads
* footer
->secs_per_cyl
;
306 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
307 * VHD image sizes differently. VPC will rely on CHS geometry,
308 * while Hyper-V and disk2vhd use the size specified in the footer.
310 * We use a couple of approaches to try and determine the correct method:
311 * look at the Creator App field, and look for images that have CHS
312 * geometry that is the maximum value.
314 * If the CHS geometry is the maximum CHS geometry, then we assume that
315 * the size is the footer->current_size to avoid truncation. Otherwise,
316 * we follow the table based on footer->creator_app:
318 * Known creator apps:
319 * 'vpc ' : CHS Virtual PC (uses disk geometry)
320 * 'qemu' : CHS QEMU (uses disk geometry)
321 * 'qem2' : current_size QEMU (uses current_size)
322 * 'win ' : current_size Hyper-V
323 * 'd2v ' : current_size Disk2vhd
324 * 'tap\0' : current_size XenServer
325 * 'CTXS' : current_size XenConverter
327 * The user can override the table values via drive options, however
328 * even with an override we will still use current_size for images
329 * that have CHS geometry of the maximum size.
331 use_chs
= (!!strncmp(footer
->creator_app
, "win ", 4) &&
332 !!strncmp(footer
->creator_app
, "qem2", 4) &&
333 !!strncmp(footer
->creator_app
, "d2v ", 4) &&
334 !!strncmp(footer
->creator_app
, "CTXS", 4) &&
335 !!memcmp(footer
->creator_app
, "tap", 4)) || s
->force_use_chs
;
337 if (!use_chs
|| bs
->total_sectors
== VHD_MAX_GEOMETRY
|| s
->force_use_sz
) {
338 bs
->total_sectors
= be64_to_cpu(footer
->current_size
) /
342 /* Allow a maximum disk size of 2040 GiB */
343 if (bs
->total_sectors
> VHD_MAX_SECTORS
) {
348 if (disk_type
== VHD_DYNAMIC
) {
349 ret
= bdrv_pread(bs
->file
, be64_to_cpu(footer
->data_offset
),
350 &dyndisk_header
, sizeof(dyndisk_header
));
352 error_setg(errp
, "Error reading dynamic VHD header");
356 if (strncmp(dyndisk_header
.magic
, "cxsparse", 8)) {
357 error_setg(errp
, "Invalid header magic");
362 s
->block_size
= be32_to_cpu(dyndisk_header
.block_size
);
363 if (!is_power_of_2(s
->block_size
) || s
->block_size
< BDRV_SECTOR_SIZE
) {
364 error_setg(errp
, "Invalid block size %" PRIu32
, s
->block_size
);
368 s
->bitmap_size
= ((s
->block_size
/ (8 * 512)) + 511) & ~511;
370 s
->max_table_entries
= be32_to_cpu(dyndisk_header
.max_table_entries
);
372 if ((bs
->total_sectors
* 512) / s
->block_size
> 0xffffffffU
) {
373 error_setg(errp
, "Too many blocks");
378 computed_size
= (uint64_t) s
->max_table_entries
* s
->block_size
;
379 if (computed_size
< bs
->total_sectors
* 512) {
380 error_setg(errp
, "Page table too small");
385 if (s
->max_table_entries
> SIZE_MAX
/ 4 ||
386 s
->max_table_entries
> (int) INT_MAX
/ 4) {
387 error_setg(errp
, "Max Table Entries too large (%" PRId32
")",
388 s
->max_table_entries
);
393 pagetable_size
= (uint64_t) s
->max_table_entries
* 4;
395 s
->pagetable
= qemu_try_blockalign(bs
->file
->bs
, pagetable_size
);
396 if (s
->pagetable
== NULL
) {
397 error_setg(errp
, "Unable to allocate memory for page table");
402 s
->bat_offset
= be64_to_cpu(dyndisk_header
.table_offset
);
404 ret
= bdrv_pread(bs
->file
, s
->bat_offset
, s
->pagetable
,
407 error_setg(errp
, "Error reading pagetable");
411 s
->free_data_block_offset
=
412 ROUND_UP(s
->bat_offset
+ pagetable_size
, 512);
414 for (i
= 0; i
< s
->max_table_entries
; i
++) {
415 be32_to_cpus(&s
->pagetable
[i
]);
416 if (s
->pagetable
[i
] != 0xFFFFFFFF) {
417 int64_t next
= (512 * (int64_t) s
->pagetable
[i
]) +
418 s
->bitmap_size
+ s
->block_size
;
420 if (next
> s
->free_data_block_offset
) {
421 s
->free_data_block_offset
= next
;
426 bs_size
= bdrv_getlength(bs
->file
->bs
);
428 error_setg_errno(errp
, -bs_size
, "Unable to learn image size");
432 if (s
->free_data_block_offset
> bs_size
) {
433 error_setg(errp
, "block-vpc: free_data_block_offset points after "
434 "the end of file. The image has been truncated.");
439 s
->last_bitmap_offset
= (int64_t) -1;
442 s
->pageentry_u8
= g_malloc(512);
443 s
->pageentry_u32
= s
->pageentry_u8
;
444 s
->pageentry_u16
= s
->pageentry_u8
;
445 s
->last_pagetable
= -1;
449 /* Disable migration when VHD images are used */
450 error_setg(&s
->migration_blocker
, "The vpc format used by node '%s' "
451 "does not support live migration",
452 bdrv_get_device_or_node_name(bs
));
453 ret
= migrate_add_blocker(s
->migration_blocker
, errp
);
455 error_free(s
->migration_blocker
);
459 qemu_co_mutex_init(&s
->lock
);
466 qemu_vfree(s
->pagetable
);
468 g_free(s
->pageentry_u8
);
473 static int vpc_reopen_prepare(BDRVReopenState
*state
,
474 BlockReopenQueue
*queue
, Error
**errp
)
480 * Returns the absolute byte offset of the given sector in the image file.
481 * If the sector is not allocated, -1 is returned instead.
482 * If an error occurred trying to write an updated block bitmap back to
483 * the file, -2 is returned, and the error value is written to *err.
484 * This can only happen for a write operation.
486 * The parameter write must be 1 if the offset will be used for a write
487 * operation (the block bitmaps is updated then), 0 otherwise.
488 * If write is true then err must not be NULL.
490 static inline int64_t get_image_offset(BlockDriverState
*bs
, uint64_t offset
,
491 bool write
, int *err
)
493 BDRVVPCState
*s
= bs
->opaque
;
494 uint64_t bitmap_offset
, block_offset
;
495 uint32_t pagetable_index
, offset_in_block
;
497 assert(!(write
&& err
== NULL
));
499 pagetable_index
= offset
/ s
->block_size
;
500 offset_in_block
= offset
% s
->block_size
;
502 if (pagetable_index
>= s
->max_table_entries
|| s
->pagetable
[pagetable_index
] == 0xffffffff)
503 return -1; /* not allocated */
505 bitmap_offset
= 512 * (uint64_t) s
->pagetable
[pagetable_index
];
506 block_offset
= bitmap_offset
+ s
->bitmap_size
+ offset_in_block
;
508 /* We must ensure that we don't write to any sectors which are marked as
509 unused in the bitmap. We get away with setting all bits in the block
510 bitmap each time we write to a new block. This might cause Virtual PC to
511 miss sparse read optimization, but it's not a problem in terms of
513 if (write
&& (s
->last_bitmap_offset
!= bitmap_offset
)) {
514 uint8_t bitmap
[s
->bitmap_size
];
517 s
->last_bitmap_offset
= bitmap_offset
;
518 memset(bitmap
, 0xff, s
->bitmap_size
);
519 r
= bdrv_pwrite_sync(bs
->file
, bitmap_offset
, bitmap
, s
->bitmap_size
);
530 * Writes the footer to the end of the image file. This is needed when the
531 * file grows as it overwrites the old footer
533 * Returns 0 on success and < 0 on error
535 static int rewrite_footer(BlockDriverState
*bs
)
538 BDRVVPCState
*s
= bs
->opaque
;
539 int64_t offset
= s
->free_data_block_offset
;
541 ret
= bdrv_pwrite_sync(bs
->file
, offset
, &s
->footer
, HEADER_SIZE
);
549 * Allocates a new block. This involves writing a new footer and updating
550 * the Block Allocation Table to use the space at the old end of the image
551 * file (overwriting the old footer)
553 * Returns the sectors' offset in the image file on success and < 0 on error
555 static int64_t alloc_block(BlockDriverState
*bs
, int64_t offset
)
557 BDRVVPCState
*s
= bs
->opaque
;
559 uint32_t index
, bat_value
;
561 uint8_t bitmap
[s
->bitmap_size
];
563 /* Check if sector_num is valid */
564 if ((offset
< 0) || (offset
> bs
->total_sectors
* BDRV_SECTOR_SIZE
)) {
568 /* Write entry into in-memory BAT */
569 index
= offset
/ s
->block_size
;
570 assert(s
->pagetable
[index
] == 0xFFFFFFFF);
571 s
->pagetable
[index
] = s
->free_data_block_offset
/ 512;
573 /* Initialize the block's bitmap */
574 memset(bitmap
, 0xff, s
->bitmap_size
);
575 ret
= bdrv_pwrite_sync(bs
->file
, s
->free_data_block_offset
, bitmap
,
581 /* Write new footer (the old one will be overwritten) */
582 s
->free_data_block_offset
+= s
->block_size
+ s
->bitmap_size
;
583 ret
= rewrite_footer(bs
);
587 /* Write BAT entry to disk */
588 bat_offset
= s
->bat_offset
+ (4 * index
);
589 bat_value
= cpu_to_be32(s
->pagetable
[index
]);
590 ret
= bdrv_pwrite_sync(bs
->file
, bat_offset
, &bat_value
, 4);
594 return get_image_offset(bs
, offset
, false, NULL
);
597 s
->free_data_block_offset
-= (s
->block_size
+ s
->bitmap_size
);
601 static int vpc_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
603 BDRVVPCState
*s
= (BDRVVPCState
*)bs
->opaque
;
605 if (be32_to_cpu(s
->footer
.type
) != VHD_FIXED
) {
606 bdi
->cluster_size
= s
->block_size
;
612 static int coroutine_fn
613 vpc_co_preadv(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
614 QEMUIOVector
*qiov
, int flags
)
616 BDRVVPCState
*s
= bs
->opaque
;
618 int64_t image_offset
;
620 int64_t bytes_done
= 0;
621 QEMUIOVector local_qiov
;
623 if (be32_to_cpu(s
->footer
.type
) == VHD_FIXED
) {
624 return bdrv_co_preadv(bs
->file
, offset
, bytes
, qiov
, 0);
627 qemu_co_mutex_lock(&s
->lock
);
628 qemu_iovec_init(&local_qiov
, qiov
->niov
);
631 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
632 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
634 if (image_offset
== -1) {
635 qemu_iovec_memset(qiov
, bytes_done
, 0, n_bytes
);
637 qemu_iovec_reset(&local_qiov
);
638 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
640 qemu_co_mutex_unlock(&s
->lock
);
641 ret
= bdrv_co_preadv(bs
->file
, image_offset
, n_bytes
,
643 qemu_co_mutex_lock(&s
->lock
);
651 bytes_done
+= n_bytes
;
656 qemu_iovec_destroy(&local_qiov
);
657 qemu_co_mutex_unlock(&s
->lock
);
662 static int coroutine_fn
663 vpc_co_pwritev(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
664 QEMUIOVector
*qiov
, int flags
)
666 BDRVVPCState
*s
= bs
->opaque
;
667 int64_t image_offset
;
669 int64_t bytes_done
= 0;
671 QEMUIOVector local_qiov
;
673 if (be32_to_cpu(s
->footer
.type
) == VHD_FIXED
) {
674 return bdrv_co_pwritev(bs
->file
, offset
, bytes
, qiov
, 0);
677 qemu_co_mutex_lock(&s
->lock
);
678 qemu_iovec_init(&local_qiov
, qiov
->niov
);
681 image_offset
= get_image_offset(bs
, offset
, true, &ret
);
682 if (image_offset
== -2) {
683 /* Failed to write block bitmap: can't proceed with write */
686 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
688 if (image_offset
== -1) {
689 image_offset
= alloc_block(bs
, offset
);
690 if (image_offset
< 0) {
696 qemu_iovec_reset(&local_qiov
);
697 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
699 qemu_co_mutex_unlock(&s
->lock
);
700 ret
= bdrv_co_pwritev(bs
->file
, image_offset
, n_bytes
,
702 qemu_co_mutex_lock(&s
->lock
);
709 bytes_done
+= n_bytes
;
714 qemu_iovec_destroy(&local_qiov
);
715 qemu_co_mutex_unlock(&s
->lock
);
720 static int coroutine_fn
vpc_co_block_status(BlockDriverState
*bs
,
722 int64_t offset
, int64_t bytes
,
723 int64_t *pnum
, int64_t *map
,
724 BlockDriverState
**file
)
726 BDRVVPCState
*s
= bs
->opaque
;
727 int64_t image_offset
;
732 if (be32_to_cpu(s
->footer
.type
) == VHD_FIXED
) {
735 *file
= bs
->file
->bs
;
736 return BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
| BDRV_BLOCK_RECURSE
;
739 qemu_co_mutex_lock(&s
->lock
);
741 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
742 allocated
= (image_offset
!= -1);
744 ret
= BDRV_BLOCK_ZERO
;
747 /* All sectors in a block are contiguous (without using the bitmap) */
748 n
= ROUND_UP(offset
+ 1, s
->block_size
) - offset
;
754 /* *pnum can't be greater than one block for allocated
755 * sectors since there is always a bitmap in between. */
757 *file
= bs
->file
->bs
;
759 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
765 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
766 } while (image_offset
== -1);
768 qemu_co_mutex_unlock(&s
->lock
);
773 * Calculates the number of cylinders, heads and sectors per cylinder
774 * based on a given number of sectors. This is the algorithm described
775 * in the VHD specification.
777 * Note that the geometry doesn't always exactly match total_sectors but
780 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
781 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
782 * and instead allow up to 255 heads.
784 static int calculate_geometry(int64_t total_sectors
, uint16_t *cyls
,
785 uint8_t *heads
, uint8_t *secs_per_cyl
)
787 uint32_t cyls_times_heads
;
789 total_sectors
= MIN(total_sectors
, VHD_MAX_GEOMETRY
);
791 if (total_sectors
>= 65535LL * 16 * 63) {
794 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
797 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
798 *heads
= DIV_ROUND_UP(cyls_times_heads
, 1024);
804 if (cyls_times_heads
>= (*heads
* 1024) || *heads
> 16) {
807 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
810 if (cyls_times_heads
>= (*heads
* 1024)) {
813 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
817 *cyls
= cyls_times_heads
/ *heads
;
822 static int create_dynamic_disk(BlockBackend
*blk
, uint8_t *buf
,
823 int64_t total_sectors
)
825 VHDDynDiskHeader dyndisk_header
;
826 uint8_t bat_sector
[512];
827 size_t block_size
, num_bat_entries
;
832 /* Write the footer (twice: at the beginning and at the end) */
833 block_size
= 0x200000;
834 num_bat_entries
= DIV_ROUND_UP(total_sectors
, block_size
/ 512);
836 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
841 offset
= 1536 + ((num_bat_entries
* 4 + 511) & ~511);
842 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
847 /* Write the initial BAT */
850 memset(bat_sector
, 0xFF, 512);
851 for (i
= 0; i
< DIV_ROUND_UP(num_bat_entries
* 4, 512); i
++) {
852 ret
= blk_pwrite(blk
, offset
, bat_sector
, 512, 0);
859 /* Prepare the Dynamic Disk Header */
860 memset(&dyndisk_header
, 0, sizeof(dyndisk_header
));
862 memcpy(dyndisk_header
.magic
, "cxsparse", 8);
865 * Note: The spec is actually wrong here for data_offset, it says
866 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
868 dyndisk_header
.data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
869 dyndisk_header
.table_offset
= cpu_to_be64(3 * 512);
870 dyndisk_header
.version
= cpu_to_be32(0x00010000);
871 dyndisk_header
.block_size
= cpu_to_be32(block_size
);
872 dyndisk_header
.max_table_entries
= cpu_to_be32(num_bat_entries
);
874 dyndisk_header
.checksum
= cpu_to_be32(
875 vpc_checksum(&dyndisk_header
, sizeof(dyndisk_header
)));
877 /* Write the header */
880 ret
= blk_pwrite(blk
, offset
, &dyndisk_header
, sizeof(dyndisk_header
), 0);
890 static int create_fixed_disk(BlockBackend
*blk
, uint8_t *buf
,
891 int64_t total_size
, Error
**errp
)
895 /* Add footer to total size */
896 total_size
+= HEADER_SIZE
;
898 ret
= blk_truncate(blk
, total_size
, false, PREALLOC_MODE_OFF
, 0, errp
);
903 ret
= blk_pwrite(blk
, total_size
- HEADER_SIZE
, buf
, HEADER_SIZE
, 0);
905 error_setg_errno(errp
, -ret
, "Unable to write VHD header");
912 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc
*vpc_opts
,
915 uint8_t *out_secs_per_cyl
,
916 int64_t *out_total_sectors
,
919 int64_t total_size
= vpc_opts
->size
;
922 uint8_t secs_per_cyl
= 0;
923 int64_t total_sectors
;
927 * Calculate matching total_size and geometry. Increase the number of
928 * sectors requested until we get enough (or fail). This ensures that
929 * qemu-img convert doesn't truncate images, but rather rounds up.
931 * If the image size can't be represented by a spec conformant CHS geometry,
932 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
933 * the image size from the VHD footer to calculate total_sectors.
935 if (vpc_opts
->force_size
) {
936 /* This will force the use of total_size for sector count, below */
937 cyls
= VHD_CHS_MAX_C
;
938 heads
= VHD_CHS_MAX_H
;
939 secs_per_cyl
= VHD_CHS_MAX_S
;
941 total_sectors
= MIN(VHD_MAX_GEOMETRY
, total_size
/ BDRV_SECTOR_SIZE
);
942 for (i
= 0; total_sectors
> (int64_t)cyls
* heads
* secs_per_cyl
; i
++) {
943 calculate_geometry(total_sectors
+ i
, &cyls
, &heads
, &secs_per_cyl
);
947 if ((int64_t)cyls
* heads
* secs_per_cyl
== VHD_MAX_GEOMETRY
) {
948 total_sectors
= total_size
/ BDRV_SECTOR_SIZE
;
949 /* Allow a maximum disk size of 2040 GiB */
950 if (total_sectors
> VHD_MAX_SECTORS
) {
951 error_setg(errp
, "Disk size is too large, max size is 2040 GiB");
955 total_sectors
= (int64_t) cyls
* heads
* secs_per_cyl
;
958 *out_total_sectors
= total_sectors
;
962 *out_secs_per_cyl
= secs_per_cyl
;
968 static int coroutine_fn
vpc_co_create(BlockdevCreateOptions
*opts
,
971 BlockdevCreateOptionsVpc
*vpc_opts
;
972 BlockBackend
*blk
= NULL
;
973 BlockDriverState
*bs
= NULL
;
978 uint8_t secs_per_cyl
= 0;
979 int64_t total_sectors
;
985 assert(opts
->driver
== BLOCKDEV_DRIVER_VPC
);
986 vpc_opts
= &opts
->u
.vpc
;
988 /* Validate options and set default values */
989 total_size
= vpc_opts
->size
;
991 if (!vpc_opts
->has_subformat
) {
992 vpc_opts
->subformat
= BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
;
994 switch (vpc_opts
->subformat
) {
995 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
:
996 disk_type
= VHD_DYNAMIC
;
998 case BLOCKDEV_VPC_SUBFORMAT_FIXED
:
999 disk_type
= VHD_FIXED
;
1002 g_assert_not_reached();
1005 /* Create BlockBackend to write to the image */
1006 bs
= bdrv_open_blockdev_ref(vpc_opts
->file
, errp
);
1011 blk
= blk_new_with_bs(bs
, BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
,
1017 blk_set_allow_write_beyond_eof(blk
, true);
1019 /* Get geometry and check that it matches the image size*/
1020 ret
= calculate_rounded_image_size(vpc_opts
, &cyls
, &heads
, &secs_per_cyl
,
1021 &total_sectors
, errp
);
1026 if (total_size
!= total_sectors
* BDRV_SECTOR_SIZE
) {
1027 error_setg(errp
, "The requested image size cannot be represented in "
1029 error_append_hint(errp
, "Try size=%llu or force-size=on (the "
1030 "latter makes the image incompatible with "
1032 total_sectors
* BDRV_SECTOR_SIZE
);
1037 /* Prepare the Hard Disk Footer */
1038 memset(&footer
, 0, HEADER_SIZE
);
1040 memcpy(footer
.creator
, "conectix", 8);
1041 if (vpc_opts
->force_size
) {
1042 memcpy(footer
.creator_app
, "qem2", 4);
1044 memcpy(footer
.creator_app
, "qemu", 4);
1046 memcpy(footer
.creator_os
, "Wi2k", 4);
1048 footer
.features
= cpu_to_be32(0x02);
1049 footer
.version
= cpu_to_be32(0x00010000);
1050 if (disk_type
== VHD_DYNAMIC
) {
1051 footer
.data_offset
= cpu_to_be64(HEADER_SIZE
);
1053 footer
.data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
1055 footer
.timestamp
= cpu_to_be32(time(NULL
) - VHD_TIMESTAMP_BASE
);
1057 /* Version of Virtual PC 2007 */
1058 footer
.major
= cpu_to_be16(0x0005);
1059 footer
.minor
= cpu_to_be16(0x0003);
1060 footer
.orig_size
= cpu_to_be64(total_size
);
1061 footer
.current_size
= cpu_to_be64(total_size
);
1062 footer
.cyls
= cpu_to_be16(cyls
);
1063 footer
.heads
= heads
;
1064 footer
.secs_per_cyl
= secs_per_cyl
;
1066 footer
.type
= cpu_to_be32(disk_type
);
1068 qemu_uuid_generate(&uuid
);
1071 footer
.checksum
= cpu_to_be32(vpc_checksum(&footer
, HEADER_SIZE
));
1073 if (disk_type
== VHD_DYNAMIC
) {
1074 ret
= create_dynamic_disk(blk
, (uint8_t *)&footer
, total_sectors
);
1076 error_setg(errp
, "Unable to create or write VHD header");
1079 ret
= create_fixed_disk(blk
, (uint8_t *)&footer
, total_size
, errp
);
1088 static int coroutine_fn
vpc_co_create_opts(BlockDriver
*drv
,
1089 const char *filename
,
1093 BlockdevCreateOptions
*create_options
= NULL
;
1096 BlockDriverState
*bs
= NULL
;
1099 static const QDictRenames opt_renames
[] = {
1100 { VPC_OPT_FORCE_SIZE
, "force-size" },
1104 /* Parse options and convert legacy syntax */
1105 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &vpc_create_opts
, true);
1107 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
1112 /* Create and open the file (protocol layer) */
1113 ret
= bdrv_create_file(filename
, opts
, errp
);
1118 bs
= bdrv_open(filename
, NULL
, NULL
,
1119 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
1125 /* Now get the QAPI type BlockdevCreateOptions */
1126 qdict_put_str(qdict
, "driver", "vpc");
1127 qdict_put_str(qdict
, "file", bs
->node_name
);
1129 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
1135 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, errp
);
1137 if (!create_options
) {
1142 /* Silently round up size */
1143 assert(create_options
->driver
== BLOCKDEV_DRIVER_VPC
);
1144 create_options
->u
.vpc
.size
=
1145 ROUND_UP(create_options
->u
.vpc
.size
, BDRV_SECTOR_SIZE
);
1147 if (!create_options
->u
.vpc
.force_size
) {
1148 int64_t total_sectors
;
1149 ret
= calculate_rounded_image_size(&create_options
->u
.vpc
, NULL
, NULL
,
1150 NULL
, &total_sectors
, errp
);
1155 create_options
->u
.vpc
.size
= total_sectors
* BDRV_SECTOR_SIZE
;
1159 /* Create the vpc image (format layer) */
1160 ret
= vpc_co_create(create_options
, errp
);
1163 qobject_unref(qdict
);
1165 qapi_free_BlockdevCreateOptions(create_options
);
1170 static int vpc_has_zero_init(BlockDriverState
*bs
)
1172 BDRVVPCState
*s
= bs
->opaque
;
1174 if (be32_to_cpu(s
->footer
.type
) == VHD_FIXED
) {
1175 return bdrv_has_zero_init(bs
->file
->bs
);
1181 static void vpc_close(BlockDriverState
*bs
)
1183 BDRVVPCState
*s
= bs
->opaque
;
1184 qemu_vfree(s
->pagetable
);
1186 g_free(s
->pageentry_u8
);
1189 migrate_del_blocker(s
->migration_blocker
);
1190 error_free(s
->migration_blocker
);
1193 static QemuOptsList vpc_create_opts
= {
1194 .name
= "vpc-create-opts",
1195 .head
= QTAILQ_HEAD_INITIALIZER(vpc_create_opts
.head
),
1198 .name
= BLOCK_OPT_SIZE
,
1199 .type
= QEMU_OPT_SIZE
,
1200 .help
= "Virtual disk size"
1203 .name
= BLOCK_OPT_SUBFMT
,
1204 .type
= QEMU_OPT_STRING
,
1206 "Type of virtual hard disk format. Supported formats are "
1207 "{dynamic (default) | fixed} "
1210 .name
= VPC_OPT_FORCE_SIZE
,
1211 .type
= QEMU_OPT_BOOL
,
1212 .help
= "Force disk size calculation to use the actual size "
1213 "specified, rather than using the nearest CHS-based "
1216 { /* end of list */ }
1220 static const char *const vpc_strong_runtime_opts
[] = {
1226 static BlockDriver bdrv_vpc
= {
1227 .format_name
= "vpc",
1228 .instance_size
= sizeof(BDRVVPCState
),
1230 .bdrv_probe
= vpc_probe
,
1231 .bdrv_open
= vpc_open
,
1232 .bdrv_close
= vpc_close
,
1233 .bdrv_reopen_prepare
= vpc_reopen_prepare
,
1234 .bdrv_child_perm
= bdrv_default_perms
,
1235 .bdrv_co_create
= vpc_co_create
,
1236 .bdrv_co_create_opts
= vpc_co_create_opts
,
1238 .bdrv_co_preadv
= vpc_co_preadv
,
1239 .bdrv_co_pwritev
= vpc_co_pwritev
,
1240 .bdrv_co_block_status
= vpc_co_block_status
,
1242 .bdrv_get_info
= vpc_get_info
,
1245 .create_opts
= &vpc_create_opts
,
1246 .bdrv_has_zero_init
= vpc_has_zero_init
,
1247 .strong_runtime_opts
= vpc_strong_runtime_opts
,
1250 static void bdrv_vpc_init(void)
1252 bdrv_register(&bdrv_vpc
);
1255 block_init(bdrv_vpc_init
);