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 uint8_t reserved2
[256];
131 } QEMU_PACKED VHDDynDiskHeader
;
133 QEMU_BUILD_BUG_ON(sizeof(VHDDynDiskHeader
) != 1024);
135 typedef struct BDRVVPCState
{
137 uint8_t footer_buf
[HEADER_SIZE
];
138 uint64_t free_data_block_offset
;
139 int max_table_entries
;
142 uint64_t last_bitmap_offset
;
145 uint32_t bitmap_size
;
150 uint8_t *pageentry_u8
;
151 uint32_t *pageentry_u32
;
152 uint16_t *pageentry_u16
;
154 uint64_t last_bitmap
;
157 Error
*migration_blocker
;
160 #define VPC_OPT_SIZE_CALC "force_size_calc"
161 static QemuOptsList vpc_runtime_opts
= {
162 .name
= "vpc-runtime-opts",
163 .head
= QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts
.head
),
166 .name
= VPC_OPT_SIZE_CALC
,
167 .type
= QEMU_OPT_STRING
,
168 .help
= "Force disk size calculation to use either CHS geometry, "
169 "or use the disk current_size specified in the VHD footer. "
170 "{chs, current_size}"
172 { /* end of list */ }
176 static QemuOptsList vpc_create_opts
;
178 static uint32_t vpc_checksum(void *p
, size_t size
)
184 for (i
= 0; i
< size
; i
++)
191 static int vpc_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
193 if (buf_size
>= 8 && !strncmp((char *)buf
, "conectix", 8))
198 static void vpc_parse_options(BlockDriverState
*bs
, QemuOpts
*opts
,
201 BDRVVPCState
*s
= bs
->opaque
;
202 const char *size_calc
;
204 size_calc
= qemu_opt_get(opts
, VPC_OPT_SIZE_CALC
);
207 /* no override, use autodetect only */
208 } else if (!strcmp(size_calc
, "current_size")) {
209 s
->force_use_sz
= true;
210 } else if (!strcmp(size_calc
, "chs")) {
211 s
->force_use_chs
= true;
213 error_setg(errp
, "Invalid size calculation mode: '%s'", size_calc
);
217 static int vpc_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
220 BDRVVPCState
*s
= bs
->opaque
;
223 QemuOpts
*opts
= NULL
;
224 Error
*local_err
= NULL
;
226 VHDDynDiskHeader dyndisk_header
;
228 uint64_t computed_size
;
229 uint64_t pagetable_size
;
230 int disk_type
= VHD_DYNAMIC
;
234 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_of_bds
,
235 BDRV_CHILD_IMAGE
, false, errp
);
240 opts
= qemu_opts_create(&vpc_runtime_opts
, NULL
, 0, &error_abort
);
241 if (!qemu_opts_absorb_qdict(opts
, options
, errp
)) {
246 vpc_parse_options(bs
, opts
, &local_err
);
248 error_propagate(errp
, local_err
);
253 ret
= bdrv_pread(bs
->file
, 0, s
->footer_buf
, HEADER_SIZE
);
255 error_setg(errp
, "Unable to read VHD header");
259 footer
= (VHDFooter
*) s
->footer_buf
;
260 if (strncmp(footer
->creator
, "conectix", 8)) {
261 int64_t offset
= bdrv_getlength(bs
->file
->bs
);
264 error_setg(errp
, "Invalid file size");
266 } else if (offset
< HEADER_SIZE
) {
268 error_setg(errp
, "File too small for a VHD header");
272 /* If a fixed disk, the footer is found only at the end of the file */
273 ret
= bdrv_pread(bs
->file
, offset
-HEADER_SIZE
, s
->footer_buf
,
278 if (strncmp(footer
->creator
, "conectix", 8)) {
279 error_setg(errp
, "invalid VPC image");
283 disk_type
= VHD_FIXED
;
286 checksum
= be32_to_cpu(footer
->checksum
);
287 footer
->checksum
= 0;
288 if (vpc_checksum(s
->footer_buf
, HEADER_SIZE
) != checksum
) {
289 error_setg(errp
, "Incorrect header checksum");
294 /* Write 'checksum' back to footer, or else will leave it with zero. */
295 footer
->checksum
= cpu_to_be32(checksum
);
297 /* The visible size of a image in Virtual PC depends on the geometry
298 rather than on the size stored in the footer (the size in the footer
299 is too large usually) */
300 bs
->total_sectors
= (int64_t)
301 be16_to_cpu(footer
->cyls
) * footer
->heads
* footer
->secs_per_cyl
;
303 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
304 * VHD image sizes differently. VPC will rely on CHS geometry,
305 * while Hyper-V and disk2vhd use the size specified in the footer.
307 * We use a couple of approaches to try and determine the correct method:
308 * look at the Creator App field, and look for images that have CHS
309 * geometry that is the maximum value.
311 * If the CHS geometry is the maximum CHS geometry, then we assume that
312 * the size is the footer->current_size to avoid truncation. Otherwise,
313 * we follow the table based on footer->creator_app:
315 * Known creator apps:
316 * 'vpc ' : CHS Virtual PC (uses disk geometry)
317 * 'qemu' : CHS QEMU (uses disk geometry)
318 * 'qem2' : current_size QEMU (uses current_size)
319 * 'win ' : current_size Hyper-V
320 * 'd2v ' : current_size Disk2vhd
321 * 'tap\0' : current_size XenServer
322 * 'CTXS' : current_size XenConverter
324 * The user can override the table values via drive options, however
325 * even with an override we will still use current_size for images
326 * that have CHS geometry of the maximum size.
328 use_chs
= (!!strncmp(footer
->creator_app
, "win ", 4) &&
329 !!strncmp(footer
->creator_app
, "qem2", 4) &&
330 !!strncmp(footer
->creator_app
, "d2v ", 4) &&
331 !!strncmp(footer
->creator_app
, "CTXS", 4) &&
332 !!memcmp(footer
->creator_app
, "tap", 4)) || s
->force_use_chs
;
334 if (!use_chs
|| bs
->total_sectors
== VHD_MAX_GEOMETRY
|| s
->force_use_sz
) {
335 bs
->total_sectors
= be64_to_cpu(footer
->current_size
) /
339 /* Allow a maximum disk size of 2040 GiB */
340 if (bs
->total_sectors
> VHD_MAX_SECTORS
) {
345 if (disk_type
== VHD_DYNAMIC
) {
346 ret
= bdrv_pread(bs
->file
, be64_to_cpu(footer
->data_offset
),
347 &dyndisk_header
, sizeof(dyndisk_header
));
349 error_setg(errp
, "Error reading dynamic VHD header");
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
, errp
);
452 error_free(s
->migration_blocker
);
456 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
;
610 static int coroutine_fn
611 vpc_co_preadv(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
612 QEMUIOVector
*qiov
, int flags
)
614 BDRVVPCState
*s
= bs
->opaque
;
616 int64_t image_offset
;
618 int64_t bytes_done
= 0;
619 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
620 QEMUIOVector local_qiov
;
622 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
623 return bdrv_co_preadv(bs
->file
, offset
, bytes
, qiov
, 0);
626 qemu_co_mutex_lock(&s
->lock
);
627 qemu_iovec_init(&local_qiov
, qiov
->niov
);
630 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
631 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
633 if (image_offset
== -1) {
634 qemu_iovec_memset(qiov
, bytes_done
, 0, n_bytes
);
636 qemu_iovec_reset(&local_qiov
);
637 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
639 qemu_co_mutex_unlock(&s
->lock
);
640 ret
= bdrv_co_preadv(bs
->file
, image_offset
, n_bytes
,
642 qemu_co_mutex_lock(&s
->lock
);
650 bytes_done
+= n_bytes
;
655 qemu_iovec_destroy(&local_qiov
);
656 qemu_co_mutex_unlock(&s
->lock
);
661 static int coroutine_fn
662 vpc_co_pwritev(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
663 QEMUIOVector
*qiov
, int flags
)
665 BDRVVPCState
*s
= bs
->opaque
;
666 int64_t image_offset
;
668 int64_t bytes_done
= 0;
670 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
671 QEMUIOVector local_qiov
;
673 if (be32_to_cpu(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 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
728 int64_t image_offset
;
733 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
736 *file
= bs
->file
->bs
;
737 return BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
| BDRV_BLOCK_RECURSE
;
740 qemu_co_mutex_lock(&s
->lock
);
742 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
743 allocated
= (image_offset
!= -1);
745 ret
= BDRV_BLOCK_ZERO
;
748 /* All sectors in a block are contiguous (without using the bitmap) */
749 n
= ROUND_UP(offset
+ 1, s
->block_size
) - offset
;
755 /* *pnum can't be greater than one block for allocated
756 * sectors since there is always a bitmap in between. */
758 *file
= bs
->file
->bs
;
760 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
766 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
767 } while (image_offset
== -1);
769 qemu_co_mutex_unlock(&s
->lock
);
774 * Calculates the number of cylinders, heads and sectors per cylinder
775 * based on a given number of sectors. This is the algorithm described
776 * in the VHD specification.
778 * Note that the geometry doesn't always exactly match total_sectors but
781 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
782 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
783 * and instead allow up to 255 heads.
785 static int calculate_geometry(int64_t total_sectors
, uint16_t *cyls
,
786 uint8_t *heads
, uint8_t *secs_per_cyl
)
788 uint32_t cyls_times_heads
;
790 total_sectors
= MIN(total_sectors
, VHD_MAX_GEOMETRY
);
792 if (total_sectors
>= 65535LL * 16 * 63) {
795 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
798 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
799 *heads
= DIV_ROUND_UP(cyls_times_heads
, 1024);
805 if (cyls_times_heads
>= (*heads
* 1024) || *heads
> 16) {
808 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
811 if (cyls_times_heads
>= (*heads
* 1024)) {
814 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
818 *cyls
= cyls_times_heads
/ *heads
;
823 static int create_dynamic_disk(BlockBackend
*blk
, uint8_t *buf
,
824 int64_t total_sectors
)
826 VHDDynDiskHeader dyndisk_header
;
827 uint8_t bat_sector
[512];
828 size_t block_size
, num_bat_entries
;
833 /* Write the footer (twice: at the beginning and at the end) */
834 block_size
= 0x200000;
835 num_bat_entries
= DIV_ROUND_UP(total_sectors
, block_size
/ 512);
837 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
842 offset
= 1536 + ((num_bat_entries
* 4 + 511) & ~511);
843 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
848 /* Write the initial BAT */
851 memset(bat_sector
, 0xFF, 512);
852 for (i
= 0; i
< DIV_ROUND_UP(num_bat_entries
* 4, 512); i
++) {
853 ret
= blk_pwrite(blk
, offset
, bat_sector
, 512, 0);
860 /* Prepare the Dynamic Disk Header */
861 memset(&dyndisk_header
, 0, sizeof(dyndisk_header
));
863 memcpy(dyndisk_header
.magic
, "cxsparse", 8);
866 * Note: The spec is actually wrong here for data_offset, it says
867 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
869 dyndisk_header
.data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
870 dyndisk_header
.table_offset
= cpu_to_be64(3 * 512);
871 dyndisk_header
.version
= cpu_to_be32(0x00010000);
872 dyndisk_header
.block_size
= cpu_to_be32(block_size
);
873 dyndisk_header
.max_table_entries
= cpu_to_be32(num_bat_entries
);
875 dyndisk_header
.checksum
= cpu_to_be32(
876 vpc_checksum(&dyndisk_header
, sizeof(dyndisk_header
)));
878 /* Write the header */
881 ret
= blk_pwrite(blk
, offset
, &dyndisk_header
, sizeof(dyndisk_header
), 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
;
976 uint8_t footer_buf
[HEADER_SIZE
];
977 VHDFooter
*footer
= (VHDFooter
*)footer_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(footer_buf
, 0, HEADER_SIZE
);
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(footer_buf
, HEADER_SIZE
));
1075 if (disk_type
== VHD_DYNAMIC
) {
1076 ret
= create_dynamic_disk(blk
, footer_buf
, total_sectors
);
1078 error_setg(errp
, "Unable to create or write VHD header");
1081 ret
= create_fixed_disk(blk
, footer_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
;
1101 static const QDictRenames opt_renames
[] = {
1102 { VPC_OPT_FORCE_SIZE
, "force-size" },
1106 /* Parse options and convert legacy syntax */
1107 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &vpc_create_opts
, true);
1109 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
1114 /* Create and open the file (protocol layer) */
1115 ret
= bdrv_create_file(filename
, opts
, errp
);
1120 bs
= bdrv_open(filename
, NULL
, NULL
,
1121 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
1127 /* Now get the QAPI type BlockdevCreateOptions */
1128 qdict_put_str(qdict
, "driver", "vpc");
1129 qdict_put_str(qdict
, "file", bs
->node_name
);
1131 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
1137 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, errp
);
1139 if (!create_options
) {
1144 /* Silently round up size */
1145 assert(create_options
->driver
== BLOCKDEV_DRIVER_VPC
);
1146 create_options
->u
.vpc
.size
=
1147 ROUND_UP(create_options
->u
.vpc
.size
, BDRV_SECTOR_SIZE
);
1149 if (!create_options
->u
.vpc
.force_size
) {
1150 int64_t total_sectors
;
1151 ret
= calculate_rounded_image_size(&create_options
->u
.vpc
, NULL
, NULL
,
1152 NULL
, &total_sectors
, errp
);
1157 create_options
->u
.vpc
.size
= total_sectors
* BDRV_SECTOR_SIZE
;
1161 /* Create the vpc image (format layer) */
1162 ret
= vpc_co_create(create_options
, errp
);
1165 qobject_unref(qdict
);
1167 qapi_free_BlockdevCreateOptions(create_options
);
1172 static int vpc_has_zero_init(BlockDriverState
*bs
)
1174 BDRVVPCState
*s
= bs
->opaque
;
1175 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
1177 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
1178 return bdrv_has_zero_init(bs
->file
->bs
);
1184 static void vpc_close(BlockDriverState
*bs
)
1186 BDRVVPCState
*s
= bs
->opaque
;
1187 qemu_vfree(s
->pagetable
);
1189 g_free(s
->pageentry_u8
);
1192 migrate_del_blocker(s
->migration_blocker
);
1193 error_free(s
->migration_blocker
);
1196 static QemuOptsList vpc_create_opts
= {
1197 .name
= "vpc-create-opts",
1198 .head
= QTAILQ_HEAD_INITIALIZER(vpc_create_opts
.head
),
1201 .name
= BLOCK_OPT_SIZE
,
1202 .type
= QEMU_OPT_SIZE
,
1203 .help
= "Virtual disk size"
1206 .name
= BLOCK_OPT_SUBFMT
,
1207 .type
= QEMU_OPT_STRING
,
1209 "Type of virtual hard disk format. Supported formats are "
1210 "{dynamic (default) | fixed} "
1213 .name
= VPC_OPT_FORCE_SIZE
,
1214 .type
= QEMU_OPT_BOOL
,
1215 .help
= "Force disk size calculation to use the actual size "
1216 "specified, rather than using the nearest CHS-based "
1219 { /* end of list */ }
1223 static const char *const vpc_strong_runtime_opts
[] = {
1229 static BlockDriver bdrv_vpc
= {
1230 .format_name
= "vpc",
1231 .instance_size
= sizeof(BDRVVPCState
),
1233 .bdrv_probe
= vpc_probe
,
1234 .bdrv_open
= vpc_open
,
1235 .bdrv_close
= vpc_close
,
1236 .bdrv_reopen_prepare
= vpc_reopen_prepare
,
1237 .bdrv_child_perm
= bdrv_default_perms
,
1238 .bdrv_co_create
= vpc_co_create
,
1239 .bdrv_co_create_opts
= vpc_co_create_opts
,
1241 .bdrv_co_preadv
= vpc_co_preadv
,
1242 .bdrv_co_pwritev
= vpc_co_pwritev
,
1243 .bdrv_co_block_status
= vpc_co_block_status
,
1245 .bdrv_get_info
= vpc_get_info
,
1248 .create_opts
= &vpc_create_opts
,
1249 .bdrv_has_zero_init
= vpc_has_zero_init
,
1250 .strong_runtime_opts
= vpc_strong_runtime_opts
,
1253 static void bdrv_vpc_init(void)
1255 bdrv_register(&bdrv_vpc
);
1258 block_init(bdrv_vpc_init
);