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 #include "qemu-common.h" 26 #include "block/block_int.h" 27 #include "qemu/module.h" 28 #include "migration/migration.h" 29 #if defined(CONFIG_UUID) 30 #include <uuid/uuid.h> 31 #endif 32 33 /**************************************************************/ 34 35 #define HEADER_SIZE 512 36 37 //#define CACHE 38 39 enum vhd_type { 40 VHD_FIXED = 2, 41 VHD_DYNAMIC = 3, 42 VHD_DIFFERENCING = 4, 43 }; 44 45 // Seconds since Jan 1, 2000 0:00:00 (UTC) 46 #define VHD_TIMESTAMP_BASE 946684800 47 48 // always big-endian 49 typedef struct vhd_footer { 50 char creator[8]; // "conectix" 51 uint32_t features; 52 uint32_t version; 53 54 // Offset of next header structure, 0xFFFFFFFF if none 55 uint64_t data_offset; 56 57 // Seconds since Jan 1, 2000 0:00:00 (UTC) 58 uint32_t timestamp; 59 60 char creator_app[4]; // "vpc " 61 uint16_t major; 62 uint16_t minor; 63 char creator_os[4]; // "Wi2k" 64 65 uint64_t orig_size; 66 uint64_t size; 67 68 uint16_t cyls; 69 uint8_t heads; 70 uint8_t secs_per_cyl; 71 72 uint32_t type; 73 74 // Checksum of the Hard Disk Footer ("one's complement of the sum of all 75 // the bytes in the footer without the checksum field") 76 uint32_t checksum; 77 78 // UUID used to identify a parent hard disk (backing file) 79 uint8_t uuid[16]; 80 81 uint8_t in_saved_state; 82 } QEMU_PACKED VHDFooter; 83 84 typedef struct vhd_dyndisk_header { 85 char magic[8]; // "cxsparse" 86 87 // Offset of next header structure, 0xFFFFFFFF if none 88 uint64_t data_offset; 89 90 // Offset of the Block Allocation Table (BAT) 91 uint64_t table_offset; 92 93 uint32_t version; 94 uint32_t max_table_entries; // 32bit/entry 95 96 // 2 MB by default, must be a power of two 97 uint32_t block_size; 98 99 uint32_t checksum; 100 uint8_t parent_uuid[16]; 101 uint32_t parent_timestamp; 102 uint32_t reserved; 103 104 // Backing file name (in UTF-16) 105 uint8_t parent_name[512]; 106 107 struct { 108 uint32_t platform; 109 uint32_t data_space; 110 uint32_t data_length; 111 uint32_t reserved; 112 uint64_t data_offset; 113 } parent_locator[8]; 114 } QEMU_PACKED VHDDynDiskHeader; 115 116 typedef struct BDRVVPCState { 117 CoMutex lock; 118 uint8_t footer_buf[HEADER_SIZE]; 119 uint64_t free_data_block_offset; 120 int max_table_entries; 121 uint32_t *pagetable; 122 uint64_t bat_offset; 123 uint64_t last_bitmap_offset; 124 125 uint32_t block_size; 126 uint32_t bitmap_size; 127 128 #ifdef CACHE 129 uint8_t *pageentry_u8; 130 uint32_t *pageentry_u32; 131 uint16_t *pageentry_u16; 132 133 uint64_t last_bitmap; 134 #endif 135 136 Error *migration_blocker; 137 } BDRVVPCState; 138 139 static uint32_t vpc_checksum(uint8_t* buf, size_t size) 140 { 141 uint32_t res = 0; 142 int i; 143 144 for (i = 0; i < size; i++) 145 res += buf[i]; 146 147 return ~res; 148 } 149 150 151 static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename) 152 { 153 if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8)) 154 return 100; 155 return 0; 156 } 157 158 static int vpc_open(BlockDriverState *bs, QDict *options, int flags, 159 Error **errp) 160 { 161 BDRVVPCState *s = bs->opaque; 162 int i; 163 VHDFooter *footer; 164 VHDDynDiskHeader *dyndisk_header; 165 uint8_t buf[HEADER_SIZE]; 166 uint32_t checksum; 167 int disk_type = VHD_DYNAMIC; 168 int ret; 169 170 ret = bdrv_pread(bs->file, 0, s->footer_buf, HEADER_SIZE); 171 if (ret < 0) { 172 goto fail; 173 } 174 175 footer = (VHDFooter *) s->footer_buf; 176 if (strncmp(footer->creator, "conectix", 8)) { 177 int64_t offset = bdrv_getlength(bs->file); 178 if (offset < 0) { 179 ret = offset; 180 goto fail; 181 } else if (offset < HEADER_SIZE) { 182 ret = -EINVAL; 183 goto fail; 184 } 185 186 /* If a fixed disk, the footer is found only at the end of the file */ 187 ret = bdrv_pread(bs->file, offset-HEADER_SIZE, s->footer_buf, 188 HEADER_SIZE); 189 if (ret < 0) { 190 goto fail; 191 } 192 if (strncmp(footer->creator, "conectix", 8)) { 193 ret = -EMEDIUMTYPE; 194 goto fail; 195 } 196 disk_type = VHD_FIXED; 197 } 198 199 checksum = be32_to_cpu(footer->checksum); 200 footer->checksum = 0; 201 if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum) 202 fprintf(stderr, "block-vpc: The header checksum of '%s' is " 203 "incorrect.\n", bs->filename); 204 205 /* Write 'checksum' back to footer, or else will leave it with zero. */ 206 footer->checksum = be32_to_cpu(checksum); 207 208 // The visible size of a image in Virtual PC depends on the geometry 209 // rather than on the size stored in the footer (the size in the footer 210 // is too large usually) 211 bs->total_sectors = (int64_t) 212 be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl; 213 214 /* Allow a maximum disk size of approximately 2 TB */ 215 if (bs->total_sectors >= 65535LL * 255 * 255) { 216 ret = -EFBIG; 217 goto fail; 218 } 219 220 if (disk_type == VHD_DYNAMIC) { 221 ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset), buf, 222 HEADER_SIZE); 223 if (ret < 0) { 224 goto fail; 225 } 226 227 dyndisk_header = (VHDDynDiskHeader *) buf; 228 229 if (strncmp(dyndisk_header->magic, "cxsparse", 8)) { 230 ret = -EINVAL; 231 goto fail; 232 } 233 234 s->block_size = be32_to_cpu(dyndisk_header->block_size); 235 s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511; 236 237 s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries); 238 s->pagetable = g_malloc(s->max_table_entries * 4); 239 240 s->bat_offset = be64_to_cpu(dyndisk_header->table_offset); 241 242 ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable, 243 s->max_table_entries * 4); 244 if (ret < 0) { 245 goto fail; 246 } 247 248 s->free_data_block_offset = 249 (s->bat_offset + (s->max_table_entries * 4) + 511) & ~511; 250 251 for (i = 0; i < s->max_table_entries; i++) { 252 be32_to_cpus(&s->pagetable[i]); 253 if (s->pagetable[i] != 0xFFFFFFFF) { 254 int64_t next = (512 * (int64_t) s->pagetable[i]) + 255 s->bitmap_size + s->block_size; 256 257 if (next > s->free_data_block_offset) { 258 s->free_data_block_offset = next; 259 } 260 } 261 } 262 263 if (s->free_data_block_offset > bdrv_getlength(bs->file)) { 264 error_setg(errp, "block-vpc: free_data_block_offset points after " 265 "the end of file. The image has been truncated."); 266 ret = -EINVAL; 267 goto fail; 268 } 269 270 s->last_bitmap_offset = (int64_t) -1; 271 272 #ifdef CACHE 273 s->pageentry_u8 = g_malloc(512); 274 s->pageentry_u32 = s->pageentry_u8; 275 s->pageentry_u16 = s->pageentry_u8; 276 s->last_pagetable = -1; 277 #endif 278 } 279 280 qemu_co_mutex_init(&s->lock); 281 282 /* Disable migration when VHD images are used */ 283 error_set(&s->migration_blocker, 284 QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, 285 "vpc", bs->device_name, "live migration"); 286 migrate_add_blocker(s->migration_blocker); 287 288 return 0; 289 290 fail: 291 g_free(s->pagetable); 292 #ifdef CACHE 293 g_free(s->pageentry_u8); 294 #endif 295 return ret; 296 } 297 298 static int vpc_reopen_prepare(BDRVReopenState *state, 299 BlockReopenQueue *queue, Error **errp) 300 { 301 return 0; 302 } 303 304 /* 305 * Returns the absolute byte offset of the given sector in the image file. 306 * If the sector is not allocated, -1 is returned instead. 307 * 308 * The parameter write must be 1 if the offset will be used for a write 309 * operation (the block bitmaps is updated then), 0 otherwise. 310 */ 311 static inline int64_t get_sector_offset(BlockDriverState *bs, 312 int64_t sector_num, int write) 313 { 314 BDRVVPCState *s = bs->opaque; 315 uint64_t offset = sector_num * 512; 316 uint64_t bitmap_offset, block_offset; 317 uint32_t pagetable_index, pageentry_index; 318 319 pagetable_index = offset / s->block_size; 320 pageentry_index = (offset % s->block_size) / 512; 321 322 if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff) 323 return -1; // not allocated 324 325 bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index]; 326 block_offset = bitmap_offset + s->bitmap_size + (512 * pageentry_index); 327 328 // We must ensure that we don't write to any sectors which are marked as 329 // unused in the bitmap. We get away with setting all bits in the block 330 // bitmap each time we write to a new block. This might cause Virtual PC to 331 // miss sparse read optimization, but it's not a problem in terms of 332 // correctness. 333 if (write && (s->last_bitmap_offset != bitmap_offset)) { 334 uint8_t bitmap[s->bitmap_size]; 335 336 s->last_bitmap_offset = bitmap_offset; 337 memset(bitmap, 0xff, s->bitmap_size); 338 bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size); 339 } 340 341 // printf("sector: %" PRIx64 ", index: %x, offset: %x, bioff: %" PRIx64 ", bloff: %" PRIx64 "\n", 342 // sector_num, pagetable_index, pageentry_index, 343 // bitmap_offset, block_offset); 344 345 // disabled by reason 346 #if 0 347 #ifdef CACHE 348 if (bitmap_offset != s->last_bitmap) 349 { 350 lseek(s->fd, bitmap_offset, SEEK_SET); 351 352 s->last_bitmap = bitmap_offset; 353 354 // Scary! Bitmap is stored as big endian 32bit entries, 355 // while we used to look it up byte by byte 356 read(s->fd, s->pageentry_u8, 512); 357 for (i = 0; i < 128; i++) 358 be32_to_cpus(&s->pageentry_u32[i]); 359 } 360 361 if ((s->pageentry_u8[pageentry_index / 8] >> (pageentry_index % 8)) & 1) 362 return -1; 363 #else 364 lseek(s->fd, bitmap_offset + (pageentry_index / 8), SEEK_SET); 365 366 read(s->fd, &bitmap_entry, 1); 367 368 if ((bitmap_entry >> (pageentry_index % 8)) & 1) 369 return -1; // not allocated 370 #endif 371 #endif 372 373 return block_offset; 374 } 375 376 /* 377 * Writes the footer to the end of the image file. This is needed when the 378 * file grows as it overwrites the old footer 379 * 380 * Returns 0 on success and < 0 on error 381 */ 382 static int rewrite_footer(BlockDriverState* bs) 383 { 384 int ret; 385 BDRVVPCState *s = bs->opaque; 386 int64_t offset = s->free_data_block_offset; 387 388 ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE); 389 if (ret < 0) 390 return ret; 391 392 return 0; 393 } 394 395 /* 396 * Allocates a new block. This involves writing a new footer and updating 397 * the Block Allocation Table to use the space at the old end of the image 398 * file (overwriting the old footer) 399 * 400 * Returns the sectors' offset in the image file on success and < 0 on error 401 */ 402 static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num) 403 { 404 BDRVVPCState *s = bs->opaque; 405 int64_t bat_offset; 406 uint32_t index, bat_value; 407 int ret; 408 uint8_t bitmap[s->bitmap_size]; 409 410 // Check if sector_num is valid 411 if ((sector_num < 0) || (sector_num > bs->total_sectors)) 412 return -1; 413 414 // Write entry into in-memory BAT 415 index = (sector_num * 512) / s->block_size; 416 if (s->pagetable[index] != 0xFFFFFFFF) 417 return -1; 418 419 s->pagetable[index] = s->free_data_block_offset / 512; 420 421 // Initialize the block's bitmap 422 memset(bitmap, 0xff, s->bitmap_size); 423 ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap, 424 s->bitmap_size); 425 if (ret < 0) { 426 return ret; 427 } 428 429 // Write new footer (the old one will be overwritten) 430 s->free_data_block_offset += s->block_size + s->bitmap_size; 431 ret = rewrite_footer(bs); 432 if (ret < 0) 433 goto fail; 434 435 // Write BAT entry to disk 436 bat_offset = s->bat_offset + (4 * index); 437 bat_value = be32_to_cpu(s->pagetable[index]); 438 ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4); 439 if (ret < 0) 440 goto fail; 441 442 return get_sector_offset(bs, sector_num, 0); 443 444 fail: 445 s->free_data_block_offset -= (s->block_size + s->bitmap_size); 446 return -1; 447 } 448 449 static int vpc_read(BlockDriverState *bs, int64_t sector_num, 450 uint8_t *buf, int nb_sectors) 451 { 452 BDRVVPCState *s = bs->opaque; 453 int ret; 454 int64_t offset; 455 int64_t sectors, sectors_per_block; 456 VHDFooter *footer = (VHDFooter *) s->footer_buf; 457 458 if (cpu_to_be32(footer->type) == VHD_FIXED) { 459 return bdrv_read(bs->file, sector_num, buf, nb_sectors); 460 } 461 while (nb_sectors > 0) { 462 offset = get_sector_offset(bs, sector_num, 0); 463 464 sectors_per_block = s->block_size >> BDRV_SECTOR_BITS; 465 sectors = sectors_per_block - (sector_num % sectors_per_block); 466 if (sectors > nb_sectors) { 467 sectors = nb_sectors; 468 } 469 470 if (offset == -1) { 471 memset(buf, 0, sectors * BDRV_SECTOR_SIZE); 472 } else { 473 ret = bdrv_pread(bs->file, offset, buf, 474 sectors * BDRV_SECTOR_SIZE); 475 if (ret != sectors * BDRV_SECTOR_SIZE) { 476 return -1; 477 } 478 } 479 480 nb_sectors -= sectors; 481 sector_num += sectors; 482 buf += sectors * BDRV_SECTOR_SIZE; 483 } 484 return 0; 485 } 486 487 static coroutine_fn int vpc_co_read(BlockDriverState *bs, int64_t sector_num, 488 uint8_t *buf, int nb_sectors) 489 { 490 int ret; 491 BDRVVPCState *s = bs->opaque; 492 qemu_co_mutex_lock(&s->lock); 493 ret = vpc_read(bs, sector_num, buf, nb_sectors); 494 qemu_co_mutex_unlock(&s->lock); 495 return ret; 496 } 497 498 static int vpc_write(BlockDriverState *bs, int64_t sector_num, 499 const uint8_t *buf, int nb_sectors) 500 { 501 BDRVVPCState *s = bs->opaque; 502 int64_t offset; 503 int64_t sectors, sectors_per_block; 504 int ret; 505 VHDFooter *footer = (VHDFooter *) s->footer_buf; 506 507 if (cpu_to_be32(footer->type) == VHD_FIXED) { 508 return bdrv_write(bs->file, sector_num, buf, nb_sectors); 509 } 510 while (nb_sectors > 0) { 511 offset = get_sector_offset(bs, sector_num, 1); 512 513 sectors_per_block = s->block_size >> BDRV_SECTOR_BITS; 514 sectors = sectors_per_block - (sector_num % sectors_per_block); 515 if (sectors > nb_sectors) { 516 sectors = nb_sectors; 517 } 518 519 if (offset == -1) { 520 offset = alloc_block(bs, sector_num); 521 if (offset < 0) 522 return -1; 523 } 524 525 ret = bdrv_pwrite(bs->file, offset, buf, sectors * BDRV_SECTOR_SIZE); 526 if (ret != sectors * BDRV_SECTOR_SIZE) { 527 return -1; 528 } 529 530 nb_sectors -= sectors; 531 sector_num += sectors; 532 buf += sectors * BDRV_SECTOR_SIZE; 533 } 534 535 return 0; 536 } 537 538 static coroutine_fn int vpc_co_write(BlockDriverState *bs, int64_t sector_num, 539 const uint8_t *buf, int nb_sectors) 540 { 541 int ret; 542 BDRVVPCState *s = bs->opaque; 543 qemu_co_mutex_lock(&s->lock); 544 ret = vpc_write(bs, sector_num, buf, nb_sectors); 545 qemu_co_mutex_unlock(&s->lock); 546 return ret; 547 } 548 549 /* 550 * Calculates the number of cylinders, heads and sectors per cylinder 551 * based on a given number of sectors. This is the algorithm described 552 * in the VHD specification. 553 * 554 * Note that the geometry doesn't always exactly match total_sectors but 555 * may round it down. 556 * 557 * Returns 0 on success, -EFBIG if the size is larger than ~2 TB. Override 558 * the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB) 559 * and instead allow up to 255 heads. 560 */ 561 static int calculate_geometry(int64_t total_sectors, uint16_t* cyls, 562 uint8_t* heads, uint8_t* secs_per_cyl) 563 { 564 uint32_t cyls_times_heads; 565 566 /* Allow a maximum disk size of approximately 2 TB */ 567 if (total_sectors > 65535LL * 255 * 255) { 568 return -EFBIG; 569 } 570 571 if (total_sectors > 65535 * 16 * 63) { 572 *secs_per_cyl = 255; 573 if (total_sectors > 65535 * 16 * 255) { 574 *heads = 255; 575 } else { 576 *heads = 16; 577 } 578 cyls_times_heads = total_sectors / *secs_per_cyl; 579 } else { 580 *secs_per_cyl = 17; 581 cyls_times_heads = total_sectors / *secs_per_cyl; 582 *heads = (cyls_times_heads + 1023) / 1024; 583 584 if (*heads < 4) 585 *heads = 4; 586 587 if (cyls_times_heads >= (*heads * 1024) || *heads > 16) { 588 *secs_per_cyl = 31; 589 *heads = 16; 590 cyls_times_heads = total_sectors / *secs_per_cyl; 591 } 592 593 if (cyls_times_heads >= (*heads * 1024)) { 594 *secs_per_cyl = 63; 595 *heads = 16; 596 cyls_times_heads = total_sectors / *secs_per_cyl; 597 } 598 } 599 600 *cyls = cyls_times_heads / *heads; 601 602 return 0; 603 } 604 605 static int create_dynamic_disk(int fd, uint8_t *buf, int64_t total_sectors) 606 { 607 VHDDynDiskHeader *dyndisk_header = 608 (VHDDynDiskHeader *) buf; 609 size_t block_size, num_bat_entries; 610 int i; 611 int ret = -EIO; 612 613 // Write the footer (twice: at the beginning and at the end) 614 block_size = 0x200000; 615 num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512); 616 617 if (write(fd, buf, HEADER_SIZE) != HEADER_SIZE) { 618 goto fail; 619 } 620 621 if (lseek(fd, 1536 + ((num_bat_entries * 4 + 511) & ~511), SEEK_SET) < 0) { 622 goto fail; 623 } 624 if (write(fd, buf, HEADER_SIZE) != HEADER_SIZE) { 625 goto fail; 626 } 627 628 // Write the initial BAT 629 if (lseek(fd, 3 * 512, SEEK_SET) < 0) { 630 goto fail; 631 } 632 633 memset(buf, 0xFF, 512); 634 for (i = 0; i < (num_bat_entries * 4 + 511) / 512; i++) { 635 if (write(fd, buf, 512) != 512) { 636 goto fail; 637 } 638 } 639 640 // Prepare the Dynamic Disk Header 641 memset(buf, 0, 1024); 642 643 memcpy(dyndisk_header->magic, "cxsparse", 8); 644 645 /* 646 * Note: The spec is actually wrong here for data_offset, it says 647 * 0xFFFFFFFF, but MS tools expect all 64 bits to be set. 648 */ 649 dyndisk_header->data_offset = be64_to_cpu(0xFFFFFFFFFFFFFFFFULL); 650 dyndisk_header->table_offset = be64_to_cpu(3 * 512); 651 dyndisk_header->version = be32_to_cpu(0x00010000); 652 dyndisk_header->block_size = be32_to_cpu(block_size); 653 dyndisk_header->max_table_entries = be32_to_cpu(num_bat_entries); 654 655 dyndisk_header->checksum = be32_to_cpu(vpc_checksum(buf, 1024)); 656 657 // Write the header 658 if (lseek(fd, 512, SEEK_SET) < 0) { 659 goto fail; 660 } 661 662 if (write(fd, buf, 1024) != 1024) { 663 goto fail; 664 } 665 ret = 0; 666 667 fail: 668 return ret; 669 } 670 671 static int create_fixed_disk(int fd, uint8_t *buf, int64_t total_size) 672 { 673 int ret = -EIO; 674 675 /* Add footer to total size */ 676 total_size += 512; 677 if (ftruncate(fd, total_size) != 0) { 678 ret = -errno; 679 goto fail; 680 } 681 if (lseek(fd, -512, SEEK_END) < 0) { 682 goto fail; 683 } 684 if (write(fd, buf, HEADER_SIZE) != HEADER_SIZE) { 685 goto fail; 686 } 687 688 ret = 0; 689 690 fail: 691 return ret; 692 } 693 694 static int vpc_create(const char *filename, QEMUOptionParameter *options, 695 Error **errp) 696 { 697 uint8_t buf[1024]; 698 VHDFooter *footer = (VHDFooter *) buf; 699 QEMUOptionParameter *disk_type_param; 700 int fd, i; 701 uint16_t cyls = 0; 702 uint8_t heads = 0; 703 uint8_t secs_per_cyl = 0; 704 int64_t total_sectors; 705 int64_t total_size; 706 int disk_type; 707 int ret = -EIO; 708 709 /* Read out options */ 710 total_size = get_option_parameter(options, BLOCK_OPT_SIZE)->value.n; 711 712 disk_type_param = get_option_parameter(options, BLOCK_OPT_SUBFMT); 713 if (disk_type_param && disk_type_param->value.s) { 714 if (!strcmp(disk_type_param->value.s, "dynamic")) { 715 disk_type = VHD_DYNAMIC; 716 } else if (!strcmp(disk_type_param->value.s, "fixed")) { 717 disk_type = VHD_FIXED; 718 } else { 719 return -EINVAL; 720 } 721 } else { 722 disk_type = VHD_DYNAMIC; 723 } 724 725 /* Create the file */ 726 fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644); 727 if (fd < 0) { 728 return -EIO; 729 } 730 731 /* 732 * Calculate matching total_size and geometry. Increase the number of 733 * sectors requested until we get enough (or fail). This ensures that 734 * qemu-img convert doesn't truncate images, but rather rounds up. 735 */ 736 total_sectors = total_size / BDRV_SECTOR_SIZE; 737 for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) { 738 if (calculate_geometry(total_sectors + i, &cyls, &heads, 739 &secs_per_cyl)) 740 { 741 ret = -EFBIG; 742 goto fail; 743 } 744 } 745 746 total_sectors = (int64_t) cyls * heads * secs_per_cyl; 747 748 /* Prepare the Hard Disk Footer */ 749 memset(buf, 0, 1024); 750 751 memcpy(footer->creator, "conectix", 8); 752 /* TODO Check if "qemu" creator_app is ok for VPC */ 753 memcpy(footer->creator_app, "qemu", 4); 754 memcpy(footer->creator_os, "Wi2k", 4); 755 756 footer->features = be32_to_cpu(0x02); 757 footer->version = be32_to_cpu(0x00010000); 758 if (disk_type == VHD_DYNAMIC) { 759 footer->data_offset = be64_to_cpu(HEADER_SIZE); 760 } else { 761 footer->data_offset = be64_to_cpu(0xFFFFFFFFFFFFFFFFULL); 762 } 763 footer->timestamp = be32_to_cpu(time(NULL) - VHD_TIMESTAMP_BASE); 764 765 /* Version of Virtual PC 2007 */ 766 footer->major = be16_to_cpu(0x0005); 767 footer->minor = be16_to_cpu(0x0003); 768 if (disk_type == VHD_DYNAMIC) { 769 footer->orig_size = be64_to_cpu(total_sectors * 512); 770 footer->size = be64_to_cpu(total_sectors * 512); 771 } else { 772 footer->orig_size = be64_to_cpu(total_size); 773 footer->size = be64_to_cpu(total_size); 774 } 775 footer->cyls = be16_to_cpu(cyls); 776 footer->heads = heads; 777 footer->secs_per_cyl = secs_per_cyl; 778 779 footer->type = be32_to_cpu(disk_type); 780 781 #if defined(CONFIG_UUID) 782 uuid_generate(footer->uuid); 783 #endif 784 785 footer->checksum = be32_to_cpu(vpc_checksum(buf, HEADER_SIZE)); 786 787 if (disk_type == VHD_DYNAMIC) { 788 ret = create_dynamic_disk(fd, buf, total_sectors); 789 } else { 790 ret = create_fixed_disk(fd, buf, total_size); 791 } 792 793 fail: 794 qemu_close(fd); 795 return ret; 796 } 797 798 static int vpc_has_zero_init(BlockDriverState *bs) 799 { 800 BDRVVPCState *s = bs->opaque; 801 VHDFooter *footer = (VHDFooter *) s->footer_buf; 802 803 if (cpu_to_be32(footer->type) == VHD_FIXED) { 804 return bdrv_has_zero_init(bs->file); 805 } else { 806 return 1; 807 } 808 } 809 810 static void vpc_close(BlockDriverState *bs) 811 { 812 BDRVVPCState *s = bs->opaque; 813 g_free(s->pagetable); 814 #ifdef CACHE 815 g_free(s->pageentry_u8); 816 #endif 817 818 migrate_del_blocker(s->migration_blocker); 819 error_free(s->migration_blocker); 820 } 821 822 static QEMUOptionParameter vpc_create_options[] = { 823 { 824 .name = BLOCK_OPT_SIZE, 825 .type = OPT_SIZE, 826 .help = "Virtual disk size" 827 }, 828 { 829 .name = BLOCK_OPT_SUBFMT, 830 .type = OPT_STRING, 831 .help = 832 "Type of virtual hard disk format. Supported formats are " 833 "{dynamic (default) | fixed} " 834 }, 835 { NULL } 836 }; 837 838 static BlockDriver bdrv_vpc = { 839 .format_name = "vpc", 840 .instance_size = sizeof(BDRVVPCState), 841 842 .bdrv_probe = vpc_probe, 843 .bdrv_open = vpc_open, 844 .bdrv_close = vpc_close, 845 .bdrv_reopen_prepare = vpc_reopen_prepare, 846 .bdrv_create = vpc_create, 847 848 .bdrv_read = vpc_co_read, 849 .bdrv_write = vpc_co_write, 850 851 .create_options = vpc_create_options, 852 .bdrv_has_zero_init = vpc_has_zero_init, 853 }; 854 855 static void bdrv_vpc_init(void) 856 { 857 bdrv_register(&bdrv_vpc); 858 } 859 860 block_init(bdrv_vpc_init); 861