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 } QEMU_PACKED VHDFooter
;
100 typedef struct vhd_dyndisk_header
{
101 char magic
[8]; /* "cxsparse" */
103 /* Offset of next header structure, 0xFFFFFFFF if none */
104 uint64_t data_offset
;
106 /* Offset of the Block Allocation Table (BAT) */
107 uint64_t table_offset
;
110 uint32_t max_table_entries
; /* 32bit/entry */
112 /* 2 MB by default, must be a power of two */
116 uint8_t parent_uuid
[16];
117 uint32_t parent_timestamp
;
120 /* Backing file name (in UTF-16) */
121 uint8_t parent_name
[512];
126 uint32_t data_length
;
128 uint64_t data_offset
;
130 } QEMU_PACKED VHDDynDiskHeader
;
132 typedef struct BDRVVPCState
{
134 uint8_t footer_buf
[HEADER_SIZE
];
135 uint64_t free_data_block_offset
;
136 int max_table_entries
;
139 uint64_t last_bitmap_offset
;
142 uint32_t bitmap_size
;
147 uint8_t *pageentry_u8
;
148 uint32_t *pageentry_u32
;
149 uint16_t *pageentry_u16
;
151 uint64_t last_bitmap
;
154 Error
*migration_blocker
;
157 #define VPC_OPT_SIZE_CALC "force_size_calc"
158 static QemuOptsList vpc_runtime_opts
= {
159 .name
= "vpc-runtime-opts",
160 .head
= QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts
.head
),
163 .name
= VPC_OPT_SIZE_CALC
,
164 .type
= QEMU_OPT_STRING
,
165 .help
= "Force disk size calculation to use either CHS geometry, "
166 "or use the disk current_size specified in the VHD footer. "
167 "{chs, current_size}"
169 { /* end of list */ }
173 static QemuOptsList vpc_create_opts
;
175 static uint32_t vpc_checksum(uint8_t* buf
, size_t size
)
180 for (i
= 0; i
< size
; i
++)
187 static int vpc_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
189 if (buf_size
>= 8 && !strncmp((char *)buf
, "conectix", 8))
194 static void vpc_parse_options(BlockDriverState
*bs
, QemuOpts
*opts
,
197 BDRVVPCState
*s
= bs
->opaque
;
198 const char *size_calc
;
200 size_calc
= qemu_opt_get(opts
, VPC_OPT_SIZE_CALC
);
203 /* no override, use autodetect only */
204 } else if (!strcmp(size_calc
, "current_size")) {
205 s
->force_use_sz
= true;
206 } else if (!strcmp(size_calc
, "chs")) {
207 s
->force_use_chs
= true;
209 error_setg(errp
, "Invalid size calculation mode: '%s'", size_calc
);
213 static int vpc_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
216 BDRVVPCState
*s
= bs
->opaque
;
219 VHDDynDiskHeader
*dyndisk_header
;
220 QemuOpts
*opts
= NULL
;
221 Error
*local_err
= NULL
;
223 uint8_t buf
[HEADER_SIZE
];
225 uint64_t computed_size
;
226 uint64_t pagetable_size
;
227 int disk_type
= VHD_DYNAMIC
;
231 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
237 opts
= qemu_opts_create(&vpc_runtime_opts
, NULL
, 0, &error_abort
);
238 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
240 error_propagate(errp
, local_err
);
245 vpc_parse_options(bs
, opts
, &local_err
);
247 error_propagate(errp
, local_err
);
252 ret
= bdrv_pread(bs
->file
, 0, s
->footer_buf
, HEADER_SIZE
);
254 error_setg(errp
, "Unable to read VHD header");
258 footer
= (VHDFooter
*) s
->footer_buf
;
259 if (strncmp(footer
->creator
, "conectix", 8)) {
260 int64_t offset
= bdrv_getlength(bs
->file
->bs
);
263 error_setg(errp
, "Invalid file size");
265 } else if (offset
< HEADER_SIZE
) {
267 error_setg(errp
, "File too small for a VHD header");
271 /* If a fixed disk, the footer is found only at the end of the file */
272 ret
= bdrv_pread(bs
->file
, offset
-HEADER_SIZE
, s
->footer_buf
,
277 if (strncmp(footer
->creator
, "conectix", 8)) {
278 error_setg(errp
, "invalid VPC image");
282 disk_type
= VHD_FIXED
;
285 checksum
= be32_to_cpu(footer
->checksum
);
286 footer
->checksum
= 0;
287 if (vpc_checksum(s
->footer_buf
, HEADER_SIZE
) != checksum
) {
288 error_setg(errp
, "Incorrect header checksum");
293 /* Write 'checksum' back to footer, or else will leave it with zero. */
294 footer
->checksum
= cpu_to_be32(checksum
);
296 /* The visible size of a image in Virtual PC depends on the geometry
297 rather than on the size stored in the footer (the size in the footer
298 is too large usually) */
299 bs
->total_sectors
= (int64_t)
300 be16_to_cpu(footer
->cyls
) * footer
->heads
* footer
->secs_per_cyl
;
302 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
303 * VHD image sizes differently. VPC will rely on CHS geometry,
304 * while Hyper-V and disk2vhd use the size specified in the footer.
306 * We use a couple of approaches to try and determine the correct method:
307 * look at the Creator App field, and look for images that have CHS
308 * geometry that is the maximum value.
310 * If the CHS geometry is the maximum CHS geometry, then we assume that
311 * the size is the footer->current_size to avoid truncation. Otherwise,
312 * we follow the table based on footer->creator_app:
314 * Known creator apps:
315 * 'vpc ' : CHS Virtual PC (uses disk geometry)
316 * 'qemu' : CHS QEMU (uses disk geometry)
317 * 'qem2' : current_size QEMU (uses current_size)
318 * 'win ' : current_size Hyper-V
319 * 'd2v ' : current_size Disk2vhd
320 * 'tap\0' : current_size XenServer
321 * 'CTXS' : current_size XenConverter
323 * The user can override the table values via drive options, however
324 * even with an override we will still use current_size for images
325 * that have CHS geometry of the maximum size.
327 use_chs
= (!!strncmp(footer
->creator_app
, "win ", 4) &&
328 !!strncmp(footer
->creator_app
, "qem2", 4) &&
329 !!strncmp(footer
->creator_app
, "d2v ", 4) &&
330 !!strncmp(footer
->creator_app
, "CTXS", 4) &&
331 !!memcmp(footer
->creator_app
, "tap", 4)) || s
->force_use_chs
;
333 if (!use_chs
|| bs
->total_sectors
== VHD_MAX_GEOMETRY
|| s
->force_use_sz
) {
334 bs
->total_sectors
= be64_to_cpu(footer
->current_size
) /
338 /* Allow a maximum disk size of 2040 GiB */
339 if (bs
->total_sectors
> VHD_MAX_SECTORS
) {
344 if (disk_type
== VHD_DYNAMIC
) {
345 ret
= bdrv_pread(bs
->file
, be64_to_cpu(footer
->data_offset
), buf
,
348 error_setg(errp
, "Error reading dynamic VHD header");
352 dyndisk_header
= (VHDDynDiskHeader
*) buf
;
354 if (strncmp(dyndisk_header
->magic
, "cxsparse", 8)) {
355 error_setg(errp
, "Invalid header magic");
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
);
366 s
->bitmap_size
= ((s
->block_size
/ (8 * 512)) + 511) & ~511;
368 s
->max_table_entries
= be32_to_cpu(dyndisk_header
->max_table_entries
);
370 if ((bs
->total_sectors
* 512) / s
->block_size
> 0xffffffffU
) {
371 error_setg(errp
, "Too many blocks");
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");
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
);
391 pagetable_size
= (uint64_t) s
->max_table_entries
* 4;
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");
400 s
->bat_offset
= be64_to_cpu(dyndisk_header
->table_offset
);
402 ret
= bdrv_pread(bs
->file
, s
->bat_offset
, s
->pagetable
,
405 error_setg(errp
, "Error reading pagetable");
409 s
->free_data_block_offset
=
410 ROUND_UP(s
->bat_offset
+ pagetable_size
, 512);
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
;
418 if (next
> s
->free_data_block_offset
) {
419 s
->free_data_block_offset
= next
;
424 bs_size
= bdrv_getlength(bs
->file
->bs
);
426 error_setg_errno(errp
, -bs_size
, "Unable to learn image size");
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.");
437 s
->last_bitmap_offset
= (int64_t) -1;
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;
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
, &local_err
);
453 error_propagate(errp
, local_err
);
454 error_free(s
->migration_blocker
);
458 qemu_co_mutex_init(&s
->lock
);
465 qemu_vfree(s
->pagetable
);
467 g_free(s
->pageentry_u8
);
472 static int vpc_reopen_prepare(BDRVReopenState
*state
,
473 BlockReopenQueue
*queue
, Error
**errp
)
479 * Returns the absolute byte offset of the given sector in the image file.
480 * If the sector is not allocated, -1 is returned instead.
481 * If an error occurred trying to write an updated block bitmap back to
482 * the file, -2 is returned, and the error value is written to *err.
483 * This can only happen for a write operation.
485 * The parameter write must be 1 if the offset will be used for a write
486 * operation (the block bitmaps is updated then), 0 otherwise.
487 * If write is true then err must not be NULL.
489 static inline int64_t get_image_offset(BlockDriverState
*bs
, uint64_t offset
,
490 bool write
, int *err
)
492 BDRVVPCState
*s
= bs
->opaque
;
493 uint64_t bitmap_offset
, block_offset
;
494 uint32_t pagetable_index
, offset_in_block
;
496 assert(!(write
&& err
== NULL
));
498 pagetable_index
= offset
/ s
->block_size
;
499 offset_in_block
= offset
% s
->block_size
;
501 if (pagetable_index
>= s
->max_table_entries
|| s
->pagetable
[pagetable_index
] == 0xffffffff)
502 return -1; /* not allocated */
504 bitmap_offset
= 512 * (uint64_t) s
->pagetable
[pagetable_index
];
505 block_offset
= bitmap_offset
+ s
->bitmap_size
+ offset_in_block
;
507 /* We must ensure that we don't write to any sectors which are marked as
508 unused in the bitmap. We get away with setting all bits in the block
509 bitmap each time we write to a new block. This might cause Virtual PC to
510 miss sparse read optimization, but it's not a problem in terms of
512 if (write
&& (s
->last_bitmap_offset
!= bitmap_offset
)) {
513 uint8_t bitmap
[s
->bitmap_size
];
516 s
->last_bitmap_offset
= bitmap_offset
;
517 memset(bitmap
, 0xff, s
->bitmap_size
);
518 r
= bdrv_pwrite_sync(bs
->file
, bitmap_offset
, bitmap
, s
->bitmap_size
);
529 * Writes the footer to the end of the image file. This is needed when the
530 * file grows as it overwrites the old footer
532 * Returns 0 on success and < 0 on error
534 static int rewrite_footer(BlockDriverState
* bs
)
537 BDRVVPCState
*s
= bs
->opaque
;
538 int64_t offset
= s
->free_data_block_offset
;
540 ret
= bdrv_pwrite_sync(bs
->file
, offset
, s
->footer_buf
, HEADER_SIZE
);
548 * Allocates a new block. This involves writing a new footer and updating
549 * the Block Allocation Table to use the space at the old end of the image
550 * file (overwriting the old footer)
552 * Returns the sectors' offset in the image file on success and < 0 on error
554 static int64_t alloc_block(BlockDriverState
* bs
, int64_t offset
)
556 BDRVVPCState
*s
= bs
->opaque
;
558 uint32_t index
, bat_value
;
560 uint8_t bitmap
[s
->bitmap_size
];
562 /* Check if sector_num is valid */
563 if ((offset
< 0) || (offset
> bs
->total_sectors
* BDRV_SECTOR_SIZE
)) {
567 /* Write entry into in-memory BAT */
568 index
= offset
/ s
->block_size
;
569 assert(s
->pagetable
[index
] == 0xFFFFFFFF);
570 s
->pagetable
[index
] = s
->free_data_block_offset
/ 512;
572 /* Initialize the block's bitmap */
573 memset(bitmap
, 0xff, s
->bitmap_size
);
574 ret
= bdrv_pwrite_sync(bs
->file
, s
->free_data_block_offset
, bitmap
,
580 /* Write new footer (the old one will be overwritten) */
581 s
->free_data_block_offset
+= s
->block_size
+ s
->bitmap_size
;
582 ret
= rewrite_footer(bs
);
586 /* Write BAT entry to disk */
587 bat_offset
= s
->bat_offset
+ (4 * index
);
588 bat_value
= cpu_to_be32(s
->pagetable
[index
]);
589 ret
= bdrv_pwrite_sync(bs
->file
, bat_offset
, &bat_value
, 4);
593 return get_image_offset(bs
, offset
, false, NULL
);
596 s
->free_data_block_offset
-= (s
->block_size
+ s
->bitmap_size
);
600 static int vpc_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
602 BDRVVPCState
*s
= (BDRVVPCState
*)bs
->opaque
;
603 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
605 if (be32_to_cpu(footer
->type
) != VHD_FIXED
) {
606 bdi
->cluster_size
= s
->block_size
;
609 bdi
->unallocated_blocks_are_zero
= true;
613 static int coroutine_fn
614 vpc_co_preadv(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
615 QEMUIOVector
*qiov
, int flags
)
617 BDRVVPCState
*s
= bs
->opaque
;
619 int64_t image_offset
;
621 int64_t bytes_done
= 0;
622 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
623 QEMUIOVector local_qiov
;
625 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
626 return bdrv_co_preadv(bs
->file
, offset
, bytes
, qiov
, 0);
629 qemu_co_mutex_lock(&s
->lock
);
630 qemu_iovec_init(&local_qiov
, qiov
->niov
);
633 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
634 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
636 if (image_offset
== -1) {
637 qemu_iovec_memset(qiov
, bytes_done
, 0, n_bytes
);
639 qemu_iovec_reset(&local_qiov
);
640 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
642 ret
= bdrv_co_preadv(bs
->file
, image_offset
, n_bytes
,
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 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
672 QEMUIOVector local_qiov
;
674 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
675 return bdrv_co_pwritev(bs
->file
, offset
, bytes
, qiov
, 0);
678 qemu_co_mutex_lock(&s
->lock
);
679 qemu_iovec_init(&local_qiov
, qiov
->niov
);
682 image_offset
= get_image_offset(bs
, offset
, true, &ret
);
683 if (image_offset
== -2) {
684 /* Failed to write block bitmap: can't proceed with write */
687 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
689 if (image_offset
== -1) {
690 image_offset
= alloc_block(bs
, offset
);
691 if (image_offset
< 0) {
697 qemu_iovec_reset(&local_qiov
);
698 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
700 ret
= bdrv_co_pwritev(bs
->file
, image_offset
, n_bytes
,
708 bytes_done
+= n_bytes
;
713 qemu_iovec_destroy(&local_qiov
);
714 qemu_co_mutex_unlock(&s
->lock
);
719 static int coroutine_fn
vpc_co_block_status(BlockDriverState
*bs
,
721 int64_t offset
, int64_t bytes
,
722 int64_t *pnum
, int64_t *map
,
723 BlockDriverState
**file
)
725 BDRVVPCState
*s
= bs
->opaque
;
726 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
727 int64_t image_offset
;
732 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
735 *file
= bs
->file
->bs
;
736 return BDRV_BLOCK_RAW
| BDRV_BLOCK_OFFSET_VALID
;
739 qemu_co_mutex_lock(&s
->lock
);
741 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
742 allocated
= (image_offset
!= -1);
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 (VHDDynDiskHeader
*) buf
;
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
= (total_sectors
+ block_size
/ 512) / (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(buf
, 0xFF, 512);
851 for (i
= 0; i
< DIV_ROUND_UP(num_bat_entries
* 4, 512); i
++) {
852 ret
= blk_pwrite(blk
, offset
, buf
, 512, 0);
859 /* Prepare the Dynamic Disk Header */
860 memset(buf
, 0, 1024);
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(vpc_checksum(buf
, 1024));
876 /* Write the header */
879 ret
= blk_pwrite(blk
, offset
, buf
, 1024, 0);
888 static int create_fixed_disk(BlockBackend
*blk
, uint8_t *buf
,
889 int64_t total_size
, Error
**errp
)
893 /* Add footer to total size */
894 total_size
+= HEADER_SIZE
;
896 ret
= blk_truncate(blk
, total_size
, PREALLOC_MODE_OFF
, errp
);
901 ret
= blk_pwrite(blk
, total_size
- HEADER_SIZE
, buf
, HEADER_SIZE
, 0);
903 error_setg_errno(errp
, -ret
, "Unable to write VHD header");
910 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc
*vpc_opts
,
913 uint8_t *out_secs_per_cyl
,
914 int64_t *out_total_sectors
,
917 int64_t total_size
= vpc_opts
->size
;
920 uint8_t secs_per_cyl
= 0;
921 int64_t total_sectors
;
925 * Calculate matching total_size and geometry. Increase the number of
926 * sectors requested until we get enough (or fail). This ensures that
927 * qemu-img convert doesn't truncate images, but rather rounds up.
929 * If the image size can't be represented by a spec conformant CHS geometry,
930 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
931 * the image size from the VHD footer to calculate total_sectors.
933 if (vpc_opts
->force_size
) {
934 /* This will force the use of total_size for sector count, below */
935 cyls
= VHD_CHS_MAX_C
;
936 heads
= VHD_CHS_MAX_H
;
937 secs_per_cyl
= VHD_CHS_MAX_S
;
939 total_sectors
= MIN(VHD_MAX_GEOMETRY
, total_size
/ BDRV_SECTOR_SIZE
);
940 for (i
= 0; total_sectors
> (int64_t)cyls
* heads
* secs_per_cyl
; i
++) {
941 calculate_geometry(total_sectors
+ i
, &cyls
, &heads
, &secs_per_cyl
);
945 if ((int64_t)cyls
* heads
* secs_per_cyl
== VHD_MAX_GEOMETRY
) {
946 total_sectors
= total_size
/ BDRV_SECTOR_SIZE
;
947 /* Allow a maximum disk size of 2040 GiB */
948 if (total_sectors
> VHD_MAX_SECTORS
) {
949 error_setg(errp
, "Disk size is too large, max size is 2040 GiB");
953 total_sectors
= (int64_t) cyls
* heads
* secs_per_cyl
;
956 *out_total_sectors
= total_sectors
;
960 *out_secs_per_cyl
= secs_per_cyl
;
966 static int coroutine_fn
vpc_co_create(BlockdevCreateOptions
*opts
,
969 BlockdevCreateOptionsVpc
*vpc_opts
;
970 BlockBackend
*blk
= NULL
;
971 BlockDriverState
*bs
= NULL
;
974 VHDFooter
*footer
= (VHDFooter
*) buf
;
977 uint8_t secs_per_cyl
= 0;
978 int64_t total_sectors
;
984 assert(opts
->driver
== BLOCKDEV_DRIVER_VPC
);
985 vpc_opts
= &opts
->u
.vpc
;
987 /* Validate options and set default values */
988 total_size
= vpc_opts
->size
;
990 if (!vpc_opts
->has_subformat
) {
991 vpc_opts
->subformat
= BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
;
993 switch (vpc_opts
->subformat
) {
994 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
:
995 disk_type
= VHD_DYNAMIC
;
997 case BLOCKDEV_VPC_SUBFORMAT_FIXED
:
998 disk_type
= VHD_FIXED
;
1001 g_assert_not_reached();
1004 /* Create BlockBackend to write to the image */
1005 bs
= bdrv_open_blockdev_ref(vpc_opts
->file
, errp
);
1010 blk
= blk_new(BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
);
1011 ret
= blk_insert_bs(blk
, bs
, errp
);
1015 blk_set_allow_write_beyond_eof(blk
, true);
1017 /* Get geometry and check that it matches the image size*/
1018 ret
= calculate_rounded_image_size(vpc_opts
, &cyls
, &heads
, &secs_per_cyl
,
1019 &total_sectors
, errp
);
1024 if (total_size
!= total_sectors
* BDRV_SECTOR_SIZE
) {
1025 error_setg(errp
, "The requested image size cannot be represented in "
1027 error_append_hint(errp
, "Try size=%llu or force-size=on (the "
1028 "latter makes the image incompatible with "
1030 total_sectors
* BDRV_SECTOR_SIZE
);
1035 /* Prepare the Hard Disk Footer */
1036 memset(buf
, 0, 1024);
1038 memcpy(footer
->creator
, "conectix", 8);
1039 if (vpc_opts
->force_size
) {
1040 memcpy(footer
->creator_app
, "qem2", 4);
1042 memcpy(footer
->creator_app
, "qemu", 4);
1044 memcpy(footer
->creator_os
, "Wi2k", 4);
1046 footer
->features
= cpu_to_be32(0x02);
1047 footer
->version
= cpu_to_be32(0x00010000);
1048 if (disk_type
== VHD_DYNAMIC
) {
1049 footer
->data_offset
= cpu_to_be64(HEADER_SIZE
);
1051 footer
->data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
1053 footer
->timestamp
= cpu_to_be32(time(NULL
) - VHD_TIMESTAMP_BASE
);
1055 /* Version of Virtual PC 2007 */
1056 footer
->major
= cpu_to_be16(0x0005);
1057 footer
->minor
= cpu_to_be16(0x0003);
1058 footer
->orig_size
= cpu_to_be64(total_size
);
1059 footer
->current_size
= cpu_to_be64(total_size
);
1060 footer
->cyls
= cpu_to_be16(cyls
);
1061 footer
->heads
= heads
;
1062 footer
->secs_per_cyl
= secs_per_cyl
;
1064 footer
->type
= cpu_to_be32(disk_type
);
1066 qemu_uuid_generate(&uuid
);
1067 footer
->uuid
= uuid
;
1069 footer
->checksum
= cpu_to_be32(vpc_checksum(buf
, HEADER_SIZE
));
1071 if (disk_type
== VHD_DYNAMIC
) {
1072 ret
= create_dynamic_disk(blk
, buf
, total_sectors
);
1074 error_setg(errp
, "Unable to create or write VHD header");
1077 ret
= create_fixed_disk(blk
, buf
, total_size
, errp
);
1086 static int coroutine_fn
vpc_co_create_opts(const char *filename
,
1087 QemuOpts
*opts
, Error
**errp
)
1089 BlockdevCreateOptions
*create_options
= NULL
;
1092 BlockDriverState
*bs
= NULL
;
1093 Error
*local_err
= NULL
;
1096 static const QDictRenames opt_renames
[] = {
1097 { VPC_OPT_FORCE_SIZE
, "force-size" },
1101 /* Parse options and convert legacy syntax */
1102 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &vpc_create_opts
, true);
1104 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
1109 /* Create and open the file (protocol layer) */
1110 ret
= bdrv_create_file(filename
, opts
, &local_err
);
1112 error_propagate(errp
, local_err
);
1116 bs
= bdrv_open(filename
, NULL
, NULL
,
1117 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
1123 /* Now get the QAPI type BlockdevCreateOptions */
1124 qdict_put_str(qdict
, "driver", "vpc");
1125 qdict_put_str(qdict
, "file", bs
->node_name
);
1127 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
1133 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, &local_err
);
1137 error_propagate(errp
, local_err
);
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
;
1173 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
1175 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
1176 return bdrv_has_zero_init(bs
->file
->bs
);
1182 static void vpc_close(BlockDriverState
*bs
)
1184 BDRVVPCState
*s
= bs
->opaque
;
1185 qemu_vfree(s
->pagetable
);
1187 g_free(s
->pageentry_u8
);
1190 migrate_del_blocker(s
->migration_blocker
);
1191 error_free(s
->migration_blocker
);
1194 static QemuOptsList vpc_create_opts
= {
1195 .name
= "vpc-create-opts",
1196 .head
= QTAILQ_HEAD_INITIALIZER(vpc_create_opts
.head
),
1199 .name
= BLOCK_OPT_SIZE
,
1200 .type
= QEMU_OPT_SIZE
,
1201 .help
= "Virtual disk size"
1204 .name
= BLOCK_OPT_SUBFMT
,
1205 .type
= QEMU_OPT_STRING
,
1207 "Type of virtual hard disk format. Supported formats are "
1208 "{dynamic (default) | fixed} "
1211 .name
= VPC_OPT_FORCE_SIZE
,
1212 .type
= QEMU_OPT_BOOL
,
1213 .help
= "Force disk size calculation to use the actual size "
1214 "specified, rather than using the nearest CHS-based "
1217 { /* end of list */ }
1221 static const char *const vpc_strong_runtime_opts
[] = {
1227 static BlockDriver bdrv_vpc
= {
1228 .format_name
= "vpc",
1229 .instance_size
= sizeof(BDRVVPCState
),
1231 .bdrv_probe
= vpc_probe
,
1232 .bdrv_open
= vpc_open
,
1233 .bdrv_close
= vpc_close
,
1234 .bdrv_reopen_prepare
= vpc_reopen_prepare
,
1235 .bdrv_child_perm
= bdrv_format_default_perms
,
1236 .bdrv_co_create
= vpc_co_create
,
1237 .bdrv_co_create_opts
= vpc_co_create_opts
,
1239 .bdrv_co_preadv
= vpc_co_preadv
,
1240 .bdrv_co_pwritev
= vpc_co_pwritev
,
1241 .bdrv_co_block_status
= vpc_co_block_status
,
1243 .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
);