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 "qemu/error-report.h"
33 #include "qapi/error.h"
34 #include "block/block_int.h"
35 #include "block/qdict.h"
36 #include "sysemu/block-backend.h"
37 #include "qemu/module.h"
38 #include "qemu/option.h"
39 #include "qapi/qmp/qdict.h"
40 #include "qapi/qobject-input-visitor.h"
41 #include "qapi/qapi-visit-block-core.h"
42 #include "qemu/bswap.h"
43 #include "qemu/bitmap.h"
44 #include "qemu/memalign.h"
45 #include "migration/blocker.h"
46 #include "parallels.h"
48 /**************************************************************/
50 #define HEADER_MAGIC "WithoutFreeSpace"
51 #define HEADER_MAGIC2 "WithouFreSpacExt"
52 #define HEADER_VERSION 2
53 #define HEADER_INUSE_MAGIC (0x746F6E59)
54 #define MAX_PARALLELS_IMAGE_FACTOR (1ull << 32)
56 static QEnumLookup prealloc_mode_lookup
= {
57 .array
= (const char *const[]) {
61 .size
= PRL_PREALLOC_MODE__MAX
64 #define PARALLELS_OPT_PREALLOC_MODE "prealloc-mode"
65 #define PARALLELS_OPT_PREALLOC_SIZE "prealloc-size"
67 static QemuOptsList parallels_runtime_opts
= {
69 .head
= QTAILQ_HEAD_INITIALIZER(parallels_runtime_opts
.head
),
72 .name
= PARALLELS_OPT_PREALLOC_SIZE
,
73 .type
= QEMU_OPT_SIZE
,
74 .help
= "Preallocation size on image expansion",
75 .def_value_str
= "128M",
78 .name
= PARALLELS_OPT_PREALLOC_MODE
,
79 .type
= QEMU_OPT_STRING
,
80 .help
= "Preallocation mode on image expansion "
81 "(allowed values: falloc, truncate)",
82 .def_value_str
= "falloc",
84 { /* end of list */ },
88 static QemuOptsList parallels_create_opts
= {
89 .name
= "parallels-create-opts",
90 .head
= QTAILQ_HEAD_INITIALIZER(parallels_create_opts
.head
),
93 .name
= BLOCK_OPT_SIZE
,
94 .type
= QEMU_OPT_SIZE
,
95 .help
= "Virtual disk size",
98 .name
= BLOCK_OPT_CLUSTER_SIZE
,
99 .type
= QEMU_OPT_SIZE
,
100 .help
= "Parallels image cluster size",
101 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
),
103 { /* end of list */ }
108 static int64_t bat2sect(BDRVParallelsState
*s
, uint32_t idx
)
110 return (uint64_t)le32_to_cpu(s
->bat_bitmap
[idx
]) * s
->off_multiplier
;
113 static uint32_t bat_entry_off(uint32_t idx
)
115 return sizeof(ParallelsHeader
) + sizeof(uint32_t) * idx
;
118 static int64_t seek_to_sector(BDRVParallelsState
*s
, int64_t sector_num
)
120 uint32_t index
, offset
;
122 index
= sector_num
/ s
->tracks
;
123 offset
= sector_num
% s
->tracks
;
126 if ((index
>= s
->bat_size
) || (s
->bat_bitmap
[index
] == 0)) {
129 return bat2sect(s
, index
) + offset
;
132 static int cluster_remainder(BDRVParallelsState
*s
, int64_t sector_num
,
135 int ret
= s
->tracks
- sector_num
% s
->tracks
;
136 return MIN(nb_sectors
, ret
);
139 static uint32_t host_cluster_index(BDRVParallelsState
*s
, int64_t off
)
141 off
-= s
->data_start
<< BDRV_SECTOR_BITS
;
142 return off
/ s
->cluster_size
;
145 static int64_t block_status(BDRVParallelsState
*s
, int64_t sector_num
,
146 int nb_sectors
, int *pnum
)
148 int64_t start_off
= -2, prev_end_off
= -2;
151 while (nb_sectors
> 0 || start_off
== -2) {
152 int64_t offset
= seek_to_sector(s
, sector_num
);
155 if (start_off
== -2) {
157 prev_end_off
= offset
;
158 } else if (offset
!= prev_end_off
) {
162 to_end
= cluster_remainder(s
, sector_num
, nb_sectors
);
163 nb_sectors
-= to_end
;
164 sector_num
+= to_end
;
168 prev_end_off
+= to_end
;
174 static void parallels_set_bat_entry(BDRVParallelsState
*s
,
175 uint32_t index
, uint32_t offset
)
177 s
->bat_bitmap
[index
] = cpu_to_le32(offset
);
178 bitmap_set(s
->bat_dirty_bmap
, bat_entry_off(index
) / s
->bat_dirty_block
, 1);
181 static int64_t coroutine_fn GRAPH_RDLOCK
182 allocate_clusters(BlockDriverState
*bs
, int64_t sector_num
,
183 int nb_sectors
, int *pnum
)
186 BDRVParallelsState
*s
= bs
->opaque
;
187 int64_t pos
, space
, idx
, to_allocate
, i
, len
;
189 pos
= block_status(s
, sector_num
, nb_sectors
, pnum
);
194 idx
= sector_num
/ s
->tracks
;
195 to_allocate
= DIV_ROUND_UP(sector_num
+ *pnum
, s
->tracks
) - idx
;
198 * This function is called only by parallels_co_writev(), which will never
199 * pass a sector_num at or beyond the end of the image (because the block
200 * layer never passes such a sector_num to that function). Therefore, idx
201 * is always below s->bat_size.
202 * block_status() will limit *pnum so that sector_num + *pnum will not
203 * exceed the image end. Therefore, idx + to_allocate cannot exceed
205 * Note that s->bat_size is an unsigned int, therefore idx + to_allocate
206 * will always fit into a uint32_t.
208 assert(idx
< s
->bat_size
&& idx
+ to_allocate
<= s
->bat_size
);
210 space
= to_allocate
* s
->tracks
;
211 len
= bdrv_co_getlength(bs
->file
->bs
);
215 if (s
->data_end
+ space
> (len
>> BDRV_SECTOR_BITS
)) {
216 space
+= s
->prealloc_size
;
218 * We require the expanded size to read back as zero. If the
219 * user permitted truncation, we try that; but if it fails, we
220 * force the safer-but-slower fallocate.
222 if (s
->prealloc_mode
== PRL_PREALLOC_MODE_TRUNCATE
) {
223 ret
= bdrv_co_truncate(bs
->file
,
224 (s
->data_end
+ space
) << BDRV_SECTOR_BITS
,
225 false, PREALLOC_MODE_OFF
,
226 BDRV_REQ_ZERO_WRITE
, NULL
);
227 if (ret
== -ENOTSUP
) {
228 s
->prealloc_mode
= PRL_PREALLOC_MODE_FALLOCATE
;
231 if (s
->prealloc_mode
== PRL_PREALLOC_MODE_FALLOCATE
) {
232 ret
= bdrv_co_pwrite_zeroes(bs
->file
,
233 s
->data_end
<< BDRV_SECTOR_BITS
,
234 space
<< BDRV_SECTOR_BITS
, 0);
242 * Try to read from backing to fill empty clusters
243 * FIXME: 1. previous write_zeroes may be redundant
244 * 2. most of data we read from backing will be rewritten by
245 * parallels_co_writev. On aligned-to-cluster write we do not need
247 * 3. it would be good to combine write of data from backing and new
248 * data into one write call.
251 int64_t nb_cow_sectors
= to_allocate
* s
->tracks
;
252 int64_t nb_cow_bytes
= nb_cow_sectors
<< BDRV_SECTOR_BITS
;
253 void *buf
= qemu_blockalign(bs
, nb_cow_bytes
);
255 ret
= bdrv_co_pread(bs
->backing
, idx
* s
->tracks
* BDRV_SECTOR_SIZE
,
256 nb_cow_bytes
, buf
, 0);
262 ret
= bdrv_co_pwrite(bs
->file
, s
->data_end
* BDRV_SECTOR_SIZE
,
263 nb_cow_bytes
, buf
, 0);
270 for (i
= 0; i
< to_allocate
; i
++) {
271 parallels_set_bat_entry(s
, idx
+ i
, s
->data_end
/ s
->off_multiplier
);
272 s
->data_end
+= s
->tracks
;
275 return bat2sect(s
, idx
) + sector_num
% s
->tracks
;
279 static int coroutine_fn GRAPH_RDLOCK
280 parallels_co_flush_to_os(BlockDriverState
*bs
)
282 BDRVParallelsState
*s
= bs
->opaque
;
283 unsigned long size
= DIV_ROUND_UP(s
->header_size
, s
->bat_dirty_block
);
286 qemu_co_mutex_lock(&s
->lock
);
288 bit
= find_first_bit(s
->bat_dirty_bmap
, size
);
290 uint32_t off
= bit
* s
->bat_dirty_block
;
291 uint32_t to_write
= s
->bat_dirty_block
;
294 if (off
+ to_write
> s
->header_size
) {
295 to_write
= s
->header_size
- off
;
297 ret
= bdrv_co_pwrite(bs
->file
, off
, to_write
,
298 (uint8_t *)s
->header
+ off
, 0);
300 qemu_co_mutex_unlock(&s
->lock
);
303 bit
= find_next_bit(s
->bat_dirty_bmap
, size
, bit
+ 1);
305 bitmap_zero(s
->bat_dirty_bmap
, size
);
307 qemu_co_mutex_unlock(&s
->lock
);
312 static int coroutine_fn
parallels_co_block_status(BlockDriverState
*bs
,
318 BlockDriverState
**file
)
320 BDRVParallelsState
*s
= bs
->opaque
;
323 assert(QEMU_IS_ALIGNED(offset
| bytes
, BDRV_SECTOR_SIZE
));
324 qemu_co_mutex_lock(&s
->lock
);
325 offset
= block_status(s
, offset
>> BDRV_SECTOR_BITS
,
326 bytes
>> BDRV_SECTOR_BITS
, &count
);
327 qemu_co_mutex_unlock(&s
->lock
);
329 *pnum
= count
* BDRV_SECTOR_SIZE
;
334 *map
= offset
* BDRV_SECTOR_SIZE
;
335 *file
= bs
->file
->bs
;
336 return BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
339 static int coroutine_fn GRAPH_RDLOCK
340 parallels_co_writev(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
341 QEMUIOVector
*qiov
, int flags
)
343 BDRVParallelsState
*s
= bs
->opaque
;
344 uint64_t bytes_done
= 0;
345 QEMUIOVector hd_qiov
;
348 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
350 while (nb_sectors
> 0) {
354 qemu_co_mutex_lock(&s
->lock
);
355 position
= allocate_clusters(bs
, sector_num
, nb_sectors
, &n
);
356 qemu_co_mutex_unlock(&s
->lock
);
362 nbytes
= n
<< BDRV_SECTOR_BITS
;
364 qemu_iovec_reset(&hd_qiov
);
365 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, nbytes
);
367 ret
= bdrv_co_pwritev(bs
->file
, position
* BDRV_SECTOR_SIZE
, nbytes
,
375 bytes_done
+= nbytes
;
378 qemu_iovec_destroy(&hd_qiov
);
382 static int coroutine_fn GRAPH_RDLOCK
383 parallels_co_readv(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
386 BDRVParallelsState
*s
= bs
->opaque
;
387 uint64_t bytes_done
= 0;
388 QEMUIOVector hd_qiov
;
391 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
393 while (nb_sectors
> 0) {
397 qemu_co_mutex_lock(&s
->lock
);
398 position
= block_status(s
, sector_num
, nb_sectors
, &n
);
399 qemu_co_mutex_unlock(&s
->lock
);
401 nbytes
= n
<< BDRV_SECTOR_BITS
;
403 qemu_iovec_reset(&hd_qiov
);
404 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, nbytes
);
408 ret
= bdrv_co_preadv(bs
->backing
, sector_num
* BDRV_SECTOR_SIZE
,
409 nbytes
, &hd_qiov
, 0);
414 qemu_iovec_memset(&hd_qiov
, 0, 0, nbytes
);
417 ret
= bdrv_co_preadv(bs
->file
, position
* BDRV_SECTOR_SIZE
, nbytes
,
426 bytes_done
+= nbytes
;
429 qemu_iovec_destroy(&hd_qiov
);
433 static void parallels_check_unclean(BlockDriverState
*bs
,
434 BdrvCheckResult
*res
,
437 BDRVParallelsState
*s
= bs
->opaque
;
439 if (!s
->header_unclean
) {
443 fprintf(stderr
, "%s image was not closed correctly\n",
444 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR");
446 if (fix
& BDRV_FIX_ERRORS
) {
447 /* parallels_close will do the job right */
448 res
->corruptions_fixed
++;
449 s
->header_unclean
= false;
454 * Returns true if data_off is correct, otherwise false. In both cases
455 * correct_offset is set to the proper value.
457 static bool parallels_test_data_off(BDRVParallelsState
*s
,
458 int64_t file_nb_sectors
,
459 uint32_t *correct_offset
)
461 uint32_t data_off
, min_off
;
465 * There are two slightly different image formats: with "WithoutFreeSpace"
466 * or "WithouFreSpacExt" magic words. Call the first one as "old magic".
467 * In such images data_off field can be zero. In this case the offset is
468 * calculated as the end of BAT table plus some padding to ensure sector
471 old_magic
= !memcmp(s
->header
->magic
, HEADER_MAGIC
, 16);
473 min_off
= DIV_ROUND_UP(bat_entry_off(s
->bat_size
), BDRV_SECTOR_SIZE
);
475 min_off
= ROUND_UP(min_off
, s
->cluster_size
/ BDRV_SECTOR_SIZE
);
478 if (correct_offset
) {
479 *correct_offset
= min_off
;
482 data_off
= le32_to_cpu(s
->header
->data_off
);
483 if (data_off
== 0 && old_magic
) {
487 if (data_off
< min_off
|| data_off
> file_nb_sectors
) {
491 if (correct_offset
) {
492 *correct_offset
= data_off
;
498 static int coroutine_fn GRAPH_RDLOCK
499 parallels_check_data_off(BlockDriverState
*bs
, BdrvCheckResult
*res
,
502 BDRVParallelsState
*s
= bs
->opaque
;
506 file_size
= bdrv_co_nb_sectors(bs
->file
->bs
);
512 if (parallels_test_data_off(s
, file_size
, &data_off
)) {
517 if (fix
& BDRV_FIX_ERRORS
) {
518 s
->header
->data_off
= cpu_to_le32(data_off
);
519 res
->corruptions_fixed
++;
522 fprintf(stderr
, "%s data_off field has incorrect value\n",
523 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR");
528 static int coroutine_fn GRAPH_RDLOCK
529 parallels_check_outside_image(BlockDriverState
*bs
, BdrvCheckResult
*res
,
532 BDRVParallelsState
*s
= bs
->opaque
;
534 int64_t off
, high_off
, size
;
536 size
= bdrv_co_getlength(bs
->file
->bs
);
543 for (i
= 0; i
< s
->bat_size
; i
++) {
544 off
= bat2sect(s
, i
) << BDRV_SECTOR_BITS
;
545 if (off
+ s
->cluster_size
> size
) {
546 fprintf(stderr
, "%s cluster %u is outside image\n",
547 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR", i
);
549 if (fix
& BDRV_FIX_ERRORS
) {
550 parallels_set_bat_entry(s
, i
, 0);
551 res
->corruptions_fixed
++;
555 if (high_off
< off
) {
561 res
->image_end_offset
= s
->data_end
<< BDRV_SECTOR_BITS
;
563 res
->image_end_offset
= high_off
+ s
->cluster_size
;
564 s
->data_end
= res
->image_end_offset
>> BDRV_SECTOR_BITS
;
570 static int coroutine_fn GRAPH_RDLOCK
571 parallels_check_leak(BlockDriverState
*bs
, BdrvCheckResult
*res
,
572 BdrvCheckMode fix
, bool explicit)
574 BDRVParallelsState
*s
= bs
->opaque
;
578 size
= bdrv_co_getlength(bs
->file
->bs
);
584 if (size
> res
->image_end_offset
) {
586 count
= DIV_ROUND_UP(size
- res
->image_end_offset
, s
->cluster_size
);
589 "%s space leaked at the end of the image %" PRId64
"\n",
590 fix
& BDRV_FIX_LEAKS
? "Repairing" : "ERROR",
591 size
- res
->image_end_offset
);
594 if (fix
& BDRV_FIX_LEAKS
) {
595 Error
*local_err
= NULL
;
598 * In order to really repair the image, we must shrink it.
599 * That means we have to pass exact=true.
601 ret
= bdrv_co_truncate(bs
->file
, res
->image_end_offset
, true,
602 PREALLOC_MODE_OFF
, 0, &local_err
);
604 error_report_err(local_err
);
609 res
->leaks_fixed
+= count
;
617 static int coroutine_fn GRAPH_RDLOCK
618 parallels_check_duplicate(BlockDriverState
*bs
, BdrvCheckResult
*res
,
621 BDRVParallelsState
*s
= bs
->opaque
;
622 int64_t host_off
, host_sector
, guest_sector
;
623 unsigned long *bitmap
;
624 uint32_t i
, bitmap_size
, cluster_index
, bat_entry
;
626 uint64_t *buf
= NULL
;
630 * Create a bitmap of used clusters.
631 * If a bit is set, there is a BAT entry pointing to this cluster.
632 * Loop through the BAT entries, check bits relevant to an entry offset.
633 * If bit is set, this entry is duplicated. Otherwise set the bit.
635 * We shouldn't worry about newly allocated clusters outside the image
636 * because they are created higher then any existing cluster pointed by
639 bitmap_size
= host_cluster_index(s
, res
->image_end_offset
);
640 if (bitmap_size
== 0) {
643 if (res
->image_end_offset
% s
->cluster_size
) {
644 /* A not aligned image end leads to a bitmap shorter by 1 */
648 bitmap
= bitmap_new(bitmap_size
);
650 buf
= qemu_blockalign(bs
, s
->cluster_size
);
652 for (i
= 0; i
< s
->bat_size
; i
++) {
653 host_off
= bat2sect(s
, i
) << BDRV_SECTOR_BITS
;
658 cluster_index
= host_cluster_index(s
, host_off
);
659 assert(cluster_index
< bitmap_size
);
660 if (!test_bit(cluster_index
, bitmap
)) {
661 bitmap_set(bitmap
, cluster_index
, 1);
665 /* this cluster duplicates another one */
666 fprintf(stderr
, "%s duplicate offset in BAT entry %u\n",
667 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR", i
);
671 if (!(fix
& BDRV_FIX_ERRORS
)) {
676 * Reset the entry and allocate a new cluster
677 * for the relevant guest offset. In this way we let
678 * the lower layer to place the new cluster properly.
679 * Copy the original cluster to the allocated one.
680 * But before save the old offset value for repairing
681 * if we have an error.
683 bat_entry
= s
->bat_bitmap
[i
];
684 parallels_set_bat_entry(s
, i
, 0);
686 ret
= bdrv_co_pread(bs
->file
, host_off
, s
->cluster_size
, buf
, 0);
692 guest_sector
= (i
* (int64_t)s
->cluster_size
) >> BDRV_SECTOR_BITS
;
693 host_sector
= allocate_clusters(bs
, guest_sector
, s
->tracks
, &n
);
694 if (host_sector
< 0) {
698 host_off
= host_sector
<< BDRV_SECTOR_BITS
;
700 ret
= bdrv_co_pwrite(bs
->file
, host_off
, s
->cluster_size
, buf
, 0);
706 if (host_off
+ s
->cluster_size
> res
->image_end_offset
) {
707 res
->image_end_offset
= host_off
+ s
->cluster_size
;
711 * In the future allocate_cluster() will reuse holed offsets
712 * inside the image. Keep the used clusters bitmap content
713 * consistent for the new allocated clusters too.
715 * Note, clusters allocated outside the current image are not
716 * considered, and the bitmap size doesn't change.
718 cluster_index
= host_cluster_index(s
, host_off
);
719 if (cluster_index
< bitmap_size
) {
720 bitmap_set(bitmap
, cluster_index
, 1);
724 res
->corruptions_fixed
++;
730 * When new clusters are allocated, the file size increases by
731 * 128 Mb. We need to truncate the file to the right size. Let
732 * the leak fix code make its job without res changing.
734 ret
= parallels_check_leak(bs
, res
, fix
, false);
742 * We can get here only from places where index and old_offset have
746 s
->bat_bitmap
[i
] = bat_entry
;
750 static void parallels_collect_statistics(BlockDriverState
*bs
,
751 BdrvCheckResult
*res
,
754 BDRVParallelsState
*s
= bs
->opaque
;
755 int64_t off
, prev_off
;
758 res
->bfi
.total_clusters
= s
->bat_size
;
759 res
->bfi
.compressed_clusters
= 0; /* compression is not supported */
762 for (i
= 0; i
< s
->bat_size
; i
++) {
763 off
= bat2sect(s
, i
) << BDRV_SECTOR_BITS
;
765 * If BDRV_FIX_ERRORS is not set, out-of-image BAT entries were not
766 * fixed. Skip not allocated and out-of-image BAT entries.
768 if (off
== 0 || off
+ s
->cluster_size
> res
->image_end_offset
) {
773 if (prev_off
!= 0 && (prev_off
+ s
->cluster_size
) != off
) {
774 res
->bfi
.fragmented_clusters
++;
777 res
->bfi
.allocated_clusters
++;
781 static int coroutine_fn GRAPH_RDLOCK
782 parallels_co_check(BlockDriverState
*bs
, BdrvCheckResult
*res
,
785 BDRVParallelsState
*s
= bs
->opaque
;
788 WITH_QEMU_LOCK_GUARD(&s
->lock
) {
789 parallels_check_unclean(bs
, res
, fix
);
791 ret
= parallels_check_data_off(bs
, res
, fix
);
796 ret
= parallels_check_outside_image(bs
, res
, fix
);
801 ret
= parallels_check_leak(bs
, res
, fix
, true);
806 ret
= parallels_check_duplicate(bs
, res
, fix
);
811 parallels_collect_statistics(bs
, res
, fix
);
814 ret
= bdrv_co_flush(bs
);
823 static int coroutine_fn GRAPH_UNLOCKED
824 parallels_co_create(BlockdevCreateOptions
* opts
, Error
**errp
)
826 BlockdevCreateOptionsParallels
*parallels_opts
;
827 BlockDriverState
*bs
;
829 int64_t total_size
, cl_size
;
830 uint32_t bat_entries
, bat_sectors
;
831 ParallelsHeader header
;
832 uint8_t tmp
[BDRV_SECTOR_SIZE
];
835 assert(opts
->driver
== BLOCKDEV_DRIVER_PARALLELS
);
836 parallels_opts
= &opts
->u
.parallels
;
839 total_size
= parallels_opts
->size
;
841 if (parallels_opts
->has_cluster_size
) {
842 cl_size
= parallels_opts
->cluster_size
;
844 cl_size
= DEFAULT_CLUSTER_SIZE
;
847 /* XXX What is the real limit here? This is an insanely large maximum. */
848 if (cl_size
>= INT64_MAX
/ MAX_PARALLELS_IMAGE_FACTOR
) {
849 error_setg(errp
, "Cluster size is too large");
852 if (total_size
>= MAX_PARALLELS_IMAGE_FACTOR
* cl_size
) {
853 error_setg(errp
, "Image size is too large for this cluster size");
857 if (!QEMU_IS_ALIGNED(total_size
, BDRV_SECTOR_SIZE
)) {
858 error_setg(errp
, "Image size must be a multiple of 512 bytes");
862 if (!QEMU_IS_ALIGNED(cl_size
, BDRV_SECTOR_SIZE
)) {
863 error_setg(errp
, "Cluster size must be a multiple of 512 bytes");
867 /* Create BlockBackend to write to the image */
868 bs
= bdrv_co_open_blockdev_ref(parallels_opts
->file
, errp
);
873 blk
= blk_co_new_with_bs(bs
, BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
,
879 blk_set_allow_write_beyond_eof(blk
, true);
881 /* Create image format */
882 bat_entries
= DIV_ROUND_UP(total_size
, cl_size
);
883 bat_sectors
= DIV_ROUND_UP(bat_entry_off(bat_entries
), cl_size
);
884 bat_sectors
= (bat_sectors
* cl_size
) >> BDRV_SECTOR_BITS
;
886 memset(&header
, 0, sizeof(header
));
887 memcpy(header
.magic
, HEADER_MAGIC2
, sizeof(header
.magic
));
888 header
.version
= cpu_to_le32(HEADER_VERSION
);
889 /* don't care much about geometry, it is not used on image level */
890 header
.heads
= cpu_to_le32(HEADS_NUMBER
);
891 header
.cylinders
= cpu_to_le32(total_size
/ BDRV_SECTOR_SIZE
892 / HEADS_NUMBER
/ SEC_IN_CYL
);
893 header
.tracks
= cpu_to_le32(cl_size
>> BDRV_SECTOR_BITS
);
894 header
.bat_entries
= cpu_to_le32(bat_entries
);
895 header
.nb_sectors
= cpu_to_le64(DIV_ROUND_UP(total_size
, BDRV_SECTOR_SIZE
));
896 header
.data_off
= cpu_to_le32(bat_sectors
);
898 /* write all the data */
899 memset(tmp
, 0, sizeof(tmp
));
900 memcpy(tmp
, &header
, sizeof(header
));
902 ret
= blk_co_pwrite(blk
, 0, BDRV_SECTOR_SIZE
, tmp
, 0);
906 ret
= blk_co_pwrite_zeroes(blk
, BDRV_SECTOR_SIZE
,
907 (bat_sectors
- 1) << BDRV_SECTOR_BITS
, 0);
919 error_setg_errno(errp
, -ret
, "Failed to create Parallels image");
923 static int coroutine_fn GRAPH_UNLOCKED
924 parallels_co_create_opts(BlockDriver
*drv
, const char *filename
,
925 QemuOpts
*opts
, Error
**errp
)
927 BlockdevCreateOptions
*create_options
= NULL
;
928 BlockDriverState
*bs
= NULL
;
933 static const QDictRenames opt_renames
[] = {
934 { BLOCK_OPT_CLUSTER_SIZE
, "cluster-size" },
938 /* Parse options and convert legacy syntax */
939 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, ¶llels_create_opts
,
942 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
947 /* Create and open the file (protocol layer) */
948 ret
= bdrv_co_create_file(filename
, opts
, errp
);
953 bs
= bdrv_co_open(filename
, NULL
, NULL
,
954 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
960 /* Now get the QAPI type BlockdevCreateOptions */
961 qdict_put_str(qdict
, "driver", "parallels");
962 qdict_put_str(qdict
, "file", bs
->node_name
);
964 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
970 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, errp
);
972 if (!create_options
) {
977 /* Silently round up sizes */
978 create_options
->u
.parallels
.size
=
979 ROUND_UP(create_options
->u
.parallels
.size
, BDRV_SECTOR_SIZE
);
980 create_options
->u
.parallels
.cluster_size
=
981 ROUND_UP(create_options
->u
.parallels
.cluster_size
, BDRV_SECTOR_SIZE
);
983 /* Create the Parallels image (format layer) */
984 ret
= parallels_co_create(create_options
, errp
);
991 qobject_unref(qdict
);
993 qapi_free_BlockdevCreateOptions(create_options
);
998 static int parallels_probe(const uint8_t *buf
, int buf_size
,
999 const char *filename
)
1001 const ParallelsHeader
*ph
= (const void *)buf
;
1003 if (buf_size
< sizeof(ParallelsHeader
)) {
1007 if ((!memcmp(ph
->magic
, HEADER_MAGIC
, 16) ||
1008 !memcmp(ph
->magic
, HEADER_MAGIC2
, 16)) &&
1009 (le32_to_cpu(ph
->version
) == HEADER_VERSION
)) {
1016 static int parallels_update_header(BlockDriverState
*bs
)
1018 BDRVParallelsState
*s
= bs
->opaque
;
1019 unsigned size
= MAX(bdrv_opt_mem_align(bs
->file
->bs
),
1020 sizeof(ParallelsHeader
));
1022 if (size
> s
->header_size
) {
1023 size
= s
->header_size
;
1025 return bdrv_pwrite_sync(bs
->file
, 0, size
, s
->header
, 0);
1028 static int parallels_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1031 BDRVParallelsState
*s
= bs
->opaque
;
1034 int64_t file_nb_sectors
, sector
;
1035 uint32_t data_start
;
1036 QemuOpts
*opts
= NULL
;
1037 Error
*local_err
= NULL
;
1039 bool data_off_is_correct
;
1041 ret
= bdrv_open_file_child(NULL
, options
, "file", bs
, errp
);
1046 file_nb_sectors
= bdrv_nb_sectors(bs
->file
->bs
);
1047 if (file_nb_sectors
< 0) {
1051 ret
= bdrv_pread(bs
->file
, 0, sizeof(ph
), &ph
, 0);
1056 bs
->total_sectors
= le64_to_cpu(ph
.nb_sectors
);
1058 if (le32_to_cpu(ph
.version
) != HEADER_VERSION
) {
1061 if (!memcmp(ph
.magic
, HEADER_MAGIC
, 16)) {
1062 s
->off_multiplier
= 1;
1063 bs
->total_sectors
= 0xffffffff & bs
->total_sectors
;
1064 } else if (!memcmp(ph
.magic
, HEADER_MAGIC2
, 16)) {
1065 s
->off_multiplier
= le32_to_cpu(ph
.tracks
);
1070 s
->tracks
= le32_to_cpu(ph
.tracks
);
1071 if (s
->tracks
== 0) {
1072 error_setg(errp
, "Invalid image: Zero sectors per track");
1076 if (s
->tracks
> INT32_MAX
/513) {
1077 error_setg(errp
, "Invalid image: Too big cluster");
1081 s
->cluster_size
= s
->tracks
<< BDRV_SECTOR_BITS
;
1083 s
->bat_size
= le32_to_cpu(ph
.bat_entries
);
1084 if (s
->bat_size
> INT_MAX
/ sizeof(uint32_t)) {
1085 error_setg(errp
, "Catalog too large");
1090 size
= bat_entry_off(s
->bat_size
);
1091 s
->header_size
= ROUND_UP(size
, bdrv_opt_mem_align(bs
->file
->bs
));
1092 s
->header
= qemu_try_blockalign(bs
->file
->bs
, s
->header_size
);
1093 if (s
->header
== NULL
) {
1098 ret
= bdrv_pread(bs
->file
, 0, s
->header_size
, s
->header
, 0);
1102 s
->bat_bitmap
= (uint32_t *)(s
->header
+ 1);
1104 if (le32_to_cpu(ph
.inuse
) == HEADER_INUSE_MAGIC
) {
1105 s
->header_unclean
= true;
1108 data_off_is_correct
= parallels_test_data_off(s
, file_nb_sectors
,
1110 s
->data_start
= data_start
;
1111 s
->data_end
= s
->data_start
;
1112 if (s
->data_end
< (s
->header_size
>> BDRV_SECTOR_BITS
)) {
1114 * There is not enough unused space to fit to block align between BAT
1115 * and actual data. We can't avoid read-modify-write...
1117 s
->header_size
= size
;
1120 opts
= qemu_opts_create(¶llels_runtime_opts
, NULL
, 0, errp
);
1125 if (!qemu_opts_absorb_qdict(opts
, options
, errp
)) {
1130 qemu_opt_get_size_del(opts
, PARALLELS_OPT_PREALLOC_SIZE
, 0);
1131 s
->prealloc_size
= MAX(s
->tracks
, s
->prealloc_size
>> BDRV_SECTOR_BITS
);
1132 buf
= qemu_opt_get_del(opts
, PARALLELS_OPT_PREALLOC_MODE
);
1133 /* prealloc_mode can be downgraded later during allocate_clusters */
1134 s
->prealloc_mode
= qapi_enum_parse(&prealloc_mode_lookup
, buf
,
1135 PRL_PREALLOC_MODE_FALLOCATE
,
1138 if (local_err
!= NULL
) {
1139 error_propagate(errp
, local_err
);
1144 if (flags
& BDRV_O_RDWR
) {
1146 * It's unsafe to open image RW if there is an extension (as we
1147 * don't support it). But parallels driver in QEMU historically
1148 * ignores the extension, so print warning and don't care.
1150 warn_report("Format Extension ignored in RW mode");
1152 ret
= parallels_read_format_extension(
1153 bs
, le64_to_cpu(ph
.ext_off
) << BDRV_SECTOR_BITS
, errp
);
1160 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_INACTIVE
)) {
1161 s
->header
->inuse
= cpu_to_le32(HEADER_INUSE_MAGIC
);
1162 ret
= parallels_update_header(bs
);
1168 s
->bat_dirty_block
= 4 * qemu_real_host_page_size();
1170 bitmap_new(DIV_ROUND_UP(s
->header_size
, s
->bat_dirty_block
));
1172 /* Disable migration until bdrv_activate method is added */
1173 error_setg(&s
->migration_blocker
, "The Parallels format used by node '%s' "
1174 "does not support live migration",
1175 bdrv_get_device_or_node_name(bs
));
1176 ret
= migrate_add_blocker(s
->migration_blocker
, errp
);
1178 error_setg(errp
, "Migration blocker error");
1181 qemu_co_mutex_init(&s
->lock
);
1183 for (i
= 0; i
< s
->bat_size
; i
++) {
1184 sector
= bat2sect(s
, i
);
1185 if (sector
+ s
->tracks
> s
->data_end
) {
1186 s
->data_end
= sector
+ s
->tracks
;
1191 * We don't repair the image here if it's opened for checks. Also we don't
1192 * want to change inactive images and can't change readonly images.
1194 if ((flags
& (BDRV_O_CHECK
| BDRV_O_INACTIVE
)) || !(flags
& BDRV_O_RDWR
)) {
1199 * Repair the image if it's dirty or
1200 * out-of-image corruption was detected.
1202 if (s
->data_end
> file_nb_sectors
|| s
->header_unclean
1203 || !data_off_is_correct
) {
1204 BdrvCheckResult res
;
1205 ret
= bdrv_check(bs
, &res
, BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1207 error_setg_errno(errp
, -ret
, "Could not repair corrupted image");
1208 migrate_del_blocker(s
->migration_blocker
);
1216 error_setg(errp
, "Image not in Parallels format");
1221 * "s" object was allocated by g_malloc0 so we can safely
1222 * try to free its fields even they were not allocated.
1224 error_free(s
->migration_blocker
);
1225 g_free(s
->bat_dirty_bmap
);
1226 qemu_vfree(s
->header
);
1231 static void parallels_close(BlockDriverState
*bs
)
1233 BDRVParallelsState
*s
= bs
->opaque
;
1235 if ((bs
->open_flags
& BDRV_O_RDWR
) && !(bs
->open_flags
& BDRV_O_INACTIVE
)) {
1236 s
->header
->inuse
= 0;
1237 parallels_update_header(bs
);
1239 /* errors are ignored, so we might as well pass exact=true */
1240 bdrv_truncate(bs
->file
, s
->data_end
<< BDRV_SECTOR_BITS
, true,
1241 PREALLOC_MODE_OFF
, 0, NULL
);
1244 g_free(s
->bat_dirty_bmap
);
1245 qemu_vfree(s
->header
);
1247 migrate_del_blocker(s
->migration_blocker
);
1248 error_free(s
->migration_blocker
);
1251 static BlockDriver bdrv_parallels
= {
1252 .format_name
= "parallels",
1253 .instance_size
= sizeof(BDRVParallelsState
),
1254 .bdrv_probe
= parallels_probe
,
1255 .bdrv_open
= parallels_open
,
1256 .bdrv_close
= parallels_close
,
1257 .bdrv_child_perm
= bdrv_default_perms
,
1258 .bdrv_co_block_status
= parallels_co_block_status
,
1259 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
1260 .bdrv_co_flush_to_os
= parallels_co_flush_to_os
,
1261 .bdrv_co_readv
= parallels_co_readv
,
1262 .bdrv_co_writev
= parallels_co_writev
,
1264 .supports_backing
= true,
1265 .bdrv_co_create
= parallels_co_create
,
1266 .bdrv_co_create_opts
= parallels_co_create_opts
,
1267 .bdrv_co_check
= parallels_co_check
,
1268 .create_opts
= ¶llels_create_opts
,
1271 static void bdrv_parallels_init(void)
1273 bdrv_register(&bdrv_parallels
);
1276 block_init(bdrv_parallels_init
);