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"
34 /**************************************************************/
36 #define HEADER_MAGIC "WithoutFreeSpace"
37 #define HEADER_MAGIC2 "WithouFreSpacExt"
38 #define HEADER_VERSION 2
40 #define DEFAULT_CLUSTER_SIZE 1048576 /* 1 MiB */
43 // always little-endian
44 typedef struct ParallelsHeader
{
45 char magic
[16]; // "WithoutFreeSpace"
55 } QEMU_PACKED ParallelsHeader
;
57 typedef struct BDRVParallelsState
{
58 /** Locking is conservative, the lock protects
59 * - image file extending (truncate, fallocate)
60 * - any access to block allocation table
64 ParallelsHeader
*header
;
67 unsigned int bat_size
;
71 unsigned int off_multiplier
;
77 static int64_t bat2sect(BDRVParallelsState
*s
, uint32_t idx
)
79 return (uint64_t)le32_to_cpu(s
->bat_bitmap
[idx
]) * s
->off_multiplier
;
82 static int64_t seek_to_sector(BDRVParallelsState
*s
, int64_t sector_num
)
84 uint32_t index
, offset
;
86 index
= sector_num
/ s
->tracks
;
87 offset
= sector_num
% s
->tracks
;
90 if ((index
>= s
->bat_size
) || (s
->bat_bitmap
[index
] == 0)) {
93 return bat2sect(s
, index
) + offset
;
96 static int cluster_remainder(BDRVParallelsState
*s
, int64_t sector_num
,
99 int ret
= s
->tracks
- sector_num
% s
->tracks
;
100 return MIN(nb_sectors
, ret
);
103 static int64_t allocate_cluster(BlockDriverState
*bs
, int64_t sector_num
)
105 BDRVParallelsState
*s
= bs
->opaque
;
106 uint32_t idx
, offset
;
110 idx
= sector_num
/ s
->tracks
;
111 offset
= sector_num
% s
->tracks
;
113 if (idx
>= s
->bat_size
) {
116 if (s
->bat_bitmap
[idx
] != 0) {
117 return bat2sect(s
, idx
) + offset
;
120 pos
= bdrv_getlength(bs
->file
) >> BDRV_SECTOR_BITS
;
121 if (s
->has_truncate
) {
122 ret
= bdrv_truncate(bs
->file
, (pos
+ s
->tracks
) << BDRV_SECTOR_BITS
);
124 ret
= bdrv_write_zeroes(bs
->file
, pos
, s
->tracks
, 0);
130 s
->bat_bitmap
[idx
] = cpu_to_le32(pos
/ s
->off_multiplier
);
131 ret
= bdrv_pwrite(bs
->file
,
132 sizeof(ParallelsHeader
) + idx
* sizeof(s
->bat_bitmap
[idx
]),
133 s
->bat_bitmap
+ idx
, sizeof(s
->bat_bitmap
[idx
]));
135 s
->bat_bitmap
[idx
] = 0;
138 return bat2sect(s
, idx
) + offset
;
141 static int64_t coroutine_fn
parallels_co_get_block_status(BlockDriverState
*bs
,
142 int64_t sector_num
, int nb_sectors
, int *pnum
)
144 BDRVParallelsState
*s
= bs
->opaque
;
147 qemu_co_mutex_lock(&s
->lock
);
148 offset
= seek_to_sector(s
, sector_num
);
149 qemu_co_mutex_unlock(&s
->lock
);
151 *pnum
= cluster_remainder(s
, sector_num
, nb_sectors
);
157 return (offset
<< BDRV_SECTOR_BITS
) |
158 BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
161 static coroutine_fn
int parallels_co_writev(BlockDriverState
*bs
,
162 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
164 BDRVParallelsState
*s
= bs
->opaque
;
165 uint64_t bytes_done
= 0;
166 QEMUIOVector hd_qiov
;
169 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
171 while (nb_sectors
> 0) {
175 qemu_co_mutex_lock(&s
->lock
);
176 position
= allocate_cluster(bs
, sector_num
);
177 qemu_co_mutex_unlock(&s
->lock
);
183 n
= cluster_remainder(s
, sector_num
, nb_sectors
);
184 nbytes
= n
<< BDRV_SECTOR_BITS
;
186 qemu_iovec_reset(&hd_qiov
);
187 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, nbytes
);
189 ret
= bdrv_co_writev(bs
->file
, position
, n
, &hd_qiov
);
196 bytes_done
+= nbytes
;
199 qemu_iovec_destroy(&hd_qiov
);
203 static coroutine_fn
int parallels_co_readv(BlockDriverState
*bs
,
204 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
206 BDRVParallelsState
*s
= bs
->opaque
;
207 uint64_t bytes_done
= 0;
208 QEMUIOVector hd_qiov
;
211 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
213 while (nb_sectors
> 0) {
217 qemu_co_mutex_lock(&s
->lock
);
218 position
= seek_to_sector(s
, sector_num
);
219 qemu_co_mutex_unlock(&s
->lock
);
221 n
= cluster_remainder(s
, sector_num
, nb_sectors
);
222 nbytes
= n
<< BDRV_SECTOR_BITS
;
225 qemu_iovec_memset(qiov
, bytes_done
, 0, nbytes
);
227 qemu_iovec_reset(&hd_qiov
);
228 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, nbytes
);
230 ret
= bdrv_co_readv(bs
->file
, position
, n
, &hd_qiov
);
238 bytes_done
+= nbytes
;
241 qemu_iovec_destroy(&hd_qiov
);
246 static int parallels_check(BlockDriverState
*bs
, BdrvCheckResult
*res
,
249 BDRVParallelsState
*s
= bs
->opaque
;
250 int64_t size
, prev_off
, high_off
;
253 bool flush_bat
= false;
254 int cluster_size
= s
->tracks
<< BDRV_SECTOR_BITS
;
256 size
= bdrv_getlength(bs
->file
);
262 res
->bfi
.total_clusters
= s
->bat_size
;
263 res
->bfi
.compressed_clusters
= 0; /* compression is not supported */
267 for (i
= 0; i
< s
->bat_size
; i
++) {
268 int64_t off
= bat2sect(s
, i
) << BDRV_SECTOR_BITS
;
274 /* cluster outside the image */
276 fprintf(stderr
, "%s cluster %u is outside image\n",
277 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR", i
);
279 if (fix
& BDRV_FIX_ERRORS
) {
281 s
->bat_bitmap
[i
] = 0;
282 res
->corruptions_fixed
++;
288 res
->bfi
.allocated_clusters
++;
289 if (off
> high_off
) {
293 if (prev_off
!= 0 && (prev_off
+ cluster_size
) != off
) {
294 res
->bfi
.fragmented_clusters
++;
300 ret
= bdrv_pwrite_sync(bs
->file
, 0, s
->header
, s
->header_size
);
307 res
->image_end_offset
= high_off
+ cluster_size
;
308 if (size
> res
->image_end_offset
) {
310 count
= DIV_ROUND_UP(size
- res
->image_end_offset
, cluster_size
);
311 fprintf(stderr
, "%s space leaked at the end of the image %" PRId64
"\n",
312 fix
& BDRV_FIX_LEAKS
? "Repairing" : "ERROR",
313 size
- res
->image_end_offset
);
315 if (fix
& BDRV_FIX_LEAKS
) {
316 ret
= bdrv_truncate(bs
->file
, res
->image_end_offset
);
321 res
->leaks_fixed
+= count
;
329 static int parallels_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
331 int64_t total_size
, cl_size
;
332 uint8_t tmp
[BDRV_SECTOR_SIZE
];
333 Error
*local_err
= NULL
;
334 BlockDriverState
*file
;
335 uint32_t bat_entries
, bat_sectors
;
336 ParallelsHeader header
;
339 total_size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
341 cl_size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
342 DEFAULT_CLUSTER_SIZE
), BDRV_SECTOR_SIZE
);
344 ret
= bdrv_create_file(filename
, opts
, &local_err
);
346 error_propagate(errp
, local_err
);
351 ret
= bdrv_open(&file
, filename
, NULL
, NULL
,
352 BDRV_O_RDWR
| BDRV_O_PROTOCOL
, NULL
, &local_err
);
354 error_propagate(errp
, local_err
);
357 ret
= bdrv_truncate(file
, 0);
362 bat_entries
= DIV_ROUND_UP(total_size
, cl_size
);
363 bat_sectors
= DIV_ROUND_UP(bat_entries
* sizeof(uint32_t) +
364 sizeof(ParallelsHeader
), cl_size
);
365 bat_sectors
= (bat_sectors
* cl_size
) >> BDRV_SECTOR_BITS
;
367 memset(&header
, 0, sizeof(header
));
368 memcpy(header
.magic
, HEADER_MAGIC2
, sizeof(header
.magic
));
369 header
.version
= cpu_to_le32(HEADER_VERSION
);
370 /* don't care much about geometry, it is not used on image level */
371 header
.heads
= cpu_to_le32(16);
372 header
.cylinders
= cpu_to_le32(total_size
/ BDRV_SECTOR_SIZE
/ 16 / 32);
373 header
.tracks
= cpu_to_le32(cl_size
>> BDRV_SECTOR_BITS
);
374 header
.bat_entries
= cpu_to_le32(bat_entries
);
375 header
.nb_sectors
= cpu_to_le64(DIV_ROUND_UP(total_size
, BDRV_SECTOR_SIZE
));
376 header
.data_off
= cpu_to_le32(bat_sectors
);
378 /* write all the data */
379 memset(tmp
, 0, sizeof(tmp
));
380 memcpy(tmp
, &header
, sizeof(header
));
382 ret
= bdrv_pwrite(file
, 0, tmp
, BDRV_SECTOR_SIZE
);
386 ret
= bdrv_write_zeroes(file
, 1, bat_sectors
- 1, 0);
397 error_setg_errno(errp
, -ret
, "Failed to create Parallels image");
402 static int parallels_probe(const uint8_t *buf
, int buf_size
,
403 const char *filename
)
405 const ParallelsHeader
*ph
= (const void *)buf
;
407 if (buf_size
< sizeof(ParallelsHeader
)) {
411 if ((!memcmp(ph
->magic
, HEADER_MAGIC
, 16) ||
412 !memcmp(ph
->magic
, HEADER_MAGIC2
, 16)) &&
413 (le32_to_cpu(ph
->version
) == HEADER_VERSION
)) {
420 static int parallels_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
423 BDRVParallelsState
*s
= bs
->opaque
;
427 ret
= bdrv_pread(bs
->file
, 0, &ph
, sizeof(ph
));
432 bs
->total_sectors
= le64_to_cpu(ph
.nb_sectors
);
434 if (le32_to_cpu(ph
.version
) != HEADER_VERSION
) {
437 if (!memcmp(ph
.magic
, HEADER_MAGIC
, 16)) {
438 s
->off_multiplier
= 1;
439 bs
->total_sectors
= 0xffffffff & bs
->total_sectors
;
440 } else if (!memcmp(ph
.magic
, HEADER_MAGIC2
, 16)) {
441 s
->off_multiplier
= le32_to_cpu(ph
.tracks
);
446 s
->tracks
= le32_to_cpu(ph
.tracks
);
447 if (s
->tracks
== 0) {
448 error_setg(errp
, "Invalid image: Zero sectors per track");
452 if (s
->tracks
> INT32_MAX
/513) {
453 error_setg(errp
, "Invalid image: Too big cluster");
458 s
->bat_size
= le32_to_cpu(ph
.bat_entries
);
459 if (s
->bat_size
> INT_MAX
/ sizeof(uint32_t)) {
460 error_setg(errp
, "Catalog too large");
465 size
= sizeof(ParallelsHeader
) + sizeof(uint32_t) * s
->bat_size
;
466 s
->header_size
= ROUND_UP(size
, bdrv_opt_mem_align(bs
->file
));
467 s
->header
= qemu_try_blockalign(bs
->file
, s
->header_size
);
468 if (s
->header
== NULL
) {
472 if (le32_to_cpu(ph
.data_off
) < s
->header_size
) {
473 /* there is not enough unused space to fit to block align between BAT
474 and actual data. We can't avoid read-modify-write... */
475 s
->header_size
= size
;
478 ret
= bdrv_pread(bs
->file
, 0, s
->header
, s
->header_size
);
482 s
->bat_bitmap
= (uint32_t *)(s
->header
+ 1);
484 s
->has_truncate
= bdrv_has_zero_init(bs
->file
) &&
485 bdrv_truncate(bs
->file
, bdrv_getlength(bs
->file
)) == 0;
487 qemu_co_mutex_init(&s
->lock
);
491 error_setg(errp
, "Image not in Parallels format");
494 qemu_vfree(s
->header
);
499 static void parallels_close(BlockDriverState
*bs
)
501 BDRVParallelsState
*s
= bs
->opaque
;
502 qemu_vfree(s
->header
);
505 static QemuOptsList parallels_create_opts
= {
506 .name
= "parallels-create-opts",
507 .head
= QTAILQ_HEAD_INITIALIZER(parallels_create_opts
.head
),
510 .name
= BLOCK_OPT_SIZE
,
511 .type
= QEMU_OPT_SIZE
,
512 .help
= "Virtual disk size",
515 .name
= BLOCK_OPT_CLUSTER_SIZE
,
516 .type
= QEMU_OPT_SIZE
,
517 .help
= "Parallels image cluster size",
518 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
),
520 { /* end of list */ }
524 static BlockDriver bdrv_parallels
= {
525 .format_name
= "parallels",
526 .instance_size
= sizeof(BDRVParallelsState
),
527 .bdrv_probe
= parallels_probe
,
528 .bdrv_open
= parallels_open
,
529 .bdrv_close
= parallels_close
,
530 .bdrv_co_get_block_status
= parallels_co_get_block_status
,
531 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
532 .bdrv_co_readv
= parallels_co_readv
,
533 .bdrv_co_writev
= parallels_co_writev
,
535 .bdrv_create
= parallels_create
,
536 .bdrv_check
= parallels_check
,
537 .create_opts
= ¶llels_create_opts
,
540 static void bdrv_parallels_init(void)
542 bdrv_register(&bdrv_parallels
);
545 block_init(bdrv_parallels_init
);