block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
[qemu.git] / block / parallels.c
1 /*
2 * Block driver for Parallels disk image format
3 *
4 * Copyright (c) 2007 Alex Beregszaszi
5 * Copyright (c) 2015 Denis V. Lunev <den@openvz.org>
6 *
7 * This code was originally based on comparing different disk images created
8 * by Parallels. Currently it is based on opened OpenVZ sources
9 * available at
10 * http://git.openvz.org/?p=ploop;a=summary
11 *
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:
18 *
19 * The above copyright notice and this permission notice shall be included in
20 * all copies or substantial portions of the Software.
21 *
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
28 * THE SOFTWARE.
29 */
30 #include "qemu/osdep.h"
31 #include "qapi/error.h"
32 #include "qemu-common.h"
33 #include "block/block_int.h"
34 #include "sysemu/block-backend.h"
35 #include "qemu/module.h"
36 #include "qemu/bswap.h"
37 #include "qemu/bitmap.h"
38 #include "qapi/util.h"
39
40 /**************************************************************/
41
42 #define HEADER_MAGIC "WithoutFreeSpace"
43 #define HEADER_MAGIC2 "WithouFreSpacExt"
44 #define HEADER_VERSION 2
45 #define HEADER_INUSE_MAGIC (0x746F6E59)
46 #define MAX_PARALLELS_IMAGE_FACTOR (1ull << 32)
47
48 #define DEFAULT_CLUSTER_SIZE 1048576 /* 1 MiB */
49
50
51 // always little-endian
52 typedef struct ParallelsHeader {
53 char magic[16]; // "WithoutFreeSpace"
54 uint32_t version;
55 uint32_t heads;
56 uint32_t cylinders;
57 uint32_t tracks;
58 uint32_t bat_entries;
59 uint64_t nb_sectors;
60 uint32_t inuse;
61 uint32_t data_off;
62 char padding[12];
63 } QEMU_PACKED ParallelsHeader;
64
65
66 typedef enum ParallelsPreallocMode {
67 PRL_PREALLOC_MODE_FALLOCATE = 0,
68 PRL_PREALLOC_MODE_TRUNCATE = 1,
69 PRL_PREALLOC_MODE__MAX = 2,
70 } ParallelsPreallocMode;
71
72 static const char *prealloc_mode_lookup[] = {
73 "falloc",
74 "truncate",
75 NULL,
76 };
77
78
79 typedef struct BDRVParallelsState {
80 /** Locking is conservative, the lock protects
81 * - image file extending (truncate, fallocate)
82 * - any access to block allocation table
83 */
84 CoMutex lock;
85
86 ParallelsHeader *header;
87 uint32_t header_size;
88 bool header_unclean;
89
90 unsigned long *bat_dirty_bmap;
91 unsigned int bat_dirty_block;
92
93 uint32_t *bat_bitmap;
94 unsigned int bat_size;
95
96 int64_t data_end;
97 uint64_t prealloc_size;
98 ParallelsPreallocMode prealloc_mode;
99
100 unsigned int tracks;
101
102 unsigned int off_multiplier;
103 } BDRVParallelsState;
104
105
106 #define PARALLELS_OPT_PREALLOC_MODE "prealloc-mode"
107 #define PARALLELS_OPT_PREALLOC_SIZE "prealloc-size"
108
109 static QemuOptsList parallels_runtime_opts = {
110 .name = "parallels",
111 .head = QTAILQ_HEAD_INITIALIZER(parallels_runtime_opts.head),
112 .desc = {
113 {
114 .name = PARALLELS_OPT_PREALLOC_SIZE,
115 .type = QEMU_OPT_SIZE,
116 .help = "Preallocation size on image expansion",
117 .def_value_str = "128M",
118 },
119 {
120 .name = PARALLELS_OPT_PREALLOC_MODE,
121 .type = QEMU_OPT_STRING,
122 .help = "Preallocation mode on image expansion "
123 "(allowed values: falloc, truncate)",
124 .def_value_str = "falloc",
125 },
126 { /* end of list */ },
127 },
128 };
129
130
131 static int64_t bat2sect(BDRVParallelsState *s, uint32_t idx)
132 {
133 return (uint64_t)le32_to_cpu(s->bat_bitmap[idx]) * s->off_multiplier;
134 }
135
136 static uint32_t bat_entry_off(uint32_t idx)
137 {
138 return sizeof(ParallelsHeader) + sizeof(uint32_t) * idx;
139 }
140
141 static int64_t seek_to_sector(BDRVParallelsState *s, int64_t sector_num)
142 {
143 uint32_t index, offset;
144
145 index = sector_num / s->tracks;
146 offset = sector_num % s->tracks;
147
148 /* not allocated */
149 if ((index >= s->bat_size) || (s->bat_bitmap[index] == 0)) {
150 return -1;
151 }
152 return bat2sect(s, index) + offset;
153 }
154
155 static int cluster_remainder(BDRVParallelsState *s, int64_t sector_num,
156 int nb_sectors)
157 {
158 int ret = s->tracks - sector_num % s->tracks;
159 return MIN(nb_sectors, ret);
160 }
161
162 static int64_t block_status(BDRVParallelsState *s, int64_t sector_num,
163 int nb_sectors, int *pnum)
164 {
165 int64_t start_off = -2, prev_end_off = -2;
166
167 *pnum = 0;
168 while (nb_sectors > 0 || start_off == -2) {
169 int64_t offset = seek_to_sector(s, sector_num);
170 int to_end;
171
172 if (start_off == -2) {
173 start_off = offset;
174 prev_end_off = offset;
175 } else if (offset != prev_end_off) {
176 break;
177 }
178
179 to_end = cluster_remainder(s, sector_num, nb_sectors);
180 nb_sectors -= to_end;
181 sector_num += to_end;
182 *pnum += to_end;
183
184 if (offset > 0) {
185 prev_end_off += to_end;
186 }
187 }
188 return start_off;
189 }
190
191 static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
192 int nb_sectors, int *pnum)
193 {
194 BDRVParallelsState *s = bs->opaque;
195 int64_t pos, space, idx, to_allocate, i;
196
197 pos = block_status(s, sector_num, nb_sectors, pnum);
198 if (pos > 0) {
199 return pos;
200 }
201
202 idx = sector_num / s->tracks;
203 to_allocate = DIV_ROUND_UP(sector_num + *pnum, s->tracks) - idx;
204
205 /* This function is called only by parallels_co_writev(), which will never
206 * pass a sector_num at or beyond the end of the image (because the block
207 * layer never passes such a sector_num to that function). Therefore, idx
208 * is always below s->bat_size.
209 * block_status() will limit *pnum so that sector_num + *pnum will not
210 * exceed the image end. Therefore, idx + to_allocate cannot exceed
211 * s->bat_size.
212 * Note that s->bat_size is an unsigned int, therefore idx + to_allocate
213 * will always fit into a uint32_t. */
214 assert(idx < s->bat_size && idx + to_allocate <= s->bat_size);
215
216 space = to_allocate * s->tracks;
217 if (s->data_end + space > bdrv_getlength(bs->file->bs) >> BDRV_SECTOR_BITS) {
218 int ret;
219 space += s->prealloc_size;
220 if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {
221 ret = bdrv_pwrite_zeroes(bs->file,
222 s->data_end << BDRV_SECTOR_BITS,
223 space << BDRV_SECTOR_BITS, 0);
224 } else {
225 ret = bdrv_truncate(bs->file,
226 (s->data_end + space) << BDRV_SECTOR_BITS);
227 }
228 if (ret < 0) {
229 return ret;
230 }
231 }
232
233 for (i = 0; i < to_allocate; i++) {
234 s->bat_bitmap[idx + i] = cpu_to_le32(s->data_end / s->off_multiplier);
235 s->data_end += s->tracks;
236 bitmap_set(s->bat_dirty_bmap,
237 bat_entry_off(idx + i) / s->bat_dirty_block, 1);
238 }
239
240 return bat2sect(s, idx) + sector_num % s->tracks;
241 }
242
243
244 static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
245 {
246 BDRVParallelsState *s = bs->opaque;
247 unsigned long size = DIV_ROUND_UP(s->header_size, s->bat_dirty_block);
248 unsigned long bit;
249
250 qemu_co_mutex_lock(&s->lock);
251
252 bit = find_first_bit(s->bat_dirty_bmap, size);
253 while (bit < size) {
254 uint32_t off = bit * s->bat_dirty_block;
255 uint32_t to_write = s->bat_dirty_block;
256 int ret;
257
258 if (off + to_write > s->header_size) {
259 to_write = s->header_size - off;
260 }
261 ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off,
262 to_write);
263 if (ret < 0) {
264 qemu_co_mutex_unlock(&s->lock);
265 return ret;
266 }
267 bit = find_next_bit(s->bat_dirty_bmap, size, bit + 1);
268 }
269 bitmap_zero(s->bat_dirty_bmap, size);
270
271 qemu_co_mutex_unlock(&s->lock);
272 return 0;
273 }
274
275
276 static int64_t coroutine_fn parallels_co_get_block_status(BlockDriverState *bs,
277 int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
278 {
279 BDRVParallelsState *s = bs->opaque;
280 int64_t offset;
281
282 qemu_co_mutex_lock(&s->lock);
283 offset = block_status(s, sector_num, nb_sectors, pnum);
284 qemu_co_mutex_unlock(&s->lock);
285
286 if (offset < 0) {
287 return 0;
288 }
289
290 *file = bs->file->bs;
291 return (offset << BDRV_SECTOR_BITS) |
292 BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
293 }
294
295 static coroutine_fn int parallels_co_writev(BlockDriverState *bs,
296 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
297 {
298 BDRVParallelsState *s = bs->opaque;
299 uint64_t bytes_done = 0;
300 QEMUIOVector hd_qiov;
301 int ret = 0;
302
303 qemu_iovec_init(&hd_qiov, qiov->niov);
304
305 while (nb_sectors > 0) {
306 int64_t position;
307 int n, nbytes;
308
309 qemu_co_mutex_lock(&s->lock);
310 position = allocate_clusters(bs, sector_num, nb_sectors, &n);
311 qemu_co_mutex_unlock(&s->lock);
312 if (position < 0) {
313 ret = (int)position;
314 break;
315 }
316
317 nbytes = n << BDRV_SECTOR_BITS;
318
319 qemu_iovec_reset(&hd_qiov);
320 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);
321
322 ret = bdrv_co_writev(bs->file, position, n, &hd_qiov);
323 if (ret < 0) {
324 break;
325 }
326
327 nb_sectors -= n;
328 sector_num += n;
329 bytes_done += nbytes;
330 }
331
332 qemu_iovec_destroy(&hd_qiov);
333 return ret;
334 }
335
336 static coroutine_fn int parallels_co_readv(BlockDriverState *bs,
337 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
338 {
339 BDRVParallelsState *s = bs->opaque;
340 uint64_t bytes_done = 0;
341 QEMUIOVector hd_qiov;
342 int ret = 0;
343
344 qemu_iovec_init(&hd_qiov, qiov->niov);
345
346 while (nb_sectors > 0) {
347 int64_t position;
348 int n, nbytes;
349
350 qemu_co_mutex_lock(&s->lock);
351 position = block_status(s, sector_num, nb_sectors, &n);
352 qemu_co_mutex_unlock(&s->lock);
353
354 nbytes = n << BDRV_SECTOR_BITS;
355
356 if (position < 0) {
357 qemu_iovec_memset(qiov, bytes_done, 0, nbytes);
358 } else {
359 qemu_iovec_reset(&hd_qiov);
360 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);
361
362 ret = bdrv_co_readv(bs->file, position, n, &hd_qiov);
363 if (ret < 0) {
364 break;
365 }
366 }
367
368 nb_sectors -= n;
369 sector_num += n;
370 bytes_done += nbytes;
371 }
372
373 qemu_iovec_destroy(&hd_qiov);
374 return ret;
375 }
376
377
378 static int parallels_check(BlockDriverState *bs, BdrvCheckResult *res,
379 BdrvCheckMode fix)
380 {
381 BDRVParallelsState *s = bs->opaque;
382 int64_t size, prev_off, high_off;
383 int ret;
384 uint32_t i;
385 bool flush_bat = false;
386 int cluster_size = s->tracks << BDRV_SECTOR_BITS;
387
388 size = bdrv_getlength(bs->file->bs);
389 if (size < 0) {
390 res->check_errors++;
391 return size;
392 }
393
394 if (s->header_unclean) {
395 fprintf(stderr, "%s image was not closed correctly\n",
396 fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR");
397 res->corruptions++;
398 if (fix & BDRV_FIX_ERRORS) {
399 /* parallels_close will do the job right */
400 res->corruptions_fixed++;
401 s->header_unclean = false;
402 }
403 }
404
405 res->bfi.total_clusters = s->bat_size;
406 res->bfi.compressed_clusters = 0; /* compression is not supported */
407
408 high_off = 0;
409 prev_off = 0;
410 for (i = 0; i < s->bat_size; i++) {
411 int64_t off = bat2sect(s, i) << BDRV_SECTOR_BITS;
412 if (off == 0) {
413 prev_off = 0;
414 continue;
415 }
416
417 /* cluster outside the image */
418 if (off > size) {
419 fprintf(stderr, "%s cluster %u is outside image\n",
420 fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);
421 res->corruptions++;
422 if (fix & BDRV_FIX_ERRORS) {
423 prev_off = 0;
424 s->bat_bitmap[i] = 0;
425 res->corruptions_fixed++;
426 flush_bat = true;
427 continue;
428 }
429 }
430
431 res->bfi.allocated_clusters++;
432 if (off > high_off) {
433 high_off = off;
434 }
435
436 if (prev_off != 0 && (prev_off + cluster_size) != off) {
437 res->bfi.fragmented_clusters++;
438 }
439 prev_off = off;
440 }
441
442 if (flush_bat) {
443 ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size);
444 if (ret < 0) {
445 res->check_errors++;
446 return ret;
447 }
448 }
449
450 res->image_end_offset = high_off + cluster_size;
451 if (size > res->image_end_offset) {
452 int64_t count;
453 count = DIV_ROUND_UP(size - res->image_end_offset, cluster_size);
454 fprintf(stderr, "%s space leaked at the end of the image %" PRId64 "\n",
455 fix & BDRV_FIX_LEAKS ? "Repairing" : "ERROR",
456 size - res->image_end_offset);
457 res->leaks += count;
458 if (fix & BDRV_FIX_LEAKS) {
459 ret = bdrv_truncate(bs->file, res->image_end_offset);
460 if (ret < 0) {
461 res->check_errors++;
462 return ret;
463 }
464 res->leaks_fixed += count;
465 }
466 }
467
468 return 0;
469 }
470
471
472 static int parallels_create(const char *filename, QemuOpts *opts, Error **errp)
473 {
474 int64_t total_size, cl_size;
475 uint8_t tmp[BDRV_SECTOR_SIZE];
476 Error *local_err = NULL;
477 BlockBackend *file;
478 uint32_t bat_entries, bat_sectors;
479 ParallelsHeader header;
480 int ret;
481
482 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
483 BDRV_SECTOR_SIZE);
484 cl_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
485 DEFAULT_CLUSTER_SIZE), BDRV_SECTOR_SIZE);
486 if (total_size >= MAX_PARALLELS_IMAGE_FACTOR * cl_size) {
487 error_propagate(errp, local_err);
488 return -E2BIG;
489 }
490
491 ret = bdrv_create_file(filename, opts, &local_err);
492 if (ret < 0) {
493 error_propagate(errp, local_err);
494 return ret;
495 }
496
497 file = blk_new_open(filename, NULL, NULL,
498 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
499 &local_err);
500 if (file == NULL) {
501 error_propagate(errp, local_err);
502 return -EIO;
503 }
504
505 blk_set_allow_write_beyond_eof(file, true);
506
507 ret = blk_truncate(file, 0);
508 if (ret < 0) {
509 goto exit;
510 }
511
512 bat_entries = DIV_ROUND_UP(total_size, cl_size);
513 bat_sectors = DIV_ROUND_UP(bat_entry_off(bat_entries), cl_size);
514 bat_sectors = (bat_sectors * cl_size) >> BDRV_SECTOR_BITS;
515
516 memset(&header, 0, sizeof(header));
517 memcpy(header.magic, HEADER_MAGIC2, sizeof(header.magic));
518 header.version = cpu_to_le32(HEADER_VERSION);
519 /* don't care much about geometry, it is not used on image level */
520 header.heads = cpu_to_le32(16);
521 header.cylinders = cpu_to_le32(total_size / BDRV_SECTOR_SIZE / 16 / 32);
522 header.tracks = cpu_to_le32(cl_size >> BDRV_SECTOR_BITS);
523 header.bat_entries = cpu_to_le32(bat_entries);
524 header.nb_sectors = cpu_to_le64(DIV_ROUND_UP(total_size, BDRV_SECTOR_SIZE));
525 header.data_off = cpu_to_le32(bat_sectors);
526
527 /* write all the data */
528 memset(tmp, 0, sizeof(tmp));
529 memcpy(tmp, &header, sizeof(header));
530
531 ret = blk_pwrite(file, 0, tmp, BDRV_SECTOR_SIZE, 0);
532 if (ret < 0) {
533 goto exit;
534 }
535 ret = blk_pwrite_zeroes(file, BDRV_SECTOR_SIZE,
536 (bat_sectors - 1) << BDRV_SECTOR_BITS, 0);
537 if (ret < 0) {
538 goto exit;
539 }
540 ret = 0;
541
542 done:
543 blk_unref(file);
544 return ret;
545
546 exit:
547 error_setg_errno(errp, -ret, "Failed to create Parallels image");
548 goto done;
549 }
550
551
552 static int parallels_probe(const uint8_t *buf, int buf_size,
553 const char *filename)
554 {
555 const ParallelsHeader *ph = (const void *)buf;
556
557 if (buf_size < sizeof(ParallelsHeader)) {
558 return 0;
559 }
560
561 if ((!memcmp(ph->magic, HEADER_MAGIC, 16) ||
562 !memcmp(ph->magic, HEADER_MAGIC2, 16)) &&
563 (le32_to_cpu(ph->version) == HEADER_VERSION)) {
564 return 100;
565 }
566
567 return 0;
568 }
569
570 static int parallels_update_header(BlockDriverState *bs)
571 {
572 BDRVParallelsState *s = bs->opaque;
573 unsigned size = MAX(bdrv_opt_mem_align(bs->file->bs),
574 sizeof(ParallelsHeader));
575
576 if (size > s->header_size) {
577 size = s->header_size;
578 }
579 return bdrv_pwrite_sync(bs->file, 0, s->header, size);
580 }
581
582 static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
583 Error **errp)
584 {
585 BDRVParallelsState *s = bs->opaque;
586 ParallelsHeader ph;
587 int ret, size, i;
588 QemuOpts *opts = NULL;
589 Error *local_err = NULL;
590 char *buf;
591
592 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
593 false, errp);
594 if (!bs->file) {
595 return -EINVAL;
596 }
597
598 ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));
599 if (ret < 0) {
600 goto fail;
601 }
602
603 bs->total_sectors = le64_to_cpu(ph.nb_sectors);
604
605 if (le32_to_cpu(ph.version) != HEADER_VERSION) {
606 goto fail_format;
607 }
608 if (!memcmp(ph.magic, HEADER_MAGIC, 16)) {
609 s->off_multiplier = 1;
610 bs->total_sectors = 0xffffffff & bs->total_sectors;
611 } else if (!memcmp(ph.magic, HEADER_MAGIC2, 16)) {
612 s->off_multiplier = le32_to_cpu(ph.tracks);
613 } else {
614 goto fail_format;
615 }
616
617 s->tracks = le32_to_cpu(ph.tracks);
618 if (s->tracks == 0) {
619 error_setg(errp, "Invalid image: Zero sectors per track");
620 ret = -EINVAL;
621 goto fail;
622 }
623 if (s->tracks > INT32_MAX/513) {
624 error_setg(errp, "Invalid image: Too big cluster");
625 ret = -EFBIG;
626 goto fail;
627 }
628
629 s->bat_size = le32_to_cpu(ph.bat_entries);
630 if (s->bat_size > INT_MAX / sizeof(uint32_t)) {
631 error_setg(errp, "Catalog too large");
632 ret = -EFBIG;
633 goto fail;
634 }
635
636 size = bat_entry_off(s->bat_size);
637 s->header_size = ROUND_UP(size, bdrv_opt_mem_align(bs->file->bs));
638 s->header = qemu_try_blockalign(bs->file->bs, s->header_size);
639 if (s->header == NULL) {
640 ret = -ENOMEM;
641 goto fail;
642 }
643 s->data_end = le32_to_cpu(ph.data_off);
644 if (s->data_end == 0) {
645 s->data_end = ROUND_UP(bat_entry_off(s->bat_size), BDRV_SECTOR_SIZE);
646 }
647 if (s->data_end < s->header_size) {
648 /* there is not enough unused space to fit to block align between BAT
649 and actual data. We can't avoid read-modify-write... */
650 s->header_size = size;
651 }
652
653 ret = bdrv_pread(bs->file, 0, s->header, s->header_size);
654 if (ret < 0) {
655 goto fail;
656 }
657 s->bat_bitmap = (uint32_t *)(s->header + 1);
658
659 for (i = 0; i < s->bat_size; i++) {
660 int64_t off = bat2sect(s, i);
661 if (off >= s->data_end) {
662 s->data_end = off + s->tracks;
663 }
664 }
665
666 if (le32_to_cpu(ph.inuse) == HEADER_INUSE_MAGIC) {
667 /* Image was not closed correctly. The check is mandatory */
668 s->header_unclean = true;
669 if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
670 error_setg(errp, "parallels: Image was not closed correctly; "
671 "cannot be opened read/write");
672 ret = -EACCES;
673 goto fail;
674 }
675 }
676
677 opts = qemu_opts_create(&parallels_runtime_opts, NULL, 0, &local_err);
678 if (local_err != NULL) {
679 goto fail_options;
680 }
681
682 qemu_opts_absorb_qdict(opts, options, &local_err);
683 if (local_err != NULL) {
684 goto fail_options;
685 }
686
687 s->prealloc_size =
688 qemu_opt_get_size_del(opts, PARALLELS_OPT_PREALLOC_SIZE, 0);
689 s->prealloc_size = MAX(s->tracks, s->prealloc_size >> BDRV_SECTOR_BITS);
690 buf = qemu_opt_get_del(opts, PARALLELS_OPT_PREALLOC_MODE);
691 s->prealloc_mode = qapi_enum_parse(prealloc_mode_lookup, buf,
692 PRL_PREALLOC_MODE__MAX, PRL_PREALLOC_MODE_FALLOCATE, &local_err);
693 g_free(buf);
694 if (local_err != NULL) {
695 goto fail_options;
696 }
697
698 if (!(flags & BDRV_O_RESIZE) || !bdrv_has_zero_init(bs->file->bs) ||
699 bdrv_truncate(bs->file, bdrv_getlength(bs->file->bs)) != 0) {
700 s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
701 }
702
703 if (flags & BDRV_O_RDWR) {
704 s->header->inuse = cpu_to_le32(HEADER_INUSE_MAGIC);
705 ret = parallels_update_header(bs);
706 if (ret < 0) {
707 goto fail;
708 }
709 }
710
711 s->bat_dirty_block = 4 * getpagesize();
712 s->bat_dirty_bmap =
713 bitmap_new(DIV_ROUND_UP(s->header_size, s->bat_dirty_block));
714
715 qemu_co_mutex_init(&s->lock);
716 return 0;
717
718 fail_format:
719 error_setg(errp, "Image not in Parallels format");
720 ret = -EINVAL;
721 fail:
722 qemu_vfree(s->header);
723 return ret;
724
725 fail_options:
726 error_propagate(errp, local_err);
727 ret = -EINVAL;
728 goto fail;
729 }
730
731
732 static void parallels_close(BlockDriverState *bs)
733 {
734 BDRVParallelsState *s = bs->opaque;
735
736 if (bs->open_flags & BDRV_O_RDWR) {
737 s->header->inuse = 0;
738 parallels_update_header(bs);
739 }
740
741 if (bs->open_flags & BDRV_O_RDWR) {
742 bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS);
743 }
744
745 g_free(s->bat_dirty_bmap);
746 qemu_vfree(s->header);
747 }
748
749 static QemuOptsList parallels_create_opts = {
750 .name = "parallels-create-opts",
751 .head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head),
752 .desc = {
753 {
754 .name = BLOCK_OPT_SIZE,
755 .type = QEMU_OPT_SIZE,
756 .help = "Virtual disk size",
757 },
758 {
759 .name = BLOCK_OPT_CLUSTER_SIZE,
760 .type = QEMU_OPT_SIZE,
761 .help = "Parallels image cluster size",
762 .def_value_str = stringify(DEFAULT_CLUSTER_SIZE),
763 },
764 { /* end of list */ }
765 }
766 };
767
768 static BlockDriver bdrv_parallels = {
769 .format_name = "parallels",
770 .instance_size = sizeof(BDRVParallelsState),
771 .bdrv_probe = parallels_probe,
772 .bdrv_open = parallels_open,
773 .bdrv_close = parallels_close,
774 .bdrv_child_perm = bdrv_format_default_perms,
775 .bdrv_co_get_block_status = parallels_co_get_block_status,
776 .bdrv_has_zero_init = bdrv_has_zero_init_1,
777 .bdrv_co_flush_to_os = parallels_co_flush_to_os,
778 .bdrv_co_readv = parallels_co_readv,
779 .bdrv_co_writev = parallels_co_writev,
780
781 .bdrv_create = parallels_create,
782 .bdrv_check = parallels_check,
783 .create_opts = &parallels_create_opts,
784 };
785
786 static void bdrv_parallels_init(void)
787 {
788 bdrv_register(&bdrv_parallels);
789 }
790
791 block_init(bdrv_parallels_init);