2 * Block driver for Parallels disk image format
4 * Copyright (c) 2007 Alex Beregszaszi
5 * Copyright (c) 2015 Denis V. Lunev <den@openvz.org>
7 * This code was originally based on comparing different disk images created
8 * by Parallels. Currently it is based on opened OpenVZ sources
10 * http://git.openvz.org/?p=ploop;a=summary
12 * Permission is hereby granted, free of charge, to any person obtaining a copy
13 * of this software and associated documentation files (the "Software"), to deal
14 * in the Software without restriction, including without limitation the rights
15 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16 * copies of the Software, and to permit persons to whom the Software is
17 * furnished to do so, subject to the following conditions:
19 * The above copyright notice and this permission notice shall be included in
20 * all copies or substantial portions of the Software.
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
30 #include "qemu-common.h"
31 #include "block/block_int.h"
32 #include "qemu/module.h"
33 #include "qemu/bitmap.h"
34 #include "qapi/util.h"
36 /**************************************************************/
38 #define HEADER_MAGIC "WithoutFreeSpace"
39 #define HEADER_MAGIC2 "WithouFreSpacExt"
40 #define HEADER_VERSION 2
41 #define HEADER_INUSE_MAGIC (0x746F6E59)
43 #define DEFAULT_CLUSTER_SIZE 1048576 /* 1 MiB */
46 // always little-endian
47 typedef struct ParallelsHeader {
48 char magic[16]; // "WithoutFreeSpace"
58 } QEMU_PACKED ParallelsHeader;
61 typedef enum ParallelsPreallocMode {
62 PRL_PREALLOC_MODE_FALLOCATE = 0,
63 PRL_PREALLOC_MODE_TRUNCATE = 1,
64 PRL_PREALLOC_MODE_MAX = 2,
65 } ParallelsPreallocMode;
67 static const char *prealloc_mode_lookup[] = {
74 typedef struct BDRVParallelsState {
75 /** Locking is conservative, the lock protects
76 * - image file extending (truncate, fallocate)
77 * - any access to block allocation table
81 ParallelsHeader *header;
85 unsigned long *bat_dirty_bmap;
86 unsigned int bat_dirty_block;
89 unsigned int bat_size;
92 uint64_t prealloc_size;
93 ParallelsPreallocMode prealloc_mode;
97 unsigned int off_multiplier;
101 #define PARALLELS_OPT_PREALLOC_MODE "prealloc-mode"
102 #define PARALLELS_OPT_PREALLOC_SIZE "prealloc-size"
104 static QemuOptsList parallels_runtime_opts = {
106 .head = QTAILQ_HEAD_INITIALIZER(parallels_runtime_opts.head),
109 .name = PARALLELS_OPT_PREALLOC_SIZE,
110 .type = QEMU_OPT_SIZE,
111 .help = "Preallocation size on image expansion",
112 .def_value_str = "128MiB",
115 .name = PARALLELS_OPT_PREALLOC_MODE,
116 .type = QEMU_OPT_STRING,
117 .help = "Preallocation mode on image expansion "
118 "(allowed values: falloc, truncate)",
119 .def_value_str = "falloc",
121 { /* end of list */ },
126 static int64_t bat2sect(BDRVParallelsState *s, uint32_t idx)
128 return (uint64_t)le32_to_cpu(s->bat_bitmap[idx]) * s->off_multiplier;
131 static uint32_t bat_entry_off(uint32_t idx)
133 return sizeof(ParallelsHeader) + sizeof(uint32_t) * idx;
136 static int64_t seek_to_sector(BDRVParallelsState *s, int64_t sector_num)
138 uint32_t index, offset;
140 index = sector_num / s->tracks;
141 offset = sector_num % s->tracks;
144 if ((index >= s->bat_size) || (s->bat_bitmap[index] == 0)) {
147 return bat2sect(s, index) + offset;
150 static int cluster_remainder(BDRVParallelsState *s, int64_t sector_num,
153 int ret = s->tracks - sector_num % s->tracks;
154 return MIN(nb_sectors, ret);
157 static int64_t block_status(BDRVParallelsState *s, int64_t sector_num,
158 int nb_sectors, int *pnum)
160 int64_t start_off = -2, prev_end_off = -2;
163 while (nb_sectors > 0 || start_off == -2) {
164 int64_t offset = seek_to_sector(s, sector_num);
167 if (start_off == -2) {
169 prev_end_off = offset;
170 } else if (offset != prev_end_off) {
174 to_end = cluster_remainder(s, sector_num, nb_sectors);
175 nb_sectors -= to_end;
176 sector_num += to_end;
180 prev_end_off += to_end;
186 static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
187 int nb_sectors, int *pnum)
189 BDRVParallelsState *s = bs->opaque;
190 uint32_t idx, to_allocate, i;
193 pos = block_status(s, sector_num, nb_sectors, pnum);
198 idx = sector_num / s->tracks;
199 if (idx >= s->bat_size) {
203 to_allocate = (sector_num + *pnum + s->tracks - 1) / s->tracks - idx;
204 space = to_allocate * s->tracks;
205 if (s->data_end + space > bdrv_getlength(bs->file) >> BDRV_SECTOR_BITS) {
207 space += s->prealloc_size;
208 if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {
209 ret = bdrv_write_zeroes(bs->file, s->data_end, space, 0);
211 ret = bdrv_truncate(bs->file,
212 (s->data_end + space) << BDRV_SECTOR_BITS);
219 for (i = 0; i < to_allocate; i++) {
220 s->bat_bitmap[idx + i] = cpu_to_le32(s->data_end / s->off_multiplier);
221 s->data_end += s->tracks;
222 bitmap_set(s->bat_dirty_bmap,
223 bat_entry_off(idx) / s->bat_dirty_block, 1);
226 return bat2sect(s, idx) + sector_num % s->tracks;
230 static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
232 BDRVParallelsState *s = bs->opaque;
233 unsigned long size = DIV_ROUND_UP(s->header_size, s->bat_dirty_block);
236 qemu_co_mutex_lock(&s->lock);
238 bit = find_first_bit(s->bat_dirty_bmap, size);
240 uint32_t off = bit * s->bat_dirty_block;
241 uint32_t to_write = s->bat_dirty_block;
244 if (off + to_write > s->header_size) {
245 to_write = s->header_size - off;
247 ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off, to_write);
249 qemu_co_mutex_unlock(&s->lock);
252 bit = find_next_bit(s->bat_dirty_bmap, size, bit + 1);
254 bitmap_zero(s->bat_dirty_bmap, size);
256 qemu_co_mutex_unlock(&s->lock);
261 static int64_t coroutine_fn parallels_co_get_block_status(BlockDriverState *bs,
262 int64_t sector_num, int nb_sectors, int *pnum)
264 BDRVParallelsState *s = bs->opaque;
267 qemu_co_mutex_lock(&s->lock);
268 offset = block_status(s, sector_num, nb_sectors, pnum);
269 qemu_co_mutex_unlock(&s->lock);
275 return (offset << BDRV_SECTOR_BITS) |
276 BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
279 static coroutine_fn int parallels_co_writev(BlockDriverState *bs,
280 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
282 BDRVParallelsState *s = bs->opaque;
283 uint64_t bytes_done = 0;
284 QEMUIOVector hd_qiov;
287 qemu_iovec_init(&hd_qiov, qiov->niov);
289 while (nb_sectors > 0) {
293 qemu_co_mutex_lock(&s->lock);
294 position = allocate_clusters(bs, sector_num, nb_sectors, &n);
295 qemu_co_mutex_unlock(&s->lock);
301 nbytes = n << BDRV_SECTOR_BITS;
303 qemu_iovec_reset(&hd_qiov);
304 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);
306 ret = bdrv_co_writev(bs->file, position, n, &hd_qiov);
313 bytes_done += nbytes;
316 qemu_iovec_destroy(&hd_qiov);
320 static coroutine_fn int parallels_co_readv(BlockDriverState *bs,
321 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
323 BDRVParallelsState *s = bs->opaque;
324 uint64_t bytes_done = 0;
325 QEMUIOVector hd_qiov;
328 qemu_iovec_init(&hd_qiov, qiov->niov);
330 while (nb_sectors > 0) {
334 qemu_co_mutex_lock(&s->lock);
335 position = block_status(s, sector_num, nb_sectors, &n);
336 qemu_co_mutex_unlock(&s->lock);
338 nbytes = n << BDRV_SECTOR_BITS;
341 qemu_iovec_memset(qiov, bytes_done, 0, nbytes);
343 qemu_iovec_reset(&hd_qiov);
344 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);
346 ret = bdrv_co_readv(bs->file, position, n, &hd_qiov);
354 bytes_done += nbytes;
357 qemu_iovec_destroy(&hd_qiov);
362 static int parallels_check(BlockDriverState *bs, BdrvCheckResult *res,
365 BDRVParallelsState *s = bs->opaque;
366 int64_t size, prev_off, high_off;
369 bool flush_bat = false;
370 int cluster_size = s->tracks << BDRV_SECTOR_BITS;
372 size = bdrv_getlength(bs->file);
378 if (s->header_unclean) {
379 fprintf(stderr, "%s image was not closed correctly\n",
380 fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR");
382 if (fix & BDRV_FIX_ERRORS) {
383 /* parallels_close will do the job right */
384 res->corruptions_fixed++;
385 s->header_unclean = false;
389 res->bfi.total_clusters = s->bat_size;
390 res->bfi.compressed_clusters = 0; /* compression is not supported */
394 for (i = 0; i < s->bat_size; i++) {
395 int64_t off = bat2sect(s, i) << BDRV_SECTOR_BITS;
401 /* cluster outside the image */
403 fprintf(stderr, "%s cluster %u is outside image\n",
404 fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);
406 if (fix & BDRV_FIX_ERRORS) {
408 s->bat_bitmap[i] = 0;
409 res->corruptions_fixed++;
415 res->bfi.allocated_clusters++;
416 if (off > high_off) {
420 if (prev_off != 0 && (prev_off + cluster_size) != off) {
421 res->bfi.fragmented_clusters++;
427 ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size);
434 res->image_end_offset = high_off + cluster_size;
435 if (size > res->image_end_offset) {
437 count = DIV_ROUND_UP(size - res->image_end_offset, cluster_size);
438 fprintf(stderr, "%s space leaked at the end of the image %" PRId64 "\n",
439 fix & BDRV_FIX_LEAKS ? "Repairing" : "ERROR",
440 size - res->image_end_offset);
442 if (fix & BDRV_FIX_LEAKS) {
443 ret = bdrv_truncate(bs->file, res->image_end_offset);
448 res->leaks_fixed += count;
456 static int parallels_create(const char *filename, QemuOpts *opts, Error **errp)
458 int64_t total_size, cl_size;
459 uint8_t tmp[BDRV_SECTOR_SIZE];
460 Error *local_err = NULL;
461 BlockDriverState *file;
462 uint32_t bat_entries, bat_sectors;
463 ParallelsHeader header;
466 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
468 cl_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
469 DEFAULT_CLUSTER_SIZE), BDRV_SECTOR_SIZE);
471 ret = bdrv_create_file(filename, opts, &local_err);
473 error_propagate(errp, local_err);
478 ret = bdrv_open(&file, filename, NULL, NULL,
479 BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err);
481 error_propagate(errp, local_err);
484 ret = bdrv_truncate(file, 0);
489 bat_entries = DIV_ROUND_UP(total_size, cl_size);
490 bat_sectors = DIV_ROUND_UP(bat_entry_off(bat_entries), cl_size);
491 bat_sectors = (bat_sectors * cl_size) >> BDRV_SECTOR_BITS;
493 memset(&header, 0, sizeof(header));
494 memcpy(header.magic, HEADER_MAGIC2, sizeof(header.magic));
495 header.version = cpu_to_le32(HEADER_VERSION);
496 /* don't care much about geometry, it is not used on image level */
497 header.heads = cpu_to_le32(16);
498 header.cylinders = cpu_to_le32(total_size / BDRV_SECTOR_SIZE / 16 / 32);
499 header.tracks = cpu_to_le32(cl_size >> BDRV_SECTOR_BITS);
500 header.bat_entries = cpu_to_le32(bat_entries);
501 header.nb_sectors = cpu_to_le64(DIV_ROUND_UP(total_size, BDRV_SECTOR_SIZE));
502 header.data_off = cpu_to_le32(bat_sectors);
504 /* write all the data */
505 memset(tmp, 0, sizeof(tmp));
506 memcpy(tmp, &header, sizeof(header));
508 ret = bdrv_pwrite(file, 0, tmp, BDRV_SECTOR_SIZE);
512 ret = bdrv_write_zeroes(file, 1, bat_sectors - 1, 0);
523 error_setg_errno(errp, -ret, "Failed to create Parallels image");
528 static int parallels_probe(const uint8_t *buf, int buf_size,
529 const char *filename)
531 const ParallelsHeader *ph = (const void *)buf;
533 if (buf_size < sizeof(ParallelsHeader)) {
537 if ((!memcmp(ph->magic, HEADER_MAGIC, 16) ||
538 !memcmp(ph->magic, HEADER_MAGIC2, 16)) &&
539 (le32_to_cpu(ph->version) == HEADER_VERSION)) {
546 static int parallels_update_header(BlockDriverState *bs)
548 BDRVParallelsState *s = bs->opaque;
549 unsigned size = MAX(bdrv_opt_mem_align(bs->file), sizeof(ParallelsHeader));
551 if (size > s->header_size) {
552 size = s->header_size;
554 return bdrv_pwrite_sync(bs->file, 0, s->header, size);
557 static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
560 BDRVParallelsState *s = bs->opaque;
563 QemuOpts *opts = NULL;
564 Error *local_err = NULL;
567 ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));
572 bs->total_sectors = le64_to_cpu(ph.nb_sectors);
574 if (le32_to_cpu(ph.version) != HEADER_VERSION) {
577 if (!memcmp(ph.magic, HEADER_MAGIC, 16)) {
578 s->off_multiplier = 1;
579 bs->total_sectors = 0xffffffff & bs->total_sectors;
580 } else if (!memcmp(ph.magic, HEADER_MAGIC2, 16)) {
581 s->off_multiplier = le32_to_cpu(ph.tracks);
586 s->tracks = le32_to_cpu(ph.tracks);
587 if (s->tracks == 0) {
588 error_setg(errp, "Invalid image: Zero sectors per track");
592 if (s->tracks > INT32_MAX/513) {
593 error_setg(errp, "Invalid image: Too big cluster");
598 s->bat_size = le32_to_cpu(ph.bat_entries);
599 if (s->bat_size > INT_MAX / sizeof(uint32_t)) {
600 error_setg(errp, "Catalog too large");
605 size = bat_entry_off(s->bat_size);
606 s->header_size = ROUND_UP(size, bdrv_opt_mem_align(bs->file));
607 s->header = qemu_try_blockalign(bs->file, s->header_size);
608 if (s->header == NULL) {
612 s->data_end = le32_to_cpu(ph.data_off);
613 if (s->data_end == 0) {
614 s->data_end = ROUND_UP(bat_entry_off(s->bat_size), BDRV_SECTOR_SIZE);
616 if (s->data_end < s->header_size) {
617 /* there is not enough unused space to fit to block align between BAT
618 and actual data. We can't avoid read-modify-write... */
619 s->header_size = size;
622 ret = bdrv_pread(bs->file, 0, s->header, s->header_size);
626 s->bat_bitmap = (uint32_t *)(s->header + 1);
628 for (i = 0; i < s->bat_size; i++) {
629 int64_t off = bat2sect(s, i);
630 if (off >= s->data_end) {
631 s->data_end = off + s->tracks;
635 if (le32_to_cpu(ph.inuse) == HEADER_INUSE_MAGIC) {
636 /* Image was not closed correctly. The check is mandatory */
637 s->header_unclean = true;
638 if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
639 error_setg(errp, "parallels: Image was not closed correctly; "
640 "cannot be opened read/write");
646 opts = qemu_opts_create(¶llels_runtime_opts, NULL, 0, &local_err);
647 if (local_err != NULL) {
651 qemu_opts_absorb_qdict(opts, options, &local_err);
652 if (local_err != NULL) {
657 qemu_opt_get_size_del(opts, PARALLELS_OPT_PREALLOC_SIZE, 0);
658 s->prealloc_size = MAX(s->tracks, s->prealloc_size >> BDRV_SECTOR_BITS);
659 buf = qemu_opt_get_del(opts, PARALLELS_OPT_PREALLOC_MODE);
660 s->prealloc_mode = qapi_enum_parse(prealloc_mode_lookup, buf,
661 PRL_PREALLOC_MODE_MAX, PRL_PREALLOC_MODE_FALLOCATE, &local_err);
663 if (local_err != NULL) {
666 if (!bdrv_has_zero_init(bs->file) ||
667 bdrv_truncate(bs->file, bdrv_getlength(bs->file)) != 0) {
668 s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
671 if (flags & BDRV_O_RDWR) {
672 s->header->inuse = cpu_to_le32(HEADER_INUSE_MAGIC);
673 ret = parallels_update_header(bs);
679 s->bat_dirty_block = 4 * getpagesize();
681 bitmap_new(DIV_ROUND_UP(s->header_size, s->bat_dirty_block));
683 qemu_co_mutex_init(&s->lock);
687 error_setg(errp, "Image not in Parallels format");
690 qemu_vfree(s->header);
694 error_propagate(errp, local_err);
700 static void parallels_close(BlockDriverState *bs)
702 BDRVParallelsState *s = bs->opaque;
704 if (bs->open_flags & BDRV_O_RDWR) {
705 s->header->inuse = 0;
706 parallels_update_header(bs);
709 if (bs->open_flags & BDRV_O_RDWR) {
710 bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS);
713 g_free(s->bat_dirty_bmap);
714 qemu_vfree(s->header);
717 static QemuOptsList parallels_create_opts = {
718 .name = "parallels-create-opts",
719 .head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head),
722 .name = BLOCK_OPT_SIZE,
723 .type = QEMU_OPT_SIZE,
724 .help = "Virtual disk size",
727 .name = BLOCK_OPT_CLUSTER_SIZE,
728 .type = QEMU_OPT_SIZE,
729 .help = "Parallels image cluster size",
730 .def_value_str = stringify(DEFAULT_CLUSTER_SIZE),
732 { /* end of list */ }
736 static BlockDriver bdrv_parallels = {
737 .format_name = "parallels",
738 .instance_size = sizeof(BDRVParallelsState),
739 .bdrv_probe = parallels_probe,
740 .bdrv_open = parallels_open,
741 .bdrv_close = parallels_close,
742 .bdrv_co_get_block_status = parallels_co_get_block_status,
743 .bdrv_has_zero_init = bdrv_has_zero_init_1,
744 .bdrv_co_flush_to_os = parallels_co_flush_to_os,
745 .bdrv_co_readv = parallels_co_readv,
746 .bdrv_co_writev = parallels_co_writev,
748 .bdrv_create = parallels_create,
749 .bdrv_check = parallels_check,
750 .create_opts = ¶llels_create_opts,
753 static void bdrv_parallels_init(void)
755 bdrv_register(&bdrv_parallels);
758 block_init(bdrv_parallels_init);