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_of_bds
,
232 BDRV_CHILD_IMAGE
, false, errp
);
237 opts
= qemu_opts_create(&vpc_runtime_opts
, NULL
, 0, &error_abort
);
238 if (!qemu_opts_absorb_qdict(opts
, options
, &local_err
)) {
239 error_propagate(errp
, local_err
);
244 vpc_parse_options(bs
, opts
, &local_err
);
246 error_propagate(errp
, local_err
);
251 ret
= bdrv_pread(bs
->file
, 0, s
->footer_buf
, HEADER_SIZE
);
253 error_setg(errp
, "Unable to read VHD header");
257 footer
= (VHDFooter
*) s
->footer_buf
;
258 if (strncmp(footer
->creator
, "conectix", 8)) {
259 int64_t offset
= bdrv_getlength(bs
->file
->bs
);
262 error_setg(errp
, "Invalid file size");
264 } else if (offset
< HEADER_SIZE
) {
266 error_setg(errp
, "File too small for a VHD header");
270 /* If a fixed disk, the footer is found only at the end of the file */
271 ret
= bdrv_pread(bs
->file
, offset
-HEADER_SIZE
, s
->footer_buf
,
276 if (strncmp(footer
->creator
, "conectix", 8)) {
277 error_setg(errp
, "invalid VPC image");
281 disk_type
= VHD_FIXED
;
284 checksum
= be32_to_cpu(footer
->checksum
);
285 footer
->checksum
= 0;
286 if (vpc_checksum(s
->footer_buf
, HEADER_SIZE
) != checksum
) {
287 error_setg(errp
, "Incorrect header checksum");
292 /* Write 'checksum' back to footer, or else will leave it with zero. */
293 footer
->checksum
= cpu_to_be32(checksum
);
295 /* The visible size of a image in Virtual PC depends on the geometry
296 rather than on the size stored in the footer (the size in the footer
297 is too large usually) */
298 bs
->total_sectors
= (int64_t)
299 be16_to_cpu(footer
->cyls
) * footer
->heads
* footer
->secs_per_cyl
;
301 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
302 * VHD image sizes differently. VPC will rely on CHS geometry,
303 * while Hyper-V and disk2vhd use the size specified in the footer.
305 * We use a couple of approaches to try and determine the correct method:
306 * look at the Creator App field, and look for images that have CHS
307 * geometry that is the maximum value.
309 * If the CHS geometry is the maximum CHS geometry, then we assume that
310 * the size is the footer->current_size to avoid truncation. Otherwise,
311 * we follow the table based on footer->creator_app:
313 * Known creator apps:
314 * 'vpc ' : CHS Virtual PC (uses disk geometry)
315 * 'qemu' : CHS QEMU (uses disk geometry)
316 * 'qem2' : current_size QEMU (uses current_size)
317 * 'win ' : current_size Hyper-V
318 * 'd2v ' : current_size Disk2vhd
319 * 'tap\0' : current_size XenServer
320 * 'CTXS' : current_size XenConverter
322 * The user can override the table values via drive options, however
323 * even with an override we will still use current_size for images
324 * that have CHS geometry of the maximum size.
326 use_chs
= (!!strncmp(footer
->creator_app
, "win ", 4) &&
327 !!strncmp(footer
->creator_app
, "qem2", 4) &&
328 !!strncmp(footer
->creator_app
, "d2v ", 4) &&
329 !!strncmp(footer
->creator_app
, "CTXS", 4) &&
330 !!memcmp(footer
->creator_app
, "tap", 4)) || s
->force_use_chs
;
332 if (!use_chs
|| bs
->total_sectors
== VHD_MAX_GEOMETRY
|| s
->force_use_sz
) {
333 bs
->total_sectors
= be64_to_cpu(footer
->current_size
) /
337 /* Allow a maximum disk size of 2040 GiB */
338 if (bs
->total_sectors
> VHD_MAX_SECTORS
) {
343 if (disk_type
== VHD_DYNAMIC
) {
344 ret
= bdrv_pread(bs
->file
, be64_to_cpu(footer
->data_offset
), buf
,
347 error_setg(errp
, "Error reading dynamic VHD header");
351 dyndisk_header
= (VHDDynDiskHeader
*) buf
;
353 if (strncmp(dyndisk_header
->magic
, "cxsparse", 8)) {
354 error_setg(errp
, "Invalid header magic");
359 s
->block_size
= be32_to_cpu(dyndisk_header
->block_size
);
360 if (!is_power_of_2(s
->block_size
) || s
->block_size
< BDRV_SECTOR_SIZE
) {
361 error_setg(errp
, "Invalid block size %" PRIu32
, s
->block_size
);
365 s
->bitmap_size
= ((s
->block_size
/ (8 * 512)) + 511) & ~511;
367 s
->max_table_entries
= be32_to_cpu(dyndisk_header
->max_table_entries
);
369 if ((bs
->total_sectors
* 512) / s
->block_size
> 0xffffffffU
) {
370 error_setg(errp
, "Too many blocks");
375 computed_size
= (uint64_t) s
->max_table_entries
* s
->block_size
;
376 if (computed_size
< bs
->total_sectors
* 512) {
377 error_setg(errp
, "Page table too small");
382 if (s
->max_table_entries
> SIZE_MAX
/ 4 ||
383 s
->max_table_entries
> (int) INT_MAX
/ 4) {
384 error_setg(errp
, "Max Table Entries too large (%" PRId32
")",
385 s
->max_table_entries
);
390 pagetable_size
= (uint64_t) s
->max_table_entries
* 4;
392 s
->pagetable
= qemu_try_blockalign(bs
->file
->bs
, pagetable_size
);
393 if (s
->pagetable
== NULL
) {
394 error_setg(errp
, "Unable to allocate memory for page table");
399 s
->bat_offset
= be64_to_cpu(dyndisk_header
->table_offset
);
401 ret
= bdrv_pread(bs
->file
, s
->bat_offset
, s
->pagetable
,
404 error_setg(errp
, "Error reading pagetable");
408 s
->free_data_block_offset
=
409 ROUND_UP(s
->bat_offset
+ pagetable_size
, 512);
411 for (i
= 0; i
< s
->max_table_entries
; i
++) {
412 be32_to_cpus(&s
->pagetable
[i
]);
413 if (s
->pagetable
[i
] != 0xFFFFFFFF) {
414 int64_t next
= (512 * (int64_t) s
->pagetable
[i
]) +
415 s
->bitmap_size
+ s
->block_size
;
417 if (next
> s
->free_data_block_offset
) {
418 s
->free_data_block_offset
= next
;
423 bs_size
= bdrv_getlength(bs
->file
->bs
);
425 error_setg_errno(errp
, -bs_size
, "Unable to learn image size");
429 if (s
->free_data_block_offset
> bs_size
) {
430 error_setg(errp
, "block-vpc: free_data_block_offset points after "
431 "the end of file. The image has been truncated.");
436 s
->last_bitmap_offset
= (int64_t) -1;
439 s
->pageentry_u8
= g_malloc(512);
440 s
->pageentry_u32
= s
->pageentry_u8
;
441 s
->pageentry_u16
= s
->pageentry_u8
;
442 s
->last_pagetable
= -1;
446 /* Disable migration when VHD images are used */
447 error_setg(&s
->migration_blocker
, "The vpc format used by node '%s' "
448 "does not support live migration",
449 bdrv_get_device_or_node_name(bs
));
450 ret
= migrate_add_blocker(s
->migration_blocker
, &local_err
);
452 error_propagate(errp
, local_err
);
453 error_free(s
->migration_blocker
);
457 qemu_co_mutex_init(&s
->lock
);
464 qemu_vfree(s
->pagetable
);
466 g_free(s
->pageentry_u8
);
471 static int vpc_reopen_prepare(BDRVReopenState
*state
,
472 BlockReopenQueue
*queue
, Error
**errp
)
478 * Returns the absolute byte offset of the given sector in the image file.
479 * If the sector is not allocated, -1 is returned instead.
480 * If an error occurred trying to write an updated block bitmap back to
481 * the file, -2 is returned, and the error value is written to *err.
482 * This can only happen for a write operation.
484 * The parameter write must be 1 if the offset will be used for a write
485 * operation (the block bitmaps is updated then), 0 otherwise.
486 * If write is true then err must not be NULL.
488 static inline int64_t get_image_offset(BlockDriverState
*bs
, uint64_t offset
,
489 bool write
, int *err
)
491 BDRVVPCState
*s
= bs
->opaque
;
492 uint64_t bitmap_offset
, block_offset
;
493 uint32_t pagetable_index
, offset_in_block
;
495 assert(!(write
&& err
== NULL
));
497 pagetable_index
= offset
/ s
->block_size
;
498 offset_in_block
= offset
% s
->block_size
;
500 if (pagetable_index
>= s
->max_table_entries
|| s
->pagetable
[pagetable_index
] == 0xffffffff)
501 return -1; /* not allocated */
503 bitmap_offset
= 512 * (uint64_t) s
->pagetable
[pagetable_index
];
504 block_offset
= bitmap_offset
+ s
->bitmap_size
+ offset_in_block
;
506 /* We must ensure that we don't write to any sectors which are marked as
507 unused in the bitmap. We get away with setting all bits in the block
508 bitmap each time we write to a new block. This might cause Virtual PC to
509 miss sparse read optimization, but it's not a problem in terms of
511 if (write
&& (s
->last_bitmap_offset
!= bitmap_offset
)) {
512 uint8_t bitmap
[s
->bitmap_size
];
515 s
->last_bitmap_offset
= bitmap_offset
;
516 memset(bitmap
, 0xff, s
->bitmap_size
);
517 r
= bdrv_pwrite_sync(bs
->file
, bitmap_offset
, bitmap
, s
->bitmap_size
);
528 * Writes the footer to the end of the image file. This is needed when the
529 * file grows as it overwrites the old footer
531 * Returns 0 on success and < 0 on error
533 static int rewrite_footer(BlockDriverState
* bs
)
536 BDRVVPCState
*s
= bs
->opaque
;
537 int64_t offset
= s
->free_data_block_offset
;
539 ret
= bdrv_pwrite_sync(bs
->file
, offset
, s
->footer_buf
, HEADER_SIZE
);
547 * Allocates a new block. This involves writing a new footer and updating
548 * the Block Allocation Table to use the space at the old end of the image
549 * file (overwriting the old footer)
551 * Returns the sectors' offset in the image file on success and < 0 on error
553 static int64_t alloc_block(BlockDriverState
* bs
, int64_t offset
)
555 BDRVVPCState
*s
= bs
->opaque
;
557 uint32_t index
, bat_value
;
559 uint8_t bitmap
[s
->bitmap_size
];
561 /* Check if sector_num is valid */
562 if ((offset
< 0) || (offset
> bs
->total_sectors
* BDRV_SECTOR_SIZE
)) {
566 /* Write entry into in-memory BAT */
567 index
= offset
/ s
->block_size
;
568 assert(s
->pagetable
[index
] == 0xFFFFFFFF);
569 s
->pagetable
[index
] = s
->free_data_block_offset
/ 512;
571 /* Initialize the block's bitmap */
572 memset(bitmap
, 0xff, s
->bitmap_size
);
573 ret
= bdrv_pwrite_sync(bs
->file
, s
->free_data_block_offset
, bitmap
,
579 /* Write new footer (the old one will be overwritten) */
580 s
->free_data_block_offset
+= s
->block_size
+ s
->bitmap_size
;
581 ret
= rewrite_footer(bs
);
585 /* Write BAT entry to disk */
586 bat_offset
= s
->bat_offset
+ (4 * index
);
587 bat_value
= cpu_to_be32(s
->pagetable
[index
]);
588 ret
= bdrv_pwrite_sync(bs
->file
, bat_offset
, &bat_value
, 4);
592 return get_image_offset(bs
, offset
, false, NULL
);
595 s
->free_data_block_offset
-= (s
->block_size
+ s
->bitmap_size
);
599 static int vpc_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
601 BDRVVPCState
*s
= (BDRVVPCState
*)bs
->opaque
;
602 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
604 if (be32_to_cpu(footer
->type
) != VHD_FIXED
) {
605 bdi
->cluster_size
= s
->block_size
;
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 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 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 qemu_co_mutex_unlock(&s
->lock
);
701 ret
= bdrv_co_pwritev(bs
->file
, image_offset
, n_bytes
,
703 qemu_co_mutex_lock(&s
->lock
);
710 bytes_done
+= n_bytes
;
715 qemu_iovec_destroy(&local_qiov
);
716 qemu_co_mutex_unlock(&s
->lock
);
721 static int coroutine_fn
vpc_co_block_status(BlockDriverState
*bs
,
723 int64_t offset
, int64_t bytes
,
724 int64_t *pnum
, int64_t *map
,
725 BlockDriverState
**file
)
727 BDRVVPCState
*s
= bs
->opaque
;
728 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
729 int64_t image_offset
;
734 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
737 *file
= bs
->file
->bs
;
738 return BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
| BDRV_BLOCK_RECURSE
;
741 qemu_co_mutex_lock(&s
->lock
);
743 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
744 allocated
= (image_offset
!= -1);
746 ret
= BDRV_BLOCK_ZERO
;
749 /* All sectors in a block are contiguous (without using the bitmap) */
750 n
= ROUND_UP(offset
+ 1, s
->block_size
) - offset
;
756 /* *pnum can't be greater than one block for allocated
757 * sectors since there is always a bitmap in between. */
759 *file
= bs
->file
->bs
;
761 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
767 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
768 } while (image_offset
== -1);
770 qemu_co_mutex_unlock(&s
->lock
);
775 * Calculates the number of cylinders, heads and sectors per cylinder
776 * based on a given number of sectors. This is the algorithm described
777 * in the VHD specification.
779 * Note that the geometry doesn't always exactly match total_sectors but
782 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
783 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
784 * and instead allow up to 255 heads.
786 static int calculate_geometry(int64_t total_sectors
, uint16_t* cyls
,
787 uint8_t* heads
, uint8_t* secs_per_cyl
)
789 uint32_t cyls_times_heads
;
791 total_sectors
= MIN(total_sectors
, VHD_MAX_GEOMETRY
);
793 if (total_sectors
>= 65535LL * 16 * 63) {
796 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
799 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
800 *heads
= DIV_ROUND_UP(cyls_times_heads
, 1024);
806 if (cyls_times_heads
>= (*heads
* 1024) || *heads
> 16) {
809 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
812 if (cyls_times_heads
>= (*heads
* 1024)) {
815 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
819 *cyls
= cyls_times_heads
/ *heads
;
824 static int create_dynamic_disk(BlockBackend
*blk
, uint8_t *buf
,
825 int64_t total_sectors
)
827 VHDDynDiskHeader
*dyndisk_header
=
828 (VHDDynDiskHeader
*) buf
;
829 size_t block_size
, num_bat_entries
;
834 /* Write the footer (twice: at the beginning and at the end) */
835 block_size
= 0x200000;
836 num_bat_entries
= DIV_ROUND_UP(total_sectors
, block_size
/ 512);
838 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
843 offset
= 1536 + ((num_bat_entries
* 4 + 511) & ~511);
844 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
849 /* Write the initial BAT */
852 memset(buf
, 0xFF, 512);
853 for (i
= 0; i
< DIV_ROUND_UP(num_bat_entries
* 4, 512); i
++) {
854 ret
= blk_pwrite(blk
, offset
, buf
, 512, 0);
861 /* Prepare the Dynamic Disk Header */
862 memset(buf
, 0, 1024);
864 memcpy(dyndisk_header
->magic
, "cxsparse", 8);
867 * Note: The spec is actually wrong here for data_offset, it says
868 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
870 dyndisk_header
->data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
871 dyndisk_header
->table_offset
= cpu_to_be64(3 * 512);
872 dyndisk_header
->version
= cpu_to_be32(0x00010000);
873 dyndisk_header
->block_size
= cpu_to_be32(block_size
);
874 dyndisk_header
->max_table_entries
= cpu_to_be32(num_bat_entries
);
876 dyndisk_header
->checksum
= cpu_to_be32(vpc_checksum(buf
, 1024));
878 /* Write the header */
881 ret
= blk_pwrite(blk
, offset
, buf
, 1024, 0);
891 static int create_fixed_disk(BlockBackend
*blk
, uint8_t *buf
,
892 int64_t total_size
, Error
**errp
)
896 /* Add footer to total size */
897 total_size
+= HEADER_SIZE
;
899 ret
= blk_truncate(blk
, total_size
, false, PREALLOC_MODE_OFF
, 0, errp
);
904 ret
= blk_pwrite(blk
, total_size
- HEADER_SIZE
, buf
, HEADER_SIZE
, 0);
906 error_setg_errno(errp
, -ret
, "Unable to write VHD header");
913 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc
*vpc_opts
,
916 uint8_t *out_secs_per_cyl
,
917 int64_t *out_total_sectors
,
920 int64_t total_size
= vpc_opts
->size
;
923 uint8_t secs_per_cyl
= 0;
924 int64_t total_sectors
;
928 * Calculate matching total_size and geometry. Increase the number of
929 * sectors requested until we get enough (or fail). This ensures that
930 * qemu-img convert doesn't truncate images, but rather rounds up.
932 * If the image size can't be represented by a spec conformant CHS geometry,
933 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
934 * the image size from the VHD footer to calculate total_sectors.
936 if (vpc_opts
->force_size
) {
937 /* This will force the use of total_size for sector count, below */
938 cyls
= VHD_CHS_MAX_C
;
939 heads
= VHD_CHS_MAX_H
;
940 secs_per_cyl
= VHD_CHS_MAX_S
;
942 total_sectors
= MIN(VHD_MAX_GEOMETRY
, total_size
/ BDRV_SECTOR_SIZE
);
943 for (i
= 0; total_sectors
> (int64_t)cyls
* heads
* secs_per_cyl
; i
++) {
944 calculate_geometry(total_sectors
+ i
, &cyls
, &heads
, &secs_per_cyl
);
948 if ((int64_t)cyls
* heads
* secs_per_cyl
== VHD_MAX_GEOMETRY
) {
949 total_sectors
= total_size
/ BDRV_SECTOR_SIZE
;
950 /* Allow a maximum disk size of 2040 GiB */
951 if (total_sectors
> VHD_MAX_SECTORS
) {
952 error_setg(errp
, "Disk size is too large, max size is 2040 GiB");
956 total_sectors
= (int64_t) cyls
* heads
* secs_per_cyl
;
959 *out_total_sectors
= total_sectors
;
963 *out_secs_per_cyl
= secs_per_cyl
;
969 static int coroutine_fn
vpc_co_create(BlockdevCreateOptions
*opts
,
972 BlockdevCreateOptionsVpc
*vpc_opts
;
973 BlockBackend
*blk
= NULL
;
974 BlockDriverState
*bs
= NULL
;
977 VHDFooter
*footer
= (VHDFooter
*) buf
;
980 uint8_t secs_per_cyl
= 0;
981 int64_t total_sectors
;
987 assert(opts
->driver
== BLOCKDEV_DRIVER_VPC
);
988 vpc_opts
= &opts
->u
.vpc
;
990 /* Validate options and set default values */
991 total_size
= vpc_opts
->size
;
993 if (!vpc_opts
->has_subformat
) {
994 vpc_opts
->subformat
= BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
;
996 switch (vpc_opts
->subformat
) {
997 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC
:
998 disk_type
= VHD_DYNAMIC
;
1000 case BLOCKDEV_VPC_SUBFORMAT_FIXED
:
1001 disk_type
= VHD_FIXED
;
1004 g_assert_not_reached();
1007 /* Create BlockBackend to write to the image */
1008 bs
= bdrv_open_blockdev_ref(vpc_opts
->file
, errp
);
1013 blk
= blk_new_with_bs(bs
, BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
,
1019 blk_set_allow_write_beyond_eof(blk
, true);
1021 /* Get geometry and check that it matches the image size*/
1022 ret
= calculate_rounded_image_size(vpc_opts
, &cyls
, &heads
, &secs_per_cyl
,
1023 &total_sectors
, errp
);
1028 if (total_size
!= total_sectors
* BDRV_SECTOR_SIZE
) {
1029 error_setg(errp
, "The requested image size cannot be represented in "
1031 error_append_hint(errp
, "Try size=%llu or force-size=on (the "
1032 "latter makes the image incompatible with "
1034 total_sectors
* BDRV_SECTOR_SIZE
);
1039 /* Prepare the Hard Disk Footer */
1040 memset(buf
, 0, 1024);
1042 memcpy(footer
->creator
, "conectix", 8);
1043 if (vpc_opts
->force_size
) {
1044 memcpy(footer
->creator_app
, "qem2", 4);
1046 memcpy(footer
->creator_app
, "qemu", 4);
1048 memcpy(footer
->creator_os
, "Wi2k", 4);
1050 footer
->features
= cpu_to_be32(0x02);
1051 footer
->version
= cpu_to_be32(0x00010000);
1052 if (disk_type
== VHD_DYNAMIC
) {
1053 footer
->data_offset
= cpu_to_be64(HEADER_SIZE
);
1055 footer
->data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
1057 footer
->timestamp
= cpu_to_be32(time(NULL
) - VHD_TIMESTAMP_BASE
);
1059 /* Version of Virtual PC 2007 */
1060 footer
->major
= cpu_to_be16(0x0005);
1061 footer
->minor
= cpu_to_be16(0x0003);
1062 footer
->orig_size
= cpu_to_be64(total_size
);
1063 footer
->current_size
= cpu_to_be64(total_size
);
1064 footer
->cyls
= cpu_to_be16(cyls
);
1065 footer
->heads
= heads
;
1066 footer
->secs_per_cyl
= secs_per_cyl
;
1068 footer
->type
= cpu_to_be32(disk_type
);
1070 qemu_uuid_generate(&uuid
);
1071 footer
->uuid
= uuid
;
1073 footer
->checksum
= cpu_to_be32(vpc_checksum(buf
, HEADER_SIZE
));
1075 if (disk_type
== VHD_DYNAMIC
) {
1076 ret
= create_dynamic_disk(blk
, buf
, total_sectors
);
1078 error_setg(errp
, "Unable to create or write VHD header");
1081 ret
= create_fixed_disk(blk
, buf
, total_size
, errp
);
1090 static int coroutine_fn
vpc_co_create_opts(BlockDriver
*drv
,
1091 const char *filename
,
1095 BlockdevCreateOptions
*create_options
= NULL
;
1098 BlockDriverState
*bs
= NULL
;
1099 Error
*local_err
= NULL
;
1102 static const QDictRenames opt_renames
[] = {
1103 { VPC_OPT_FORCE_SIZE
, "force-size" },
1107 /* Parse options and convert legacy syntax */
1108 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &vpc_create_opts
, true);
1110 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
1115 /* Create and open the file (protocol layer) */
1116 ret
= bdrv_create_file(filename
, opts
, errp
);
1121 bs
= bdrv_open(filename
, NULL
, NULL
,
1122 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
1128 /* Now get the QAPI type BlockdevCreateOptions */
1129 qdict_put_str(qdict
, "driver", "vpc");
1130 qdict_put_str(qdict
, "file", bs
->node_name
);
1132 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
1138 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, &local_err
);
1142 error_propagate(errp
, local_err
);
1147 /* Silently round up size */
1148 assert(create_options
->driver
== BLOCKDEV_DRIVER_VPC
);
1149 create_options
->u
.vpc
.size
=
1150 ROUND_UP(create_options
->u
.vpc
.size
, BDRV_SECTOR_SIZE
);
1152 if (!create_options
->u
.vpc
.force_size
) {
1153 int64_t total_sectors
;
1154 ret
= calculate_rounded_image_size(&create_options
->u
.vpc
, NULL
, NULL
,
1155 NULL
, &total_sectors
, errp
);
1160 create_options
->u
.vpc
.size
= total_sectors
* BDRV_SECTOR_SIZE
;
1164 /* Create the vpc image (format layer) */
1165 ret
= vpc_co_create(create_options
, errp
);
1168 qobject_unref(qdict
);
1170 qapi_free_BlockdevCreateOptions(create_options
);
1175 static int vpc_has_zero_init(BlockDriverState
*bs
)
1177 BDRVVPCState
*s
= bs
->opaque
;
1178 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
1180 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
1181 return bdrv_has_zero_init(bs
->file
->bs
);
1187 static void vpc_close(BlockDriverState
*bs
)
1189 BDRVVPCState
*s
= bs
->opaque
;
1190 qemu_vfree(s
->pagetable
);
1192 g_free(s
->pageentry_u8
);
1195 migrate_del_blocker(s
->migration_blocker
);
1196 error_free(s
->migration_blocker
);
1199 static QemuOptsList vpc_create_opts
= {
1200 .name
= "vpc-create-opts",
1201 .head
= QTAILQ_HEAD_INITIALIZER(vpc_create_opts
.head
),
1204 .name
= BLOCK_OPT_SIZE
,
1205 .type
= QEMU_OPT_SIZE
,
1206 .help
= "Virtual disk size"
1209 .name
= BLOCK_OPT_SUBFMT
,
1210 .type
= QEMU_OPT_STRING
,
1212 "Type of virtual hard disk format. Supported formats are "
1213 "{dynamic (default) | fixed} "
1216 .name
= VPC_OPT_FORCE_SIZE
,
1217 .type
= QEMU_OPT_BOOL
,
1218 .help
= "Force disk size calculation to use the actual size "
1219 "specified, rather than using the nearest CHS-based "
1222 { /* end of list */ }
1226 static const char *const vpc_strong_runtime_opts
[] = {
1232 static BlockDriver bdrv_vpc
= {
1233 .format_name
= "vpc",
1234 .instance_size
= sizeof(BDRVVPCState
),
1236 .bdrv_probe
= vpc_probe
,
1237 .bdrv_open
= vpc_open
,
1238 .bdrv_close
= vpc_close
,
1239 .bdrv_reopen_prepare
= vpc_reopen_prepare
,
1240 .bdrv_child_perm
= bdrv_default_perms
,
1241 .bdrv_co_create
= vpc_co_create
,
1242 .bdrv_co_create_opts
= vpc_co_create_opts
,
1244 .bdrv_co_preadv
= vpc_co_preadv
,
1245 .bdrv_co_pwritev
= vpc_co_pwritev
,
1246 .bdrv_co_block_status
= vpc_co_block_status
,
1248 .bdrv_get_info
= vpc_get_info
,
1251 .create_opts
= &vpc_create_opts
,
1252 .bdrv_has_zero_init
= vpc_has_zero_init
,
1253 .strong_runtime_opts
= vpc_strong_runtime_opts
,
1256 static void bdrv_vpc_init(void)
1258 bdrv_register(&bdrv_vpc
);
1261 block_init(bdrv_vpc_init
);