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