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
);
463 qemu_vfree(s
->pagetable
);
465 g_free(s
->pageentry_u8
);
470 static int vpc_reopen_prepare(BDRVReopenState
*state
,
471 BlockReopenQueue
*queue
, Error
**errp
)
477 * Returns the absolute byte offset of the given sector in the image file.
478 * If the sector is not allocated, -1 is returned instead.
479 * If an error occurred trying to write an updated block bitmap back to
480 * the file, -2 is returned, and the error value is written to *err.
481 * This can only happen for a write operation.
483 * The parameter write must be 1 if the offset will be used for a write
484 * operation (the block bitmaps is updated then), 0 otherwise.
485 * If write is true then err must not be NULL.
487 static inline int64_t get_image_offset(BlockDriverState
*bs
, uint64_t offset
,
488 bool write
, int *err
)
490 BDRVVPCState
*s
= bs
->opaque
;
491 uint64_t bitmap_offset
, block_offset
;
492 uint32_t pagetable_index
, offset_in_block
;
494 assert(!(write
&& err
== NULL
));
496 pagetable_index
= offset
/ s
->block_size
;
497 offset_in_block
= offset
% s
->block_size
;
499 if (pagetable_index
>= s
->max_table_entries
|| s
->pagetable
[pagetable_index
] == 0xffffffff)
500 return -1; /* not allocated */
502 bitmap_offset
= 512 * (uint64_t) s
->pagetable
[pagetable_index
];
503 block_offset
= bitmap_offset
+ s
->bitmap_size
+ offset_in_block
;
505 /* We must ensure that we don't write to any sectors which are marked as
506 unused in the bitmap. We get away with setting all bits in the block
507 bitmap each time we write to a new block. This might cause Virtual PC to
508 miss sparse read optimization, but it's not a problem in terms of
510 if (write
&& (s
->last_bitmap_offset
!= bitmap_offset
)) {
511 uint8_t bitmap
[s
->bitmap_size
];
514 s
->last_bitmap_offset
= bitmap_offset
;
515 memset(bitmap
, 0xff, s
->bitmap_size
);
516 r
= bdrv_pwrite_sync(bs
->file
, bitmap_offset
, bitmap
, s
->bitmap_size
);
527 * Writes the footer to the end of the image file. This is needed when the
528 * file grows as it overwrites the old footer
530 * Returns 0 on success and < 0 on error
532 static int rewrite_footer(BlockDriverState
* bs
)
535 BDRVVPCState
*s
= bs
->opaque
;
536 int64_t offset
= s
->free_data_block_offset
;
538 ret
= bdrv_pwrite_sync(bs
->file
, offset
, s
->footer_buf
, HEADER_SIZE
);
546 * Allocates a new block. This involves writing a new footer and updating
547 * the Block Allocation Table to use the space at the old end of the image
548 * file (overwriting the old footer)
550 * Returns the sectors' offset in the image file on success and < 0 on error
552 static int64_t alloc_block(BlockDriverState
* bs
, int64_t offset
)
554 BDRVVPCState
*s
= bs
->opaque
;
556 uint32_t index
, bat_value
;
558 uint8_t bitmap
[s
->bitmap_size
];
560 /* Check if sector_num is valid */
561 if ((offset
< 0) || (offset
> bs
->total_sectors
* BDRV_SECTOR_SIZE
)) {
565 /* Write entry into in-memory BAT */
566 index
= offset
/ s
->block_size
;
567 assert(s
->pagetable
[index
] == 0xFFFFFFFF);
568 s
->pagetable
[index
] = s
->free_data_block_offset
/ 512;
570 /* Initialize the block's bitmap */
571 memset(bitmap
, 0xff, s
->bitmap_size
);
572 ret
= bdrv_pwrite_sync(bs
->file
, s
->free_data_block_offset
, bitmap
,
578 /* Write new footer (the old one will be overwritten) */
579 s
->free_data_block_offset
+= s
->block_size
+ s
->bitmap_size
;
580 ret
= rewrite_footer(bs
);
584 /* Write BAT entry to disk */
585 bat_offset
= s
->bat_offset
+ (4 * index
);
586 bat_value
= cpu_to_be32(s
->pagetable
[index
]);
587 ret
= bdrv_pwrite_sync(bs
->file
, bat_offset
, &bat_value
, 4);
591 return get_image_offset(bs
, offset
, false, NULL
);
594 s
->free_data_block_offset
-= (s
->block_size
+ s
->bitmap_size
);
598 static int vpc_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
600 BDRVVPCState
*s
= (BDRVVPCState
*)bs
->opaque
;
601 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
603 if (be32_to_cpu(footer
->type
) != VHD_FIXED
) {
604 bdi
->cluster_size
= s
->block_size
;
607 bdi
->unallocated_blocks_are_zero
= true;
611 static int coroutine_fn
612 vpc_co_preadv(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
613 QEMUIOVector
*qiov
, int flags
)
615 BDRVVPCState
*s
= bs
->opaque
;
617 int64_t image_offset
;
619 int64_t bytes_done
= 0;
620 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
621 QEMUIOVector local_qiov
;
623 if (be32_to_cpu(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 ret
= bdrv_co_preadv(bs
->file
, image_offset
, n_bytes
,
649 bytes_done
+= n_bytes
;
654 qemu_iovec_destroy(&local_qiov
);
655 qemu_co_mutex_unlock(&s
->lock
);
660 static int coroutine_fn
661 vpc_co_pwritev(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
662 QEMUIOVector
*qiov
, int flags
)
664 BDRVVPCState
*s
= bs
->opaque
;
665 int64_t image_offset
;
667 int64_t bytes_done
= 0;
669 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
670 QEMUIOVector local_qiov
;
672 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
673 return bdrv_co_pwritev(bs
->file
, offset
, bytes
, qiov
, 0);
676 qemu_co_mutex_lock(&s
->lock
);
677 qemu_iovec_init(&local_qiov
, qiov
->niov
);
680 image_offset
= get_image_offset(bs
, offset
, true, &ret
);
681 if (image_offset
== -2) {
682 /* Failed to write block bitmap: can't proceed with write */
685 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
687 if (image_offset
== -1) {
688 image_offset
= alloc_block(bs
, offset
);
689 if (image_offset
< 0) {
695 qemu_iovec_reset(&local_qiov
);
696 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
698 ret
= bdrv_co_pwritev(bs
->file
, image_offset
, n_bytes
,
706 bytes_done
+= n_bytes
;
711 qemu_iovec_destroy(&local_qiov
);
712 qemu_co_mutex_unlock(&s
->lock
);
717 static int coroutine_fn
vpc_co_block_status(BlockDriverState
*bs
,
719 int64_t offset
, int64_t bytes
,
720 int64_t *pnum
, int64_t *map
,
721 BlockDriverState
**file
)
723 BDRVVPCState
*s
= bs
->opaque
;
724 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
725 int64_t image_offset
;
730 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
733 *file
= bs
->file
->bs
;
734 return BDRV_BLOCK_RAW
| BDRV_BLOCK_OFFSET_VALID
;
737 qemu_co_mutex_lock(&s
->lock
);
739 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
740 allocated
= (image_offset
!= -1);
745 /* All sectors in a block are contiguous (without using the bitmap) */
746 n
= ROUND_UP(offset
+ 1, s
->block_size
) - offset
;
752 /* *pnum can't be greater than one block for allocated
753 * sectors since there is always a bitmap in between. */
755 *file
= bs
->file
->bs
;
757 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
763 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
764 } while (image_offset
== -1);
766 qemu_co_mutex_unlock(&s
->lock
);
771 * Calculates the number of cylinders, heads and sectors per cylinder
772 * based on a given number of sectors. This is the algorithm described
773 * in the VHD specification.
775 * Note that the geometry doesn't always exactly match total_sectors but
778 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
779 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
780 * and instead allow up to 255 heads.
782 static int calculate_geometry(int64_t total_sectors
, uint16_t* cyls
,
783 uint8_t* heads
, uint8_t* secs_per_cyl
)
785 uint32_t cyls_times_heads
;
787 total_sectors
= MIN(total_sectors
, VHD_MAX_GEOMETRY
);
789 if (total_sectors
>= 65535LL * 16 * 63) {
792 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
795 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
796 *heads
= DIV_ROUND_UP(cyls_times_heads
, 1024);
802 if (cyls_times_heads
>= (*heads
* 1024) || *heads
> 16) {
805 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
808 if (cyls_times_heads
>= (*heads
* 1024)) {
811 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
815 *cyls
= cyls_times_heads
/ *heads
;
820 static int create_dynamic_disk(BlockBackend
*blk
, uint8_t *buf
,
821 int64_t total_sectors
)
823 VHDDynDiskHeader
*dyndisk_header
=
824 (VHDDynDiskHeader
*) buf
;
825 size_t block_size
, num_bat_entries
;
830 /* Write the footer (twice: at the beginning and at the end) */
831 block_size
= 0x200000;
832 num_bat_entries
= (total_sectors
+ block_size
/ 512) / (block_size
/ 512);
834 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
839 offset
= 1536 + ((num_bat_entries
* 4 + 511) & ~511);
840 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
845 /* Write the initial BAT */
848 memset(buf
, 0xFF, 512);
849 for (i
= 0; i
< DIV_ROUND_UP(num_bat_entries
* 4, 512); i
++) {
850 ret
= blk_pwrite(blk
, offset
, buf
, 512, 0);
857 /* Prepare the Dynamic Disk Header */
858 memset(buf
, 0, 1024);
860 memcpy(dyndisk_header
->magic
, "cxsparse", 8);
863 * Note: The spec is actually wrong here for data_offset, it says
864 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
866 dyndisk_header
->data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
867 dyndisk_header
->table_offset
= cpu_to_be64(3 * 512);
868 dyndisk_header
->version
= cpu_to_be32(0x00010000);
869 dyndisk_header
->block_size
= cpu_to_be32(block_size
);
870 dyndisk_header
->max_table_entries
= cpu_to_be32(num_bat_entries
);
872 dyndisk_header
->checksum
= cpu_to_be32(vpc_checksum(buf
, 1024));
874 /* Write the header */
877 ret
= blk_pwrite(blk
, offset
, buf
, 1024, 0);
886 static int create_fixed_disk(BlockBackend
*blk
, uint8_t *buf
,
887 int64_t total_size
, Error
**errp
)
891 /* Add footer to total size */
892 total_size
+= HEADER_SIZE
;
894 ret
= blk_truncate(blk
, total_size
, PREALLOC_MODE_OFF
, errp
);
899 ret
= blk_pwrite(blk
, total_size
- HEADER_SIZE
, buf
, HEADER_SIZE
, 0);
901 error_setg_errno(errp
, -ret
, "Unable to write VHD header");
908 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc
*vpc_opts
,
911 uint8_t *out_secs_per_cyl
,
912 int64_t *out_total_sectors
,
915 int64_t total_size
= vpc_opts
->size
;
918 uint8_t secs_per_cyl
= 0;
919 int64_t total_sectors
;
923 * Calculate matching total_size and geometry. Increase the number of
924 * sectors requested until we get enough (or fail). This ensures that
925 * qemu-img convert doesn't truncate images, but rather rounds up.
927 * If the image size can't be represented by a spec conformant CHS geometry,
928 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
929 * the image size from the VHD footer to calculate total_sectors.
931 if (vpc_opts
->force_size
) {
932 /* This will force the use of total_size for sector count, below */
933 cyls
= VHD_CHS_MAX_C
;
934 heads
= VHD_CHS_MAX_H
;
935 secs_per_cyl
= VHD_CHS_MAX_S
;
937 total_sectors
= MIN(VHD_MAX_GEOMETRY
, total_size
/ BDRV_SECTOR_SIZE
);
938 for (i
= 0; total_sectors
> (int64_t)cyls
* heads
* secs_per_cyl
; i
++) {
939 calculate_geometry(total_sectors
+ i
, &cyls
, &heads
, &secs_per_cyl
);
943 if ((int64_t)cyls
* heads
* secs_per_cyl
== VHD_MAX_GEOMETRY
) {
944 total_sectors
= total_size
/ BDRV_SECTOR_SIZE
;
945 /* Allow a maximum disk size of 2040 GiB */
946 if (total_sectors
> VHD_MAX_SECTORS
) {
947 error_setg(errp
, "Disk size is too large, max size is 2040 GiB");
951 total_sectors
= (int64_t) cyls
* heads
* secs_per_cyl
;
954 *out_total_sectors
= total_sectors
;
958 *out_secs_per_cyl
= secs_per_cyl
;
964 static int coroutine_fn
vpc_co_create(BlockdevCreateOptions
*opts
,
967 BlockdevCreateOptionsVpc
*vpc_opts
;
968 BlockBackend
*blk
= NULL
;
969 BlockDriverState
*bs
= NULL
;
972 VHDFooter
*footer
= (VHDFooter
*) buf
;
975 uint8_t secs_per_cyl
= 0;
976 int64_t total_sectors
;
981 assert(opts
->driver
== BLOCKDEV_DRIVER_VPC
);
982 vpc_opts
= &opts
->u
.vpc
;
984 /* Validate options and set default values */
985 total_size
= vpc_opts
->size
;
987 if (!vpc_opts
->has_subformat
) {
988 vpc_opts
->subformat
= BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
;
990 switch (vpc_opts
->subformat
) {
991 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
:
992 disk_type
= VHD_DYNAMIC
;
994 case BLOCKDEV_VPC_SUBFORMAT_FIXED
:
995 disk_type
= VHD_FIXED
;
998 g_assert_not_reached();
1001 /* Create BlockBackend to write to the image */
1002 bs
= bdrv_open_blockdev_ref(vpc_opts
->file
, errp
);
1007 blk
= blk_new(BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
);
1008 ret
= blk_insert_bs(blk
, bs
, errp
);
1012 blk_set_allow_write_beyond_eof(blk
, true);
1014 /* Get geometry and check that it matches the image size*/
1015 ret
= calculate_rounded_image_size(vpc_opts
, &cyls
, &heads
, &secs_per_cyl
,
1016 &total_sectors
, errp
);
1021 if (total_size
!= total_sectors
* BDRV_SECTOR_SIZE
) {
1022 error_setg(errp
, "The requested image size cannot be represented in "
1024 error_append_hint(errp
, "Try size=%llu or force-size=on (the "
1025 "latter makes the image incompatible with "
1027 total_sectors
* BDRV_SECTOR_SIZE
);
1032 /* Prepare the Hard Disk Footer */
1033 memset(buf
, 0, 1024);
1035 memcpy(footer
->creator
, "conectix", 8);
1036 if (vpc_opts
->force_size
) {
1037 memcpy(footer
->creator_app
, "qem2", 4);
1039 memcpy(footer
->creator_app
, "qemu", 4);
1041 memcpy(footer
->creator_os
, "Wi2k", 4);
1043 footer
->features
= cpu_to_be32(0x02);
1044 footer
->version
= cpu_to_be32(0x00010000);
1045 if (disk_type
== VHD_DYNAMIC
) {
1046 footer
->data_offset
= cpu_to_be64(HEADER_SIZE
);
1048 footer
->data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
1050 footer
->timestamp
= cpu_to_be32(time(NULL
) - VHD_TIMESTAMP_BASE
);
1052 /* Version of Virtual PC 2007 */
1053 footer
->major
= cpu_to_be16(0x0005);
1054 footer
->minor
= cpu_to_be16(0x0003);
1055 footer
->orig_size
= cpu_to_be64(total_size
);
1056 footer
->current_size
= cpu_to_be64(total_size
);
1057 footer
->cyls
= cpu_to_be16(cyls
);
1058 footer
->heads
= heads
;
1059 footer
->secs_per_cyl
= secs_per_cyl
;
1061 footer
->type
= cpu_to_be32(disk_type
);
1063 qemu_uuid_generate(&footer
->uuid
);
1065 footer
->checksum
= cpu_to_be32(vpc_checksum(buf
, HEADER_SIZE
));
1067 if (disk_type
== VHD_DYNAMIC
) {
1068 ret
= create_dynamic_disk(blk
, buf
, total_sectors
);
1070 error_setg(errp
, "Unable to create or write VHD header");
1073 ret
= create_fixed_disk(blk
, buf
, total_size
, errp
);
1082 static int coroutine_fn
vpc_co_create_opts(const char *filename
,
1083 QemuOpts
*opts
, Error
**errp
)
1085 BlockdevCreateOptions
*create_options
= NULL
;
1088 BlockDriverState
*bs
= NULL
;
1089 Error
*local_err
= NULL
;
1092 static const QDictRenames opt_renames
[] = {
1093 { VPC_OPT_FORCE_SIZE
, "force-size" },
1097 /* Parse options and convert legacy syntax */
1098 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &vpc_create_opts
, true);
1100 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
1105 /* Create and open the file (protocol layer) */
1106 ret
= bdrv_create_file(filename
, opts
, &local_err
);
1108 error_propagate(errp
, local_err
);
1112 bs
= bdrv_open(filename
, NULL
, NULL
,
1113 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
1119 /* Now get the QAPI type BlockdevCreateOptions */
1120 qdict_put_str(qdict
, "driver", "vpc");
1121 qdict_put_str(qdict
, "file", bs
->node_name
);
1123 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
1129 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, &local_err
);
1133 error_propagate(errp
, local_err
);
1138 /* Silently round up size */
1139 assert(create_options
->driver
== BLOCKDEV_DRIVER_VPC
);
1140 create_options
->u
.vpc
.size
=
1141 ROUND_UP(create_options
->u
.vpc
.size
, BDRV_SECTOR_SIZE
);
1143 if (!create_options
->u
.vpc
.force_size
) {
1144 int64_t total_sectors
;
1145 ret
= calculate_rounded_image_size(&create_options
->u
.vpc
, NULL
, NULL
,
1146 NULL
, &total_sectors
, errp
);
1151 create_options
->u
.vpc
.size
= total_sectors
* BDRV_SECTOR_SIZE
;
1155 /* Create the vpc image (format layer) */
1156 ret
= vpc_co_create(create_options
, errp
);
1159 qobject_unref(qdict
);
1161 qapi_free_BlockdevCreateOptions(create_options
);
1166 static int vpc_has_zero_init(BlockDriverState
*bs
)
1168 BDRVVPCState
*s
= bs
->opaque
;
1169 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
1171 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
1172 return bdrv_has_zero_init(bs
->file
->bs
);
1178 static void vpc_close(BlockDriverState
*bs
)
1180 BDRVVPCState
*s
= bs
->opaque
;
1181 qemu_vfree(s
->pagetable
);
1183 g_free(s
->pageentry_u8
);
1186 migrate_del_blocker(s
->migration_blocker
);
1187 error_free(s
->migration_blocker
);
1190 static QemuOptsList vpc_create_opts
= {
1191 .name
= "vpc-create-opts",
1192 .head
= QTAILQ_HEAD_INITIALIZER(vpc_create_opts
.head
),
1195 .name
= BLOCK_OPT_SIZE
,
1196 .type
= QEMU_OPT_SIZE
,
1197 .help
= "Virtual disk size"
1200 .name
= BLOCK_OPT_SUBFMT
,
1201 .type
= QEMU_OPT_STRING
,
1203 "Type of virtual hard disk format. Supported formats are "
1204 "{dynamic (default) | fixed} "
1207 .name
= VPC_OPT_FORCE_SIZE
,
1208 .type
= QEMU_OPT_BOOL
,
1209 .help
= "Force disk size calculation to use the actual size "
1210 "specified, rather than using the nearest CHS-based "
1213 { /* end of list */ }
1217 static BlockDriver bdrv_vpc
= {
1218 .format_name
= "vpc",
1219 .instance_size
= sizeof(BDRVVPCState
),
1221 .bdrv_probe
= vpc_probe
,
1222 .bdrv_open
= vpc_open
,
1223 .bdrv_close
= vpc_close
,
1224 .bdrv_reopen_prepare
= vpc_reopen_prepare
,
1225 .bdrv_child_perm
= bdrv_format_default_perms
,
1226 .bdrv_co_create
= vpc_co_create
,
1227 .bdrv_co_create_opts
= vpc_co_create_opts
,
1229 .bdrv_co_preadv
= vpc_co_preadv
,
1230 .bdrv_co_pwritev
= vpc_co_pwritev
,
1231 .bdrv_co_block_status
= vpc_co_block_status
,
1233 .bdrv_get_info
= vpc_get_info
,
1235 .create_opts
= &vpc_create_opts
,
1236 .bdrv_has_zero_init
= vpc_has_zero_init
,
1239 static void bdrv_vpc_init(void)
1241 bdrv_register(&bdrv_vpc
);
1244 block_init(bdrv_vpc_init
);