![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vdi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to vdi.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 root 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:
56: #if defined(CONFIG_UUID)
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:
116: /* Unallocated blocks use this index (no need to convert endianess). */
117: #define VDI_UNALLOCATED UINT32_MAX
118:
119: #if !defined(CONFIG_UUID)
120: void uuid_generate(uuid_t out)
121: {
1.1.1.4 ! root 122: memset(out, 0, sizeof(uuid_t));
1.1 root 123: }
124:
125: int uuid_is_null(const uuid_t uu)
126: {
127: uuid_t null_uuid = { 0 };
1.1.1.4 ! root 128: return memcmp(uu, null_uuid, sizeof(uuid_t)) == 0;
1.1 root 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 {
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;
197: /* VDI header (converted to host endianess). */
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:
1.1.1.3 root 293: static int vdi_check(BlockDriverState *bs, BdrvCheckResult *res)
1.1 root 294: {
295: /* TODO: additional checks possible. */
296: BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
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);
1.1.1.3 root 316: res->corruptions++;
1.1 root 317: }
318: } else {
319: fprintf(stderr, "ERROR: block index %" PRIu32
320: " too large, is %" PRIu32 "\n", block, bmap_entry);
1.1.1.3 root 321: res->corruptions++;
1.1 root 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);
1.1.1.3 root 329: res->corruptions++;
1.1 root 330: }
331:
332: qemu_free(bmap);
333:
1.1.1.3 root 334: return 0;
1.1 root 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:
1.1.1.3 root 378: static int vdi_open(BlockDriverState *bs, int flags)
1.1 root 379: {
380: BDRVVdiState *s = bs->opaque;
381: VdiHeader header;
382: size_t bmap_size;
383:
384: logout("\n");
385:
1.1.1.3 root 386: if (bdrv_read(bs->file, 0, (uint8_t *)&header, 1) < 0) {
1.1 root 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:
1.1.1.2 root 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:
1.1 root 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;
1.1.1.2 root 422: } else if (header.disk_size >
1.1 root 423: (uint64_t)header.blocks_in_image * header.block_size) {
1.1.1.2 root 424: logout("unsupported disk size %" PRIu64 " B\n", header.disk_size);
1.1 root 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);
442: bmap_size = (bmap_size + SECTOR_SIZE - 1) / SECTOR_SIZE;
1.1.1.3 root 443: if (bmap_size > 0) {
444: s->bmap = qemu_malloc(bmap_size * SECTOR_SIZE);
445: }
446: if (bdrv_read(bs->file, s->bmap_sector, (uint8_t *)s->bmap, bmap_size) < 0) {
1.1 root 447: goto fail_free_bmap;
448: }
449:
450: return 0;
451:
452: fail_free_bmap:
453: qemu_free(s->bmap);
454:
455: fail:
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? */
1.1.1.3 root 479: VdiAIOCB *acb = container_of(blockacb, VdiAIOCB, common);
1.1 root 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);
1.1.1.3 root 610: acb->hd_aiocb = bdrv_aio_readv(bs->file, offset, &acb->hd_qiov,
1.1 root 611: n_sectors, vdi_aio_read_cb, acb);
612: if (acb->hd_aiocb == NULL) {
613: goto done;
614: }
615: }
616: return;
617: done:
618: if (acb->qiov->niov > 1) {
619: qemu_iovec_from_buffer(acb->qiov, acb->orig_buf, acb->qiov->size);
620: qemu_vfree(acb->orig_buf);
621: }
622: acb->common.cb(acb->common.opaque, ret);
623: qemu_aio_release(acb);
624: }
625:
626: static BlockDriverAIOCB *vdi_aio_readv(BlockDriverState *bs,
627: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
628: BlockDriverCompletionFunc *cb, void *opaque)
629: {
630: VdiAIOCB *acb;
631: logout("\n");
632: acb = vdi_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
633: if (!acb) {
634: return NULL;
635: }
636: vdi_aio_read_cb(acb, 0);
637: return &acb->common;
638: }
639:
640: static void vdi_aio_write_cb(void *opaque, int ret)
641: {
642: VdiAIOCB *acb = opaque;
643: BlockDriverState *bs = acb->common.bs;
644: BDRVVdiState *s = bs->opaque;
645: uint32_t bmap_entry;
646: uint32_t block_index;
647: uint32_t sector_in_block;
648: uint32_t n_sectors;
649:
650: acb->hd_aiocb = NULL;
651:
652: if (ret < 0) {
653: goto done;
654: }
655:
656: acb->nb_sectors -= acb->n_sectors;
657: acb->sector_num += acb->n_sectors;
658: acb->buf += acb->n_sectors * SECTOR_SIZE;
659:
660: if (acb->nb_sectors == 0) {
661: logout("finished data write\n");
662: acb->n_sectors = 0;
663: if (acb->header_modified) {
664: VdiHeader *header = acb->block_buffer;
665: logout("now writing modified header\n");
666: assert(acb->bmap_first != VDI_UNALLOCATED);
667: *header = s->header;
668: vdi_header_to_le(header);
669: acb->header_modified = 0;
670: acb->hd_iov.iov_base = acb->block_buffer;
671: acb->hd_iov.iov_len = SECTOR_SIZE;
672: qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1);
1.1.1.3 root 673: acb->hd_aiocb = bdrv_aio_writev(bs->file, 0, &acb->hd_qiov, 1,
1.1 root 674: vdi_aio_write_cb, acb);
675: if (acb->hd_aiocb == NULL) {
676: goto done;
677: }
678: return;
679: } else if (acb->bmap_first != VDI_UNALLOCATED) {
680: /* One or more new blocks were allocated. */
681: uint64_t offset;
682: uint32_t bmap_first;
683: uint32_t bmap_last;
684: qemu_free(acb->block_buffer);
685: acb->block_buffer = NULL;
686: bmap_first = acb->bmap_first;
687: bmap_last = acb->bmap_last;
688: logout("now writing modified block map entry %u...%u\n",
689: bmap_first, bmap_last);
690: /* Write modified sectors from block map. */
691: bmap_first /= (SECTOR_SIZE / sizeof(uint32_t));
692: bmap_last /= (SECTOR_SIZE / sizeof(uint32_t));
693: n_sectors = bmap_last - bmap_first + 1;
694: offset = s->bmap_sector + bmap_first;
695: acb->bmap_first = VDI_UNALLOCATED;
696: acb->hd_iov.iov_base = (void *)((uint8_t *)&s->bmap[0] +
697: bmap_first * SECTOR_SIZE);
698: acb->hd_iov.iov_len = n_sectors * SECTOR_SIZE;
699: qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1);
700: logout("will write %u block map sectors starting from entry %u\n",
701: n_sectors, bmap_first);
1.1.1.3 root 702: acb->hd_aiocb = bdrv_aio_writev(bs->file, offset, &acb->hd_qiov,
1.1 root 703: n_sectors, vdi_aio_write_cb, acb);
704: if (acb->hd_aiocb == NULL) {
705: goto done;
706: }
707: return;
708: }
709: ret = 0;
710: goto done;
711: }
712:
713: logout("%u sectors written\n", acb->n_sectors);
714:
715: block_index = acb->sector_num / s->block_sectors;
716: sector_in_block = acb->sector_num % s->block_sectors;
717: n_sectors = s->block_sectors - sector_in_block;
718: if (n_sectors > acb->nb_sectors) {
719: n_sectors = acb->nb_sectors;
720: }
721:
722: logout("will write %u sectors starting at sector %" PRIu64 "\n",
723: n_sectors, acb->sector_num);
724:
725: /* prepare next AIO request */
726: acb->n_sectors = n_sectors;
727: bmap_entry = le32_to_cpu(s->bmap[block_index]);
728: if (bmap_entry == VDI_UNALLOCATED) {
729: /* Allocate new block and write to it. */
730: uint64_t offset;
731: uint8_t *block;
732: bmap_entry = s->header.blocks_allocated;
733: s->bmap[block_index] = cpu_to_le32(bmap_entry);
734: s->header.blocks_allocated++;
735: offset = s->header.offset_data / SECTOR_SIZE +
736: (uint64_t)bmap_entry * s->block_sectors;
737: block = acb->block_buffer;
738: if (block == NULL) {
739: block = qemu_mallocz(s->block_size);
740: acb->block_buffer = block;
741: acb->bmap_first = block_index;
742: assert(!acb->header_modified);
743: acb->header_modified = 1;
744: }
745: acb->bmap_last = block_index;
746: memcpy(block + sector_in_block * SECTOR_SIZE,
747: acb->buf, n_sectors * SECTOR_SIZE);
748: acb->hd_iov.iov_base = (void *)block;
749: acb->hd_iov.iov_len = s->block_size;
750: qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1);
1.1.1.3 root 751: acb->hd_aiocb = bdrv_aio_writev(bs->file, offset,
1.1 root 752: &acb->hd_qiov, s->block_sectors,
753: vdi_aio_write_cb, acb);
754: if (acb->hd_aiocb == NULL) {
755: goto done;
756: }
757: } else {
758: uint64_t offset = s->header.offset_data / SECTOR_SIZE +
759: (uint64_t)bmap_entry * s->block_sectors +
760: sector_in_block;
761: acb->hd_iov.iov_base = (void *)acb->buf;
762: acb->hd_iov.iov_len = n_sectors * SECTOR_SIZE;
763: qemu_iovec_init_external(&acb->hd_qiov, &acb->hd_iov, 1);
1.1.1.3 root 764: acb->hd_aiocb = bdrv_aio_writev(bs->file, offset, &acb->hd_qiov,
1.1 root 765: n_sectors, vdi_aio_write_cb, acb);
766: if (acb->hd_aiocb == NULL) {
767: goto done;
768: }
769: }
770:
771: return;
772:
773: done:
774: if (acb->qiov->niov > 1) {
775: qemu_vfree(acb->orig_buf);
776: }
777: acb->common.cb(acb->common.opaque, ret);
778: qemu_aio_release(acb);
779: }
780:
781: static BlockDriverAIOCB *vdi_aio_writev(BlockDriverState *bs,
782: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
783: BlockDriverCompletionFunc *cb, void *opaque)
784: {
785: VdiAIOCB *acb;
786: logout("\n");
787: acb = vdi_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
788: if (!acb) {
789: return NULL;
790: }
791: vdi_aio_write_cb(acb, 0);
792: return &acb->common;
793: }
794:
795: static int vdi_create(const char *filename, QEMUOptionParameter *options)
796: {
797: int fd;
798: int result = 0;
799: uint64_t bytes = 0;
800: uint32_t blocks;
801: size_t block_size = 1 * MiB;
802: uint32_t image_type = VDI_TYPE_DYNAMIC;
803: VdiHeader header;
804: size_t i;
805: size_t bmap_size;
806: uint32_t *bmap;
807:
808: logout("\n");
809:
810: /* Read out options. */
811: while (options && options->name) {
812: if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
813: bytes = options->value.n;
814: #if defined(CONFIG_VDI_BLOCK_SIZE)
815: } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {
816: if (options->value.n) {
817: /* TODO: Additional checks (SECTOR_SIZE * 2^n, ...). */
818: block_size = options->value.n;
819: }
820: #endif
821: #if defined(CONFIG_VDI_STATIC_IMAGE)
822: } else if (!strcmp(options->name, BLOCK_OPT_STATIC)) {
823: if (options->value.n) {
824: image_type = VDI_TYPE_STATIC;
825: }
826: #endif
827: }
828: options++;
829: }
830:
831: fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
832: 0644);
833: if (fd < 0) {
834: return -errno;
835: }
836:
1.1.1.2 root 837: /* We need enough blocks to store the given disk size,
838: so always round up. */
839: blocks = (bytes + block_size - 1) / block_size;
840:
1.1 root 841: bmap_size = blocks * sizeof(uint32_t);
842: bmap_size = ((bmap_size + SECTOR_SIZE - 1) & ~(SECTOR_SIZE -1));
843:
844: memset(&header, 0, sizeof(header));
845: pstrcpy(header.text, sizeof(header.text), VDI_TEXT);
846: header.signature = VDI_SIGNATURE;
847: header.version = VDI_VERSION_1_1;
848: header.header_size = 0x180;
849: header.image_type = image_type;
850: header.offset_bmap = 0x200;
851: header.offset_data = 0x200 + bmap_size;
852: header.sector_size = SECTOR_SIZE;
853: header.disk_size = bytes;
854: header.block_size = block_size;
855: header.blocks_in_image = blocks;
856: if (image_type == VDI_TYPE_STATIC) {
857: header.blocks_allocated = blocks;
858: }
859: uuid_generate(header.uuid_image);
860: uuid_generate(header.uuid_last_snap);
861: /* There is no need to set header.uuid_link or header.uuid_parent here. */
862: #if defined(CONFIG_VDI_DEBUG)
863: vdi_header_print(&header);
864: #endif
865: vdi_header_to_le(&header);
866: if (write(fd, &header, sizeof(header)) < 0) {
867: result = -errno;
868: }
869:
1.1.1.3 root 870: bmap = NULL;
871: if (bmap_size > 0) {
872: bmap = (uint32_t *)qemu_mallocz(bmap_size);
873: }
1.1 root 874: for (i = 0; i < blocks; i++) {
875: if (image_type == VDI_TYPE_STATIC) {
876: bmap[i] = i;
877: } else {
878: bmap[i] = VDI_UNALLOCATED;
879: }
880: }
881: if (write(fd, bmap, bmap_size) < 0) {
882: result = -errno;
883: }
884: qemu_free(bmap);
885: if (image_type == VDI_TYPE_STATIC) {
886: if (ftruncate(fd, sizeof(header) + bmap_size + blocks * block_size)) {
887: result = -errno;
888: }
889: }
890:
891: if (close(fd) < 0) {
892: result = -errno;
893: }
894:
895: return result;
896: }
897:
898: static void vdi_close(BlockDriverState *bs)
899: {
900: }
901:
1.1.1.4 ! root 902: static int vdi_flush(BlockDriverState *bs)
1.1 root 903: {
904: logout("\n");
1.1.1.4 ! root 905: return bdrv_flush(bs->file);
1.1 root 906: }
907:
908:
909: static QEMUOptionParameter vdi_create_options[] = {
910: {
911: .name = BLOCK_OPT_SIZE,
912: .type = OPT_SIZE,
913: .help = "Virtual disk size"
914: },
915: #if defined(CONFIG_VDI_BLOCK_SIZE)
916: {
917: .name = BLOCK_OPT_CLUSTER_SIZE,
918: .type = OPT_SIZE,
919: .help = "VDI cluster (block) size"
920: },
921: #endif
922: #if defined(CONFIG_VDI_STATIC_IMAGE)
923: {
924: .name = BLOCK_OPT_STATIC,
925: .type = OPT_FLAG,
926: .help = "VDI static (pre-allocated) image"
927: },
928: #endif
929: /* TODO: An additional option to set UUID values might be useful. */
930: { NULL }
931: };
932:
933: static BlockDriver bdrv_vdi = {
934: .format_name = "vdi",
935: .instance_size = sizeof(BDRVVdiState),
936: .bdrv_probe = vdi_probe,
937: .bdrv_open = vdi_open,
938: .bdrv_close = vdi_close,
939: .bdrv_create = vdi_create,
940: .bdrv_flush = vdi_flush,
941: .bdrv_is_allocated = vdi_is_allocated,
942: .bdrv_make_empty = vdi_make_empty,
943:
944: .bdrv_aio_readv = vdi_aio_readv,
945: #if defined(CONFIG_VDI_WRITE)
946: .bdrv_aio_writev = vdi_aio_writev,
947: #endif
948:
949: .bdrv_get_info = vdi_get_info,
950:
951: .create_options = vdi_create_options,
952: .bdrv_check = vdi_check,
953: };
954:
955: static void bdrv_vdi_init(void)
956: {
957: logout("\n");
958: bdrv_register(&bdrv_vdi);
959: }
960:
961: block_init(bdrv_vdi_init);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.