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
31 #include "qemu/osdep.h"
32 #include "qapi/error.h"
33 #include "block/block_int.h"
34 #include "sysemu/block-backend.h"
35 #include "qemu/module.h"
36 #include "qemu/option.h"
37 #include "qemu/bswap.h"
38 #include "qemu/bitmap.h"
39 #include "migration/blocker.h"
40 #include "parallels.h"
42 /**************************************************************/
44 #define HEADER_MAGIC "WithoutFreeSpace"
45 #define HEADER_MAGIC2 "WithouFreSpacExt"
46 #define HEADER_VERSION 2
47 #define HEADER_INUSE_MAGIC (0x746F6E59)
48 #define MAX_PARALLELS_IMAGE_FACTOR (1ull << 32)
50 static QEnumLookup prealloc_mode_lookup
= {
51 .array
= (const char *const[]) {
55 .size
= PRL_PREALLOC_MODE__MAX
58 #define PARALLELS_OPT_PREALLOC_MODE "prealloc-mode"
59 #define PARALLELS_OPT_PREALLOC_SIZE "prealloc-size"
61 static QemuOptsList parallels_runtime_opts
= {
63 .head
= QTAILQ_HEAD_INITIALIZER(parallels_runtime_opts
.head
),
66 .name
= PARALLELS_OPT_PREALLOC_SIZE
,
67 .type
= QEMU_OPT_SIZE
,
68 .help
= "Preallocation size on image expansion",
69 .def_value_str
= "128M",
72 .name
= PARALLELS_OPT_PREALLOC_MODE
,
73 .type
= QEMU_OPT_STRING
,
74 .help
= "Preallocation mode on image expansion "
75 "(allowed values: falloc, truncate)",
76 .def_value_str
= "falloc",
78 { /* end of list */ },
83 static int64_t bat2sect(BDRVParallelsState
*s
, uint32_t idx
)
85 return (uint64_t)le32_to_cpu(s
->bat_bitmap
[idx
]) * s
->off_multiplier
;
88 static uint32_t bat_entry_off(uint32_t idx
)
90 return sizeof(ParallelsHeader
) + sizeof(uint32_t) * idx
;
93 static int64_t seek_to_sector(BDRVParallelsState
*s
, int64_t sector_num
)
95 uint32_t index
, offset
;
97 index
= sector_num
/ s
->tracks
;
98 offset
= sector_num
% s
->tracks
;
101 if ((index
>= s
->bat_size
) || (s
->bat_bitmap
[index
] == 0)) {
104 return bat2sect(s
, index
) + offset
;
107 static int cluster_remainder(BDRVParallelsState
*s
, int64_t sector_num
,
110 int ret
= s
->tracks
- sector_num
% s
->tracks
;
111 return MIN(nb_sectors
, ret
);
114 static int64_t block_status(BDRVParallelsState
*s
, int64_t sector_num
,
115 int nb_sectors
, int *pnum
)
117 int64_t start_off
= -2, prev_end_off
= -2;
120 while (nb_sectors
> 0 || start_off
== -2) {
121 int64_t offset
= seek_to_sector(s
, sector_num
);
124 if (start_off
== -2) {
126 prev_end_off
= offset
;
127 } else if (offset
!= prev_end_off
) {
131 to_end
= cluster_remainder(s
, sector_num
, nb_sectors
);
132 nb_sectors
-= to_end
;
133 sector_num
+= to_end
;
137 prev_end_off
+= to_end
;
143 static int64_t allocate_clusters(BlockDriverState
*bs
, int64_t sector_num
,
144 int nb_sectors
, int *pnum
)
147 BDRVParallelsState
*s
= bs
->opaque
;
148 int64_t pos
, space
, idx
, to_allocate
, i
, len
;
150 pos
= block_status(s
, sector_num
, nb_sectors
, pnum
);
155 idx
= sector_num
/ s
->tracks
;
156 to_allocate
= DIV_ROUND_UP(sector_num
+ *pnum
, s
->tracks
) - idx
;
158 /* This function is called only by parallels_co_writev(), which will never
159 * pass a sector_num at or beyond the end of the image (because the block
160 * layer never passes such a sector_num to that function). Therefore, idx
161 * is always below s->bat_size.
162 * block_status() will limit *pnum so that sector_num + *pnum will not
163 * exceed the image end. Therefore, idx + to_allocate cannot exceed
165 * Note that s->bat_size is an unsigned int, therefore idx + to_allocate
166 * will always fit into a uint32_t. */
167 assert(idx
< s
->bat_size
&& idx
+ to_allocate
<= s
->bat_size
);
169 space
= to_allocate
* s
->tracks
;
170 len
= bdrv_getlength(bs
->file
->bs
);
174 if (s
->data_end
+ space
> (len
>> BDRV_SECTOR_BITS
)) {
175 space
+= s
->prealloc_size
;
176 if (s
->prealloc_mode
== PRL_PREALLOC_MODE_FALLOCATE
) {
177 ret
= bdrv_pwrite_zeroes(bs
->file
,
178 s
->data_end
<< BDRV_SECTOR_BITS
,
179 space
<< BDRV_SECTOR_BITS
, 0);
181 ret
= bdrv_truncate(bs
->file
,
182 (s
->data_end
+ space
) << BDRV_SECTOR_BITS
,
183 PREALLOC_MODE_OFF
, NULL
);
190 /* Try to read from backing to fill empty clusters
191 * FIXME: 1. previous write_zeroes may be redundant
192 * 2. most of data we read from backing will be rewritten by
193 * parallels_co_writev. On aligned-to-cluster write we do not need
195 * 3. it would be good to combine write of data from backing and new
196 * data into one write call */
198 int64_t nb_cow_sectors
= to_allocate
* s
->tracks
;
199 int64_t nb_cow_bytes
= nb_cow_sectors
<< BDRV_SECTOR_BITS
;
202 .iov_len
= nb_cow_bytes
,
203 .iov_base
= qemu_blockalign(bs
, nb_cow_bytes
)
205 qemu_iovec_init_external(&qiov
, &iov
, 1);
207 ret
= bdrv_co_readv(bs
->backing
, idx
* s
->tracks
, nb_cow_sectors
,
210 qemu_vfree(iov
.iov_base
);
214 ret
= bdrv_co_writev(bs
->file
, s
->data_end
, nb_cow_sectors
, &qiov
);
215 qemu_vfree(iov
.iov_base
);
221 for (i
= 0; i
< to_allocate
; i
++) {
222 s
->bat_bitmap
[idx
+ i
] = cpu_to_le32(s
->data_end
/ s
->off_multiplier
);
223 s
->data_end
+= s
->tracks
;
224 bitmap_set(s
->bat_dirty_bmap
,
225 bat_entry_off(idx
+ i
) / s
->bat_dirty_block
, 1);
228 return bat2sect(s
, idx
) + sector_num
% s
->tracks
;
232 static coroutine_fn
int parallels_co_flush_to_os(BlockDriverState
*bs
)
234 BDRVParallelsState
*s
= bs
->opaque
;
235 unsigned long size
= DIV_ROUND_UP(s
->header_size
, s
->bat_dirty_block
);
238 qemu_co_mutex_lock(&s
->lock
);
240 bit
= find_first_bit(s
->bat_dirty_bmap
, size
);
242 uint32_t off
= bit
* s
->bat_dirty_block
;
243 uint32_t to_write
= s
->bat_dirty_block
;
246 if (off
+ to_write
> s
->header_size
) {
247 to_write
= s
->header_size
- off
;
249 ret
= bdrv_pwrite(bs
->file
, off
, (uint8_t *)s
->header
+ off
,
252 qemu_co_mutex_unlock(&s
->lock
);
255 bit
= find_next_bit(s
->bat_dirty_bmap
, size
, bit
+ 1);
257 bitmap_zero(s
->bat_dirty_bmap
, size
);
259 qemu_co_mutex_unlock(&s
->lock
);
264 static int64_t coroutine_fn
parallels_co_get_block_status(BlockDriverState
*bs
,
265 int64_t sector_num
, int nb_sectors
, int *pnum
, BlockDriverState
**file
)
267 BDRVParallelsState
*s
= bs
->opaque
;
270 qemu_co_mutex_lock(&s
->lock
);
271 offset
= block_status(s
, sector_num
, nb_sectors
, pnum
);
272 qemu_co_mutex_unlock(&s
->lock
);
278 *file
= bs
->file
->bs
;
279 return (offset
<< BDRV_SECTOR_BITS
) |
280 BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
283 static coroutine_fn
int parallels_co_writev(BlockDriverState
*bs
,
284 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
286 BDRVParallelsState
*s
= bs
->opaque
;
287 uint64_t bytes_done
= 0;
288 QEMUIOVector hd_qiov
;
291 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
293 while (nb_sectors
> 0) {
297 qemu_co_mutex_lock(&s
->lock
);
298 position
= allocate_clusters(bs
, sector_num
, nb_sectors
, &n
);
299 qemu_co_mutex_unlock(&s
->lock
);
305 nbytes
= n
<< BDRV_SECTOR_BITS
;
307 qemu_iovec_reset(&hd_qiov
);
308 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, nbytes
);
310 ret
= bdrv_co_writev(bs
->file
, position
, n
, &hd_qiov
);
317 bytes_done
+= nbytes
;
320 qemu_iovec_destroy(&hd_qiov
);
324 static coroutine_fn
int parallels_co_readv(BlockDriverState
*bs
,
325 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
327 BDRVParallelsState
*s
= bs
->opaque
;
328 uint64_t bytes_done
= 0;
329 QEMUIOVector hd_qiov
;
332 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
334 while (nb_sectors
> 0) {
338 qemu_co_mutex_lock(&s
->lock
);
339 position
= block_status(s
, sector_num
, nb_sectors
, &n
);
340 qemu_co_mutex_unlock(&s
->lock
);
342 nbytes
= n
<< BDRV_SECTOR_BITS
;
344 qemu_iovec_reset(&hd_qiov
);
345 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, nbytes
);
349 ret
= bdrv_co_readv(bs
->backing
, sector_num
, n
, &hd_qiov
);
354 qemu_iovec_memset(&hd_qiov
, 0, 0, nbytes
);
357 ret
= bdrv_co_readv(bs
->file
, position
, n
, &hd_qiov
);
365 bytes_done
+= nbytes
;
368 qemu_iovec_destroy(&hd_qiov
);
373 static int parallels_check(BlockDriverState
*bs
, BdrvCheckResult
*res
,
376 BDRVParallelsState
*s
= bs
->opaque
;
377 int64_t size
, prev_off
, high_off
;
380 bool flush_bat
= false;
381 int cluster_size
= s
->tracks
<< BDRV_SECTOR_BITS
;
383 size
= bdrv_getlength(bs
->file
->bs
);
389 if (s
->header_unclean
) {
390 fprintf(stderr
, "%s image was not closed correctly\n",
391 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR");
393 if (fix
& BDRV_FIX_ERRORS
) {
394 /* parallels_close will do the job right */
395 res
->corruptions_fixed
++;
396 s
->header_unclean
= false;
400 res
->bfi
.total_clusters
= s
->bat_size
;
401 res
->bfi
.compressed_clusters
= 0; /* compression is not supported */
405 for (i
= 0; i
< s
->bat_size
; i
++) {
406 int64_t off
= bat2sect(s
, i
) << BDRV_SECTOR_BITS
;
412 /* cluster outside the image */
414 fprintf(stderr
, "%s cluster %u is outside image\n",
415 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR", i
);
417 if (fix
& BDRV_FIX_ERRORS
) {
419 s
->bat_bitmap
[i
] = 0;
420 res
->corruptions_fixed
++;
426 res
->bfi
.allocated_clusters
++;
427 if (off
> high_off
) {
431 if (prev_off
!= 0 && (prev_off
+ cluster_size
) != off
) {
432 res
->bfi
.fragmented_clusters
++;
438 ret
= bdrv_pwrite_sync(bs
->file
, 0, s
->header
, s
->header_size
);
445 res
->image_end_offset
= high_off
+ cluster_size
;
446 if (size
> res
->image_end_offset
) {
448 count
= DIV_ROUND_UP(size
- res
->image_end_offset
, cluster_size
);
449 fprintf(stderr
, "%s space leaked at the end of the image %" PRId64
"\n",
450 fix
& BDRV_FIX_LEAKS
? "Repairing" : "ERROR",
451 size
- res
->image_end_offset
);
453 if (fix
& BDRV_FIX_LEAKS
) {
454 Error
*local_err
= NULL
;
455 ret
= bdrv_truncate(bs
->file
, res
->image_end_offset
,
456 PREALLOC_MODE_OFF
, &local_err
);
458 error_report_err(local_err
);
462 res
->leaks_fixed
+= count
;
470 static int parallels_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
472 int64_t total_size
, cl_size
;
473 uint8_t tmp
[BDRV_SECTOR_SIZE
];
474 Error
*local_err
= NULL
;
476 uint32_t bat_entries
, bat_sectors
;
477 ParallelsHeader header
;
480 total_size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
482 cl_size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
483 DEFAULT_CLUSTER_SIZE
), BDRV_SECTOR_SIZE
);
484 if (total_size
>= MAX_PARALLELS_IMAGE_FACTOR
* cl_size
) {
485 error_propagate(errp
, local_err
);
489 ret
= bdrv_create_file(filename
, opts
, &local_err
);
491 error_propagate(errp
, local_err
);
495 file
= blk_new_open(filename
, NULL
, NULL
,
496 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
,
499 error_propagate(errp
, local_err
);
503 blk_set_allow_write_beyond_eof(file
, true);
505 ret
= blk_truncate(file
, 0, PREALLOC_MODE_OFF
, errp
);
510 bat_entries
= DIV_ROUND_UP(total_size
, cl_size
);
511 bat_sectors
= DIV_ROUND_UP(bat_entry_off(bat_entries
), cl_size
);
512 bat_sectors
= (bat_sectors
* cl_size
) >> BDRV_SECTOR_BITS
;
514 memset(&header
, 0, sizeof(header
));
515 memcpy(header
.magic
, HEADER_MAGIC2
, sizeof(header
.magic
));
516 header
.version
= cpu_to_le32(HEADER_VERSION
);
517 /* don't care much about geometry, it is not used on image level */
518 header
.heads
= cpu_to_le32(HEADS_NUMBER
);
519 header
.cylinders
= cpu_to_le32(total_size
/ BDRV_SECTOR_SIZE
520 / HEADS_NUMBER
/ SEC_IN_CYL
);
521 header
.tracks
= cpu_to_le32(cl_size
>> BDRV_SECTOR_BITS
);
522 header
.bat_entries
= cpu_to_le32(bat_entries
);
523 header
.nb_sectors
= cpu_to_le64(DIV_ROUND_UP(total_size
, BDRV_SECTOR_SIZE
));
524 header
.data_off
= cpu_to_le32(bat_sectors
);
526 /* write all the data */
527 memset(tmp
, 0, sizeof(tmp
));
528 memcpy(tmp
, &header
, sizeof(header
));
530 ret
= blk_pwrite(file
, 0, tmp
, BDRV_SECTOR_SIZE
, 0);
534 ret
= blk_pwrite_zeroes(file
, BDRV_SECTOR_SIZE
,
535 (bat_sectors
- 1) << BDRV_SECTOR_BITS
, 0);
546 error_setg_errno(errp
, -ret
, "Failed to create Parallels image");
551 static int parallels_probe(const uint8_t *buf
, int buf_size
,
552 const char *filename
)
554 const ParallelsHeader
*ph
= (const void *)buf
;
556 if (buf_size
< sizeof(ParallelsHeader
)) {
560 if ((!memcmp(ph
->magic
, HEADER_MAGIC
, 16) ||
561 !memcmp(ph
->magic
, HEADER_MAGIC2
, 16)) &&
562 (le32_to_cpu(ph
->version
) == HEADER_VERSION
)) {
569 static int parallels_update_header(BlockDriverState
*bs
)
571 BDRVParallelsState
*s
= bs
->opaque
;
572 unsigned size
= MAX(bdrv_opt_mem_align(bs
->file
->bs
),
573 sizeof(ParallelsHeader
));
575 if (size
> s
->header_size
) {
576 size
= s
->header_size
;
578 return bdrv_pwrite_sync(bs
->file
, 0, s
->header
, size
);
581 static int parallels_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
584 BDRVParallelsState
*s
= bs
->opaque
;
587 QemuOpts
*opts
= NULL
;
588 Error
*local_err
= NULL
;
591 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
597 ret
= bdrv_pread(bs
->file
, 0, &ph
, sizeof(ph
));
602 bs
->total_sectors
= le64_to_cpu(ph
.nb_sectors
);
604 if (le32_to_cpu(ph
.version
) != HEADER_VERSION
) {
607 if (!memcmp(ph
.magic
, HEADER_MAGIC
, 16)) {
608 s
->off_multiplier
= 1;
609 bs
->total_sectors
= 0xffffffff & bs
->total_sectors
;
610 } else if (!memcmp(ph
.magic
, HEADER_MAGIC2
, 16)) {
611 s
->off_multiplier
= le32_to_cpu(ph
.tracks
);
616 s
->tracks
= le32_to_cpu(ph
.tracks
);
617 if (s
->tracks
== 0) {
618 error_setg(errp
, "Invalid image: Zero sectors per track");
622 if (s
->tracks
> INT32_MAX
/513) {
623 error_setg(errp
, "Invalid image: Too big cluster");
628 s
->bat_size
= le32_to_cpu(ph
.bat_entries
);
629 if (s
->bat_size
> INT_MAX
/ sizeof(uint32_t)) {
630 error_setg(errp
, "Catalog too large");
635 size
= bat_entry_off(s
->bat_size
);
636 s
->header_size
= ROUND_UP(size
, bdrv_opt_mem_align(bs
->file
->bs
));
637 s
->header
= qemu_try_blockalign(bs
->file
->bs
, s
->header_size
);
638 if (s
->header
== NULL
) {
642 s
->data_end
= le32_to_cpu(ph
.data_off
);
643 if (s
->data_end
== 0) {
644 s
->data_end
= ROUND_UP(bat_entry_off(s
->bat_size
), BDRV_SECTOR_SIZE
);
646 if (s
->data_end
< s
->header_size
) {
647 /* there is not enough unused space to fit to block align between BAT
648 and actual data. We can't avoid read-modify-write... */
649 s
->header_size
= size
;
652 ret
= bdrv_pread(bs
->file
, 0, s
->header
, s
->header_size
);
656 s
->bat_bitmap
= (uint32_t *)(s
->header
+ 1);
658 for (i
= 0; i
< s
->bat_size
; i
++) {
659 int64_t off
= bat2sect(s
, i
);
660 if (off
>= s
->data_end
) {
661 s
->data_end
= off
+ s
->tracks
;
665 if (le32_to_cpu(ph
.inuse
) == HEADER_INUSE_MAGIC
) {
666 /* Image was not closed correctly. The check is mandatory */
667 s
->header_unclean
= true;
668 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
669 error_setg(errp
, "parallels: Image was not closed correctly; "
670 "cannot be opened read/write");
676 opts
= qemu_opts_create(¶llels_runtime_opts
, NULL
, 0, &local_err
);
677 if (local_err
!= NULL
) {
681 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
682 if (local_err
!= NULL
) {
687 qemu_opt_get_size_del(opts
, PARALLELS_OPT_PREALLOC_SIZE
, 0);
688 s
->prealloc_size
= MAX(s
->tracks
, s
->prealloc_size
>> BDRV_SECTOR_BITS
);
689 buf
= qemu_opt_get_del(opts
, PARALLELS_OPT_PREALLOC_MODE
);
690 s
->prealloc_mode
= qapi_enum_parse(&prealloc_mode_lookup
, buf
,
691 PRL_PREALLOC_MODE_FALLOCATE
,
694 if (local_err
!= NULL
) {
698 if (!bdrv_has_zero_init(bs
->file
->bs
)) {
699 s
->prealloc_mode
= PRL_PREALLOC_MODE_FALLOCATE
;
702 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_INACTIVE
)) {
703 s
->header
->inuse
= cpu_to_le32(HEADER_INUSE_MAGIC
);
704 ret
= parallels_update_header(bs
);
710 s
->bat_dirty_block
= 4 * getpagesize();
712 bitmap_new(DIV_ROUND_UP(s
->header_size
, s
->bat_dirty_block
));
714 /* Disable migration until bdrv_invalidate_cache method is added */
715 error_setg(&s
->migration_blocker
, "The Parallels format used by node '%s' "
716 "does not support live migration",
717 bdrv_get_device_or_node_name(bs
));
718 ret
= migrate_add_blocker(s
->migration_blocker
, &local_err
);
720 error_propagate(errp
, local_err
);
721 error_free(s
->migration_blocker
);
724 qemu_co_mutex_init(&s
->lock
);
728 error_setg(errp
, "Image not in Parallels format");
731 qemu_vfree(s
->header
);
735 error_propagate(errp
, local_err
);
741 static void parallels_close(BlockDriverState
*bs
)
743 BDRVParallelsState
*s
= bs
->opaque
;
745 if ((bs
->open_flags
& BDRV_O_RDWR
) && !(bs
->open_flags
& BDRV_O_INACTIVE
)) {
746 s
->header
->inuse
= 0;
747 parallels_update_header(bs
);
748 bdrv_truncate(bs
->file
, s
->data_end
<< BDRV_SECTOR_BITS
,
749 PREALLOC_MODE_OFF
, NULL
);
752 g_free(s
->bat_dirty_bmap
);
753 qemu_vfree(s
->header
);
755 migrate_del_blocker(s
->migration_blocker
);
756 error_free(s
->migration_blocker
);
759 static QemuOptsList parallels_create_opts
= {
760 .name
= "parallels-create-opts",
761 .head
= QTAILQ_HEAD_INITIALIZER(parallels_create_opts
.head
),
764 .name
= BLOCK_OPT_SIZE
,
765 .type
= QEMU_OPT_SIZE
,
766 .help
= "Virtual disk size",
769 .name
= BLOCK_OPT_CLUSTER_SIZE
,
770 .type
= QEMU_OPT_SIZE
,
771 .help
= "Parallels image cluster size",
772 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
),
774 { /* end of list */ }
778 static BlockDriver bdrv_parallels
= {
779 .format_name
= "parallels",
780 .instance_size
= sizeof(BDRVParallelsState
),
781 .bdrv_probe
= parallels_probe
,
782 .bdrv_open
= parallels_open
,
783 .bdrv_close
= parallels_close
,
784 .bdrv_child_perm
= bdrv_format_default_perms
,
785 .bdrv_co_get_block_status
= parallels_co_get_block_status
,
786 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
787 .bdrv_co_flush_to_os
= parallels_co_flush_to_os
,
788 .bdrv_co_readv
= parallels_co_readv
,
789 .bdrv_co_writev
= parallels_co_writev
,
790 .supports_backing
= true,
791 .bdrv_create
= parallels_create
,
792 .bdrv_check
= parallels_check
,
793 .create_opts
= ¶llels_create_opts
,
796 static void bdrv_parallels_init(void)
798 bdrv_register(&bdrv_parallels
);
801 block_init(bdrv_parallels_init
);