]>
Commit | Line | Data |
---|---|---|
9aebd98a SW |
1 | /* |
2 | * Block driver for the Virtual Disk Image (VDI) format | |
3 | * | |
4 | * Copyright (c) 2009 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 adjacents 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-common.h" | |
53 | #include "block_int.h" | |
54 | #include "module.h" | |
55 | ||
ee682d27 | 56 | #if defined(CONFIG_UUID) |
9aebd98a SW |
57 | #include <uuid/uuid.h> |
58 | #else | |
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); | |
65 | #endif | |
66 | ||
67 | /* Code configuration options. */ | |
68 | ||
69 | /* Enable debug messages. */ | |
70 | //~ #define CONFIG_VDI_DEBUG | |
71 | ||
72 | /* Support write operations on VDI images. */ | |
73 | #define CONFIG_VDI_WRITE | |
74 | ||
75 | /* Support non-standard block (cluster) size. This is untested. | |
76 | * Maybe it will be needed for very large images. | |
77 | */ | |
78 | //~ #define CONFIG_VDI_BLOCK_SIZE | |
79 | ||
80 | /* Support static (fixed, pre-allocated) images. */ | |
81 | #define CONFIG_VDI_STATIC_IMAGE | |
82 | ||
83 | /* Command line option for static images. */ | |
84 | #define BLOCK_OPT_STATIC "static" | |
85 | ||
86 | #define KiB 1024 | |
87 | #define MiB (KiB * KiB) | |
88 | ||
89 | #define SECTOR_SIZE 512 | |
90 | ||
91 | #if defined(CONFIG_VDI_DEBUG) | |
92 | #define logout(fmt, ...) \ | |
93 | fprintf(stderr, "vdi\t%-24s" fmt, __func__, ##__VA_ARGS__) | |
94 | #else | |
95 | #define logout(fmt, ...) ((void)0) | |
96 | #endif | |
97 | ||
98 | /* Image signature. */ | |
99 | #define VDI_SIGNATURE 0xbeda107f | |
100 | ||
101 | /* Image version. */ | |
102 | #define VDI_VERSION_1_1 0x00010001 | |
103 | ||
104 | /* Image type. */ | |
105 | #define VDI_TYPE_DYNAMIC 1 | |
106 | #define VDI_TYPE_STATIC 2 | |
107 | ||
108 | /* Innotek / SUN images use these strings in header.text: | |
109 | * "<<< innotek VirtualBox Disk Image >>>\n" | |
110 | * "<<< Sun xVM VirtualBox Disk Image >>>\n" | |
111 | * "<<< Sun VirtualBox Disk Image >>>\n" | |
112 | * The value does not matter, so QEMU created images use a different text. | |
113 | */ | |
114 | #define VDI_TEXT "<<< QEMU VM Virtual Disk Image >>>\n" | |
115 | ||
4ff9786c | 116 | /* Unallocated blocks use this index (no need to convert endianness). */ |
9aebd98a SW |
117 | #define VDI_UNALLOCATED UINT32_MAX |
118 | ||
ee682d27 | 119 | #if !defined(CONFIG_UUID) |
9aebd98a SW |
120 | void uuid_generate(uuid_t out) |
121 | { | |
4f3669ea | 122 | memset(out, 0, sizeof(uuid_t)); |
9aebd98a SW |
123 | } |
124 | ||
125 | int uuid_is_null(const uuid_t uu) | |
126 | { | |
127 | uuid_t null_uuid = { 0 }; | |
4f3669ea | 128 | return memcmp(uu, null_uuid, sizeof(uuid_t)) == 0; |
9aebd98a SW |
129 | } |
130 | ||
131 | void uuid_unparse(const uuid_t uu, char *out) | |
132 | { | |
133 | snprintf(out, 37, UUID_FMT, | |
134 | uu[0], uu[1], uu[2], uu[3], uu[4], uu[5], uu[6], uu[7], | |
135 | uu[8], uu[9], uu[10], uu[11], uu[12], uu[13], uu[14], uu[15]); | |
136 | } | |
137 | #endif | |
138 | ||
139 | typedef struct { | |
140 | BlockDriverAIOCB common; | |
141 | int64_t sector_num; | |
142 | QEMUIOVector *qiov; | |
143 | uint8_t *buf; | |
144 | /* Total number of sectors. */ | |
145 | int nb_sectors; | |
146 | /* Number of sectors for current AIO. */ | |
147 | int n_sectors; | |
148 | /* New allocated block map entry. */ | |
149 | uint32_t bmap_first; | |
150 | uint32_t bmap_last; | |
151 | /* Buffer for new allocated block. */ | |
152 | void *block_buffer; | |
153 | void *orig_buf; | |
154 | int header_modified; | |
155 | BlockDriverAIOCB *hd_aiocb; | |
156 | struct iovec hd_iov; | |
157 | QEMUIOVector hd_qiov; | |
158 | QEMUBH *bh; | |
159 | } VdiAIOCB; | |
160 | ||
161 | typedef struct { | |
162 | char text[0x40]; | |
163 | uint32_t signature; | |
164 | uint32_t version; | |
165 | uint32_t header_size; | |
166 | uint32_t image_type; | |
167 | uint32_t image_flags; | |
168 | char description[256]; | |
169 | uint32_t offset_bmap; | |
170 | uint32_t offset_data; | |
171 | uint32_t cylinders; /* disk geometry, unused here */ | |
172 | uint32_t heads; /* disk geometry, unused here */ | |
173 | uint32_t sectors; /* disk geometry, unused here */ | |
174 | uint32_t sector_size; | |
175 | uint32_t unused1; | |
176 | uint64_t disk_size; | |
177 | uint32_t block_size; | |
178 | uint32_t block_extra; /* unused here */ | |
179 | uint32_t blocks_in_image; | |
180 | uint32_t blocks_allocated; | |
181 | uuid_t uuid_image; | |
182 | uuid_t uuid_last_snap; | |
183 | uuid_t uuid_link; | |
184 | uuid_t uuid_parent; | |
185 | uint64_t unused2[7]; | |
186 | } VdiHeader; | |
187 | ||
188 | typedef struct { | |
9aebd98a SW |
189 | /* The block map entries are little endian (even in memory). */ |
190 | uint32_t *bmap; | |
191 | /* Size of block (bytes). */ | |
192 | uint32_t block_size; | |
193 | /* Size of block (sectors). */ | |
194 | uint32_t block_sectors; | |
195 | /* First sector of block map. */ | |
196 | uint32_t bmap_sector; | |
4ff9786c | 197 | /* VDI header (converted to host endianness). */ |
9aebd98a SW |
198 | VdiHeader header; |
199 | } BDRVVdiState; | |
200 | ||
201 | /* Change UUID from little endian (IPRT = VirtualBox format) to big endian | |
202 | * format (network byte order, standard, see RFC 4122) and vice versa. | |
203 | */ | |
204 | static void uuid_convert(uuid_t uuid) | |
205 | { | |
206 | bswap32s((uint32_t *)&uuid[0]); | |
207 | bswap16s((uint16_t *)&uuid[4]); | |
208 | bswap16s((uint16_t *)&uuid[6]); | |
209 | } | |
210 | ||
211 | static void vdi_header_to_cpu(VdiHeader *header) | |
212 | { | |
213 | le32_to_cpus(&header->signature); | |
214 | le32_to_cpus(&header->version); | |
215 | le32_to_cpus(&header->header_size); | |
216 | le32_to_cpus(&header->image_type); | |
217 | le32_to_cpus(&header->image_flags); | |
218 | le32_to_cpus(&header->offset_bmap); | |
219 | le32_to_cpus(&header->offset_data); | |
220 | le32_to_cpus(&header->cylinders); | |
221 | le32_to_cpus(&header->heads); | |
222 | le32_to_cpus(&header->sectors); | |
223 | le32_to_cpus(&header->sector_size); | |
224 | le64_to_cpus(&header->disk_size); | |
225 | le32_to_cpus(&header->block_size); | |
226 | le32_to_cpus(&header->block_extra); | |
227 | le32_to_cpus(&header->blocks_in_image); | |
228 | le32_to_cpus(&header->blocks_allocated); | |
229 | uuid_convert(header->uuid_image); | |
230 | uuid_convert(header->uuid_last_snap); | |
231 | uuid_convert(header->uuid_link); | |
232 | uuid_convert(header->uuid_parent); | |
233 | } | |
234 | ||
235 | static void vdi_header_to_le(VdiHeader *header) | |
236 | { | |
237 | cpu_to_le32s(&header->signature); | |
238 | cpu_to_le32s(&header->version); | |
239 | cpu_to_le32s(&header->header_size); | |
240 | cpu_to_le32s(&header->image_type); | |
241 | cpu_to_le32s(&header->image_flags); | |
242 | cpu_to_le32s(&header->offset_bmap); | |
243 | cpu_to_le32s(&header->offset_data); | |
244 | cpu_to_le32s(&header->cylinders); | |
245 | cpu_to_le32s(&header->heads); | |
246 | cpu_to_le32s(&header->sectors); | |
247 | cpu_to_le32s(&header->sector_size); | |
248 | cpu_to_le64s(&header->disk_size); | |
249 | cpu_to_le32s(&header->block_size); | |
250 | cpu_to_le32s(&header->block_extra); | |
251 | cpu_to_le32s(&header->blocks_in_image); | |
252 | cpu_to_le32s(&header->blocks_allocated); | |
253 | cpu_to_le32s(&header->blocks_allocated); | |
254 | uuid_convert(header->uuid_image); | |
255 | uuid_convert(header->uuid_last_snap); | |
256 | uuid_convert(header->uuid_link); | |
257 | uuid_convert(header->uuid_parent); | |
258 | } | |
259 | ||
260 | #if defined(CONFIG_VDI_DEBUG) | |
261 | static void vdi_header_print(VdiHeader *header) | |
262 | { | |
263 | char uuid[37]; | |
264 | logout("text %s", header->text); | |
265 | logout("signature 0x%04x\n", header->signature); | |
266 | logout("header size 0x%04x\n", header->header_size); | |
267 | logout("image type 0x%04x\n", header->image_type); | |
268 | logout("image flags 0x%04x\n", header->image_flags); | |
269 | logout("description %s\n", header->description); | |
270 | logout("offset bmap 0x%04x\n", header->offset_bmap); | |
271 | logout("offset data 0x%04x\n", header->offset_data); | |
272 | logout("cylinders 0x%04x\n", header->cylinders); | |
273 | logout("heads 0x%04x\n", header->heads); | |
274 | logout("sectors 0x%04x\n", header->sectors); | |
275 | logout("sector size 0x%04x\n", header->sector_size); | |
276 | logout("image size 0x%" PRIx64 " B (%" PRIu64 " MiB)\n", | |
277 | header->disk_size, header->disk_size / MiB); | |
278 | logout("block size 0x%04x\n", header->block_size); | |
279 | logout("block extra 0x%04x\n", header->block_extra); | |
280 | logout("blocks tot. 0x%04x\n", header->blocks_in_image); | |
281 | logout("blocks all. 0x%04x\n", header->blocks_allocated); | |
282 | uuid_unparse(header->uuid_image, uuid); | |
283 | logout("uuid image %s\n", uuid); | |
284 | uuid_unparse(header->uuid_last_snap, uuid); | |
285 | logout("uuid snap %s\n", uuid); | |
286 | uuid_unparse(header->uuid_link, uuid); | |
287 | logout("uuid link %s\n", uuid); | |
288 | uuid_unparse(header->uuid_parent, uuid); | |
289 | logout("uuid parent %s\n", uuid); | |
290 | } | |
291 | #endif | |
292 | ||
9ac228e0 | 293 | static int vdi_check(BlockDriverState *bs, BdrvCheckResult *res) |
9aebd98a SW |
294 | { |
295 | /* TODO: additional checks possible. */ | |
296 | BDRVVdiState *s = (BDRVVdiState *)bs->opaque; | |
9aebd98a SW |
297 | uint32_t blocks_allocated = 0; |
298 | uint32_t block; | |
299 | uint32_t *bmap; | |
300 | logout("\n"); | |
301 | ||
302 | bmap = qemu_malloc(s->header.blocks_in_image * sizeof(uint32_t)); | |
303 | memset(bmap, 0xff, s->header.blocks_in_image * sizeof(uint32_t)); | |
304 | ||
305 | /* Check block map and value of blocks_allocated. */ | |
306 | for (block = 0; block < s->header.blocks_in_image; block++) { | |
307 | uint32_t bmap_entry = le32_to_cpu(s->bmap[block]); | |
308 | if (bmap_entry != VDI_UNALLOCATED) { | |
309 | if (bmap_entry < s->header.blocks_in_image) { | |
310 | blocks_allocated++; | |
311 | if (bmap[bmap_entry] == VDI_UNALLOCATED) { | |
312 | bmap[bmap_entry] = bmap_entry; | |
313 | } else { | |
314 | fprintf(stderr, "ERROR: block index %" PRIu32 | |
315 | " also used by %" PRIu32 "\n", bmap[bmap_entry], bmap_entry); | |
9ac228e0 | 316 | res->corruptions++; |
9aebd98a SW |
317 | } |
318 | } else { | |
319 | fprintf(stderr, "ERROR: block index %" PRIu32 | |
320 | " too large, is %" PRIu32 "\n", block, bmap_entry); | |
9ac228e0 | 321 | res->corruptions++; |
9aebd98a SW |
322 | } |
323 | } | |
324 | } | |
325 | if (blocks_allocated != s->header.blocks_allocated) { | |
326 | fprintf(stderr, "ERROR: allocated blocks mismatch, is %" PRIu32 | |
327 | ", should be %" PRIu32 "\n", | |
328 | blocks_allocated, s->header.blocks_allocated); | |
9ac228e0 | 329 | res->corruptions++; |
9aebd98a SW |
330 | } |
331 | ||
332 | qemu_free(bmap); | |
333 | ||
9ac228e0 | 334 | return 0; |
9aebd98a SW |
335 | } |
336 | ||
337 | static int vdi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) | |
338 | { | |
339 | /* TODO: vdi_get_info would be needed for machine snapshots. | |
340 | vm_state_offset is still missing. */ | |
341 | BDRVVdiState *s = (BDRVVdiState *)bs->opaque; | |
342 | logout("\n"); | |
343 | bdi->cluster_size = s->block_size; | |
344 | bdi->vm_state_offset = 0; | |
345 | return 0; | |
346 | } | |
347 | ||
348 | static int vdi_make_empty(BlockDriverState *bs) | |
349 | { | |
350 | /* TODO: missing code. */ | |
351 | logout("\n"); | |
352 | /* The return value for missing code must be 0, see block.c. */ | |
353 | return 0; | |
354 | } | |
355 | ||
356 | static int vdi_probe(const uint8_t *buf, int buf_size, const char *filename) | |
357 | { | |
358 | const VdiHeader *header = (const VdiHeader *)buf; | |
359 | int result = 0; | |
360 | ||
361 | logout("\n"); | |
362 | ||
363 | if (buf_size < sizeof(*header)) { | |
364 | /* Header too small, no VDI. */ | |
365 | } else if (le32_to_cpu(header->signature) == VDI_SIGNATURE) { | |
366 | result = 100; | |
367 | } | |
368 | ||
369 | if (result == 0) { | |
370 | logout("no vdi image\n"); | |
371 | } else { | |
372 | logout("%s", header->text); | |
373 | } | |
374 | ||
375 | return result; | |
376 | } | |
377 | ||
66f82cee | 378 | static int vdi_open(BlockDriverState *bs, int flags) |
9aebd98a SW |
379 | { |
380 | BDRVVdiState *s = bs->opaque; | |
381 | VdiHeader header; | |
382 | size_t bmap_size; | |
9aebd98a SW |
383 | |
384 | logout("\n"); | |
385 | ||
66f82cee | 386 | if (bdrv_read(bs->file, 0, (uint8_t *)&header, 1) < 0) { |
9aebd98a SW |
387 | goto fail; |
388 | } | |
389 | ||
390 | vdi_header_to_cpu(&header); | |
391 | #if defined(CONFIG_VDI_DEBUG) | |
392 | vdi_header_print(&header); | |
393 | #endif | |
394 | ||
f21dc3a4 SW |
395 | if (header.disk_size % SECTOR_SIZE != 0) { |
396 | /* 'VBoxManage convertfromraw' can create images with odd disk sizes. | |
397 | We accept them but round the disk size to the next multiple of | |
398 | SECTOR_SIZE. */ | |
399 | logout("odd disk size %" PRIu64 " B, round up\n", header.disk_size); | |
400 | header.disk_size += SECTOR_SIZE - 1; | |
401 | header.disk_size &= ~(SECTOR_SIZE - 1); | |
402 | } | |
403 | ||
9aebd98a SW |
404 | if (header.version != VDI_VERSION_1_1) { |
405 | logout("unsupported version %u.%u\n", | |
406 | header.version >> 16, header.version & 0xffff); | |
407 | goto fail; | |
408 | } else if (header.offset_bmap % SECTOR_SIZE != 0) { | |
409 | /* We only support block maps which start on a sector boundary. */ | |
410 | logout("unsupported block map offset 0x%x B\n", header.offset_bmap); | |
411 | goto fail; | |
412 | } else if (header.offset_data % SECTOR_SIZE != 0) { | |
413 | /* We only support data blocks which start on a sector boundary. */ | |
414 | logout("unsupported data offset 0x%x B\n", header.offset_data); | |
415 | goto fail; | |
416 | } else if (header.sector_size != SECTOR_SIZE) { | |
417 | logout("unsupported sector size %u B\n", header.sector_size); | |
418 | goto fail; | |
419 | } else if (header.block_size != 1 * MiB) { | |
420 | logout("unsupported block size %u B\n", header.block_size); | |
421 | goto fail; | |
f21dc3a4 SW |
422 | } else if (header.disk_size > |
423 | (uint64_t)header.blocks_in_image * header.block_size) { | |
424 | logout("unsupported disk size %" PRIu64 " B\n", header.disk_size); | |
9aebd98a SW |
425 | goto fail; |
426 | } else if (!uuid_is_null(header.uuid_link)) { | |
427 | logout("link uuid != 0, unsupported\n"); | |
428 | goto fail; | |
429 | } else if (!uuid_is_null(header.uuid_parent)) { | |
430 | logout("parent uuid != 0, unsupported\n"); | |
431 | goto fail; | |
432 | } | |
433 | ||
434 | bs->total_sectors = header.disk_size / SECTOR_SIZE; | |
435 | ||
436 | s->block_size = header.block_size; | |
437 | s->block_sectors = header.block_size / SECTOR_SIZE; | |
438 | s->bmap_sector = header.offset_bmap / SECTOR_SIZE; | |
439 | s->header = header; | |
440 | ||
441 | bmap_size = header.blocks_in_image * sizeof(uint32_t); | |
6eea90eb | 442 | bmap_size = (bmap_size + SECTOR_SIZE - 1) / SECTOR_SIZE; |
b76b6e95 SW |
443 | if (bmap_size > 0) { |
444 | s->bmap = qemu_malloc(bmap_size * SECTOR_SIZE); | |
445 | } | |
66f82cee | 446 | if (bdrv_read(bs->file, s->bmap_sector, (uint8_t *)s->bmap, bmap_size) < 0) { |
9aebd98a SW |
447 | goto fail_free_bmap; |
448 | } | |
449 | ||
450 | return 0; | |
451 | ||
452 | fail_free_bmap: | |
453 | qemu_free(s->bmap); | |
454 | ||
455 | fail: | |
9aebd98a SW |
456 | return -1; |
457 | } | |
458 | ||
459 | static int vdi_is_allocated(BlockDriverState *bs, int64_t sector_num, | |
460 | int nb_sectors, int *pnum) | |
461 | { | |
462 | /* TODO: Check for too large sector_num (in bdrv_is_allocated or here). */ | |
463 | BDRVVdiState *s = (BDRVVdiState *)bs->opaque; | |
464 | size_t bmap_index = sector_num / s->block_sectors; | |
465 | size_t sector_in_block = sector_num % s->block_sectors; | |
466 | int n_sectors = s->block_sectors - sector_in_block; | |
467 | uint32_t bmap_entry = le32_to_cpu(s->bmap[bmap_index]); | |
468 | logout("%p, %" PRId64 ", %d, %p\n", bs, sector_num, nb_sectors, pnum); | |
469 | if (n_sectors > nb_sectors) { | |
470 | n_sectors = nb_sectors; | |
471 | } | |
472 | *pnum = n_sectors; | |
473 | return bmap_entry != VDI_UNALLOCATED; | |
474 | } | |
475 | ||
476 | static void vdi_aio_cancel(BlockDriverAIOCB *blockacb) | |
477 | { | |
478 | /* TODO: This code is untested. How can I get it executed? */ | |
b666d239 | 479 | VdiAIOCB *acb = container_of(blockacb, VdiAIOCB, common); |
9aebd98a SW |
480 | logout("\n"); |
481 | if (acb->hd_aiocb) { | |
482 | bdrv_aio_cancel(acb->hd_aiocb); | |
483 | } | |
484 | qemu_aio_release(acb); | |
485 | } | |
486 | ||
487 | static AIOPool vdi_aio_pool = { | |
488 | .aiocb_size = sizeof(VdiAIOCB), | |
489 | .cancel = vdi_aio_cancel, | |
490 | }; | |
491 | ||
492 | static VdiAIOCB *vdi_aio_setup(BlockDriverState *bs, int64_t sector_num, | |
493 | QEMUIOVector *qiov, int nb_sectors, | |
494 | BlockDriverCompletionFunc *cb, void *opaque, int is_write) | |
495 | { | |
496 | VdiAIOCB *acb; | |
497 | ||
498 | logout("%p, %" PRId64 ", %p, %d, %p, %p, %d\n", | |
499 | bs, sector_num, qiov, nb_sectors, cb, opaque, is_write); | |
500 | ||
501 | acb = qemu_aio_get(&vdi_aio_pool, bs, cb, opaque); | |
502 | if (acb) { | |
503 | acb->hd_aiocb = NULL; | |
504 | acb->sector_num = sector_num; | |
505 | acb->qiov = qiov; | |
506 | if (qiov->niov > 1) { | |
507 | acb->buf = qemu_blockalign(bs, qiov->size); | |
508 | acb->orig_buf = acb->buf; | |
509 | if (is_write) { | |
510 | qemu_iovec_to_buffer(qiov, acb->buf); | |
511 | } | |
512 | } else { | |
513 | acb->buf = (uint8_t *)qiov->iov->iov_base; | |
514 | } | |
515 | acb->nb_sectors = nb_sectors; | |
516 | acb->n_sectors = 0; | |
517 | acb->bmap_first = VDI_UNALLOCATED; | |
518 | acb->bmap_last = VDI_UNALLOCATED; | |
519 | acb->block_buffer = NULL; | |
520 | acb->header_modified = 0; | |
521 | } | |
522 | return acb; | |
523 | } | |
524 | ||
525 | static int vdi_schedule_bh(QEMUBHFunc *cb, VdiAIOCB *acb) | |
526 | { | |
527 | logout("\n"); | |
528 | ||
529 | if (acb->bh) { | |
530 | return -EIO; | |
531 | } | |
532 | ||
533 | acb->bh = qemu_bh_new(cb, acb); | |
534 | if (!acb->bh) { | |
535 | return -EIO; | |
536 | } | |
537 | ||
538 | qemu_bh_schedule(acb->bh); | |
539 | ||
540 | return 0; | |
541 | } | |
542 | ||
543 | static void vdi_aio_read_cb(void *opaque, int ret); | |
544 | ||
545 | static void vdi_aio_read_bh(void *opaque) | |
546 | { | |
547 | VdiAIOCB *acb = opaque; | |
548 | logout("\n"); | |
549 | qemu_bh_delete(acb->bh); | |
550 | acb->bh = NULL; | |
551 | vdi_aio_read_cb(opaque, 0); | |
552 | } | |
553 | ||
554 | static void vdi_aio_read_cb(void *opaque, int ret) | |
555 | { | |
556 | VdiAIOCB *acb = opaque; | |
557 | BlockDriverState *bs = acb->common.bs; | |
558 | BDRVVdiState *s = bs->opaque; | |
559 | uint32_t bmap_entry; | |
560 | uint32_t block_index; | |
561 | uint32_t sector_in_block; | |
562 | uint32_t n_sectors; | |
563 | ||
564 | logout("%u sectors read\n", acb->n_sectors); | |
565 | ||
566 | acb->hd_aiocb = NULL; | |
567 | ||
568 | if (ret < 0) { | |
569 | goto done; | |
570 | } | |
571 | ||
572 | acb->nb_sectors -= acb->n_sectors; | |
573 | ||
574 | if (acb->nb_sectors == 0) { | |
575 | /* request completed */ | |
576 | ret = 0; | |
577 | goto done; | |
578 | } | |
579 | ||
580 | acb->sector_num += acb->n_sectors; | |
581 | acb->buf += acb->n_sectors * SECTOR_SIZE; | |
582 | ||
583 | block_index = acb->sector_num / s->block_sectors; | |
584 | sector_in_block = acb->sector_num % s->block_sectors; | |
585 | n_sectors = s->block_sectors - sector_in_block; | |
586 | if (n_sectors > acb->nb_sectors) { | |
587 | n_sectors = acb->nb_sectors; | |
588 | } | |
589 | ||
590 | logout("will read %u sectors starting at sector %" PRIu64 "\n", | |
591 | n_sectors, acb->sector_num); | |
592 | ||
593 | /* prepare next AIO request */ | |
594 | acb->n_sectors = n_sectors; | |
595 | bmap_entry = le32_to_cpu(s->bmap[block_index]); | |
596 | if (bmap_entry == VDI_UNALLOCATED) { | |
597 | /* Block not allocated, return zeros, no need to wait. */ | |
598 | memset(acb->buf, 0, n_sectors * SECTOR_SIZE); | |
599 | ret = vdi_schedule_bh(vdi_aio_read_bh, acb); | |
600 | if (ret < 0) { | |
601 | goto done; | |
602 | } | |
603 | } else { | |
604 | uint64_t offset = s->header.offset_data / SECTOR_SIZE + | |
605 | (uint64_t)bmap_entry * s->block_sectors + | |
606 | sector_in_block; | |
607 | acb->hd_iov.iov_base = (void *)acb->buf; | |
608 | acb->hd_iov.iov_len = n_sectors * SECTOR_SIZE; | |
609 | qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); | |
66f82cee | 610 | acb->hd_aiocb = bdrv_aio_readv(bs->file, offset, &acb->hd_qiov, |
9aebd98a SW |
611 | n_sectors, vdi_aio_read_cb, acb); |
612 | if (acb->hd_aiocb == NULL) { | |
40a892b7 | 613 | ret = -EIO; |
9aebd98a SW |
614 | goto done; |
615 | } | |
616 | } | |
617 | return; | |
618 | done: | |
619 | if (acb->qiov->niov > 1) { | |
620 | qemu_iovec_from_buffer(acb->qiov, acb->orig_buf, acb->qiov->size); | |
621 | qemu_vfree(acb->orig_buf); | |
622 | } | |
623 | acb->common.cb(acb->common.opaque, ret); | |
624 | qemu_aio_release(acb); | |
625 | } | |
626 | ||
627 | static BlockDriverAIOCB *vdi_aio_readv(BlockDriverState *bs, | |
628 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
629 | BlockDriverCompletionFunc *cb, void *opaque) | |
630 | { | |
631 | VdiAIOCB *acb; | |
632 | logout("\n"); | |
633 | acb = vdi_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); | |
634 | if (!acb) { | |
635 | return NULL; | |
636 | } | |
637 | vdi_aio_read_cb(acb, 0); | |
638 | return &acb->common; | |
639 | } | |
640 | ||
641 | static void vdi_aio_write_cb(void *opaque, int ret) | |
642 | { | |
643 | VdiAIOCB *acb = opaque; | |
644 | BlockDriverState *bs = acb->common.bs; | |
645 | BDRVVdiState *s = bs->opaque; | |
646 | uint32_t bmap_entry; | |
647 | uint32_t block_index; | |
648 | uint32_t sector_in_block; | |
649 | uint32_t n_sectors; | |
650 | ||
651 | acb->hd_aiocb = NULL; | |
652 | ||
653 | if (ret < 0) { | |
654 | goto done; | |
655 | } | |
656 | ||
657 | acb->nb_sectors -= acb->n_sectors; | |
658 | acb->sector_num += acb->n_sectors; | |
659 | acb->buf += acb->n_sectors * SECTOR_SIZE; | |
660 | ||
661 | if (acb->nb_sectors == 0) { | |
662 | logout("finished data write\n"); | |
663 | acb->n_sectors = 0; | |
664 | if (acb->header_modified) { | |
665 | VdiHeader *header = acb->block_buffer; | |
666 | logout("now writing modified header\n"); | |
667 | assert(acb->bmap_first != VDI_UNALLOCATED); | |
668 | *header = s->header; | |
669 | vdi_header_to_le(header); | |
670 | acb->header_modified = 0; | |
671 | acb->hd_iov.iov_base = acb->block_buffer; | |
672 | acb->hd_iov.iov_len = SECTOR_SIZE; | |
673 | qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); | |
66f82cee | 674 | acb->hd_aiocb = bdrv_aio_writev(bs->file, 0, &acb->hd_qiov, 1, |
9aebd98a SW |
675 | vdi_aio_write_cb, acb); |
676 | if (acb->hd_aiocb == NULL) { | |
40a892b7 | 677 | ret = -EIO; |
9aebd98a SW |
678 | goto done; |
679 | } | |
680 | return; | |
681 | } else if (acb->bmap_first != VDI_UNALLOCATED) { | |
682 | /* One or more new blocks were allocated. */ | |
683 | uint64_t offset; | |
684 | uint32_t bmap_first; | |
685 | uint32_t bmap_last; | |
686 | qemu_free(acb->block_buffer); | |
687 | acb->block_buffer = NULL; | |
688 | bmap_first = acb->bmap_first; | |
689 | bmap_last = acb->bmap_last; | |
690 | logout("now writing modified block map entry %u...%u\n", | |
691 | bmap_first, bmap_last); | |
692 | /* Write modified sectors from block map. */ | |
693 | bmap_first /= (SECTOR_SIZE / sizeof(uint32_t)); | |
694 | bmap_last /= (SECTOR_SIZE / sizeof(uint32_t)); | |
695 | n_sectors = bmap_last - bmap_first + 1; | |
696 | offset = s->bmap_sector + bmap_first; | |
697 | acb->bmap_first = VDI_UNALLOCATED; | |
a2a45a26 BS |
698 | acb->hd_iov.iov_base = (void *)((uint8_t *)&s->bmap[0] + |
699 | bmap_first * SECTOR_SIZE); | |
9aebd98a SW |
700 | acb->hd_iov.iov_len = n_sectors * SECTOR_SIZE; |
701 | qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); | |
702 | logout("will write %u block map sectors starting from entry %u\n", | |
703 | n_sectors, bmap_first); | |
66f82cee | 704 | acb->hd_aiocb = bdrv_aio_writev(bs->file, offset, &acb->hd_qiov, |
9aebd98a SW |
705 | n_sectors, vdi_aio_write_cb, acb); |
706 | if (acb->hd_aiocb == NULL) { | |
40a892b7 | 707 | ret = -EIO; |
9aebd98a SW |
708 | goto done; |
709 | } | |
710 | return; | |
711 | } | |
712 | ret = 0; | |
713 | goto done; | |
714 | } | |
715 | ||
716 | logout("%u sectors written\n", acb->n_sectors); | |
717 | ||
718 | block_index = acb->sector_num / s->block_sectors; | |
719 | sector_in_block = acb->sector_num % s->block_sectors; | |
720 | n_sectors = s->block_sectors - sector_in_block; | |
721 | if (n_sectors > acb->nb_sectors) { | |
722 | n_sectors = acb->nb_sectors; | |
723 | } | |
724 | ||
725 | logout("will write %u sectors starting at sector %" PRIu64 "\n", | |
726 | n_sectors, acb->sector_num); | |
727 | ||
728 | /* prepare next AIO request */ | |
729 | acb->n_sectors = n_sectors; | |
730 | bmap_entry = le32_to_cpu(s->bmap[block_index]); | |
731 | if (bmap_entry == VDI_UNALLOCATED) { | |
732 | /* Allocate new block and write to it. */ | |
733 | uint64_t offset; | |
734 | uint8_t *block; | |
735 | bmap_entry = s->header.blocks_allocated; | |
736 | s->bmap[block_index] = cpu_to_le32(bmap_entry); | |
737 | s->header.blocks_allocated++; | |
738 | offset = s->header.offset_data / SECTOR_SIZE + | |
739 | (uint64_t)bmap_entry * s->block_sectors; | |
740 | block = acb->block_buffer; | |
741 | if (block == NULL) { | |
742 | block = qemu_mallocz(s->block_size); | |
743 | acb->block_buffer = block; | |
744 | acb->bmap_first = block_index; | |
745 | assert(!acb->header_modified); | |
746 | acb->header_modified = 1; | |
747 | } | |
748 | acb->bmap_last = block_index; | |
749 | memcpy(block + sector_in_block * SECTOR_SIZE, | |
750 | acb->buf, n_sectors * SECTOR_SIZE); | |
a2a45a26 | 751 | acb->hd_iov.iov_base = (void *)block; |
9aebd98a SW |
752 | acb->hd_iov.iov_len = s->block_size; |
753 | qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); | |
66f82cee | 754 | acb->hd_aiocb = bdrv_aio_writev(bs->file, offset, |
9aebd98a SW |
755 | &acb->hd_qiov, s->block_sectors, |
756 | vdi_aio_write_cb, acb); | |
757 | if (acb->hd_aiocb == NULL) { | |
40a892b7 | 758 | ret = -EIO; |
9aebd98a SW |
759 | goto done; |
760 | } | |
761 | } else { | |
762 | uint64_t offset = s->header.offset_data / SECTOR_SIZE + | |
763 | (uint64_t)bmap_entry * s->block_sectors + | |
764 | sector_in_block; | |
a2a45a26 | 765 | acb->hd_iov.iov_base = (void *)acb->buf; |
9aebd98a SW |
766 | acb->hd_iov.iov_len = n_sectors * SECTOR_SIZE; |
767 | qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1); | |
66f82cee | 768 | acb->hd_aiocb = bdrv_aio_writev(bs->file, offset, &acb->hd_qiov, |
9aebd98a SW |
769 | n_sectors, vdi_aio_write_cb, acb); |
770 | if (acb->hd_aiocb == NULL) { | |
40a892b7 | 771 | ret = -EIO; |
9aebd98a SW |
772 | goto done; |
773 | } | |
774 | } | |
775 | ||
776 | return; | |
777 | ||
778 | done: | |
779 | if (acb->qiov->niov > 1) { | |
780 | qemu_vfree(acb->orig_buf); | |
781 | } | |
782 | acb->common.cb(acb->common.opaque, ret); | |
783 | qemu_aio_release(acb); | |
784 | } | |
785 | ||
786 | static BlockDriverAIOCB *vdi_aio_writev(BlockDriverState *bs, | |
787 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
788 | BlockDriverCompletionFunc *cb, void *opaque) | |
789 | { | |
790 | VdiAIOCB *acb; | |
791 | logout("\n"); | |
792 | acb = vdi_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); | |
793 | if (!acb) { | |
794 | return NULL; | |
795 | } | |
796 | vdi_aio_write_cb(acb, 0); | |
797 | return &acb->common; | |
798 | } | |
799 | ||
800 | static int vdi_create(const char *filename, QEMUOptionParameter *options) | |
801 | { | |
802 | int fd; | |
803 | int result = 0; | |
804 | uint64_t bytes = 0; | |
805 | uint32_t blocks; | |
806 | size_t block_size = 1 * MiB; | |
807 | uint32_t image_type = VDI_TYPE_DYNAMIC; | |
808 | VdiHeader header; | |
809 | size_t i; | |
810 | size_t bmap_size; | |
811 | uint32_t *bmap; | |
812 | ||
813 | logout("\n"); | |
814 | ||
815 | /* Read out options. */ | |
816 | while (options && options->name) { | |
817 | if (!strcmp(options->name, BLOCK_OPT_SIZE)) { | |
818 | bytes = options->value.n; | |
819 | #if defined(CONFIG_VDI_BLOCK_SIZE) | |
820 | } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { | |
821 | if (options->value.n) { | |
822 | /* TODO: Additional checks (SECTOR_SIZE * 2^n, ...). */ | |
823 | block_size = options->value.n; | |
824 | } | |
825 | #endif | |
826 | #if defined(CONFIG_VDI_STATIC_IMAGE) | |
827 | } else if (!strcmp(options->name, BLOCK_OPT_STATIC)) { | |
6eea90eb SW |
828 | if (options->value.n) { |
829 | image_type = VDI_TYPE_STATIC; | |
830 | } | |
9aebd98a SW |
831 | #endif |
832 | } | |
833 | options++; | |
834 | } | |
835 | ||
836 | fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE, | |
837 | 0644); | |
838 | if (fd < 0) { | |
839 | return -errno; | |
840 | } | |
841 | ||
f21dc3a4 SW |
842 | /* We need enough blocks to store the given disk size, |
843 | so always round up. */ | |
844 | blocks = (bytes + block_size - 1) / block_size; | |
845 | ||
9aebd98a SW |
846 | bmap_size = blocks * sizeof(uint32_t); |
847 | bmap_size = ((bmap_size + SECTOR_SIZE - 1) & ~(SECTOR_SIZE -1)); | |
848 | ||
849 | memset(&header, 0, sizeof(header)); | |
1786dc15 | 850 | pstrcpy(header.text, sizeof(header.text), VDI_TEXT); |
9aebd98a SW |
851 | header.signature = VDI_SIGNATURE; |
852 | header.version = VDI_VERSION_1_1; | |
853 | header.header_size = 0x180; | |
854 | header.image_type = image_type; | |
855 | header.offset_bmap = 0x200; | |
856 | header.offset_data = 0x200 + bmap_size; | |
857 | header.sector_size = SECTOR_SIZE; | |
858 | header.disk_size = bytes; | |
859 | header.block_size = block_size; | |
860 | header.blocks_in_image = blocks; | |
6eea90eb SW |
861 | if (image_type == VDI_TYPE_STATIC) { |
862 | header.blocks_allocated = blocks; | |
863 | } | |
9aebd98a SW |
864 | uuid_generate(header.uuid_image); |
865 | uuid_generate(header.uuid_last_snap); | |
866 | /* There is no need to set header.uuid_link or header.uuid_parent here. */ | |
867 | #if defined(CONFIG_VDI_DEBUG) | |
868 | vdi_header_print(&header); | |
869 | #endif | |
870 | vdi_header_to_le(&header); | |
871 | if (write(fd, &header, sizeof(header)) < 0) { | |
872 | result = -errno; | |
873 | } | |
874 | ||
b76b6e95 SW |
875 | bmap = NULL; |
876 | if (bmap_size > 0) { | |
877 | bmap = (uint32_t *)qemu_mallocz(bmap_size); | |
878 | } | |
9aebd98a SW |
879 | for (i = 0; i < blocks; i++) { |
880 | if (image_type == VDI_TYPE_STATIC) { | |
881 | bmap[i] = i; | |
882 | } else { | |
883 | bmap[i] = VDI_UNALLOCATED; | |
884 | } | |
885 | } | |
886 | if (write(fd, bmap, bmap_size) < 0) { | |
887 | result = -errno; | |
888 | } | |
889 | qemu_free(bmap); | |
890 | if (image_type == VDI_TYPE_STATIC) { | |
891 | if (ftruncate(fd, sizeof(header) + bmap_size + blocks * block_size)) { | |
892 | result = -errno; | |
893 | } | |
894 | } | |
895 | ||
896 | if (close(fd) < 0) { | |
897 | result = -errno; | |
898 | } | |
899 | ||
900 | return result; | |
901 | } | |
902 | ||
903 | static void vdi_close(BlockDriverState *bs) | |
904 | { | |
9aebd98a SW |
905 | } |
906 | ||
205ef796 | 907 | static int vdi_flush(BlockDriverState *bs) |
9aebd98a | 908 | { |
9aebd98a | 909 | logout("\n"); |
205ef796 | 910 | return bdrv_flush(bs->file); |
9aebd98a SW |
911 | } |
912 | ||
913 | ||
914 | static QEMUOptionParameter vdi_create_options[] = { | |
915 | { | |
916 | .name = BLOCK_OPT_SIZE, | |
917 | .type = OPT_SIZE, | |
918 | .help = "Virtual disk size" | |
919 | }, | |
920 | #if defined(CONFIG_VDI_BLOCK_SIZE) | |
921 | { | |
922 | .name = BLOCK_OPT_CLUSTER_SIZE, | |
923 | .type = OPT_SIZE, | |
924 | .help = "VDI cluster (block) size" | |
925 | }, | |
926 | #endif | |
927 | #if defined(CONFIG_VDI_STATIC_IMAGE) | |
928 | { | |
929 | .name = BLOCK_OPT_STATIC, | |
930 | .type = OPT_FLAG, | |
931 | .help = "VDI static (pre-allocated) image" | |
932 | }, | |
933 | #endif | |
934 | /* TODO: An additional option to set UUID values might be useful. */ | |
935 | { NULL } | |
936 | }; | |
937 | ||
938 | static BlockDriver bdrv_vdi = { | |
939 | .format_name = "vdi", | |
940 | .instance_size = sizeof(BDRVVdiState), | |
941 | .bdrv_probe = vdi_probe, | |
942 | .bdrv_open = vdi_open, | |
943 | .bdrv_close = vdi_close, | |
944 | .bdrv_create = vdi_create, | |
945 | .bdrv_flush = vdi_flush, | |
946 | .bdrv_is_allocated = vdi_is_allocated, | |
947 | .bdrv_make_empty = vdi_make_empty, | |
948 | ||
949 | .bdrv_aio_readv = vdi_aio_readv, | |
950 | #if defined(CONFIG_VDI_WRITE) | |
951 | .bdrv_aio_writev = vdi_aio_writev, | |
952 | #endif | |
953 | ||
954 | .bdrv_get_info = vdi_get_info, | |
955 | ||
956 | .create_options = vdi_create_options, | |
957 | .bdrv_check = vdi_check, | |
958 | }; | |
959 | ||
960 | static void bdrv_vdi_init(void) | |
961 | { | |
962 | logout("\n"); | |
963 | bdrv_register(&bdrv_vdi); | |
964 | } | |
965 | ||
966 | block_init(bdrv_vdi_init); |