target/arm/cpu64: Ensure kvm really supports aarch64=off
[qemu/ar7.git] / block / vpc.c
blobd4776ee8a5229ff43e8fb4fb6e0f38c4ec348770
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 HEADER_SIZE 512
44 //#define CACHE
46 enum vhd_type {
47 VHD_FIXED = 2,
48 VHD_DYNAMIC = 3,
49 VHD_DIFFERENCING = 4,
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" */
67 uint32_t features;
68 uint32_t version;
70 /* Offset of next header structure, 0xFFFFFFFF if none */
71 uint64_t data_offset;
73 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
74 uint32_t timestamp;
76 char creator_app[4]; /* e.g., "vpc " */
77 uint16_t major;
78 uint16_t minor;
79 char creator_os[4]; /* "Wi2k" */
81 uint64_t orig_size;
82 uint64_t current_size;
84 uint16_t cyls;
85 uint8_t heads;
86 uint8_t secs_per_cyl;
88 uint32_t type;
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") */
92 uint32_t checksum;
94 /* UUID used to identify a parent hard disk (backing file) */
95 QemuUUID uuid;
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;
109 uint32_t version;
110 uint32_t max_table_entries; /* 32bit/entry */
112 /* 2 MB by default, must be a power of two */
113 uint32_t block_size;
115 uint32_t checksum;
116 uint8_t parent_uuid[16];
117 uint32_t parent_timestamp;
118 uint32_t reserved;
120 /* Backing file name (in UTF-16) */
121 uint8_t parent_name[512];
123 struct {
124 uint32_t platform;
125 uint32_t data_space;
126 uint32_t data_length;
127 uint32_t reserved;
128 uint64_t data_offset;
129 } parent_locator[8];
130 } QEMU_PACKED VHDDynDiskHeader;
132 typedef struct BDRVVPCState {
133 CoMutex lock;
134 uint8_t footer_buf[HEADER_SIZE];
135 uint64_t free_data_block_offset;
136 int max_table_entries;
137 uint32_t *pagetable;
138 uint64_t bat_offset;
139 uint64_t last_bitmap_offset;
141 uint32_t block_size;
142 uint32_t bitmap_size;
143 bool force_use_chs;
144 bool force_use_sz;
146 #ifdef CACHE
147 uint8_t *pageentry_u8;
148 uint32_t *pageentry_u32;
149 uint16_t *pageentry_u16;
151 uint64_t last_bitmap;
152 #endif
154 Error *migration_blocker;
155 } BDRVVPCState;
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),
161 .desc = {
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)
177 uint32_t res = 0;
178 int i;
180 for (i = 0; i < size; i++)
181 res += buf[i];
183 return ~res;
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))
190 return 100;
191 return 0;
194 static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
195 Error **errp)
197 BDRVVPCState *s = bs->opaque;
198 const char *size_calc;
200 size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC);
202 if (!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;
208 } else {
209 error_setg(errp, "Invalid size calculation mode: '%s'", size_calc);
213 static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
214 Error **errp)
216 BDRVVPCState *s = bs->opaque;
217 int i;
218 VHDFooter *footer;
219 VHDDynDiskHeader *dyndisk_header;
220 QemuOpts *opts = NULL;
221 Error *local_err = NULL;
222 bool use_chs;
223 uint8_t buf[HEADER_SIZE];
224 uint32_t checksum;
225 uint64_t computed_size;
226 uint64_t pagetable_size;
227 int disk_type = VHD_DYNAMIC;
228 int ret;
229 int64_t bs_size;
231 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
232 false, errp);
233 if (!bs->file) {
234 return -EINVAL;
237 opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
238 qemu_opts_absorb_qdict(opts, options, &local_err);
239 if (local_err) {
240 error_propagate(errp, local_err);
241 ret = -EINVAL;
242 goto fail;
245 vpc_parse_options(bs, opts, &local_err);
246 if (local_err) {
247 error_propagate(errp, local_err);
248 ret = -EINVAL;
249 goto fail;
252 ret = bdrv_pread(bs->file, 0, s->footer_buf, HEADER_SIZE);
253 if (ret < 0) {
254 error_setg(errp, "Unable to read VHD header");
255 goto fail;
258 footer = (VHDFooter *) s->footer_buf;
259 if (strncmp(footer->creator, "conectix", 8)) {
260 int64_t offset = bdrv_getlength(bs->file->bs);
261 if (offset < 0) {
262 ret = offset;
263 error_setg(errp, "Invalid file size");
264 goto fail;
265 } else if (offset < HEADER_SIZE) {
266 ret = -EINVAL;
267 error_setg(errp, "File too small for a VHD header");
268 goto fail;
271 /* If a fixed disk, the footer is found only at the end of the file */
272 ret = bdrv_pread(bs->file, offset-HEADER_SIZE, s->footer_buf,
273 HEADER_SIZE);
274 if (ret < 0) {
275 goto fail;
277 if (strncmp(footer->creator, "conectix", 8)) {
278 error_setg(errp, "invalid VPC image");
279 ret = -EINVAL;
280 goto fail;
282 disk_type = VHD_FIXED;
285 checksum = be32_to_cpu(footer->checksum);
286 footer->checksum = 0;
287 if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum) {
288 error_setg(errp, "Incorrect header checksum");
289 ret = -EINVAL;
290 goto fail;
293 /* Write 'checksum' back to footer, or else will leave it with zero. */
294 footer->checksum = cpu_to_be32(checksum);
296 /* The visible size of a image in Virtual PC depends on the geometry
297 rather than on the size stored in the footer (the size in the footer
298 is too large usually) */
299 bs->total_sectors = (int64_t)
300 be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
302 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
303 * VHD image sizes differently. VPC will rely on CHS geometry,
304 * while Hyper-V and disk2vhd use the size specified in the footer.
306 * We use a couple of approaches to try and determine the correct method:
307 * look at the Creator App field, and look for images that have CHS
308 * geometry that is the maximum value.
310 * If the CHS geometry is the maximum CHS geometry, then we assume that
311 * the size is the footer->current_size to avoid truncation. Otherwise,
312 * we follow the table based on footer->creator_app:
314 * Known creator apps:
315 * 'vpc ' : CHS Virtual PC (uses disk geometry)
316 * 'qemu' : CHS QEMU (uses disk geometry)
317 * 'qem2' : current_size QEMU (uses current_size)
318 * 'win ' : current_size Hyper-V
319 * 'd2v ' : current_size Disk2vhd
320 * 'tap\0' : current_size XenServer
321 * 'CTXS' : current_size XenConverter
323 * The user can override the table values via drive options, however
324 * even with an override we will still use current_size for images
325 * that have CHS geometry of the maximum size.
327 use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
328 !!strncmp(footer->creator_app, "qem2", 4) &&
329 !!strncmp(footer->creator_app, "d2v ", 4) &&
330 !!strncmp(footer->creator_app, "CTXS", 4) &&
331 !!memcmp(footer->creator_app, "tap", 4)) || s->force_use_chs;
333 if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
334 bs->total_sectors = be64_to_cpu(footer->current_size) /
335 BDRV_SECTOR_SIZE;
338 /* Allow a maximum disk size of 2040 GiB */
339 if (bs->total_sectors > VHD_MAX_SECTORS) {
340 ret = -EFBIG;
341 goto fail;
344 if (disk_type == VHD_DYNAMIC) {
345 ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset), buf,
346 HEADER_SIZE);
347 if (ret < 0) {
348 error_setg(errp, "Error reading dynamic VHD header");
349 goto fail;
352 dyndisk_header = (VHDDynDiskHeader *) buf;
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, &local_err);
452 if (local_err) {
453 error_propagate(errp, local_err);
454 error_free(s->migration_blocker);
455 goto fail;
458 qemu_co_mutex_init(&s->lock);
459 qemu_opts_del(opts);
461 return 0;
463 fail:
464 qemu_opts_del(opts);
465 qemu_vfree(s->pagetable);
466 #ifdef CACHE
467 g_free(s->pageentry_u8);
468 #endif
469 return ret;
472 static int vpc_reopen_prepare(BDRVReopenState *state,
473 BlockReopenQueue *queue, Error **errp)
475 return 0;
479 * Returns the absolute byte offset of the given sector in the image file.
480 * If the sector is not allocated, -1 is returned instead.
481 * If an error occurred trying to write an updated block bitmap back to
482 * the file, -2 is returned, and the error value is written to *err.
483 * This can only happen for a write operation.
485 * The parameter write must be 1 if the offset will be used for a write
486 * operation (the block bitmaps is updated then), 0 otherwise.
487 * If write is true then err must not be NULL.
489 static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
490 bool write, int *err)
492 BDRVVPCState *s = bs->opaque;
493 uint64_t bitmap_offset, block_offset;
494 uint32_t pagetable_index, offset_in_block;
496 assert(!(write && err == NULL));
498 pagetable_index = offset / s->block_size;
499 offset_in_block = offset % s->block_size;
501 if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)
502 return -1; /* not allocated */
504 bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
505 block_offset = bitmap_offset + s->bitmap_size + offset_in_block;
507 /* We must ensure that we don't write to any sectors which are marked as
508 unused in the bitmap. We get away with setting all bits in the block
509 bitmap each time we write to a new block. This might cause Virtual PC to
510 miss sparse read optimization, but it's not a problem in terms of
511 correctness. */
512 if (write && (s->last_bitmap_offset != bitmap_offset)) {
513 uint8_t bitmap[s->bitmap_size];
514 int r;
516 s->last_bitmap_offset = bitmap_offset;
517 memset(bitmap, 0xff, s->bitmap_size);
518 r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
519 if (r < 0) {
520 *err = r;
521 return -2;
525 return block_offset;
529 * Writes the footer to the end of the image file. This is needed when the
530 * file grows as it overwrites the old footer
532 * Returns 0 on success and < 0 on error
534 static int rewrite_footer(BlockDriverState* bs)
536 int ret;
537 BDRVVPCState *s = bs->opaque;
538 int64_t offset = s->free_data_block_offset;
540 ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE);
541 if (ret < 0)
542 return ret;
544 return 0;
548 * Allocates a new block. This involves writing a new footer and updating
549 * the Block Allocation Table to use the space at the old end of the image
550 * file (overwriting the old footer)
552 * Returns the sectors' offset in the image file on success and < 0 on error
554 static int64_t alloc_block(BlockDriverState* bs, int64_t offset)
556 BDRVVPCState *s = bs->opaque;
557 int64_t bat_offset;
558 uint32_t index, bat_value;
559 int ret;
560 uint8_t bitmap[s->bitmap_size];
562 /* Check if sector_num is valid */
563 if ((offset < 0) || (offset > bs->total_sectors * BDRV_SECTOR_SIZE)) {
564 return -EINVAL;
567 /* Write entry into in-memory BAT */
568 index = offset / s->block_size;
569 assert(s->pagetable[index] == 0xFFFFFFFF);
570 s->pagetable[index] = s->free_data_block_offset / 512;
572 /* Initialize the block's bitmap */
573 memset(bitmap, 0xff, s->bitmap_size);
574 ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
575 s->bitmap_size);
576 if (ret < 0) {
577 return ret;
580 /* Write new footer (the old one will be overwritten) */
581 s->free_data_block_offset += s->block_size + s->bitmap_size;
582 ret = rewrite_footer(bs);
583 if (ret < 0)
584 goto fail;
586 /* Write BAT entry to disk */
587 bat_offset = s->bat_offset + (4 * index);
588 bat_value = cpu_to_be32(s->pagetable[index]);
589 ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4);
590 if (ret < 0)
591 goto fail;
593 return get_image_offset(bs, offset, false, NULL);
595 fail:
596 s->free_data_block_offset -= (s->block_size + s->bitmap_size);
597 return ret;
600 static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
602 BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
603 VHDFooter *footer = (VHDFooter *) s->footer_buf;
605 if (be32_to_cpu(footer->type) != VHD_FIXED) {
606 bdi->cluster_size = s->block_size;
609 bdi->unallocated_blocks_are_zero = true;
610 return 0;
613 static int coroutine_fn
614 vpc_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
615 QEMUIOVector *qiov, int flags)
617 BDRVVPCState *s = bs->opaque;
618 int ret;
619 int64_t image_offset;
620 int64_t n_bytes;
621 int64_t bytes_done = 0;
622 VHDFooter *footer = (VHDFooter *) s->footer_buf;
623 QEMUIOVector local_qiov;
625 if (be32_to_cpu(footer->type) == VHD_FIXED) {
626 return bdrv_co_preadv(bs->file, offset, bytes, qiov, 0);
629 qemu_co_mutex_lock(&s->lock);
630 qemu_iovec_init(&local_qiov, qiov->niov);
632 while (bytes > 0) {
633 image_offset = get_image_offset(bs, offset, false, NULL);
634 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
636 if (image_offset == -1) {
637 qemu_iovec_memset(qiov, bytes_done, 0, n_bytes);
638 } else {
639 qemu_iovec_reset(&local_qiov);
640 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
642 qemu_co_mutex_unlock(&s->lock);
643 ret = bdrv_co_preadv(bs->file, image_offset, n_bytes,
644 &local_qiov, 0);
645 qemu_co_mutex_lock(&s->lock);
646 if (ret < 0) {
647 goto fail;
651 bytes -= n_bytes;
652 offset += n_bytes;
653 bytes_done += n_bytes;
656 ret = 0;
657 fail:
658 qemu_iovec_destroy(&local_qiov);
659 qemu_co_mutex_unlock(&s->lock);
661 return ret;
664 static int coroutine_fn
665 vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
666 QEMUIOVector *qiov, int flags)
668 BDRVVPCState *s = bs->opaque;
669 int64_t image_offset;
670 int64_t n_bytes;
671 int64_t bytes_done = 0;
672 int ret = 0;
673 VHDFooter *footer = (VHDFooter *) s->footer_buf;
674 QEMUIOVector local_qiov;
676 if (be32_to_cpu(footer->type) == VHD_FIXED) {
677 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, 0);
680 qemu_co_mutex_lock(&s->lock);
681 qemu_iovec_init(&local_qiov, qiov->niov);
683 while (bytes > 0) {
684 image_offset = get_image_offset(bs, offset, true, &ret);
685 if (image_offset == -2) {
686 /* Failed to write block bitmap: can't proceed with write */
687 goto fail;
689 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
691 if (image_offset == -1) {
692 image_offset = alloc_block(bs, offset);
693 if (image_offset < 0) {
694 ret = image_offset;
695 goto fail;
699 qemu_iovec_reset(&local_qiov);
700 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
702 qemu_co_mutex_unlock(&s->lock);
703 ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes,
704 &local_qiov, 0);
705 qemu_co_mutex_lock(&s->lock);
706 if (ret < 0) {
707 goto fail;
710 bytes -= n_bytes;
711 offset += n_bytes;
712 bytes_done += n_bytes;
715 ret = 0;
716 fail:
717 qemu_iovec_destroy(&local_qiov);
718 qemu_co_mutex_unlock(&s->lock);
720 return ret;
723 static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
724 bool want_zero,
725 int64_t offset, int64_t bytes,
726 int64_t *pnum, int64_t *map,
727 BlockDriverState **file)
729 BDRVVPCState *s = bs->opaque;
730 VHDFooter *footer = (VHDFooter*) s->footer_buf;
731 int64_t image_offset;
732 bool allocated;
733 int ret;
734 int64_t n;
736 if (be32_to_cpu(footer->type) == VHD_FIXED) {
737 *pnum = bytes;
738 *map = offset;
739 *file = bs->file->bs;
740 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
743 qemu_co_mutex_lock(&s->lock);
745 image_offset = get_image_offset(bs, offset, false, NULL);
746 allocated = (image_offset != -1);
747 *pnum = 0;
748 ret = 0;
750 do {
751 /* All sectors in a block are contiguous (without using the bitmap) */
752 n = ROUND_UP(offset + 1, s->block_size) - offset;
753 n = MIN(n, bytes);
755 *pnum += n;
756 offset += n;
757 bytes -= n;
758 /* *pnum can't be greater than one block for allocated
759 * sectors since there is always a bitmap in between. */
760 if (allocated) {
761 *file = bs->file->bs;
762 *map = image_offset;
763 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
764 break;
766 if (bytes == 0) {
767 break;
769 image_offset = get_image_offset(bs, offset, false, NULL);
770 } while (image_offset == -1);
772 qemu_co_mutex_unlock(&s->lock);
773 return ret;
777 * Calculates the number of cylinders, heads and sectors per cylinder
778 * based on a given number of sectors. This is the algorithm described
779 * in the VHD specification.
781 * Note that the geometry doesn't always exactly match total_sectors but
782 * may round it down.
784 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
785 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
786 * and instead allow up to 255 heads.
788 static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
789 uint8_t* heads, uint8_t* secs_per_cyl)
791 uint32_t cyls_times_heads;
793 total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY);
795 if (total_sectors >= 65535LL * 16 * 63) {
796 *secs_per_cyl = 255;
797 *heads = 16;
798 cyls_times_heads = total_sectors / *secs_per_cyl;
799 } else {
800 *secs_per_cyl = 17;
801 cyls_times_heads = total_sectors / *secs_per_cyl;
802 *heads = DIV_ROUND_UP(cyls_times_heads, 1024);
804 if (*heads < 4) {
805 *heads = 4;
808 if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
809 *secs_per_cyl = 31;
810 *heads = 16;
811 cyls_times_heads = total_sectors / *secs_per_cyl;
814 if (cyls_times_heads >= (*heads * 1024)) {
815 *secs_per_cyl = 63;
816 *heads = 16;
817 cyls_times_heads = total_sectors / *secs_per_cyl;
821 *cyls = cyls_times_heads / *heads;
823 return 0;
826 static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf,
827 int64_t total_sectors)
829 VHDDynDiskHeader *dyndisk_header =
830 (VHDDynDiskHeader *) buf;
831 size_t block_size, num_bat_entries;
832 int i;
833 int ret;
834 int64_t offset = 0;
836 /* Write the footer (twice: at the beginning and at the end) */
837 block_size = 0x200000;
838 num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512);
840 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
841 if (ret < 0) {
842 goto fail;
845 offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
846 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
847 if (ret < 0) {
848 goto fail;
851 /* Write the initial BAT */
852 offset = 3 * 512;
854 memset(buf, 0xFF, 512);
855 for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
856 ret = blk_pwrite(blk, offset, buf, 512, 0);
857 if (ret < 0) {
858 goto fail;
860 offset += 512;
863 /* Prepare the Dynamic Disk Header */
864 memset(buf, 0, 1024);
866 memcpy(dyndisk_header->magic, "cxsparse", 8);
869 * Note: The spec is actually wrong here for data_offset, it says
870 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
872 dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
873 dyndisk_header->table_offset = cpu_to_be64(3 * 512);
874 dyndisk_header->version = cpu_to_be32(0x00010000);
875 dyndisk_header->block_size = cpu_to_be32(block_size);
876 dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries);
878 dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024));
880 /* Write the header */
881 offset = 512;
883 ret = blk_pwrite(blk, offset, buf, 1024, 0);
884 if (ret < 0) {
885 goto fail;
888 fail:
889 return ret;
892 static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
893 int64_t total_size, Error **errp)
895 int ret;
897 /* Add footer to total size */
898 total_size += HEADER_SIZE;
900 ret = blk_truncate(blk, total_size, PREALLOC_MODE_OFF, errp);
901 if (ret < 0) {
902 return ret;
905 ret = blk_pwrite(blk, total_size - HEADER_SIZE, buf, HEADER_SIZE, 0);
906 if (ret < 0) {
907 error_setg_errno(errp, -ret, "Unable to write VHD header");
908 return ret;
911 return ret;
914 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
915 uint16_t *out_cyls,
916 uint8_t *out_heads,
917 uint8_t *out_secs_per_cyl,
918 int64_t *out_total_sectors,
919 Error **errp)
921 int64_t total_size = vpc_opts->size;
922 uint16_t cyls = 0;
923 uint8_t heads = 0;
924 uint8_t secs_per_cyl = 0;
925 int64_t total_sectors;
926 int i;
929 * Calculate matching total_size and geometry. Increase the number of
930 * sectors requested until we get enough (or fail). This ensures that
931 * qemu-img convert doesn't truncate images, but rather rounds up.
933 * If the image size can't be represented by a spec conformant CHS geometry,
934 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
935 * the image size from the VHD footer to calculate total_sectors.
937 if (vpc_opts->force_size) {
938 /* This will force the use of total_size for sector count, below */
939 cyls = VHD_CHS_MAX_C;
940 heads = VHD_CHS_MAX_H;
941 secs_per_cyl = VHD_CHS_MAX_S;
942 } else {
943 total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
944 for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
945 calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
949 if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
950 total_sectors = total_size / BDRV_SECTOR_SIZE;
951 /* Allow a maximum disk size of 2040 GiB */
952 if (total_sectors > VHD_MAX_SECTORS) {
953 error_setg(errp, "Disk size is too large, max size is 2040 GiB");
954 return -EFBIG;
956 } else {
957 total_sectors = (int64_t) cyls * heads * secs_per_cyl;
960 *out_total_sectors = total_sectors;
961 if (out_cyls) {
962 *out_cyls = cyls;
963 *out_heads = heads;
964 *out_secs_per_cyl = secs_per_cyl;
967 return 0;
970 static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
971 Error **errp)
973 BlockdevCreateOptionsVpc *vpc_opts;
974 BlockBackend *blk = NULL;
975 BlockDriverState *bs = NULL;
977 uint8_t buf[1024];
978 VHDFooter *footer = (VHDFooter *) buf;
979 uint16_t cyls = 0;
980 uint8_t heads = 0;
981 uint8_t secs_per_cyl = 0;
982 int64_t total_sectors;
983 int64_t total_size;
984 int disk_type;
985 int ret = -EIO;
986 QemuUUID uuid;
988 assert(opts->driver == BLOCKDEV_DRIVER_VPC);
989 vpc_opts = &opts->u.vpc;
991 /* Validate options and set default values */
992 total_size = vpc_opts->size;
994 if (!vpc_opts->has_subformat) {
995 vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC;
997 switch (vpc_opts->subformat) {
998 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC:
999 disk_type = VHD_DYNAMIC;
1000 break;
1001 case BLOCKDEV_VPC_SUBFORMAT_FIXED:
1002 disk_type = VHD_FIXED;
1003 break;
1004 default:
1005 g_assert_not_reached();
1008 /* Create BlockBackend to write to the image */
1009 bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
1010 if (bs == NULL) {
1011 return -EIO;
1014 blk = blk_new(bdrv_get_aio_context(bs),
1015 BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
1016 ret = blk_insert_bs(blk, bs, errp);
1017 if (ret < 0) {
1018 goto out;
1020 blk_set_allow_write_beyond_eof(blk, true);
1022 /* Get geometry and check that it matches the image size*/
1023 ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl,
1024 &total_sectors, errp);
1025 if (ret < 0) {
1026 goto out;
1029 if (total_size != total_sectors * BDRV_SECTOR_SIZE) {
1030 error_setg(errp, "The requested image size cannot be represented in "
1031 "CHS geometry");
1032 error_append_hint(errp, "Try size=%llu or force-size=on (the "
1033 "latter makes the image incompatible with "
1034 "Virtual PC)",
1035 total_sectors * BDRV_SECTOR_SIZE);
1036 ret = -EINVAL;
1037 goto out;
1040 /* Prepare the Hard Disk Footer */
1041 memset(buf, 0, 1024);
1043 memcpy(footer->creator, "conectix", 8);
1044 if (vpc_opts->force_size) {
1045 memcpy(footer->creator_app, "qem2", 4);
1046 } else {
1047 memcpy(footer->creator_app, "qemu", 4);
1049 memcpy(footer->creator_os, "Wi2k", 4);
1051 footer->features = cpu_to_be32(0x02);
1052 footer->version = cpu_to_be32(0x00010000);
1053 if (disk_type == VHD_DYNAMIC) {
1054 footer->data_offset = cpu_to_be64(HEADER_SIZE);
1055 } else {
1056 footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
1058 footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
1060 /* Version of Virtual PC 2007 */
1061 footer->major = cpu_to_be16(0x0005);
1062 footer->minor = cpu_to_be16(0x0003);
1063 footer->orig_size = cpu_to_be64(total_size);
1064 footer->current_size = cpu_to_be64(total_size);
1065 footer->cyls = cpu_to_be16(cyls);
1066 footer->heads = heads;
1067 footer->secs_per_cyl = secs_per_cyl;
1069 footer->type = cpu_to_be32(disk_type);
1071 qemu_uuid_generate(&uuid);
1072 footer->uuid = uuid;
1074 footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE));
1076 if (disk_type == VHD_DYNAMIC) {
1077 ret = create_dynamic_disk(blk, buf, total_sectors);
1078 if (ret < 0) {
1079 error_setg(errp, "Unable to create or write VHD header");
1081 } else {
1082 ret = create_fixed_disk(blk, buf, total_size, errp);
1085 out:
1086 blk_unref(blk);
1087 bdrv_unref(bs);
1088 return ret;
1091 static int coroutine_fn vpc_co_create_opts(const char *filename,
1092 QemuOpts *opts, Error **errp)
1094 BlockdevCreateOptions *create_options = NULL;
1095 QDict *qdict;
1096 Visitor *v;
1097 BlockDriverState *bs = NULL;
1098 Error *local_err = NULL;
1099 int ret;
1101 static const QDictRenames opt_renames[] = {
1102 { VPC_OPT_FORCE_SIZE, "force-size" },
1103 { NULL, NULL },
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)) {
1110 ret = -EINVAL;
1111 goto fail;
1114 /* Create and open the file (protocol layer) */
1115 ret = bdrv_create_file(filename, opts, &local_err);
1116 if (ret < 0) {
1117 error_propagate(errp, local_err);
1118 goto fail;
1121 bs = bdrv_open(filename, NULL, NULL,
1122 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
1123 if (bs == NULL) {
1124 ret = -EIO;
1125 goto fail;
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);
1133 if (!v) {
1134 ret = -EINVAL;
1135 goto fail;
1138 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
1139 visit_free(v);
1141 if (local_err) {
1142 error_propagate(errp, local_err);
1143 ret = -EINVAL;
1144 goto fail;
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);
1156 if (ret < 0) {
1157 goto fail;
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);
1167 fail:
1168 qobject_unref(qdict);
1169 bdrv_unref(bs);
1170 qapi_free_BlockdevCreateOptions(create_options);
1171 return ret;
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);
1182 } else {
1183 return 1;
1187 static void vpc_close(BlockDriverState *bs)
1189 BDRVVPCState *s = bs->opaque;
1190 qemu_vfree(s->pagetable);
1191 #ifdef CACHE
1192 g_free(s->pageentry_u8);
1193 #endif
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),
1202 .desc = {
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,
1211 .help =
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 "
1220 "calculation"
1222 { /* end of list */ }
1226 static const char *const vpc_strong_runtime_opts[] = {
1227 VPC_OPT_SIZE_CALC,
1229 NULL
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_format_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,
1250 .create_opts = &vpc_create_opts,
1251 .bdrv_has_zero_init = vpc_has_zero_init,
1252 .strong_runtime_opts = vpc_strong_runtime_opts,
1255 static void bdrv_vpc_init(void)
1257 bdrv_register(&bdrv_vpc);
1260 block_init(bdrv_vpc_init);