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
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu-common.h"
28 #include "block/block_int.h"
29 #include "sysemu/block-backend.h"
30 #include "qemu/module.h"
31 #include "migration/blocker.h"
32 #include "qemu/bswap.h"
33 #include "qemu/uuid.h"
35 /**************************************************************/
37 #define HEADER_SIZE 512
47 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
48 #define VHD_TIMESTAMP_BASE 946684800
50 #define VHD_CHS_MAX_C 65535LL
51 #define VHD_CHS_MAX_H 16
52 #define VHD_CHS_MAX_S 255
54 #define VHD_MAX_SECTORS 0xff000000 /* 2040 GiB max image size */
55 #define VHD_MAX_GEOMETRY (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S)
57 #define VPC_OPT_FORCE_SIZE "force_size"
59 /* always big-endian */
60 typedef struct vhd_footer
{
61 char creator
[8]; /* "conectix" */
65 /* Offset of next header structure, 0xFFFFFFFF if none */
68 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
71 char creator_app
[4]; /* e.g., "vpc " */
74 char creator_os
[4]; /* "Wi2k" */
77 uint64_t current_size
;
85 /* Checksum of the Hard Disk Footer ("one's complement of the sum of all
86 the bytes in the footer without the checksum field") */
89 /* UUID used to identify a parent hard disk (backing file) */
92 uint8_t in_saved_state
;
93 } QEMU_PACKED VHDFooter
;
95 typedef struct vhd_dyndisk_header
{
96 char magic
[8]; /* "cxsparse" */
98 /* Offset of next header structure, 0xFFFFFFFF if none */
101 /* Offset of the Block Allocation Table (BAT) */
102 uint64_t table_offset
;
105 uint32_t max_table_entries
; /* 32bit/entry */
107 /* 2 MB by default, must be a power of two */
111 uint8_t parent_uuid
[16];
112 uint32_t parent_timestamp
;
115 /* Backing file name (in UTF-16) */
116 uint8_t parent_name
[512];
121 uint32_t data_length
;
123 uint64_t data_offset
;
125 } QEMU_PACKED VHDDynDiskHeader
;
127 typedef struct BDRVVPCState
{
129 uint8_t footer_buf
[HEADER_SIZE
];
130 uint64_t free_data_block_offset
;
131 int max_table_entries
;
134 uint64_t last_bitmap_offset
;
137 uint32_t bitmap_size
;
142 uint8_t *pageentry_u8
;
143 uint32_t *pageentry_u32
;
144 uint16_t *pageentry_u16
;
146 uint64_t last_bitmap
;
149 Error
*migration_blocker
;
152 #define VPC_OPT_SIZE_CALC "force_size_calc"
153 static QemuOptsList vpc_runtime_opts
= {
154 .name
= "vpc-runtime-opts",
155 .head
= QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts
.head
),
158 .name
= VPC_OPT_SIZE_CALC
,
159 .type
= QEMU_OPT_STRING
,
160 .help
= "Force disk size calculation to use either CHS geometry, "
161 "or use the disk current_size specified in the VHD footer. "
162 "{chs, current_size}"
164 { /* end of list */ }
168 static uint32_t vpc_checksum(uint8_t* buf
, size_t size
)
173 for (i
= 0; i
< size
; i
++)
180 static int vpc_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
182 if (buf_size
>= 8 && !strncmp((char *)buf
, "conectix", 8))
187 static void vpc_parse_options(BlockDriverState
*bs
, QemuOpts
*opts
,
190 BDRVVPCState
*s
= bs
->opaque
;
191 const char *size_calc
;
193 size_calc
= qemu_opt_get(opts
, VPC_OPT_SIZE_CALC
);
196 /* no override, use autodetect only */
197 } else if (!strcmp(size_calc
, "current_size")) {
198 s
->force_use_sz
= true;
199 } else if (!strcmp(size_calc
, "chs")) {
200 s
->force_use_chs
= true;
202 error_setg(errp
, "Invalid size calculation mode: '%s'", size_calc
);
206 static int vpc_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
209 BDRVVPCState
*s
= bs
->opaque
;
212 VHDDynDiskHeader
*dyndisk_header
;
213 QemuOpts
*opts
= NULL
;
214 Error
*local_err
= NULL
;
216 uint8_t buf
[HEADER_SIZE
];
218 uint64_t computed_size
;
219 uint64_t pagetable_size
;
220 int disk_type
= VHD_DYNAMIC
;
223 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
229 opts
= qemu_opts_create(&vpc_runtime_opts
, NULL
, 0, &error_abort
);
230 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
232 error_propagate(errp
, local_err
);
237 vpc_parse_options(bs
, opts
, &local_err
);
239 error_propagate(errp
, local_err
);
244 ret
= bdrv_pread(bs
->file
, 0, s
->footer_buf
, HEADER_SIZE
);
246 error_setg(errp
, "Unable to read VHD header");
250 footer
= (VHDFooter
*) s
->footer_buf
;
251 if (strncmp(footer
->creator
, "conectix", 8)) {
252 int64_t offset
= bdrv_getlength(bs
->file
->bs
);
255 error_setg(errp
, "Invalid file size");
257 } else if (offset
< HEADER_SIZE
) {
259 error_setg(errp
, "File too small for a VHD header");
263 /* If a fixed disk, the footer is found only at the end of the file */
264 ret
= bdrv_pread(bs
->file
, offset
-HEADER_SIZE
, s
->footer_buf
,
269 if (strncmp(footer
->creator
, "conectix", 8)) {
270 error_setg(errp
, "invalid VPC image");
274 disk_type
= VHD_FIXED
;
277 checksum
= be32_to_cpu(footer
->checksum
);
278 footer
->checksum
= 0;
279 if (vpc_checksum(s
->footer_buf
, HEADER_SIZE
) != checksum
)
280 fprintf(stderr
, "block-vpc: The header checksum of '%s' is "
281 "incorrect.\n", bs
->filename
);
283 /* Write 'checksum' back to footer, or else will leave it with zero. */
284 footer
->checksum
= cpu_to_be32(checksum
);
286 /* The visible size of a image in Virtual PC depends on the geometry
287 rather than on the size stored in the footer (the size in the footer
288 is too large usually) */
289 bs
->total_sectors
= (int64_t)
290 be16_to_cpu(footer
->cyls
) * footer
->heads
* footer
->secs_per_cyl
;
292 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
293 * VHD image sizes differently. VPC will rely on CHS geometry,
294 * while Hyper-V and disk2vhd use the size specified in the footer.
296 * We use a couple of approaches to try and determine the correct method:
297 * look at the Creator App field, and look for images that have CHS
298 * geometry that is the maximum value.
300 * If the CHS geometry is the maximum CHS geometry, then we assume that
301 * the size is the footer->current_size to avoid truncation. Otherwise,
302 * we follow the table based on footer->creator_app:
304 * Known creator apps:
305 * 'vpc ' : CHS Virtual PC (uses disk geometry)
306 * 'qemu' : CHS QEMU (uses disk geometry)
307 * 'qem2' : current_size QEMU (uses current_size)
308 * 'win ' : current_size Hyper-V
309 * 'd2v ' : current_size Disk2vhd
310 * 'tap\0' : current_size XenServer
311 * 'CTXS' : current_size XenConverter
313 * The user can override the table values via drive options, however
314 * even with an override we will still use current_size for images
315 * that have CHS geometry of the maximum size.
317 use_chs
= (!!strncmp(footer
->creator_app
, "win ", 4) &&
318 !!strncmp(footer
->creator_app
, "qem2", 4) &&
319 !!strncmp(footer
->creator_app
, "d2v ", 4) &&
320 !!strncmp(footer
->creator_app
, "CTXS", 4) &&
321 !!memcmp(footer
->creator_app
, "tap", 4)) || s
->force_use_chs
;
323 if (!use_chs
|| bs
->total_sectors
== VHD_MAX_GEOMETRY
|| s
->force_use_sz
) {
324 bs
->total_sectors
= be64_to_cpu(footer
->current_size
) /
328 /* Allow a maximum disk size of 2040 GiB */
329 if (bs
->total_sectors
> VHD_MAX_SECTORS
) {
334 if (disk_type
== VHD_DYNAMIC
) {
335 ret
= bdrv_pread(bs
->file
, be64_to_cpu(footer
->data_offset
), buf
,
338 error_setg(errp
, "Error reading dynamic VHD header");
342 dyndisk_header
= (VHDDynDiskHeader
*) buf
;
344 if (strncmp(dyndisk_header
->magic
, "cxsparse", 8)) {
345 error_setg(errp
, "Invalid header magic");
350 s
->block_size
= be32_to_cpu(dyndisk_header
->block_size
);
351 if (!is_power_of_2(s
->block_size
) || s
->block_size
< BDRV_SECTOR_SIZE
) {
352 error_setg(errp
, "Invalid block size %" PRIu32
, s
->block_size
);
356 s
->bitmap_size
= ((s
->block_size
/ (8 * 512)) + 511) & ~511;
358 s
->max_table_entries
= be32_to_cpu(dyndisk_header
->max_table_entries
);
360 if ((bs
->total_sectors
* 512) / s
->block_size
> 0xffffffffU
) {
361 error_setg(errp
, "Too many blocks");
366 computed_size
= (uint64_t) s
->max_table_entries
* s
->block_size
;
367 if (computed_size
< bs
->total_sectors
* 512) {
368 error_setg(errp
, "Page table too small");
373 if (s
->max_table_entries
> SIZE_MAX
/ 4 ||
374 s
->max_table_entries
> (int) INT_MAX
/ 4) {
375 error_setg(errp
, "Max Table Entries too large (%" PRId32
")",
376 s
->max_table_entries
);
381 pagetable_size
= (uint64_t) s
->max_table_entries
* 4;
383 s
->pagetable
= qemu_try_blockalign(bs
->file
->bs
, pagetable_size
);
384 if (s
->pagetable
== NULL
) {
385 error_setg(errp
, "Unable to allocate memory for page table");
390 s
->bat_offset
= be64_to_cpu(dyndisk_header
->table_offset
);
392 ret
= bdrv_pread(bs
->file
, s
->bat_offset
, s
->pagetable
,
395 error_setg(errp
, "Error reading pagetable");
399 s
->free_data_block_offset
=
400 ROUND_UP(s
->bat_offset
+ pagetable_size
, 512);
402 for (i
= 0; i
< s
->max_table_entries
; i
++) {
403 be32_to_cpus(&s
->pagetable
[i
]);
404 if (s
->pagetable
[i
] != 0xFFFFFFFF) {
405 int64_t next
= (512 * (int64_t) s
->pagetable
[i
]) +
406 s
->bitmap_size
+ s
->block_size
;
408 if (next
> s
->free_data_block_offset
) {
409 s
->free_data_block_offset
= next
;
414 if (s
->free_data_block_offset
> bdrv_getlength(bs
->file
->bs
)) {
415 error_setg(errp
, "block-vpc: free_data_block_offset points after "
416 "the end of file. The image has been truncated.");
421 s
->last_bitmap_offset
= (int64_t) -1;
424 s
->pageentry_u8
= g_malloc(512);
425 s
->pageentry_u32
= s
->pageentry_u8
;
426 s
->pageentry_u16
= s
->pageentry_u8
;
427 s
->last_pagetable
= -1;
431 /* Disable migration when VHD images are used */
432 error_setg(&s
->migration_blocker
, "The vpc format used by node '%s' "
433 "does not support live migration",
434 bdrv_get_device_or_node_name(bs
));
435 ret
= migrate_add_blocker(s
->migration_blocker
, &local_err
);
437 error_propagate(errp
, local_err
);
438 error_free(s
->migration_blocker
);
442 qemu_co_mutex_init(&s
->lock
);
447 qemu_vfree(s
->pagetable
);
449 g_free(s
->pageentry_u8
);
454 static int vpc_reopen_prepare(BDRVReopenState
*state
,
455 BlockReopenQueue
*queue
, Error
**errp
)
461 * Returns the absolute byte offset of the given sector in the image file.
462 * If the sector is not allocated, -1 is returned instead.
463 * If an error occurred trying to write an updated block bitmap back to
464 * the file, -2 is returned, and the error value is written to *err.
465 * This can only happen for a write operation.
467 * The parameter write must be 1 if the offset will be used for a write
468 * operation (the block bitmaps is updated then), 0 otherwise.
469 * If write is true then err must not be NULL.
471 static inline int64_t get_image_offset(BlockDriverState
*bs
, uint64_t offset
,
472 bool write
, int *err
)
474 BDRVVPCState
*s
= bs
->opaque
;
475 uint64_t bitmap_offset
, block_offset
;
476 uint32_t pagetable_index
, offset_in_block
;
478 assert(!(write
&& err
== NULL
));
480 pagetable_index
= offset
/ s
->block_size
;
481 offset_in_block
= offset
% s
->block_size
;
483 if (pagetable_index
>= s
->max_table_entries
|| s
->pagetable
[pagetable_index
] == 0xffffffff)
484 return -1; /* not allocated */
486 bitmap_offset
= 512 * (uint64_t) s
->pagetable
[pagetable_index
];
487 block_offset
= bitmap_offset
+ s
->bitmap_size
+ offset_in_block
;
489 /* We must ensure that we don't write to any sectors which are marked as
490 unused in the bitmap. We get away with setting all bits in the block
491 bitmap each time we write to a new block. This might cause Virtual PC to
492 miss sparse read optimization, but it's not a problem in terms of
494 if (write
&& (s
->last_bitmap_offset
!= bitmap_offset
)) {
495 uint8_t bitmap
[s
->bitmap_size
];
498 s
->last_bitmap_offset
= bitmap_offset
;
499 memset(bitmap
, 0xff, s
->bitmap_size
);
500 r
= bdrv_pwrite_sync(bs
->file
, bitmap_offset
, bitmap
, s
->bitmap_size
);
511 * Writes the footer to the end of the image file. This is needed when the
512 * file grows as it overwrites the old footer
514 * Returns 0 on success and < 0 on error
516 static int rewrite_footer(BlockDriverState
* bs
)
519 BDRVVPCState
*s
= bs
->opaque
;
520 int64_t offset
= s
->free_data_block_offset
;
522 ret
= bdrv_pwrite_sync(bs
->file
, offset
, s
->footer_buf
, HEADER_SIZE
);
530 * Allocates a new block. This involves writing a new footer and updating
531 * the Block Allocation Table to use the space at the old end of the image
532 * file (overwriting the old footer)
534 * Returns the sectors' offset in the image file on success and < 0 on error
536 static int64_t alloc_block(BlockDriverState
* bs
, int64_t offset
)
538 BDRVVPCState
*s
= bs
->opaque
;
540 uint32_t index
, bat_value
;
542 uint8_t bitmap
[s
->bitmap_size
];
544 /* Check if sector_num is valid */
545 if ((offset
< 0) || (offset
> bs
->total_sectors
* BDRV_SECTOR_SIZE
)) {
549 /* Write entry into in-memory BAT */
550 index
= offset
/ s
->block_size
;
551 assert(s
->pagetable
[index
] == 0xFFFFFFFF);
552 s
->pagetable
[index
] = s
->free_data_block_offset
/ 512;
554 /* Initialize the block's bitmap */
555 memset(bitmap
, 0xff, s
->bitmap_size
);
556 ret
= bdrv_pwrite_sync(bs
->file
, s
->free_data_block_offset
, bitmap
,
562 /* Write new footer (the old one will be overwritten) */
563 s
->free_data_block_offset
+= s
->block_size
+ s
->bitmap_size
;
564 ret
= rewrite_footer(bs
);
568 /* Write BAT entry to disk */
569 bat_offset
= s
->bat_offset
+ (4 * index
);
570 bat_value
= cpu_to_be32(s
->pagetable
[index
]);
571 ret
= bdrv_pwrite_sync(bs
->file
, bat_offset
, &bat_value
, 4);
575 return get_image_offset(bs
, offset
, false, NULL
);
578 s
->free_data_block_offset
-= (s
->block_size
+ s
->bitmap_size
);
582 static int vpc_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
584 BDRVVPCState
*s
= (BDRVVPCState
*)bs
->opaque
;
585 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
587 if (be32_to_cpu(footer
->type
) != VHD_FIXED
) {
588 bdi
->cluster_size
= s
->block_size
;
591 bdi
->unallocated_blocks_are_zero
= true;
595 static int coroutine_fn
596 vpc_co_preadv(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
597 QEMUIOVector
*qiov
, int flags
)
599 BDRVVPCState
*s
= bs
->opaque
;
601 int64_t image_offset
;
603 int64_t bytes_done
= 0;
604 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
605 QEMUIOVector local_qiov
;
607 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
608 return bdrv_co_preadv(bs
->file
, offset
, bytes
, qiov
, 0);
611 qemu_co_mutex_lock(&s
->lock
);
612 qemu_iovec_init(&local_qiov
, qiov
->niov
);
615 image_offset
= get_image_offset(bs
, offset
, false, NULL
);
616 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
618 if (image_offset
== -1) {
619 qemu_iovec_memset(qiov
, bytes_done
, 0, n_bytes
);
621 qemu_iovec_reset(&local_qiov
);
622 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
624 ret
= bdrv_co_preadv(bs
->file
, image_offset
, n_bytes
,
633 bytes_done
+= n_bytes
;
638 qemu_iovec_destroy(&local_qiov
);
639 qemu_co_mutex_unlock(&s
->lock
);
644 static int coroutine_fn
645 vpc_co_pwritev(BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
646 QEMUIOVector
*qiov
, int flags
)
648 BDRVVPCState
*s
= bs
->opaque
;
649 int64_t image_offset
;
651 int64_t bytes_done
= 0;
653 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
654 QEMUIOVector local_qiov
;
656 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
657 return bdrv_co_pwritev(bs
->file
, offset
, bytes
, qiov
, 0);
660 qemu_co_mutex_lock(&s
->lock
);
661 qemu_iovec_init(&local_qiov
, qiov
->niov
);
664 image_offset
= get_image_offset(bs
, offset
, true, &ret
);
665 if (image_offset
== -2) {
666 /* Failed to write block bitmap: can't proceed with write */
669 n_bytes
= MIN(bytes
, s
->block_size
- (offset
% s
->block_size
));
671 if (image_offset
== -1) {
672 image_offset
= alloc_block(bs
, offset
);
673 if (image_offset
< 0) {
679 qemu_iovec_reset(&local_qiov
);
680 qemu_iovec_concat(&local_qiov
, qiov
, bytes_done
, n_bytes
);
682 ret
= bdrv_co_pwritev(bs
->file
, image_offset
, n_bytes
,
690 bytes_done
+= n_bytes
;
695 qemu_iovec_destroy(&local_qiov
);
696 qemu_co_mutex_unlock(&s
->lock
);
701 static int64_t coroutine_fn
vpc_co_get_block_status(BlockDriverState
*bs
,
702 int64_t sector_num
, int nb_sectors
, int *pnum
, BlockDriverState
**file
)
704 BDRVVPCState
*s
= bs
->opaque
;
705 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
706 int64_t start
, offset
;
711 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
713 *file
= bs
->file
->bs
;
714 return BDRV_BLOCK_RAW
| BDRV_BLOCK_OFFSET_VALID
|
715 (sector_num
<< BDRV_SECTOR_BITS
);
718 qemu_co_mutex_lock(&s
->lock
);
720 offset
= get_image_offset(bs
, sector_num
<< BDRV_SECTOR_BITS
, false, NULL
);
722 allocated
= (offset
!= -1);
727 /* All sectors in a block are contiguous (without using the bitmap) */
728 n
= ROUND_UP(sector_num
+ 1, s
->block_size
/ BDRV_SECTOR_SIZE
)
730 n
= MIN(n
, nb_sectors
);
735 /* *pnum can't be greater than one block for allocated
736 * sectors since there is always a bitmap in between. */
738 *file
= bs
->file
->bs
;
739 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
| start
;
742 if (nb_sectors
== 0) {
745 offset
= get_image_offset(bs
, sector_num
<< BDRV_SECTOR_BITS
, false,
747 } while (offset
== -1);
749 qemu_co_mutex_unlock(&s
->lock
);
754 * Calculates the number of cylinders, heads and sectors per cylinder
755 * based on a given number of sectors. This is the algorithm described
756 * in the VHD specification.
758 * Note that the geometry doesn't always exactly match total_sectors but
761 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
762 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
763 * and instead allow up to 255 heads.
765 static int calculate_geometry(int64_t total_sectors
, uint16_t* cyls
,
766 uint8_t* heads
, uint8_t* secs_per_cyl
)
768 uint32_t cyls_times_heads
;
770 total_sectors
= MIN(total_sectors
, VHD_MAX_GEOMETRY
);
772 if (total_sectors
>= 65535LL * 16 * 63) {
775 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
778 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
779 *heads
= (cyls_times_heads
+ 1023) / 1024;
785 if (cyls_times_heads
>= (*heads
* 1024) || *heads
> 16) {
788 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
791 if (cyls_times_heads
>= (*heads
* 1024)) {
794 cyls_times_heads
= total_sectors
/ *secs_per_cyl
;
798 *cyls
= cyls_times_heads
/ *heads
;
803 static int create_dynamic_disk(BlockBackend
*blk
, uint8_t *buf
,
804 int64_t total_sectors
)
806 VHDDynDiskHeader
*dyndisk_header
=
807 (VHDDynDiskHeader
*) buf
;
808 size_t block_size
, num_bat_entries
;
813 /* Write the footer (twice: at the beginning and at the end) */
814 block_size
= 0x200000;
815 num_bat_entries
= (total_sectors
+ block_size
/ 512) / (block_size
/ 512);
817 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
822 offset
= 1536 + ((num_bat_entries
* 4 + 511) & ~511);
823 ret
= blk_pwrite(blk
, offset
, buf
, HEADER_SIZE
, 0);
828 /* Write the initial BAT */
831 memset(buf
, 0xFF, 512);
832 for (i
= 0; i
< (num_bat_entries
* 4 + 511) / 512; i
++) {
833 ret
= blk_pwrite(blk
, offset
, buf
, 512, 0);
840 /* Prepare the Dynamic Disk Header */
841 memset(buf
, 0, 1024);
843 memcpy(dyndisk_header
->magic
, "cxsparse", 8);
846 * Note: The spec is actually wrong here for data_offset, it says
847 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
849 dyndisk_header
->data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
850 dyndisk_header
->table_offset
= cpu_to_be64(3 * 512);
851 dyndisk_header
->version
= cpu_to_be32(0x00010000);
852 dyndisk_header
->block_size
= cpu_to_be32(block_size
);
853 dyndisk_header
->max_table_entries
= cpu_to_be32(num_bat_entries
);
855 dyndisk_header
->checksum
= cpu_to_be32(vpc_checksum(buf
, 1024));
857 /* Write the header */
860 ret
= blk_pwrite(blk
, offset
, buf
, 1024, 0);
869 static int create_fixed_disk(BlockBackend
*blk
, uint8_t *buf
,
870 int64_t total_size
, Error
**errp
)
874 /* Add footer to total size */
875 total_size
+= HEADER_SIZE
;
877 ret
= blk_truncate(blk
, total_size
, PREALLOC_MODE_OFF
, errp
);
882 ret
= blk_pwrite(blk
, total_size
- HEADER_SIZE
, buf
, HEADER_SIZE
, 0);
884 error_setg_errno(errp
, -ret
, "Unable to write VHD header");
891 static int vpc_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
894 VHDFooter
*footer
= (VHDFooter
*) buf
;
895 char *disk_type_param
;
899 uint8_t secs_per_cyl
= 0;
900 int64_t total_sectors
;
905 Error
*local_err
= NULL
;
906 BlockBackend
*blk
= NULL
;
908 /* Read out options */
909 total_size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
911 disk_type_param
= qemu_opt_get_del(opts
, BLOCK_OPT_SUBFMT
);
912 if (disk_type_param
) {
913 if (!strcmp(disk_type_param
, "dynamic")) {
914 disk_type
= VHD_DYNAMIC
;
915 } else if (!strcmp(disk_type_param
, "fixed")) {
916 disk_type
= VHD_FIXED
;
918 error_setg(errp
, "Invalid disk type, %s", disk_type_param
);
923 disk_type
= VHD_DYNAMIC
;
926 force_size
= qemu_opt_get_bool_del(opts
, VPC_OPT_FORCE_SIZE
, false);
928 ret
= bdrv_create_file(filename
, opts
, &local_err
);
930 error_propagate(errp
, local_err
);
934 blk
= blk_new_open(filename
, NULL
, NULL
,
935 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
,
938 error_propagate(errp
, local_err
);
943 blk_set_allow_write_beyond_eof(blk
, true);
946 * Calculate matching total_size and geometry. Increase the number of
947 * sectors requested until we get enough (or fail). This ensures that
948 * qemu-img convert doesn't truncate images, but rather rounds up.
950 * If the image size can't be represented by a spec conformant CHS geometry,
951 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
952 * the image size from the VHD footer to calculate total_sectors.
955 /* This will force the use of total_size for sector count, below */
956 cyls
= VHD_CHS_MAX_C
;
957 heads
= VHD_CHS_MAX_H
;
958 secs_per_cyl
= VHD_CHS_MAX_S
;
960 total_sectors
= MIN(VHD_MAX_GEOMETRY
, total_size
/ BDRV_SECTOR_SIZE
);
961 for (i
= 0; total_sectors
> (int64_t)cyls
* heads
* secs_per_cyl
; i
++) {
962 calculate_geometry(total_sectors
+ i
, &cyls
, &heads
, &secs_per_cyl
);
966 if ((int64_t)cyls
* heads
* secs_per_cyl
== VHD_MAX_GEOMETRY
) {
967 total_sectors
= total_size
/ BDRV_SECTOR_SIZE
;
968 /* Allow a maximum disk size of 2040 GiB */
969 if (total_sectors
> VHD_MAX_SECTORS
) {
970 error_setg(errp
, "Disk size is too large, max size is 2040 GiB");
975 total_sectors
= (int64_t)cyls
* heads
* secs_per_cyl
;
976 total_size
= total_sectors
* BDRV_SECTOR_SIZE
;
979 /* Prepare the Hard Disk Footer */
980 memset(buf
, 0, 1024);
982 memcpy(footer
->creator
, "conectix", 8);
984 memcpy(footer
->creator_app
, "qem2", 4);
986 memcpy(footer
->creator_app
, "qemu", 4);
988 memcpy(footer
->creator_os
, "Wi2k", 4);
990 footer
->features
= cpu_to_be32(0x02);
991 footer
->version
= cpu_to_be32(0x00010000);
992 if (disk_type
== VHD_DYNAMIC
) {
993 footer
->data_offset
= cpu_to_be64(HEADER_SIZE
);
995 footer
->data_offset
= cpu_to_be64(0xFFFFFFFFFFFFFFFFULL
);
997 footer
->timestamp
= cpu_to_be32(time(NULL
) - VHD_TIMESTAMP_BASE
);
999 /* Version of Virtual PC 2007 */
1000 footer
->major
= cpu_to_be16(0x0005);
1001 footer
->minor
= cpu_to_be16(0x0003);
1002 footer
->orig_size
= cpu_to_be64(total_size
);
1003 footer
->current_size
= cpu_to_be64(total_size
);
1004 footer
->cyls
= cpu_to_be16(cyls
);
1005 footer
->heads
= heads
;
1006 footer
->secs_per_cyl
= secs_per_cyl
;
1008 footer
->type
= cpu_to_be32(disk_type
);
1010 qemu_uuid_generate(&footer
->uuid
);
1012 footer
->checksum
= cpu_to_be32(vpc_checksum(buf
, HEADER_SIZE
));
1014 if (disk_type
== VHD_DYNAMIC
) {
1015 ret
= create_dynamic_disk(blk
, buf
, total_sectors
);
1017 error_setg(errp
, "Unable to create or write VHD header");
1020 ret
= create_fixed_disk(blk
, buf
, total_size
, errp
);
1025 g_free(disk_type_param
);
1029 static int vpc_has_zero_init(BlockDriverState
*bs
)
1031 BDRVVPCState
*s
= bs
->opaque
;
1032 VHDFooter
*footer
= (VHDFooter
*) s
->footer_buf
;
1034 if (be32_to_cpu(footer
->type
) == VHD_FIXED
) {
1035 return bdrv_has_zero_init(bs
->file
->bs
);
1041 static void vpc_close(BlockDriverState
*bs
)
1043 BDRVVPCState
*s
= bs
->opaque
;
1044 qemu_vfree(s
->pagetable
);
1046 g_free(s
->pageentry_u8
);
1049 migrate_del_blocker(s
->migration_blocker
);
1050 error_free(s
->migration_blocker
);
1053 static QemuOptsList vpc_create_opts
= {
1054 .name
= "vpc-create-opts",
1055 .head
= QTAILQ_HEAD_INITIALIZER(vpc_create_opts
.head
),
1058 .name
= BLOCK_OPT_SIZE
,
1059 .type
= QEMU_OPT_SIZE
,
1060 .help
= "Virtual disk size"
1063 .name
= BLOCK_OPT_SUBFMT
,
1064 .type
= QEMU_OPT_STRING
,
1066 "Type of virtual hard disk format. Supported formats are "
1067 "{dynamic (default) | fixed} "
1070 .name
= VPC_OPT_FORCE_SIZE
,
1071 .type
= QEMU_OPT_BOOL
,
1072 .help
= "Force disk size calculation to use the actual size "
1073 "specified, rather than using the nearest CHS-based "
1076 { /* end of list */ }
1080 static BlockDriver bdrv_vpc
= {
1081 .format_name
= "vpc",
1082 .instance_size
= sizeof(BDRVVPCState
),
1084 .bdrv_probe
= vpc_probe
,
1085 .bdrv_open
= vpc_open
,
1086 .bdrv_close
= vpc_close
,
1087 .bdrv_reopen_prepare
= vpc_reopen_prepare
,
1088 .bdrv_child_perm
= bdrv_format_default_perms
,
1089 .bdrv_create
= vpc_create
,
1091 .bdrv_co_preadv
= vpc_co_preadv
,
1092 .bdrv_co_pwritev
= vpc_co_pwritev
,
1093 .bdrv_co_get_block_status
= vpc_co_get_block_status
,
1095 .bdrv_get_info
= vpc_get_info
,
1097 .create_opts
= &vpc_create_opts
,
1098 .bdrv_has_zero_init
= vpc_has_zero_init
,
1101 static void bdrv_vpc_init(void)
1103 bdrv_register(&bdrv_vpc
);
1106 block_init(bdrv_vpc_init
);