Make vfio MSI interrupt be non-threaded.
[kvmfornfv.git] / qemu / block / vdi.c
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-common.h"
53 #include "block/block_int.h"
54 #include "qemu/module.h"
55 #include "migration/migration.h"
56 #include "block/coroutine.h"
57
58 #if defined(CONFIG_UUID)
59 #include <uuid/uuid.h>
60 #else
61 /* TODO: move uuid emulation to some central place in QEMU. */
62 #include "sysemu/sysemu.h"     /* UUID_FMT */
63 typedef unsigned char uuid_t[16];
64 #endif
65
66 /* Code configuration options. */
67
68 /* Enable debug messages. */
69 //~ #define CONFIG_VDI_DEBUG
70
71 /* Support write operations on VDI images. */
72 #define CONFIG_VDI_WRITE
73
74 /* Support non-standard block (cluster) size. This is untested.
75  * Maybe it will be needed for very large images.
76  */
77 //~ #define CONFIG_VDI_BLOCK_SIZE
78
79 /* Support static (fixed, pre-allocated) images. */
80 #define CONFIG_VDI_STATIC_IMAGE
81
82 /* Command line option for static images. */
83 #define BLOCK_OPT_STATIC "static"
84
85 #define KiB     1024
86 #define MiB     (KiB * KiB)
87
88 #define SECTOR_SIZE 512
89 #define DEFAULT_CLUSTER_SIZE (1 * MiB)
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 /* A never-allocated block; semantically arbitrary content. */
117 #define VDI_UNALLOCATED 0xffffffffU
118
119 /* A discarded (no longer allocated) block; semantically zero-filled. */
120 #define VDI_DISCARDED   0xfffffffeU
121
122 #define VDI_IS_ALLOCATED(X) ((X) < VDI_DISCARDED)
123
124 /* The bmap will take up VDI_BLOCKS_IN_IMAGE_MAX * sizeof(uint32_t) bytes; since
125  * the bmap is read and written in a single operation, its size needs to be
126  * limited to INT_MAX; furthermore, when opening an image, the bmap size is
127  * rounded up to be aligned on BDRV_SECTOR_SIZE.
128  * Therefore this should satisfy the following:
129  * VDI_BLOCKS_IN_IMAGE_MAX * sizeof(uint32_t) + BDRV_SECTOR_SIZE == INT_MAX + 1
130  * (INT_MAX + 1 is the first value not representable as an int)
131  * This guarantees that any value below or equal to the constant will, when
132  * multiplied by sizeof(uint32_t) and rounded up to a BDRV_SECTOR_SIZE boundary,
133  * still be below or equal to INT_MAX. */
134 #define VDI_BLOCKS_IN_IMAGE_MAX \
135     ((unsigned)((INT_MAX + 1u - BDRV_SECTOR_SIZE) / sizeof(uint32_t)))
136 #define VDI_DISK_SIZE_MAX        ((uint64_t)VDI_BLOCKS_IN_IMAGE_MAX * \
137                                   (uint64_t)DEFAULT_CLUSTER_SIZE)
138
139 #if !defined(CONFIG_UUID)
140 static inline void uuid_generate(uuid_t out)
141 {
142     memset(out, 0, sizeof(uuid_t));
143 }
144
145 static inline int uuid_is_null(const uuid_t uu)
146 {
147     uuid_t null_uuid = { 0 };
148     return memcmp(uu, null_uuid, sizeof(uuid_t)) == 0;
149 }
150
151 # if defined(CONFIG_VDI_DEBUG)
152 static inline void uuid_unparse(const uuid_t uu, char *out)
153 {
154     snprintf(out, 37, UUID_FMT,
155             uu[0], uu[1], uu[2], uu[3], uu[4], uu[5], uu[6], uu[7],
156             uu[8], uu[9], uu[10], uu[11], uu[12], uu[13], uu[14], uu[15]);
157 }
158 # endif
159 #endif
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 } QEMU_PACKED 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 endianness). */
198     VdiHeader header;
199
200     CoMutex write_lock;
201
202     Error *migration_blocker;
203 } BDRVVdiState;
204
205 /* Change UUID from little endian (IPRT = VirtualBox format) to big endian
206  * format (network byte order, standard, see RFC 4122) and vice versa.
207  */
208 static void uuid_convert(uuid_t uuid)
209 {
210     bswap32s((uint32_t *)&uuid[0]);
211     bswap16s((uint16_t *)&uuid[4]);
212     bswap16s((uint16_t *)&uuid[6]);
213 }
214
215 static void vdi_header_to_cpu(VdiHeader *header)
216 {
217     le32_to_cpus(&header->signature);
218     le32_to_cpus(&header->version);
219     le32_to_cpus(&header->header_size);
220     le32_to_cpus(&header->image_type);
221     le32_to_cpus(&header->image_flags);
222     le32_to_cpus(&header->offset_bmap);
223     le32_to_cpus(&header->offset_data);
224     le32_to_cpus(&header->cylinders);
225     le32_to_cpus(&header->heads);
226     le32_to_cpus(&header->sectors);
227     le32_to_cpus(&header->sector_size);
228     le64_to_cpus(&header->disk_size);
229     le32_to_cpus(&header->block_size);
230     le32_to_cpus(&header->block_extra);
231     le32_to_cpus(&header->blocks_in_image);
232     le32_to_cpus(&header->blocks_allocated);
233     uuid_convert(header->uuid_image);
234     uuid_convert(header->uuid_last_snap);
235     uuid_convert(header->uuid_link);
236     uuid_convert(header->uuid_parent);
237 }
238
239 static void vdi_header_to_le(VdiHeader *header)
240 {
241     cpu_to_le32s(&header->signature);
242     cpu_to_le32s(&header->version);
243     cpu_to_le32s(&header->header_size);
244     cpu_to_le32s(&header->image_type);
245     cpu_to_le32s(&header->image_flags);
246     cpu_to_le32s(&header->offset_bmap);
247     cpu_to_le32s(&header->offset_data);
248     cpu_to_le32s(&header->cylinders);
249     cpu_to_le32s(&header->heads);
250     cpu_to_le32s(&header->sectors);
251     cpu_to_le32s(&header->sector_size);
252     cpu_to_le64s(&header->disk_size);
253     cpu_to_le32s(&header->block_size);
254     cpu_to_le32s(&header->block_extra);
255     cpu_to_le32s(&header->blocks_in_image);
256     cpu_to_le32s(&header->blocks_allocated);
257     uuid_convert(header->uuid_image);
258     uuid_convert(header->uuid_last_snap);
259     uuid_convert(header->uuid_link);
260     uuid_convert(header->uuid_parent);
261 }
262
263 #if defined(CONFIG_VDI_DEBUG)
264 static void vdi_header_print(VdiHeader *header)
265 {
266     char uuid[37];
267     logout("text        %s", header->text);
268     logout("signature   0x%08x\n", header->signature);
269     logout("header size 0x%04x\n", header->header_size);
270     logout("image type  0x%04x\n", header->image_type);
271     logout("image flags 0x%04x\n", header->image_flags);
272     logout("description %s\n", header->description);
273     logout("offset bmap 0x%04x\n", header->offset_bmap);
274     logout("offset data 0x%04x\n", header->offset_data);
275     logout("cylinders   0x%04x\n", header->cylinders);
276     logout("heads       0x%04x\n", header->heads);
277     logout("sectors     0x%04x\n", header->sectors);
278     logout("sector size 0x%04x\n", header->sector_size);
279     logout("image size  0x%" PRIx64 " B (%" PRIu64 " MiB)\n",
280            header->disk_size, header->disk_size / MiB);
281     logout("block size  0x%04x\n", header->block_size);
282     logout("block extra 0x%04x\n", header->block_extra);
283     logout("blocks tot. 0x%04x\n", header->blocks_in_image);
284     logout("blocks all. 0x%04x\n", header->blocks_allocated);
285     uuid_unparse(header->uuid_image, uuid);
286     logout("uuid image  %s\n", uuid);
287     uuid_unparse(header->uuid_last_snap, uuid);
288     logout("uuid snap   %s\n", uuid);
289     uuid_unparse(header->uuid_link, uuid);
290     logout("uuid link   %s\n", uuid);
291     uuid_unparse(header->uuid_parent, uuid);
292     logout("uuid parent %s\n", uuid);
293 }
294 #endif
295
296 static int vdi_check(BlockDriverState *bs, BdrvCheckResult *res,
297                      BdrvCheckMode fix)
298 {
299     /* TODO: additional checks possible. */
300     BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
301     uint32_t blocks_allocated = 0;
302     uint32_t block;
303     uint32_t *bmap;
304     logout("\n");
305
306     if (fix) {
307         return -ENOTSUP;
308     }
309
310     bmap = g_try_new(uint32_t, s->header.blocks_in_image);
311     if (s->header.blocks_in_image && bmap == NULL) {
312         res->check_errors++;
313         return -ENOMEM;
314     }
315
316     memset(bmap, 0xff, s->header.blocks_in_image * sizeof(uint32_t));
317
318     /* Check block map and value of blocks_allocated. */
319     for (block = 0; block < s->header.blocks_in_image; block++) {
320         uint32_t bmap_entry = le32_to_cpu(s->bmap[block]);
321         if (VDI_IS_ALLOCATED(bmap_entry)) {
322             if (bmap_entry < s->header.blocks_in_image) {
323                 blocks_allocated++;
324                 if (!VDI_IS_ALLOCATED(bmap[bmap_entry])) {
325                     bmap[bmap_entry] = bmap_entry;
326                 } else {
327                     fprintf(stderr, "ERROR: block index %" PRIu32
328                             " also used by %" PRIu32 "\n", bmap[bmap_entry], bmap_entry);
329                     res->corruptions++;
330                 }
331             } else {
332                 fprintf(stderr, "ERROR: block index %" PRIu32
333                         " too large, is %" PRIu32 "\n", block, bmap_entry);
334                 res->corruptions++;
335             }
336         }
337     }
338     if (blocks_allocated != s->header.blocks_allocated) {
339         fprintf(stderr, "ERROR: allocated blocks mismatch, is %" PRIu32
340                ", should be %" PRIu32 "\n",
341                blocks_allocated, s->header.blocks_allocated);
342         res->corruptions++;
343     }
344
345     g_free(bmap);
346
347     return 0;
348 }
349
350 static int vdi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
351 {
352     /* TODO: vdi_get_info would be needed for machine snapshots.
353        vm_state_offset is still missing. */
354     BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
355     logout("\n");
356     bdi->cluster_size = s->block_size;
357     bdi->vm_state_offset = 0;
358     bdi->unallocated_blocks_are_zero = true;
359     return 0;
360 }
361
362 static int vdi_make_empty(BlockDriverState *bs)
363 {
364     /* TODO: missing code. */
365     logout("\n");
366     /* The return value for missing code must be 0, see block.c. */
367     return 0;
368 }
369
370 static int vdi_probe(const uint8_t *buf, int buf_size, const char *filename)
371 {
372     const VdiHeader *header = (const VdiHeader *)buf;
373     int ret = 0;
374
375     logout("\n");
376
377     if (buf_size < sizeof(*header)) {
378         /* Header too small, no VDI. */
379     } else if (le32_to_cpu(header->signature) == VDI_SIGNATURE) {
380         ret = 100;
381     }
382
383     if (ret == 0) {
384         logout("no vdi image\n");
385     } else {
386         logout("%s", header->text);
387     }
388
389     return ret;
390 }
391
392 static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
393                     Error **errp)
394 {
395     BDRVVdiState *s = bs->opaque;
396     VdiHeader header;
397     size_t bmap_size;
398     int ret;
399
400     logout("\n");
401
402     ret = bdrv_read(bs->file, 0, (uint8_t *)&header, 1);
403     if (ret < 0) {
404         goto fail;
405     }
406
407     vdi_header_to_cpu(&header);
408 #if defined(CONFIG_VDI_DEBUG)
409     vdi_header_print(&header);
410 #endif
411
412     if (header.disk_size > VDI_DISK_SIZE_MAX) {
413         error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
414                           ", max supported is 0x%" PRIx64 ")",
415                           header.disk_size, VDI_DISK_SIZE_MAX);
416         ret = -ENOTSUP;
417         goto fail;
418     }
419
420     if (header.disk_size % SECTOR_SIZE != 0) {
421         /* 'VBoxManage convertfromraw' can create images with odd disk sizes.
422            We accept them but round the disk size to the next multiple of
423            SECTOR_SIZE. */
424         logout("odd disk size %" PRIu64 " B, round up\n", header.disk_size);
425         header.disk_size = ROUND_UP(header.disk_size, SECTOR_SIZE);
426     }
427
428     if (header.signature != VDI_SIGNATURE) {
429         error_setg(errp, "Image not in VDI format (bad signature %08" PRIx32
430                    ")", header.signature);
431         ret = -EINVAL;
432         goto fail;
433     } else if (header.version != VDI_VERSION_1_1) {
434         error_setg(errp, "unsupported VDI image (version %" PRIu32 ".%" PRIu32
435                    ")", header.version >> 16, header.version & 0xffff);
436         ret = -ENOTSUP;
437         goto fail;
438     } else if (header.offset_bmap % SECTOR_SIZE != 0) {
439         /* We only support block maps which start on a sector boundary. */
440         error_setg(errp, "unsupported VDI image (unaligned block map offset "
441                    "0x%" PRIx32 ")", header.offset_bmap);
442         ret = -ENOTSUP;
443         goto fail;
444     } else if (header.offset_data % SECTOR_SIZE != 0) {
445         /* We only support data blocks which start on a sector boundary. */
446         error_setg(errp, "unsupported VDI image (unaligned data offset 0x%"
447                    PRIx32 ")", header.offset_data);
448         ret = -ENOTSUP;
449         goto fail;
450     } else if (header.sector_size != SECTOR_SIZE) {
451         error_setg(errp, "unsupported VDI image (sector size %" PRIu32
452                    " is not %u)", header.sector_size, SECTOR_SIZE);
453         ret = -ENOTSUP;
454         goto fail;
455     } else if (header.block_size != DEFAULT_CLUSTER_SIZE) {
456         error_setg(errp, "unsupported VDI image (block size %" PRIu32
457                    " is not %u)", header.block_size, DEFAULT_CLUSTER_SIZE);
458         ret = -ENOTSUP;
459         goto fail;
460     } else if (header.disk_size >
461                (uint64_t)header.blocks_in_image * header.block_size) {
462         error_setg(errp, "unsupported VDI image (disk size %" PRIu64 ", "
463                    "image bitmap has room for %" PRIu64 ")",
464                    header.disk_size,
465                    (uint64_t)header.blocks_in_image * header.block_size);
466         ret = -ENOTSUP;
467         goto fail;
468     } else if (!uuid_is_null(header.uuid_link)) {
469         error_setg(errp, "unsupported VDI image (non-NULL link UUID)");
470         ret = -ENOTSUP;
471         goto fail;
472     } else if (!uuid_is_null(header.uuid_parent)) {
473         error_setg(errp, "unsupported VDI image (non-NULL parent UUID)");
474         ret = -ENOTSUP;
475         goto fail;
476     } else if (header.blocks_in_image > VDI_BLOCKS_IN_IMAGE_MAX) {
477         error_setg(errp, "unsupported VDI image "
478                          "(too many blocks %u, max is %u)",
479                           header.blocks_in_image, VDI_BLOCKS_IN_IMAGE_MAX);
480         ret = -ENOTSUP;
481         goto fail;
482     }
483
484     bs->total_sectors = header.disk_size / SECTOR_SIZE;
485
486     s->block_size = header.block_size;
487     s->block_sectors = header.block_size / SECTOR_SIZE;
488     s->bmap_sector = header.offset_bmap / SECTOR_SIZE;
489     s->header = header;
490
491     bmap_size = header.blocks_in_image * sizeof(uint32_t);
492     bmap_size = DIV_ROUND_UP(bmap_size, SECTOR_SIZE);
493     s->bmap = qemu_try_blockalign(bs->file, bmap_size * SECTOR_SIZE);
494     if (s->bmap == NULL) {
495         ret = -ENOMEM;
496         goto fail;
497     }
498
499     ret = bdrv_read(bs->file, s->bmap_sector, (uint8_t *)s->bmap, bmap_size);
500     if (ret < 0) {
501         goto fail_free_bmap;
502     }
503
504     /* Disable migration when vdi images are used */
505     error_setg(&s->migration_blocker, "The vdi format used by node '%s' "
506                "does not support live migration",
507                bdrv_get_device_or_node_name(bs));
508     migrate_add_blocker(s->migration_blocker);
509
510     qemu_co_mutex_init(&s->write_lock);
511
512     return 0;
513
514  fail_free_bmap:
515     qemu_vfree(s->bmap);
516
517  fail:
518     return ret;
519 }
520
521 static int vdi_reopen_prepare(BDRVReopenState *state,
522                               BlockReopenQueue *queue, Error **errp)
523 {
524     return 0;
525 }
526
527 static int64_t coroutine_fn vdi_co_get_block_status(BlockDriverState *bs,
528         int64_t sector_num, int nb_sectors, int *pnum)
529 {
530     /* TODO: Check for too large sector_num (in bdrv_is_allocated or here). */
531     BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
532     size_t bmap_index = sector_num / s->block_sectors;
533     size_t sector_in_block = sector_num % s->block_sectors;
534     int n_sectors = s->block_sectors - sector_in_block;
535     uint32_t bmap_entry = le32_to_cpu(s->bmap[bmap_index]);
536     uint64_t offset;
537     int result;
538
539     logout("%p, %" PRId64 ", %d, %p\n", bs, sector_num, nb_sectors, pnum);
540     if (n_sectors > nb_sectors) {
541         n_sectors = nb_sectors;
542     }
543     *pnum = n_sectors;
544     result = VDI_IS_ALLOCATED(bmap_entry);
545     if (!result) {
546         return 0;
547     }
548
549     offset = s->header.offset_data +
550                               (uint64_t)bmap_entry * s->block_size +
551                               sector_in_block * SECTOR_SIZE;
552     return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset;
553 }
554
555 static int vdi_co_read(BlockDriverState *bs,
556         int64_t sector_num, uint8_t *buf, int nb_sectors)
557 {
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     int ret = 0;
564
565     logout("\n");
566
567     while (ret >= 0 && nb_sectors > 0) {
568         block_index = sector_num / s->block_sectors;
569         sector_in_block = sector_num % s->block_sectors;
570         n_sectors = s->block_sectors - sector_in_block;
571         if (n_sectors > nb_sectors) {
572             n_sectors = nb_sectors;
573         }
574
575         logout("will read %u sectors starting at sector %" PRIu64 "\n",
576                n_sectors, sector_num);
577
578         /* prepare next AIO request */
579         bmap_entry = le32_to_cpu(s->bmap[block_index]);
580         if (!VDI_IS_ALLOCATED(bmap_entry)) {
581             /* Block not allocated, return zeros, no need to wait. */
582             memset(buf, 0, n_sectors * SECTOR_SIZE);
583             ret = 0;
584         } else {
585             uint64_t offset = s->header.offset_data / SECTOR_SIZE +
586                               (uint64_t)bmap_entry * s->block_sectors +
587                               sector_in_block;
588             ret = bdrv_read(bs->file, offset, buf, n_sectors);
589         }
590         logout("%u sectors read\n", n_sectors);
591
592         nb_sectors -= n_sectors;
593         sector_num += n_sectors;
594         buf += n_sectors * SECTOR_SIZE;
595     }
596
597     return ret;
598 }
599
600 static int vdi_co_write(BlockDriverState *bs,
601         int64_t sector_num, const uint8_t *buf, int nb_sectors)
602 {
603     BDRVVdiState *s = bs->opaque;
604     uint32_t bmap_entry;
605     uint32_t block_index;
606     uint32_t sector_in_block;
607     uint32_t n_sectors;
608     uint32_t bmap_first = VDI_UNALLOCATED;
609     uint32_t bmap_last = VDI_UNALLOCATED;
610     uint8_t *block = NULL;
611     int ret = 0;
612
613     logout("\n");
614
615     while (ret >= 0 && nb_sectors > 0) {
616         block_index = sector_num / s->block_sectors;
617         sector_in_block = sector_num % s->block_sectors;
618         n_sectors = s->block_sectors - sector_in_block;
619         if (n_sectors > nb_sectors) {
620             n_sectors = nb_sectors;
621         }
622
623         logout("will write %u sectors starting at sector %" PRIu64 "\n",
624                n_sectors, sector_num);
625
626         /* prepare next AIO request */
627         bmap_entry = le32_to_cpu(s->bmap[block_index]);
628         if (!VDI_IS_ALLOCATED(bmap_entry)) {
629             /* Allocate new block and write to it. */
630             uint64_t offset;
631             bmap_entry = s->header.blocks_allocated;
632             s->bmap[block_index] = cpu_to_le32(bmap_entry);
633             s->header.blocks_allocated++;
634             offset = s->header.offset_data / SECTOR_SIZE +
635                      (uint64_t)bmap_entry * s->block_sectors;
636             if (block == NULL) {
637                 block = g_malloc(s->block_size);
638                 bmap_first = block_index;
639             }
640             bmap_last = block_index;
641             /* Copy data to be written to new block and zero unused parts. */
642             memset(block, 0, sector_in_block * SECTOR_SIZE);
643             memcpy(block + sector_in_block * SECTOR_SIZE,
644                    buf, n_sectors * SECTOR_SIZE);
645             memset(block + (sector_in_block + n_sectors) * SECTOR_SIZE, 0,
646                    (s->block_sectors - n_sectors - sector_in_block) * SECTOR_SIZE);
647
648             /* Note that this coroutine does not yield anywhere from reading the
649              * bmap entry until here, so in regards to all the coroutines trying
650              * to write to this cluster, the one doing the allocation will
651              * always be the first to try to acquire the lock.
652              * Therefore, it is also the first that will actually be able to
653              * acquire the lock and thus the padded cluster is written before
654              * the other coroutines can write to the affected area. */
655             qemu_co_mutex_lock(&s->write_lock);
656             ret = bdrv_write(bs->file, offset, block, s->block_sectors);
657             qemu_co_mutex_unlock(&s->write_lock);
658         } else {
659             uint64_t offset = s->header.offset_data / SECTOR_SIZE +
660                               (uint64_t)bmap_entry * s->block_sectors +
661                               sector_in_block;
662             qemu_co_mutex_lock(&s->write_lock);
663             /* This lock is only used to make sure the following write operation
664              * is executed after the write issued by the coroutine allocating
665              * this cluster, therefore we do not need to keep it locked.
666              * As stated above, the allocating coroutine will always try to lock
667              * the mutex before all the other concurrent accesses to that
668              * cluster, therefore at this point we can be absolutely certain
669              * that that write operation has returned (there may be other writes
670              * in flight, but they do not concern this very operation). */
671             qemu_co_mutex_unlock(&s->write_lock);
672             ret = bdrv_write(bs->file, offset, buf, n_sectors);
673         }
674
675         nb_sectors -= n_sectors;
676         sector_num += n_sectors;
677         buf += n_sectors * SECTOR_SIZE;
678
679         logout("%u sectors written\n", n_sectors);
680     }
681
682     logout("finished data write\n");
683     if (ret < 0) {
684         return ret;
685     }
686
687     if (block) {
688         /* One or more new blocks were allocated. */
689         VdiHeader *header = (VdiHeader *) block;
690         uint8_t *base;
691         uint64_t offset;
692
693         logout("now writing modified header\n");
694         assert(VDI_IS_ALLOCATED(bmap_first));
695         *header = s->header;
696         vdi_header_to_le(header);
697         ret = bdrv_write(bs->file, 0, block, 1);
698         g_free(block);
699         block = NULL;
700
701         if (ret < 0) {
702             return ret;
703         }
704
705         logout("now writing modified block map entry %u...%u\n",
706                bmap_first, bmap_last);
707         /* Write modified sectors from block map. */
708         bmap_first /= (SECTOR_SIZE / sizeof(uint32_t));
709         bmap_last /= (SECTOR_SIZE / sizeof(uint32_t));
710         n_sectors = bmap_last - bmap_first + 1;
711         offset = s->bmap_sector + bmap_first;
712         base = ((uint8_t *)&s->bmap[0]) + bmap_first * SECTOR_SIZE;
713         logout("will write %u block map sectors starting from entry %u\n",
714                n_sectors, bmap_first);
715         ret = bdrv_write(bs->file, offset, base, n_sectors);
716     }
717
718     return ret;
719 }
720
721 static int vdi_create(const char *filename, QemuOpts *opts, Error **errp)
722 {
723     int ret = 0;
724     uint64_t bytes = 0;
725     uint32_t blocks;
726     size_t block_size = DEFAULT_CLUSTER_SIZE;
727     uint32_t image_type = VDI_TYPE_DYNAMIC;
728     VdiHeader header;
729     size_t i;
730     size_t bmap_size;
731     int64_t offset = 0;
732     Error *local_err = NULL;
733     BlockDriverState *bs = NULL;
734     uint32_t *bmap = NULL;
735
736     logout("\n");
737
738     /* Read out options. */
739     bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
740                      BDRV_SECTOR_SIZE);
741 #if defined(CONFIG_VDI_BLOCK_SIZE)
742     /* TODO: Additional checks (SECTOR_SIZE * 2^n, ...). */
743     block_size = qemu_opt_get_size_del(opts,
744                                        BLOCK_OPT_CLUSTER_SIZE,
745                                        DEFAULT_CLUSTER_SIZE);
746 #endif
747 #if defined(CONFIG_VDI_STATIC_IMAGE)
748     if (qemu_opt_get_bool_del(opts, BLOCK_OPT_STATIC, false)) {
749         image_type = VDI_TYPE_STATIC;
750     }
751 #endif
752
753     if (bytes > VDI_DISK_SIZE_MAX) {
754         ret = -ENOTSUP;
755         error_setg(errp, "Unsupported VDI image size (size is 0x%" PRIx64
756                           ", max supported is 0x%" PRIx64 ")",
757                           bytes, VDI_DISK_SIZE_MAX);
758         goto exit;
759     }
760
761     ret = bdrv_create_file(filename, opts, &local_err);
762     if (ret < 0) {
763         error_propagate(errp, local_err);
764         goto exit;
765     }
766     ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
767                     NULL, &local_err);
768     if (ret < 0) {
769         error_propagate(errp, local_err);
770         goto exit;
771     }
772
773     /* We need enough blocks to store the given disk size,
774        so always round up. */
775     blocks = DIV_ROUND_UP(bytes, block_size);
776
777     bmap_size = blocks * sizeof(uint32_t);
778     bmap_size = ROUND_UP(bmap_size, SECTOR_SIZE);
779
780     memset(&header, 0, sizeof(header));
781     pstrcpy(header.text, sizeof(header.text), VDI_TEXT);
782     header.signature = VDI_SIGNATURE;
783     header.version = VDI_VERSION_1_1;
784     header.header_size = 0x180;
785     header.image_type = image_type;
786     header.offset_bmap = 0x200;
787     header.offset_data = 0x200 + bmap_size;
788     header.sector_size = SECTOR_SIZE;
789     header.disk_size = bytes;
790     header.block_size = block_size;
791     header.blocks_in_image = blocks;
792     if (image_type == VDI_TYPE_STATIC) {
793         header.blocks_allocated = blocks;
794     }
795     uuid_generate(header.uuid_image);
796     uuid_generate(header.uuid_last_snap);
797     /* There is no need to set header.uuid_link or header.uuid_parent here. */
798 #if defined(CONFIG_VDI_DEBUG)
799     vdi_header_print(&header);
800 #endif
801     vdi_header_to_le(&header);
802     ret = bdrv_pwrite_sync(bs, offset, &header, sizeof(header));
803     if (ret < 0) {
804         error_setg(errp, "Error writing header to %s", filename);
805         goto exit;
806     }
807     offset += sizeof(header);
808
809     if (bmap_size > 0) {
810         bmap = g_try_malloc0(bmap_size);
811         if (bmap == NULL) {
812             ret = -ENOMEM;
813             error_setg(errp, "Could not allocate bmap");
814             goto exit;
815         }
816         for (i = 0; i < blocks; i++) {
817             if (image_type == VDI_TYPE_STATIC) {
818                 bmap[i] = i;
819             } else {
820                 bmap[i] = VDI_UNALLOCATED;
821             }
822         }
823         ret = bdrv_pwrite_sync(bs, offset, bmap, bmap_size);
824         if (ret < 0) {
825             error_setg(errp, "Error writing bmap to %s", filename);
826             goto exit;
827         }
828         offset += bmap_size;
829     }
830
831     if (image_type == VDI_TYPE_STATIC) {
832         ret = bdrv_truncate(bs, offset + blocks * block_size);
833         if (ret < 0) {
834             error_setg(errp, "Failed to statically allocate %s", filename);
835             goto exit;
836         }
837     }
838
839 exit:
840     bdrv_unref(bs);
841     g_free(bmap);
842     return ret;
843 }
844
845 static void vdi_close(BlockDriverState *bs)
846 {
847     BDRVVdiState *s = bs->opaque;
848
849     qemu_vfree(s->bmap);
850
851     migrate_del_blocker(s->migration_blocker);
852     error_free(s->migration_blocker);
853 }
854
855 static QemuOptsList vdi_create_opts = {
856     .name = "vdi-create-opts",
857     .head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),
858     .desc = {
859         {
860             .name = BLOCK_OPT_SIZE,
861             .type = QEMU_OPT_SIZE,
862             .help = "Virtual disk size"
863         },
864 #if defined(CONFIG_VDI_BLOCK_SIZE)
865         {
866             .name = BLOCK_OPT_CLUSTER_SIZE,
867             .type = QEMU_OPT_SIZE,
868             .help = "VDI cluster (block) size",
869             .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
870         },
871 #endif
872 #if defined(CONFIG_VDI_STATIC_IMAGE)
873         {
874             .name = BLOCK_OPT_STATIC,
875             .type = QEMU_OPT_BOOL,
876             .help = "VDI static (pre-allocated) image",
877             .def_value_str = "off"
878         },
879 #endif
880         /* TODO: An additional option to set UUID values might be useful. */
881         { /* end of list */ }
882     }
883 };
884
885 static BlockDriver bdrv_vdi = {
886     .format_name = "vdi",
887     .instance_size = sizeof(BDRVVdiState),
888     .bdrv_probe = vdi_probe,
889     .bdrv_open = vdi_open,
890     .bdrv_close = vdi_close,
891     .bdrv_reopen_prepare = vdi_reopen_prepare,
892     .bdrv_create = vdi_create,
893     .bdrv_has_zero_init = bdrv_has_zero_init_1,
894     .bdrv_co_get_block_status = vdi_co_get_block_status,
895     .bdrv_make_empty = vdi_make_empty,
896
897     .bdrv_read = vdi_co_read,
898 #if defined(CONFIG_VDI_WRITE)
899     .bdrv_write = vdi_co_write,
900 #endif
901
902     .bdrv_get_info = vdi_get_info,
903
904     .create_opts = &vdi_create_opts,
905     .bdrv_check = vdi_check,
906 };
907
908 static void bdrv_vdi_init(void)
909 {
910     logout("\n");
911     bdrv_register(&bdrv_vdi);
912 }
913
914 block_init(bdrv_vdi_init);