1 /* 2 * Block driver for Hyper-V VHDX Images 3 * 4 * Copyright (c) 2013 Red Hat, Inc., 5 * 6 * Authors: 7 * Jeff Cody <jcody@redhat.com> 8 * 9 * This is based on the "VHDX Format Specification v1.00", published 8/25/2012 10 * by Microsoft: 11 * https://www.microsoft.com/en-us/download/details.aspx?id=34750 12 * 13 * This work is licensed under the terms of the GNU LGPL, version 2 or later. 14 * See the COPYING.LIB file in the top-level directory. 15 * 16 */ 17 18 #include "qemu/osdep.h" 19 #include "qapi/error.h" 20 #include "block/block_int.h" 21 #include "sysemu/block-backend.h" 22 #include "qemu/module.h" 23 #include "qemu/option.h" 24 #include "qemu/crc32c.h" 25 #include "qemu/bswap.h" 26 #include "vhdx.h" 27 #include "migration/blocker.h" 28 #include "qemu/uuid.h" 29 #include "qapi/qmp/qdict.h" 30 #include "qapi/qobject-input-visitor.h" 31 #include "qapi/qapi-visit-block-core.h" 32 33 /* Options for VHDX creation */ 34 35 #define VHDX_BLOCK_OPT_LOG_SIZE "log_size" 36 #define VHDX_BLOCK_OPT_BLOCK_SIZE "block_size" 37 #define VHDX_BLOCK_OPT_ZERO "block_state_zero" 38 39 typedef enum VHDXImageType { 40 VHDX_TYPE_DYNAMIC = 0, 41 VHDX_TYPE_FIXED, 42 VHDX_TYPE_DIFFERENCING, /* Currently unsupported */ 43 } VHDXImageType; 44 45 static QemuOptsList vhdx_create_opts; 46 47 /* Several metadata and region table data entries are identified by 48 * guids in a MS-specific GUID format. */ 49 50 51 /* ------- Known Region Table GUIDs ---------------------- */ 52 static const MSGUID bat_guid = { .data1 = 0x2dc27766, 53 .data2 = 0xf623, 54 .data3 = 0x4200, 55 .data4 = { 0x9d, 0x64, 0x11, 0x5e, 56 0x9b, 0xfd, 0x4a, 0x08} }; 57 58 static const MSGUID metadata_guid = { .data1 = 0x8b7ca206, 59 .data2 = 0x4790, 60 .data3 = 0x4b9a, 61 .data4 = { 0xb8, 0xfe, 0x57, 0x5f, 62 0x05, 0x0f, 0x88, 0x6e} }; 63 64 65 66 /* ------- Known Metadata Entry GUIDs ---------------------- */ 67 static const MSGUID file_param_guid = { .data1 = 0xcaa16737, 68 .data2 = 0xfa36, 69 .data3 = 0x4d43, 70 .data4 = { 0xb3, 0xb6, 0x33, 0xf0, 71 0xaa, 0x44, 0xe7, 0x6b} }; 72 73 static const MSGUID virtual_size_guid = { .data1 = 0x2FA54224, 74 .data2 = 0xcd1b, 75 .data3 = 0x4876, 76 .data4 = { 0xb2, 0x11, 0x5d, 0xbe, 77 0xd8, 0x3b, 0xf4, 0xb8} }; 78 79 static const MSGUID page83_guid = { .data1 = 0xbeca12ab, 80 .data2 = 0xb2e6, 81 .data3 = 0x4523, 82 .data4 = { 0x93, 0xef, 0xc3, 0x09, 83 0xe0, 0x00, 0xc7, 0x46} }; 84 85 86 static const MSGUID phys_sector_guid = { .data1 = 0xcda348c7, 87 .data2 = 0x445d, 88 .data3 = 0x4471, 89 .data4 = { 0x9c, 0xc9, 0xe9, 0x88, 90 0x52, 0x51, 0xc5, 0x56} }; 91 92 static const MSGUID parent_locator_guid = { .data1 = 0xa8d35f2d, 93 .data2 = 0xb30b, 94 .data3 = 0x454d, 95 .data4 = { 0xab, 0xf7, 0xd3, 96 0xd8, 0x48, 0x34, 97 0xab, 0x0c} }; 98 99 static const MSGUID logical_sector_guid = { .data1 = 0x8141bf1d, 100 .data2 = 0xa96f, 101 .data3 = 0x4709, 102 .data4 = { 0xba, 0x47, 0xf2, 103 0x33, 0xa8, 0xfa, 104 0xab, 0x5f} }; 105 106 /* Each parent type must have a valid GUID; this is for parent images 107 * of type 'VHDX'. If we were to allow e.g. a QCOW2 parent, we would 108 * need to make up our own QCOW2 GUID type */ 109 static const MSGUID parent_vhdx_guid __attribute__((unused)) 110 = { .data1 = 0xb04aefb7, 111 .data2 = 0xd19e, 112 .data3 = 0x4a81, 113 .data4 = { 0xb7, 0x89, 0x25, 0xb8, 114 0xe9, 0x44, 0x59, 0x13} }; 115 116 117 #define META_FILE_PARAMETER_PRESENT 0x01 118 #define META_VIRTUAL_DISK_SIZE_PRESENT 0x02 119 #define META_PAGE_83_PRESENT 0x04 120 #define META_LOGICAL_SECTOR_SIZE_PRESENT 0x08 121 #define META_PHYS_SECTOR_SIZE_PRESENT 0x10 122 #define META_PARENT_LOCATOR_PRESENT 0x20 123 124 #define META_ALL_PRESENT \ 125 (META_FILE_PARAMETER_PRESENT | META_VIRTUAL_DISK_SIZE_PRESENT | \ 126 META_PAGE_83_PRESENT | META_LOGICAL_SECTOR_SIZE_PRESENT | \ 127 META_PHYS_SECTOR_SIZE_PRESENT) 128 129 130 typedef struct VHDXSectorInfo { 131 uint32_t bat_idx; /* BAT entry index */ 132 uint32_t sectors_avail; /* sectors available in payload block */ 133 uint32_t bytes_left; /* bytes left in the block after data to r/w */ 134 uint32_t bytes_avail; /* bytes available in payload block */ 135 uint64_t file_offset; /* absolute offset in bytes, in file */ 136 uint64_t block_offset; /* block offset, in bytes */ 137 } VHDXSectorInfo; 138 139 /* Calculates new checksum. 140 * 141 * Zero is substituted during crc calculation for the original crc field 142 * crc_offset: byte offset in buf of the buffer crc 143 * buf: buffer pointer 144 * size: size of buffer (must be > crc_offset+4) 145 * 146 * Note: The buffer should have all multi-byte data in little-endian format, 147 * and the resulting checksum is in little endian format. 148 */ 149 uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset) 150 { 151 uint32_t crc; 152 153 assert(buf != NULL); 154 assert(size > (crc_offset + sizeof(crc))); 155 156 memset(buf + crc_offset, 0, sizeof(crc)); 157 crc = crc32c(0xffffffff, buf, size); 158 cpu_to_le32s(&crc); 159 memcpy(buf + crc_offset, &crc, sizeof(crc)); 160 161 return crc; 162 } 163 164 uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size, 165 int crc_offset) 166 { 167 uint32_t crc_new; 168 uint32_t crc_orig; 169 assert(buf != NULL); 170 171 if (crc_offset > 0) { 172 memcpy(&crc_orig, buf + crc_offset, sizeof(crc_orig)); 173 memset(buf + crc_offset, 0, sizeof(crc_orig)); 174 } 175 176 crc_new = crc32c(crc, buf, size); 177 if (crc_offset > 0) { 178 memcpy(buf + crc_offset, &crc_orig, sizeof(crc_orig)); 179 } 180 181 return crc_new; 182 } 183 184 /* Validates the checksum of the buffer, with an in-place CRC. 185 * 186 * Zero is substituted during crc calculation for the original crc field, 187 * and the crc field is restored afterwards. But the buffer will be modifed 188 * during the calculation, so this may not be not suitable for multi-threaded 189 * use. 190 * 191 * crc_offset: byte offset in buf of the buffer crc 192 * buf: buffer pointer 193 * size: size of buffer (must be > crc_offset+4) 194 * 195 * returns true if checksum is valid, false otherwise 196 */ 197 bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset) 198 { 199 uint32_t crc_orig; 200 uint32_t crc; 201 202 assert(buf != NULL); 203 assert(size > (crc_offset + 4)); 204 205 memcpy(&crc_orig, buf + crc_offset, sizeof(crc_orig)); 206 crc_orig = le32_to_cpu(crc_orig); 207 208 crc = vhdx_checksum_calc(0xffffffff, buf, size, crc_offset); 209 210 return crc == crc_orig; 211 } 212 213 214 /* 215 * This generates a UUID that is compliant with the MS GUIDs used 216 * in the VHDX spec (and elsewhere). 217 */ 218 void vhdx_guid_generate(MSGUID *guid) 219 { 220 QemuUUID uuid; 221 assert(guid != NULL); 222 223 qemu_uuid_generate(&uuid); 224 memcpy(guid, &uuid, sizeof(MSGUID)); 225 } 226 227 /* Check for region overlaps inside the VHDX image */ 228 static int vhdx_region_check(BDRVVHDXState *s, uint64_t start, uint64_t length) 229 { 230 int ret = 0; 231 uint64_t end; 232 VHDXRegionEntry *r; 233 234 end = start + length; 235 QLIST_FOREACH(r, &s->regions, entries) { 236 if (!((start >= r->end) || (end <= r->start))) { 237 ret = -EINVAL; 238 goto exit; 239 } 240 } 241 242 exit: 243 return ret; 244 } 245 246 /* Register a region for future checks */ 247 static void vhdx_region_register(BDRVVHDXState *s, 248 uint64_t start, uint64_t length) 249 { 250 VHDXRegionEntry *r; 251 252 r = g_malloc0(sizeof(*r)); 253 254 r->start = start; 255 r->end = start + length; 256 257 QLIST_INSERT_HEAD(&s->regions, r, entries); 258 } 259 260 /* Free all registered regions */ 261 static void vhdx_region_unregister_all(BDRVVHDXState *s) 262 { 263 VHDXRegionEntry *r, *r_next; 264 265 QLIST_FOREACH_SAFE(r, &s->regions, entries, r_next) { 266 QLIST_REMOVE(r, entries); 267 g_free(r); 268 } 269 } 270 271 static void vhdx_set_shift_bits(BDRVVHDXState *s) 272 { 273 s->logical_sector_size_bits = ctz32(s->logical_sector_size); 274 s->sectors_per_block_bits = ctz32(s->sectors_per_block); 275 s->chunk_ratio_bits = ctz64(s->chunk_ratio); 276 s->block_size_bits = ctz32(s->block_size); 277 } 278 279 /* 280 * Per the MS VHDX Specification, for every VHDX file: 281 * - The header section is fixed size - 1 MB 282 * - The header section is always the first "object" 283 * - The first 64KB of the header is the File Identifier 284 * - The first uint64 (8 bytes) is the VHDX Signature ("vhdxfile") 285 * - The following 512 bytes constitute a UTF-16 string identifiying the 286 * software that created the file, and is optional and diagnostic only. 287 * 288 * Therefore, we probe by looking for the vhdxfile signature "vhdxfile" 289 */ 290 static int vhdx_probe(const uint8_t *buf, int buf_size, const char *filename) 291 { 292 if (buf_size >= 8 && !memcmp(buf, "vhdxfile", 8)) { 293 return 100; 294 } 295 return 0; 296 } 297 298 /* 299 * Writes the header to the specified offset. 300 * 301 * This will optionally read in buffer data from disk (otherwise zero-fill), 302 * and then update the header checksum. Header is converted to proper 303 * endianness before being written to the specified file offset 304 */ 305 static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr, 306 uint64_t offset, bool read) 307 { 308 BlockDriverState *bs_file = file->bs; 309 uint8_t *buffer = NULL; 310 int ret; 311 VHDXHeader *header_le; 312 313 assert(bs_file != NULL); 314 assert(hdr != NULL); 315 316 /* the header checksum is not over just the packed size of VHDXHeader, 317 * but rather over the entire 'reserved' range for the header, which is 318 * 4KB (VHDX_HEADER_SIZE). */ 319 320 buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE); 321 if (read) { 322 /* if true, we can't assume the extra reserved bytes are 0 */ 323 ret = bdrv_pread(file, offset, buffer, VHDX_HEADER_SIZE); 324 if (ret < 0) { 325 goto exit; 326 } 327 } else { 328 memset(buffer, 0, VHDX_HEADER_SIZE); 329 } 330 331 /* overwrite the actual VHDXHeader portion */ 332 header_le = (VHDXHeader *)buffer; 333 memcpy(header_le, hdr, sizeof(VHDXHeader)); 334 vhdx_header_le_export(hdr, header_le); 335 vhdx_update_checksum(buffer, VHDX_HEADER_SIZE, 336 offsetof(VHDXHeader, checksum)); 337 ret = bdrv_pwrite_sync(file, offset, header_le, sizeof(VHDXHeader)); 338 339 exit: 340 qemu_vfree(buffer); 341 return ret; 342 } 343 344 /* Update the VHDX headers 345 * 346 * This follows the VHDX spec procedures for header updates. 347 * 348 * - non-current header is updated with largest sequence number 349 */ 350 static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, 351 bool generate_data_write_guid, MSGUID *log_guid) 352 { 353 int ret = 0; 354 int hdr_idx = 0; 355 uint64_t header_offset = VHDX_HEADER1_OFFSET; 356 357 VHDXHeader *active_header; 358 VHDXHeader *inactive_header; 359 360 /* operate on the non-current header */ 361 if (s->curr_header == 0) { 362 hdr_idx = 1; 363 header_offset = VHDX_HEADER2_OFFSET; 364 } 365 366 active_header = s->headers[s->curr_header]; 367 inactive_header = s->headers[hdr_idx]; 368 369 inactive_header->sequence_number = active_header->sequence_number + 1; 370 371 /* a new file guid must be generated before any file write, including 372 * headers */ 373 inactive_header->file_write_guid = s->session_guid; 374 375 /* a new data guid only needs to be generated before any guest-visible 376 * writes (i.e. something observable via virtual disk read) */ 377 if (generate_data_write_guid) { 378 vhdx_guid_generate(&inactive_header->data_write_guid); 379 } 380 381 /* update the log guid if present */ 382 if (log_guid) { 383 inactive_header->log_guid = *log_guid; 384 } 385 386 ret = vhdx_write_header(bs->file, inactive_header, header_offset, true); 387 if (ret < 0) { 388 goto exit; 389 } 390 s->curr_header = hdr_idx; 391 392 exit: 393 return ret; 394 } 395 396 /* 397 * The VHDX spec calls for header updates to be performed twice, so that both 398 * the current and non-current header have valid info 399 */ 400 int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, 401 bool generate_data_write_guid, MSGUID *log_guid) 402 { 403 int ret; 404 405 ret = vhdx_update_header(bs, s, generate_data_write_guid, log_guid); 406 if (ret < 0) { 407 return ret; 408 } 409 ret = vhdx_update_header(bs, s, generate_data_write_guid, log_guid); 410 return ret; 411 } 412 413 /* opens the specified header block from the VHDX file header section */ 414 static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s, 415 Error **errp) 416 { 417 int ret; 418 VHDXHeader *header1; 419 VHDXHeader *header2; 420 bool h1_valid = false; 421 bool h2_valid = false; 422 uint64_t h1_seq = 0; 423 uint64_t h2_seq = 0; 424 uint8_t *buffer; 425 426 /* header1 & header2 are freed in vhdx_close() */ 427 header1 = qemu_blockalign(bs, sizeof(VHDXHeader)); 428 header2 = qemu_blockalign(bs, sizeof(VHDXHeader)); 429 430 buffer = qemu_blockalign(bs, VHDX_HEADER_SIZE); 431 432 s->headers[0] = header1; 433 s->headers[1] = header2; 434 435 /* We have to read the whole VHDX_HEADER_SIZE instead of 436 * sizeof(VHDXHeader), because the checksum is over the whole 437 * region */ 438 ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer, 439 VHDX_HEADER_SIZE); 440 if (ret < 0) { 441 goto fail; 442 } 443 /* copy over just the relevant portion that we need */ 444 memcpy(header1, buffer, sizeof(VHDXHeader)); 445 446 if (vhdx_checksum_is_valid(buffer, VHDX_HEADER_SIZE, 4)) { 447 vhdx_header_le_import(header1); 448 if (header1->signature == VHDX_HEADER_SIGNATURE && 449 header1->version == 1) { 450 h1_seq = header1->sequence_number; 451 h1_valid = true; 452 } 453 } 454 455 ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, buffer, 456 VHDX_HEADER_SIZE); 457 if (ret < 0) { 458 goto fail; 459 } 460 /* copy over just the relevant portion that we need */ 461 memcpy(header2, buffer, sizeof(VHDXHeader)); 462 463 if (vhdx_checksum_is_valid(buffer, VHDX_HEADER_SIZE, 4)) { 464 vhdx_header_le_import(header2); 465 if (header2->signature == VHDX_HEADER_SIGNATURE && 466 header2->version == 1) { 467 h2_seq = header2->sequence_number; 468 h2_valid = true; 469 } 470 } 471 472 /* If there is only 1 valid header (or no valid headers), we 473 * don't care what the sequence numbers are */ 474 if (h1_valid && !h2_valid) { 475 s->curr_header = 0; 476 } else if (!h1_valid && h2_valid) { 477 s->curr_header = 1; 478 } else if (!h1_valid && !h2_valid) { 479 goto fail; 480 } else { 481 /* If both headers are valid, then we choose the active one by the 482 * highest sequence number. If the sequence numbers are equal, that is 483 * invalid */ 484 if (h1_seq > h2_seq) { 485 s->curr_header = 0; 486 } else if (h2_seq > h1_seq) { 487 s->curr_header = 1; 488 } else { 489 /* The Microsoft Disk2VHD tool will create 2 identical 490 * headers, with identical sequence numbers. If the headers are 491 * identical, don't consider the file corrupt */ 492 if (!memcmp(header1, header2, sizeof(VHDXHeader))) { 493 s->curr_header = 0; 494 } else { 495 goto fail; 496 } 497 } 498 } 499 500 vhdx_region_register(s, s->headers[s->curr_header]->log_offset, 501 s->headers[s->curr_header]->log_length); 502 goto exit; 503 504 fail: 505 error_setg_errno(errp, -ret, "No valid VHDX header found"); 506 qemu_vfree(header1); 507 qemu_vfree(header2); 508 s->headers[0] = NULL; 509 s->headers[1] = NULL; 510 exit: 511 qemu_vfree(buffer); 512 } 513 514 515 static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s) 516 { 517 int ret = 0; 518 uint8_t *buffer; 519 int offset = 0; 520 VHDXRegionTableEntry rt_entry; 521 uint32_t i; 522 bool bat_rt_found = false; 523 bool metadata_rt_found = false; 524 525 /* We have to read the whole 64KB block, because the crc32 is over the 526 * whole block */ 527 buffer = qemu_blockalign(bs, VHDX_HEADER_BLOCK_SIZE); 528 529 ret = bdrv_pread(bs->file, VHDX_REGION_TABLE_OFFSET, buffer, 530 VHDX_HEADER_BLOCK_SIZE); 531 if (ret < 0) { 532 goto fail; 533 } 534 memcpy(&s->rt, buffer, sizeof(s->rt)); 535 offset += sizeof(s->rt); 536 537 if (!vhdx_checksum_is_valid(buffer, VHDX_HEADER_BLOCK_SIZE, 4)) { 538 ret = -EINVAL; 539 goto fail; 540 } 541 542 vhdx_region_header_le_import(&s->rt); 543 544 if (s->rt.signature != VHDX_REGION_SIGNATURE) { 545 ret = -EINVAL; 546 goto fail; 547 } 548 549 550 /* Per spec, maximum region table entry count is 2047 */ 551 if (s->rt.entry_count > 2047) { 552 ret = -EINVAL; 553 goto fail; 554 } 555 556 for (i = 0; i < s->rt.entry_count; i++) { 557 memcpy(&rt_entry, buffer + offset, sizeof(rt_entry)); 558 offset += sizeof(rt_entry); 559 560 vhdx_region_entry_le_import(&rt_entry); 561 562 /* check for region overlap between these entries, and any 563 * other memory regions in the file */ 564 ret = vhdx_region_check(s, rt_entry.file_offset, rt_entry.length); 565 if (ret < 0) { 566 goto fail; 567 } 568 569 vhdx_region_register(s, rt_entry.file_offset, rt_entry.length); 570 571 /* see if we recognize the entry */ 572 if (guid_eq(rt_entry.guid, bat_guid)) { 573 /* must be unique; if we have already found it this is invalid */ 574 if (bat_rt_found) { 575 ret = -EINVAL; 576 goto fail; 577 } 578 bat_rt_found = true; 579 s->bat_rt = rt_entry; 580 continue; 581 } 582 583 if (guid_eq(rt_entry.guid, metadata_guid)) { 584 /* must be unique; if we have already found it this is invalid */ 585 if (metadata_rt_found) { 586 ret = -EINVAL; 587 goto fail; 588 } 589 metadata_rt_found = true; 590 s->metadata_rt = rt_entry; 591 continue; 592 } 593 594 if (rt_entry.data_bits & VHDX_REGION_ENTRY_REQUIRED) { 595 /* cannot read vhdx file - required region table entry that 596 * we do not understand. per spec, we must fail to open */ 597 ret = -ENOTSUP; 598 goto fail; 599 } 600 } 601 602 if (!bat_rt_found || !metadata_rt_found) { 603 ret = -EINVAL; 604 goto fail; 605 } 606 607 ret = 0; 608 609 fail: 610 qemu_vfree(buffer); 611 return ret; 612 } 613 614 615 616 /* Metadata initial parser 617 * 618 * This loads all the metadata entry fields. This may cause additional 619 * fields to be processed (e.g. parent locator, etc..). 620 * 621 * There are 5 Metadata items that are always required: 622 * - File Parameters (block size, has a parent) 623 * - Virtual Disk Size (size, in bytes, of the virtual drive) 624 * - Page 83 Data (scsi page 83 guid) 625 * - Logical Sector Size (logical sector size in bytes, either 512 or 626 * 4096. We only support 512 currently) 627 * - Physical Sector Size (512 or 4096) 628 * 629 * Also, if the File Parameters indicate this is a differencing file, 630 * we must also look for the Parent Locator metadata item. 631 */ 632 static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s) 633 { 634 int ret = 0; 635 uint8_t *buffer; 636 int offset = 0; 637 uint32_t i = 0; 638 VHDXMetadataTableEntry md_entry; 639 640 buffer = qemu_blockalign(bs, VHDX_METADATA_TABLE_MAX_SIZE); 641 642 ret = bdrv_pread(bs->file, s->metadata_rt.file_offset, buffer, 643 VHDX_METADATA_TABLE_MAX_SIZE); 644 if (ret < 0) { 645 goto exit; 646 } 647 memcpy(&s->metadata_hdr, buffer, sizeof(s->metadata_hdr)); 648 offset += sizeof(s->metadata_hdr); 649 650 vhdx_metadata_header_le_import(&s->metadata_hdr); 651 652 if (s->metadata_hdr.signature != VHDX_METADATA_SIGNATURE) { 653 ret = -EINVAL; 654 goto exit; 655 } 656 657 s->metadata_entries.present = 0; 658 659 if ((s->metadata_hdr.entry_count * sizeof(md_entry)) > 660 (VHDX_METADATA_TABLE_MAX_SIZE - offset)) { 661 ret = -EINVAL; 662 goto exit; 663 } 664 665 for (i = 0; i < s->metadata_hdr.entry_count; i++) { 666 memcpy(&md_entry, buffer + offset, sizeof(md_entry)); 667 offset += sizeof(md_entry); 668 669 vhdx_metadata_entry_le_import(&md_entry); 670 671 if (guid_eq(md_entry.item_id, file_param_guid)) { 672 if (s->metadata_entries.present & META_FILE_PARAMETER_PRESENT) { 673 ret = -EINVAL; 674 goto exit; 675 } 676 s->metadata_entries.file_parameters_entry = md_entry; 677 s->metadata_entries.present |= META_FILE_PARAMETER_PRESENT; 678 continue; 679 } 680 681 if (guid_eq(md_entry.item_id, virtual_size_guid)) { 682 if (s->metadata_entries.present & META_VIRTUAL_DISK_SIZE_PRESENT) { 683 ret = -EINVAL; 684 goto exit; 685 } 686 s->metadata_entries.virtual_disk_size_entry = md_entry; 687 s->metadata_entries.present |= META_VIRTUAL_DISK_SIZE_PRESENT; 688 continue; 689 } 690 691 if (guid_eq(md_entry.item_id, page83_guid)) { 692 if (s->metadata_entries.present & META_PAGE_83_PRESENT) { 693 ret = -EINVAL; 694 goto exit; 695 } 696 s->metadata_entries.page83_data_entry = md_entry; 697 s->metadata_entries.present |= META_PAGE_83_PRESENT; 698 continue; 699 } 700 701 if (guid_eq(md_entry.item_id, logical_sector_guid)) { 702 if (s->metadata_entries.present & 703 META_LOGICAL_SECTOR_SIZE_PRESENT) { 704 ret = -EINVAL; 705 goto exit; 706 } 707 s->metadata_entries.logical_sector_size_entry = md_entry; 708 s->metadata_entries.present |= META_LOGICAL_SECTOR_SIZE_PRESENT; 709 continue; 710 } 711 712 if (guid_eq(md_entry.item_id, phys_sector_guid)) { 713 if (s->metadata_entries.present & META_PHYS_SECTOR_SIZE_PRESENT) { 714 ret = -EINVAL; 715 goto exit; 716 } 717 s->metadata_entries.phys_sector_size_entry = md_entry; 718 s->metadata_entries.present |= META_PHYS_SECTOR_SIZE_PRESENT; 719 continue; 720 } 721 722 if (guid_eq(md_entry.item_id, parent_locator_guid)) { 723 if (s->metadata_entries.present & META_PARENT_LOCATOR_PRESENT) { 724 ret = -EINVAL; 725 goto exit; 726 } 727 s->metadata_entries.parent_locator_entry = md_entry; 728 s->metadata_entries.present |= META_PARENT_LOCATOR_PRESENT; 729 continue; 730 } 731 732 if (md_entry.data_bits & VHDX_META_FLAGS_IS_REQUIRED) { 733 /* cannot read vhdx file - required region table entry that 734 * we do not understand. per spec, we must fail to open */ 735 ret = -ENOTSUP; 736 goto exit; 737 } 738 } 739 740 if (s->metadata_entries.present != META_ALL_PRESENT) { 741 ret = -ENOTSUP; 742 goto exit; 743 } 744 745 ret = bdrv_pread(bs->file, 746 s->metadata_entries.file_parameters_entry.offset 747 + s->metadata_rt.file_offset, 748 &s->params, 749 sizeof(s->params)); 750 751 if (ret < 0) { 752 goto exit; 753 } 754 755 le32_to_cpus(&s->params.block_size); 756 le32_to_cpus(&s->params.data_bits); 757 758 759 /* We now have the file parameters, so we can tell if this is a 760 * differencing file (i.e.. has_parent), is dynamic or fixed 761 * sized (leave_blocks_allocated), and the block size */ 762 763 /* The parent locator required iff the file parameters has_parent set */ 764 if (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) { 765 if (s->metadata_entries.present & META_PARENT_LOCATOR_PRESENT) { 766 /* TODO: parse parent locator fields */ 767 ret = -ENOTSUP; /* temp, until differencing files are supported */ 768 goto exit; 769 } else { 770 /* if has_parent is set, but there is not parent locator present, 771 * then that is an invalid combination */ 772 ret = -EINVAL; 773 goto exit; 774 } 775 } 776 777 /* determine virtual disk size, logical sector size, 778 * and phys sector size */ 779 780 ret = bdrv_pread(bs->file, 781 s->metadata_entries.virtual_disk_size_entry.offset 782 + s->metadata_rt.file_offset, 783 &s->virtual_disk_size, 784 sizeof(uint64_t)); 785 if (ret < 0) { 786 goto exit; 787 } 788 ret = bdrv_pread(bs->file, 789 s->metadata_entries.logical_sector_size_entry.offset 790 + s->metadata_rt.file_offset, 791 &s->logical_sector_size, 792 sizeof(uint32_t)); 793 if (ret < 0) { 794 goto exit; 795 } 796 ret = bdrv_pread(bs->file, 797 s->metadata_entries.phys_sector_size_entry.offset 798 + s->metadata_rt.file_offset, 799 &s->physical_sector_size, 800 sizeof(uint32_t)); 801 if (ret < 0) { 802 goto exit; 803 } 804 805 le64_to_cpus(&s->virtual_disk_size); 806 le32_to_cpus(&s->logical_sector_size); 807 le32_to_cpus(&s->physical_sector_size); 808 809 if (s->params.block_size < VHDX_BLOCK_SIZE_MIN || 810 s->params.block_size > VHDX_BLOCK_SIZE_MAX) { 811 ret = -EINVAL; 812 goto exit; 813 } 814 815 /* only 2 supported sector sizes */ 816 if (s->logical_sector_size != 512 && s->logical_sector_size != 4096) { 817 ret = -EINVAL; 818 goto exit; 819 } 820 821 /* Both block_size and sector_size are guaranteed powers of 2, below. 822 Due to range checks above, s->sectors_per_block can never be < 256 */ 823 s->sectors_per_block = s->params.block_size / s->logical_sector_size; 824 s->chunk_ratio = (VHDX_MAX_SECTORS_PER_BLOCK) * 825 (uint64_t)s->logical_sector_size / 826 (uint64_t)s->params.block_size; 827 828 /* These values are ones we will want to use for division / multiplication 829 * later on, and they are all guaranteed (per the spec) to be powers of 2, 830 * so we can take advantage of that for shift operations during 831 * reads/writes */ 832 if (s->logical_sector_size & (s->logical_sector_size - 1)) { 833 ret = -EINVAL; 834 goto exit; 835 } 836 if (s->sectors_per_block & (s->sectors_per_block - 1)) { 837 ret = -EINVAL; 838 goto exit; 839 } 840 if (s->chunk_ratio & (s->chunk_ratio - 1)) { 841 ret = -EINVAL; 842 goto exit; 843 } 844 s->block_size = s->params.block_size; 845 if (s->block_size & (s->block_size - 1)) { 846 ret = -EINVAL; 847 goto exit; 848 } 849 850 vhdx_set_shift_bits(s); 851 852 ret = 0; 853 854 exit: 855 qemu_vfree(buffer); 856 return ret; 857 } 858 859 /* 860 * Calculate the number of BAT entries, including sector 861 * bitmap entries. 862 */ 863 static void vhdx_calc_bat_entries(BDRVVHDXState *s) 864 { 865 uint32_t data_blocks_cnt, bitmap_blocks_cnt; 866 867 data_blocks_cnt = DIV_ROUND_UP(s->virtual_disk_size, s->block_size); 868 bitmap_blocks_cnt = DIV_ROUND_UP(data_blocks_cnt, s->chunk_ratio); 869 870 if (s->parent_entries) { 871 s->bat_entries = bitmap_blocks_cnt * (s->chunk_ratio + 1); 872 } else { 873 s->bat_entries = data_blocks_cnt + 874 ((data_blocks_cnt - 1) >> s->chunk_ratio_bits); 875 } 876 877 } 878 879 static void vhdx_close(BlockDriverState *bs) 880 { 881 BDRVVHDXState *s = bs->opaque; 882 qemu_vfree(s->headers[0]); 883 s->headers[0] = NULL; 884 qemu_vfree(s->headers[1]); 885 s->headers[1] = NULL; 886 qemu_vfree(s->bat); 887 s->bat = NULL; 888 qemu_vfree(s->parent_entries); 889 s->parent_entries = NULL; 890 migrate_del_blocker(s->migration_blocker); 891 error_free(s->migration_blocker); 892 qemu_vfree(s->log.hdr); 893 s->log.hdr = NULL; 894 vhdx_region_unregister_all(s); 895 } 896 897 static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, 898 Error **errp) 899 { 900 BDRVVHDXState *s = bs->opaque; 901 int ret = 0; 902 uint32_t i; 903 uint64_t signature; 904 Error *local_err = NULL; 905 906 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 907 false, errp); 908 if (!bs->file) { 909 return -EINVAL; 910 } 911 912 s->bat = NULL; 913 s->first_visible_write = true; 914 915 qemu_co_mutex_init(&s->lock); 916 QLIST_INIT(&s->regions); 917 918 /* validate the file signature */ 919 ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t)); 920 if (ret < 0) { 921 goto fail; 922 } 923 if (memcmp(&signature, "vhdxfile", 8)) { 924 ret = -EINVAL; 925 goto fail; 926 } 927 928 /* This is used for any header updates, for the file_write_guid. 929 * The spec dictates that a new value should be used for the first 930 * header update */ 931 vhdx_guid_generate(&s->session_guid); 932 933 vhdx_parse_header(bs, s, &local_err); 934 if (local_err != NULL) { 935 error_propagate(errp, local_err); 936 ret = -EINVAL; 937 goto fail; 938 } 939 940 ret = vhdx_parse_log(bs, s, &s->log_replayed_on_open, errp); 941 if (ret < 0) { 942 goto fail; 943 } 944 945 ret = vhdx_open_region_tables(bs, s); 946 if (ret < 0) { 947 goto fail; 948 } 949 950 ret = vhdx_parse_metadata(bs, s); 951 if (ret < 0) { 952 goto fail; 953 } 954 955 s->block_size = s->params.block_size; 956 957 /* the VHDX spec dictates that virtual_disk_size is always a multiple of 958 * logical_sector_size */ 959 bs->total_sectors = s->virtual_disk_size >> s->logical_sector_size_bits; 960 961 vhdx_calc_bat_entries(s); 962 963 s->bat_offset = s->bat_rt.file_offset; 964 965 if (s->bat_entries > s->bat_rt.length / sizeof(VHDXBatEntry)) { 966 /* BAT allocation is not large enough for all entries */ 967 ret = -EINVAL; 968 goto fail; 969 } 970 971 /* s->bat is freed in vhdx_close() */ 972 s->bat = qemu_try_blockalign(bs->file->bs, s->bat_rt.length); 973 if (s->bat == NULL) { 974 ret = -ENOMEM; 975 goto fail; 976 } 977 978 ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length); 979 if (ret < 0) { 980 goto fail; 981 } 982 983 uint64_t payblocks = s->chunk_ratio; 984 /* endian convert, and verify populated BAT field file offsets against 985 * region table and log entries */ 986 for (i = 0; i < s->bat_entries; i++) { 987 le64_to_cpus(&s->bat[i]); 988 if (payblocks--) { 989 /* payload bat entries */ 990 if ((s->bat[i] & VHDX_BAT_STATE_BIT_MASK) == 991 PAYLOAD_BLOCK_FULLY_PRESENT) { 992 ret = vhdx_region_check(s, s->bat[i] & VHDX_BAT_FILE_OFF_MASK, 993 s->block_size); 994 if (ret < 0) { 995 goto fail; 996 } 997 } 998 } else { 999 payblocks = s->chunk_ratio; 1000 /* Once differencing files are supported, verify sector bitmap 1001 * blocks here */ 1002 } 1003 } 1004 1005 /* Disable migration when VHDX images are used */ 1006 error_setg(&s->migration_blocker, "The vhdx format used by node '%s' " 1007 "does not support live migration", 1008 bdrv_get_device_or_node_name(bs)); 1009 ret = migrate_add_blocker(s->migration_blocker, &local_err); 1010 if (local_err) { 1011 error_propagate(errp, local_err); 1012 error_free(s->migration_blocker); 1013 goto fail; 1014 } 1015 1016 /* TODO: differencing files */ 1017 1018 return 0; 1019 fail: 1020 vhdx_close(bs); 1021 return ret; 1022 } 1023 1024 static int vhdx_reopen_prepare(BDRVReopenState *state, 1025 BlockReopenQueue *queue, Error **errp) 1026 { 1027 return 0; 1028 } 1029 1030 1031 /* 1032 * Perform sector to block offset translations, to get various 1033 * sector and file offsets into the image. See VHDXSectorInfo 1034 */ 1035 static void vhdx_block_translate(BDRVVHDXState *s, int64_t sector_num, 1036 int nb_sectors, VHDXSectorInfo *sinfo) 1037 { 1038 uint32_t block_offset; 1039 1040 sinfo->bat_idx = sector_num >> s->sectors_per_block_bits; 1041 /* effectively a modulo - this gives us the offset into the block 1042 * (in sector sizes) for our sector number */ 1043 block_offset = sector_num - (sinfo->bat_idx << s->sectors_per_block_bits); 1044 /* the chunk ratio gives us the interleaving of the sector 1045 * bitmaps, so we need to advance our page block index by the 1046 * sector bitmaps entry number */ 1047 sinfo->bat_idx += sinfo->bat_idx >> s->chunk_ratio_bits; 1048 1049 /* the number of sectors we can read/write in this cycle */ 1050 sinfo->sectors_avail = s->sectors_per_block - block_offset; 1051 1052 sinfo->bytes_left = sinfo->sectors_avail << s->logical_sector_size_bits; 1053 1054 if (sinfo->sectors_avail > nb_sectors) { 1055 sinfo->sectors_avail = nb_sectors; 1056 } 1057 1058 sinfo->bytes_avail = sinfo->sectors_avail << s->logical_sector_size_bits; 1059 1060 sinfo->file_offset = s->bat[sinfo->bat_idx] & VHDX_BAT_FILE_OFF_MASK; 1061 1062 sinfo->block_offset = block_offset << s->logical_sector_size_bits; 1063 1064 /* The file offset must be past the header section, so must be > 0 */ 1065 if (sinfo->file_offset == 0) { 1066 return; 1067 } 1068 1069 /* block offset is the offset in vhdx logical sectors, in 1070 * the payload data block. Convert that to a byte offset 1071 * in the block, and add in the payload data block offset 1072 * in the file, in bytes, to get the final read address */ 1073 1074 sinfo->file_offset += sinfo->block_offset; 1075 } 1076 1077 1078 static int vhdx_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 1079 { 1080 BDRVVHDXState *s = bs->opaque; 1081 1082 bdi->cluster_size = s->block_size; 1083 1084 bdi->unallocated_blocks_are_zero = 1085 (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) == 0; 1086 1087 return 0; 1088 } 1089 1090 1091 static coroutine_fn int vhdx_co_readv(BlockDriverState *bs, int64_t sector_num, 1092 int nb_sectors, QEMUIOVector *qiov) 1093 { 1094 BDRVVHDXState *s = bs->opaque; 1095 int ret = 0; 1096 VHDXSectorInfo sinfo; 1097 uint64_t bytes_done = 0; 1098 QEMUIOVector hd_qiov; 1099 1100 qemu_iovec_init(&hd_qiov, qiov->niov); 1101 1102 qemu_co_mutex_lock(&s->lock); 1103 1104 while (nb_sectors > 0) { 1105 /* We are a differencing file, so we need to inspect the sector bitmap 1106 * to see if we have the data or not */ 1107 if (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) { 1108 /* not supported yet */ 1109 ret = -ENOTSUP; 1110 goto exit; 1111 } else { 1112 vhdx_block_translate(s, sector_num, nb_sectors, &sinfo); 1113 1114 qemu_iovec_reset(&hd_qiov); 1115 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, sinfo.bytes_avail); 1116 1117 /* check the payload block state */ 1118 switch (s->bat[sinfo.bat_idx] & VHDX_BAT_STATE_BIT_MASK) { 1119 case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */ 1120 case PAYLOAD_BLOCK_UNDEFINED: 1121 case PAYLOAD_BLOCK_UNMAPPED: 1122 case PAYLOAD_BLOCK_UNMAPPED_v095: 1123 case PAYLOAD_BLOCK_ZERO: 1124 /* return zero */ 1125 qemu_iovec_memset(&hd_qiov, 0, 0, sinfo.bytes_avail); 1126 break; 1127 case PAYLOAD_BLOCK_FULLY_PRESENT: 1128 qemu_co_mutex_unlock(&s->lock); 1129 ret = bdrv_co_readv(bs->file, 1130 sinfo.file_offset >> BDRV_SECTOR_BITS, 1131 sinfo.sectors_avail, &hd_qiov); 1132 qemu_co_mutex_lock(&s->lock); 1133 if (ret < 0) { 1134 goto exit; 1135 } 1136 break; 1137 case PAYLOAD_BLOCK_PARTIALLY_PRESENT: 1138 /* we don't yet support difference files, fall through 1139 * to error */ 1140 default: 1141 ret = -EIO; 1142 goto exit; 1143 break; 1144 } 1145 nb_sectors -= sinfo.sectors_avail; 1146 sector_num += sinfo.sectors_avail; 1147 bytes_done += sinfo.bytes_avail; 1148 } 1149 } 1150 ret = 0; 1151 exit: 1152 qemu_co_mutex_unlock(&s->lock); 1153 qemu_iovec_destroy(&hd_qiov); 1154 return ret; 1155 } 1156 1157 /* 1158 * Allocate a new payload block at the end of the file. 1159 * 1160 * Allocation will happen at 1MB alignment inside the file 1161 * 1162 * Returns the file offset start of the new payload block 1163 */ 1164 static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s, 1165 uint64_t *new_offset) 1166 { 1167 int64_t current_len; 1168 1169 current_len = bdrv_getlength(bs->file->bs); 1170 if (current_len < 0) { 1171 return current_len; 1172 } 1173 1174 *new_offset = current_len; 1175 1176 /* per the spec, the address for a block is in units of 1MB */ 1177 *new_offset = ROUND_UP(*new_offset, 1024 * 1024); 1178 if (*new_offset > INT64_MAX) { 1179 return -EINVAL; 1180 } 1181 1182 return bdrv_truncate(bs->file, *new_offset + s->block_size, 1183 PREALLOC_MODE_OFF, NULL); 1184 } 1185 1186 /* 1187 * Update the BAT table entry with the new file offset, and the new entry 1188 * state */ 1189 static void vhdx_update_bat_table_entry(BlockDriverState *bs, BDRVVHDXState *s, 1190 VHDXSectorInfo *sinfo, 1191 uint64_t *bat_entry_le, 1192 uint64_t *bat_offset, int state) 1193 { 1194 /* The BAT entry is a uint64, with 44 bits for the file offset in units of 1195 * 1MB, and 3 bits for the block state. */ 1196 if ((state == PAYLOAD_BLOCK_ZERO) || 1197 (state == PAYLOAD_BLOCK_UNDEFINED) || 1198 (state == PAYLOAD_BLOCK_NOT_PRESENT) || 1199 (state == PAYLOAD_BLOCK_UNMAPPED)) { 1200 s->bat[sinfo->bat_idx] = 0; /* For PAYLOAD_BLOCK_ZERO, the 1201 FileOffsetMB field is denoted as 1202 'reserved' in the v1.0 spec. If it is 1203 non-zero, MS Hyper-V will fail to read 1204 the disk image */ 1205 } else { 1206 s->bat[sinfo->bat_idx] = sinfo->file_offset; 1207 } 1208 1209 s->bat[sinfo->bat_idx] |= state & VHDX_BAT_STATE_BIT_MASK; 1210 1211 *bat_entry_le = cpu_to_le64(s->bat[sinfo->bat_idx]); 1212 *bat_offset = s->bat_offset + sinfo->bat_idx * sizeof(VHDXBatEntry); 1213 1214 } 1215 1216 /* Per the spec, on the first write of guest-visible data to the file the 1217 * data write guid must be updated in the header */ 1218 int vhdx_user_visible_write(BlockDriverState *bs, BDRVVHDXState *s) 1219 { 1220 int ret = 0; 1221 if (s->first_visible_write) { 1222 s->first_visible_write = false; 1223 ret = vhdx_update_headers(bs, s, true, NULL); 1224 } 1225 return ret; 1226 } 1227 1228 static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num, 1229 int nb_sectors, QEMUIOVector *qiov, 1230 int flags) 1231 { 1232 int ret = -ENOTSUP; 1233 BDRVVHDXState *s = bs->opaque; 1234 VHDXSectorInfo sinfo; 1235 uint64_t bytes_done = 0; 1236 uint64_t bat_entry = 0; 1237 uint64_t bat_entry_offset = 0; 1238 QEMUIOVector hd_qiov; 1239 struct iovec iov1 = { 0 }; 1240 struct iovec iov2 = { 0 }; 1241 int sectors_to_write; 1242 int bat_state; 1243 uint64_t bat_prior_offset = 0; 1244 bool bat_update = false; 1245 1246 assert(!flags); 1247 qemu_iovec_init(&hd_qiov, qiov->niov); 1248 1249 qemu_co_mutex_lock(&s->lock); 1250 1251 ret = vhdx_user_visible_write(bs, s); 1252 if (ret < 0) { 1253 goto exit; 1254 } 1255 1256 while (nb_sectors > 0) { 1257 bool use_zero_buffers = false; 1258 bat_update = false; 1259 if (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) { 1260 /* not supported yet */ 1261 ret = -ENOTSUP; 1262 goto exit; 1263 } else { 1264 vhdx_block_translate(s, sector_num, nb_sectors, &sinfo); 1265 sectors_to_write = sinfo.sectors_avail; 1266 1267 qemu_iovec_reset(&hd_qiov); 1268 /* check the payload block state */ 1269 bat_state = s->bat[sinfo.bat_idx] & VHDX_BAT_STATE_BIT_MASK; 1270 switch (bat_state) { 1271 case PAYLOAD_BLOCK_ZERO: 1272 /* in this case, we need to preserve zero writes for 1273 * data that is not part of this write, so we must pad 1274 * the rest of the buffer to zeroes */ 1275 1276 /* if we are on a posix system with ftruncate() that extends 1277 * a file, then it is zero-filled for us. On Win32, the raw 1278 * layer uses SetFilePointer and SetFileEnd, which does not 1279 * zero fill AFAIK */ 1280 1281 /* Queue another write of zero buffers if the underlying file 1282 * does not zero-fill on file extension */ 1283 1284 if (bdrv_has_zero_init(bs->file->bs) == 0) { 1285 use_zero_buffers = true; 1286 1287 /* zero fill the front, if any */ 1288 if (sinfo.block_offset) { 1289 iov1.iov_len = sinfo.block_offset; 1290 iov1.iov_base = qemu_blockalign(bs, iov1.iov_len); 1291 memset(iov1.iov_base, 0, iov1.iov_len); 1292 qemu_iovec_concat_iov(&hd_qiov, &iov1, 1, 0, 1293 iov1.iov_len); 1294 sectors_to_write += iov1.iov_len >> BDRV_SECTOR_BITS; 1295 } 1296 1297 /* our actual data */ 1298 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, 1299 sinfo.bytes_avail); 1300 1301 /* zero fill the back, if any */ 1302 if ((sinfo.bytes_avail - sinfo.block_offset) < 1303 s->block_size) { 1304 iov2.iov_len = s->block_size - 1305 (sinfo.bytes_avail + sinfo.block_offset); 1306 iov2.iov_base = qemu_blockalign(bs, iov2.iov_len); 1307 memset(iov2.iov_base, 0, iov2.iov_len); 1308 qemu_iovec_concat_iov(&hd_qiov, &iov2, 1, 0, 1309 iov2.iov_len); 1310 sectors_to_write += iov2.iov_len >> BDRV_SECTOR_BITS; 1311 } 1312 } 1313 /* fall through */ 1314 case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */ 1315 case PAYLOAD_BLOCK_UNMAPPED: 1316 case PAYLOAD_BLOCK_UNMAPPED_v095: 1317 case PAYLOAD_BLOCK_UNDEFINED: 1318 bat_prior_offset = sinfo.file_offset; 1319 ret = vhdx_allocate_block(bs, s, &sinfo.file_offset); 1320 if (ret < 0) { 1321 goto exit; 1322 } 1323 /* once we support differencing files, this may also be 1324 * partially present */ 1325 /* update block state to the newly specified state */ 1326 vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry, 1327 &bat_entry_offset, 1328 PAYLOAD_BLOCK_FULLY_PRESENT); 1329 bat_update = true; 1330 /* since we just allocated a block, file_offset is the 1331 * beginning of the payload block. It needs to be the 1332 * write address, which includes the offset into the block */ 1333 if (!use_zero_buffers) { 1334 sinfo.file_offset += sinfo.block_offset; 1335 } 1336 /* fall through */ 1337 case PAYLOAD_BLOCK_FULLY_PRESENT: 1338 /* if the file offset address is in the header zone, 1339 * there is a problem */ 1340 if (sinfo.file_offset < (1024 * 1024)) { 1341 ret = -EFAULT; 1342 goto error_bat_restore; 1343 } 1344 1345 if (!use_zero_buffers) { 1346 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, 1347 sinfo.bytes_avail); 1348 } 1349 /* block exists, so we can just overwrite it */ 1350 qemu_co_mutex_unlock(&s->lock); 1351 ret = bdrv_co_writev(bs->file, 1352 sinfo.file_offset >> BDRV_SECTOR_BITS, 1353 sectors_to_write, &hd_qiov); 1354 qemu_co_mutex_lock(&s->lock); 1355 if (ret < 0) { 1356 goto error_bat_restore; 1357 } 1358 break; 1359 case PAYLOAD_BLOCK_PARTIALLY_PRESENT: 1360 /* we don't yet support difference files, fall through 1361 * to error */ 1362 default: 1363 ret = -EIO; 1364 goto exit; 1365 break; 1366 } 1367 1368 if (bat_update) { 1369 /* this will update the BAT entry into the log journal, and 1370 * then flush the log journal out to disk */ 1371 ret = vhdx_log_write_and_flush(bs, s, &bat_entry, 1372 sizeof(VHDXBatEntry), 1373 bat_entry_offset); 1374 if (ret < 0) { 1375 goto exit; 1376 } 1377 } 1378 1379 nb_sectors -= sinfo.sectors_avail; 1380 sector_num += sinfo.sectors_avail; 1381 bytes_done += sinfo.bytes_avail; 1382 1383 } 1384 } 1385 1386 goto exit; 1387 1388 error_bat_restore: 1389 if (bat_update) { 1390 /* keep metadata in sync, and restore the bat entry state 1391 * if error. */ 1392 sinfo.file_offset = bat_prior_offset; 1393 vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry, 1394 &bat_entry_offset, bat_state); 1395 } 1396 exit: 1397 qemu_vfree(iov1.iov_base); 1398 qemu_vfree(iov2.iov_base); 1399 qemu_co_mutex_unlock(&s->lock); 1400 qemu_iovec_destroy(&hd_qiov); 1401 return ret; 1402 } 1403 1404 1405 1406 /* 1407 * Create VHDX Headers 1408 * 1409 * There are 2 headers, and the highest sequence number will represent 1410 * the active header 1411 */ 1412 static int vhdx_create_new_headers(BlockBackend *blk, uint64_t image_size, 1413 uint32_t log_size) 1414 { 1415 BlockDriverState *bs = blk_bs(blk); 1416 BdrvChild *child; 1417 int ret = 0; 1418 VHDXHeader *hdr = NULL; 1419 1420 hdr = g_new0(VHDXHeader, 1); 1421 1422 hdr->signature = VHDX_HEADER_SIGNATURE; 1423 hdr->sequence_number = g_random_int(); 1424 hdr->log_version = 0; 1425 hdr->version = 1; 1426 hdr->log_length = log_size; 1427 hdr->log_offset = VHDX_HEADER_SECTION_END; 1428 vhdx_guid_generate(&hdr->file_write_guid); 1429 vhdx_guid_generate(&hdr->data_write_guid); 1430 1431 /* XXX Ugly way to get blk->root, but that's a feature, not a bug. This 1432 * hack makes it obvious that vhdx_write_header() bypasses the BlockBackend 1433 * here, which it really shouldn't be doing. */ 1434 child = QLIST_FIRST(&bs->parents); 1435 assert(!QLIST_NEXT(child, next_parent)); 1436 1437 ret = vhdx_write_header(child, hdr, VHDX_HEADER1_OFFSET, false); 1438 if (ret < 0) { 1439 goto exit; 1440 } 1441 hdr->sequence_number++; 1442 ret = vhdx_write_header(child, hdr, VHDX_HEADER2_OFFSET, false); 1443 if (ret < 0) { 1444 goto exit; 1445 } 1446 1447 exit: 1448 g_free(hdr); 1449 return ret; 1450 } 1451 1452 #define VHDX_METADATA_ENTRY_BUFFER_SIZE \ 1453 (sizeof(VHDXFileParameters) +\ 1454 sizeof(VHDXVirtualDiskSize) +\ 1455 sizeof(VHDXPage83Data) +\ 1456 sizeof(VHDXVirtualDiskLogicalSectorSize) +\ 1457 sizeof(VHDXVirtualDiskPhysicalSectorSize)) 1458 1459 /* 1460 * Create the Metadata entries. 1461 * 1462 * For more details on the entries, see section 3.5 (pg 29) in the 1463 * VHDX 1.00 specification. 1464 * 1465 * We support 5 metadata entries (all required by spec): 1466 * File Parameters, 1467 * Virtual Disk Size, 1468 * Page 83 Data, 1469 * Logical Sector Size, 1470 * Physical Sector Size 1471 * 1472 * The first 64KB of the Metadata section is reserved for the metadata 1473 * header and entries; beyond that, the metadata items themselves reside. 1474 */ 1475 static int vhdx_create_new_metadata(BlockBackend *blk, 1476 uint64_t image_size, 1477 uint32_t block_size, 1478 uint32_t sector_size, 1479 uint64_t metadata_offset, 1480 VHDXImageType type) 1481 { 1482 int ret = 0; 1483 uint32_t offset = 0; 1484 void *buffer = NULL; 1485 void *entry_buffer; 1486 VHDXMetadataTableHeader *md_table; 1487 VHDXMetadataTableEntry *md_table_entry; 1488 1489 /* Metadata entries */ 1490 VHDXFileParameters *mt_file_params; 1491 VHDXVirtualDiskSize *mt_virtual_size; 1492 VHDXPage83Data *mt_page83; 1493 VHDXVirtualDiskLogicalSectorSize *mt_log_sector_size; 1494 VHDXVirtualDiskPhysicalSectorSize *mt_phys_sector_size; 1495 1496 entry_buffer = g_malloc0(VHDX_METADATA_ENTRY_BUFFER_SIZE); 1497 1498 mt_file_params = entry_buffer; 1499 offset += sizeof(VHDXFileParameters); 1500 mt_virtual_size = entry_buffer + offset; 1501 offset += sizeof(VHDXVirtualDiskSize); 1502 mt_page83 = entry_buffer + offset; 1503 offset += sizeof(VHDXPage83Data); 1504 mt_log_sector_size = entry_buffer + offset; 1505 offset += sizeof(VHDXVirtualDiskLogicalSectorSize); 1506 mt_phys_sector_size = entry_buffer + offset; 1507 1508 mt_file_params->block_size = cpu_to_le32(block_size); 1509 if (type == VHDX_TYPE_FIXED) { 1510 mt_file_params->data_bits |= VHDX_PARAMS_LEAVE_BLOCKS_ALLOCED; 1511 cpu_to_le32s(&mt_file_params->data_bits); 1512 } 1513 1514 vhdx_guid_generate(&mt_page83->page_83_data); 1515 cpu_to_leguids(&mt_page83->page_83_data); 1516 mt_virtual_size->virtual_disk_size = cpu_to_le64(image_size); 1517 mt_log_sector_size->logical_sector_size = cpu_to_le32(sector_size); 1518 mt_phys_sector_size->physical_sector_size = cpu_to_le32(sector_size); 1519 1520 buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE); 1521 md_table = buffer; 1522 1523 md_table->signature = VHDX_METADATA_SIGNATURE; 1524 md_table->entry_count = 5; 1525 vhdx_metadata_header_le_export(md_table); 1526 1527 1528 /* This will reference beyond the reserved table portion */ 1529 offset = 64 * KiB; 1530 1531 md_table_entry = buffer + sizeof(VHDXMetadataTableHeader); 1532 1533 md_table_entry[0].item_id = file_param_guid; 1534 md_table_entry[0].offset = offset; 1535 md_table_entry[0].length = sizeof(VHDXFileParameters); 1536 md_table_entry[0].data_bits |= VHDX_META_FLAGS_IS_REQUIRED; 1537 offset += md_table_entry[0].length; 1538 vhdx_metadata_entry_le_export(&md_table_entry[0]); 1539 1540 md_table_entry[1].item_id = virtual_size_guid; 1541 md_table_entry[1].offset = offset; 1542 md_table_entry[1].length = sizeof(VHDXVirtualDiskSize); 1543 md_table_entry[1].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | 1544 VHDX_META_FLAGS_IS_VIRTUAL_DISK; 1545 offset += md_table_entry[1].length; 1546 vhdx_metadata_entry_le_export(&md_table_entry[1]); 1547 1548 md_table_entry[2].item_id = page83_guid; 1549 md_table_entry[2].offset = offset; 1550 md_table_entry[2].length = sizeof(VHDXPage83Data); 1551 md_table_entry[2].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | 1552 VHDX_META_FLAGS_IS_VIRTUAL_DISK; 1553 offset += md_table_entry[2].length; 1554 vhdx_metadata_entry_le_export(&md_table_entry[2]); 1555 1556 md_table_entry[3].item_id = logical_sector_guid; 1557 md_table_entry[3].offset = offset; 1558 md_table_entry[3].length = sizeof(VHDXVirtualDiskLogicalSectorSize); 1559 md_table_entry[3].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | 1560 VHDX_META_FLAGS_IS_VIRTUAL_DISK; 1561 offset += md_table_entry[3].length; 1562 vhdx_metadata_entry_le_export(&md_table_entry[3]); 1563 1564 md_table_entry[4].item_id = phys_sector_guid; 1565 md_table_entry[4].offset = offset; 1566 md_table_entry[4].length = sizeof(VHDXVirtualDiskPhysicalSectorSize); 1567 md_table_entry[4].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | 1568 VHDX_META_FLAGS_IS_VIRTUAL_DISK; 1569 vhdx_metadata_entry_le_export(&md_table_entry[4]); 1570 1571 ret = blk_pwrite(blk, metadata_offset, buffer, VHDX_HEADER_BLOCK_SIZE, 0); 1572 if (ret < 0) { 1573 goto exit; 1574 } 1575 1576 ret = blk_pwrite(blk, metadata_offset + (64 * KiB), entry_buffer, 1577 VHDX_METADATA_ENTRY_BUFFER_SIZE, 0); 1578 if (ret < 0) { 1579 goto exit; 1580 } 1581 1582 1583 exit: 1584 g_free(buffer); 1585 g_free(entry_buffer); 1586 return ret; 1587 } 1588 1589 /* This create the actual BAT itself. We currently only support 1590 * 'Dynamic' and 'Fixed' image types. 1591 * 1592 * Dynamic images: default state of the BAT is all zeroes. 1593 * 1594 * Fixed images: default state of the BAT is fully populated, with 1595 * file offsets and state PAYLOAD_BLOCK_FULLY_PRESENT. 1596 */ 1597 static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s, 1598 uint64_t image_size, VHDXImageType type, 1599 bool use_zero_blocks, uint64_t file_offset, 1600 uint32_t length, Error **errp) 1601 { 1602 int ret = 0; 1603 uint64_t data_file_offset; 1604 uint64_t total_sectors = 0; 1605 uint64_t sector_num = 0; 1606 uint64_t unused; 1607 int block_state; 1608 VHDXSectorInfo sinfo; 1609 1610 assert(s->bat == NULL); 1611 1612 /* this gives a data start after BAT/bitmap entries, and well 1613 * past any metadata entries (with a 4 MB buffer for future 1614 * expansion */ 1615 data_file_offset = file_offset + length + 5 * MiB; 1616 total_sectors = image_size >> s->logical_sector_size_bits; 1617 1618 if (type == VHDX_TYPE_DYNAMIC) { 1619 /* All zeroes, so we can just extend the file - the end of the BAT 1620 * is the furthest thing we have written yet */ 1621 ret = blk_truncate(blk, data_file_offset, PREALLOC_MODE_OFF, errp); 1622 if (ret < 0) { 1623 goto exit; 1624 } 1625 } else if (type == VHDX_TYPE_FIXED) { 1626 ret = blk_truncate(blk, data_file_offset + image_size, 1627 PREALLOC_MODE_OFF, errp); 1628 if (ret < 0) { 1629 goto exit; 1630 } 1631 } else { 1632 error_setg(errp, "Unsupported image type"); 1633 ret = -ENOTSUP; 1634 goto exit; 1635 } 1636 1637 if (type == VHDX_TYPE_FIXED || 1638 use_zero_blocks || 1639 bdrv_has_zero_init(blk_bs(blk)) == 0) { 1640 /* for a fixed file, the default BAT entry is not zero */ 1641 s->bat = g_try_malloc0(length); 1642 if (length && s->bat == NULL) { 1643 error_setg(errp, "Failed to allocate memory for the BAT"); 1644 ret = -ENOMEM; 1645 goto exit; 1646 } 1647 block_state = type == VHDX_TYPE_FIXED ? PAYLOAD_BLOCK_FULLY_PRESENT : 1648 PAYLOAD_BLOCK_NOT_PRESENT; 1649 block_state = use_zero_blocks ? PAYLOAD_BLOCK_ZERO : block_state; 1650 /* fill the BAT by emulating sector writes of sectors_per_block size */ 1651 while (sector_num < total_sectors) { 1652 vhdx_block_translate(s, sector_num, s->sectors_per_block, &sinfo); 1653 sinfo.file_offset = data_file_offset + 1654 (sector_num << s->logical_sector_size_bits); 1655 sinfo.file_offset = ROUND_UP(sinfo.file_offset, MiB); 1656 vhdx_update_bat_table_entry(blk_bs(blk), s, &sinfo, &unused, &unused, 1657 block_state); 1658 cpu_to_le64s(&s->bat[sinfo.bat_idx]); 1659 sector_num += s->sectors_per_block; 1660 } 1661 ret = blk_pwrite(blk, file_offset, s->bat, length, 0); 1662 if (ret < 0) { 1663 error_setg_errno(errp, -ret, "Failed to write the BAT"); 1664 goto exit; 1665 } 1666 } 1667 1668 1669 1670 exit: 1671 g_free(s->bat); 1672 return ret; 1673 } 1674 1675 /* Creates the region table header, and region table entries. 1676 * There are 2 supported region table entries: BAT, and Metadata/ 1677 * 1678 * As the calculations for the BAT region table are also needed 1679 * to create the BAT itself, we will also cause the BAT to be 1680 * created. 1681 */ 1682 static int vhdx_create_new_region_table(BlockBackend *blk, 1683 uint64_t image_size, 1684 uint32_t block_size, 1685 uint32_t sector_size, 1686 uint32_t log_size, 1687 bool use_zero_blocks, 1688 VHDXImageType type, 1689 uint64_t *metadata_offset, 1690 Error **errp) 1691 { 1692 int ret = 0; 1693 uint32_t offset = 0; 1694 void *buffer = NULL; 1695 uint64_t bat_file_offset; 1696 uint32_t bat_length; 1697 BDRVVHDXState *s = NULL; 1698 VHDXRegionTableHeader *region_table; 1699 VHDXRegionTableEntry *rt_bat; 1700 VHDXRegionTableEntry *rt_metadata; 1701 1702 assert(metadata_offset != NULL); 1703 1704 /* Populate enough of the BDRVVHDXState to be able to use the 1705 * pre-existing BAT calculation, translation, and update functions */ 1706 s = g_new0(BDRVVHDXState, 1); 1707 1708 s->chunk_ratio = (VHDX_MAX_SECTORS_PER_BLOCK) * 1709 (uint64_t) sector_size / (uint64_t) block_size; 1710 1711 s->sectors_per_block = block_size / sector_size; 1712 s->virtual_disk_size = image_size; 1713 s->block_size = block_size; 1714 s->logical_sector_size = sector_size; 1715 1716 vhdx_set_shift_bits(s); 1717 1718 vhdx_calc_bat_entries(s); 1719 1720 /* At this point the VHDX state is populated enough for creation */ 1721 1722 /* a single buffer is used so we can calculate the checksum over the 1723 * entire 64KB block */ 1724 buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE); 1725 region_table = buffer; 1726 offset += sizeof(VHDXRegionTableHeader); 1727 rt_bat = buffer + offset; 1728 offset += sizeof(VHDXRegionTableEntry); 1729 rt_metadata = buffer + offset; 1730 1731 region_table->signature = VHDX_REGION_SIGNATURE; 1732 region_table->entry_count = 2; /* BAT and Metadata */ 1733 1734 rt_bat->guid = bat_guid; 1735 rt_bat->length = ROUND_UP(s->bat_entries * sizeof(VHDXBatEntry), MiB); 1736 rt_bat->file_offset = ROUND_UP(VHDX_HEADER_SECTION_END + log_size, MiB); 1737 s->bat_offset = rt_bat->file_offset; 1738 1739 rt_metadata->guid = metadata_guid; 1740 rt_metadata->file_offset = ROUND_UP(rt_bat->file_offset + rt_bat->length, 1741 MiB); 1742 rt_metadata->length = 1 * MiB; /* min size, and more than enough */ 1743 *metadata_offset = rt_metadata->file_offset; 1744 1745 bat_file_offset = rt_bat->file_offset; 1746 bat_length = rt_bat->length; 1747 1748 vhdx_region_header_le_export(region_table); 1749 vhdx_region_entry_le_export(rt_bat); 1750 vhdx_region_entry_le_export(rt_metadata); 1751 1752 vhdx_update_checksum(buffer, VHDX_HEADER_BLOCK_SIZE, 1753 offsetof(VHDXRegionTableHeader, checksum)); 1754 1755 1756 /* The region table gives us the data we need to create the BAT, 1757 * so do that now */ 1758 ret = vhdx_create_bat(blk, s, image_size, type, use_zero_blocks, 1759 bat_file_offset, bat_length, errp); 1760 if (ret < 0) { 1761 goto exit; 1762 } 1763 1764 /* Now write out the region headers to disk */ 1765 ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, buffer, 1766 VHDX_HEADER_BLOCK_SIZE, 0); 1767 if (ret < 0) { 1768 error_setg_errno(errp, -ret, "Failed to write first region table"); 1769 goto exit; 1770 } 1771 1772 ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, buffer, 1773 VHDX_HEADER_BLOCK_SIZE, 0); 1774 if (ret < 0) { 1775 error_setg_errno(errp, -ret, "Failed to write second region table"); 1776 goto exit; 1777 } 1778 1779 exit: 1780 g_free(s); 1781 g_free(buffer); 1782 return ret; 1783 } 1784 1785 /* We need to create the following elements: 1786 * 1787 * .-----------------------------------------------------------------. 1788 * | (A) | (B) | (C) | (D) | (E) | 1789 * | File ID | Header1 | Header 2 | Region Tbl 1 | Region Tbl 2 | 1790 * | | | | | | 1791 * .-----------------------------------------------------------------. 1792 * 0 64KB 128KB 192KB 256KB 320KB 1793 * 1794 * 1795 * .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------. 1796 * | (F) | (G) | (H) | | 1797 * | Journal Log | BAT / Bitmap | Metadata | .... data ...... | 1798 * | | | | | 1799 * .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------. 1800 * 1MB 1801 */ 1802 static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts, 1803 Error **errp) 1804 { 1805 BlockdevCreateOptionsVhdx *vhdx_opts; 1806 BlockBackend *blk = NULL; 1807 BlockDriverState *bs = NULL; 1808 1809 int ret = 0; 1810 uint64_t image_size; 1811 uint32_t log_size; 1812 uint32_t block_size; 1813 uint64_t signature; 1814 uint64_t metadata_offset; 1815 bool use_zero_blocks = false; 1816 1817 gunichar2 *creator = NULL; 1818 glong creator_items; 1819 VHDXImageType image_type; 1820 1821 assert(opts->driver == BLOCKDEV_DRIVER_VHDX); 1822 vhdx_opts = &opts->u.vhdx; 1823 1824 /* Validate options and set default values */ 1825 image_size = vhdx_opts->size; 1826 if (image_size > VHDX_MAX_IMAGE_SIZE) { 1827 error_setg(errp, "Image size too large; max of 64TB"); 1828 return -EINVAL; 1829 } 1830 1831 if (!vhdx_opts->has_log_size) { 1832 log_size = DEFAULT_LOG_SIZE; 1833 } else { 1834 if (vhdx_opts->log_size > UINT32_MAX) { 1835 error_setg(errp, "Log size must be smaller than 4 GB"); 1836 return -EINVAL; 1837 } 1838 log_size = vhdx_opts->log_size; 1839 } 1840 if (log_size < MiB || (log_size % MiB) != 0) { 1841 error_setg(errp, "Log size must be a multiple of 1 MB"); 1842 return -EINVAL; 1843 } 1844 1845 if (!vhdx_opts->has_block_state_zero) { 1846 use_zero_blocks = true; 1847 } else { 1848 use_zero_blocks = vhdx_opts->block_state_zero; 1849 } 1850 1851 if (!vhdx_opts->has_subformat) { 1852 vhdx_opts->subformat = BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC; 1853 } 1854 1855 switch (vhdx_opts->subformat) { 1856 case BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC: 1857 image_type = VHDX_TYPE_DYNAMIC; 1858 break; 1859 case BLOCKDEV_VHDX_SUBFORMAT_FIXED: 1860 image_type = VHDX_TYPE_FIXED; 1861 break; 1862 default: 1863 g_assert_not_reached(); 1864 } 1865 1866 /* These are pretty arbitrary, and mainly designed to keep the BAT 1867 * size reasonable to load into RAM */ 1868 if (vhdx_opts->has_block_size) { 1869 block_size = vhdx_opts->block_size; 1870 } else { 1871 if (image_size > 32 * TiB) { 1872 block_size = 64 * MiB; 1873 } else if (image_size > (uint64_t) 100 * GiB) { 1874 block_size = 32 * MiB; 1875 } else if (image_size > 1 * GiB) { 1876 block_size = 16 * MiB; 1877 } else { 1878 block_size = 8 * MiB; 1879 } 1880 } 1881 1882 if (block_size < MiB || (block_size % MiB) != 0) { 1883 error_setg(errp, "Block size must be a multiple of 1 MB"); 1884 return -EINVAL; 1885 } 1886 if (!is_power_of_2(block_size)) { 1887 error_setg(errp, "Block size must be a power of two"); 1888 return -EINVAL; 1889 } 1890 if (block_size > VHDX_BLOCK_SIZE_MAX) { 1891 error_setg(errp, "Block size must not exceed %d", VHDX_BLOCK_SIZE_MAX); 1892 return -EINVAL; 1893 } 1894 1895 /* Create BlockBackend to write to the image */ 1896 bs = bdrv_open_blockdev_ref(vhdx_opts->file, errp); 1897 if (bs == NULL) { 1898 return -EIO; 1899 } 1900 1901 blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL); 1902 ret = blk_insert_bs(blk, bs, errp); 1903 if (ret < 0) { 1904 goto delete_and_exit; 1905 } 1906 blk_set_allow_write_beyond_eof(blk, true); 1907 1908 /* Create (A) */ 1909 1910 /* The creator field is optional, but may be useful for 1911 * debugging / diagnostics */ 1912 creator = g_utf8_to_utf16("QEMU v" QEMU_VERSION, -1, NULL, 1913 &creator_items, NULL); 1914 signature = cpu_to_le64(VHDX_FILE_SIGNATURE); 1915 ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET, &signature, sizeof(signature), 1916 0); 1917 if (ret < 0) { 1918 error_setg_errno(errp, -ret, "Failed to write file signature"); 1919 goto delete_and_exit; 1920 } 1921 if (creator) { 1922 ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET + sizeof(signature), 1923 creator, creator_items * sizeof(gunichar2), 0); 1924 if (ret < 0) { 1925 error_setg_errno(errp, -ret, "Failed to write creator field"); 1926 goto delete_and_exit; 1927 } 1928 } 1929 1930 1931 /* Creates (B),(C) */ 1932 ret = vhdx_create_new_headers(blk, image_size, log_size); 1933 if (ret < 0) { 1934 error_setg_errno(errp, -ret, "Failed to write image headers"); 1935 goto delete_and_exit; 1936 } 1937 1938 /* Creates (D),(E),(G) explicitly. (F) created as by-product */ 1939 ret = vhdx_create_new_region_table(blk, image_size, block_size, 512, 1940 log_size, use_zero_blocks, image_type, 1941 &metadata_offset, errp); 1942 if (ret < 0) { 1943 goto delete_and_exit; 1944 } 1945 1946 /* Creates (H) */ 1947 ret = vhdx_create_new_metadata(blk, image_size, block_size, 512, 1948 metadata_offset, image_type); 1949 if (ret < 0) { 1950 error_setg_errno(errp, -ret, "Failed to initialize metadata"); 1951 goto delete_and_exit; 1952 } 1953 1954 ret = 0; 1955 delete_and_exit: 1956 blk_unref(blk); 1957 bdrv_unref(bs); 1958 g_free(creator); 1959 return ret; 1960 } 1961 1962 static int coroutine_fn vhdx_co_create_opts(const char *filename, 1963 QemuOpts *opts, 1964 Error **errp) 1965 { 1966 BlockdevCreateOptions *create_options = NULL; 1967 QDict *qdict = NULL; 1968 QObject *qobj; 1969 Visitor *v; 1970 BlockDriverState *bs = NULL; 1971 Error *local_err = NULL; 1972 int ret; 1973 1974 static const QDictRenames opt_renames[] = { 1975 { VHDX_BLOCK_OPT_LOG_SIZE, "log-size" }, 1976 { VHDX_BLOCK_OPT_BLOCK_SIZE, "block-size" }, 1977 { VHDX_BLOCK_OPT_ZERO, "block-state-zero" }, 1978 { NULL, NULL }, 1979 }; 1980 1981 /* Parse options and convert legacy syntax */ 1982 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vhdx_create_opts, true); 1983 1984 if (!qdict_rename_keys(qdict, opt_renames, errp)) { 1985 ret = -EINVAL; 1986 goto fail; 1987 } 1988 1989 /* Create and open the file (protocol layer) */ 1990 ret = bdrv_create_file(filename, opts, &local_err); 1991 if (ret < 0) { 1992 error_propagate(errp, local_err); 1993 goto fail; 1994 } 1995 1996 bs = bdrv_open(filename, NULL, NULL, 1997 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp); 1998 if (bs == NULL) { 1999 ret = -EIO; 2000 goto fail; 2001 } 2002 2003 /* Now get the QAPI type BlockdevCreateOptions */ 2004 qdict_put_str(qdict, "driver", "vhdx"); 2005 qdict_put_str(qdict, "file", bs->node_name); 2006 2007 qobj = qdict_crumple(qdict, errp); 2008 qobject_unref(qdict); 2009 qdict = qobject_to(QDict, qobj); 2010 if (qdict == NULL) { 2011 ret = -EINVAL; 2012 goto fail; 2013 } 2014 2015 v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); 2016 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err); 2017 visit_free(v); 2018 2019 if (local_err) { 2020 error_propagate(errp, local_err); 2021 ret = -EINVAL; 2022 goto fail; 2023 } 2024 2025 /* Silently round up sizes: 2026 * The image size is rounded to 512 bytes. Make the block and log size 2027 * close to what was specified, but must be at least 1MB, and a multiple of 2028 * 1 MB. Also respect VHDX_BLOCK_SIZE_MAX for block sizes. block_size = 0 2029 * means auto, which is represented by a missing key in QAPI. */ 2030 assert(create_options->driver == BLOCKDEV_DRIVER_VHDX); 2031 create_options->u.vhdx.size = 2032 ROUND_UP(create_options->u.vhdx.size, BDRV_SECTOR_SIZE); 2033 2034 if (create_options->u.vhdx.has_log_size) { 2035 create_options->u.vhdx.log_size = 2036 ROUND_UP(create_options->u.vhdx.log_size, MiB); 2037 } 2038 if (create_options->u.vhdx.has_block_size) { 2039 create_options->u.vhdx.block_size = 2040 ROUND_UP(create_options->u.vhdx.block_size, MiB); 2041 2042 if (create_options->u.vhdx.block_size == 0) { 2043 create_options->u.vhdx.has_block_size = false; 2044 } 2045 if (create_options->u.vhdx.block_size > VHDX_BLOCK_SIZE_MAX) { 2046 create_options->u.vhdx.block_size = VHDX_BLOCK_SIZE_MAX; 2047 } 2048 } 2049 2050 /* Create the vhdx image (format layer) */ 2051 ret = vhdx_co_create(create_options, errp); 2052 2053 fail: 2054 qobject_unref(qdict); 2055 bdrv_unref(bs); 2056 qapi_free_BlockdevCreateOptions(create_options); 2057 return ret; 2058 } 2059 2060 /* If opened r/w, the VHDX driver will automatically replay the log, 2061 * if one is present, inside the vhdx_open() call. 2062 * 2063 * If qemu-img check -r all is called, the image is automatically opened 2064 * r/w and any log has already been replayed, so there is nothing (currently) 2065 * for us to do here 2066 */ 2067 static int coroutine_fn vhdx_co_check(BlockDriverState *bs, 2068 BdrvCheckResult *result, 2069 BdrvCheckMode fix) 2070 { 2071 BDRVVHDXState *s = bs->opaque; 2072 2073 if (s->log_replayed_on_open) { 2074 result->corruptions_fixed++; 2075 } 2076 return 0; 2077 } 2078 2079 static QemuOptsList vhdx_create_opts = { 2080 .name = "vhdx-create-opts", 2081 .head = QTAILQ_HEAD_INITIALIZER(vhdx_create_opts.head), 2082 .desc = { 2083 { 2084 .name = BLOCK_OPT_SIZE, 2085 .type = QEMU_OPT_SIZE, 2086 .help = "Virtual disk size; max of 64TB." 2087 }, 2088 { 2089 .name = VHDX_BLOCK_OPT_LOG_SIZE, 2090 .type = QEMU_OPT_SIZE, 2091 .def_value_str = stringify(DEFAULT_LOG_SIZE), 2092 .help = "Log size; min 1MB." 2093 }, 2094 { 2095 .name = VHDX_BLOCK_OPT_BLOCK_SIZE, 2096 .type = QEMU_OPT_SIZE, 2097 .def_value_str = stringify(0), 2098 .help = "Block Size; min 1MB, max 256MB. " \ 2099 "0 means auto-calculate based on image size." 2100 }, 2101 { 2102 .name = BLOCK_OPT_SUBFMT, 2103 .type = QEMU_OPT_STRING, 2104 .help = "VHDX format type, can be either 'dynamic' or 'fixed'. "\ 2105 "Default is 'dynamic'." 2106 }, 2107 { 2108 .name = VHDX_BLOCK_OPT_ZERO, 2109 .type = QEMU_OPT_BOOL, 2110 .help = "Force use of payload blocks of type 'ZERO'. "\ 2111 "Non-standard, but default. Do not set to 'off' when "\ 2112 "using 'qemu-img convert' with subformat=dynamic." 2113 }, 2114 { NULL } 2115 } 2116 }; 2117 2118 static BlockDriver bdrv_vhdx = { 2119 .format_name = "vhdx", 2120 .instance_size = sizeof(BDRVVHDXState), 2121 .bdrv_probe = vhdx_probe, 2122 .bdrv_open = vhdx_open, 2123 .bdrv_close = vhdx_close, 2124 .bdrv_reopen_prepare = vhdx_reopen_prepare, 2125 .bdrv_child_perm = bdrv_format_default_perms, 2126 .bdrv_co_readv = vhdx_co_readv, 2127 .bdrv_co_writev = vhdx_co_writev, 2128 .bdrv_co_create = vhdx_co_create, 2129 .bdrv_co_create_opts = vhdx_co_create_opts, 2130 .bdrv_get_info = vhdx_get_info, 2131 .bdrv_co_check = vhdx_co_check, 2132 .bdrv_has_zero_init = bdrv_has_zero_init_1, 2133 2134 .create_opts = &vhdx_create_opts, 2135 }; 2136 2137 static void bdrv_vhdx_init(void) 2138 { 2139 bdrv_register(&bdrv_vhdx); 2140 } 2141 2142 block_init(bdrv_vhdx_init); 2143