error: Eliminate error_propagate() with Coccinelle, part 2
[qemu.git] / block / vpc.c
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
46 enum 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 */
65 typedef 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
100 typedef 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
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;
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"
158 static 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
173 static QemuOptsList vpc_create_opts;
174
175 static 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
187 static 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
194 static 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
213 static 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, &local_err);
450 if (local_err) {
451 error_propagate(errp, local_err);
452 error_free(s->migration_blocker);
453 goto fail;
454 }
455
456 qemu_co_mutex_init(&s->lock);
457 qemu_opts_del(opts);
458
459 return 0;
460
461 fail:
462 qemu_opts_del(opts);
463 qemu_vfree(s->pagetable);
464 #ifdef CACHE
465 g_free(s->pageentry_u8);
466 #endif
467 return ret;
468 }
469
470 static int vpc_reopen_prepare(BDRVReopenState *state,
471 BlockReopenQueue *queue, Error **errp)
472 {
473 return 0;
474 }
475
476 /*
477 * Returns the absolute byte offset of the given sector in the image file.
478 * If the sector is not allocated, -1 is returned instead.
479 * If an error occurred trying to write an updated block bitmap back to
480 * the file, -2 is returned, and the error value is written to *err.
481 * This can only happen for a write operation.
482 *
483 * The parameter write must be 1 if the offset will be used for a write
484 * operation (the block bitmaps is updated then), 0 otherwise.
485 * If write is true then err must not be NULL.
486 */
487 static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
488 bool write, int *err)
489 {
490 BDRVVPCState *s = bs->opaque;
491 uint64_t bitmap_offset, block_offset;
492 uint32_t pagetable_index, offset_in_block;
493
494 assert(!(write && err == NULL));
495
496 pagetable_index = offset / s->block_size;
497 offset_in_block = offset % s->block_size;
498
499 if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)
500 return -1; /* not allocated */
501
502 bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
503 block_offset = bitmap_offset + s->bitmap_size + offset_in_block;
504
505 /* We must ensure that we don't write to any sectors which are marked as
506 unused in the bitmap. We get away with setting all bits in the block
507 bitmap each time we write to a new block. This might cause Virtual PC to
508 miss sparse read optimization, but it's not a problem in terms of
509 correctness. */
510 if (write && (s->last_bitmap_offset != bitmap_offset)) {
511 uint8_t bitmap[s->bitmap_size];
512 int r;
513
514 s->last_bitmap_offset = bitmap_offset;
515 memset(bitmap, 0xff, s->bitmap_size);
516 r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
517 if (r < 0) {
518 *err = r;
519 return -2;
520 }
521 }
522
523 return block_offset;
524 }
525
526 /*
527 * Writes the footer to the end of the image file. This is needed when the
528 * file grows as it overwrites the old footer
529 *
530 * Returns 0 on success and < 0 on error
531 */
532 static int rewrite_footer(BlockDriverState* bs)
533 {
534 int ret;
535 BDRVVPCState *s = bs->opaque;
536 int64_t offset = s->free_data_block_offset;
537
538 ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE);
539 if (ret < 0)
540 return ret;
541
542 return 0;
543 }
544
545 /*
546 * Allocates a new block. This involves writing a new footer and updating
547 * the Block Allocation Table to use the space at the old end of the image
548 * file (overwriting the old footer)
549 *
550 * Returns the sectors' offset in the image file on success and < 0 on error
551 */
552 static int64_t alloc_block(BlockDriverState* bs, int64_t offset)
553 {
554 BDRVVPCState *s = bs->opaque;
555 int64_t bat_offset;
556 uint32_t index, bat_value;
557 int ret;
558 uint8_t bitmap[s->bitmap_size];
559
560 /* Check if sector_num is valid */
561 if ((offset < 0) || (offset > bs->total_sectors * BDRV_SECTOR_SIZE)) {
562 return -EINVAL;
563 }
564
565 /* Write entry into in-memory BAT */
566 index = offset / s->block_size;
567 assert(s->pagetable[index] == 0xFFFFFFFF);
568 s->pagetable[index] = s->free_data_block_offset / 512;
569
570 /* Initialize the block's bitmap */
571 memset(bitmap, 0xff, s->bitmap_size);
572 ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
573 s->bitmap_size);
574 if (ret < 0) {
575 return ret;
576 }
577
578 /* Write new footer (the old one will be overwritten) */
579 s->free_data_block_offset += s->block_size + s->bitmap_size;
580 ret = rewrite_footer(bs);
581 if (ret < 0)
582 goto fail;
583
584 /* Write BAT entry to disk */
585 bat_offset = s->bat_offset + (4 * index);
586 bat_value = cpu_to_be32(s->pagetable[index]);
587 ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4);
588 if (ret < 0)
589 goto fail;
590
591 return get_image_offset(bs, offset, false, NULL);
592
593 fail:
594 s->free_data_block_offset -= (s->block_size + s->bitmap_size);
595 return ret;
596 }
597
598 static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
599 {
600 BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
601 VHDFooter *footer = (VHDFooter *) s->footer_buf;
602
603 if (be32_to_cpu(footer->type) != VHD_FIXED) {
604 bdi->cluster_size = s->block_size;
605 }
606
607 return 0;
608 }
609
610 static int coroutine_fn
611 vpc_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
612 QEMUIOVector *qiov, int flags)
613 {
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 VHDFooter *footer = (VHDFooter *) s->footer_buf;
620 QEMUIOVector local_qiov;
621
622 if (be32_to_cpu(footer->type) == VHD_FIXED) {
623 return bdrv_co_preadv(bs->file, offset, bytes, qiov, 0);
624 }
625
626 qemu_co_mutex_lock(&s->lock);
627 qemu_iovec_init(&local_qiov, qiov->niov);
628
629 while (bytes > 0) {
630 image_offset = get_image_offset(bs, offset, false, NULL);
631 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
632
633 if (image_offset == -1) {
634 qemu_iovec_memset(qiov, bytes_done, 0, n_bytes);
635 } else {
636 qemu_iovec_reset(&local_qiov);
637 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
638
639 qemu_co_mutex_unlock(&s->lock);
640 ret = bdrv_co_preadv(bs->file, image_offset, n_bytes,
641 &local_qiov, 0);
642 qemu_co_mutex_lock(&s->lock);
643 if (ret < 0) {
644 goto fail;
645 }
646 }
647
648 bytes -= n_bytes;
649 offset += n_bytes;
650 bytes_done += n_bytes;
651 }
652
653 ret = 0;
654 fail:
655 qemu_iovec_destroy(&local_qiov);
656 qemu_co_mutex_unlock(&s->lock);
657
658 return ret;
659 }
660
661 static int coroutine_fn
662 vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
663 QEMUIOVector *qiov, int flags)
664 {
665 BDRVVPCState *s = bs->opaque;
666 int64_t image_offset;
667 int64_t n_bytes;
668 int64_t bytes_done = 0;
669 int ret = 0;
670 VHDFooter *footer = (VHDFooter *) s->footer_buf;
671 QEMUIOVector local_qiov;
672
673 if (be32_to_cpu(footer->type) == VHD_FIXED) {
674 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, 0);
675 }
676
677 qemu_co_mutex_lock(&s->lock);
678 qemu_iovec_init(&local_qiov, qiov->niov);
679
680 while (bytes > 0) {
681 image_offset = get_image_offset(bs, offset, true, &ret);
682 if (image_offset == -2) {
683 /* Failed to write block bitmap: can't proceed with write */
684 goto fail;
685 }
686 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size));
687
688 if (image_offset == -1) {
689 image_offset = alloc_block(bs, offset);
690 if (image_offset < 0) {
691 ret = image_offset;
692 goto fail;
693 }
694 }
695
696 qemu_iovec_reset(&local_qiov);
697 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
698
699 qemu_co_mutex_unlock(&s->lock);
700 ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes,
701 &local_qiov, 0);
702 qemu_co_mutex_lock(&s->lock);
703 if (ret < 0) {
704 goto fail;
705 }
706
707 bytes -= n_bytes;
708 offset += n_bytes;
709 bytes_done += n_bytes;
710 }
711
712 ret = 0;
713 fail:
714 qemu_iovec_destroy(&local_qiov);
715 qemu_co_mutex_unlock(&s->lock);
716
717 return ret;
718 }
719
720 static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
721 bool want_zero,
722 int64_t offset, int64_t bytes,
723 int64_t *pnum, int64_t *map,
724 BlockDriverState **file)
725 {
726 BDRVVPCState *s = bs->opaque;
727 VHDFooter *footer = (VHDFooter*) s->footer_buf;
728 int64_t image_offset;
729 bool allocated;
730 int ret;
731 int64_t n;
732
733 if (be32_to_cpu(footer->type) == VHD_FIXED) {
734 *pnum = bytes;
735 *map = offset;
736 *file = bs->file->bs;
737 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE;
738 }
739
740 qemu_co_mutex_lock(&s->lock);
741
742 image_offset = get_image_offset(bs, offset, false, NULL);
743 allocated = (image_offset != -1);
744 *pnum = 0;
745 ret = BDRV_BLOCK_ZERO;
746
747 do {
748 /* All sectors in a block are contiguous (without using the bitmap) */
749 n = ROUND_UP(offset + 1, s->block_size) - offset;
750 n = MIN(n, bytes);
751
752 *pnum += n;
753 offset += n;
754 bytes -= n;
755 /* *pnum can't be greater than one block for allocated
756 * sectors since there is always a bitmap in between. */
757 if (allocated) {
758 *file = bs->file->bs;
759 *map = image_offset;
760 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
761 break;
762 }
763 if (bytes == 0) {
764 break;
765 }
766 image_offset = get_image_offset(bs, offset, false, NULL);
767 } while (image_offset == -1);
768
769 qemu_co_mutex_unlock(&s->lock);
770 return ret;
771 }
772
773 /*
774 * Calculates the number of cylinders, heads and sectors per cylinder
775 * based on a given number of sectors. This is the algorithm described
776 * in the VHD specification.
777 *
778 * Note that the geometry doesn't always exactly match total_sectors but
779 * may round it down.
780 *
781 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
782 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
783 * and instead allow up to 255 heads.
784 */
785 static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
786 uint8_t* heads, uint8_t* secs_per_cyl)
787 {
788 uint32_t cyls_times_heads;
789
790 total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY);
791
792 if (total_sectors >= 65535LL * 16 * 63) {
793 *secs_per_cyl = 255;
794 *heads = 16;
795 cyls_times_heads = total_sectors / *secs_per_cyl;
796 } else {
797 *secs_per_cyl = 17;
798 cyls_times_heads = total_sectors / *secs_per_cyl;
799 *heads = DIV_ROUND_UP(cyls_times_heads, 1024);
800
801 if (*heads < 4) {
802 *heads = 4;
803 }
804
805 if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
806 *secs_per_cyl = 31;
807 *heads = 16;
808 cyls_times_heads = total_sectors / *secs_per_cyl;
809 }
810
811 if (cyls_times_heads >= (*heads * 1024)) {
812 *secs_per_cyl = 63;
813 *heads = 16;
814 cyls_times_heads = total_sectors / *secs_per_cyl;
815 }
816 }
817
818 *cyls = cyls_times_heads / *heads;
819
820 return 0;
821 }
822
823 static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf,
824 int64_t total_sectors)
825 {
826 VHDDynDiskHeader *dyndisk_header =
827 (VHDDynDiskHeader *) buf;
828 size_t block_size, num_bat_entries;
829 int i;
830 int ret;
831 int64_t offset = 0;
832
833 /* Write the footer (twice: at the beginning and at the end) */
834 block_size = 0x200000;
835 num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
836
837 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
838 if (ret < 0) {
839 goto fail;
840 }
841
842 offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
843 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0);
844 if (ret < 0) {
845 goto fail;
846 }
847
848 /* Write the initial BAT */
849 offset = 3 * 512;
850
851 memset(buf, 0xFF, 512);
852 for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
853 ret = blk_pwrite(blk, offset, buf, 512, 0);
854 if (ret < 0) {
855 goto fail;
856 }
857 offset += 512;
858 }
859
860 /* Prepare the Dynamic Disk Header */
861 memset(buf, 0, 1024);
862
863 memcpy(dyndisk_header->magic, "cxsparse", 8);
864
865 /*
866 * Note: The spec is actually wrong here for data_offset, it says
867 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set.
868 */
869 dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
870 dyndisk_header->table_offset = cpu_to_be64(3 * 512);
871 dyndisk_header->version = cpu_to_be32(0x00010000);
872 dyndisk_header->block_size = cpu_to_be32(block_size);
873 dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries);
874
875 dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024));
876
877 /* Write the header */
878 offset = 512;
879
880 ret = blk_pwrite(blk, offset, buf, 1024, 0);
881 if (ret < 0) {
882 goto fail;
883 }
884
885 ret = 0;
886 fail:
887 return ret;
888 }
889
890 static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
891 int64_t total_size, Error **errp)
892 {
893 int ret;
894
895 /* Add footer to total size */
896 total_size += HEADER_SIZE;
897
898 ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
899 if (ret < 0) {
900 return ret;
901 }
902
903 ret = blk_pwrite(blk, total_size - HEADER_SIZE, buf, HEADER_SIZE, 0);
904 if (ret < 0) {
905 error_setg_errno(errp, -ret, "Unable to write VHD header");
906 return ret;
907 }
908
909 return 0;
910 }
911
912 static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
913 uint16_t *out_cyls,
914 uint8_t *out_heads,
915 uint8_t *out_secs_per_cyl,
916 int64_t *out_total_sectors,
917 Error **errp)
918 {
919 int64_t total_size = vpc_opts->size;
920 uint16_t cyls = 0;
921 uint8_t heads = 0;
922 uint8_t secs_per_cyl = 0;
923 int64_t total_sectors;
924 int i;
925
926 /*
927 * Calculate matching total_size and geometry. Increase the number of
928 * sectors requested until we get enough (or fail). This ensures that
929 * qemu-img convert doesn't truncate images, but rather rounds up.
930 *
931 * If the image size can't be represented by a spec conformant CHS geometry,
932 * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
933 * the image size from the VHD footer to calculate total_sectors.
934 */
935 if (vpc_opts->force_size) {
936 /* This will force the use of total_size for sector count, below */
937 cyls = VHD_CHS_MAX_C;
938 heads = VHD_CHS_MAX_H;
939 secs_per_cyl = VHD_CHS_MAX_S;
940 } else {
941 total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
942 for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
943 calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
944 }
945 }
946
947 if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
948 total_sectors = total_size / BDRV_SECTOR_SIZE;
949 /* Allow a maximum disk size of 2040 GiB */
950 if (total_sectors > VHD_MAX_SECTORS) {
951 error_setg(errp, "Disk size is too large, max size is 2040 GiB");
952 return -EFBIG;
953 }
954 } else {
955 total_sectors = (int64_t) cyls * heads * secs_per_cyl;
956 }
957
958 *out_total_sectors = total_sectors;
959 if (out_cyls) {
960 *out_cyls = cyls;
961 *out_heads = heads;
962 *out_secs_per_cyl = secs_per_cyl;
963 }
964
965 return 0;
966 }
967
968 static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
969 Error **errp)
970 {
971 BlockdevCreateOptionsVpc *vpc_opts;
972 BlockBackend *blk = NULL;
973 BlockDriverState *bs = NULL;
974
975 uint8_t buf[1024];
976 VHDFooter *footer = (VHDFooter *) buf;
977 uint16_t cyls = 0;
978 uint8_t heads = 0;
979 uint8_t secs_per_cyl = 0;
980 int64_t total_sectors;
981 int64_t total_size;
982 int disk_type;
983 int ret = -EIO;
984 QemuUUID uuid;
985
986 assert(opts->driver == BLOCKDEV_DRIVER_VPC);
987 vpc_opts = &opts->u.vpc;
988
989 /* Validate options and set default values */
990 total_size = vpc_opts->size;
991
992 if (!vpc_opts->has_subformat) {
993 vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC;
994 }
995 switch (vpc_opts->subformat) {
996 case BLOCKDEV_VPC_SUBFORMAT_DYNAMIC:
997 disk_type = VHD_DYNAMIC;
998 break;
999 case BLOCKDEV_VPC_SUBFORMAT_FIXED:
1000 disk_type = VHD_FIXED;
1001 break;
1002 default:
1003 g_assert_not_reached();
1004 }
1005
1006 /* Create BlockBackend to write to the image */
1007 bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
1008 if (bs == NULL) {
1009 return -EIO;
1010 }
1011
1012 blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
1013 errp);
1014 if (!blk) {
1015 ret = -EPERM;
1016 goto out;
1017 }
1018 blk_set_allow_write_beyond_eof(blk, true);
1019
1020 /* Get geometry and check that it matches the image size*/
1021 ret = calculate_rounded_image_size(vpc_opts, &cyls, &heads, &secs_per_cyl,
1022 &total_sectors, errp);
1023 if (ret < 0) {
1024 goto out;
1025 }
1026
1027 if (total_size != total_sectors * BDRV_SECTOR_SIZE) {
1028 error_setg(errp, "The requested image size cannot be represented in "
1029 "CHS geometry");
1030 error_append_hint(errp, "Try size=%llu or force-size=on (the "
1031 "latter makes the image incompatible with "
1032 "Virtual PC)",
1033 total_sectors * BDRV_SECTOR_SIZE);
1034 ret = -EINVAL;
1035 goto out;
1036 }
1037
1038 /* Prepare the Hard Disk Footer */
1039 memset(buf, 0, 1024);
1040
1041 memcpy(footer->creator, "conectix", 8);
1042 if (vpc_opts->force_size) {
1043 memcpy(footer->creator_app, "qem2", 4);
1044 } else {
1045 memcpy(footer->creator_app, "qemu", 4);
1046 }
1047 memcpy(footer->creator_os, "Wi2k", 4);
1048
1049 footer->features = cpu_to_be32(0x02);
1050 footer->version = cpu_to_be32(0x00010000);
1051 if (disk_type == VHD_DYNAMIC) {
1052 footer->data_offset = cpu_to_be64(HEADER_SIZE);
1053 } else {
1054 footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL);
1055 }
1056 footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE);
1057
1058 /* Version of Virtual PC 2007 */
1059 footer->major = cpu_to_be16(0x0005);
1060 footer->minor = cpu_to_be16(0x0003);
1061 footer->orig_size = cpu_to_be64(total_size);
1062 footer->current_size = cpu_to_be64(total_size);
1063 footer->cyls = cpu_to_be16(cyls);
1064 footer->heads = heads;
1065 footer->secs_per_cyl = secs_per_cyl;
1066
1067 footer->type = cpu_to_be32(disk_type);
1068
1069 qemu_uuid_generate(&uuid);
1070 footer->uuid = uuid;
1071
1072 footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE));
1073
1074 if (disk_type == VHD_DYNAMIC) {
1075 ret = create_dynamic_disk(blk, buf, total_sectors);
1076 if (ret < 0) {
1077 error_setg(errp, "Unable to create or write VHD header");
1078 }
1079 } else {
1080 ret = create_fixed_disk(blk, buf, total_size, errp);
1081 }
1082
1083 out:
1084 blk_unref(blk);
1085 bdrv_unref(bs);
1086 return ret;
1087 }
1088
1089 static int coroutine_fn vpc_co_create_opts(BlockDriver *drv,
1090 const char *filename,
1091 QemuOpts *opts,
1092 Error **errp)
1093 {
1094 BlockdevCreateOptions *create_options = NULL;
1095 QDict *qdict;
1096 Visitor *v;
1097 BlockDriverState *bs = NULL;
1098 Error *local_err = NULL;
1099 int ret;
1100
1101 static const QDictRenames opt_renames[] = {
1102 { VPC_OPT_FORCE_SIZE, "force-size" },
1103 { NULL, NULL },
1104 };
1105
1106 /* Parse options and convert legacy syntax */
1107 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true);
1108
1109 if (!qdict_rename_keys(qdict, opt_renames, errp)) {
1110 ret = -EINVAL;
1111 goto fail;
1112 }
1113
1114 /* Create and open the file (protocol layer) */
1115 ret = bdrv_create_file(filename, opts, errp);
1116 if (ret < 0) {
1117 goto fail;
1118 }
1119
1120 bs = bdrv_open(filename, NULL, NULL,
1121 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
1122 if (bs == NULL) {
1123 ret = -EIO;
1124 goto fail;
1125 }
1126
1127 /* Now get the QAPI type BlockdevCreateOptions */
1128 qdict_put_str(qdict, "driver", "vpc");
1129 qdict_put_str(qdict, "file", bs->node_name);
1130
1131 v = qobject_input_visitor_new_flat_confused(qdict, errp);
1132 if (!v) {
1133 ret = -EINVAL;
1134 goto fail;
1135 }
1136
1137 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
1138 visit_free(v);
1139
1140 if (local_err) {
1141 error_propagate(errp, local_err);
1142 ret = -EINVAL;
1143 goto fail;
1144 }
1145
1146 /* Silently round up size */
1147 assert(create_options->driver == BLOCKDEV_DRIVER_VPC);
1148 create_options->u.vpc.size =
1149 ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE);
1150
1151 if (!create_options->u.vpc.force_size) {
1152 int64_t total_sectors;
1153 ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL,
1154 NULL, &total_sectors, errp);
1155 if (ret < 0) {
1156 goto fail;
1157 }
1158
1159 create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE;
1160 }
1161
1162
1163 /* Create the vpc image (format layer) */
1164 ret = vpc_co_create(create_options, errp);
1165
1166 fail:
1167 qobject_unref(qdict);
1168 bdrv_unref(bs);
1169 qapi_free_BlockdevCreateOptions(create_options);
1170 return ret;
1171 }
1172
1173
1174 static int vpc_has_zero_init(BlockDriverState *bs)
1175 {
1176 BDRVVPCState *s = bs->opaque;
1177 VHDFooter *footer = (VHDFooter *) s->footer_buf;
1178
1179 if (be32_to_cpu(footer->type) == VHD_FIXED) {
1180 return bdrv_has_zero_init(bs->file->bs);
1181 } else {
1182 return 1;
1183 }
1184 }
1185
1186 static void vpc_close(BlockDriverState *bs)
1187 {
1188 BDRVVPCState *s = bs->opaque;
1189 qemu_vfree(s->pagetable);
1190 #ifdef CACHE
1191 g_free(s->pageentry_u8);
1192 #endif
1193
1194 migrate_del_blocker(s->migration_blocker);
1195 error_free(s->migration_blocker);
1196 }
1197
1198 static QemuOptsList vpc_create_opts = {
1199 .name = "vpc-create-opts",
1200 .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head),
1201 .desc = {
1202 {
1203 .name = BLOCK_OPT_SIZE,
1204 .type = QEMU_OPT_SIZE,
1205 .help = "Virtual disk size"
1206 },
1207 {
1208 .name = BLOCK_OPT_SUBFMT,
1209 .type = QEMU_OPT_STRING,
1210 .help =
1211 "Type of virtual hard disk format. Supported formats are "
1212 "{dynamic (default) | fixed} "
1213 },
1214 {
1215 .name = VPC_OPT_FORCE_SIZE,
1216 .type = QEMU_OPT_BOOL,
1217 .help = "Force disk size calculation to use the actual size "
1218 "specified, rather than using the nearest CHS-based "
1219 "calculation"
1220 },
1221 { /* end of list */ }
1222 }
1223 };
1224
1225 static const char *const vpc_strong_runtime_opts[] = {
1226 VPC_OPT_SIZE_CALC,
1227
1228 NULL
1229 };
1230
1231 static BlockDriver bdrv_vpc = {
1232 .format_name = "vpc",
1233 .instance_size = sizeof(BDRVVPCState),
1234
1235 .bdrv_probe = vpc_probe,
1236 .bdrv_open = vpc_open,
1237 .bdrv_close = vpc_close,
1238 .bdrv_reopen_prepare = vpc_reopen_prepare,
1239 .bdrv_child_perm = bdrv_default_perms,
1240 .bdrv_co_create = vpc_co_create,
1241 .bdrv_co_create_opts = vpc_co_create_opts,
1242
1243 .bdrv_co_preadv = vpc_co_preadv,
1244 .bdrv_co_pwritev = vpc_co_pwritev,
1245 .bdrv_co_block_status = vpc_co_block_status,
1246
1247 .bdrv_get_info = vpc_get_info,
1248
1249 .is_format = true,
1250 .create_opts = &vpc_create_opts,
1251 .bdrv_has_zero_init = vpc_has_zero_init,
1252 .strong_runtime_opts = vpc_strong_runtime_opts,
1253 };
1254
1255 static void bdrv_vpc_init(void)
1256 {
1257 bdrv_register(&bdrv_vpc);
1258 }
1259
1260 block_init(bdrv_vpc_init);