1/*
2 * Block driver for the Virtual Disk Image (VDI) format
3 *
4 * Copyright (c) 2009, 2012 Stefan Weil
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 2 of the License, or
9 * (at your option) version 3 or any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 *
19 * Reference:
20 * http://forums.virtualbox.org/viewtopic.php?t=8046
21 *
22 * This driver supports create / read / write operations on VDI images.
23 *
24 * Todo (see also TODO in code):
25 *
26 * Some features like snapshots are still missing.
27 *
28 * Deallocation of zero-filled blocks and shrinking images are missing, too
29 * (might be added to common block layer).
30 *
31 * Allocation of blocks could be optimized (less writes to block map and
32 * header).
33 *
34 * Read and write of adjacent blocks could be done in one operation
35 * (current code uses one operation per block (1 MiB).
36 *
37 * The code is not thread safe (missing locks for changes in header and
38 * block table, no problem with current QEMU).
39 *
40 * Hints:
41 *
42 * Blocks (VDI documentation) correspond to clusters (QEMU).
43 * QEMU's backing files could be implemented using VDI snapshot files (TODO).
44 * VDI snapshot files may also contain the complete machine state.
45 * Maybe this machine state can be converted to QEMU PC machine snapshot data.
46 *
47 * The driver keeps a block cache (little endian entries) in memory.
48 * For the standard block size (1 MiB), a 1 TiB disk will use 4 MiB RAM,
49 * so this seems to be reasonable.
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/* Code configuration options. */
69
70/* Enable debug messages. */
71//~ #define CONFIG_VDI_DEBUG
72
73/* Support write operations on VDI images. */
74#define CONFIG_VDI_WRITE
75
76/* Support non-standard block (cluster) size. This is untested.
77 * Maybe it will be needed for very large images.
78 */
79//~ #define CONFIG_VDI_BLOCK_SIZE
80
81/* Support static (fixed, pre-allocated) images. */
82#define CONFIG_VDI_STATIC_IMAGE
83
84/* Command line option for static images. */
85#define BLOCK_OPT_STATIC "static"
86
87#define SECTOR_SIZE 512
88#define DEFAULT_CLUSTER_SIZE 1048576
89/* Note: can't use 1 * MiB, because it's passed to stringify() */
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/* Image signature. */
105#define VDI_SIGNATURE 0xbeda107f
106
107/* Image version. */
108#define VDI_VERSION_1_1 0x00010001
109
110/* Image type. */
111#define VDI_TYPE_DYNAMIC 1
112#define VDI_TYPE_STATIC 2
113
114/* Innotek / SUN images use these strings in header.text:
115 * "<<< innotek VirtualBox Disk Image >>>\n"
116 * "<<< Sun xVM VirtualBox Disk Image >>>\n"
117 * "<<< Sun VirtualBox Disk Image >>>\n"
118 * The value does not matter, so QEMU created images use a different text.
119 */
120#define VDI_TEXT "<<< QEMU VM Virtual Disk Image >>>\n"
121
122/* A never-allocated block; semantically arbitrary content. */
123#define VDI_UNALLOCATED 0xffffffffU
124
125/* A discarded (no longer allocated) block; semantically zero-filled. */
126#define VDI_DISCARDED 0xfffffffeU
127
128#define VDI_IS_ALLOCATED(X) ((X) < VDI_DISCARDED)
129
130/* The bmap will take up VDI_BLOCKS_IN_IMAGE_MAX * sizeof(uint32_t) bytes; since
131 * the bmap is read and written in a single operation, its size needs to be
132 * limited to INT_MAX; furthermore, when opening an image, the bmap size is
133 * rounded up to be aligned on BDRV_SECTOR_SIZE.
134 * Therefore this should satisfy the following:
135 * VDI_BLOCKS_IN_IMAGE_MAX * sizeof(uint32_t) + BDRV_SECTOR_SIZE == INT_MAX + 1
136 * (INT_MAX + 1 is the first value not representable as an int)
137 * This guarantees that any value below or equal to the constant will, when
138 * multiplied by sizeof(uint32_t) and rounded up to a BDRV_SECTOR_SIZE boundary,
139 * still be below or equal to INT_MAX. */
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; /* disk geometry, unused here */
158 uint32_t heads; /* disk geometry, unused here */
159 uint32_t sectors; /* disk geometry, unused here */
160 uint32_t sector_size;
161 uint32_t unused1;
162 uint64_t disk_size;
163 uint32_t block_size;
164 uint32_t block_extra; /* unused here */
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
174QEMU_BUILD_BUG_ON(sizeof(VdiHeader) != 512);
175
176typedef struct {
177 /* The block map entries are little endian (even in memory). */
178 uint32_t *bmap;
179 /* Size of block (bytes). */
180 uint32_t block_size;
181 /* First sector of block map. */
182 uint32_t bmap_sector;
183 /* VDI header (converted to host endianness). */
184 VdiHeader header;
185
186 CoRwlock bmap_lock;
187
188 Error *migration_blocker;
189} BDRVVdiState;
190
191static void vdi_header_to_cpu(VdiHeader *header)
192{
193 header->signature = le32_to_cpu(header->signature);
194 header->version = le32_to_cpu(header->version);
195 header->header_size = le32_to_cpu(header->header_size);
196 header->image_type = le32_to_cpu(header->image_type);
197 header->image_flags = le32_to_cpu(header->image_flags);
198 header->offset_bmap = le32_to_cpu(header->offset_bmap);
199 header->offset_data = le32_to_cpu(header->offset_data);
200 header->cylinders = le32_to_cpu(header->cylinders);
201 header->heads = le32_to_cpu(header->heads);
202 header->sectors = le32_to_cpu(header->sectors);
203 header->sector_size = le32_to_cpu(header->sector_size);
204 header->disk_size = le64_to_cpu(header->disk_size);
205 header->block_size = le32_to_cpu(header->block_size);
206 header->block_extra = le32_to_cpu(header->block_extra);
207 header->blocks_in_image = le32_to_cpu(header->blocks_in_image);
208 header->blocks_allocated = le32_to_cpu(header->blocks_allocated);
209 header->uuid_image = qemu_uuid_bswap(header->uuid_image);
210 header->uuid_last_snap = qemu_uuid_bswap(header->uuid_last_snap);
211 header->uuid_link = qemu_uuid_bswap(header->uuid_link);
212 header->uuid_parent = qemu_uuid_bswap(header->uuid_parent);
213}
214
215static void vdi_header_to_le(VdiHeader *header)
216{
217 header->signature = cpu_to_le32(header->signature);
218 header->version = cpu_to_le32(header->version);
219 header->header_size = cpu_to_le32(header->header_size);
220 header->image_type = cpu_to_le32(header->image_type);
221 header->image_flags = cpu_to_le32(header->image_flags);
222 header->offset_bmap = cpu_to_le32(header->offset_bmap);
223 header->offset_data = cpu_to_le32(header->offset_data);
224 header->cylinders = cpu_to_le32(header->cylinders);
225 header->heads = cpu_to_le32(header->heads);
226 header->sectors = cpu_to_le32(header->sectors);
227 header->sector_size = cpu_to_le32(header->sector_size);
228 header->disk_size = cpu_to_le64(header->disk_size);
229 header->block_size = cpu_to_le32(header->block_size);
230 header->block_extra = cpu_to_le32(header->block_extra);
231 header->blocks_in_image = cpu_to_le32(header->blocks_in_image);
232 header->blocks_allocated = cpu_to_le32(header->blocks_allocated);
233 header->uuid_image = qemu_uuid_bswap(header->uuid_image);
234 header->uuid_last_snap = qemu_uuid_bswap(header->uuid_last_snap);
235 header->uuid_link = qemu_uuid_bswap(header->uuid_link);
236 header->uuid_parent = qemu_uuid_bswap(header->uuid_parent);
237}
238
239static void vdi_header_print(VdiHeader *header)
240{
241 char uuidstr[37];
242 QemuUUID uuid;
243 logout("text %s", header->text);
244 logout("signature 0x%08x\n", header->signature);
245 logout("header size 0x%04x\n", header->header_size);
246 logout("image type 0x%04x\n", header->image_type);
247 logout("image flags 0x%04x\n", header->image_flags);
248 logout("description %s\n", header->description);
249 logout("offset bmap 0x%04x\n", header->offset_bmap);
250 logout("offset data 0x%04x\n", header->offset_data);
251 logout("cylinders 0x%04x\n", header->cylinders);
252 logout("heads 0x%04x\n", header->heads);
253 logout("sectors 0x%04x\n", header->sectors);
254 logout("sector size 0x%04x\n", header->sector_size);
255 logout("image size 0x%" PRIx64 " B (%" PRIu64 " MiB)\n",
256 header->disk_size, header->disk_size / MiB);
257 logout("block size 0x%04x\n", header->block_size);
258 logout("block extra 0x%04x\n", header->block_extra);
259 logout("blocks tot. 0x%04x\n", header->blocks_in_image);
260 logout("blocks all. 0x%04x\n", header->blocks_allocated);
261 uuid = header->uuid_image;
262 qemu_uuid_unparse(&uuid, uuidstr);
263 logout("uuid image %s\n", uuidstr);
264 uuid = header->uuid_last_snap;
265 qemu_uuid_unparse(&uuid, uuidstr);
266 logout("uuid snap %s\n", uuidstr);
267 uuid = header->uuid_link;
268 qemu_uuid_unparse(&uuid, uuidstr);
269 logout("uuid link %s\n", uuidstr);
270 uuid = header->uuid_parent;
271 qemu_uuid_unparse(&uuid, uuidstr);
272 logout("uuid parent %s\n", uuidstr);
273}
274
275static int coroutine_fn vdi_co_check(BlockDriverState *bs, BdrvCheckResult *res,
276 BdrvCheckMode fix)
277{
278 /* TODO: additional checks possible. */
279 BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
280 uint32_t blocks_allocated = 0;
281 uint32_t block;
282 uint32_t *bmap;
283 logout("\n");
284
285 if (fix) {
286 return -ENOTSUP;
287 }
288
289 bmap = g_try_new(uint32_t, s->header.blocks_in_image);
290 if (s->header.blocks_in_image && bmap == NULL) {
291 res->check_errors++;
292 return -ENOMEM;
293 }
294
295 memset(bmap, 0xff, s->header.blocks_in_image * sizeof(uint32_t));
296
297 /* Check block map and value of blocks_allocated. */
298 for (block = 0; block < s->header.blocks_in_image; block++) {
299 uint32_t bmap_entry = le32_to_cpu(s->bmap[block]);
300 if (VDI_IS_ALLOCATED(bmap_entry)) {
301 if (bmap_entry < s->header.blocks_in_image) {
302 blocks_allocated++;
303 if (!VDI_IS_ALLOCATED(bmap[bmap_entry])) {
304 bmap[bmap_entry] = bmap_entry;
305 } else {
306 fprintf(stderr, "ERROR: block index %" PRIu32
307 " also used by %" PRIu32 "\n", bmap[bmap_entry], bmap_entry);
308 res->corruptions++;
309 }
310 } else {
311 fprintf(stderr, "ERROR: block index %" PRIu32
312 " too large, is %" PRIu32 "\n", block, bmap_entry);
313 res->corruptions++;
314 }
315 }
316 }
317 if (blocks_allocated != s->header.blocks_allocated) {
318 fprintf(stderr, "ERROR: allocated blocks mismatch, is %" PRIu32
319 ", should be %" PRIu32 "\n",
320 blocks_allocated, s->header.blocks_allocated);
321 res->corruptions++;
322 }
323
324 g_free(bmap);
325
326 return 0;
327}
328
329static int vdi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
330{
331 /* TODO: vdi_get_info would be needed for machine snapshots.
332 vm_state_offset is still missing. */
333 BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
334 logout("\n");
335 bdi->cluster_size = s->block_size;
336 bdi->vm_state_offset = 0;
337 bdi->unallocated_blocks_are_zero = true;
338 return 0;
339}
340
341static int vdi_make_empty(BlockDriverState *bs)
342{
343 /* TODO: missing code. */
344 logout("\n");
345 /* The return value for missing code must be 0, see block.c. */
346 return 0;
347}
348
349static int vdi_probe(const uint8_t *buf, int buf_size, const char *filename)
350{
351 const VdiHeader *header = (const VdiHeader *)buf;
352 int ret = 0;
353
354 logout("\n");
355
356 if (buf_size < sizeof(*header)) {
357 /* Header too small, no VDI. */
358 } else if (le32_to_cpu(header->signature) == VDI_SIGNATURE) {
359 ret = 100;
360 }
361
362 if (ret == 0) {
363 logout("no vdi image\n");
364 } else {
365 logout("%s", header->text);
366 }
367
368 return ret;
369}
370
371static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
372 Error **errp)
373{
374 BDRVVdiState *s = bs->opaque;
375 VdiHeader header;
376 size_t bmap_size;
377 int ret;
378 Error *local_err = NULL;
379 QemuUUID uuid_link, uuid_parent;
380
381 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
382 false, errp);
383 if (!bs->file) {
384 return -EINVAL;
385 }
386
387 logout("\n");
388
389 ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
390 if (ret < 0) {
391 goto fail;
392 }
393
394 vdi_header_to_cpu(&header);
395 if (VDI_DEBUG) {
396 vdi_header_print(&header);
397 }
398
399 if (header.disk_size > VDI_DISK_SIZE_MAX) {
400 error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
401 ", max supported is 0x%" PRIx64 ")",
402 header.disk_size, VDI_DISK_SIZE_MAX);
403 ret = -ENOTSUP;
404 goto fail;
405 }
406
407 uuid_link = header.uuid_link;
408 uuid_parent = header.uuid_parent;
409
410 if (header.disk_size % SECTOR_SIZE != 0) {
411 /* 'VBoxManage convertfromraw' can create images with odd disk sizes.
412 We accept them but round the disk size to the next multiple of
413 SECTOR_SIZE. */
414 logout("odd disk size %" PRIu64 " B, round up\n", header.disk_size);
415 header.disk_size = ROUND_UP(header.disk_size, SECTOR_SIZE);
416 }
417
418 if (header.signature != VDI_SIGNATURE) {
419 error_setg(errp, "Image not in VDI format (bad signature %08" PRIx32
420 ")", header.signature);
421 ret = -EINVAL;
422 goto fail;
423 } else if (header.version != VDI_VERSION_1_1) {
424 error_setg(errp, "unsupported VDI image (version %" PRIu32 ".%" PRIu32
425 ")", header.version >> 16, header.version & 0xffff);
426 ret = -ENOTSUP;
427 goto fail;
428 } else if (header.offset_bmap % SECTOR_SIZE != 0) {
429 /* We only support block maps which start on a sector boundary. */
430 error_setg(errp, "unsupported VDI image (unaligned block map offset "
431 "0x%" PRIx32 ")", header.offset_bmap);
432 ret = -ENOTSUP;
433 goto fail;
434 } else if (header.offset_data % SECTOR_SIZE != 0) {
435 /* We only support data blocks which start on a sector boundary. */
436 error_setg(errp, "unsupported VDI image (unaligned data offset 0x%"
437 PRIx32 ")", header.offset_data);
438 ret = -ENOTSUP;
439 goto fail;
440 } else if (header.sector_size != SECTOR_SIZE) {
441 error_setg(errp, "unsupported VDI image (sector size %" PRIu32
442 " is not %u)", header.sector_size, SECTOR_SIZE);
443 ret = -ENOTSUP;
444 goto fail;
445 } else if (header.block_size != DEFAULT_CLUSTER_SIZE) {
446 error_setg(errp, "unsupported VDI image (block size %" PRIu32
447 " is not %" PRIu32 ")",
448 header.block_size, DEFAULT_CLUSTER_SIZE);
449 ret = -ENOTSUP;
450 goto fail;
451 } else if (header.disk_size >
452 (uint64_t)header.blocks_in_image * header.block_size) {
453 error_setg(errp, "unsupported VDI image (disk size %" PRIu64 ", "
454 "image bitmap has room for %" PRIu64 ")",
455 header.disk_size,
456 (uint64_t)header.blocks_in_image * header.block_size);
457 ret = -ENOTSUP;
458 goto fail;
459 } else if (!qemu_uuid_is_null(&uuid_link)) {
460 error_setg(errp, "unsupported VDI image (non-NULL link UUID)");
461 ret = -ENOTSUP;
462 goto fail;
463 } else if (!qemu_uuid_is_null(&uuid_parent)) {
464 error_setg(errp, "unsupported VDI image (non-NULL parent UUID)");
465 ret = -ENOTSUP;
466 goto fail;
467 } else if (header.blocks_in_image > VDI_BLOCKS_IN_IMAGE_MAX) {
468 error_setg(errp, "unsupported VDI image "
469 "(too many blocks %u, max is %u)",
470 header.blocks_in_image, VDI_BLOCKS_IN_IMAGE_MAX);
471 ret = -ENOTSUP;
472 goto fail;
473 }
474
475 bs->total_sectors = header.disk_size / SECTOR_SIZE;
476
477 s->block_size = header.block_size;
478 s->bmap_sector = header.offset_bmap / SECTOR_SIZE;
479 s->header = header;
480
481 bmap_size = header.blocks_in_image * sizeof(uint32_t);
482 bmap_size = DIV_ROUND_UP(bmap_size, SECTOR_SIZE);
483 s->bmap = qemu_try_blockalign(bs->file->bs, bmap_size * SECTOR_SIZE);
484 if (s->bmap == NULL) {
485 ret = -ENOMEM;
486 goto fail;
487 }
488
489 ret = bdrv_pread(bs->file, header.offset_bmap, s->bmap,
490 bmap_size * SECTOR_SIZE);
491 if (ret < 0) {
492 goto fail_free_bmap;
493 }
494
495 /* Disable migration when vdi images are used */
496 error_setg(&s->migration_blocker, "The vdi format used by node '%s' "
497 "does not support live migration",
498 bdrv_get_device_or_node_name(bs));
499 ret = migrate_add_blocker(s->migration_blocker, &local_err);
500 if (local_err) {
501 error_propagate(errp, local_err);
502 error_free(s->migration_blocker);
503 goto fail_free_bmap;
504 }
505
506 qemu_co_rwlock_init(&s->bmap_lock);
507
508 return 0;
509
510 fail_free_bmap:
511 qemu_vfree(s->bmap);
512
513 fail:
514 return ret;
515}
516
517static int vdi_reopen_prepare(BDRVReopenState *state,
518 BlockReopenQueue *queue, Error **errp)
519{
520 return 0;
521}
522
523static int coroutine_fn vdi_co_block_status(BlockDriverState *bs,
524 bool want_zero,
525 int64_t offset, int64_t bytes,
526 int64_t *pnum, int64_t *map,
527 BlockDriverState **file)
528{
529 BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
530 size_t bmap_index = offset / s->block_size;
531 size_t index_in_block = offset % s->block_size;
532 uint32_t bmap_entry = le32_to_cpu(s->bmap[bmap_index]);
533 int result;
534
535 logout("%p, %" PRId64 ", %" PRId64 ", %p\n", bs, offset, bytes, pnum);
536 *pnum = MIN(s->block_size - index_in_block, bytes);
537 result = VDI_IS_ALLOCATED(bmap_entry);
538 if (!result) {
539 return 0;
540 }
541
542 *map = s->header.offset_data + (uint64_t)bmap_entry * s->block_size +
543 index_in_block;
544 *file = bs->file->bs;
545 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID |
546 (s->header.image_type == VDI_TYPE_STATIC ? BDRV_BLOCK_RECURSE : 0);
547}
548
549static int coroutine_fn
550vdi_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
551 QEMUIOVector *qiov, int flags)
552{
553 BDRVVdiState *s = bs->opaque;
554 QEMUIOVector local_qiov;
555 uint32_t bmap_entry;
556 uint32_t block_index;
557 uint32_t offset_in_block;
558 uint32_t n_bytes;
559 uint64_t bytes_done = 0;
560 int ret = 0;
561
562 logout("\n");
563
564 qemu_iovec_init(&local_qiov, qiov->niov);
565
566 while (ret >= 0 && bytes > 0) {
567 block_index = offset / s->block_size;
568 offset_in_block = offset % s->block_size;
569 n_bytes = MIN(bytes, s->block_size - offset_in_block);
570
571 logout("will read %u bytes starting at offset %" PRIu64 "\n",
572 n_bytes, offset);
573
574 /* prepare next AIO request */
575 qemu_co_rwlock_rdlock(&s->bmap_lock);
576 bmap_entry = le32_to_cpu(s->bmap[block_index]);
577 qemu_co_rwlock_unlock(&s->bmap_lock);
578 if (!VDI_IS_ALLOCATED(bmap_entry)) {
579 /* Block not allocated, return zeros, no need to wait. */
580 qemu_iovec_memset(qiov, bytes_done, 0, n_bytes);
581 ret = 0;
582 } else {
583 uint64_t data_offset = s->header.offset_data +
584 (uint64_t)bmap_entry * s->block_size +
585 offset_in_block;
586
587 qemu_iovec_reset(&local_qiov);
588 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
589
590 ret = bdrv_co_preadv(bs->file, data_offset, n_bytes,
591 &local_qiov, 0);
592 }
593 logout("%u bytes read\n", n_bytes);
594
595 bytes -= n_bytes;
596 offset += n_bytes;
597 bytes_done += n_bytes;
598 }
599
600 qemu_iovec_destroy(&local_qiov);
601
602 return ret;
603}
604
605static int coroutine_fn
606vdi_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
607 QEMUIOVector *qiov, int flags)
608{
609 BDRVVdiState *s = bs->opaque;
610 QEMUIOVector local_qiov;
611 uint32_t bmap_entry;
612 uint32_t block_index;
613 uint32_t offset_in_block;
614 uint32_t n_bytes;
615 uint64_t data_offset;
616 uint32_t bmap_first = VDI_UNALLOCATED;
617 uint32_t bmap_last = VDI_UNALLOCATED;
618 uint8_t *block = NULL;
619 uint64_t bytes_done = 0;
620 int ret = 0;
621
622 logout("\n");
623
624 qemu_iovec_init(&local_qiov, qiov->niov);
625
626 while (ret >= 0 && bytes > 0) {
627 block_index = offset / s->block_size;
628 offset_in_block = offset % s->block_size;
629 n_bytes = MIN(bytes, s->block_size - offset_in_block);
630
631 logout("will write %u bytes starting at offset %" PRIu64 "\n",
632 n_bytes, offset);
633
634 /* prepare next AIO request */
635 qemu_co_rwlock_rdlock(&s->bmap_lock);
636 bmap_entry = le32_to_cpu(s->bmap[block_index]);
637 if (!VDI_IS_ALLOCATED(bmap_entry)) {
638 /* Allocate new block and write to it. */
639 uint64_t data_offset;
640 qemu_co_rwlock_upgrade(&s->bmap_lock);
641 bmap_entry = le32_to_cpu(s->bmap[block_index]);
642 if (VDI_IS_ALLOCATED(bmap_entry)) {
643 /* A concurrent allocation did the work for us. */
644 qemu_co_rwlock_downgrade(&s->bmap_lock);
645 goto nonallocating_write;
646 }
647
648 bmap_entry = s->header.blocks_allocated;
649 s->bmap[block_index] = cpu_to_le32(bmap_entry);
650 s->header.blocks_allocated++;
651 data_offset = s->header.offset_data +
652 (uint64_t)bmap_entry * s->block_size;
653 if (block == NULL) {
654 block = g_malloc(s->block_size);
655 bmap_first = block_index;
656 }
657 bmap_last = block_index;
658 /* Copy data to be written to new block and zero unused parts. */
659 memset(block, 0, offset_in_block);
660 qemu_iovec_to_buf(qiov, bytes_done, block + offset_in_block,
661 n_bytes);
662 memset(block + offset_in_block + n_bytes, 0,
663 s->block_size - n_bytes - offset_in_block);
664
665 /* Write the new block under CoRwLock write-side protection,
666 * so this full-cluster write does not overlap a partial write
667 * of the same cluster, issued from the "else" branch.
668 */
669 ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size);
670 qemu_co_rwlock_unlock(&s->bmap_lock);
671 } else {
672nonallocating_write:
673 data_offset = s->header.offset_data +
674 (uint64_t)bmap_entry * s->block_size +
675 offset_in_block;
676 qemu_co_rwlock_unlock(&s->bmap_lock);
677
678 qemu_iovec_reset(&local_qiov);
679 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
680
681 ret = bdrv_co_pwritev(bs->file, data_offset, n_bytes,
682 &local_qiov, 0);
683 }
684
685 bytes -= n_bytes;
686 offset += n_bytes;
687 bytes_done += n_bytes;
688
689 logout("%u bytes written\n", n_bytes);
690 }
691
692 qemu_iovec_destroy(&local_qiov);
693
694 logout("finished data write\n");
695 if (ret < 0) {
696 return ret;
697 }
698
699 if (block) {
700 /* One or more new blocks were allocated. */
701 VdiHeader *header = (VdiHeader *) block;
702 uint8_t *base;
703 uint64_t offset;
704 uint32_t n_sectors;
705
706 logout("now writing modified header\n");
707 assert(VDI_IS_ALLOCATED(bmap_first));
708 *header = s->header;
709 vdi_header_to_le(header);
710 ret = bdrv_pwrite(bs->file, 0, block, sizeof(VdiHeader));
711 g_free(block);
712 block = NULL;
713
714 if (ret < 0) {
715 return ret;
716 }
717
718 logout("now writing modified block map entry %u...%u\n",
719 bmap_first, bmap_last);
720 /* Write modified sectors from block map. */
721 bmap_first /= (SECTOR_SIZE / sizeof(uint32_t));
722 bmap_last /= (SECTOR_SIZE / sizeof(uint32_t));
723 n_sectors = bmap_last - bmap_first + 1;
724 offset = s->bmap_sector + bmap_first;
725 base = ((uint8_t *)&s->bmap[0]) + bmap_first * SECTOR_SIZE;
726 logout("will write %u block map sectors starting from entry %u\n",
727 n_sectors, bmap_first);
728 ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE, base,
729 n_sectors * SECTOR_SIZE);
730 }
731
732 return ret < 0 ? ret : 0;
733}
734
735static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
736 size_t block_size, Error **errp)
737{
738 BlockdevCreateOptionsVdi *vdi_opts;
739 int ret = 0;
740 uint64_t bytes = 0;
741 uint32_t blocks;
742 uint32_t image_type;
743 VdiHeader header;
744 size_t i;
745 size_t bmap_size;
746 int64_t offset = 0;
747 BlockDriverState *bs_file = NULL;
748 BlockBackend *blk = NULL;
749 uint32_t *bmap = NULL;
750 QemuUUID uuid;
751
752 assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
753 vdi_opts = &create_options->u.vdi;
754
755 logout("\n");
756
757 /* Validate options and set default values */
758 bytes = vdi_opts->size;
759
760 if (!vdi_opts->has_preallocation) {
761 vdi_opts->preallocation = PREALLOC_MODE_OFF;
762 }
763 switch (vdi_opts->preallocation) {
764 case PREALLOC_MODE_OFF:
765 image_type = VDI_TYPE_DYNAMIC;
766 break;
767 case PREALLOC_MODE_METADATA:
768 image_type = VDI_TYPE_STATIC;
769 break;
770 default:
771 error_setg(errp, "Preallocation mode not supported for vdi");
772 return -EINVAL;
773 }
774
775#ifndef CONFIG_VDI_STATIC_IMAGE
776 if (image_type == VDI_TYPE_STATIC) {
777 ret = -ENOTSUP;
778 error_setg(errp, "Statically allocated images cannot be created in "
779 "this build");
780 goto exit;
781 }
782#endif
783#ifndef CONFIG_VDI_BLOCK_SIZE
784 if (block_size != DEFAULT_CLUSTER_SIZE) {
785 ret = -ENOTSUP;
786 error_setg(errp,
787 "A non-default cluster size is not supported in this build");
788 goto exit;
789 }
790#endif
791
792 if (bytes > VDI_DISK_SIZE_MAX) {
793 ret = -ENOTSUP;
794 error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
795 ", max supported is 0x%" PRIx64 ")",
796 bytes, VDI_DISK_SIZE_MAX);
797 goto exit;
798 }
799
800 /* Create BlockBackend to write to the image */
801 bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
802 if (!bs_file) {
803 ret = -EIO;
804 goto exit;
805 }
806
807 blk = blk_new(bdrv_get_aio_context(bs_file),
808 BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
809 ret = blk_insert_bs(blk, bs_file, errp);
810 if (ret < 0) {
811 goto exit;
812 }
813
814 blk_set_allow_write_beyond_eof(blk, true);
815
816 /* We need enough blocks to store the given disk size,
817 so always round up. */
818 blocks = DIV_ROUND_UP(bytes, block_size);
819
820 bmap_size = blocks * sizeof(uint32_t);
821 bmap_size = ROUND_UP(bmap_size, SECTOR_SIZE);
822
823 memset(&header, 0, sizeof(header));
824 pstrcpy(header.text, sizeof(header.text), VDI_TEXT);
825 header.signature = VDI_SIGNATURE;
826 header.version = VDI_VERSION_1_1;
827 header.header_size = 0x180;
828 header.image_type = image_type;
829 header.offset_bmap = 0x200;
830 header.offset_data = 0x200 + bmap_size;
831 header.sector_size = SECTOR_SIZE;
832 header.disk_size = bytes;
833 header.block_size = block_size;
834 header.blocks_in_image = blocks;
835 if (image_type == VDI_TYPE_STATIC) {
836 header.blocks_allocated = blocks;
837 }
838 qemu_uuid_generate(&uuid);
839 header.uuid_image = uuid;
840 qemu_uuid_generate(&uuid);
841 header.uuid_last_snap = uuid;
842 /* There is no need to set header.uuid_link or header.uuid_parent here. */
843 if (VDI_DEBUG) {
844 vdi_header_print(&header);
845 }
846 vdi_header_to_le(&header);
847 ret = blk_pwrite(blk, offset, &header, sizeof(header), 0);
848 if (ret < 0) {
849 error_setg(errp, "Error writing header");
850 goto exit;
851 }
852 offset += sizeof(header);
853
854 if (bmap_size > 0) {
855 bmap = g_try_malloc0(bmap_size);
856 if (bmap == NULL) {
857 ret = -ENOMEM;
858 error_setg(errp, "Could not allocate bmap");
859 goto exit;
860 }
861 for (i = 0; i < blocks; i++) {
862 if (image_type == VDI_TYPE_STATIC) {
863 bmap[i] = i;
864 } else {
865 bmap[i] = VDI_UNALLOCATED;
866 }
867 }
868 ret = blk_pwrite(blk, offset, bmap, bmap_size, 0);
869 if (ret < 0) {
870 error_setg(errp, "Error writing bmap");
871 goto exit;
872 }
873 offset += bmap_size;
874 }
875
876 if (image_type == VDI_TYPE_STATIC) {
877 ret = blk_truncate(blk, offset + blocks * block_size,
878 PREALLOC_MODE_OFF, errp);
879 if (ret < 0) {
880 error_prepend(errp, "Failed to statically allocate file");
881 goto exit;
882 }
883 }
884
885 ret = 0;
886exit:
887 blk_unref(blk);
888 bdrv_unref(bs_file);
889 g_free(bmap);
890 return ret;
891}
892
893static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
894 Error **errp)
895{
896 return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
897}
898
899static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
900 Error **errp)
901{
902 QDict *qdict = NULL;
903 BlockdevCreateOptions *create_options = NULL;
904 BlockDriverState *bs_file = NULL;
905 uint64_t block_size = DEFAULT_CLUSTER_SIZE;
906 bool is_static = false;
907 Visitor *v;
908 Error *local_err = NULL;
909 int ret;
910
911 /* Parse options and convert legacy syntax.
912 *
913 * Since CONFIG_VDI_BLOCK_SIZE is disabled by default,
914 * cluster-size is not part of the QAPI schema; therefore we have
915 * to parse it before creating the QAPI object. */
916#if defined(CONFIG_VDI_BLOCK_SIZE)
917 block_size = qemu_opt_get_size_del(opts,
918 BLOCK_OPT_CLUSTER_SIZE,
919 DEFAULT_CLUSTER_SIZE);
920 if (block_size < BDRV_SECTOR_SIZE || block_size > UINT32_MAX ||
921 !is_power_of_2(block_size))
922 {
923 error_setg(errp, "Invalid cluster size");
924 ret = -EINVAL;
925 goto done;
926 }
927#endif
928 if (qemu_opt_get_bool_del(opts, BLOCK_OPT_STATIC, false)) {
929 is_static = true;
930 }
931
932 qdict = qemu_opts_to_qdict_filtered(opts, NULL, &vdi_create_opts, true);
933
934 /* Create and open the file (protocol layer) */
935 ret = bdrv_create_file(filename, opts, errp);
936 if (ret < 0) {
937 goto done;
938 }
939
940 bs_file = bdrv_open(filename, NULL, NULL,
941 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
942 if (!bs_file) {
943 ret = -EIO;
944 goto done;
945 }
946
947 qdict_put_str(qdict, "driver", "vdi");
948 qdict_put_str(qdict, "file", bs_file->node_name);
949 if (is_static) {
950 qdict_put_str(qdict, "preallocation", "metadata");
951 }
952
953 /* Get the QAPI object */
954 v = qobject_input_visitor_new_flat_confused(qdict, errp);
955 if (!v) {
956 ret = -EINVAL;
957 goto done;
958 }
959 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
960 visit_free(v);
961
962 if (local_err) {
963 error_propagate(errp, local_err);
964 ret = -EINVAL;
965 goto done;
966 }
967
968 /* Silently round up size */
969 assert(create_options->driver == BLOCKDEV_DRIVER_VDI);
970 create_options->u.vdi.size = ROUND_UP(create_options->u.vdi.size,
971 BDRV_SECTOR_SIZE);
972
973 /* Create the vdi image (format layer) */
974 ret = vdi_co_do_create(create_options, block_size, errp);
975done:
976 qobject_unref(qdict);
977 qapi_free_BlockdevCreateOptions(create_options);
978 bdrv_unref(bs_file);
979 return ret;
980}
981
982static void vdi_close(BlockDriverState *bs)
983{
984 BDRVVdiState *s = bs->opaque;
985
986 qemu_vfree(s->bmap);
987
988 migrate_del_blocker(s->migration_blocker);
989 error_free(s->migration_blocker);
990}
991
992static int vdi_has_zero_init(BlockDriverState *bs)
993{
994 BDRVVdiState *s = bs->opaque;
995
996 if (s->header.image_type == VDI_TYPE_STATIC) {
997 return bdrv_has_zero_init(bs->file->bs);
998 } else {
999 return 1;
1000 }
1001}
1002
1003static QemuOptsList vdi_create_opts = {
1004 .name = "vdi-create-opts",
1005 .head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),
1006 .desc = {
1007 {
1008 .name = BLOCK_OPT_SIZE,
1009 .type = QEMU_OPT_SIZE,
1010 .help = "Virtual disk size"
1011 },
1012#if defined(CONFIG_VDI_BLOCK_SIZE)
1013 {
1014 .name = BLOCK_OPT_CLUSTER_SIZE,
1015 .type = QEMU_OPT_SIZE,
1016 .help = "VDI cluster (block) size",
1017 .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
1018 },
1019#endif
1020#if defined(CONFIG_VDI_STATIC_IMAGE)
1021 {
1022 .name = BLOCK_OPT_STATIC,
1023 .type = QEMU_OPT_BOOL,
1024 .help = "VDI static (pre-allocated) image",
1025 .def_value_str = "off"
1026 },
1027#endif
1028 /* TODO: An additional option to set UUID values might be useful. */
1029 { /* end of list */ }
1030 }
1031};
1032
1033static BlockDriver bdrv_vdi = {
1034 .format_name = "vdi",
1035 .instance_size = sizeof(BDRVVdiState),
1036 .bdrv_probe = vdi_probe,
1037 .bdrv_open = vdi_open,
1038 .bdrv_close = vdi_close,
1039 .bdrv_reopen_prepare = vdi_reopen_prepare,
1040 .bdrv_child_perm = bdrv_format_default_perms,
1041 .bdrv_co_create = vdi_co_create,
1042 .bdrv_co_create_opts = vdi_co_create_opts,
1043 .bdrv_has_zero_init = vdi_has_zero_init,
1044 .bdrv_co_block_status = vdi_co_block_status,
1045 .bdrv_make_empty = vdi_make_empty,
1046
1047 .bdrv_co_preadv = vdi_co_preadv,
1048#if defined(CONFIG_VDI_WRITE)
1049 .bdrv_co_pwritev = vdi_co_pwritev,
1050#endif
1051
1052 .bdrv_get_info = vdi_get_info,
1053
1054 .create_opts = &vdi_create_opts,
1055 .bdrv_co_check = vdi_co_check,
1056};
1057
1058static void bdrv_vdi_init(void)
1059{
1060 logout("\n");
1061 bdrv_register(&bdrv_vdi);
1062}
1063
1064block_init(bdrv_vdi_init);
1065