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 | |
31 | #include "qemu/osdep.h" |
32 | #include "qapi/error.h" |
33 | #include "block/block_int.h" |
34 | #include "block/qdict.h" |
35 | #include "sysemu/block-backend.h" |
36 | #include "qemu/module.h" |
37 | #include "qemu/option.h" |
38 | #include "qapi/qmp/qdict.h" |
39 | #include "qapi/qobject-input-visitor.h" |
40 | #include "qapi/qapi-visit-block-core.h" |
41 | #include "qemu/bswap.h" |
42 | #include "qemu/bitmap.h" |
43 | #include "migration/blocker.h" |
44 | #include "parallels.h" |
45 | |
46 | /**************************************************************/ |
47 | |
48 | #define "WithoutFreeSpace" |
49 | #define "WithouFreSpacExt" |
50 | #define 2 |
51 | #define (0x746F6E59) |
52 | #define MAX_PARALLELS_IMAGE_FACTOR (1ull << 32) |
53 | |
54 | static QEnumLookup prealloc_mode_lookup = { |
55 | .array = (const char *const[]) { |
56 | "falloc" , |
57 | "truncate" , |
58 | }, |
59 | .size = PRL_PREALLOC_MODE__MAX |
60 | }; |
61 | |
62 | #define PARALLELS_OPT_PREALLOC_MODE "prealloc-mode" |
63 | #define PARALLELS_OPT_PREALLOC_SIZE "prealloc-size" |
64 | |
65 | static QemuOptsList parallels_runtime_opts = { |
66 | .name = "parallels" , |
67 | .head = QTAILQ_HEAD_INITIALIZER(parallels_runtime_opts.head), |
68 | .desc = { |
69 | { |
70 | .name = PARALLELS_OPT_PREALLOC_SIZE, |
71 | .type = QEMU_OPT_SIZE, |
72 | .help = "Preallocation size on image expansion" , |
73 | .def_value_str = "128M" , |
74 | }, |
75 | { |
76 | .name = PARALLELS_OPT_PREALLOC_MODE, |
77 | .type = QEMU_OPT_STRING, |
78 | .help = "Preallocation mode on image expansion " |
79 | "(allowed values: falloc, truncate)" , |
80 | .def_value_str = "falloc" , |
81 | }, |
82 | { /* end of list */ }, |
83 | }, |
84 | }; |
85 | |
86 | static QemuOptsList parallels_create_opts = { |
87 | .name = "parallels-create-opts" , |
88 | .head = QTAILQ_HEAD_INITIALIZER(parallels_create_opts.head), |
89 | .desc = { |
90 | { |
91 | .name = BLOCK_OPT_SIZE, |
92 | .type = QEMU_OPT_SIZE, |
93 | .help = "Virtual disk size" , |
94 | }, |
95 | { |
96 | .name = BLOCK_OPT_CLUSTER_SIZE, |
97 | .type = QEMU_OPT_SIZE, |
98 | .help = "Parallels image cluster size" , |
99 | .def_value_str = stringify(DEFAULT_CLUSTER_SIZE), |
100 | }, |
101 | { /* end of list */ } |
102 | } |
103 | }; |
104 | |
105 | |
106 | static int64_t bat2sect(BDRVParallelsState *s, uint32_t idx) |
107 | { |
108 | return (uint64_t)le32_to_cpu(s->bat_bitmap[idx]) * s->off_multiplier; |
109 | } |
110 | |
111 | static uint32_t bat_entry_off(uint32_t idx) |
112 | { |
113 | return sizeof(ParallelsHeader) + sizeof(uint32_t) * idx; |
114 | } |
115 | |
116 | static int64_t seek_to_sector(BDRVParallelsState *s, int64_t sector_num) |
117 | { |
118 | uint32_t index, offset; |
119 | |
120 | index = sector_num / s->tracks; |
121 | offset = sector_num % s->tracks; |
122 | |
123 | /* not allocated */ |
124 | if ((index >= s->bat_size) || (s->bat_bitmap[index] == 0)) { |
125 | return -1; |
126 | } |
127 | return bat2sect(s, index) + offset; |
128 | } |
129 | |
130 | static int cluster_remainder(BDRVParallelsState *s, int64_t sector_num, |
131 | int nb_sectors) |
132 | { |
133 | int ret = s->tracks - sector_num % s->tracks; |
134 | return MIN(nb_sectors, ret); |
135 | } |
136 | |
137 | static int64_t block_status(BDRVParallelsState *s, int64_t sector_num, |
138 | int nb_sectors, int *pnum) |
139 | { |
140 | int64_t start_off = -2, prev_end_off = -2; |
141 | |
142 | *pnum = 0; |
143 | while (nb_sectors > 0 || start_off == -2) { |
144 | int64_t offset = seek_to_sector(s, sector_num); |
145 | int to_end; |
146 | |
147 | if (start_off == -2) { |
148 | start_off = offset; |
149 | prev_end_off = offset; |
150 | } else if (offset != prev_end_off) { |
151 | break; |
152 | } |
153 | |
154 | to_end = cluster_remainder(s, sector_num, nb_sectors); |
155 | nb_sectors -= to_end; |
156 | sector_num += to_end; |
157 | *pnum += to_end; |
158 | |
159 | if (offset > 0) { |
160 | prev_end_off += to_end; |
161 | } |
162 | } |
163 | return start_off; |
164 | } |
165 | |
166 | static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, |
167 | int nb_sectors, int *pnum) |
168 | { |
169 | int ret; |
170 | BDRVParallelsState *s = bs->opaque; |
171 | int64_t pos, space, idx, to_allocate, i, len; |
172 | |
173 | pos = block_status(s, sector_num, nb_sectors, pnum); |
174 | if (pos > 0) { |
175 | return pos; |
176 | } |
177 | |
178 | idx = sector_num / s->tracks; |
179 | to_allocate = DIV_ROUND_UP(sector_num + *pnum, s->tracks) - idx; |
180 | |
181 | /* This function is called only by parallels_co_writev(), which will never |
182 | * pass a sector_num at or beyond the end of the image (because the block |
183 | * layer never passes such a sector_num to that function). Therefore, idx |
184 | * is always below s->bat_size. |
185 | * block_status() will limit *pnum so that sector_num + *pnum will not |
186 | * exceed the image end. Therefore, idx + to_allocate cannot exceed |
187 | * s->bat_size. |
188 | * Note that s->bat_size is an unsigned int, therefore idx + to_allocate |
189 | * will always fit into a uint32_t. */ |
190 | assert(idx < s->bat_size && idx + to_allocate <= s->bat_size); |
191 | |
192 | space = to_allocate * s->tracks; |
193 | len = bdrv_getlength(bs->file->bs); |
194 | if (len < 0) { |
195 | return len; |
196 | } |
197 | if (s->data_end + space > (len >> BDRV_SECTOR_BITS)) { |
198 | space += s->prealloc_size; |
199 | if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) { |
200 | ret = bdrv_pwrite_zeroes(bs->file, |
201 | s->data_end << BDRV_SECTOR_BITS, |
202 | space << BDRV_SECTOR_BITS, 0); |
203 | } else { |
204 | ret = bdrv_truncate(bs->file, |
205 | (s->data_end + space) << BDRV_SECTOR_BITS, |
206 | PREALLOC_MODE_OFF, NULL); |
207 | } |
208 | if (ret < 0) { |
209 | return ret; |
210 | } |
211 | } |
212 | |
213 | /* Try to read from backing to fill empty clusters |
214 | * FIXME: 1. previous write_zeroes may be redundant |
215 | * 2. most of data we read from backing will be rewritten by |
216 | * parallels_co_writev. On aligned-to-cluster write we do not need |
217 | * this read at all. |
218 | * 3. it would be good to combine write of data from backing and new |
219 | * data into one write call */ |
220 | if (bs->backing) { |
221 | int64_t nb_cow_sectors = to_allocate * s->tracks; |
222 | int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS; |
223 | void *buf = qemu_blockalign(bs, nb_cow_bytes); |
224 | |
225 | ret = bdrv_co_pread(bs->backing, idx * s->tracks * BDRV_SECTOR_SIZE, |
226 | nb_cow_bytes, buf, 0); |
227 | if (ret < 0) { |
228 | qemu_vfree(buf); |
229 | return ret; |
230 | } |
231 | |
232 | ret = bdrv_co_pwritev(bs->file, s->data_end * BDRV_SECTOR_SIZE, |
233 | nb_cow_bytes, buf, 0); |
234 | qemu_vfree(buf); |
235 | if (ret < 0) { |
236 | return ret; |
237 | } |
238 | } |
239 | |
240 | for (i = 0; i < to_allocate; i++) { |
241 | s->bat_bitmap[idx + i] = cpu_to_le32(s->data_end / s->off_multiplier); |
242 | s->data_end += s->tracks; |
243 | bitmap_set(s->bat_dirty_bmap, |
244 | bat_entry_off(idx + i) / s->bat_dirty_block, 1); |
245 | } |
246 | |
247 | return bat2sect(s, idx) + sector_num % s->tracks; |
248 | } |
249 | |
250 | |
251 | static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs) |
252 | { |
253 | BDRVParallelsState *s = bs->opaque; |
254 | unsigned long size = DIV_ROUND_UP(s->header_size, s->bat_dirty_block); |
255 | unsigned long bit; |
256 | |
257 | qemu_co_mutex_lock(&s->lock); |
258 | |
259 | bit = find_first_bit(s->bat_dirty_bmap, size); |
260 | while (bit < size) { |
261 | uint32_t off = bit * s->bat_dirty_block; |
262 | uint32_t to_write = s->bat_dirty_block; |
263 | int ret; |
264 | |
265 | if (off + to_write > s->header_size) { |
266 | to_write = s->header_size - off; |
267 | } |
268 | ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off, |
269 | to_write); |
270 | if (ret < 0) { |
271 | qemu_co_mutex_unlock(&s->lock); |
272 | return ret; |
273 | } |
274 | bit = find_next_bit(s->bat_dirty_bmap, size, bit + 1); |
275 | } |
276 | bitmap_zero(s->bat_dirty_bmap, size); |
277 | |
278 | qemu_co_mutex_unlock(&s->lock); |
279 | return 0; |
280 | } |
281 | |
282 | |
283 | static int coroutine_fn parallels_co_block_status(BlockDriverState *bs, |
284 | bool want_zero, |
285 | int64_t offset, |
286 | int64_t bytes, |
287 | int64_t *pnum, |
288 | int64_t *map, |
289 | BlockDriverState **file) |
290 | { |
291 | BDRVParallelsState *s = bs->opaque; |
292 | int count; |
293 | |
294 | assert(QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE)); |
295 | qemu_co_mutex_lock(&s->lock); |
296 | offset = block_status(s, offset >> BDRV_SECTOR_BITS, |
297 | bytes >> BDRV_SECTOR_BITS, &count); |
298 | qemu_co_mutex_unlock(&s->lock); |
299 | |
300 | *pnum = count * BDRV_SECTOR_SIZE; |
301 | if (offset < 0) { |
302 | return 0; |
303 | } |
304 | |
305 | *map = offset * BDRV_SECTOR_SIZE; |
306 | *file = bs->file->bs; |
307 | return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID; |
308 | } |
309 | |
310 | static coroutine_fn int parallels_co_writev(BlockDriverState *bs, |
311 | int64_t sector_num, int nb_sectors, |
312 | QEMUIOVector *qiov, int flags) |
313 | { |
314 | BDRVParallelsState *s = bs->opaque; |
315 | uint64_t bytes_done = 0; |
316 | QEMUIOVector hd_qiov; |
317 | int ret = 0; |
318 | |
319 | assert(!flags); |
320 | qemu_iovec_init(&hd_qiov, qiov->niov); |
321 | |
322 | while (nb_sectors > 0) { |
323 | int64_t position; |
324 | int n, nbytes; |
325 | |
326 | qemu_co_mutex_lock(&s->lock); |
327 | position = allocate_clusters(bs, sector_num, nb_sectors, &n); |
328 | qemu_co_mutex_unlock(&s->lock); |
329 | if (position < 0) { |
330 | ret = (int)position; |
331 | break; |
332 | } |
333 | |
334 | nbytes = n << BDRV_SECTOR_BITS; |
335 | |
336 | qemu_iovec_reset(&hd_qiov); |
337 | qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes); |
338 | |
339 | ret = bdrv_co_pwritev(bs->file, position * BDRV_SECTOR_SIZE, nbytes, |
340 | &hd_qiov, 0); |
341 | if (ret < 0) { |
342 | break; |
343 | } |
344 | |
345 | nb_sectors -= n; |
346 | sector_num += n; |
347 | bytes_done += nbytes; |
348 | } |
349 | |
350 | qemu_iovec_destroy(&hd_qiov); |
351 | return ret; |
352 | } |
353 | |
354 | static coroutine_fn int parallels_co_readv(BlockDriverState *bs, |
355 | int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) |
356 | { |
357 | BDRVParallelsState *s = bs->opaque; |
358 | uint64_t bytes_done = 0; |
359 | QEMUIOVector hd_qiov; |
360 | int ret = 0; |
361 | |
362 | qemu_iovec_init(&hd_qiov, qiov->niov); |
363 | |
364 | while (nb_sectors > 0) { |
365 | int64_t position; |
366 | int n, nbytes; |
367 | |
368 | qemu_co_mutex_lock(&s->lock); |
369 | position = block_status(s, sector_num, nb_sectors, &n); |
370 | qemu_co_mutex_unlock(&s->lock); |
371 | |
372 | nbytes = n << BDRV_SECTOR_BITS; |
373 | |
374 | qemu_iovec_reset(&hd_qiov); |
375 | qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes); |
376 | |
377 | if (position < 0) { |
378 | if (bs->backing) { |
379 | ret = bdrv_co_preadv(bs->backing, sector_num * BDRV_SECTOR_SIZE, |
380 | nbytes, &hd_qiov, 0); |
381 | if (ret < 0) { |
382 | break; |
383 | } |
384 | } else { |
385 | qemu_iovec_memset(&hd_qiov, 0, 0, nbytes); |
386 | } |
387 | } else { |
388 | ret = bdrv_co_preadv(bs->file, position * BDRV_SECTOR_SIZE, nbytes, |
389 | &hd_qiov, 0); |
390 | if (ret < 0) { |
391 | break; |
392 | } |
393 | } |
394 | |
395 | nb_sectors -= n; |
396 | sector_num += n; |
397 | bytes_done += nbytes; |
398 | } |
399 | |
400 | qemu_iovec_destroy(&hd_qiov); |
401 | return ret; |
402 | } |
403 | |
404 | |
405 | static int coroutine_fn parallels_co_check(BlockDriverState *bs, |
406 | BdrvCheckResult *res, |
407 | BdrvCheckMode fix) |
408 | { |
409 | BDRVParallelsState *s = bs->opaque; |
410 | int64_t size, prev_off, high_off; |
411 | int ret; |
412 | uint32_t i; |
413 | bool flush_bat = false; |
414 | int cluster_size = s->tracks << BDRV_SECTOR_BITS; |
415 | |
416 | size = bdrv_getlength(bs->file->bs); |
417 | if (size < 0) { |
418 | res->check_errors++; |
419 | return size; |
420 | } |
421 | |
422 | qemu_co_mutex_lock(&s->lock); |
423 | if (s->header_unclean) { |
424 | fprintf(stderr, "%s image was not closed correctly\n" , |
425 | fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR" ); |
426 | res->corruptions++; |
427 | if (fix & BDRV_FIX_ERRORS) { |
428 | /* parallels_close will do the job right */ |
429 | res->corruptions_fixed++; |
430 | s->header_unclean = false; |
431 | } |
432 | } |
433 | |
434 | res->bfi.total_clusters = s->bat_size; |
435 | res->bfi.compressed_clusters = 0; /* compression is not supported */ |
436 | |
437 | high_off = 0; |
438 | prev_off = 0; |
439 | for (i = 0; i < s->bat_size; i++) { |
440 | int64_t off = bat2sect(s, i) << BDRV_SECTOR_BITS; |
441 | if (off == 0) { |
442 | prev_off = 0; |
443 | continue; |
444 | } |
445 | |
446 | /* cluster outside the image */ |
447 | if (off > size) { |
448 | fprintf(stderr, "%s cluster %u is outside image\n" , |
449 | fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR" , i); |
450 | res->corruptions++; |
451 | if (fix & BDRV_FIX_ERRORS) { |
452 | prev_off = 0; |
453 | s->bat_bitmap[i] = 0; |
454 | res->corruptions_fixed++; |
455 | flush_bat = true; |
456 | continue; |
457 | } |
458 | } |
459 | |
460 | res->bfi.allocated_clusters++; |
461 | if (off > high_off) { |
462 | high_off = off; |
463 | } |
464 | |
465 | if (prev_off != 0 && (prev_off + cluster_size) != off) { |
466 | res->bfi.fragmented_clusters++; |
467 | } |
468 | prev_off = off; |
469 | } |
470 | |
471 | ret = 0; |
472 | if (flush_bat) { |
473 | ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size); |
474 | if (ret < 0) { |
475 | res->check_errors++; |
476 | goto out; |
477 | } |
478 | } |
479 | |
480 | res->image_end_offset = high_off + cluster_size; |
481 | if (size > res->image_end_offset) { |
482 | int64_t count; |
483 | count = DIV_ROUND_UP(size - res->image_end_offset, cluster_size); |
484 | fprintf(stderr, "%s space leaked at the end of the image %" PRId64 "\n" , |
485 | fix & BDRV_FIX_LEAKS ? "Repairing" : "ERROR" , |
486 | size - res->image_end_offset); |
487 | res->leaks += count; |
488 | if (fix & BDRV_FIX_LEAKS) { |
489 | Error *local_err = NULL; |
490 | ret = bdrv_truncate(bs->file, res->image_end_offset, |
491 | PREALLOC_MODE_OFF, &local_err); |
492 | if (ret < 0) { |
493 | error_report_err(local_err); |
494 | res->check_errors++; |
495 | goto out; |
496 | } |
497 | res->leaks_fixed += count; |
498 | } |
499 | } |
500 | |
501 | out: |
502 | qemu_co_mutex_unlock(&s->lock); |
503 | return ret; |
504 | } |
505 | |
506 | |
507 | static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts, |
508 | Error **errp) |
509 | { |
510 | BlockdevCreateOptionsParallels *parallels_opts; |
511 | BlockDriverState *bs; |
512 | BlockBackend *blk; |
513 | int64_t total_size, cl_size; |
514 | uint32_t bat_entries, bat_sectors; |
515 | ParallelsHeader ; |
516 | uint8_t tmp[BDRV_SECTOR_SIZE]; |
517 | int ret; |
518 | |
519 | assert(opts->driver == BLOCKDEV_DRIVER_PARALLELS); |
520 | parallels_opts = &opts->u.parallels; |
521 | |
522 | /* Sanity checks */ |
523 | total_size = parallels_opts->size; |
524 | |
525 | if (parallels_opts->has_cluster_size) { |
526 | cl_size = parallels_opts->cluster_size; |
527 | } else { |
528 | cl_size = DEFAULT_CLUSTER_SIZE; |
529 | } |
530 | |
531 | /* XXX What is the real limit here? This is an insanely large maximum. */ |
532 | if (cl_size >= INT64_MAX / MAX_PARALLELS_IMAGE_FACTOR) { |
533 | error_setg(errp, "Cluster size is too large" ); |
534 | return -EINVAL; |
535 | } |
536 | if (total_size >= MAX_PARALLELS_IMAGE_FACTOR * cl_size) { |
537 | error_setg(errp, "Image size is too large for this cluster size" ); |
538 | return -E2BIG; |
539 | } |
540 | |
541 | if (!QEMU_IS_ALIGNED(total_size, BDRV_SECTOR_SIZE)) { |
542 | error_setg(errp, "Image size must be a multiple of 512 bytes" ); |
543 | return -EINVAL; |
544 | } |
545 | |
546 | if (!QEMU_IS_ALIGNED(cl_size, BDRV_SECTOR_SIZE)) { |
547 | error_setg(errp, "Cluster size must be a multiple of 512 bytes" ); |
548 | return -EINVAL; |
549 | } |
550 | |
551 | /* Create BlockBackend to write to the image */ |
552 | bs = bdrv_open_blockdev_ref(parallels_opts->file, errp); |
553 | if (bs == NULL) { |
554 | return -EIO; |
555 | } |
556 | |
557 | blk = blk_new(bdrv_get_aio_context(bs), |
558 | BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL); |
559 | ret = blk_insert_bs(blk, bs, errp); |
560 | if (ret < 0) { |
561 | goto out; |
562 | } |
563 | blk_set_allow_write_beyond_eof(blk, true); |
564 | |
565 | /* Create image format */ |
566 | ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp); |
567 | if (ret < 0) { |
568 | goto out; |
569 | } |
570 | |
571 | bat_entries = DIV_ROUND_UP(total_size, cl_size); |
572 | bat_sectors = DIV_ROUND_UP(bat_entry_off(bat_entries), cl_size); |
573 | bat_sectors = (bat_sectors * cl_size) >> BDRV_SECTOR_BITS; |
574 | |
575 | memset(&header, 0, sizeof(header)); |
576 | memcpy(header.magic, HEADER_MAGIC2, sizeof(header.magic)); |
577 | header.version = cpu_to_le32(HEADER_VERSION); |
578 | /* don't care much about geometry, it is not used on image level */ |
579 | header.heads = cpu_to_le32(HEADS_NUMBER); |
580 | header.cylinders = cpu_to_le32(total_size / BDRV_SECTOR_SIZE |
581 | / HEADS_NUMBER / SEC_IN_CYL); |
582 | header.tracks = cpu_to_le32(cl_size >> BDRV_SECTOR_BITS); |
583 | header.bat_entries = cpu_to_le32(bat_entries); |
584 | header.nb_sectors = cpu_to_le64(DIV_ROUND_UP(total_size, BDRV_SECTOR_SIZE)); |
585 | header.data_off = cpu_to_le32(bat_sectors); |
586 | |
587 | /* write all the data */ |
588 | memset(tmp, 0, sizeof(tmp)); |
589 | memcpy(tmp, &header, sizeof(header)); |
590 | |
591 | ret = blk_pwrite(blk, 0, tmp, BDRV_SECTOR_SIZE, 0); |
592 | if (ret < 0) { |
593 | goto exit; |
594 | } |
595 | ret = blk_pwrite_zeroes(blk, BDRV_SECTOR_SIZE, |
596 | (bat_sectors - 1) << BDRV_SECTOR_BITS, 0); |
597 | if (ret < 0) { |
598 | goto exit; |
599 | } |
600 | |
601 | ret = 0; |
602 | out: |
603 | blk_unref(blk); |
604 | bdrv_unref(bs); |
605 | return ret; |
606 | |
607 | exit: |
608 | error_setg_errno(errp, -ret, "Failed to create Parallels image" ); |
609 | goto out; |
610 | } |
611 | |
612 | static int coroutine_fn parallels_co_create_opts(const char *filename, |
613 | QemuOpts *opts, |
614 | Error **errp) |
615 | { |
616 | BlockdevCreateOptions *create_options = NULL; |
617 | Error *local_err = NULL; |
618 | BlockDriverState *bs = NULL; |
619 | QDict *qdict; |
620 | Visitor *v; |
621 | int ret; |
622 | |
623 | static const QDictRenames opt_renames[] = { |
624 | { BLOCK_OPT_CLUSTER_SIZE, "cluster-size" }, |
625 | { NULL, NULL }, |
626 | }; |
627 | |
628 | /* Parse options and convert legacy syntax */ |
629 | qdict = qemu_opts_to_qdict_filtered(opts, NULL, ¶llels_create_opts, |
630 | true); |
631 | |
632 | if (!qdict_rename_keys(qdict, opt_renames, errp)) { |
633 | ret = -EINVAL; |
634 | goto done; |
635 | } |
636 | |
637 | /* Create and open the file (protocol layer) */ |
638 | ret = bdrv_create_file(filename, opts, &local_err); |
639 | if (ret < 0) { |
640 | error_propagate(errp, local_err); |
641 | goto done; |
642 | } |
643 | |
644 | bs = bdrv_open(filename, NULL, NULL, |
645 | BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp); |
646 | if (bs == NULL) { |
647 | ret = -EIO; |
648 | goto done; |
649 | } |
650 | |
651 | /* Now get the QAPI type BlockdevCreateOptions */ |
652 | qdict_put_str(qdict, "driver" , "parallels" ); |
653 | qdict_put_str(qdict, "file" , bs->node_name); |
654 | |
655 | v = qobject_input_visitor_new_flat_confused(qdict, errp); |
656 | if (!v) { |
657 | ret = -EINVAL; |
658 | goto done; |
659 | } |
660 | |
661 | visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err); |
662 | visit_free(v); |
663 | |
664 | if (local_err) { |
665 | error_propagate(errp, local_err); |
666 | ret = -EINVAL; |
667 | goto done; |
668 | } |
669 | |
670 | /* Silently round up sizes */ |
671 | create_options->u.parallels.size = |
672 | ROUND_UP(create_options->u.parallels.size, BDRV_SECTOR_SIZE); |
673 | create_options->u.parallels.cluster_size = |
674 | ROUND_UP(create_options->u.parallels.cluster_size, BDRV_SECTOR_SIZE); |
675 | |
676 | /* Create the Parallels image (format layer) */ |
677 | ret = parallels_co_create(create_options, errp); |
678 | if (ret < 0) { |
679 | goto done; |
680 | } |
681 | ret = 0; |
682 | |
683 | done: |
684 | qobject_unref(qdict); |
685 | bdrv_unref(bs); |
686 | qapi_free_BlockdevCreateOptions(create_options); |
687 | return ret; |
688 | } |
689 | |
690 | |
691 | static int parallels_probe(const uint8_t *buf, int buf_size, |
692 | const char *filename) |
693 | { |
694 | const ParallelsHeader *ph = (const void *)buf; |
695 | |
696 | if (buf_size < sizeof(ParallelsHeader)) { |
697 | return 0; |
698 | } |
699 | |
700 | if ((!memcmp(ph->magic, HEADER_MAGIC, 16) || |
701 | !memcmp(ph->magic, HEADER_MAGIC2, 16)) && |
702 | (le32_to_cpu(ph->version) == HEADER_VERSION)) { |
703 | return 100; |
704 | } |
705 | |
706 | return 0; |
707 | } |
708 | |
709 | static int (BlockDriverState *bs) |
710 | { |
711 | BDRVParallelsState *s = bs->opaque; |
712 | unsigned size = MAX(bdrv_opt_mem_align(bs->file->bs), |
713 | sizeof(ParallelsHeader)); |
714 | |
715 | if (size > s->header_size) { |
716 | size = s->header_size; |
717 | } |
718 | return bdrv_pwrite_sync(bs->file, 0, s->header, size); |
719 | } |
720 | |
721 | static int parallels_open(BlockDriverState *bs, QDict *options, int flags, |
722 | Error **errp) |
723 | { |
724 | BDRVParallelsState *s = bs->opaque; |
725 | ParallelsHeader ph; |
726 | int ret, size, i; |
727 | QemuOpts *opts = NULL; |
728 | Error *local_err = NULL; |
729 | char *buf; |
730 | |
731 | bs->file = bdrv_open_child(NULL, options, "file" , bs, &child_file, |
732 | false, errp); |
733 | if (!bs->file) { |
734 | return -EINVAL; |
735 | } |
736 | |
737 | ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph)); |
738 | if (ret < 0) { |
739 | goto fail; |
740 | } |
741 | |
742 | bs->total_sectors = le64_to_cpu(ph.nb_sectors); |
743 | |
744 | if (le32_to_cpu(ph.version) != HEADER_VERSION) { |
745 | goto fail_format; |
746 | } |
747 | if (!memcmp(ph.magic, HEADER_MAGIC, 16)) { |
748 | s->off_multiplier = 1; |
749 | bs->total_sectors = 0xffffffff & bs->total_sectors; |
750 | } else if (!memcmp(ph.magic, HEADER_MAGIC2, 16)) { |
751 | s->off_multiplier = le32_to_cpu(ph.tracks); |
752 | } else { |
753 | goto fail_format; |
754 | } |
755 | |
756 | s->tracks = le32_to_cpu(ph.tracks); |
757 | if (s->tracks == 0) { |
758 | error_setg(errp, "Invalid image: Zero sectors per track" ); |
759 | ret = -EINVAL; |
760 | goto fail; |
761 | } |
762 | if (s->tracks > INT32_MAX/513) { |
763 | error_setg(errp, "Invalid image: Too big cluster" ); |
764 | ret = -EFBIG; |
765 | goto fail; |
766 | } |
767 | |
768 | s->bat_size = le32_to_cpu(ph.bat_entries); |
769 | if (s->bat_size > INT_MAX / sizeof(uint32_t)) { |
770 | error_setg(errp, "Catalog too large" ); |
771 | ret = -EFBIG; |
772 | goto fail; |
773 | } |
774 | |
775 | size = bat_entry_off(s->bat_size); |
776 | s->header_size = ROUND_UP(size, bdrv_opt_mem_align(bs->file->bs)); |
777 | s->header = qemu_try_blockalign(bs->file->bs, s->header_size); |
778 | if (s->header == NULL) { |
779 | ret = -ENOMEM; |
780 | goto fail; |
781 | } |
782 | s->data_end = le32_to_cpu(ph.data_off); |
783 | if (s->data_end == 0) { |
784 | s->data_end = ROUND_UP(bat_entry_off(s->bat_size), BDRV_SECTOR_SIZE); |
785 | } |
786 | if (s->data_end < s->header_size) { |
787 | /* there is not enough unused space to fit to block align between BAT |
788 | and actual data. We can't avoid read-modify-write... */ |
789 | s->header_size = size; |
790 | } |
791 | |
792 | ret = bdrv_pread(bs->file, 0, s->header, s->header_size); |
793 | if (ret < 0) { |
794 | goto fail; |
795 | } |
796 | s->bat_bitmap = (uint32_t *)(s->header + 1); |
797 | |
798 | for (i = 0; i < s->bat_size; i++) { |
799 | int64_t off = bat2sect(s, i); |
800 | if (off >= s->data_end) { |
801 | s->data_end = off + s->tracks; |
802 | } |
803 | } |
804 | |
805 | if (le32_to_cpu(ph.inuse) == HEADER_INUSE_MAGIC) { |
806 | /* Image was not closed correctly. The check is mandatory */ |
807 | s->header_unclean = true; |
808 | if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) { |
809 | error_setg(errp, "parallels: Image was not closed correctly; " |
810 | "cannot be opened read/write" ); |
811 | ret = -EACCES; |
812 | goto fail; |
813 | } |
814 | } |
815 | |
816 | opts = qemu_opts_create(¶llels_runtime_opts, NULL, 0, &local_err); |
817 | if (local_err != NULL) { |
818 | goto fail_options; |
819 | } |
820 | |
821 | qemu_opts_absorb_qdict(opts, options, &local_err); |
822 | if (local_err != NULL) { |
823 | goto fail_options; |
824 | } |
825 | |
826 | s->prealloc_size = |
827 | qemu_opt_get_size_del(opts, PARALLELS_OPT_PREALLOC_SIZE, 0); |
828 | s->prealloc_size = MAX(s->tracks, s->prealloc_size >> BDRV_SECTOR_BITS); |
829 | buf = qemu_opt_get_del(opts, PARALLELS_OPT_PREALLOC_MODE); |
830 | s->prealloc_mode = qapi_enum_parse(&prealloc_mode_lookup, buf, |
831 | PRL_PREALLOC_MODE_FALLOCATE, |
832 | &local_err); |
833 | g_free(buf); |
834 | if (local_err != NULL) { |
835 | goto fail_options; |
836 | } |
837 | |
838 | if (!bdrv_has_zero_init_truncate(bs->file->bs)) { |
839 | s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE; |
840 | } |
841 | |
842 | if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_INACTIVE)) { |
843 | s->header->inuse = cpu_to_le32(HEADER_INUSE_MAGIC); |
844 | ret = parallels_update_header(bs); |
845 | if (ret < 0) { |
846 | goto fail; |
847 | } |
848 | } |
849 | |
850 | s->bat_dirty_block = 4 * getpagesize(); |
851 | s->bat_dirty_bmap = |
852 | bitmap_new(DIV_ROUND_UP(s->header_size, s->bat_dirty_block)); |
853 | |
854 | /* Disable migration until bdrv_invalidate_cache method is added */ |
855 | error_setg(&s->migration_blocker, "The Parallels format used by node '%s' " |
856 | "does not support live migration" , |
857 | bdrv_get_device_or_node_name(bs)); |
858 | ret = migrate_add_blocker(s->migration_blocker, &local_err); |
859 | if (local_err) { |
860 | error_propagate(errp, local_err); |
861 | error_free(s->migration_blocker); |
862 | goto fail; |
863 | } |
864 | qemu_co_mutex_init(&s->lock); |
865 | return 0; |
866 | |
867 | fail_format: |
868 | error_setg(errp, "Image not in Parallels format" ); |
869 | ret = -EINVAL; |
870 | fail: |
871 | qemu_vfree(s->header); |
872 | return ret; |
873 | |
874 | fail_options: |
875 | error_propagate(errp, local_err); |
876 | ret = -EINVAL; |
877 | goto fail; |
878 | } |
879 | |
880 | |
881 | static void parallels_close(BlockDriverState *bs) |
882 | { |
883 | BDRVParallelsState *s = bs->opaque; |
884 | |
885 | if ((bs->open_flags & BDRV_O_RDWR) && !(bs->open_flags & BDRV_O_INACTIVE)) { |
886 | s->header->inuse = 0; |
887 | parallels_update_header(bs); |
888 | bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, |
889 | PREALLOC_MODE_OFF, NULL); |
890 | } |
891 | |
892 | g_free(s->bat_dirty_bmap); |
893 | qemu_vfree(s->header); |
894 | |
895 | migrate_del_blocker(s->migration_blocker); |
896 | error_free(s->migration_blocker); |
897 | } |
898 | |
899 | static BlockDriver bdrv_parallels = { |
900 | .format_name = "parallels" , |
901 | .instance_size = sizeof(BDRVParallelsState), |
902 | .bdrv_probe = parallels_probe, |
903 | .bdrv_open = parallels_open, |
904 | .bdrv_close = parallels_close, |
905 | .bdrv_child_perm = bdrv_format_default_perms, |
906 | .bdrv_co_block_status = parallels_co_block_status, |
907 | .bdrv_has_zero_init = bdrv_has_zero_init_1, |
908 | .bdrv_co_flush_to_os = parallels_co_flush_to_os, |
909 | .bdrv_co_readv = parallels_co_readv, |
910 | .bdrv_co_writev = parallels_co_writev, |
911 | .supports_backing = true, |
912 | .bdrv_co_create = parallels_co_create, |
913 | .bdrv_co_create_opts = parallels_co_create_opts, |
914 | .bdrv_co_check = parallels_co_check, |
915 | .create_opts = ¶llels_create_opts, |
916 | }; |
917 | |
918 | static void bdrv_parallels_init(void) |
919 | { |
920 | bdrv_register(&bdrv_parallels); |
921 | } |
922 | |
923 | block_init(bdrv_parallels_init); |
924 | |