tests/qtest/fuzz: Fix build failure
[qemu/ar7.git] / block / vpc.c
blob17a705b482afb61d169229ec28fe0a841f61f9dd
1 /*
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
23 * THE SOFTWARE.
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 CACHE
44 enum vhd_type {
45 VHD_FIXED = 2,
46 VHD_DYNAMIC = 3,
47 VHD_DIFFERENCING = 4,
50 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
51 #define VHD_TIMESTAMP_BASE 946684800
53 #define VHD_CHS_MAX_C 65535LL
54 #define VHD_CHS_MAX_H 16
55 #define VHD_CHS_MAX_S 255
57 #define VHD_MAX_SECTORS 0xff000000 /* 2040 GiB max image size */
58 #define VHD_MAX_GEOMETRY (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S)
60 #define VPC_OPT_FORCE_SIZE "force_size"
62 /* always big-endian */
63 typedef struct vhd_footer {
64 char creator[8]; /* "conectix" */
65 uint32_t features;
66 uint32_t version;
68 /* Offset of next header structure, 0xFFFFFFFF if none */
69 uint64_t data_offset;
71 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
72 uint32_t timestamp;
74 char creator_app[4]; /* e.g., "vpc " */
75 uint16_t major;
76 uint16_t minor;
77 char creator_os[4]; /* "Wi2k" */
79 uint64_t orig_size;
80 uint64_t current_size;
82 uint16_t cyls;
83 uint8_t heads;
84 uint8_t secs_per_cyl;
86 uint32_t type;
88 /* Checksum of the Hard Disk Footer ("one's complement of the sum of all
89 the bytes in the footer without the checksum field") */
90 uint32_t checksum;
92 /* UUID used to identify a parent hard disk (backing file) */
93 QemuUUID uuid;
95 uint8_t in_saved_state;
96 uint8_t reserved[427];
97 } QEMU_PACKED VHDFooter;
99 QEMU_BUILD_BUG_ON(sizeof(VHDFooter) != 512);
101 typedef struct vhd_dyndisk_header {
102 char magic[8]; /* "cxsparse" */
104 /* Offset of next header structure, 0xFFFFFFFF if none */
105 uint64_t data_offset;
107 /* Offset of the Block Allocation Table (BAT) */
108 uint64_t table_offset;
110 uint32_t version;
111 uint32_t max_table_entries; /* 32bit/entry */
113 /* 2 MB by default, must be a power of two */
114 uint32_t block_size;
116 uint32_t checksum;
117 uint8_t parent_uuid[16];
118 uint32_t parent_timestamp;
119 uint32_t reserved;
121 /* Backing file name (in UTF-16) */
122 uint8_t parent_name[512];
124 struct {
125 uint32_t platform;
126 uint32_t data_space;
127 uint32_t data_length;
128 uint32_t reserved;
129 uint64_t data_offset;
130 } parent_locator[8];
131 uint8_t reserved2[256];
132 } QEMU_PACKED VHDDynDiskHeader;
134 QEMU_BUILD_BUG_ON(sizeof(VHDDynDiskHeader) != 1024);
136 typedef struct BDRVVPCState {
137 CoMutex lock;
138 VHDFooter footer;
139 uint64_t free_data_block_offset;
140 int max_table_entries;
141 uint32_t *pagetable;
142 uint64_t bat_offset;
143 uint64_t last_bitmap_offset;
145 uint32_t block_size;
146 uint32_t bitmap_size;
147 bool force_use_chs;
148 bool force_use_sz;
150 #ifdef CACHE
151 uint8_t *pageentry_u8;
152 uint32_t *pageentry_u32;
153 uint16_t *pageentry_u16;
155 uint64_t last_bitmap;
156 #endif
158 Error *migration_blocker;
159 } BDRVVPCState;
161 #define VPC_OPT_SIZE_CALC "force_size_calc"
162 static QemuOptsList vpc_runtime_opts = {
163 .name = "vpc-runtime-opts",
164 .head = QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts.head),
165 .desc = {
167 .name = VPC_OPT_SIZE_CALC,
168 .type = QEMU_OPT_STRING,
169 .help = "Force disk size calculation to use either CHS geometry, "
170 "or use the disk current_size specified in the VHD footer. "
171 "{chs, current_size}"
173 { /* end of list */ }
177 static QemuOptsList vpc_create_opts;
179 static uint32_t vpc_checksum(void *p, size_t size)
181 uint8_t *buf = p;
182 uint32_t res = 0;
183 int i;
185 for (i = 0; i < size; i++)
186 res += buf[i];
188 return ~res;
192 static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
194 if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
195 return 100;
196 return 0;
199 static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
200 Error **errp)
202 BDRVVPCState *s = bs->opaque;
203 const char *size_calc;
205 size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC);
207 if (!size_calc) {
208 /* no override, use autodetect only */
209 } else if (!strcmp(size_calc, "current_size")) {
210 s->force_use_sz = true;
211 } else if (!strcmp(size_calc, "chs")) {
212 s->force_use_chs = true;
213 } else {
214 error_setg(errp, "Invalid size calculation mode: '%s'", size_calc);
218 static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
219 Error **errp)
221 BDRVVPCState *s = bs->opaque;
222 int i;
223 VHDFooter *footer;
224 QemuOpts *opts = NULL;
225 Error *local_err = NULL;
226 bool use_chs;
227 VHDDynDiskHeader dyndisk_header;
228 uint32_t checksum;
229 uint64_t computed_size;
230 uint64_t pagetable_size;
231 int disk_type = VHD_DYNAMIC;
232 int ret;
233 int64_t bs_size;
235 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
236 BDRV_CHILD_IMAGE, false, errp);
237 if (!bs->file) {
238 return -EINVAL;
241 opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
242 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
243 ret = -EINVAL;
244 goto fail;
247 vpc_parse_options(bs, opts, &local_err);
248 if (local_err) {
249 error_propagate(errp, local_err);
250 ret = -EINVAL;
251 goto fail;
254 ret = bdrv_pread(bs->file, 0, &s->footer, sizeof(s->footer));
255 if (ret < 0) {
256 error_setg(errp, "Unable to read VHD header");
257 goto fail;
260 footer = &s->footer;
261 if (strncmp(footer->creator, "conectix", 8)) {
262 int64_t offset = bdrv_getlength(bs->file->bs);
263 if (offset < 0) {
264 ret = offset;
265 error_setg(errp, "Invalid file size");
266 goto fail;
267 } else if (offset < sizeof(*footer)) {
268 ret = -EINVAL;
269 error_setg(errp, "File too small for a VHD header");
270 goto fail;
273 /* If a fixed disk, the footer is found only at the end of the file */
274 ret = bdrv_pread(bs->file, offset - sizeof(*footer),
275 footer, sizeof(*footer));
276 if (ret < 0) {
277 goto fail;
279 if (strncmp(footer->creator, "conectix", 8)) {
280 error_setg(errp, "invalid VPC image");
281 ret = -EINVAL;
282 goto fail;
284 disk_type = VHD_FIXED;
287 checksum = be32_to_cpu(footer->checksum);
288 footer->checksum = 0;
289 if (vpc_checksum(footer, sizeof(*footer)) != checksum) {
290 error_setg(errp, "Incorrect header checksum");
291 ret = -EINVAL;
292 goto fail;
295 /* Write 'checksum' back to footer, or else will leave it with zero. */
296 footer->checksum = cpu_to_be32(checksum);
298 /* The visible size of a image in Virtual PC depends on the geometry
299 rather than on the size stored in the footer (the size in the footer
300 is too large usually) */
301 bs->total_sectors = (int64_t)
302 be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
304 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
305 * VHD image sizes differently. VPC will rely on CHS geometry,
306 * while Hyper-V and disk2vhd use the size specified in the footer.
308 * We use a couple of approaches to try and determine the correct method:
309 * look at the Creator App field, and look for images that have CHS
310 * geometry that is the maximum value.
312 * If the CHS geometry is the maximum CHS geometry, then we assume that
313 * the size is the footer->current_size to avoid truncation. Otherwise,
314 * we follow the table based on footer->creator_app:
316 * Known creator apps:
317 * 'vpc ' : CHS Virtual PC (uses disk geometry)
318 * 'qemu' : CHS QEMU (uses disk geometry)
319 * 'qem2' : current_size QEMU (uses current_size)
320 * 'win ' : current_size Hyper-V
321 * 'd2v ' : current_size Disk2vhd
322 * 'tap\0' : current_size XenServer
323 * 'CTXS' : current_size XenConverter
325 * The user can override the table values via drive options, however
326 * even with an override we will still use current_size for images
327 * that have CHS geometry of the maximum size.
329 use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
330 !!strncmp(footer->creator_app, "qem2", 4) &&
331 !!strncmp(footer->creator_app, "d2v ", 4) &&
332 !!strncmp(footer->creator_app, "CTXS", 4) &&
333 !!memcmp(footer->creator_app, "tap", 4)) || s->force_use_chs;
335 if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
336 bs->total_sectors = be64_to_cpu(footer->current_size) /
337 BDRV_SECTOR_SIZE;
340 /* Allow a maximum disk size of 2040 GiB */
341 if (bs->total_sectors > VHD_MAX_SECTORS) {
342 ret = -EFBIG;
343 goto fail;
346 if (disk_type == VHD_DYNAMIC) {
347 ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset),
348 &dyndisk_header, sizeof(dyndisk_header));
349 if (ret < 0) {
350 error_setg(errp, "Error reading dynamic VHD header");
351 goto fail;
354 if (strncmp(dyndisk_header.magic, "cxsparse", 8)) {
355 error_setg(errp, "Invalid header magic");
356 ret = -EINVAL;
357 goto fail;
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);
363 ret = -EINVAL;
364 goto fail;
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");
372 ret = -EINVAL;
373 goto fail;
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");
379 ret = -EINVAL;
380 goto fail;
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);
387 ret = -EINVAL;
388 goto fail;
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");
396 ret = -ENOMEM;
397 goto fail;
400 s->bat_offset = be64_to_cpu(dyndisk_header.table_offset);
402 ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable,
403 pagetable_size);
404 if (ret < 0) {
405 error_setg(errp, "Error reading pagetable");
406 goto fail;
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);
425 if (bs_size < 0) {
426 error_setg_errno(errp, -bs_size, "Unable to learn image size");
427 ret = bs_size;
428 goto fail;
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.");
433 ret = -EINVAL;
434 goto fail;
437 s->last_bitmap_offset = (int64_t) -1;
439 #ifdef CACHE
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;
444 #endif
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, errp);
452 if (ret < 0) {
453 error_free(s->migration_blocker);
454 goto fail;
457 qemu_co_mutex_init(&s->lock);
458 qemu_opts_del(opts);
460 return 0;
462 fail:
463 qemu_opts_del(opts);
464 qemu_vfree(s->pagetable);
465 #ifdef CACHE
466 g_free(s->pageentry_u8);
467 #endif
468 return ret;
471 static int vpc_reopen_prepare(BDRVReopenState *state,
472 BlockReopenQueue *queue, Error **errp)
474 return 0;
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
510 correctness. */
511 if (write && (s->last_bitmap_offset != bitmap_offset)) {
512 uint8_t bitmap[s->bitmap_size];
513 int r;
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);
518 if (r < 0) {
519 *err = r;
520 return -2;
524 return block_offset;
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)
535 int ret;
536 BDRVVPCState *s = bs->opaque;
537 int64_t offset = s->free_data_block_offset;
539 ret = bdrv_pwrite_sync(bs->file, offset, &s->footer, sizeof(s->footer));
540 if (ret < 0)
541 return ret;
543 return 0;
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;
556 int64_t bat_offset;
557 uint32_t index, bat_value;
558 int ret;
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)) {
563 return -EINVAL;
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,
574 s->bitmap_size);
575 if (ret < 0) {
576 return ret;
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);
582 if (ret < 0)
583 goto fail;
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);
589 if (ret < 0)
590 goto fail;
592 return get_image_offset(bs, offset, false, NULL);
594 fail:
595 s->free_data_block_offset -= (s->block_size + s->bitmap_size);
596 return ret;
599 static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
601 BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
603 if (be32_to_cpu(s->footer.type) != VHD_FIXED) {
604 bdi->cluster_size = s->block_size;
607 return 0;
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;
615 int ret;
616 int64_t image_offset;
617 int64_t n_bytes;
618 int64_t bytes_done = 0;
619 QEMUIOVector local_qiov;
621 if (be32_to_cpu(s->footer.type) == VHD_FIXED) {
622 return bdrv_co_preadv(bs->file, offset, bytes, qiov, 0);
625 qemu_co_mutex_lock(&s->lock);
626 qemu_iovec_init(&local_qiov, qiov->niov);
628 while (bytes > 0) {
629 image_offset = get_image_offset(bs, offset, false, NULL);
630 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
632 if (image_offset == -1) {
633 qemu_iovec_memset(qiov, bytes_done, 0, n_bytes);
634 } else {
635 qemu_iovec_reset(&local_qiov);
636 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
638 qemu_co_mutex_unlock(&s->lock);
639 ret = bdrv_co_preadv(bs->file, image_offset, n_bytes,
640 &local_qiov, 0);
641 qemu_co_mutex_lock(&s->lock);
642 if (ret < 0) {
643 goto fail;
647 bytes -= n_bytes;
648 offset += n_bytes;
649 bytes_done += n_bytes;
652 ret = 0;
653 fail:
654 qemu_iovec_destroy(&local_qiov);
655 qemu_co_mutex_unlock(&s->lock);
657 return ret;
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;
666 int64_t n_bytes;
667 int64_t bytes_done = 0;
668 int ret = 0;
669 QEMUIOVector local_qiov;
671 if (be32_to_cpu(s->footer.type) == VHD_FIXED) {
672 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, 0);
675 qemu_co_mutex_lock(&s->lock);
676 qemu_iovec_init(&local_qiov, qiov->niov);
678 while (bytes > 0) {
679 image_offset = get_image_offset(bs, offset, true, &ret);
680 if (image_offset == -2) {
681 /* Failed to write block bitmap: can't proceed with write */
682 goto fail;
684 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
686 if (image_offset == -1) {
687 image_offset = alloc_block(bs, offset);
688 if (image_offset < 0) {
689 ret = image_offset;
690 goto fail;
694 qemu_iovec_reset(&local_qiov);
695 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
697 qemu_co_mutex_unlock(&s->lock);
698 ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes,
699 &local_qiov, 0);
700 qemu_co_mutex_lock(&s->lock);
701 if (ret < 0) {
702 goto fail;
705 bytes -= n_bytes;
706 offset += n_bytes;
707 bytes_done += n_bytes;
710 ret = 0;
711 fail:
712 qemu_iovec_destroy(&local_qiov);
713 qemu_co_mutex_unlock(&s->lock);
715 return ret;
718 static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
719 bool want_zero,
720 int64_t offset, int64_t bytes,
721 int64_t *pnum, int64_t *map,
722 BlockDriverState **file)
724 BDRVVPCState *s = bs->opaque;
725 int64_t image_offset;
726 bool allocated;
727 int ret;
728 int64_t n;
730 if (be32_to_cpu(s->footer.type) == VHD_FIXED) {
731 *pnum = bytes;
732 *map = offset;
733 *file = bs->file->bs;
734 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE;
737 qemu_co_mutex_lock(&s->lock);
739 image_offset = get_image_offset(bs, offset, false, NULL);
740 allocated = (image_offset != -1);
741 *pnum = 0;
742 ret = BDRV_BLOCK_ZERO;
744 do {
745 /* All sectors in a block are contiguous (without using the bitmap) */
746 n = ROUND_UP(offset + 1, s->block_size) - offset;
747 n = MIN(n, bytes);
749 *pnum += n;
750 offset += n;
751 bytes -= n;
752 /* *pnum can't be greater than one block for allocated
753 * sectors since there is always a bitmap in between. */
754 if (allocated) {
755 *file = bs->file->bs;
756 *map = image_offset;
757 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
758 break;
760 if (bytes == 0) {
761 break;
763 image_offset = get_image_offset(bs, offset, false, NULL);
764 } while (image_offset == -1);
766 qemu_co_mutex_unlock(&s->lock);
767 return ret;
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
776 * may round it down.
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) {
790 *secs_per_cyl = 255;
791 *heads = 16;
792 cyls_times_heads = total_sectors / *secs_per_cyl;
793 } else {
794 *secs_per_cyl = 17;
795 cyls_times_heads = total_sectors / *secs_per_cyl;
796 *heads = DIV_ROUND_UP(cyls_times_heads, 1024);
798 if (*heads < 4) {
799 *heads = 4;
802 if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
803 *secs_per_cyl = 31;
804 *heads = 16;
805 cyls_times_heads = total_sectors / *secs_per_cyl;
808 if (cyls_times_heads >= (*heads * 1024)) {
809 *secs_per_cyl = 63;
810 *heads = 16;
811 cyls_times_heads = total_sectors / *secs_per_cyl;
815 *cyls = cyls_times_heads / *heads;
817 return 0;
820 static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
821 int64_t total_sectors)
823 VHDDynDiskHeader dyndisk_header;
824 uint8_t bat_sector[512];
825 size_t block_size, num_bat_entries;
826 int i;
827 int ret;
828 int64_t offset = 0;
830 /* Write the footer (twice: at the beginning and at the end) */
831 block_size = 0x200000;
832 num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
834 ret = blk_pwrite(blk, offset, footer, sizeof(*footer), 0);
835 if (ret < 0) {
836 goto fail;
839 offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
840 ret = blk_pwrite(blk, offset, footer, sizeof(*footer), 0);
841 if (ret < 0) {
842 goto fail;
845 /* Write the initial BAT */
846 offset = 3 * 512;
848 memset(bat_sector, 0xFF, 512);
849 for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
850 ret = blk_pwrite(blk, offset, bat_sector, 512, 0);
851 if (ret < 0) {
852 goto fail;
854 offset += 512;
857 /* Prepare the Dynamic Disk Header */
858 memset(&dyndisk_header, 0, sizeof(dyndisk_header));
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(
873 vpc_checksum(&dyndisk_header, sizeof(dyndisk_header)));
875 /* Write the header */
876 offset = 512;
878 ret = blk_pwrite(blk, offset, &dyndisk_header, sizeof(dyndisk_header), 0);
879 if (ret < 0) {
880 goto fail;
883 ret = 0;
884 fail:
885 return ret;
888 static int create_fixed_disk(BlockBackend *blk, VHDFooter *footer,
889 int64_t total_size, Error **errp)
891 int ret;
893 /* Add footer to total size */
894 total_size += sizeof(*footer);
896 ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
897 if (ret < 0) {
898 return ret;
901 ret = blk_pwrite(blk, total_size - sizeof(*footer),
902 footer, sizeof(*footer), 0);
903 if (ret < 0) {
904 error_setg_errno(errp, -ret, "Unable to write VHD header");
905 return ret;
908 return 0;
911 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
912 uint16_t *out_cyls,
913 uint8_t *out_heads,
914 uint8_t *out_secs_per_cyl,
915 int64_t *out_total_sectors,
916 Error **errp)
918 int64_t total_size = vpc_opts->size;
919 uint16_t cyls = 0;
920 uint8_t heads = 0;
921 uint8_t secs_per_cyl = 0;
922 int64_t total_sectors;
923 int i;
926 * Calculate matching total_size and geometry. Increase the number of
927 * sectors requested until we get enough (or fail). This ensures that
928 * qemu-img convert doesn't truncate images, but rather rounds up.
930 * If the image size can't be represented by a spec conformant CHS geometry,
931 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
932 * the image size from the VHD footer to calculate total_sectors.
934 if (vpc_opts->force_size) {
935 /* This will force the use of total_size for sector count, below */
936 cyls = VHD_CHS_MAX_C;
937 heads = VHD_CHS_MAX_H;
938 secs_per_cyl = VHD_CHS_MAX_S;
939 } else {
940 total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
941 for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
942 calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
946 if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
947 total_sectors = total_size / BDRV_SECTOR_SIZE;
948 /* Allow a maximum disk size of 2040 GiB */
949 if (total_sectors > VHD_MAX_SECTORS) {
950 error_setg(errp, "Disk size is too large, max size is 2040 GiB");
951 return -EFBIG;
953 } else {
954 total_sectors = (int64_t) cyls * heads * secs_per_cyl;
957 *out_total_sectors = total_sectors;
958 if (out_cyls) {
959 *out_cyls = cyls;
960 *out_heads = heads;
961 *out_secs_per_cyl = secs_per_cyl;
964 return 0;
967 static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
968 Error **errp)
970 BlockdevCreateOptionsVpc *vpc_opts;
971 BlockBackend *blk = NULL;
972 BlockDriverState *bs = NULL;
974 VHDFooter footer;
975 uint16_t cyls = 0;
976 uint8_t heads = 0;
977 uint8_t secs_per_cyl = 0;
978 int64_t total_sectors;
979 int64_t total_size;
980 int disk_type;
981 int ret = -EIO;
982 QemuUUID uuid;
984 assert(opts->driver == BLOCKDEV_DRIVER_VPC);
985 vpc_opts = &opts->u.vpc;
987 /* Validate options and set default values */
988 total_size = vpc_opts->size;
990 if (!vpc_opts->has_subformat) {
991 vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC;
993 switch (vpc_opts->subformat) {
994 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC:
995 disk_type = VHD_DYNAMIC;
996 break;
997 case BLOCKDEV_VPC_SUBFORMAT_FIXED:
998 disk_type = VHD_FIXED;
999 break;
1000 default:
1001 g_assert_not_reached();
1004 /* Create BlockBackend to write to the image */
1005 bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
1006 if (bs == NULL) {
1007 return -EIO;
1010 blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
1011 errp);
1012 if (!blk) {
1013 ret = -EPERM;
1014 goto out;
1016 blk_set_allow_write_beyond_eof(blk, true);
1018 /* Get geometry and check that it matches the image size*/
1019 ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl,
1020 &total_sectors, errp);
1021 if (ret < 0) {
1022 goto out;
1025 if (total_size != total_sectors * BDRV_SECTOR_SIZE) {
1026 error_setg(errp, "The requested image size cannot be represented in "
1027 "CHS geometry");
1028 error_append_hint(errp, "Try size=%llu or force-size=on (the "
1029 "latter makes the image incompatible with "
1030 "Virtual PC)",
1031 total_sectors * BDRV_SECTOR_SIZE);
1032 ret = -EINVAL;
1033 goto out;
1036 /* Prepare the Hard Disk Footer */
1037 memset(&footer, 0, sizeof(footer));
1039 memcpy(footer.creator, "conectix", 8);
1040 if (vpc_opts->force_size) {
1041 memcpy(footer.creator_app, "qem2", 4);
1042 } else {
1043 memcpy(footer.creator_app, "qemu", 4);
1045 memcpy(footer.creator_os, "Wi2k", 4);
1047 footer.features = cpu_to_be32(0x02);
1048 footer.version = cpu_to_be32(0x00010000);
1049 if (disk_type == VHD_DYNAMIC) {
1050 footer.data_offset = cpu_to_be64(sizeof(footer));
1051 } else {
1052 footer.data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
1054 footer.timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
1056 /* Version of Virtual PC 2007 */
1057 footer.major = cpu_to_be16(0x0005);
1058 footer.minor = cpu_to_be16(0x0003);
1059 footer.orig_size = cpu_to_be64(total_size);
1060 footer.current_size = cpu_to_be64(total_size);
1061 footer.cyls = cpu_to_be16(cyls);
1062 footer.heads = heads;
1063 footer.secs_per_cyl = secs_per_cyl;
1065 footer.type = cpu_to_be32(disk_type);
1067 qemu_uuid_generate(&uuid);
1068 footer.uuid = uuid;
1070 footer.checksum = cpu_to_be32(vpc_checksum(&footer, sizeof(footer)));
1072 if (disk_type == VHD_DYNAMIC) {
1073 ret = create_dynamic_disk(blk, &footer, total_sectors);
1074 if (ret < 0) {
1075 error_setg(errp, "Unable to create or write VHD header");
1077 } else {
1078 ret = create_fixed_disk(blk, &footer, total_size, errp);
1081 out:
1082 blk_unref(blk);
1083 bdrv_unref(bs);
1084 return ret;
1087 static int coroutine_fn vpc_co_create_opts(BlockDriver *drv,
1088 const char *filename,
1089 QemuOpts *opts,
1090 Error **errp)
1092 BlockdevCreateOptions *create_options = NULL;
1093 QDict *qdict;
1094 Visitor *v;
1095 BlockDriverState *bs = NULL;
1096 int ret;
1098 static const QDictRenames opt_renames[] = {
1099 { VPC_OPT_FORCE_SIZE, "force-size" },
1100 { NULL, NULL },
1103 /* Parse options and convert legacy syntax */
1104 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true);
1106 if (!qdict_rename_keys(qdict, opt_renames, errp)) {
1107 ret = -EINVAL;
1108 goto fail;
1111 /* Create and open the file (protocol layer) */
1112 ret = bdrv_create_file(filename, opts, errp);
1113 if (ret < 0) {
1114 goto fail;
1117 bs = bdrv_open(filename, NULL, NULL,
1118 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
1119 if (bs == NULL) {
1120 ret = -EIO;
1121 goto fail;
1124 /* Now get the QAPI type BlockdevCreateOptions */
1125 qdict_put_str(qdict, "driver", "vpc");
1126 qdict_put_str(qdict, "file", bs->node_name);
1128 v = qobject_input_visitor_new_flat_confused(qdict, errp);
1129 if (!v) {
1130 ret = -EINVAL;
1131 goto fail;
1134 visit_type_BlockdevCreateOptions(v, NULL, &create_options, errp);
1135 visit_free(v);
1136 if (!create_options) {
1137 ret = -EINVAL;
1138 goto fail;
1141 /* Silently round up size */
1142 assert(create_options->driver == BLOCKDEV_DRIVER_VPC);
1143 create_options->u.vpc.size =
1144 ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
1146 if (!create_options->u.vpc.force_size) {
1147 int64_t total_sectors;
1148 ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL,
1149 NULL, &total_sectors, errp);
1150 if (ret < 0) {
1151 goto fail;
1154 create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE;
1158 /* Create the vpc image (format layer) */
1159 ret = vpc_co_create(create_options, errp);
1161 fail:
1162 qobject_unref(qdict);
1163 bdrv_unref(bs);
1164 qapi_free_BlockdevCreateOptions(create_options);
1165 return ret;
1169 static int vpc_has_zero_init(BlockDriverState *bs)
1171 BDRVVPCState *s = bs->opaque;
1173 if (be32_to_cpu(s->footer.type) == VHD_FIXED) {
1174 return bdrv_has_zero_init(bs->file->bs);
1175 } else {
1176 return 1;
1180 static void vpc_close(BlockDriverState *bs)
1182 BDRVVPCState *s = bs->opaque;
1183 qemu_vfree(s->pagetable);
1184 #ifdef CACHE
1185 g_free(s->pageentry_u8);
1186 #endif
1188 migrate_del_blocker(s->migration_blocker);
1189 error_free(s->migration_blocker);
1192 static QemuOptsList vpc_create_opts = {
1193 .name = "vpc-create-opts",
1194 .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head),
1195 .desc = {
1197 .name = BLOCK_OPT_SIZE,
1198 .type = QEMU_OPT_SIZE,
1199 .help = "Virtual disk size"
1202 .name = BLOCK_OPT_SUBFMT,
1203 .type = QEMU_OPT_STRING,
1204 .help =
1205 "Type of virtual hard disk format. Supported formats are "
1206 "{dynamic (default) | fixed} "
1209 .name = VPC_OPT_FORCE_SIZE,
1210 .type = QEMU_OPT_BOOL,
1211 .help = "Force disk size calculation to use the actual size "
1212 "specified, rather than using the nearest CHS-based "
1213 "calculation"
1215 { /* end of list */ }
1219 static const char *const vpc_strong_runtime_opts[] = {
1220 VPC_OPT_SIZE_CALC,
1222 NULL
1225 static BlockDriver bdrv_vpc = {
1226 .format_name = "vpc",
1227 .instance_size = sizeof(BDRVVPCState),
1229 .bdrv_probe = vpc_probe,
1230 .bdrv_open = vpc_open,
1231 .bdrv_close = vpc_close,
1232 .bdrv_reopen_prepare = vpc_reopen_prepare,
1233 .bdrv_child_perm = bdrv_default_perms,
1234 .bdrv_co_create = vpc_co_create,
1235 .bdrv_co_create_opts = vpc_co_create_opts,
1237 .bdrv_co_preadv = vpc_co_preadv,
1238 .bdrv_co_pwritev = vpc_co_pwritev,
1239 .bdrv_co_block_status = vpc_co_block_status,
1241 .bdrv_get_info = vpc_get_info,
1243 .is_format = true,
1244 .create_opts = &vpc_create_opts,
1245 .bdrv_has_zero_init = vpc_has_zero_init,
1246 .strong_runtime_opts = vpc_strong_runtime_opts,
1249 static void bdrv_vpc_init(void)
1251 bdrv_register(&bdrv_vpc);
1254 block_init(bdrv_vpc_init);