1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52#include "qemu/osdep.h"
53#include "qapi/error.h"
54#include "qapi/qmp/qdict.h"
55#include "qapi/qobject-input-visitor.h"
56#include "qapi/qapi-visit-block-core.h"
57#include "block/block_int.h"
58#include "sysemu/block-backend.h"
59#include "qemu/module.h"
60#include "qemu/option.h"
61#include "qemu/bswap.h"
62#include "migration/blocker.h"
63#include "qemu/coroutine.h"
64#include "qemu/cutils.h"
65#include "qemu/uuid.h"
66
67
68
69
70
71
72
73#define CONFIG_VDI_WRITE
74
75
76
77
78
79
80
81#define CONFIG_VDI_STATIC_IMAGE
82
83
84#define BLOCK_OPT_STATIC "static"
85
86#define KiB 1024
87#define MiB (KiB * KiB)
88
89#define SECTOR_SIZE 512
90#define DEFAULT_CLUSTER_SIZE (1 * MiB)
91
92#if defined(CONFIG_VDI_DEBUG)
93#define VDI_DEBUG 1
94#else
95#define VDI_DEBUG 0
96#endif
97
98#define logout(fmt, ...) \
99 do { \
100 if (VDI_DEBUG) { \
101 fprintf(stderr, "vdi\t%-24s" fmt, __func__, ##__VA_ARGS__); \
102 } \
103 } while (0)
104
105
106#define VDI_SIGNATURE 0xbeda107f
107
108
109#define VDI_VERSION_1_1 0x00010001
110
111
112#define VDI_TYPE_DYNAMIC 1
113#define VDI_TYPE_STATIC 2
114
115
116
117
118
119
120
121#define VDI_TEXT "<<< QEMU VM Virtual Disk Image >>>\n"
122
123
124#define VDI_UNALLOCATED 0xffffffffU
125
126
127#define VDI_DISCARDED 0xfffffffeU
128
129#define VDI_IS_ALLOCATED(X) ((X) < VDI_DISCARDED)
130
131
132
133
134
135
136
137
138
139
140
141#define VDI_BLOCKS_IN_IMAGE_MAX \
142 ((unsigned)((INT_MAX + 1u - BDRV_SECTOR_SIZE) / sizeof(uint32_t)))
143#define VDI_DISK_SIZE_MAX ((uint64_t)VDI_BLOCKS_IN_IMAGE_MAX * \
144 (uint64_t)DEFAULT_CLUSTER_SIZE)
145
146static QemuOptsList vdi_create_opts;
147
148typedef struct {
149 char text[0x40];
150 uint32_t signature;
151 uint32_t version;
152 uint32_t header_size;
153 uint32_t image_type;
154 uint32_t image_flags;
155 char description[256];
156 uint32_t offset_bmap;
157 uint32_t offset_data;
158 uint32_t cylinders;
159 uint32_t heads;
160 uint32_t sectors;
161 uint32_t sector_size;
162 uint32_t unused1;
163 uint64_t disk_size;
164 uint32_t block_size;
165 uint32_t block_extra;
166 uint32_t blocks_in_image;
167 uint32_t blocks_allocated;
168 QemuUUID uuid_image;
169 QemuUUID uuid_last_snap;
170 QemuUUID uuid_link;
171 QemuUUID uuid_parent;
172 uint64_t unused2[7];
173} QEMU_PACKED VdiHeader;
174
175typedef struct {
176
177 uint32_t *bmap;
178
179 uint32_t block_size;
180
181 uint32_t bmap_sector;
182
183 VdiHeader header;
184
185 CoRwlock bmap_lock;
186
187 Error *migration_blocker;
188} BDRVVdiState;
189
190static void vdi_header_to_cpu(VdiHeader *header)
191{
192 le32_to_cpus(&header->signature);
193 le32_to_cpus(&header->version);
194 le32_to_cpus(&header->header_size);
195 le32_to_cpus(&header->image_type);
196 le32_to_cpus(&header->image_flags);
197 le32_to_cpus(&header->offset_bmap);
198 le32_to_cpus(&header->offset_data);
199 le32_to_cpus(&header->cylinders);
200 le32_to_cpus(&header->heads);
201 le32_to_cpus(&header->sectors);
202 le32_to_cpus(&header->sector_size);
203 le64_to_cpus(&header->disk_size);
204 le32_to_cpus(&header->block_size);
205 le32_to_cpus(&header->block_extra);
206 le32_to_cpus(&header->blocks_in_image);
207 le32_to_cpus(&header->blocks_allocated);
208 qemu_uuid_bswap(&header->uuid_image);
209 qemu_uuid_bswap(&header->uuid_last_snap);
210 qemu_uuid_bswap(&header->uuid_link);
211 qemu_uuid_bswap(&header->uuid_parent);
212}
213
214static void vdi_header_to_le(VdiHeader *header)
215{
216 cpu_to_le32s(&header->signature);
217 cpu_to_le32s(&header->version);
218 cpu_to_le32s(&header->header_size);
219 cpu_to_le32s(&header->image_type);
220 cpu_to_le32s(&header->image_flags);
221 cpu_to_le32s(&header->offset_bmap);
222 cpu_to_le32s(&header->offset_data);
223 cpu_to_le32s(&header->cylinders);
224 cpu_to_le32s(&header->heads);
225 cpu_to_le32s(&header->sectors);
226 cpu_to_le32s(&header->sector_size);
227 cpu_to_le64s(&header->disk_size);
228 cpu_to_le32s(&header->block_size);
229 cpu_to_le32s(&header->block_extra);
230 cpu_to_le32s(&header->blocks_in_image);
231 cpu_to_le32s(&header->blocks_allocated);
232 qemu_uuid_bswap(&header->uuid_image);
233 qemu_uuid_bswap(&header->uuid_last_snap);
234 qemu_uuid_bswap(&header->uuid_link);
235 qemu_uuid_bswap(&header->uuid_parent);
236}
237
238static void vdi_header_print(VdiHeader *header)
239{
240 char uuid[37];
241 logout("text %s", header->text);
242 logout("signature 0x%08x\n", header->signature);
243 logout("header size 0x%04x\n", header->header_size);
244 logout("image type 0x%04x\n", header->image_type);
245 logout("image flags 0x%04x\n", header->image_flags);
246 logout("description %s\n", header->description);
247 logout("offset bmap 0x%04x\n", header->offset_bmap);
248 logout("offset data 0x%04x\n", header->offset_data);
249 logout("cylinders 0x%04x\n", header->cylinders);
250 logout("heads 0x%04x\n", header->heads);
251 logout("sectors 0x%04x\n", header->sectors);
252 logout("sector size 0x%04x\n", header->sector_size);
253 logout("image size 0x%" PRIx64 " B (%" PRIu64 " MiB)\n",
254 header->disk_size, header->disk_size / MiB);
255 logout("block size 0x%04x\n", header->block_size);
256 logout("block extra 0x%04x\n", header->block_extra);
257 logout("blocks tot. 0x%04x\n", header->blocks_in_image);
258 logout("blocks all. 0x%04x\n", header->blocks_allocated);
259 qemu_uuid_unparse(&header->uuid_image, uuid);
260 logout("uuid image %s\n", uuid);
261 qemu_uuid_unparse(&header->uuid_last_snap, uuid);
262 logout("uuid snap %s\n", uuid);
263 qemu_uuid_unparse(&header->uuid_link, uuid);
264 logout("uuid link %s\n", uuid);
265 qemu_uuid_unparse(&header->uuid_parent, uuid);
266 logout("uuid parent %s\n", uuid);
267}
268
269static int coroutine_fn vdi_co_check(BlockDriverState *bs, BdrvCheckResult *res,
270 BdrvCheckMode fix)
271{
272
273 BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
274 uint32_t blocks_allocated = 0;
275 uint32_t block;
276 uint32_t *bmap;
277 logout("\n");
278
279 if (fix) {
280 return -ENOTSUP;
281 }
282
283 bmap = g_try_new(uint32_t, s->header.blocks_in_image);
284 if (s->header.blocks_in_image && bmap == NULL) {
285 res->check_errors++;
286 return -ENOMEM;
287 }
288
289 memset(bmap, 0xff, s->header.blocks_in_image * sizeof(uint32_t));
290
291
292 for (block = 0; block < s->header.blocks_in_image; block++) {
293 uint32_t bmap_entry = le32_to_cpu(s->bmap[block]);
294 if (VDI_IS_ALLOCATED(bmap_entry)) {
295 if (bmap_entry < s->header.blocks_in_image) {
296 blocks_allocated++;
297 if (!VDI_IS_ALLOCATED(bmap[bmap_entry])) {
298 bmap[bmap_entry] = bmap_entry;
299 } else {
300 fprintf(stderr, "ERROR: block index %" PRIu32
301 " also used by %" PRIu32 "\n", bmap[bmap_entry], bmap_entry);
302 res->corruptions++;
303 }
304 } else {
305 fprintf(stderr, "ERROR: block index %" PRIu32
306 " too large, is %" PRIu32 "\n", block, bmap_entry);
307 res->corruptions++;
308 }
309 }
310 }
311 if (blocks_allocated != s->header.blocks_allocated) {
312 fprintf(stderr, "ERROR: allocated blocks mismatch, is %" PRIu32
313 ", should be %" PRIu32 "\n",
314 blocks_allocated, s->header.blocks_allocated);
315 res->corruptions++;
316 }
317
318 g_free(bmap);
319
320 return 0;
321}
322
323static int vdi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
324{
325
326
327 BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
328 logout("\n");
329 bdi->cluster_size = s->block_size;
330 bdi->vm_state_offset = 0;
331 bdi->unallocated_blocks_are_zero = true;
332 return 0;
333}
334
335static int vdi_make_empty(BlockDriverState *bs)
336{
337
338 logout("\n");
339
340 return 0;
341}
342
343static int vdi_probe(const uint8_t *buf, int buf_size, const char *filename)
344{
345 const VdiHeader *header = (const VdiHeader *)buf;
346 int ret = 0;
347
348 logout("\n");
349
350 if (buf_size < sizeof(*header)) {
351
352 } else if (le32_to_cpu(header->signature) == VDI_SIGNATURE) {
353 ret = 100;
354 }
355
356 if (ret == 0) {
357 logout("no vdi image\n");
358 } else {
359 logout("%s", header->text);
360 }
361
362 return ret;
363}
364
365static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
366 Error **errp)
367{
368 BDRVVdiState *s = bs->opaque;
369 VdiHeader header;
370 size_t bmap_size;
371 int ret;
372 Error *local_err = NULL;
373
374 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
375 false, errp);
376 if (!bs->file) {
377 return -EINVAL;
378 }
379
380 logout("\n");
381
382 ret = bdrv_read(bs->file, 0, (uint8_t *)&header, 1);
383 if (ret < 0) {
384 goto fail;
385 }
386
387 vdi_header_to_cpu(&header);
388 if (VDI_DEBUG) {
389 vdi_header_print(&header);
390 }
391
392 if (header.disk_size > VDI_DISK_SIZE_MAX) {
393 error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
394 ", max supported is 0x%" PRIx64 ")",
395 header.disk_size, VDI_DISK_SIZE_MAX);
396 ret = -ENOTSUP;
397 goto fail;
398 }
399
400 if (header.disk_size % SECTOR_SIZE != 0) {
401
402
403
404 logout("odd disk size %" PRIu64 " B, round up\n", header.disk_size);
405 header.disk_size = ROUND_UP(header.disk_size, SECTOR_SIZE);
406 }
407
408 if (header.signature != VDI_SIGNATURE) {
409 error_setg(errp, "Image not in VDI format (bad signature %08" PRIx32
410 ")", header.signature);
411 ret = -EINVAL;
412 goto fail;
413 } else if (header.version != VDI_VERSION_1_1) {
414 error_setg(errp, "unsupported VDI image (version %" PRIu32 ".%" PRIu32
415 ")", header.version >> 16, header.version & 0xffff);
416 ret = -ENOTSUP;
417 goto fail;
418 } else if (header.offset_bmap % SECTOR_SIZE != 0) {
419
420 error_setg(errp, "unsupported VDI image (unaligned block map offset "
421 "0x%" PRIx32 ")", header.offset_bmap);
422 ret = -ENOTSUP;
423 goto fail;
424 } else if (header.offset_data % SECTOR_SIZE != 0) {
425
426 error_setg(errp, "unsupported VDI image (unaligned data offset 0x%"
427 PRIx32 ")", header.offset_data);
428 ret = -ENOTSUP;
429 goto fail;
430 } else if (header.sector_size != SECTOR_SIZE) {
431 error_setg(errp, "unsupported VDI image (sector size %" PRIu32
432 " is not %u)", header.sector_size, SECTOR_SIZE);
433 ret = -ENOTSUP;
434 goto fail;
435 } else if (header.block_size != DEFAULT_CLUSTER_SIZE) {
436 error_setg(errp, "unsupported VDI image (block size %" PRIu32
437 " is not %u)", header.block_size, DEFAULT_CLUSTER_SIZE);
438 ret = -ENOTSUP;
439 goto fail;
440 } else if (header.disk_size >
441 (uint64_t)header.blocks_in_image * header.block_size) {
442 error_setg(errp, "unsupported VDI image (disk size %" PRIu64 ", "
443 "image bitmap has room for %" PRIu64 ")",
444 header.disk_size,
445 (uint64_t)header.blocks_in_image * header.block_size);
446 ret = -ENOTSUP;
447 goto fail;
448 } else if (!qemu_uuid_is_null(&header.uuid_link)) {
449 error_setg(errp, "unsupported VDI image (non-NULL link UUID)");
450 ret = -ENOTSUP;
451 goto fail;
452 } else if (!qemu_uuid_is_null(&header.uuid_parent)) {
453 error_setg(errp, "unsupported VDI image (non-NULL parent UUID)");
454 ret = -ENOTSUP;
455 goto fail;
456 } else if (header.blocks_in_image > VDI_BLOCKS_IN_IMAGE_MAX) {
457 error_setg(errp, "unsupported VDI image "
458 "(too many blocks %u, max is %u)",
459 header.blocks_in_image, VDI_BLOCKS_IN_IMAGE_MAX);
460 ret = -ENOTSUP;
461 goto fail;
462 }
463
464 bs->total_sectors = header.disk_size / SECTOR_SIZE;
465
466 s->block_size = header.block_size;
467 s->bmap_sector = header.offset_bmap / SECTOR_SIZE;
468 s->header = header;
469
470 bmap_size = header.blocks_in_image * sizeof(uint32_t);
471 bmap_size = DIV_ROUND_UP(bmap_size, SECTOR_SIZE);
472 s->bmap = qemu_try_blockalign(bs->file->bs, bmap_size * SECTOR_SIZE);
473 if (s->bmap == NULL) {
474 ret = -ENOMEM;
475 goto fail;
476 }
477
478 ret = bdrv_read(bs->file, s->bmap_sector, (uint8_t *)s->bmap,
479 bmap_size);
480 if (ret < 0) {
481 goto fail_free_bmap;
482 }
483
484
485 error_setg(&s->migration_blocker, "The vdi format used by node '%s' "
486 "does not support live migration",
487 bdrv_get_device_or_node_name(bs));
488 ret = migrate_add_blocker(s->migration_blocker, &local_err);
489 if (local_err) {
490 error_propagate(errp, local_err);
491 error_free(s->migration_blocker);
492 goto fail_free_bmap;
493 }
494
495 qemu_co_rwlock_init(&s->bmap_lock);
496
497 return 0;
498
499 fail_free_bmap:
500 qemu_vfree(s->bmap);
501
502 fail:
503 return ret;
504}
505
506static int vdi_reopen_prepare(BDRVReopenState *state,
507 BlockReopenQueue *queue, Error **errp)
508{
509 return 0;
510}
511
512static int coroutine_fn vdi_co_block_status(BlockDriverState *bs,
513 bool want_zero,
514 int64_t offset, int64_t bytes,
515 int64_t *pnum, int64_t *map,
516 BlockDriverState **file)
517{
518 BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
519 size_t bmap_index = offset / s->block_size;
520 size_t index_in_block = offset % s->block_size;
521 uint32_t bmap_entry = le32_to_cpu(s->bmap[bmap_index]);
522 int result;
523
524 logout("%p, %" PRId64 ", %" PRId64 ", %p\n", bs, offset, bytes, pnum);
525 *pnum = MIN(s->block_size - index_in_block, bytes);
526 result = VDI_IS_ALLOCATED(bmap_entry);
527 if (!result) {
528 return 0;
529 }
530
531 *map = s->header.offset_data + (uint64_t)bmap_entry * s->block_size +
532 index_in_block;
533 *file = bs->file->bs;
534 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
535}
536
537static int coroutine_fn
538vdi_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
539 QEMUIOVector *qiov, int flags)
540{
541 BDRVVdiState *s = bs->opaque;
542 QEMUIOVector local_qiov;
543 uint32_t bmap_entry;
544 uint32_t block_index;
545 uint32_t offset_in_block;
546 uint32_t n_bytes;
547 uint64_t bytes_done = 0;
548 int ret = 0;
549
550 logout("\n");
551
552 qemu_iovec_init(&local_qiov, qiov->niov);
553
554 while (ret >= 0 && bytes > 0) {
555 block_index = offset / s->block_size;
556 offset_in_block = offset % s->block_size;
557 n_bytes = MIN(bytes, s->block_size - offset_in_block);
558
559 logout("will read %u bytes starting at offset %" PRIu64 "\n",
560 n_bytes, offset);
561
562
563 qemu_co_rwlock_rdlock(&s->bmap_lock);
564 bmap_entry = le32_to_cpu(s->bmap[block_index]);
565 qemu_co_rwlock_unlock(&s->bmap_lock);
566 if (!VDI_IS_ALLOCATED(bmap_entry)) {
567
568 qemu_iovec_memset(qiov, bytes_done, 0, n_bytes);
569 ret = 0;
570 } else {
571 uint64_t data_offset = s->header.offset_data +
572 (uint64_t)bmap_entry * s->block_size +
573 offset_in_block;
574
575 qemu_iovec_reset(&local_qiov);
576 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
577
578 ret = bdrv_co_preadv(bs->file, data_offset, n_bytes,
579 &local_qiov, 0);
580 }
581 logout("%u bytes read\n", n_bytes);
582
583 bytes -= n_bytes;
584 offset += n_bytes;
585 bytes_done += n_bytes;
586 }
587
588 qemu_iovec_destroy(&local_qiov);
589
590 return ret;
591}
592
593static int coroutine_fn
594vdi_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
595 QEMUIOVector *qiov, int flags)
596{
597 BDRVVdiState *s = bs->opaque;
598 QEMUIOVector local_qiov;
599 uint32_t bmap_entry;
600 uint32_t block_index;
601 uint32_t offset_in_block;
602 uint32_t n_bytes;
603 uint64_t data_offset;
604 uint32_t bmap_first = VDI_UNALLOCATED;
605 uint32_t bmap_last = VDI_UNALLOCATED;
606 uint8_t *block = NULL;
607 uint64_t bytes_done = 0;
608 int ret = 0;
609
610 logout("\n");
611
612 qemu_iovec_init(&local_qiov, qiov->niov);
613
614 while (ret >= 0 && bytes > 0) {
615 block_index = offset / s->block_size;
616 offset_in_block = offset % s->block_size;
617 n_bytes = MIN(bytes, s->block_size - offset_in_block);
618
619 logout("will write %u bytes starting at offset %" PRIu64 "\n",
620 n_bytes, offset);
621
622
623 qemu_co_rwlock_rdlock(&s->bmap_lock);
624 bmap_entry = le32_to_cpu(s->bmap[block_index]);
625 if (!VDI_IS_ALLOCATED(bmap_entry)) {
626
627 uint64_t data_offset;
628 qemu_co_rwlock_upgrade(&s->bmap_lock);
629 bmap_entry = le32_to_cpu(s->bmap[block_index]);
630 if (VDI_IS_ALLOCATED(bmap_entry)) {
631
632 qemu_co_rwlock_downgrade(&s->bmap_lock);
633 goto nonallocating_write;
634 }
635
636 bmap_entry = s->header.blocks_allocated;
637 s->bmap[block_index] = cpu_to_le32(bmap_entry);
638 s->header.blocks_allocated++;
639 data_offset = s->header.offset_data +
640 (uint64_t)bmap_entry * s->block_size;
641 if (block == NULL) {
642 block = g_malloc(s->block_size);
643 bmap_first = block_index;
644 }
645 bmap_last = block_index;
646
647 memset(block, 0, offset_in_block);
648 qemu_iovec_to_buf(qiov, bytes_done, block + offset_in_block,
649 n_bytes);
650 memset(block + offset_in_block + n_bytes, 0,
651 s->block_size - n_bytes - offset_in_block);
652
653
654
655
656
657 ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size);
658 qemu_co_rwlock_unlock(&s->bmap_lock);
659 } else {
660nonallocating_write:
661 data_offset = s->header.offset_data +
662 (uint64_t)bmap_entry * s->block_size +
663 offset_in_block;
664 qemu_co_rwlock_unlock(&s->bmap_lock);
665
666 qemu_iovec_reset(&local_qiov);
667 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
668
669 ret = bdrv_co_pwritev(bs->file, data_offset, n_bytes,
670 &local_qiov, 0);
671 }
672
673 bytes -= n_bytes;
674 offset += n_bytes;
675 bytes_done += n_bytes;
676
677 logout("%u bytes written\n", n_bytes);
678 }
679
680 qemu_iovec_destroy(&local_qiov);
681
682 logout("finished data write\n");
683 if (ret < 0) {
684 return ret;
685 }
686
687 if (block) {
688
689 VdiHeader *header = (VdiHeader *) block;
690 uint8_t *base;
691 uint64_t offset;
692 uint32_t n_sectors;
693
694 logout("now writing modified header\n");
695 assert(VDI_IS_ALLOCATED(bmap_first));
696 *header = s->header;
697 vdi_header_to_le(header);
698 ret = bdrv_write(bs->file, 0, block, 1);
699 g_free(block);
700 block = NULL;
701
702 if (ret < 0) {
703 return ret;
704 }
705
706 logout("now writing modified block map entry %u...%u\n",
707 bmap_first, bmap_last);
708
709 bmap_first /= (SECTOR_SIZE / sizeof(uint32_t));
710 bmap_last /= (SECTOR_SIZE / sizeof(uint32_t));
711 n_sectors = bmap_last - bmap_first + 1;
712 offset = s->bmap_sector + bmap_first;
713 base = ((uint8_t *)&s->bmap[0]) + bmap_first * SECTOR_SIZE;
714 logout("will write %u block map sectors starting from entry %u\n",
715 n_sectors, bmap_first);
716 ret = bdrv_write(bs->file, offset, base, n_sectors);
717 }
718
719 return ret;
720}
721
722static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
723 size_t block_size, Error **errp)
724{
725 BlockdevCreateOptionsVdi *vdi_opts;
726 int ret = 0;
727 uint64_t bytes = 0;
728 uint32_t blocks;
729 uint32_t image_type;
730 VdiHeader header;
731 size_t i;
732 size_t bmap_size;
733 int64_t offset = 0;
734 BlockDriverState *bs_file = NULL;
735 BlockBackend *blk = NULL;
736 uint32_t *bmap = NULL;
737
738 assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
739 vdi_opts = &create_options->u.vdi;
740
741 logout("\n");
742
743
744 bytes = vdi_opts->size;
745
746 if (!vdi_opts->has_preallocation) {
747 vdi_opts->preallocation = PREALLOC_MODE_OFF;
748 }
749 switch (vdi_opts->preallocation) {
750 case PREALLOC_MODE_OFF:
751 image_type = VDI_TYPE_DYNAMIC;
752 break;
753 case PREALLOC_MODE_METADATA:
754 image_type = VDI_TYPE_STATIC;
755 break;
756 default:
757 error_setg(errp, "Preallocation mode not supported for vdi");
758 return -EINVAL;
759 }
760
761#ifndef CONFIG_VDI_STATIC_IMAGE
762 if (image_type == VDI_TYPE_STATIC) {
763 ret = -ENOTSUP;
764 error_setg(errp, "Statically allocated images cannot be created in "
765 "this build");
766 goto exit;
767 }
768#endif
769#ifndef CONFIG_VDI_BLOCK_SIZE
770 if (block_size != DEFAULT_CLUSTER_SIZE) {
771 ret = -ENOTSUP;
772 error_setg(errp,
773 "A non-default cluster size is not supported in this build");
774 goto exit;
775 }
776#endif
777
778 if (bytes > VDI_DISK_SIZE_MAX) {
779 ret = -ENOTSUP;
780 error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
781 ", max supported is 0x%" PRIx64 ")",
782 bytes, VDI_DISK_SIZE_MAX);
783 goto exit;
784 }
785
786
787 bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
788 if (!bs_file) {
789 ret = -EIO;
790 goto exit;
791 }
792
793 blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
794 ret = blk_insert_bs(blk, bs_file, errp);
795 if (ret < 0) {
796 goto exit;
797 }
798
799 blk_set_allow_write_beyond_eof(blk, true);
800
801
802
803 blocks = DIV_ROUND_UP(bytes, block_size);
804
805 bmap_size = blocks * sizeof(uint32_t);
806 bmap_size = ROUND_UP(bmap_size, SECTOR_SIZE);
807
808 memset(&header, 0, sizeof(header));
809 pstrcpy(header.text, sizeof(header.text), VDI_TEXT);
810 header.signature = VDI_SIGNATURE;
811 header.version = VDI_VERSION_1_1;
812 header.header_size = 0x180;
813 header.image_type = image_type;
814 header.offset_bmap = 0x200;
815 header.offset_data = 0x200 + bmap_size;
816 header.sector_size = SECTOR_SIZE;
817 header.disk_size = bytes;
818 header.block_size = block_size;
819 header.blocks_in_image = blocks;
820 if (image_type == VDI_TYPE_STATIC) {
821 header.blocks_allocated = blocks;
822 }
823 qemu_uuid_generate(&header.uuid_image);
824 qemu_uuid_generate(&header.uuid_last_snap);
825
826 if (VDI_DEBUG) {
827 vdi_header_print(&header);
828 }
829 vdi_header_to_le(&header);
830 ret = blk_pwrite(blk, offset, &header, sizeof(header), 0);
831 if (ret < 0) {
832 error_setg(errp, "Error writing header");
833 goto exit;
834 }
835 offset += sizeof(header);
836
837 if (bmap_size > 0) {
838 bmap = g_try_malloc0(bmap_size);
839 if (bmap == NULL) {
840 ret = -ENOMEM;
841 error_setg(errp, "Could not allocate bmap");
842 goto exit;
843 }
844 for (i = 0; i < blocks; i++) {
845 if (image_type == VDI_TYPE_STATIC) {
846 bmap[i] = i;
847 } else {
848 bmap[i] = VDI_UNALLOCATED;
849 }
850 }
851 ret = blk_pwrite(blk, offset, bmap, bmap_size, 0);
852 if (ret < 0) {
853 error_setg(errp, "Error writing bmap");
854 goto exit;
855 }
856 offset += bmap_size;
857 }
858
859 if (image_type == VDI_TYPE_STATIC) {
860 ret = blk_truncate(blk, offset + blocks * block_size,
861 PREALLOC_MODE_OFF, errp);
862 if (ret < 0) {
863 error_prepend(errp, "Failed to statically allocate file");
864 goto exit;
865 }
866 }
867
868exit:
869 blk_unref(blk);
870 bdrv_unref(bs_file);
871 g_free(bmap);
872 return ret;
873}
874
875static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
876 Error **errp)
877{
878 return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
879}
880
881static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
882 Error **errp)
883{
884 QDict *qdict = NULL;
885 BlockdevCreateOptions *create_options = NULL;
886 BlockDriverState *bs_file = NULL;
887 uint64_t block_size = DEFAULT_CLUSTER_SIZE;
888 bool is_static = false;
889 Visitor *v;
890 Error *local_err = NULL;
891 int ret;
892
893
894
895
896
897
898#if defined(CONFIG_VDI_BLOCK_SIZE)
899 block_size = qemu_opt_get_size_del(opts,
900 BLOCK_OPT_CLUSTER_SIZE,
901 DEFAULT_CLUSTER_SIZE);
902 if (block_size < BDRV_SECTOR_SIZE || block_size > UINT32_MAX ||
903 !is_power_of_2(block_size))
904 {
905 error_setg(errp, "Invalid cluster size");
906 ret = -EINVAL;
907 goto done;
908 }
909#endif
910 if (qemu_opt_get_bool_del(opts, BLOCK_OPT_STATIC, false)) {
911 is_static = true;
912 }
913
914 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
915
916
917 ret = bdrv_create_file(filename, opts, errp);
918 if (ret < 0) {
919 goto done;
920 }
921
922 bs_file = bdrv_open(filename, NULL, NULL,
923 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
924 if (!bs_file) {
925 ret = -EIO;
926 goto done;
927 }
928
929 qdict_put_str(qdict, "driver", "vdi");
930 qdict_put_str(qdict, "file", bs_file->node_name);
931 if (is_static) {
932 qdict_put_str(qdict, "preallocation", "metadata");
933 }
934
935
936 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
937 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
938 visit_free(v);
939
940 if (local_err) {
941 error_propagate(errp, local_err);
942 ret = -EINVAL;
943 goto done;
944 }
945
946
947 assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
948 create_options->u.vdi.size = ROUND_UP(create_options->u.vdi.size,
949 BDRV_SECTOR_SIZE);
950
951
952 ret = vdi_co_do_create(create_options, block_size, errp);
953done:
954 QDECREF(qdict);
955 qapi_free_BlockdevCreateOptions(create_options);
956 bdrv_unref(bs_file);
957 return ret;
958}
959
960static void vdi_close(BlockDriverState *bs)
961{
962 BDRVVdiState *s = bs->opaque;
963
964 qemu_vfree(s->bmap);
965
966 migrate_del_blocker(s->migration_blocker);
967 error_free(s->migration_blocker);
968}
969
970static QemuOptsList vdi_create_opts = {
971 .name = "vdi-create-opts",
972 .head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),
973 .desc = {
974 {
975 .name = BLOCK_OPT_SIZE,
976 .type = QEMU_OPT_SIZE,
977 .help = "Virtual disk size"
978 },
979#if defined(CONFIG_VDI_BLOCK_SIZE)
980 {
981 .name = BLOCK_OPT_CLUSTER_SIZE,
982 .type = QEMU_OPT_SIZE,
983 .help = "VDI cluster (block) size",
984 .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
985 },
986#endif
987#if defined(CONFIG_VDI_STATIC_IMAGE)
988 {
989 .name = BLOCK_OPT_STATIC,
990 .type = QEMU_OPT_BOOL,
991 .help = "VDI static (pre-allocated) image",
992 .def_value_str = "off"
993 },
994#endif
995
996 { }
997 }
998};
999
1000static BlockDriver bdrv_vdi = {
1001 .format_name = "vdi",
1002 .instance_size = sizeof(BDRVVdiState),
1003 .bdrv_probe = vdi_probe,
1004 .bdrv_open = vdi_open,
1005 .bdrv_close = vdi_close,
1006 .bdrv_reopen_prepare = vdi_reopen_prepare,
1007 .bdrv_child_perm = bdrv_format_default_perms,
1008 .bdrv_co_create = vdi_co_create,
1009 .bdrv_co_create_opts = vdi_co_create_opts,
1010 .bdrv_has_zero_init = bdrv_has_zero_init_1,
1011 .bdrv_co_block_status = vdi_co_block_status,
1012 .bdrv_make_empty = vdi_make_empty,
1013
1014 .bdrv_co_preadv = vdi_co_preadv,
1015#if defined(CONFIG_VDI_WRITE)
1016 .bdrv_co_pwritev = vdi_co_pwritev,
1017#endif
1018
1019 .bdrv_get_info = vdi_get_info,
1020
1021 .create_opts = &vdi_create_opts,
1022 .bdrv_co_check = vdi_co_check,
1023};
1024
1025static void bdrv_vdi_init(void)
1026{
1027 logout("\n");
1028 bdrv_register(&bdrv_vdi);
1029}
1030
1031block_init(bdrv_vdi_init);
1032