2 * Block driver for the Virtual Disk Image (VDI) format
4 * Copyright (c) 2009 Stefan Weil
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.
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.
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/>.
20 * http://forums.virtualbox.org/viewtopic.php?t=8046
22 * This driver supports create / read / write operations on VDI images.
24 * Todo (see also TODO in code):
26 * Some features like snapshots are still missing.
28 * Deallocation of zero-filled blocks and shrinking images are missing, too
29 * (might be added to common block layer).
31 * Allocation of blocks could be optimized (less writes to block map and
34 * Read and write of adjacents blocks could be done in one operation
35 * (current code uses one operation per block (1 MiB).
37 * The code is not thread safe (missing locks for changes in header and
38 * block table, no problem with current QEMU).
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.
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.
52 #include "qemu-common.h"
53 #include "block_int.h"
56 #if defined(CONFIG_UUID)
57 #include <uuid/uuid.h>
59 /* TODO: move uuid emulation to some central place in QEMU. */
60 #include "sysemu.h" /* UUID_FMT */
61 typedef unsigned char uuid_t
[16];
62 void uuid_generate(uuid_t out
);
63 int uuid_is_null(const uuid_t uu
);
64 void uuid_unparse(const uuid_t uu
, char *out
);
67 /* Code configuration options. */
69 /* Enable debug messages. */
70 //~ #define CONFIG_VDI_DEBUG
72 /* Support write operations on VDI images. */
73 #define CONFIG_VDI_WRITE
75 /* Support non-standard block (cluster) size. This is untested.
76 * Maybe it will be needed for very large images.
78 //~ #define CONFIG_VDI_BLOCK_SIZE
80 /* Support static (fixed, pre-allocated) images. */
81 #define CONFIG_VDI_STATIC_IMAGE
83 /* Command line option for static images. */
84 #define BLOCK_OPT_STATIC "static"
87 #define MiB (KiB * KiB)
89 #define SECTOR_SIZE 512
90 #define DEFAULT_CLUSTER_SIZE (1 * MiB)
92 #if defined(CONFIG_VDI_DEBUG)
93 #define logout(fmt, ...) \
94 fprintf(stderr, "vdi\t%-24s" fmt, __func__, ##__VA_ARGS__)
96 #define logout(fmt, ...) ((void)0)
99 /* Image signature. */
100 #define VDI_SIGNATURE 0xbeda107f
103 #define VDI_VERSION_1_1 0x00010001
106 #define VDI_TYPE_DYNAMIC 1
107 #define VDI_TYPE_STATIC 2
109 /* Innotek / SUN images use these strings in header.text:
110 * "<<< innotek VirtualBox Disk Image >>>\n"
111 * "<<< Sun xVM VirtualBox Disk Image >>>\n"
112 * "<<< Sun VirtualBox Disk Image >>>\n"
113 * The value does not matter, so QEMU created images use a different text.
115 #define VDI_TEXT "<<< QEMU VM Virtual Disk Image >>>\n"
117 /* Unallocated blocks use this index (no need to convert endianness). */
118 #define VDI_UNALLOCATED UINT32_MAX
120 #if !defined(CONFIG_UUID)
121 void uuid_generate(uuid_t out
)
123 memset(out
, 0, sizeof(uuid_t
));
126 int uuid_is_null(const uuid_t uu
)
128 uuid_t null_uuid
= { 0 };
129 return memcmp(uu
, null_uuid
, sizeof(uuid_t
)) == 0;
132 void uuid_unparse(const uuid_t uu
, char *out
)
134 snprintf(out
, 37, UUID_FMT
,
135 uu
[0], uu
[1], uu
[2], uu
[3], uu
[4], uu
[5], uu
[6], uu
[7],
136 uu
[8], uu
[9], uu
[10], uu
[11], uu
[12], uu
[13], uu
[14], uu
[15]);
141 BlockDriverAIOCB common
;
145 /* Total number of sectors. */
147 /* Number of sectors for current AIO. */
149 /* New allocated block map entry. */
152 /* Buffer for new allocated block. */
157 BlockDriverAIOCB
*hd_aiocb
;
159 QEMUIOVector hd_qiov
;
167 uint32_t header_size
;
169 uint32_t image_flags
;
170 char description
[256];
171 uint32_t offset_bmap
;
172 uint32_t offset_data
;
173 uint32_t cylinders
; /* disk geometry, unused here */
174 uint32_t heads
; /* disk geometry, unused here */
175 uint32_t sectors
; /* disk geometry, unused here */
176 uint32_t sector_size
;
180 uint32_t block_extra
; /* unused here */
181 uint32_t blocks_in_image
;
182 uint32_t blocks_allocated
;
184 uuid_t uuid_last_snap
;
191 /* The block map entries are little endian (even in memory). */
193 /* Size of block (bytes). */
195 /* Size of block (sectors). */
196 uint32_t block_sectors
;
197 /* First sector of block map. */
198 uint32_t bmap_sector
;
199 /* VDI header (converted to host endianness). */
203 /* Change UUID from little endian (IPRT = VirtualBox format) to big endian
204 * format (network byte order, standard, see RFC 4122) and vice versa.
206 static void uuid_convert(uuid_t uuid
)
208 bswap32s((uint32_t *)&uuid
[0]);
209 bswap16s((uint16_t *)&uuid
[4]);
210 bswap16s((uint16_t *)&uuid
[6]);
213 static void vdi_header_to_cpu(VdiHeader
*header
)
215 le32_to_cpus(&header
->signature
);
216 le32_to_cpus(&header
->version
);
217 le32_to_cpus(&header
->header_size
);
218 le32_to_cpus(&header
->image_type
);
219 le32_to_cpus(&header
->image_flags
);
220 le32_to_cpus(&header
->offset_bmap
);
221 le32_to_cpus(&header
->offset_data
);
222 le32_to_cpus(&header
->cylinders
);
223 le32_to_cpus(&header
->heads
);
224 le32_to_cpus(&header
->sectors
);
225 le32_to_cpus(&header
->sector_size
);
226 le64_to_cpus(&header
->disk_size
);
227 le32_to_cpus(&header
->block_size
);
228 le32_to_cpus(&header
->block_extra
);
229 le32_to_cpus(&header
->blocks_in_image
);
230 le32_to_cpus(&header
->blocks_allocated
);
231 uuid_convert(header
->uuid_image
);
232 uuid_convert(header
->uuid_last_snap
);
233 uuid_convert(header
->uuid_link
);
234 uuid_convert(header
->uuid_parent
);
237 static void vdi_header_to_le(VdiHeader
*header
)
239 cpu_to_le32s(&header
->signature
);
240 cpu_to_le32s(&header
->version
);
241 cpu_to_le32s(&header
->header_size
);
242 cpu_to_le32s(&header
->image_type
);
243 cpu_to_le32s(&header
->image_flags
);
244 cpu_to_le32s(&header
->offset_bmap
);
245 cpu_to_le32s(&header
->offset_data
);
246 cpu_to_le32s(&header
->cylinders
);
247 cpu_to_le32s(&header
->heads
);
248 cpu_to_le32s(&header
->sectors
);
249 cpu_to_le32s(&header
->sector_size
);
250 cpu_to_le64s(&header
->disk_size
);
251 cpu_to_le32s(&header
->block_size
);
252 cpu_to_le32s(&header
->block_extra
);
253 cpu_to_le32s(&header
->blocks_in_image
);
254 cpu_to_le32s(&header
->blocks_allocated
);
255 cpu_to_le32s(&header
->blocks_allocated
);
256 uuid_convert(header
->uuid_image
);
257 uuid_convert(header
->uuid_last_snap
);
258 uuid_convert(header
->uuid_link
);
259 uuid_convert(header
->uuid_parent
);
262 #if defined(CONFIG_VDI_DEBUG)
263 static void vdi_header_print(VdiHeader
*header
)
266 logout("text %s", header
->text
);
267 logout("signature 0x%04x\n", header
->signature
);
268 logout("header size 0x%04x\n", header
->header_size
);
269 logout("image type 0x%04x\n", header
->image_type
);
270 logout("image flags 0x%04x\n", header
->image_flags
);
271 logout("description %s\n", header
->description
);
272 logout("offset bmap 0x%04x\n", header
->offset_bmap
);
273 logout("offset data 0x%04x\n", header
->offset_data
);
274 logout("cylinders 0x%04x\n", header
->cylinders
);
275 logout("heads 0x%04x\n", header
->heads
);
276 logout("sectors 0x%04x\n", header
->sectors
);
277 logout("sector size 0x%04x\n", header
->sector_size
);
278 logout("image size 0x%" PRIx64
" B (%" PRIu64
" MiB)\n",
279 header
->disk_size
, header
->disk_size
/ MiB
);
280 logout("block size 0x%04x\n", header
->block_size
);
281 logout("block extra 0x%04x\n", header
->block_extra
);
282 logout("blocks tot. 0x%04x\n", header
->blocks_in_image
);
283 logout("blocks all. 0x%04x\n", header
->blocks_allocated
);
284 uuid_unparse(header
->uuid_image
, uuid
);
285 logout("uuid image %s\n", uuid
);
286 uuid_unparse(header
->uuid_last_snap
, uuid
);
287 logout("uuid snap %s\n", uuid
);
288 uuid_unparse(header
->uuid_link
, uuid
);
289 logout("uuid link %s\n", uuid
);
290 uuid_unparse(header
->uuid_parent
, uuid
);
291 logout("uuid parent %s\n", uuid
);
295 static int vdi_check(BlockDriverState
*bs
, BdrvCheckResult
*res
)
297 /* TODO: additional checks possible. */
298 BDRVVdiState
*s
= (BDRVVdiState
*)bs
->opaque
;
299 uint32_t blocks_allocated
= 0;
304 bmap
= qemu_malloc(s
->header
.blocks_in_image
* sizeof(uint32_t));
305 memset(bmap
, 0xff, s
->header
.blocks_in_image
* sizeof(uint32_t));
307 /* Check block map and value of blocks_allocated. */
308 for (block
= 0; block
< s
->header
.blocks_in_image
; block
++) {
309 uint32_t bmap_entry
= le32_to_cpu(s
->bmap
[block
]);
310 if (bmap_entry
!= VDI_UNALLOCATED
) {
311 if (bmap_entry
< s
->header
.blocks_in_image
) {
313 if (bmap
[bmap_entry
] == VDI_UNALLOCATED
) {
314 bmap
[bmap_entry
] = bmap_entry
;
316 fprintf(stderr
, "ERROR: block index %" PRIu32
317 " also used by %" PRIu32
"\n", bmap
[bmap_entry
], bmap_entry
);
321 fprintf(stderr
, "ERROR: block index %" PRIu32
322 " too large, is %" PRIu32
"\n", block
, bmap_entry
);
327 if (blocks_allocated
!= s
->header
.blocks_allocated
) {
328 fprintf(stderr
, "ERROR: allocated blocks mismatch, is %" PRIu32
329 ", should be %" PRIu32
"\n",
330 blocks_allocated
, s
->header
.blocks_allocated
);
339 static int vdi_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
341 /* TODO: vdi_get_info would be needed for machine snapshots.
342 vm_state_offset is still missing. */
343 BDRVVdiState
*s
= (BDRVVdiState
*)bs
->opaque
;
345 bdi
->cluster_size
= s
->block_size
;
346 bdi
->vm_state_offset
= 0;
350 static int vdi_make_empty(BlockDriverState
*bs
)
352 /* TODO: missing code. */
354 /* The return value for missing code must be 0, see block.c. */
358 static int vdi_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
360 const VdiHeader
*header
= (const VdiHeader
*)buf
;
365 if (buf_size
< sizeof(*header
)) {
366 /* Header too small, no VDI. */
367 } else if (le32_to_cpu(header
->signature
) == VDI_SIGNATURE
) {
372 logout("no vdi image\n");
374 logout("%s", header
->text
);
380 static int vdi_open(BlockDriverState
*bs
, int flags
)
382 BDRVVdiState
*s
= bs
->opaque
;
388 if (bdrv_read(bs
->file
, 0, (uint8_t *)&header
, 1) < 0) {
392 vdi_header_to_cpu(&header
);
393 #if defined(CONFIG_VDI_DEBUG)
394 vdi_header_print(&header
);
397 if (header
.disk_size
% SECTOR_SIZE
!= 0) {
398 /* 'VBoxManage convertfromraw' can create images with odd disk sizes.
399 We accept them but round the disk size to the next multiple of
401 logout("odd disk size %" PRIu64
" B, round up\n", header
.disk_size
);
402 header
.disk_size
+= SECTOR_SIZE
- 1;
403 header
.disk_size
&= ~(SECTOR_SIZE
- 1);
406 if (header
.version
!= VDI_VERSION_1_1
) {
407 logout("unsupported version %u.%u\n",
408 header
.version
>> 16, header
.version
& 0xffff);
410 } else if (header
.offset_bmap
% SECTOR_SIZE
!= 0) {
411 /* We only support block maps which start on a sector boundary. */
412 logout("unsupported block map offset 0x%x B\n", header
.offset_bmap
);
414 } else if (header
.offset_data
% SECTOR_SIZE
!= 0) {
415 /* We only support data blocks which start on a sector boundary. */
416 logout("unsupported data offset 0x%x B\n", header
.offset_data
);
418 } else if (header
.sector_size
!= SECTOR_SIZE
) {
419 logout("unsupported sector size %u B\n", header
.sector_size
);
421 } else if (header
.block_size
!= 1 * MiB
) {
422 logout("unsupported block size %u B\n", header
.block_size
);
424 } else if (header
.disk_size
>
425 (uint64_t)header
.blocks_in_image
* header
.block_size
) {
426 logout("unsupported disk size %" PRIu64
" B\n", header
.disk_size
);
428 } else if (!uuid_is_null(header
.uuid_link
)) {
429 logout("link uuid != 0, unsupported\n");
431 } else if (!uuid_is_null(header
.uuid_parent
)) {
432 logout("parent uuid != 0, unsupported\n");
436 bs
->total_sectors
= header
.disk_size
/ SECTOR_SIZE
;
438 s
->block_size
= header
.block_size
;
439 s
->block_sectors
= header
.block_size
/ SECTOR_SIZE
;
440 s
->bmap_sector
= header
.offset_bmap
/ SECTOR_SIZE
;
443 bmap_size
= header
.blocks_in_image
* sizeof(uint32_t);
444 bmap_size
= (bmap_size
+ SECTOR_SIZE
- 1) / SECTOR_SIZE
;
446 s
->bmap
= qemu_malloc(bmap_size
* SECTOR_SIZE
);
448 if (bdrv_read(bs
->file
, s
->bmap_sector
, (uint8_t *)s
->bmap
, bmap_size
) < 0) {
461 static int vdi_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
462 int nb_sectors
, int *pnum
)
464 /* TODO: Check for too large sector_num (in bdrv_is_allocated or here). */
465 BDRVVdiState
*s
= (BDRVVdiState
*)bs
->opaque
;
466 size_t bmap_index
= sector_num
/ s
->block_sectors
;
467 size_t sector_in_block
= sector_num
% s
->block_sectors
;
468 int n_sectors
= s
->block_sectors
- sector_in_block
;
469 uint32_t bmap_entry
= le32_to_cpu(s
->bmap
[bmap_index
]);
470 logout("%p, %" PRId64
", %d, %p\n", bs
, sector_num
, nb_sectors
, pnum
);
471 if (n_sectors
> nb_sectors
) {
472 n_sectors
= nb_sectors
;
475 return bmap_entry
!= VDI_UNALLOCATED
;
478 static void vdi_aio_cancel(BlockDriverAIOCB
*blockacb
)
480 /* TODO: This code is untested. How can I get it executed? */
481 VdiAIOCB
*acb
= container_of(blockacb
, VdiAIOCB
, common
);
484 bdrv_aio_cancel(acb
->hd_aiocb
);
486 qemu_aio_release(acb
);
489 static AIOPool vdi_aio_pool
= {
490 .aiocb_size
= sizeof(VdiAIOCB
),
491 .cancel
= vdi_aio_cancel
,
494 static VdiAIOCB
*vdi_aio_setup(BlockDriverState
*bs
, int64_t sector_num
,
495 QEMUIOVector
*qiov
, int nb_sectors
,
496 BlockDriverCompletionFunc
*cb
, void *opaque
, int is_write
)
500 logout("%p, %" PRId64
", %p, %d, %p, %p, %d\n",
501 bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, is_write
);
503 acb
= qemu_aio_get(&vdi_aio_pool
, bs
, cb
, opaque
);
505 acb
->hd_aiocb
= NULL
;
506 acb
->sector_num
= sector_num
;
508 acb
->is_write
= is_write
;
510 if (qiov
->niov
> 1) {
511 acb
->buf
= qemu_blockalign(bs
, qiov
->size
);
512 acb
->orig_buf
= acb
->buf
;
514 qemu_iovec_to_buffer(qiov
, acb
->buf
);
517 acb
->buf
= (uint8_t *)qiov
->iov
->iov_base
;
519 acb
->nb_sectors
= nb_sectors
;
521 acb
->bmap_first
= VDI_UNALLOCATED
;
522 acb
->bmap_last
= VDI_UNALLOCATED
;
523 acb
->block_buffer
= NULL
;
524 acb
->header_modified
= 0;
529 static int vdi_schedule_bh(QEMUBHFunc
*cb
, VdiAIOCB
*acb
)
537 acb
->bh
= qemu_bh_new(cb
, acb
);
542 qemu_bh_schedule(acb
->bh
);
547 static void vdi_aio_read_cb(void *opaque
, int ret
);
548 static void vdi_aio_write_cb(void *opaque
, int ret
);
550 static void vdi_aio_rw_bh(void *opaque
)
552 VdiAIOCB
*acb
= opaque
;
554 qemu_bh_delete(acb
->bh
);
558 vdi_aio_write_cb(opaque
, 0);
560 vdi_aio_read_cb(opaque
, 0);
564 static void vdi_aio_read_cb(void *opaque
, int ret
)
566 VdiAIOCB
*acb
= opaque
;
567 BlockDriverState
*bs
= acb
->common
.bs
;
568 BDRVVdiState
*s
= bs
->opaque
;
570 uint32_t block_index
;
571 uint32_t sector_in_block
;
574 logout("%u sectors read\n", acb
->n_sectors
);
576 acb
->hd_aiocb
= NULL
;
582 acb
->nb_sectors
-= acb
->n_sectors
;
584 if (acb
->nb_sectors
== 0) {
585 /* request completed */
590 acb
->sector_num
+= acb
->n_sectors
;
591 acb
->buf
+= acb
->n_sectors
* SECTOR_SIZE
;
593 block_index
= acb
->sector_num
/ s
->block_sectors
;
594 sector_in_block
= acb
->sector_num
% s
->block_sectors
;
595 n_sectors
= s
->block_sectors
- sector_in_block
;
596 if (n_sectors
> acb
->nb_sectors
) {
597 n_sectors
= acb
->nb_sectors
;
600 logout("will read %u sectors starting at sector %" PRIu64
"\n",
601 n_sectors
, acb
->sector_num
);
603 /* prepare next AIO request */
604 acb
->n_sectors
= n_sectors
;
605 bmap_entry
= le32_to_cpu(s
->bmap
[block_index
]);
606 if (bmap_entry
== VDI_UNALLOCATED
) {
607 /* Block not allocated, return zeros, no need to wait. */
608 memset(acb
->buf
, 0, n_sectors
* SECTOR_SIZE
);
609 ret
= vdi_schedule_bh(vdi_aio_rw_bh
, acb
);
614 uint64_t offset
= s
->header
.offset_data
/ SECTOR_SIZE
+
615 (uint64_t)bmap_entry
* s
->block_sectors
+
617 acb
->hd_iov
.iov_base
= (void *)acb
->buf
;
618 acb
->hd_iov
.iov_len
= n_sectors
* SECTOR_SIZE
;
619 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
620 acb
->hd_aiocb
= bdrv_aio_readv(bs
->file
, offset
, &acb
->hd_qiov
,
621 n_sectors
, vdi_aio_read_cb
, acb
);
622 if (acb
->hd_aiocb
== NULL
) {
629 if (acb
->qiov
->niov
> 1) {
630 qemu_iovec_from_buffer(acb
->qiov
, acb
->orig_buf
, acb
->qiov
->size
);
631 qemu_vfree(acb
->orig_buf
);
633 acb
->common
.cb(acb
->common
.opaque
, ret
);
634 qemu_aio_release(acb
);
637 static BlockDriverAIOCB
*vdi_aio_readv(BlockDriverState
*bs
,
638 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
639 BlockDriverCompletionFunc
*cb
, void *opaque
)
645 acb
= vdi_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
650 ret
= vdi_schedule_bh(vdi_aio_rw_bh
, acb
);
652 if (acb
->qiov
->niov
> 1) {
653 qemu_vfree(acb
->orig_buf
);
655 qemu_aio_release(acb
);
662 static void vdi_aio_write_cb(void *opaque
, int ret
)
664 VdiAIOCB
*acb
= opaque
;
665 BlockDriverState
*bs
= acb
->common
.bs
;
666 BDRVVdiState
*s
= bs
->opaque
;
668 uint32_t block_index
;
669 uint32_t sector_in_block
;
672 acb
->hd_aiocb
= NULL
;
678 acb
->nb_sectors
-= acb
->n_sectors
;
679 acb
->sector_num
+= acb
->n_sectors
;
680 acb
->buf
+= acb
->n_sectors
* SECTOR_SIZE
;
682 if (acb
->nb_sectors
== 0) {
683 logout("finished data write\n");
685 if (acb
->header_modified
) {
686 VdiHeader
*header
= acb
->block_buffer
;
687 logout("now writing modified header\n");
688 assert(acb
->bmap_first
!= VDI_UNALLOCATED
);
690 vdi_header_to_le(header
);
691 acb
->header_modified
= 0;
692 acb
->hd_iov
.iov_base
= acb
->block_buffer
;
693 acb
->hd_iov
.iov_len
= SECTOR_SIZE
;
694 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
695 acb
->hd_aiocb
= bdrv_aio_writev(bs
->file
, 0, &acb
->hd_qiov
, 1,
696 vdi_aio_write_cb
, acb
);
697 if (acb
->hd_aiocb
== NULL
) {
702 } else if (acb
->bmap_first
!= VDI_UNALLOCATED
) {
703 /* One or more new blocks were allocated. */
707 qemu_free(acb
->block_buffer
);
708 acb
->block_buffer
= NULL
;
709 bmap_first
= acb
->bmap_first
;
710 bmap_last
= acb
->bmap_last
;
711 logout("now writing modified block map entry %u...%u\n",
712 bmap_first
, bmap_last
);
713 /* Write modified sectors from block map. */
714 bmap_first
/= (SECTOR_SIZE
/ sizeof(uint32_t));
715 bmap_last
/= (SECTOR_SIZE
/ sizeof(uint32_t));
716 n_sectors
= bmap_last
- bmap_first
+ 1;
717 offset
= s
->bmap_sector
+ bmap_first
;
718 acb
->bmap_first
= VDI_UNALLOCATED
;
719 acb
->hd_iov
.iov_base
= (void *)((uint8_t *)&s
->bmap
[0] +
720 bmap_first
* SECTOR_SIZE
);
721 acb
->hd_iov
.iov_len
= n_sectors
* SECTOR_SIZE
;
722 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
723 logout("will write %u block map sectors starting from entry %u\n",
724 n_sectors
, bmap_first
);
725 acb
->hd_aiocb
= bdrv_aio_writev(bs
->file
, offset
, &acb
->hd_qiov
,
726 n_sectors
, vdi_aio_write_cb
, acb
);
727 if (acb
->hd_aiocb
== NULL
) {
737 logout("%u sectors written\n", acb
->n_sectors
);
739 block_index
= acb
->sector_num
/ s
->block_sectors
;
740 sector_in_block
= acb
->sector_num
% s
->block_sectors
;
741 n_sectors
= s
->block_sectors
- sector_in_block
;
742 if (n_sectors
> acb
->nb_sectors
) {
743 n_sectors
= acb
->nb_sectors
;
746 logout("will write %u sectors starting at sector %" PRIu64
"\n",
747 n_sectors
, acb
->sector_num
);
749 /* prepare next AIO request */
750 acb
->n_sectors
= n_sectors
;
751 bmap_entry
= le32_to_cpu(s
->bmap
[block_index
]);
752 if (bmap_entry
== VDI_UNALLOCATED
) {
753 /* Allocate new block and write to it. */
756 bmap_entry
= s
->header
.blocks_allocated
;
757 s
->bmap
[block_index
] = cpu_to_le32(bmap_entry
);
758 s
->header
.blocks_allocated
++;
759 offset
= s
->header
.offset_data
/ SECTOR_SIZE
+
760 (uint64_t)bmap_entry
* s
->block_sectors
;
761 block
= acb
->block_buffer
;
763 block
= qemu_mallocz(s
->block_size
);
764 acb
->block_buffer
= block
;
765 acb
->bmap_first
= block_index
;
766 assert(!acb
->header_modified
);
767 acb
->header_modified
= 1;
769 acb
->bmap_last
= block_index
;
770 memcpy(block
+ sector_in_block
* SECTOR_SIZE
,
771 acb
->buf
, n_sectors
* SECTOR_SIZE
);
772 acb
->hd_iov
.iov_base
= (void *)block
;
773 acb
->hd_iov
.iov_len
= s
->block_size
;
774 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
775 acb
->hd_aiocb
= bdrv_aio_writev(bs
->file
, offset
,
776 &acb
->hd_qiov
, s
->block_sectors
,
777 vdi_aio_write_cb
, acb
);
778 if (acb
->hd_aiocb
== NULL
) {
783 uint64_t offset
= s
->header
.offset_data
/ SECTOR_SIZE
+
784 (uint64_t)bmap_entry
* s
->block_sectors
+
786 acb
->hd_iov
.iov_base
= (void *)acb
->buf
;
787 acb
->hd_iov
.iov_len
= n_sectors
* SECTOR_SIZE
;
788 qemu_iovec_init_external(&acb
->hd_qiov
, &acb
->hd_iov
, 1);
789 acb
->hd_aiocb
= bdrv_aio_writev(bs
->file
, offset
, &acb
->hd_qiov
,
790 n_sectors
, vdi_aio_write_cb
, acb
);
791 if (acb
->hd_aiocb
== NULL
) {
800 if (acb
->qiov
->niov
> 1) {
801 qemu_vfree(acb
->orig_buf
);
803 acb
->common
.cb(acb
->common
.opaque
, ret
);
804 qemu_aio_release(acb
);
807 static BlockDriverAIOCB
*vdi_aio_writev(BlockDriverState
*bs
,
808 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
809 BlockDriverCompletionFunc
*cb
, void *opaque
)
815 acb
= vdi_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
820 ret
= vdi_schedule_bh(vdi_aio_rw_bh
, acb
);
822 if (acb
->qiov
->niov
> 1) {
823 qemu_vfree(acb
->orig_buf
);
825 qemu_aio_release(acb
);
832 static int vdi_create(const char *filename
, QEMUOptionParameter
*options
)
838 size_t block_size
= DEFAULT_CLUSTER_SIZE
;
839 uint32_t image_type
= VDI_TYPE_DYNAMIC
;
847 /* Read out options. */
848 while (options
&& options
->name
) {
849 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
850 bytes
= options
->value
.n
;
851 #if defined(CONFIG_VDI_BLOCK_SIZE)
852 } else if (!strcmp(options
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
853 if (options
->value
.n
) {
854 /* TODO: Additional checks (SECTOR_SIZE * 2^n, ...). */
855 block_size
= options
->value
.n
;
858 #if defined(CONFIG_VDI_STATIC_IMAGE)
859 } else if (!strcmp(options
->name
, BLOCK_OPT_STATIC
)) {
860 if (options
->value
.n
) {
861 image_type
= VDI_TYPE_STATIC
;
868 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
| O_LARGEFILE
,
874 /* We need enough blocks to store the given disk size,
875 so always round up. */
876 blocks
= (bytes
+ block_size
- 1) / block_size
;
878 bmap_size
= blocks
* sizeof(uint32_t);
879 bmap_size
= ((bmap_size
+ SECTOR_SIZE
- 1) & ~(SECTOR_SIZE
-1));
881 memset(&header
, 0, sizeof(header
));
882 pstrcpy(header
.text
, sizeof(header
.text
), VDI_TEXT
);
883 header
.signature
= VDI_SIGNATURE
;
884 header
.version
= VDI_VERSION_1_1
;
885 header
.header_size
= 0x180;
886 header
.image_type
= image_type
;
887 header
.offset_bmap
= 0x200;
888 header
.offset_data
= 0x200 + bmap_size
;
889 header
.sector_size
= SECTOR_SIZE
;
890 header
.disk_size
= bytes
;
891 header
.block_size
= block_size
;
892 header
.blocks_in_image
= blocks
;
893 if (image_type
== VDI_TYPE_STATIC
) {
894 header
.blocks_allocated
= blocks
;
896 uuid_generate(header
.uuid_image
);
897 uuid_generate(header
.uuid_last_snap
);
898 /* There is no need to set header.uuid_link or header.uuid_parent here. */
899 #if defined(CONFIG_VDI_DEBUG)
900 vdi_header_print(&header
);
902 vdi_header_to_le(&header
);
903 if (write(fd
, &header
, sizeof(header
)) < 0) {
909 bmap
= (uint32_t *)qemu_mallocz(bmap_size
);
911 for (i
= 0; i
< blocks
; i
++) {
912 if (image_type
== VDI_TYPE_STATIC
) {
915 bmap
[i
] = VDI_UNALLOCATED
;
918 if (write(fd
, bmap
, bmap_size
) < 0) {
922 if (image_type
== VDI_TYPE_STATIC
) {
923 if (ftruncate(fd
, sizeof(header
) + bmap_size
+ blocks
* block_size
)) {
935 static void vdi_close(BlockDriverState
*bs
)
939 static int vdi_flush(BlockDriverState
*bs
)
942 return bdrv_flush(bs
->file
);
946 static QEMUOptionParameter vdi_create_options
[] = {
948 .name
= BLOCK_OPT_SIZE
,
950 .help
= "Virtual disk size"
952 #if defined(CONFIG_VDI_BLOCK_SIZE)
954 .name
= BLOCK_OPT_CLUSTER_SIZE
,
956 .help
= "VDI cluster (block) size",
957 .value
= { .n
= DEFAULT_CLUSTER_SIZE
},
960 #if defined(CONFIG_VDI_STATIC_IMAGE)
962 .name
= BLOCK_OPT_STATIC
,
964 .help
= "VDI static (pre-allocated) image"
967 /* TODO: An additional option to set UUID values might be useful. */
971 static BlockDriver bdrv_vdi
= {
972 .format_name
= "vdi",
973 .instance_size
= sizeof(BDRVVdiState
),
974 .bdrv_probe
= vdi_probe
,
975 .bdrv_open
= vdi_open
,
976 .bdrv_close
= vdi_close
,
977 .bdrv_create
= vdi_create
,
978 .bdrv_flush
= vdi_flush
,
979 .bdrv_is_allocated
= vdi_is_allocated
,
980 .bdrv_make_empty
= vdi_make_empty
,
982 .bdrv_aio_readv
= vdi_aio_readv
,
983 #if defined(CONFIG_VDI_WRITE)
984 .bdrv_aio_writev
= vdi_aio_writev
,
987 .bdrv_get_info
= vdi_get_info
,
989 .create_options
= vdi_create_options
,
990 .bdrv_check
= vdi_check
,
993 static void bdrv_vdi_init(void)
996 bdrv_register(&bdrv_vdi
);
999 block_init(bdrv_vdi_init
);