1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 "block/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
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
39typedef enum VHDXImageType {
40 VHDX_TYPE_DYNAMIC = 0,
41 VHDX_TYPE_FIXED,
42 VHDX_TYPE_DIFFERENCING,
43} VHDXImageType;
44
45static QemuOptsList vhdx_create_opts;
46
47
48
49
50
51
52static const MSGUID bat_guid = { .data1 = 0x2dc27766,
53 .data2 = 0xf623,
54 .data3 = 0x4200,
55 .data4 = { 0x9d, 0x64, 0x11, 0x5e,
56 0x9b, 0xfd, 0x4a, 0x08} };
57
58static 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
67static 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
73static 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
79static 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
86static 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
92static 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
99static 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
107
108
109static 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
130typedef struct VHDXSectorInfo {
131 uint32_t bat_idx;
132 uint32_t sectors_avail;
133 uint32_t bytes_left;
134 uint32_t bytes_avail;
135 uint64_t file_offset;
136 uint64_t block_offset;
137} VHDXSectorInfo;
138
139
140
141
142
143
144
145
146
147
148
149uint32_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
164uint32_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
185
186
187
188
189
190
191
192
193
194
195
196
197bool 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
216
217
218void 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
228static 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
242exit:
243 return ret;
244}
245
246
247static 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
261static 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
271static 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
281
282
283
284
285
286
287
288
289
290static 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
300
301
302
303
304
305static 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
317
318
319
320 buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE);
321 if (read) {
322
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
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
339exit:
340 qemu_vfree(buffer);
341 return ret;
342}
343
344
345
346
347
348
349
350static 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
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
372
373 inactive_header->file_write_guid = s->session_guid;
374
375
376
377 if (generate_data_write_guid) {
378 vhdx_guid_generate(&inactive_header->data_write_guid);
379 }
380
381
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
392exit:
393 return ret;
394}
395
396
397
398
399
400int 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
414static 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
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
436
437
438 ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer,
439 VHDX_HEADER_SIZE);
440 if (ret < 0) {
441 goto fail;
442 }
443
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
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
473
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
482
483
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
490
491
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
504fail:
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;
510exit:
511 qemu_vfree(buffer);
512}
513
514
515static 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
526
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
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
563
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
572 if (guid_eq(rt_entry.guid, bat_guid)) {
573
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
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
596
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
609fail:
610 qemu_vfree(buffer);
611 return ret;
612}
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632static 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
734
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
760
761
762
763
764 if (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) {
765 if (s->metadata_entries.present & META_PARENT_LOCATOR_PRESENT) {
766
767 ret = -ENOTSUP;
768 goto exit;
769 } else {
770
771
772 ret = -EINVAL;
773 goto exit;
774 }
775 }
776
777
778
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
816 if (s->logical_sector_size != 512 && s->logical_sector_size != 4096) {
817 ret = -EINVAL;
818 goto exit;
819 }
820
821
822
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
829
830
831
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
854exit:
855 qemu_vfree(buffer);
856 return ret;
857}
858
859
860
861
862
863static 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
879static 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
897static 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
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
929
930
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
958
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
967 ret = -EINVAL;
968 goto fail;
969 }
970
971
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
985
986 for (i = 0; i < s->bat_entries; i++) {
987 le64_to_cpus(&s->bat[i]);
988 if (payblocks--) {
989
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
1001
1002 }
1003 }
1004
1005
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
1017
1018 return 0;
1019fail:
1020 vhdx_close(bs);
1021 return ret;
1022}
1023
1024static int vhdx_reopen_prepare(BDRVReopenState *state,
1025 BlockReopenQueue *queue, Error **errp)
1026{
1027 return 0;
1028}
1029
1030
1031
1032
1033
1034
1035static 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
1042
1043 block_offset = sector_num - (sinfo->bat_idx << s->sectors_per_block_bits);
1044
1045
1046
1047 sinfo->bat_idx += sinfo->bat_idx >> s->chunk_ratio_bits;
1048
1049
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
1065 if (sinfo->file_offset == 0) {
1066 return;
1067 }
1068
1069
1070
1071
1072
1073
1074 sinfo->file_offset += sinfo->block_offset;
1075}
1076
1077
1078static 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
1091static 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
1106
1107 if (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) {
1108
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
1118 switch (s->bat[sinfo.bat_idx] & VHDX_BAT_STATE_BIT_MASK) {
1119 case PAYLOAD_BLOCK_NOT_PRESENT:
1120 case PAYLOAD_BLOCK_UNDEFINED:
1121 case PAYLOAD_BLOCK_UNMAPPED:
1122 case PAYLOAD_BLOCK_UNMAPPED_v095:
1123 case PAYLOAD_BLOCK_ZERO:
1124
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
1139
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;
1151exit:
1152 qemu_co_mutex_unlock(&s->lock);
1153 qemu_iovec_destroy(&hd_qiov);
1154 return ret;
1155}
1156
1157
1158
1159
1160
1161
1162
1163
1164static 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
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
1188
1189static 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
1195
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;
1201
1202
1203
1204
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
1217
1218int 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
1228static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
1229 int nb_sectors, QEMUIOVector *qiov)
1230{
1231 int ret = -ENOTSUP;
1232 BDRVVHDXState *s = bs->opaque;
1233 VHDXSectorInfo sinfo;
1234 uint64_t bytes_done = 0;
1235 uint64_t bat_entry = 0;
1236 uint64_t bat_entry_offset = 0;
1237 QEMUIOVector hd_qiov;
1238 struct iovec iov1 = { 0 };
1239 struct iovec iov2 = { 0 };
1240 int sectors_to_write;
1241 int bat_state;
1242 uint64_t bat_prior_offset = 0;
1243 bool bat_update = false;
1244
1245 qemu_iovec_init(&hd_qiov, qiov->niov);
1246
1247 qemu_co_mutex_lock(&s->lock);
1248
1249 ret = vhdx_user_visible_write(bs, s);
1250 if (ret < 0) {
1251 goto exit;
1252 }
1253
1254 while (nb_sectors > 0) {
1255 bool use_zero_buffers = false;
1256 bat_update = false;
1257 if (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) {
1258
1259 ret = -ENOTSUP;
1260 goto exit;
1261 } else {
1262 vhdx_block_translate(s, sector_num, nb_sectors, &sinfo);
1263 sectors_to_write = sinfo.sectors_avail;
1264
1265 qemu_iovec_reset(&hd_qiov);
1266
1267 bat_state = s->bat[sinfo.bat_idx] & VHDX_BAT_STATE_BIT_MASK;
1268 switch (bat_state) {
1269 case PAYLOAD_BLOCK_ZERO:
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282 if (bdrv_has_zero_init(bs->file->bs) == 0) {
1283 use_zero_buffers = true;
1284
1285
1286 if (sinfo.block_offset) {
1287 iov1.iov_len = sinfo.block_offset;
1288 iov1.iov_base = qemu_blockalign(bs, iov1.iov_len);
1289 memset(iov1.iov_base, 0, iov1.iov_len);
1290 qemu_iovec_concat_iov(&hd_qiov, &iov1, 1, 0,
1291 iov1.iov_len);
1292 sectors_to_write += iov1.iov_len >> BDRV_SECTOR_BITS;
1293 }
1294
1295
1296 qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
1297 sinfo.bytes_avail);
1298
1299
1300 if ((sinfo.bytes_avail - sinfo.block_offset) <
1301 s->block_size) {
1302 iov2.iov_len = s->block_size -
1303 (sinfo.bytes_avail + sinfo.block_offset);
1304 iov2.iov_base = qemu_blockalign(bs, iov2.iov_len);
1305 memset(iov2.iov_base, 0, iov2.iov_len);
1306 qemu_iovec_concat_iov(&hd_qiov, &iov2, 1, 0,
1307 iov2.iov_len);
1308 sectors_to_write += iov2.iov_len >> BDRV_SECTOR_BITS;
1309 }
1310 }
1311
1312 case PAYLOAD_BLOCK_NOT_PRESENT:
1313 case PAYLOAD_BLOCK_UNMAPPED:
1314 case PAYLOAD_BLOCK_UNMAPPED_v095:
1315 case PAYLOAD_BLOCK_UNDEFINED:
1316 bat_prior_offset = sinfo.file_offset;
1317 ret = vhdx_allocate_block(bs, s, &sinfo.file_offset);
1318 if (ret < 0) {
1319 goto exit;
1320 }
1321
1322
1323
1324 vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
1325 &bat_entry_offset,
1326 PAYLOAD_BLOCK_FULLY_PRESENT);
1327 bat_update = true;
1328
1329
1330
1331 if (!use_zero_buffers) {
1332 sinfo.file_offset += sinfo.block_offset;
1333 }
1334
1335 case PAYLOAD_BLOCK_FULLY_PRESENT:
1336
1337
1338 if (sinfo.file_offset < (1024 * 1024)) {
1339 ret = -EFAULT;
1340 goto error_bat_restore;
1341 }
1342
1343 if (!use_zero_buffers) {
1344 qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
1345 sinfo.bytes_avail);
1346 }
1347
1348 qemu_co_mutex_unlock(&s->lock);
1349 ret = bdrv_co_writev(bs->file,
1350 sinfo.file_offset >> BDRV_SECTOR_BITS,
1351 sectors_to_write, &hd_qiov);
1352 qemu_co_mutex_lock(&s->lock);
1353 if (ret < 0) {
1354 goto error_bat_restore;
1355 }
1356 break;
1357 case PAYLOAD_BLOCK_PARTIALLY_PRESENT:
1358
1359
1360 default:
1361 ret = -EIO;
1362 goto exit;
1363 break;
1364 }
1365
1366 if (bat_update) {
1367
1368
1369 ret = vhdx_log_write_and_flush(bs, s, &bat_entry,
1370 sizeof(VHDXBatEntry),
1371 bat_entry_offset);
1372 if (ret < 0) {
1373 goto exit;
1374 }
1375 }
1376
1377 nb_sectors -= sinfo.sectors_avail;
1378 sector_num += sinfo.sectors_avail;
1379 bytes_done += sinfo.bytes_avail;
1380
1381 }
1382 }
1383
1384 goto exit;
1385
1386error_bat_restore:
1387 if (bat_update) {
1388
1389
1390 sinfo.file_offset = bat_prior_offset;
1391 vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
1392 &bat_entry_offset, bat_state);
1393 }
1394exit:
1395 qemu_vfree(iov1.iov_base);
1396 qemu_vfree(iov2.iov_base);
1397 qemu_co_mutex_unlock(&s->lock);
1398 qemu_iovec_destroy(&hd_qiov);
1399 return ret;
1400}
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410static int vhdx_create_new_headers(BlockBackend *blk, uint64_t image_size,
1411 uint32_t log_size)
1412{
1413 BlockDriverState *bs = blk_bs(blk);
1414 BdrvChild *child;
1415 int ret = 0;
1416 VHDXHeader *hdr = NULL;
1417
1418 hdr = g_new0(VHDXHeader, 1);
1419
1420 hdr->signature = VHDX_HEADER_SIGNATURE;
1421 hdr->sequence_number = g_random_int();
1422 hdr->log_version = 0;
1423 hdr->version = 1;
1424 hdr->log_length = log_size;
1425 hdr->log_offset = VHDX_HEADER_SECTION_END;
1426 vhdx_guid_generate(&hdr->file_write_guid);
1427 vhdx_guid_generate(&hdr->data_write_guid);
1428
1429
1430
1431
1432 child = QLIST_FIRST(&bs->parents);
1433 assert(!QLIST_NEXT(child, next_parent));
1434
1435 ret = vhdx_write_header(child, hdr, VHDX_HEADER1_OFFSET, false);
1436 if (ret < 0) {
1437 goto exit;
1438 }
1439 hdr->sequence_number++;
1440 ret = vhdx_write_header(child, hdr, VHDX_HEADER2_OFFSET, false);
1441 if (ret < 0) {
1442 goto exit;
1443 }
1444
1445exit:
1446 g_free(hdr);
1447 return ret;
1448}
1449
1450#define VHDX_METADATA_ENTRY_BUFFER_SIZE \
1451 (sizeof(VHDXFileParameters) +\
1452 sizeof(VHDXVirtualDiskSize) +\
1453 sizeof(VHDXPage83Data) +\
1454 sizeof(VHDXVirtualDiskLogicalSectorSize) +\
1455 sizeof(VHDXVirtualDiskPhysicalSectorSize))
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473static int vhdx_create_new_metadata(BlockBackend *blk,
1474 uint64_t image_size,
1475 uint32_t block_size,
1476 uint32_t sector_size,
1477 uint64_t metadata_offset,
1478 VHDXImageType type)
1479{
1480 int ret = 0;
1481 uint32_t offset = 0;
1482 void *buffer = NULL;
1483 void *entry_buffer;
1484 VHDXMetadataTableHeader *md_table;
1485 VHDXMetadataTableEntry *md_table_entry;
1486
1487
1488 VHDXFileParameters *mt_file_params;
1489 VHDXVirtualDiskSize *mt_virtual_size;
1490 VHDXPage83Data *mt_page83;
1491 VHDXVirtualDiskLogicalSectorSize *mt_log_sector_size;
1492 VHDXVirtualDiskPhysicalSectorSize *mt_phys_sector_size;
1493
1494 entry_buffer = g_malloc0(VHDX_METADATA_ENTRY_BUFFER_SIZE);
1495
1496 mt_file_params = entry_buffer;
1497 offset += sizeof(VHDXFileParameters);
1498 mt_virtual_size = entry_buffer + offset;
1499 offset += sizeof(VHDXVirtualDiskSize);
1500 mt_page83 = entry_buffer + offset;
1501 offset += sizeof(VHDXPage83Data);
1502 mt_log_sector_size = entry_buffer + offset;
1503 offset += sizeof(VHDXVirtualDiskLogicalSectorSize);
1504 mt_phys_sector_size = entry_buffer + offset;
1505
1506 mt_file_params->block_size = cpu_to_le32(block_size);
1507 if (type == VHDX_TYPE_FIXED) {
1508 mt_file_params->data_bits |= VHDX_PARAMS_LEAVE_BLOCKS_ALLOCED;
1509 cpu_to_le32s(&mt_file_params->data_bits);
1510 }
1511
1512 vhdx_guid_generate(&mt_page83->page_83_data);
1513 cpu_to_leguids(&mt_page83->page_83_data);
1514 mt_virtual_size->virtual_disk_size = cpu_to_le64(image_size);
1515 mt_log_sector_size->logical_sector_size = cpu_to_le32(sector_size);
1516 mt_phys_sector_size->physical_sector_size = cpu_to_le32(sector_size);
1517
1518 buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE);
1519 md_table = buffer;
1520
1521 md_table->signature = VHDX_METADATA_SIGNATURE;
1522 md_table->entry_count = 5;
1523 vhdx_metadata_header_le_export(md_table);
1524
1525
1526
1527 offset = 64 * KiB;
1528
1529 md_table_entry = buffer + sizeof(VHDXMetadataTableHeader);
1530
1531 md_table_entry[0].item_id = file_param_guid;
1532 md_table_entry[0].offset = offset;
1533 md_table_entry[0].length = sizeof(VHDXFileParameters);
1534 md_table_entry[0].data_bits |= VHDX_META_FLAGS_IS_REQUIRED;
1535 offset += md_table_entry[0].length;
1536 vhdx_metadata_entry_le_export(&md_table_entry[0]);
1537
1538 md_table_entry[1].item_id = virtual_size_guid;
1539 md_table_entry[1].offset = offset;
1540 md_table_entry[1].length = sizeof(VHDXVirtualDiskSize);
1541 md_table_entry[1].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |
1542 VHDX_META_FLAGS_IS_VIRTUAL_DISK;
1543 offset += md_table_entry[1].length;
1544 vhdx_metadata_entry_le_export(&md_table_entry[1]);
1545
1546 md_table_entry[2].item_id = page83_guid;
1547 md_table_entry[2].offset = offset;
1548 md_table_entry[2].length = sizeof(VHDXPage83Data);
1549 md_table_entry[2].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |
1550 VHDX_META_FLAGS_IS_VIRTUAL_DISK;
1551 offset += md_table_entry[2].length;
1552 vhdx_metadata_entry_le_export(&md_table_entry[2]);
1553
1554 md_table_entry[3].item_id = logical_sector_guid;
1555 md_table_entry[3].offset = offset;
1556 md_table_entry[3].length = sizeof(VHDXVirtualDiskLogicalSectorSize);
1557 md_table_entry[3].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |
1558 VHDX_META_FLAGS_IS_VIRTUAL_DISK;
1559 offset += md_table_entry[3].length;
1560 vhdx_metadata_entry_le_export(&md_table_entry[3]);
1561
1562 md_table_entry[4].item_id = phys_sector_guid;
1563 md_table_entry[4].offset = offset;
1564 md_table_entry[4].length = sizeof(VHDXVirtualDiskPhysicalSectorSize);
1565 md_table_entry[4].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |
1566 VHDX_META_FLAGS_IS_VIRTUAL_DISK;
1567 vhdx_metadata_entry_le_export(&md_table_entry[4]);
1568
1569 ret = blk_pwrite(blk, metadata_offset, buffer, VHDX_HEADER_BLOCK_SIZE, 0);
1570 if (ret < 0) {
1571 goto exit;
1572 }
1573
1574 ret = blk_pwrite(blk, metadata_offset + (64 * KiB), entry_buffer,
1575 VHDX_METADATA_ENTRY_BUFFER_SIZE, 0);
1576 if (ret < 0) {
1577 goto exit;
1578 }
1579
1580
1581exit:
1582 g_free(buffer);
1583 g_free(entry_buffer);
1584 return ret;
1585}
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
1596 uint64_t image_size, VHDXImageType type,
1597 bool use_zero_blocks, uint64_t file_offset,
1598 uint32_t length, Error **errp)
1599{
1600 int ret = 0;
1601 uint64_t data_file_offset;
1602 uint64_t total_sectors = 0;
1603 uint64_t sector_num = 0;
1604 uint64_t unused;
1605 int block_state;
1606 VHDXSectorInfo sinfo;
1607
1608 assert(s->bat == NULL);
1609
1610
1611
1612
1613 data_file_offset = file_offset + length + 5 * MiB;
1614 total_sectors = image_size >> s->logical_sector_size_bits;
1615
1616 if (type == VHDX_TYPE_DYNAMIC) {
1617
1618
1619 ret = blk_truncate(blk, data_file_offset, PREALLOC_MODE_OFF, errp);
1620 if (ret < 0) {
1621 goto exit;
1622 }
1623 } else if (type == VHDX_TYPE_FIXED) {
1624 ret = blk_truncate(blk, data_file_offset + image_size,
1625 PREALLOC_MODE_OFF, errp);
1626 if (ret < 0) {
1627 goto exit;
1628 }
1629 } else {
1630 error_setg(errp, "Unsupported image type");
1631 ret = -ENOTSUP;
1632 goto exit;
1633 }
1634
1635 if (type == VHDX_TYPE_FIXED ||
1636 use_zero_blocks ||
1637 bdrv_has_zero_init(blk_bs(blk)) == 0) {
1638
1639 s->bat = g_try_malloc0(length);
1640 if (length && s->bat == NULL) {
1641 error_setg(errp, "Failed to allocate memory for the BAT");
1642 ret = -ENOMEM;
1643 goto exit;
1644 }
1645 block_state = type == VHDX_TYPE_FIXED ? PAYLOAD_BLOCK_FULLY_PRESENT :
1646 PAYLOAD_BLOCK_NOT_PRESENT;
1647 block_state = use_zero_blocks ? PAYLOAD_BLOCK_ZERO : block_state;
1648
1649 while (sector_num < total_sectors) {
1650 vhdx_block_translate(s, sector_num, s->sectors_per_block, &sinfo);
1651 sinfo.file_offset = data_file_offset +
1652 (sector_num << s->logical_sector_size_bits);
1653 sinfo.file_offset = ROUND_UP(sinfo.file_offset, MiB);
1654 vhdx_update_bat_table_entry(blk_bs(blk), s, &sinfo, &unused, &unused,
1655 block_state);
1656 cpu_to_le64s(&s->bat[sinfo.bat_idx]);
1657 sector_num += s->sectors_per_block;
1658 }
1659 ret = blk_pwrite(blk, file_offset, s->bat, length, 0);
1660 if (ret < 0) {
1661 error_setg_errno(errp, -ret, "Failed to write the BAT");
1662 goto exit;
1663 }
1664 }
1665
1666
1667
1668exit:
1669 g_free(s->bat);
1670 return ret;
1671}
1672
1673
1674
1675
1676
1677
1678
1679
1680static int vhdx_create_new_region_table(BlockBackend *blk,
1681 uint64_t image_size,
1682 uint32_t block_size,
1683 uint32_t sector_size,
1684 uint32_t log_size,
1685 bool use_zero_blocks,
1686 VHDXImageType type,
1687 uint64_t *metadata_offset,
1688 Error **errp)
1689{
1690 int ret = 0;
1691 uint32_t offset = 0;
1692 void *buffer = NULL;
1693 uint64_t bat_file_offset;
1694 uint32_t bat_length;
1695 BDRVVHDXState *s = NULL;
1696 VHDXRegionTableHeader *region_table;
1697 VHDXRegionTableEntry *rt_bat;
1698 VHDXRegionTableEntry *rt_metadata;
1699
1700 assert(metadata_offset != NULL);
1701
1702
1703
1704 s = g_new0(BDRVVHDXState, 1);
1705
1706 s->chunk_ratio = (VHDX_MAX_SECTORS_PER_BLOCK) *
1707 (uint64_t) sector_size / (uint64_t) block_size;
1708
1709 s->sectors_per_block = block_size / sector_size;
1710 s->virtual_disk_size = image_size;
1711 s->block_size = block_size;
1712 s->logical_sector_size = sector_size;
1713
1714 vhdx_set_shift_bits(s);
1715
1716 vhdx_calc_bat_entries(s);
1717
1718
1719
1720
1721
1722 buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE);
1723 region_table = buffer;
1724 offset += sizeof(VHDXRegionTableHeader);
1725 rt_bat = buffer + offset;
1726 offset += sizeof(VHDXRegionTableEntry);
1727 rt_metadata = buffer + offset;
1728
1729 region_table->signature = VHDX_REGION_SIGNATURE;
1730 region_table->entry_count = 2;
1731
1732 rt_bat->guid = bat_guid;
1733 rt_bat->length = ROUND_UP(s->bat_entries * sizeof(VHDXBatEntry), MiB);
1734 rt_bat->file_offset = ROUND_UP(VHDX_HEADER_SECTION_END + log_size, MiB);
1735 s->bat_offset = rt_bat->file_offset;
1736
1737 rt_metadata->guid = metadata_guid;
1738 rt_metadata->file_offset = ROUND_UP(rt_bat->file_offset + rt_bat->length,
1739 MiB);
1740 rt_metadata->length = 1 * MiB;
1741 *metadata_offset = rt_metadata->file_offset;
1742
1743 bat_file_offset = rt_bat->file_offset;
1744 bat_length = rt_bat->length;
1745
1746 vhdx_region_header_le_export(region_table);
1747 vhdx_region_entry_le_export(rt_bat);
1748 vhdx_region_entry_le_export(rt_metadata);
1749
1750 vhdx_update_checksum(buffer, VHDX_HEADER_BLOCK_SIZE,
1751 offsetof(VHDXRegionTableHeader, checksum));
1752
1753
1754
1755
1756 ret = vhdx_create_bat(blk, s, image_size, type, use_zero_blocks,
1757 bat_file_offset, bat_length, errp);
1758 if (ret < 0) {
1759 goto exit;
1760 }
1761
1762
1763 ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, buffer,
1764 VHDX_HEADER_BLOCK_SIZE, 0);
1765 if (ret < 0) {
1766 error_setg_errno(errp, -ret, "Failed to write first region table");
1767 goto exit;
1768 }
1769
1770 ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, buffer,
1771 VHDX_HEADER_BLOCK_SIZE, 0);
1772 if (ret < 0) {
1773 error_setg_errno(errp, -ret, "Failed to write second region table");
1774 goto exit;
1775 }
1776
1777exit:
1778 g_free(s);
1779 g_free(buffer);
1780 return ret;
1781}
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
1801 Error **errp)
1802{
1803 BlockdevCreateOptionsVhdx *vhdx_opts;
1804 BlockBackend *blk = NULL;
1805 BlockDriverState *bs = NULL;
1806
1807 int ret = 0;
1808 uint64_t image_size;
1809 uint32_t log_size;
1810 uint32_t block_size;
1811 uint64_t signature;
1812 uint64_t metadata_offset;
1813 bool use_zero_blocks = false;
1814
1815 gunichar2 *creator = NULL;
1816 glong creator_items;
1817 VHDXImageType image_type;
1818
1819 assert(opts->driver == BLOCKDEV_DRIVER_VHDX);
1820 vhdx_opts = &opts->u.vhdx;
1821
1822
1823 image_size = vhdx_opts->size;
1824 if (image_size > VHDX_MAX_IMAGE_SIZE) {
1825 error_setg(errp, "Image size too large; max of 64TB");
1826 return -EINVAL;
1827 }
1828
1829 if (!vhdx_opts->has_log_size) {
1830 log_size = DEFAULT_LOG_SIZE;
1831 } else {
1832 if (vhdx_opts->log_size > UINT32_MAX) {
1833 error_setg(errp, "Log size must be smaller than 4 GB");
1834 return -EINVAL;
1835 }
1836 log_size = vhdx_opts->log_size;
1837 }
1838 if (log_size < MiB || (log_size % MiB) != 0) {
1839 error_setg(errp, "Log size must be a multiple of 1 MB");
1840 return -EINVAL;
1841 }
1842
1843 if (!vhdx_opts->has_block_state_zero) {
1844 use_zero_blocks = true;
1845 } else {
1846 use_zero_blocks = vhdx_opts->block_state_zero;
1847 }
1848
1849 if (!vhdx_opts->has_subformat) {
1850 vhdx_opts->subformat = BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC;
1851 }
1852
1853 switch (vhdx_opts->subformat) {
1854 case BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC:
1855 image_type = VHDX_TYPE_DYNAMIC;
1856 break;
1857 case BLOCKDEV_VHDX_SUBFORMAT_FIXED:
1858 image_type = VHDX_TYPE_FIXED;
1859 break;
1860 default:
1861 g_assert_not_reached();
1862 }
1863
1864
1865
1866 if (vhdx_opts->has_block_size) {
1867 block_size = vhdx_opts->block_size;
1868 } else {
1869 if (image_size > 32 * TiB) {
1870 block_size = 64 * MiB;
1871 } else if (image_size > (uint64_t) 100 * GiB) {
1872 block_size = 32 * MiB;
1873 } else if (image_size > 1 * GiB) {
1874 block_size = 16 * MiB;
1875 } else {
1876 block_size = 8 * MiB;
1877 }
1878 }
1879
1880 if (block_size < MiB || (block_size % MiB) != 0) {
1881 error_setg(errp, "Block size must be a multiple of 1 MB");
1882 return -EINVAL;
1883 }
1884 if (!is_power_of_2(block_size)) {
1885 error_setg(errp, "Block size must be a power of two");
1886 return -EINVAL;
1887 }
1888 if (block_size > VHDX_BLOCK_SIZE_MAX) {
1889 error_setg(errp, "Block size must not exceed %d", VHDX_BLOCK_SIZE_MAX);
1890 return -EINVAL;
1891 }
1892
1893
1894 bs = bdrv_open_blockdev_ref(vhdx_opts->file, errp);
1895 if (bs == NULL) {
1896 return -EIO;
1897 }
1898
1899 blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
1900 ret = blk_insert_bs(blk, bs, errp);
1901 if (ret < 0) {
1902 goto delete_and_exit;
1903 }
1904 blk_set_allow_write_beyond_eof(blk, true);
1905
1906
1907
1908
1909
1910 creator = g_utf8_to_utf16("QEMU v" QEMU_VERSION, -1, NULL,
1911 &creator_items, NULL);
1912 signature = cpu_to_le64(VHDX_FILE_SIGNATURE);
1913 ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET, &signature, sizeof(signature),
1914 0);
1915 if (ret < 0) {
1916 error_setg_errno(errp, -ret, "Failed to write file signature");
1917 goto delete_and_exit;
1918 }
1919 if (creator) {
1920 ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET + sizeof(signature),
1921 creator, creator_items * sizeof(gunichar2), 0);
1922 if (ret < 0) {
1923 error_setg_errno(errp, -ret, "Failed to write creator field");
1924 goto delete_and_exit;
1925 }
1926 }
1927
1928
1929
1930 ret = vhdx_create_new_headers(blk, image_size, log_size);
1931 if (ret < 0) {
1932 error_setg_errno(errp, -ret, "Failed to write image headers");
1933 goto delete_and_exit;
1934 }
1935
1936
1937 ret = vhdx_create_new_region_table(blk, image_size, block_size, 512,
1938 log_size, use_zero_blocks, image_type,
1939 &metadata_offset, errp);
1940 if (ret < 0) {
1941 goto delete_and_exit;
1942 }
1943
1944
1945 ret = vhdx_create_new_metadata(blk, image_size, block_size, 512,
1946 metadata_offset, image_type);
1947 if (ret < 0) {
1948 error_setg_errno(errp, -ret, "Failed to initialize metadata");
1949 goto delete_and_exit;
1950 }
1951
1952
1953delete_and_exit:
1954 blk_unref(blk);
1955 bdrv_unref(bs);
1956 g_free(creator);
1957 return ret;
1958}
1959
1960static int coroutine_fn vhdx_co_create_opts(const char *filename,
1961 QemuOpts *opts,
1962 Error **errp)
1963{
1964 BlockdevCreateOptions *create_options = NULL;
1965 QDict *qdict = NULL;
1966 QObject *qobj;
1967 Visitor *v;
1968 BlockDriverState *bs = NULL;
1969 Error *local_err = NULL;
1970 int ret;
1971
1972 static const QDictRenames opt_renames[] = {
1973 { VHDX_BLOCK_OPT_LOG_SIZE, "log-size" },
1974 { VHDX_BLOCK_OPT_BLOCK_SIZE, "block-size" },
1975 { VHDX_BLOCK_OPT_ZERO, "block-state-zero" },
1976 { NULL, NULL },
1977 };
1978
1979
1980 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vhdx_create_opts, true);
1981
1982 if (!qdict_rename_keys(qdict, opt_renames, errp)) {
1983 ret = -EINVAL;
1984 goto fail;
1985 }
1986
1987
1988 ret = bdrv_create_file(filename, opts, &local_err);
1989 if (ret < 0) {
1990 error_propagate(errp, local_err);
1991 goto fail;
1992 }
1993
1994 bs = bdrv_open(filename, NULL, NULL,
1995 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
1996 if (bs == NULL) {
1997 ret = -EIO;
1998 goto fail;
1999 }
2000
2001
2002 qdict_put_str(qdict, "driver", "vhdx");
2003 qdict_put_str(qdict, "file", bs->node_name);
2004
2005 qobj = qdict_crumple(qdict, errp);
2006 QDECREF(qdict);
2007 qdict = qobject_to(QDict, qobj);
2008 if (qdict == NULL) {
2009 ret = -EINVAL;
2010 goto fail;
2011 }
2012
2013 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
2014 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
2015 visit_free(v);
2016
2017 if (local_err) {
2018 error_propagate(errp, local_err);
2019 ret = -EINVAL;
2020 goto fail;
2021 }
2022
2023
2024
2025
2026
2027
2028 assert(create_options->driver == BLOCKDEV_DRIVER_VHDX);
2029 create_options->u.vhdx.size =
2030 ROUND_UP(create_options->u.vhdx.size, BDRV_SECTOR_SIZE);
2031
2032 if (create_options->u.vhdx.has_log_size) {
2033 create_options->u.vhdx.log_size =
2034 ROUND_UP(create_options->u.vhdx.log_size, MiB);
2035 }
2036 if (create_options->u.vhdx.has_block_size) {
2037 create_options->u.vhdx.block_size =
2038 ROUND_UP(create_options->u.vhdx.block_size, MiB);
2039
2040 if (create_options->u.vhdx.block_size == 0) {
2041 create_options->u.vhdx.has_block_size = false;
2042 }
2043 if (create_options->u.vhdx.block_size > VHDX_BLOCK_SIZE_MAX) {
2044 create_options->u.vhdx.block_size = VHDX_BLOCK_SIZE_MAX;
2045 }
2046 }
2047
2048
2049 ret = vhdx_co_create(create_options, errp);
2050
2051fail:
2052 QDECREF(qdict);
2053 bdrv_unref(bs);
2054 qapi_free_BlockdevCreateOptions(create_options);
2055 return ret;
2056}
2057
2058
2059
2060
2061
2062
2063
2064
2065static int coroutine_fn vhdx_co_check(BlockDriverState *bs,
2066 BdrvCheckResult *result,
2067 BdrvCheckMode fix)
2068{
2069 BDRVVHDXState *s = bs->opaque;
2070
2071 if (s->log_replayed_on_open) {
2072 result->corruptions_fixed++;
2073 }
2074 return 0;
2075}
2076
2077static QemuOptsList vhdx_create_opts = {
2078 .name = "vhdx-create-opts",
2079 .head = QTAILQ_HEAD_INITIALIZER(vhdx_create_opts.head),
2080 .desc = {
2081 {
2082 .name = BLOCK_OPT_SIZE,
2083 .type = QEMU_OPT_SIZE,
2084 .help = "Virtual disk size; max of 64TB."
2085 },
2086 {
2087 .name = VHDX_BLOCK_OPT_LOG_SIZE,
2088 .type = QEMU_OPT_SIZE,
2089 .def_value_str = stringify(DEFAULT_LOG_SIZE),
2090 .help = "Log size; min 1MB."
2091 },
2092 {
2093 .name = VHDX_BLOCK_OPT_BLOCK_SIZE,
2094 .type = QEMU_OPT_SIZE,
2095 .def_value_str = stringify(0),
2096 .help = "Block Size; min 1MB, max 256MB. " \
2097 "0 means auto-calculate based on image size."
2098 },
2099 {
2100 .name = BLOCK_OPT_SUBFMT,
2101 .type = QEMU_OPT_STRING,
2102 .help = "VHDX format type, can be either 'dynamic' or 'fixed'. "\
2103 "Default is 'dynamic'."
2104 },
2105 {
2106 .name = VHDX_BLOCK_OPT_ZERO,
2107 .type = QEMU_OPT_BOOL,
2108 .help = "Force use of payload blocks of type 'ZERO'. "\
2109 "Non-standard, but default. Do not set to 'off' when "\
2110 "using 'qemu-img convert' with subformat=dynamic."
2111 },
2112 { NULL }
2113 }
2114};
2115
2116static BlockDriver bdrv_vhdx = {
2117 .format_name = "vhdx",
2118 .instance_size = sizeof(BDRVVHDXState),
2119 .bdrv_probe = vhdx_probe,
2120 .bdrv_open = vhdx_open,
2121 .bdrv_close = vhdx_close,
2122 .bdrv_reopen_prepare = vhdx_reopen_prepare,
2123 .bdrv_child_perm = bdrv_format_default_perms,
2124 .bdrv_co_readv = vhdx_co_readv,
2125 .bdrv_co_writev = vhdx_co_writev,
2126 .bdrv_co_create = vhdx_co_create,
2127 .bdrv_co_create_opts = vhdx_co_create_opts,
2128 .bdrv_get_info = vhdx_get_info,
2129 .bdrv_co_check = vhdx_co_check,
2130 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2131
2132 .create_opts = &vhdx_create_opts,
2133};
2134
2135static void bdrv_vhdx_init(void)
2136{
2137 bdrv_register(&bdrv_vhdx);
2138}
2139
2140block_init(bdrv_vhdx_init);
2141