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 qemu_opts_absorb_qdict(opts, options, &local_err); 239 if (local_err) { 240 error_propagate(errp, local_err); 241 ret = -EINVAL; 242 goto fail; 243 } 244 245 vpc_parse_options(bs, opts, &local_err); 246 if (local_err) { 247 error_propagate(errp, local_err); 248 ret = -EINVAL; 249 goto fail; 250 } 251 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; 256 } 257 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; 269 } 270 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; 276 } 277 if (strncmp(footer->creator, "conectix", 8)) { 278 error_setg(errp, "invalid VPC image"); 279 ret = -EINVAL; 280 goto fail; 281 } 282 disk_type = VHD_FIXED; 283 } 284 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; 291 } 292 293 /* Write 'checksum' back to footer, or else will leave it with zero. */ 294 footer->checksum = cpu_to_be32(checksum); 295 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; 301 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. 305 * 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. 309 * 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: 313 * 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 322 * 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. 326 */ 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; 332 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; 336 } 337 338 /* Allow a maximum disk size of 2040 GiB */ 339 if (bs->total_sectors > VHD_MAX_SECTORS) { 340 ret = -EFBIG; 341 goto fail; 342 } 343 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; 350 } 351 352 dyndisk_header = (VHDDynDiskHeader *) buf; 353 354 if (strncmp(dyndisk_header->magic, "cxsparse", 8)) { 355 error_setg(errp, "Invalid header magic"); 356 ret = -EINVAL; 357 goto fail; 358 } 359 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; 365 } 366 s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511; 367 368 s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries); 369 370 if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) { 371 error_setg(errp, "Too many blocks"); 372 ret = -EINVAL; 373 goto fail; 374 } 375 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; 381 } 382 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; 389 } 390 391 pagetable_size = (uint64_t) s->max_table_entries * 4; 392 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; 398 } 399 400 s->bat_offset = be64_to_cpu(dyndisk_header->table_offset); 401 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; 407 } 408 409 s->free_data_block_offset = 410 ROUND_UP(s->bat_offset + pagetable_size, 512); 411 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; 417 418 if (next > s->free_data_block_offset) { 419 s->free_data_block_offset = next; 420 } 421 } 422 } 423 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; 429 } 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; 435 } 436 437 s->last_bitmap_offset = (int64_t) -1; 438 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 445 } 446 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; 456 } 457 458 qemu_co_mutex_init(&s->lock); 459 qemu_opts_del(opts); 460 461 return 0; 462 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; 470 } 471 472 static int vpc_reopen_prepare(BDRVReopenState *state, 473 BlockReopenQueue *queue, Error **errp) 474 { 475 return 0; 476 } 477 478 /* 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. 484 * 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. 488 */ 489 static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset, 490 bool write, int *err) 491 { 492 BDRVVPCState *s = bs->opaque; 493 uint64_t bitmap_offset, block_offset; 494 uint32_t pagetable_index, offset_in_block; 495 496 assert(!(write && err == NULL)); 497 498 pagetable_index = offset / s->block_size; 499 offset_in_block = offset % s->block_size; 500 501 if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff) 502 return -1; /* not allocated */ 503 504 bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index]; 505 block_offset = bitmap_offset + s->bitmap_size + offset_in_block; 506 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; 515 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; 522 } 523 } 524 525 return block_offset; 526 } 527 528 /* 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 531 * 532 * Returns 0 on success and < 0 on error 533 */ 534 static int rewrite_footer(BlockDriverState* bs) 535 { 536 int ret; 537 BDRVVPCState *s = bs->opaque; 538 int64_t offset = s->free_data_block_offset; 539 540 ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE); 541 if (ret < 0) 542 return ret; 543 544 return 0; 545 } 546 547 /* 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) 551 * 552 * Returns the sectors' offset in the image file on success and < 0 on error 553 */ 554 static int64_t alloc_block(BlockDriverState* bs, int64_t offset) 555 { 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]; 561 562 /* Check if sector_num is valid */ 563 if ((offset < 0) || (offset > bs->total_sectors * BDRV_SECTOR_SIZE)) { 564 return -EINVAL; 565 } 566 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; 571 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; 578 } 579 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; 585 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; 592 593 return get_image_offset(bs, offset, false, NULL); 594 595 fail: 596 s->free_data_block_offset -= (s->block_size + s->bitmap_size); 597 return ret; 598 } 599 600 static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 601 { 602 BDRVVPCState *s = (BDRVVPCState *)bs->opaque; 603 VHDFooter *footer = (VHDFooter *) s->footer_buf; 604 605 if (be32_to_cpu(footer->type) != VHD_FIXED) { 606 bdi->cluster_size = s->block_size; 607 } 608 609 return 0; 610 } 611 612 static int coroutine_fn 613 vpc_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, 614 QEMUIOVector *qiov, int flags) 615 { 616 BDRVVPCState *s = bs->opaque; 617 int ret; 618 int64_t image_offset; 619 int64_t n_bytes; 620 int64_t bytes_done = 0; 621 VHDFooter *footer = (VHDFooter *) s->footer_buf; 622 QEMUIOVector local_qiov; 623 624 if (be32_to_cpu(footer->type) == VHD_FIXED) { 625 return bdrv_co_preadv(bs->file, offset, bytes, qiov, 0); 626 } 627 628 qemu_co_mutex_lock(&s->lock); 629 qemu_iovec_init(&local_qiov, qiov->niov); 630 631 while (bytes > 0) { 632 image_offset = get_image_offset(bs, offset, false, NULL); 633 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size)); 634 635 if (image_offset == -1) { 636 qemu_iovec_memset(qiov, bytes_done, 0, n_bytes); 637 } else { 638 qemu_iovec_reset(&local_qiov); 639 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes); 640 641 qemu_co_mutex_unlock(&s->lock); 642 ret = bdrv_co_preadv(bs->file, image_offset, n_bytes, 643 &local_qiov, 0); 644 qemu_co_mutex_lock(&s->lock); 645 if (ret < 0) { 646 goto fail; 647 } 648 } 649 650 bytes -= n_bytes; 651 offset += n_bytes; 652 bytes_done += n_bytes; 653 } 654 655 ret = 0; 656 fail: 657 qemu_iovec_destroy(&local_qiov); 658 qemu_co_mutex_unlock(&s->lock); 659 660 return ret; 661 } 662 663 static int coroutine_fn 664 vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes, 665 QEMUIOVector *qiov, int flags) 666 { 667 BDRVVPCState *s = bs->opaque; 668 int64_t image_offset; 669 int64_t n_bytes; 670 int64_t bytes_done = 0; 671 int ret = 0; 672 VHDFooter *footer = (VHDFooter *) s->footer_buf; 673 QEMUIOVector local_qiov; 674 675 if (be32_to_cpu(footer->type) == VHD_FIXED) { 676 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, 0); 677 } 678 679 qemu_co_mutex_lock(&s->lock); 680 qemu_iovec_init(&local_qiov, qiov->niov); 681 682 while (bytes > 0) { 683 image_offset = get_image_offset(bs, offset, true, &ret); 684 if (image_offset == -2) { 685 /* Failed to write block bitmap: can't proceed with write */ 686 goto fail; 687 } 688 n_bytes = MIN(bytes, s->block_size - (offset % s->block_size)); 689 690 if (image_offset == -1) { 691 image_offset = alloc_block(bs, offset); 692 if (image_offset < 0) { 693 ret = image_offset; 694 goto fail; 695 } 696 } 697 698 qemu_iovec_reset(&local_qiov); 699 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes); 700 701 qemu_co_mutex_unlock(&s->lock); 702 ret = bdrv_co_pwritev(bs->file, image_offset, n_bytes, 703 &local_qiov, 0); 704 qemu_co_mutex_lock(&s->lock); 705 if (ret < 0) { 706 goto fail; 707 } 708 709 bytes -= n_bytes; 710 offset += n_bytes; 711 bytes_done += n_bytes; 712 } 713 714 ret = 0; 715 fail: 716 qemu_iovec_destroy(&local_qiov); 717 qemu_co_mutex_unlock(&s->lock); 718 719 return ret; 720 } 721 722 static int coroutine_fn vpc_co_block_status(BlockDriverState *bs, 723 bool want_zero, 724 int64_t offset, int64_t bytes, 725 int64_t *pnum, int64_t *map, 726 BlockDriverState **file) 727 { 728 BDRVVPCState *s = bs->opaque; 729 VHDFooter *footer = (VHDFooter*) s->footer_buf; 730 int64_t image_offset; 731 bool allocated; 732 int ret; 733 int64_t n; 734 735 if (be32_to_cpu(footer->type) == VHD_FIXED) { 736 *pnum = bytes; 737 *map = offset; 738 *file = bs->file->bs; 739 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_RECURSE; 740 } 741 742 qemu_co_mutex_lock(&s->lock); 743 744 image_offset = get_image_offset(bs, offset, false, NULL); 745 allocated = (image_offset != -1); 746 *pnum = 0; 747 ret = BDRV_BLOCK_ZERO; 748 749 do { 750 /* All sectors in a block are contiguous (without using the bitmap) */ 751 n = ROUND_UP(offset + 1, s->block_size) - offset; 752 n = MIN(n, bytes); 753 754 *pnum += n; 755 offset += n; 756 bytes -= n; 757 /* *pnum can't be greater than one block for allocated 758 * sectors since there is always a bitmap in between. */ 759 if (allocated) { 760 *file = bs->file->bs; 761 *map = image_offset; 762 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID; 763 break; 764 } 765 if (bytes == 0) { 766 break; 767 } 768 image_offset = get_image_offset(bs, offset, false, NULL); 769 } while (image_offset == -1); 770 771 qemu_co_mutex_unlock(&s->lock); 772 return ret; 773 } 774 775 /* 776 * Calculates the number of cylinders, heads and sectors per cylinder 777 * based on a given number of sectors. This is the algorithm described 778 * in the VHD specification. 779 * 780 * Note that the geometry doesn't always exactly match total_sectors but 781 * may round it down. 782 * 783 * Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override 784 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB) 785 * and instead allow up to 255 heads. 786 */ 787 static int calculate_geometry(int64_t total_sectors, uint16_t* cyls, 788 uint8_t* heads, uint8_t* secs_per_cyl) 789 { 790 uint32_t cyls_times_heads; 791 792 total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY); 793 794 if (total_sectors >= 65535LL * 16 * 63) { 795 *secs_per_cyl = 255; 796 *heads = 16; 797 cyls_times_heads = total_sectors / *secs_per_cyl; 798 } else { 799 *secs_per_cyl = 17; 800 cyls_times_heads = total_sectors / *secs_per_cyl; 801 *heads = DIV_ROUND_UP(cyls_times_heads, 1024); 802 803 if (*heads < 4) { 804 *heads = 4; 805 } 806 807 if (cyls_times_heads >= (*heads * 1024) || *heads > 16) { 808 *secs_per_cyl = 31; 809 *heads = 16; 810 cyls_times_heads = total_sectors / *secs_per_cyl; 811 } 812 813 if (cyls_times_heads >= (*heads * 1024)) { 814 *secs_per_cyl = 63; 815 *heads = 16; 816 cyls_times_heads = total_sectors / *secs_per_cyl; 817 } 818 } 819 820 *cyls = cyls_times_heads / *heads; 821 822 return 0; 823 } 824 825 static int create_dynamic_disk(BlockBackend *blk, uint8_t *buf, 826 int64_t total_sectors) 827 { 828 VHDDynDiskHeader *dyndisk_header = 829 (VHDDynDiskHeader *) buf; 830 size_t block_size, num_bat_entries; 831 int i; 832 int ret; 833 int64_t offset = 0; 834 835 /* Write the footer (twice: at the beginning and at the end) */ 836 block_size = 0x200000; 837 num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512); 838 839 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0); 840 if (ret < 0) { 841 goto fail; 842 } 843 844 offset = 1536 + ((num_bat_entries * 4 + 511) & ~511); 845 ret = blk_pwrite(blk, offset, buf, HEADER_SIZE, 0); 846 if (ret < 0) { 847 goto fail; 848 } 849 850 /* Write the initial BAT */ 851 offset = 3 * 512; 852 853 memset(buf, 0xFF, 512); 854 for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) { 855 ret = blk_pwrite(blk, offset, buf, 512, 0); 856 if (ret < 0) { 857 goto fail; 858 } 859 offset += 512; 860 } 861 862 /* Prepare the Dynamic Disk Header */ 863 memset(buf, 0, 1024); 864 865 memcpy(dyndisk_header->magic, "cxsparse", 8); 866 867 /* 868 * Note: The spec is actually wrong here for data_offset, it says 869 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set. 870 */ 871 dyndisk_header->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL); 872 dyndisk_header->table_offset = cpu_to_be64(3 * 512); 873 dyndisk_header->version = cpu_to_be32(0x00010000); 874 dyndisk_header->block_size = cpu_to_be32(block_size); 875 dyndisk_header->max_table_entries = cpu_to_be32(num_bat_entries); 876 877 dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024)); 878 879 /* Write the header */ 880 offset = 512; 881 882 ret = blk_pwrite(blk, offset, buf, 1024, 0); 883 if (ret < 0) { 884 goto fail; 885 } 886 887 ret = 0; 888 fail: 889 return ret; 890 } 891 892 static int create_fixed_disk(BlockBackend *blk, uint8_t *buf, 893 int64_t total_size, Error **errp) 894 { 895 int ret; 896 897 /* Add footer to total size */ 898 total_size += HEADER_SIZE; 899 900 ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp); 901 if (ret < 0) { 902 return ret; 903 } 904 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; 909 } 910 911 return 0; 912 } 913 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) 920 { 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; 927 928 /* 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. 932 * 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. 936 */ 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); 946 } 947 } 948 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; 955 } 956 } else { 957 total_sectors = (int64_t) cyls * heads * secs_per_cyl; 958 } 959 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; 965 } 966 967 return 0; 968 } 969 970 static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts, 971 Error **errp) 972 { 973 BlockdevCreateOptionsVpc *vpc_opts; 974 BlockBackend *blk = NULL; 975 BlockDriverState *bs = NULL; 976 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; 987 988 assert(opts->driver == BLOCKDEV_DRIVER_VPC); 989 vpc_opts = &opts->u.vpc; 990 991 /* Validate options and set default values */ 992 total_size = vpc_opts->size; 993 994 if (!vpc_opts->has_subformat) { 995 vpc_opts->subformat = BLOCKDEV_VPC_SUBFORMAT_DYNAMIC; 996 } 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(); 1006 } 1007 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; 1012 } 1013 1014 blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL, 1015 errp); 1016 if (!blk) { 1017 ret = -EPERM; 1018 goto out; 1019 } 1020 blk_set_allow_write_beyond_eof(blk, true); 1021 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; 1027 } 1028 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; 1038 } 1039 1040 /* Prepare the Hard Disk Footer */ 1041 memset(buf, 0, 1024); 1042 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); 1048 } 1049 memcpy(footer->creator_os, "Wi2k", 4); 1050 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); 1057 } 1058 footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE); 1059 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; 1068 1069 footer->type = cpu_to_be32(disk_type); 1070 1071 qemu_uuid_generate(&uuid); 1072 footer->uuid = uuid; 1073 1074 footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE)); 1075 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"); 1080 } 1081 } else { 1082 ret = create_fixed_disk(blk, buf, total_size, errp); 1083 } 1084 1085 out: 1086 blk_unref(blk); 1087 bdrv_unref(bs); 1088 return ret; 1089 } 1090 1091 static int coroutine_fn vpc_co_create_opts(BlockDriver *drv, 1092 const char *filename, 1093 QemuOpts *opts, 1094 Error **errp) 1095 { 1096 BlockdevCreateOptions *create_options = NULL; 1097 QDict *qdict; 1098 Visitor *v; 1099 BlockDriverState *bs = NULL; 1100 Error *local_err = NULL; 1101 int ret; 1102 1103 static const QDictRenames opt_renames[] = { 1104 { VPC_OPT_FORCE_SIZE, "force-size" }, 1105 { NULL, NULL }, 1106 }; 1107 1108 /* Parse options and convert legacy syntax */ 1109 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vpc_create_opts, true); 1110 1111 if (!qdict_rename_keys(qdict, opt_renames, errp)) { 1112 ret = -EINVAL; 1113 goto fail; 1114 } 1115 1116 /* Create and open the file (protocol layer) */ 1117 ret = bdrv_create_file(filename, opts, &local_err); 1118 if (ret < 0) { 1119 error_propagate(errp, local_err); 1120 goto fail; 1121 } 1122 1123 bs = bdrv_open(filename, NULL, NULL, 1124 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp); 1125 if (bs == NULL) { 1126 ret = -EIO; 1127 goto fail; 1128 } 1129 1130 /* Now get the QAPI type BlockdevCreateOptions */ 1131 qdict_put_str(qdict, "driver", "vpc"); 1132 qdict_put_str(qdict, "file", bs->node_name); 1133 1134 v = qobject_input_visitor_new_flat_confused(qdict, errp); 1135 if (!v) { 1136 ret = -EINVAL; 1137 goto fail; 1138 } 1139 1140 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err); 1141 visit_free(v); 1142 1143 if (local_err) { 1144 error_propagate(errp, local_err); 1145 ret = -EINVAL; 1146 goto fail; 1147 } 1148 1149 /* Silently round up size */ 1150 assert(create_options->driver == BLOCKDEV_DRIVER_VPC); 1151 create_options->u.vpc.size = 1152 ROUND_UP(create_options->u.vpc.size, BDRV_SECTOR_SIZE); 1153 1154 if (!create_options->u.vpc.force_size) { 1155 int64_t total_sectors; 1156 ret = calculate_rounded_image_size(&create_options->u.vpc, NULL, NULL, 1157 NULL, &total_sectors, errp); 1158 if (ret < 0) { 1159 goto fail; 1160 } 1161 1162 create_options->u.vpc.size = total_sectors * BDRV_SECTOR_SIZE; 1163 } 1164 1165 1166 /* Create the vpc image (format layer) */ 1167 ret = vpc_co_create(create_options, errp); 1168 1169 fail: 1170 qobject_unref(qdict); 1171 bdrv_unref(bs); 1172 qapi_free_BlockdevCreateOptions(create_options); 1173 return ret; 1174 } 1175 1176 1177 static int vpc_has_zero_init(BlockDriverState *bs) 1178 { 1179 BDRVVPCState *s = bs->opaque; 1180 VHDFooter *footer = (VHDFooter *) s->footer_buf; 1181 1182 if (be32_to_cpu(footer->type) == VHD_FIXED) { 1183 return bdrv_has_zero_init(bs->file->bs); 1184 } else { 1185 return 1; 1186 } 1187 } 1188 1189 static void vpc_close(BlockDriverState *bs) 1190 { 1191 BDRVVPCState *s = bs->opaque; 1192 qemu_vfree(s->pagetable); 1193 #ifdef CACHE 1194 g_free(s->pageentry_u8); 1195 #endif 1196 1197 migrate_del_blocker(s->migration_blocker); 1198 error_free(s->migration_blocker); 1199 } 1200 1201 static QemuOptsList vpc_create_opts = { 1202 .name = "vpc-create-opts", 1203 .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head), 1204 .desc = { 1205 { 1206 .name = BLOCK_OPT_SIZE, 1207 .type = QEMU_OPT_SIZE, 1208 .help = "Virtual disk size" 1209 }, 1210 { 1211 .name = BLOCK_OPT_SUBFMT, 1212 .type = QEMU_OPT_STRING, 1213 .help = 1214 "Type of virtual hard disk format. Supported formats are " 1215 "{dynamic (default) | fixed} " 1216 }, 1217 { 1218 .name = VPC_OPT_FORCE_SIZE, 1219 .type = QEMU_OPT_BOOL, 1220 .help = "Force disk size calculation to use the actual size " 1221 "specified, rather than using the nearest CHS-based " 1222 "calculation" 1223 }, 1224 { /* end of list */ } 1225 } 1226 }; 1227 1228 static const char *const vpc_strong_runtime_opts[] = { 1229 VPC_OPT_SIZE_CALC, 1230 1231 NULL 1232 }; 1233 1234 static BlockDriver bdrv_vpc = { 1235 .format_name = "vpc", 1236 .instance_size = sizeof(BDRVVPCState), 1237 1238 .bdrv_probe = vpc_probe, 1239 .bdrv_open = vpc_open, 1240 .bdrv_close = vpc_close, 1241 .bdrv_reopen_prepare = vpc_reopen_prepare, 1242 .bdrv_child_perm = bdrv_default_perms, 1243 .bdrv_co_create = vpc_co_create, 1244 .bdrv_co_create_opts = vpc_co_create_opts, 1245 1246 .bdrv_co_preadv = vpc_co_preadv, 1247 .bdrv_co_pwritev = vpc_co_pwritev, 1248 .bdrv_co_block_status = vpc_co_block_status, 1249 1250 .bdrv_get_info = vpc_get_info, 1251 1252 .is_format = true, 1253 .create_opts = &vpc_create_opts, 1254 .bdrv_has_zero_init = vpc_has_zero_init, 1255 .strong_runtime_opts = vpc_strong_runtime_opts, 1256 }; 1257 1258 static void bdrv_vpc_init(void) 1259 { 1260 bdrv_register(&bdrv_vpc); 1261 } 1262 1263 block_init(bdrv_vpc_init); 1264