jcs.org
qemu with hax to log dma reads & writes
jcs.org/2018/11/12/vfio
1/*
2 * Block driver for Connectix / Microsoft Virtual PC images
3 *
4 * Copyright (c) 2005 Alex Beregszaszi
5 * Copyright (c) 2009 Kevin Wolf <kwolf@suse.de>
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
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.
24 */
25
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"
39
40/**************************************************************/
41
42#define HEADER_SIZE 512
43
44//#define CACHE
45
46enum vhd_type {
47 VHD_FIXED = 2,
48 VHD_DYNAMIC = 3,
49 VHD_DIFFERENCING = 4,
50};
51
52/* Seconds since Jan 1, 2000 0:00:00 (UTC) */
53#define VHD_TIMESTAMP_BASE 946684800
54
55#define VHD_CHS_MAX_C 65535LL
56#define VHD_CHS_MAX_H 16
57#define VHD_CHS_MAX_S 255
58
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)
61
62#define VPC_OPT_FORCE_SIZE "force_size"
63
64/* always big-endian */
65typedef struct vhd_footer {
66 char creator[8]; /* "conectix" */
67 uint32_t features;
68 uint32_t version;
69
70 /* Offset of next header structure, 0xFFFFFFFF if none */
71 uint64_t data_offset;
72
73 /* Seconds since Jan 1, 2000 0:00:00 (UTC) */
74 uint32_t timestamp;
75
76 char creator_app[4]; /* e.g., "vpc " */
77 uint16_t major;
78 uint16_t minor;
79 char creator_os[4]; /* "Wi2k" */
80
81 uint64_t orig_size;
82 uint64_t current_size;
83
84 uint16_t cyls;
85 uint8_t heads;
86 uint8_t secs_per_cyl;
87
88 uint32_t type;
89
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;
93
94 /* UUID used to identify a parent hard disk (backing file) */
95 QemuUUID uuid;
96
97 uint8_t in_saved_state;
98} QEMU_PACKED VHDFooter;
99
100typedef struct vhd_dyndisk_header {
101 char magic[8]; /* "cxsparse" */
102
103 /* Offset of next header structure, 0xFFFFFFFF if none */
104 uint64_t data_offset;
105
106 /* Offset of the Block Allocation Table (BAT) */
107 uint64_t table_offset;
108
109 uint32_t version;
110 uint32_t max_table_entries; /* 32bit/entry */
111
112 /* 2 MB by default, must be a power of two */
113 uint32_t block_size;
114
115 uint32_t checksum;
116 uint8_t parent_uuid[16];
117 uint32_t parent_timestamp;
118 uint32_t reserved;
119
120 /* Backing file name (in UTF-16) */
121 uint8_t parent_name[512];
122
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;
131
132typedef 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;
140
141 uint32_t block_size;
142 uint32_t bitmap_size;
143 bool force_use_chs;
144 bool force_use_sz;
145
146#ifdef CACHE
147 uint8_t *pageentry_u8;
148 uint32_t *pageentry_u32;
149 uint16_t *pageentry_u16;
150
151 uint64_t last_bitmap;
152#endif
153
154 Error *migration_blocker;
155} BDRVVPCState;
156
157#define VPC_OPT_SIZE_CALC "force_size_calc"
158static QemuOptsList vpc_runtime_opts = {
159 .name = "vpc-runtime-opts",
160 .head = QTAILQ_HEAD_INITIALIZER(vpc_runtime_opts.head),
161 .desc = {
162 {
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}"
168 },
169 { /* end of list */ }
170 }
171};
172
173static QemuOptsList vpc_create_opts;
174
175static uint32_t vpc_checksum(uint8_t* buf, size_t size)
176{
177 uint32_t res = 0;
178 int i;
179
180 for (i = 0; i < size; i++)
181 res += buf[i];
182
183 return ~res;
184}
185
186
187static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
188{
189 if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
190 return 100;
191 return 0;
192}
193
194static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
195 Error **errp)
196{
197 BDRVVPCState *s = bs->opaque;
198 const char *size_calc;
199
200 size_calc = qemu_opt_get(opts, VPC_OPT_SIZE_CALC);
201
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);
210 }
211}
212
213static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
214 Error **errp)
215{
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;
230
231 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
232 BDRV_CHILD_IMAGE, false, errp);
233 if (!bs->file) {
234 return -EINVAL;
235 }
236
237 opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
238 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
239 ret = -EINVAL;
240 goto fail;
241 }
242
243 vpc_parse_options(bs, opts, &local_err);
244 if (local_err) {
245 error_propagate(errp, local_err);
246 ret = -EINVAL;
247 goto fail;
248 }
249
250 ret = bdrv_pread(bs->file, 0, s->footer_buf, HEADER_SIZE);
251 if (ret < 0) {
252 error_setg(errp, "Unable to read VHD header");
253 goto fail;
254 }
255
256 footer = (VHDFooter *) s->footer_buf;
257 if (strncmp(footer->creator, "conectix", 8)) {
258 int64_t offset = bdrv_getlength(bs->file->bs);
259 if (offset < 0) {
260 ret = offset;
261 error_setg(errp, "Invalid file size");
262 goto fail;
263 } else if (offset < HEADER_SIZE) {
264 ret = -EINVAL;
265 error_setg(errp, "File too small for a VHD header");
266 goto fail;
267 }
268
269 /* If a fixed disk, the footer is found only at the end of the file */
270 ret = bdrv_pread(bs->file, offset-HEADER_SIZE, s->footer_buf,
271 HEADER_SIZE);
272 if (ret < 0) {
273 goto fail;
274 }
275 if (strncmp(footer->creator, "conectix", 8)) {
276 error_setg(errp, "invalid VPC image");
277 ret = -EINVAL;
278 goto fail;
279 }
280 disk_type = VHD_FIXED;
281 }
282
283 checksum = be32_to_cpu(footer->checksum);
284 footer->checksum = 0;
285 if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum) {
286 error_setg(errp, "Incorrect header checksum");
287 ret = -EINVAL;
288 goto fail;
289 }
290
291 /* Write 'checksum' back to footer, or else will leave it with zero. */
292 footer->checksum = cpu_to_be32(checksum);
293
294 /* The visible size of a image in Virtual PC depends on the geometry
295 rather than on the size stored in the footer (the size in the footer
296 is too large usually) */
297 bs->total_sectors = (int64_t)
298 be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
299
300 /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
301 * VHD image sizes differently. VPC will rely on CHS geometry,
302 * while Hyper-V and disk2vhd use the size specified in the footer.
303 *
304 * We use a couple of approaches to try and determine the correct method:
305 * look at the Creator App field, and look for images that have CHS
306 * geometry that is the maximum value.
307 *
308 * If the CHS geometry is the maximum CHS geometry, then we assume that
309 * the size is the footer->current_size to avoid truncation. Otherwise,
310 * we follow the table based on footer->creator_app:
311 *
312 * Known creator apps:
313 * 'vpc ' : CHS Virtual PC (uses disk geometry)
314 * 'qemu' : CHS QEMU (uses disk geometry)
315 * 'qem2' : current_size QEMU (uses current_size)
316 * 'win ' : current_size Hyper-V
317 * 'd2v ' : current_size Disk2vhd
318 * 'tap\0' : current_size XenServer
319 * 'CTXS' : current_size XenConverter
320 *
321 * The user can override the table values via drive options, however
322 * even with an override we will still use current_size for images
323 * that have CHS geometry of the maximum size.
324 */
325 use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
326 !!strncmp(footer->creator_app, "qem2", 4) &&
327 !!strncmp(footer->creator_app, "d2v ", 4) &&
328 !!strncmp(footer->creator_app, "CTXS", 4) &&
329 !!memcmp(footer->creator_app, "tap", 4)) || s->force_use_chs;
330
331 if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
332 bs->total_sectors = be64_to_cpu(footer->current_size) /
333 BDRV_SECTOR_SIZE;
334 }
335
336 /* Allow a maximum disk size of 2040 GiB */
337 if (bs->total_sectors > VHD_MAX_SECTORS) {
338 ret = -EFBIG;
339 goto fail;
340 }
341
342 if (disk_type == VHD_DYNAMIC) {
343 ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset), buf,
344 HEADER_SIZE);
345 if (ret < 0) {
346 error_setg(errp, "Error reading dynamic VHD header");
347 goto fail;
348 }
349
350 dyndisk_header = (VHDDynDiskHeader *) buf;
351
352 if (strncmp(dyndisk_header->magic, "cxsparse", 8)) {
353 error_setg(errp, "Invalid header magic");
354 ret = -EINVAL;
355 goto fail;
356 }
357
358 s->block_size = be32_to_cpu(dyndisk_header->block_size);
359 if (!is_power_of_2(s->block_size) || s->block_size < BDRV_SECTOR_SIZE) {
360 error_setg(errp, "Invalid block size %" PRIu32, s->block_size);
361 ret = -EINVAL;
362 goto fail;
363 }
364 s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511;
365
366 s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries);
367
368 if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) {
369 error_setg(errp, "Too many blocks");
370 ret = -EINVAL;
371 goto fail;
372 }
373
374 computed_size = (uint64_t) s->max_table_entries * s->block_size;
375 if (computed_size < bs->total_sectors * 512) {
376 error_setg(errp, "Page table too small");
377 ret = -EINVAL;
378 goto fail;
379 }
380
381 if (s->max_table_entries > SIZE_MAX / 4 ||
382 s->max_table_entries > (int) INT_MAX / 4) {
383 error_setg(errp, "Max Table Entries too large (%" PRId32 ")",
384 s->max_table_entries);
385 ret = -EINVAL;
386 goto fail;
387 }
388
389 pagetable_size = (uint64_t) s->max_table_entries * 4;
390
391 s->pagetable = qemu_try_blockalign(bs->file->bs, pagetable_size);
392 if (s->pagetable == NULL) {
393 error_setg(errp, "Unable to allocate memory for page table");
394 ret = -ENOMEM;
395 goto fail;
396 }
397
398 s->bat_offset = be64_to_cpu(dyndisk_header->table_offset);
399
400 ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable,
401 pagetable_size);
402 if (ret < 0) {
403 error_setg(errp, "Error reading pagetable");
404 goto fail;
405 }
406
407 s->free_data_block_offset =
408 ROUND_UP(s->bat_offset + pagetable_size, 512);
409
410 for (i = 0; i < s->max_table_entries; i++) {
411 be32_to_cpus(&s->pagetable[i]);
412 if (s->pagetable[i] != 0xFFFFFFFF) {
413 int64_t next = (512 * (int64_t) s->pagetable[i]) +
414 s->bitmap_size + s->block_size;
415
416 if (next > s->free_data_block_offset) {
417 s->free_data_block_offset = next;
418 }
419 }
420 }
421
422 bs_size = bdrv_getlength(bs->file->bs);
423 if (bs_size < 0) {
424 error_setg_errno(errp, -bs_size, "Unable to learn image size");
425 ret = bs_size;
426 goto fail;
427 }
428 if (s->free_data_block_offset > bs_size) {
429 error_setg(errp, "block-vpc: free_data_block_offset points after "
430 "the end of file. The image has been truncated.");
431 ret = -EINVAL;
432 goto fail;
433 }
434
435 s->last_bitmap_offset = (int64_t) -1;
436
437#ifdef CACHE
438 s->pageentry_u8 = g_malloc(512);
439 s->pageentry_u32 = s->pageentry_u8;
440 s->pageentry_u16 = s->pageentry_u8;
441 s->last_pagetable = -1;
442#endif
443 }
444
445 /* Disable migration when VHD images are used */
446 error_setg(&s->migration_blocker, "The vpc format used by node '%s' "
447 "does not support live migration",
448 bdrv_get_device_or_node_name(bs));
449 ret = migrate_add_blocker(s->migration_blocker, errp);
450 if (ret < 0) {
451 error_free(s->migration_blocker);
452 goto fail;
453 }
454
455 qemu_co_mutex_init(&s->lock);
456 qemu_opts_del(opts);
457
458 return 0;
459
460fail:
461 qemu_opts_del(opts);
462 qemu_vfree(s->pagetable);
463#ifdef CACHE
464 g_free(s->pageentry_u8);
465#endif
466 return ret;
467}
468
469static int vpc_reopen_prepare(BDRVReopenState *state,
470 BlockReopenQueue *queue, Error **errp)
471{
472 return 0;
473}
474
475/*
476 * Returns the absolute byte offset of the given sector in the image file.
477 * If the sector is not allocated, -1 is returned instead.
478 * If an error occurred trying to write an updated block bitmap back to
479 * the file, -2 is returned, and the error value is written to *err.
480 * This can only happen for a write operation.
481 *
482 * The parameter write must be 1 if the offset will be used for a write
483 * operation (the block bitmaps is updated then), 0 otherwise.
484 * If write is true then err must not be NULL.
485 */
486static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
487 bool write, int *err)
488{
489 BDRVVPCState *s = bs->opaque;
490 uint64_t bitmap_offset, block_offset;
491 uint32_t pagetable_index, offset_in_block;
492
493 assert(!(write && err == NULL));
494
495 pagetable_index = offset / s->block_size;
496 offset_in_block = offset % s->block_size;
497
498 if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)
499 return -1; /* not allocated */
500
501 bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
502 block_offset = bitmap_offset + s->bitmap_size + offset_in_block;
503
504 /* We must ensure that we don't write to any sectors which are marked as
505 unused in the bitmap. We get away with setting all bits in the block
506 bitmap each time we write to a new block. This might cause Virtual PC to
507 miss sparse read optimization, but it's not a problem in terms of
508 correctness. */
509 if (write && (s->last_bitmap_offset != bitmap_offset)) {
510 uint8_t bitmap[s->bitmap_size];
511 int r;
512
513 s->last_bitmap_offset = bitmap_offset;
514 memset(bitmap, 0xff, s->bitmap_size);
515 r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
516 if (r < 0) {
517 *err = r;
518 return -2;
519 }
520 }
521
522 return block_offset;
523}
524
525/*
526 * Writes the footer to the end of the image file. This is needed when the
527 * file grows as it overwrites the old footer
528 *
529 * Returns 0 on success and < 0 on error
530 */
531static int rewrite_footer(BlockDriverState* bs)
532{
533 int ret;
534 BDRVVPCState *s = bs->opaque;
535 int64_t offset = s->free_data_block_offset;
536
537 ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE);
538 if (ret < 0)
539 return ret;
540
541 return 0;
542}
543
544/*
545 * Allocates a new block. This involves writing a new footer and updating
546 * the Block Allocation Table to use the space at the old end of the image
547 * file (overwriting the old footer)
548 *
549 * Returns the sectors' offset in the image file on success and < 0 on error
550 */
551static int64_t alloc_block(BlockDriverState* bs, int64_t offset)
552{
553 BDRVVPCState *s = bs->opaque;
554 int64_t bat_offset;
555 uint32_t index, bat_value;
556 int ret;
557 uint8_t bitmap[s->bitmap_size];
558
559 /* Check if sector_num is valid */
560 if ((offset < 0) || (offset > bs->total_sectors * BDRV_SECTOR_SIZE)) {
561 return -EINVAL;
562 }
563
564 /* Write entry into in-memory BAT */
565 index = offset / s->block_size;
566 assert(s->pagetable[index] == 0xFFFFFFFF);
567 s->pagetable[index] = s->free_data_block_offset / 512;
568
569 /* Initialize the block's bitmap */
570 memset(bitmap, 0xff, s->bitmap_size);
571 ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
572 s->bitmap_size);
573 if (ret < 0) {
574 return ret;
575 }
576
577 /* Write new footer (the old one will be overwritten) */
578 s->free_data_block_offset += s->block_size + s->bitmap_size;
579 ret = rewrite_footer(bs);
580 if (ret < 0)
581 goto fail;
582
583 /* Write BAT entry to disk */
584 bat_offset = s->bat_offset + (4 * index);
585 bat_value = cpu_to_be32(s->pagetable[index]);
586 ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4);
587 if (ret < 0)
588 goto fail;
589
590 return get_image_offset(bs, offset, false, NULL);
591
592fail:
593 s->free_data_block_offset -= (s->block_size + s->bitmap_size);
594 return ret;
595}
596
597static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
598{
599 BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
600 VHDFooter *footer = (VHDFooter *) s->footer_buf;
601
602 if (be32_to_cpu(footer->type) != VHD_FIXED) {
603 bdi->cluster_size = s->block_size;
604 }
605
606 return 0;
607}
608
609static int coroutine_fn
610vpc_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
611 QEMUIOVector *qiov, int flags)
612{
613 BDRVVPCState *s = bs->opaque;
614 int ret;
615 int64_t image_offset;
616 int64_t n_bytes;
617 int64_t bytes_done = 0;
618 VHDFooter *footer = (VHDFooter *) s->footer_buf;
619 QEMUIOVector local_qiov;
620
621 if (be32_to_cpu(footer->type) == VHD_FIXED) {
622 return bdrv_co_preadv(bs->file, offset, bytes, qiov, 0);
623 }
624
625 qemu_co_mutex_lock(&s->lock);
626 qemu_iovec_init(&local_qiov, qiov->niov);
627
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));
631
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);
637
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;
644 }
645 }
646
647 bytes -= n_bytes;
648 offset += n_bytes;
649 bytes_done += n_bytes;
650 }
651
652 ret = 0;
653fail:
654 qemu_iovec_destroy(&local_qiov);
655 qemu_co_mutex_unlock(&s->lock);
656
657 return ret;
658}
659
660static int coroutine_fn
661vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
662 QEMUIOVector *qiov, int flags)
663{
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 VHDFooter *footer = (VHDFooter *) s->footer_buf;
670 QEMUIOVector local_qiov;
671
672 if (be32_to_cpu(footer->type) == VHD_FIXED) {
673 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, 0);
674 }
675
676 qemu_co_mutex_lock(&s->lock);
677 qemu_iovec_init(&local_qiov, qiov->niov);
678
679 while (bytes > 0) {
680 image_offset = get_image_offset(bs, offset, true, &ret);
681 if (image_offset == -2) {
682 /* Failed to write block bitmap: can't proceed with write */
683 goto fail;
684 }
685 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
686
687 if (image_offset == -1) {
688 image_offset = alloc_block(bs, offset);
689 if (image_offset < 0) {
690 ret = image_offset;
691 goto fail;
692 }
693 }
694
695 qemu_iovec_reset(&local_qiov);
696 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
697
698 qemu_co_mutex_unlock(&s->lock);
699 ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes,
700 &local_qiov, 0);
701 qemu_co_mutex_lock(&s->lock);
702 if (ret < 0) {
703 goto fail;
704 }
705
706 bytes -= n_bytes;
707 offset += n_bytes;
708 bytes_done += n_bytes;
709 }
710
711 ret = 0;
712fail:
713 qemu_iovec_destroy(&local_qiov);
714 qemu_co_mutex_unlock(&s->lock);
715
716 return ret;
717}
718
719static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
720 bool want_zero,
721 int64_t offset, int64_t bytes,
722 int64_t *pnum, int64_t *map,
723 BlockDriverState **file)
724{
725 BDRVVPCState *s = bs->opaque;
726 VHDFooter *footer = (VHDFooter*) s->footer_buf;
727 int64_t image_offset;
728 bool allocated;
729 int ret;
730 int64_t n;
731
732 if (be32_to_cpu(footer->type) == VHD_FIXED) {
733 *pnum = bytes;
734 *map = offset;
735 *file = bs->file->bs;
736 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE;
737 }
738
739 qemu_co_mutex_lock(&s->lock);
740
741 image_offset = get_image_offset(bs, offset, false, NULL);
742 allocated = (image_offset != -1);
743 *pnum = 0;
744 ret = BDRV_BLOCK_ZERO;
745
746 do {
747 /* All sectors in a block are contiguous (without using the bitmap) */
748 n = ROUND_UP(offset + 1, s->block_size) - offset;
749 n = MIN(n, bytes);
750
751 *pnum += n;
752 offset += n;
753 bytes -= n;
754 /* *pnum can't be greater than one block for allocated
755 * sectors since there is always a bitmap in between. */
756 if (allocated) {
757 *file = bs->file->bs;
758 *map = image_offset;
759 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
760 break;
761 }
762 if (bytes == 0) {
763 break;
764 }
765 image_offset = get_image_offset(bs, offset, false, NULL);
766 } while (image_offset == -1);
767
768 qemu_co_mutex_unlock(&s->lock);
769 return ret;
770}
771
772/*
773 * Calculates the number of cylinders, heads and sectors per cylinder
774 * based on a given number of sectors. This is the algorithm described
775 * in the VHD specification.
776 *
777 * Note that the geometry doesn't always exactly match total_sectors but
778 * may round it down.
779 *
780 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
781 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
782 * and instead allow up to 255 heads.
783 */
784static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
785 uint8_t* heads, uint8_t* secs_per_cyl)
786{
787 uint32_t cyls_times_heads;
788
789 total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY);
790
791 if (total_sectors >= 65535LL * 16 * 63) {
792 *secs_per_cyl = 255;
793 *heads = 16;
794 cyls_times_heads = total_sectors / *secs_per_cyl;
795 } else {
796 *secs_per_cyl = 17;
797 cyls_times_heads = total_sectors / *secs_per_cyl;
798 *heads = DIV_ROUND_UP(cyls_times_heads, 1024);
799
800 if (*heads < 4) {
801 *heads = 4;
802 }
803
804 if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
805 *secs_per_cyl = 31;
806 *heads = 16;
807 cyls_times_heads = total_sectors / *secs_per_cyl;
808 }
809
810 if (cyls_times_heads >= (*heads * 1024)) {
811 *secs_per_cyl = 63;
812 *heads = 16;
813 cyls_times_heads = total_sectors / *secs_per_cyl;
814 }
815 }
816
817 *cyls = cyls_times_heads / *heads;
818
819 return 0;
820}
821
822static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf,
823 int64_t total_sectors)
824{
825 VHDDynDiskHeader *dyndisk_header =
826 (VHDDynDiskHeader *) buf;
827 size_t block_size, num_bat_entries;
828 int i;
829 int ret;
830 int64_t offset = 0;
831
832 /* Write the footer (twice: at the beginning and at the end) */
833 block_size = 0x200000;
834 num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
835
836 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
837 if (ret < 0) {
838 goto fail;
839 }
840
841 offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
842 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
843 if (ret < 0) {
844 goto fail;
845 }
846
847 /* Write the initial BAT */
848 offset = 3 * 512;
849
850 memset(buf, 0xFF, 512);
851 for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
852 ret = blk_pwrite(blk, offset, buf, 512, 0);
853 if (ret < 0) {
854 goto fail;
855 }
856 offset += 512;
857 }
858
859 /* Prepare the Dynamic Disk Header */
860 memset(buf, 0, 1024);
861
862 memcpy(dyndisk_header->magic, "cxsparse", 8);
863
864 /*
865 * Note: The spec is actually wrong here for data_offset, it says
866 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
867 */
868 dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
869 dyndisk_header->table_offset = cpu_to_be64(3 * 512);
870 dyndisk_header->version = cpu_to_be32(0x00010000);
871 dyndisk_header->block_size = cpu_to_be32(block_size);
872 dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries);
873
874 dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024));
875
876 /* Write the header */
877 offset = 512;
878
879 ret = blk_pwrite(blk, offset, buf, 1024, 0);
880 if (ret < 0) {
881 goto fail;
882 }
883
884 ret = 0;
885 fail:
886 return ret;
887}
888
889static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
890 int64_t total_size, Error **errp)
891{
892 int ret;
893
894 /* Add footer to total size */
895 total_size += HEADER_SIZE;
896
897 ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
898 if (ret < 0) {
899 return ret;
900 }
901
902 ret = blk_pwrite(blk, total_size - HEADER_SIZE, buf, HEADER_SIZE, 0);
903 if (ret < 0) {
904 error_setg_errno(errp, -ret, "Unable to write VHD header");
905 return ret;
906 }
907
908 return 0;
909}
910
911static 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)
917{
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;
924
925 /*
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.
929 *
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.
933 */
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);
943 }
944 }
945
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;
952 }
953 } else {
954 total_sectors = (int64_t) cyls * heads * secs_per_cyl;
955 }
956
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;
962 }
963
964 return 0;
965}
966
967static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
968 Error **errp)
969{
970 BlockdevCreateOptionsVpc *vpc_opts;
971 BlockBackend *blk = NULL;
972 BlockDriverState *bs = NULL;
973
974 uint8_t buf[1024];
975 VHDFooter *footer = (VHDFooter *) buf;
976 uint16_t cyls = 0;
977 uint8_t heads = 0;
978 uint8_t secs_per_cyl = 0;
979 int64_t total_sectors;
980 int64_t total_size;
981 int disk_type;
982 int ret = -EIO;
983 QemuUUID uuid;
984
985 assert(opts->driver == BLOCKDEV_DRIVER_VPC);
986 vpc_opts = &opts->u.vpc;
987
988 /* Validate options and set default values */
989 total_size = vpc_opts->size;
990
991 if (!vpc_opts->has_subformat) {
992 vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC;
993 }
994 switch (vpc_opts->subformat) {
995 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC:
996 disk_type = VHD_DYNAMIC;
997 break;
998 case BLOCKDEV_VPC_SUBFORMAT_FIXED:
999 disk_type = VHD_FIXED;
1000 break;
1001 default:
1002 g_assert_not_reached();
1003 }
1004
1005 /* Create BlockBackend to write to the image */
1006 bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
1007 if (bs == NULL) {
1008 return -EIO;
1009 }
1010
1011 blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
1012 errp);
1013 if (!blk) {
1014 ret = -EPERM;
1015 goto out;
1016 }
1017 blk_set_allow_write_beyond_eof(blk, true);
1018
1019 /* Get geometry and check that it matches the image size*/
1020 ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl,
1021 &total_sectors, errp);
1022 if (ret < 0) {
1023 goto out;
1024 }
1025
1026 if (total_size != total_sectors * BDRV_SECTOR_SIZE) {
1027 error_setg(errp, "The requested image size cannot be represented in "
1028 "CHS geometry");
1029 error_append_hint(errp, "Try size=%llu or force-size=on (the "
1030 "latter makes the image incompatible with "
1031 "Virtual PC)",
1032 total_sectors * BDRV_SECTOR_SIZE);
1033 ret = -EINVAL;
1034 goto out;
1035 }
1036
1037 /* Prepare the Hard Disk Footer */
1038 memset(buf, 0, 1024);
1039
1040 memcpy(footer->creator, "conectix", 8);
1041 if (vpc_opts->force_size) {
1042 memcpy(footer->creator_app, "qem2", 4);
1043 } else {
1044 memcpy(footer->creator_app, "qemu", 4);
1045 }
1046 memcpy(footer->creator_os, "Wi2k", 4);
1047
1048 footer->features = cpu_to_be32(0x02);
1049 footer->version = cpu_to_be32(0x00010000);
1050 if (disk_type == VHD_DYNAMIC) {
1051 footer->data_offset = cpu_to_be64(HEADER_SIZE);
1052 } else {
1053 footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
1054 }
1055 footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
1056
1057 /* Version of Virtual PC 2007 */
1058 footer->major = cpu_to_be16(0x0005);
1059 footer->minor = cpu_to_be16(0x0003);
1060 footer->orig_size = cpu_to_be64(total_size);
1061 footer->current_size = cpu_to_be64(total_size);
1062 footer->cyls = cpu_to_be16(cyls);
1063 footer->heads = heads;
1064 footer->secs_per_cyl = secs_per_cyl;
1065
1066 footer->type = cpu_to_be32(disk_type);
1067
1068 qemu_uuid_generate(&uuid);
1069 footer->uuid = uuid;
1070
1071 footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE));
1072
1073 if (disk_type == VHD_DYNAMIC) {
1074 ret = create_dynamic_disk(blk, buf, total_sectors);
1075 if (ret < 0) {
1076 error_setg(errp, "Unable to create or write VHD header");
1077 }
1078 } else {
1079 ret = create_fixed_disk(blk, buf, total_size, errp);
1080 }
1081
1082out:
1083 blk_unref(blk);
1084 bdrv_unref(bs);
1085 return ret;
1086}
1087
1088static int coroutine_fn vpc_co_create_opts(BlockDriver *drv,
1089 const char *filename,
1090 QemuOpts *opts,
1091 Error **errp)
1092{
1093 BlockdevCreateOptions *create_options = NULL;
1094 QDict *qdict;
1095 Visitor *v;
1096 BlockDriverState *bs = NULL;
1097 int ret;
1098
1099 static const QDictRenames opt_renames[] = {
1100 { VPC_OPT_FORCE_SIZE, "force-size" },
1101 { NULL, NULL },
1102 };
1103
1104 /* Parse options and convert legacy syntax */
1105 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true);
1106
1107 if (!qdict_rename_keys(qdict, opt_renames, errp)) {
1108 ret = -EINVAL;
1109 goto fail;
1110 }
1111
1112 /* Create and open the file (protocol layer) */
1113 ret = bdrv_create_file(filename, opts, errp);
1114 if (ret < 0) {
1115 goto fail;
1116 }
1117
1118 bs = bdrv_open(filename, NULL, NULL,
1119 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
1120 if (bs == NULL) {
1121 ret = -EIO;
1122 goto fail;
1123 }
1124
1125 /* Now get the QAPI type BlockdevCreateOptions */
1126 qdict_put_str(qdict, "driver", "vpc");
1127 qdict_put_str(qdict, "file", bs->node_name);
1128
1129 v = qobject_input_visitor_new_flat_confused(qdict, errp);
1130 if (!v) {
1131 ret = -EINVAL;
1132 goto fail;
1133 }
1134
1135 visit_type_BlockdevCreateOptions(v, NULL, &create_options, errp);
1136 visit_free(v);
1137 if (!create_options) {
1138 ret = -EINVAL;
1139 goto fail;
1140 }
1141
1142 /* Silently round up size */
1143 assert(create_options->driver == BLOCKDEV_DRIVER_VPC);
1144 create_options->u.vpc.size =
1145 ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
1146
1147 if (!create_options->u.vpc.force_size) {
1148 int64_t total_sectors;
1149 ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL,
1150 NULL, &total_sectors, errp);
1151 if (ret < 0) {
1152 goto fail;
1153 }
1154
1155 create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE;
1156 }
1157
1158
1159 /* Create the vpc image (format layer) */
1160 ret = vpc_co_create(create_options, errp);
1161
1162fail:
1163 qobject_unref(qdict);
1164 bdrv_unref(bs);
1165 qapi_free_BlockdevCreateOptions(create_options);
1166 return ret;
1167}
1168
1169
1170static int vpc_has_zero_init(BlockDriverState *bs)
1171{
1172 BDRVVPCState *s = bs->opaque;
1173 VHDFooter *footer = (VHDFooter *) s->footer_buf;
1174
1175 if (be32_to_cpu(footer->type) == VHD_FIXED) {
1176 return bdrv_has_zero_init(bs->file->bs);
1177 } else {
1178 return 1;
1179 }
1180}
1181
1182static void vpc_close(BlockDriverState *bs)
1183{
1184 BDRVVPCState *s = bs->opaque;
1185 qemu_vfree(s->pagetable);
1186#ifdef CACHE
1187 g_free(s->pageentry_u8);
1188#endif
1189
1190 migrate_del_blocker(s->migration_blocker);
1191 error_free(s->migration_blocker);
1192}
1193
1194static QemuOptsList vpc_create_opts = {
1195 .name = "vpc-create-opts",
1196 .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head),
1197 .desc = {
1198 {
1199 .name = BLOCK_OPT_SIZE,
1200 .type = QEMU_OPT_SIZE,
1201 .help = "Virtual disk size"
1202 },
1203 {
1204 .name = BLOCK_OPT_SUBFMT,
1205 .type = QEMU_OPT_STRING,
1206 .help =
1207 "Type of virtual hard disk format. Supported formats are "
1208 "{dynamic (default) | fixed} "
1209 },
1210 {
1211 .name = VPC_OPT_FORCE_SIZE,
1212 .type = QEMU_OPT_BOOL,
1213 .help = "Force disk size calculation to use the actual size "
1214 "specified, rather than using the nearest CHS-based "
1215 "calculation"
1216 },
1217 { /* end of list */ }
1218 }
1219};
1220
1221static const char *const vpc_strong_runtime_opts[] = {
1222 VPC_OPT_SIZE_CALC,
1223
1224 NULL
1225};
1226
1227static BlockDriver bdrv_vpc = {
1228 .format_name = "vpc",
1229 .instance_size = sizeof(BDRVVPCState),
1230
1231 .bdrv_probe = vpc_probe,
1232 .bdrv_open = vpc_open,
1233 .bdrv_close = vpc_close,
1234 .bdrv_reopen_prepare = vpc_reopen_prepare,
1235 .bdrv_child_perm = bdrv_default_perms,
1236 .bdrv_co_create = vpc_co_create,
1237 .bdrv_co_create_opts = vpc_co_create_opts,
1238
1239 .bdrv_co_preadv = vpc_co_preadv,
1240 .bdrv_co_pwritev = vpc_co_pwritev,
1241 .bdrv_co_block_status = vpc_co_block_status,
1242
1243 .bdrv_get_info = vpc_get_info,
1244
1245 .is_format = true,
1246 .create_opts = &vpc_create_opts,
1247 .bdrv_has_zero_init = vpc_has_zero_init,
1248 .strong_runtime_opts = vpc_strong_runtime_opts,
1249};
1250
1251static void bdrv_vpc_init(void)
1252{
1253 bdrv_register(&bdrv_vpc);
1254}
1255
1256block_init(bdrv_vpc_init);