qcow2: skip writing zero buffers to empty COW areas
[qemu.git] / block / qcow2.c
1 /*
2 * Block driver for the QCOW version 2 format
3 *
4 * Copyright (c) 2004-2006 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26
27 #include "block/qdict.h"
28 #include "sysemu/block-backend.h"
29 #include "qemu/module.h"
30 #include "qcow2.h"
31 #include "qemu/error-report.h"
32 #include "qapi/error.h"
33 #include "qapi/qapi-events-block-core.h"
34 #include "qapi/qmp/qdict.h"
35 #include "qapi/qmp/qstring.h"
36 #include "trace.h"
37 #include "qemu/option_int.h"
38 #include "qemu/cutils.h"
39 #include "qemu/bswap.h"
40 #include "qapi/qobject-input-visitor.h"
41 #include "qapi/qapi-visit-block-core.h"
42 #include "crypto.h"
43
44 /*
45 Differences with QCOW:
46
47 - Support for multiple incremental snapshots.
48 - Memory management by reference counts.
49 - Clusters which have a reference count of one have the bit
50 QCOW_OFLAG_COPIED to optimize write performance.
51 - Size of compressed clusters is stored in sectors to reduce bit usage
52 in the cluster offsets.
53 - Support for storing additional data (such as the VM state) in the
54 snapshots.
55 - If a backing store is used, the cluster size is not constrained
56 (could be backported to QCOW).
57 - L2 tables have always a size of one cluster.
58 */
59
60
61 typedef struct {
62 uint32_t magic;
63 uint32_t len;
64 } QEMU_PACKED QCowExtension;
65
66 #define QCOW2_EXT_MAGIC_END 0
67 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
68 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
69 #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
70 #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875
71 #define QCOW2_EXT_MAGIC_DATA_FILE 0x44415441
72
73 static int coroutine_fn
74 qcow2_co_preadv_compressed(BlockDriverState *bs,
75 uint64_t file_cluster_offset,
76 uint64_t offset,
77 uint64_t bytes,
78 QEMUIOVector *qiov);
79
80 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
81 {
82 const QCowHeader *cow_header = (const void *)buf;
83
84 if (buf_size >= sizeof(QCowHeader) &&
85 be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
86 be32_to_cpu(cow_header->version) >= 2)
87 return 100;
88 else
89 return 0;
90 }
91
92
93 static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
94 uint8_t *buf, size_t buflen,
95 void *opaque, Error **errp)
96 {
97 BlockDriverState *bs = opaque;
98 BDRVQcow2State *s = bs->opaque;
99 ssize_t ret;
100
101 if ((offset + buflen) > s->crypto_header.length) {
102 error_setg(errp, "Request for data outside of extension header");
103 return -1;
104 }
105
106 ret = bdrv_pread(bs->file,
107 s->crypto_header.offset + offset, buf, buflen);
108 if (ret < 0) {
109 error_setg_errno(errp, -ret, "Could not read encryption header");
110 return -1;
111 }
112 return ret;
113 }
114
115
116 static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
117 void *opaque, Error **errp)
118 {
119 BlockDriverState *bs = opaque;
120 BDRVQcow2State *s = bs->opaque;
121 int64_t ret;
122 int64_t clusterlen;
123
124 ret = qcow2_alloc_clusters(bs, headerlen);
125 if (ret < 0) {
126 error_setg_errno(errp, -ret,
127 "Cannot allocate cluster for LUKS header size %zu",
128 headerlen);
129 return -1;
130 }
131
132 s->crypto_header.length = headerlen;
133 s->crypto_header.offset = ret;
134
135 /* Zero fill remaining space in cluster so it has predictable
136 * content in case of future spec changes */
137 clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
138 assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
139 ret = bdrv_pwrite_zeroes(bs->file,
140 ret + headerlen,
141 clusterlen - headerlen, 0);
142 if (ret < 0) {
143 error_setg_errno(errp, -ret, "Could not zero fill encryption header");
144 return -1;
145 }
146
147 return ret;
148 }
149
150
151 static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
152 const uint8_t *buf, size_t buflen,
153 void *opaque, Error **errp)
154 {
155 BlockDriverState *bs = opaque;
156 BDRVQcow2State *s = bs->opaque;
157 ssize_t ret;
158
159 if ((offset + buflen) > s->crypto_header.length) {
160 error_setg(errp, "Request for data outside of extension header");
161 return -1;
162 }
163
164 ret = bdrv_pwrite(bs->file,
165 s->crypto_header.offset + offset, buf, buflen);
166 if (ret < 0) {
167 error_setg_errno(errp, -ret, "Could not read encryption header");
168 return -1;
169 }
170 return ret;
171 }
172
173
174 /*
175 * read qcow2 extension and fill bs
176 * start reading from start_offset
177 * finish reading upon magic of value 0 or when end_offset reached
178 * unknown magic is skipped (future extension this version knows nothing about)
179 * return 0 upon success, non-0 otherwise
180 */
181 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
182 uint64_t end_offset, void **p_feature_table,
183 int flags, bool *need_update_header,
184 Error **errp)
185 {
186 BDRVQcow2State *s = bs->opaque;
187 QCowExtension ext;
188 uint64_t offset;
189 int ret;
190 Qcow2BitmapHeaderExt bitmaps_ext;
191
192 if (need_update_header != NULL) {
193 *need_update_header = false;
194 }
195
196 #ifdef DEBUG_EXT
197 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
198 #endif
199 offset = start_offset;
200 while (offset < end_offset) {
201
202 #ifdef DEBUG_EXT
203 /* Sanity check */
204 if (offset > s->cluster_size)
205 printf("qcow2_read_extension: suspicious offset %lu\n", offset);
206
207 printf("attempting to read extended header in offset %lu\n", offset);
208 #endif
209
210 ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext));
211 if (ret < 0) {
212 error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
213 "pread fail from offset %" PRIu64, offset);
214 return 1;
215 }
216 ext.magic = be32_to_cpu(ext.magic);
217 ext.len = be32_to_cpu(ext.len);
218 offset += sizeof(ext);
219 #ifdef DEBUG_EXT
220 printf("ext.magic = 0x%x\n", ext.magic);
221 #endif
222 if (offset > end_offset || ext.len > end_offset - offset) {
223 error_setg(errp, "Header extension too large");
224 return -EINVAL;
225 }
226
227 switch (ext.magic) {
228 case QCOW2_EXT_MAGIC_END:
229 return 0;
230
231 case QCOW2_EXT_MAGIC_BACKING_FORMAT:
232 if (ext.len >= sizeof(bs->backing_format)) {
233 error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
234 " too large (>=%zu)", ext.len,
235 sizeof(bs->backing_format));
236 return 2;
237 }
238 ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len);
239 if (ret < 0) {
240 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
241 "Could not read format name");
242 return 3;
243 }
244 bs->backing_format[ext.len] = '\0';
245 s->image_backing_format = g_strdup(bs->backing_format);
246 #ifdef DEBUG_EXT
247 printf("Qcow2: Got format extension %s\n", bs->backing_format);
248 #endif
249 break;
250
251 case QCOW2_EXT_MAGIC_FEATURE_TABLE:
252 if (p_feature_table != NULL) {
253 void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
254 ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
255 if (ret < 0) {
256 error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
257 "Could not read table");
258 return ret;
259 }
260
261 *p_feature_table = feature_table;
262 }
263 break;
264
265 case QCOW2_EXT_MAGIC_CRYPTO_HEADER: {
266 unsigned int cflags = 0;
267 if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
268 error_setg(errp, "CRYPTO header extension only "
269 "expected with LUKS encryption method");
270 return -EINVAL;
271 }
272 if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) {
273 error_setg(errp, "CRYPTO header extension size %u, "
274 "but expected size %zu", ext.len,
275 sizeof(Qcow2CryptoHeaderExtension));
276 return -EINVAL;
277 }
278
279 ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len);
280 if (ret < 0) {
281 error_setg_errno(errp, -ret,
282 "Unable to read CRYPTO header extension");
283 return ret;
284 }
285 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
286 s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
287
288 if ((s->crypto_header.offset % s->cluster_size) != 0) {
289 error_setg(errp, "Encryption header offset '%" PRIu64 "' is "
290 "not a multiple of cluster size '%u'",
291 s->crypto_header.offset, s->cluster_size);
292 return -EINVAL;
293 }
294
295 if (flags & BDRV_O_NO_IO) {
296 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
297 }
298 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
299 qcow2_crypto_hdr_read_func,
300 bs, cflags, QCOW2_MAX_THREADS, errp);
301 if (!s->crypto) {
302 return -EINVAL;
303 }
304 } break;
305
306 case QCOW2_EXT_MAGIC_BITMAPS:
307 if (ext.len != sizeof(bitmaps_ext)) {
308 error_setg_errno(errp, -ret, "bitmaps_ext: "
309 "Invalid extension length");
310 return -EINVAL;
311 }
312
313 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) {
314 if (s->qcow_version < 3) {
315 /* Let's be a bit more specific */
316 warn_report("This qcow2 v2 image contains bitmaps, but "
317 "they may have been modified by a program "
318 "without persistent bitmap support; so now "
319 "they must all be considered inconsistent");
320 } else {
321 warn_report("a program lacking bitmap support "
322 "modified this file, so all bitmaps are now "
323 "considered inconsistent");
324 }
325 error_printf("Some clusters may be leaked, "
326 "run 'qemu-img check -r' on the image "
327 "file to fix.");
328 if (need_update_header != NULL) {
329 /* Updating is needed to drop invalid bitmap extension. */
330 *need_update_header = true;
331 }
332 break;
333 }
334
335 ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len);
336 if (ret < 0) {
337 error_setg_errno(errp, -ret, "bitmaps_ext: "
338 "Could not read ext header");
339 return ret;
340 }
341
342 if (bitmaps_ext.reserved32 != 0) {
343 error_setg_errno(errp, -ret, "bitmaps_ext: "
344 "Reserved field is not zero");
345 return -EINVAL;
346 }
347
348 bitmaps_ext.nb_bitmaps = be32_to_cpu(bitmaps_ext.nb_bitmaps);
349 bitmaps_ext.bitmap_directory_size =
350 be64_to_cpu(bitmaps_ext.bitmap_directory_size);
351 bitmaps_ext.bitmap_directory_offset =
352 be64_to_cpu(bitmaps_ext.bitmap_directory_offset);
353
354 if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) {
355 error_setg(errp,
356 "bitmaps_ext: Image has %" PRIu32 " bitmaps, "
357 "exceeding the QEMU supported maximum of %d",
358 bitmaps_ext.nb_bitmaps, QCOW2_MAX_BITMAPS);
359 return -EINVAL;
360 }
361
362 if (bitmaps_ext.nb_bitmaps == 0) {
363 error_setg(errp, "found bitmaps extension with zero bitmaps");
364 return -EINVAL;
365 }
366
367 if (bitmaps_ext.bitmap_directory_offset & (s->cluster_size - 1)) {
368 error_setg(errp, "bitmaps_ext: "
369 "invalid bitmap directory offset");
370 return -EINVAL;
371 }
372
373 if (bitmaps_ext.bitmap_directory_size >
374 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
375 error_setg(errp, "bitmaps_ext: "
376 "bitmap directory size (%" PRIu64 ") exceeds "
377 "the maximum supported size (%d)",
378 bitmaps_ext.bitmap_directory_size,
379 QCOW2_MAX_BITMAP_DIRECTORY_SIZE);
380 return -EINVAL;
381 }
382
383 s->nb_bitmaps = bitmaps_ext.nb_bitmaps;
384 s->bitmap_directory_offset =
385 bitmaps_ext.bitmap_directory_offset;
386 s->bitmap_directory_size =
387 bitmaps_ext.bitmap_directory_size;
388
389 #ifdef DEBUG_EXT
390 printf("Qcow2: Got bitmaps extension: "
391 "offset=%" PRIu64 " nb_bitmaps=%" PRIu32 "\n",
392 s->bitmap_directory_offset, s->nb_bitmaps);
393 #endif
394 break;
395
396 case QCOW2_EXT_MAGIC_DATA_FILE:
397 {
398 s->image_data_file = g_malloc0(ext.len + 1);
399 ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len);
400 if (ret < 0) {
401 error_setg_errno(errp, -ret,
402 "ERROR: Could not read data file name");
403 return ret;
404 }
405 #ifdef DEBUG_EXT
406 printf("Qcow2: Got external data file %s\n", s->image_data_file);
407 #endif
408 break;
409 }
410
411 default:
412 /* unknown magic - save it in case we need to rewrite the header */
413 /* If you add a new feature, make sure to also update the fast
414 * path of qcow2_make_empty() to deal with it. */
415 {
416 Qcow2UnknownHeaderExtension *uext;
417
418 uext = g_malloc0(sizeof(*uext) + ext.len);
419 uext->magic = ext.magic;
420 uext->len = ext.len;
421 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
422
423 ret = bdrv_pread(bs->file, offset , uext->data, uext->len);
424 if (ret < 0) {
425 error_setg_errno(errp, -ret, "ERROR: unknown extension: "
426 "Could not read data");
427 return ret;
428 }
429 }
430 break;
431 }
432
433 offset += ((ext.len + 7) & ~7);
434 }
435
436 return 0;
437 }
438
439 static void cleanup_unknown_header_ext(BlockDriverState *bs)
440 {
441 BDRVQcow2State *s = bs->opaque;
442 Qcow2UnknownHeaderExtension *uext, *next;
443
444 QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
445 QLIST_REMOVE(uext, next);
446 g_free(uext);
447 }
448 }
449
450 static void report_unsupported_feature(Error **errp, Qcow2Feature *table,
451 uint64_t mask)
452 {
453 char *features = g_strdup("");
454 char *old;
455
456 while (table && table->name[0] != '\0') {
457 if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
458 if (mask & (1ULL << table->bit)) {
459 old = features;
460 features = g_strdup_printf("%s%s%.46s", old, *old ? ", " : "",
461 table->name);
462 g_free(old);
463 mask &= ~(1ULL << table->bit);
464 }
465 }
466 table++;
467 }
468
469 if (mask) {
470 old = features;
471 features = g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64,
472 old, *old ? ", " : "", mask);
473 g_free(old);
474 }
475
476 error_setg(errp, "Unsupported qcow2 feature(s): %s", features);
477 g_free(features);
478 }
479
480 /*
481 * Sets the dirty bit and flushes afterwards if necessary.
482 *
483 * The incompatible_features bit is only set if the image file header was
484 * updated successfully. Therefore it is not required to check the return
485 * value of this function.
486 */
487 int qcow2_mark_dirty(BlockDriverState *bs)
488 {
489 BDRVQcow2State *s = bs->opaque;
490 uint64_t val;
491 int ret;
492
493 assert(s->qcow_version >= 3);
494
495 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
496 return 0; /* already dirty */
497 }
498
499 val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
500 ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
501 &val, sizeof(val));
502 if (ret < 0) {
503 return ret;
504 }
505 ret = bdrv_flush(bs->file->bs);
506 if (ret < 0) {
507 return ret;
508 }
509
510 /* Only treat image as dirty if the header was updated successfully */
511 s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
512 return 0;
513 }
514
515 /*
516 * Clears the dirty bit and flushes before if necessary. Only call this
517 * function when there are no pending requests, it does not guard against
518 * concurrent requests dirtying the image.
519 */
520 static int qcow2_mark_clean(BlockDriverState *bs)
521 {
522 BDRVQcow2State *s = bs->opaque;
523
524 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
525 int ret;
526
527 s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;
528
529 ret = qcow2_flush_caches(bs);
530 if (ret < 0) {
531 return ret;
532 }
533
534 return qcow2_update_header(bs);
535 }
536 return 0;
537 }
538
539 /*
540 * Marks the image as corrupt.
541 */
542 int qcow2_mark_corrupt(BlockDriverState *bs)
543 {
544 BDRVQcow2State *s = bs->opaque;
545
546 s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
547 return qcow2_update_header(bs);
548 }
549
550 /*
551 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
552 * before if necessary.
553 */
554 int qcow2_mark_consistent(BlockDriverState *bs)
555 {
556 BDRVQcow2State *s = bs->opaque;
557
558 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
559 int ret = qcow2_flush_caches(bs);
560 if (ret < 0) {
561 return ret;
562 }
563
564 s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT;
565 return qcow2_update_header(bs);
566 }
567 return 0;
568 }
569
570 static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs,
571 BdrvCheckResult *result,
572 BdrvCheckMode fix)
573 {
574 int ret = qcow2_check_refcounts(bs, result, fix);
575 if (ret < 0) {
576 return ret;
577 }
578
579 if (fix && result->check_errors == 0 && result->corruptions == 0) {
580 ret = qcow2_mark_clean(bs);
581 if (ret < 0) {
582 return ret;
583 }
584 return qcow2_mark_consistent(bs);
585 }
586 return ret;
587 }
588
589 static int coroutine_fn qcow2_co_check(BlockDriverState *bs,
590 BdrvCheckResult *result,
591 BdrvCheckMode fix)
592 {
593 BDRVQcow2State *s = bs->opaque;
594 int ret;
595
596 qemu_co_mutex_lock(&s->lock);
597 ret = qcow2_co_check_locked(bs, result, fix);
598 qemu_co_mutex_unlock(&s->lock);
599 return ret;
600 }
601
602 int qcow2_validate_table(BlockDriverState *bs, uint64_t offset,
603 uint64_t entries, size_t entry_len,
604 int64_t max_size_bytes, const char *table_name,
605 Error **errp)
606 {
607 BDRVQcow2State *s = bs->opaque;
608
609 if (entries > max_size_bytes / entry_len) {
610 error_setg(errp, "%s too large", table_name);
611 return -EFBIG;
612 }
613
614 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
615 * because values will be passed to qemu functions taking int64_t. */
616 if ((INT64_MAX - entries * entry_len < offset) ||
617 (offset_into_cluster(s, offset) != 0)) {
618 error_setg(errp, "%s offset invalid", table_name);
619 return -EINVAL;
620 }
621
622 return 0;
623 }
624
625 static const char *const mutable_opts[] = {
626 QCOW2_OPT_LAZY_REFCOUNTS,
627 QCOW2_OPT_DISCARD_REQUEST,
628 QCOW2_OPT_DISCARD_SNAPSHOT,
629 QCOW2_OPT_DISCARD_OTHER,
630 QCOW2_OPT_OVERLAP,
631 QCOW2_OPT_OVERLAP_TEMPLATE,
632 QCOW2_OPT_OVERLAP_MAIN_HEADER,
633 QCOW2_OPT_OVERLAP_ACTIVE_L1,
634 QCOW2_OPT_OVERLAP_ACTIVE_L2,
635 QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
636 QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
637 QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
638 QCOW2_OPT_OVERLAP_INACTIVE_L1,
639 QCOW2_OPT_OVERLAP_INACTIVE_L2,
640 QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
641 QCOW2_OPT_CACHE_SIZE,
642 QCOW2_OPT_L2_CACHE_SIZE,
643 QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
644 QCOW2_OPT_REFCOUNT_CACHE_SIZE,
645 QCOW2_OPT_CACHE_CLEAN_INTERVAL,
646 NULL
647 };
648
649 static QemuOptsList qcow2_runtime_opts = {
650 .name = "qcow2",
651 .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
652 .desc = {
653 {
654 .name = QCOW2_OPT_LAZY_REFCOUNTS,
655 .type = QEMU_OPT_BOOL,
656 .help = "Postpone refcount updates",
657 },
658 {
659 .name = QCOW2_OPT_DISCARD_REQUEST,
660 .type = QEMU_OPT_BOOL,
661 .help = "Pass guest discard requests to the layer below",
662 },
663 {
664 .name = QCOW2_OPT_DISCARD_SNAPSHOT,
665 .type = QEMU_OPT_BOOL,
666 .help = "Generate discard requests when snapshot related space "
667 "is freed",
668 },
669 {
670 .name = QCOW2_OPT_DISCARD_OTHER,
671 .type = QEMU_OPT_BOOL,
672 .help = "Generate discard requests when other clusters are freed",
673 },
674 {
675 .name = QCOW2_OPT_OVERLAP,
676 .type = QEMU_OPT_STRING,
677 .help = "Selects which overlap checks to perform from a range of "
678 "templates (none, constant, cached, all)",
679 },
680 {
681 .name = QCOW2_OPT_OVERLAP_TEMPLATE,
682 .type = QEMU_OPT_STRING,
683 .help = "Selects which overlap checks to perform from a range of "
684 "templates (none, constant, cached, all)",
685 },
686 {
687 .name = QCOW2_OPT_OVERLAP_MAIN_HEADER,
688 .type = QEMU_OPT_BOOL,
689 .help = "Check for unintended writes into the main qcow2 header",
690 },
691 {
692 .name = QCOW2_OPT_OVERLAP_ACTIVE_L1,
693 .type = QEMU_OPT_BOOL,
694 .help = "Check for unintended writes into the active L1 table",
695 },
696 {
697 .name = QCOW2_OPT_OVERLAP_ACTIVE_L2,
698 .type = QEMU_OPT_BOOL,
699 .help = "Check for unintended writes into an active L2 table",
700 },
701 {
702 .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
703 .type = QEMU_OPT_BOOL,
704 .help = "Check for unintended writes into the refcount table",
705 },
706 {
707 .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
708 .type = QEMU_OPT_BOOL,
709 .help = "Check for unintended writes into a refcount block",
710 },
711 {
712 .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
713 .type = QEMU_OPT_BOOL,
714 .help = "Check for unintended writes into the snapshot table",
715 },
716 {
717 .name = QCOW2_OPT_OVERLAP_INACTIVE_L1,
718 .type = QEMU_OPT_BOOL,
719 .help = "Check for unintended writes into an inactive L1 table",
720 },
721 {
722 .name = QCOW2_OPT_OVERLAP_INACTIVE_L2,
723 .type = QEMU_OPT_BOOL,
724 .help = "Check for unintended writes into an inactive L2 table",
725 },
726 {
727 .name = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
728 .type = QEMU_OPT_BOOL,
729 .help = "Check for unintended writes into the bitmap directory",
730 },
731 {
732 .name = QCOW2_OPT_CACHE_SIZE,
733 .type = QEMU_OPT_SIZE,
734 .help = "Maximum combined metadata (L2 tables and refcount blocks) "
735 "cache size",
736 },
737 {
738 .name = QCOW2_OPT_L2_CACHE_SIZE,
739 .type = QEMU_OPT_SIZE,
740 .help = "Maximum L2 table cache size",
741 },
742 {
743 .name = QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
744 .type = QEMU_OPT_SIZE,
745 .help = "Size of each entry in the L2 cache",
746 },
747 {
748 .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE,
749 .type = QEMU_OPT_SIZE,
750 .help = "Maximum refcount block cache size",
751 },
752 {
753 .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
754 .type = QEMU_OPT_NUMBER,
755 .help = "Clean unused cache entries after this time (in seconds)",
756 },
757 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
758 "ID of secret providing qcow2 AES key or LUKS passphrase"),
759 { /* end of list */ }
760 },
761 };
762
763 static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
764 [QCOW2_OL_MAIN_HEADER_BITNR] = QCOW2_OPT_OVERLAP_MAIN_HEADER,
765 [QCOW2_OL_ACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L1,
766 [QCOW2_OL_ACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L2,
767 [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
768 [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
769 [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
770 [QCOW2_OL_INACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L1,
771 [QCOW2_OL_INACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L2,
772 [QCOW2_OL_BITMAP_DIRECTORY_BITNR] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
773 };
774
775 static void cache_clean_timer_cb(void *opaque)
776 {
777 BlockDriverState *bs = opaque;
778 BDRVQcow2State *s = bs->opaque;
779 qcow2_cache_clean_unused(s->l2_table_cache);
780 qcow2_cache_clean_unused(s->refcount_block_cache);
781 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
782 (int64_t) s->cache_clean_interval * 1000);
783 }
784
785 static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
786 {
787 BDRVQcow2State *s = bs->opaque;
788 if (s->cache_clean_interval > 0) {
789 s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL,
790 SCALE_MS, cache_clean_timer_cb,
791 bs);
792 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
793 (int64_t) s->cache_clean_interval * 1000);
794 }
795 }
796
797 static void cache_clean_timer_del(BlockDriverState *bs)
798 {
799 BDRVQcow2State *s = bs->opaque;
800 if (s->cache_clean_timer) {
801 timer_del(s->cache_clean_timer);
802 timer_free(s->cache_clean_timer);
803 s->cache_clean_timer = NULL;
804 }
805 }
806
807 static void qcow2_detach_aio_context(BlockDriverState *bs)
808 {
809 cache_clean_timer_del(bs);
810 }
811
812 static void qcow2_attach_aio_context(BlockDriverState *bs,
813 AioContext *new_context)
814 {
815 cache_clean_timer_init(bs, new_context);
816 }
817
818 static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
819 uint64_t *l2_cache_size,
820 uint64_t *l2_cache_entry_size,
821 uint64_t *refcount_cache_size, Error **errp)
822 {
823 BDRVQcow2State *s = bs->opaque;
824 uint64_t combined_cache_size, l2_cache_max_setting;
825 bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
826 bool l2_cache_entry_size_set;
827 int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
828 uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
829 uint64_t max_l2_cache = virtual_disk_size / (s->cluster_size / 8);
830
831 combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
832 l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
833 refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
834 l2_cache_entry_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE);
835
836 combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0);
837 l2_cache_max_setting = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE,
838 DEFAULT_L2_CACHE_MAX_SIZE);
839 *refcount_cache_size = qemu_opt_get_size(opts,
840 QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0);
841
842 *l2_cache_entry_size = qemu_opt_get_size(
843 opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE, s->cluster_size);
844
845 *l2_cache_size = MIN(max_l2_cache, l2_cache_max_setting);
846
847 if (combined_cache_size_set) {
848 if (l2_cache_size_set && refcount_cache_size_set) {
849 error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE
850 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set "
851 "at the same time");
852 return;
853 } else if (l2_cache_size_set &&
854 (l2_cache_max_setting > combined_cache_size)) {
855 error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed "
856 QCOW2_OPT_CACHE_SIZE);
857 return;
858 } else if (*refcount_cache_size > combined_cache_size) {
859 error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed "
860 QCOW2_OPT_CACHE_SIZE);
861 return;
862 }
863
864 if (l2_cache_size_set) {
865 *refcount_cache_size = combined_cache_size - *l2_cache_size;
866 } else if (refcount_cache_size_set) {
867 *l2_cache_size = combined_cache_size - *refcount_cache_size;
868 } else {
869 /* Assign as much memory as possible to the L2 cache, and
870 * use the remainder for the refcount cache */
871 if (combined_cache_size >= max_l2_cache + min_refcount_cache) {
872 *l2_cache_size = max_l2_cache;
873 *refcount_cache_size = combined_cache_size - *l2_cache_size;
874 } else {
875 *refcount_cache_size =
876 MIN(combined_cache_size, min_refcount_cache);
877 *l2_cache_size = combined_cache_size - *refcount_cache_size;
878 }
879 }
880 }
881
882 /*
883 * If the L2 cache is not enough to cover the whole disk then
884 * default to 4KB entries. Smaller entries reduce the cost of
885 * loads and evictions and increase I/O performance.
886 */
887 if (*l2_cache_size < max_l2_cache && !l2_cache_entry_size_set) {
888 *l2_cache_entry_size = MIN(s->cluster_size, 4096);
889 }
890
891 /* l2_cache_size and refcount_cache_size are ensured to have at least
892 * their minimum values in qcow2_update_options_prepare() */
893
894 if (*l2_cache_entry_size < (1 << MIN_CLUSTER_BITS) ||
895 *l2_cache_entry_size > s->cluster_size ||
896 !is_power_of_2(*l2_cache_entry_size)) {
897 error_setg(errp, "L2 cache entry size must be a power of two "
898 "between %d and the cluster size (%d)",
899 1 << MIN_CLUSTER_BITS, s->cluster_size);
900 return;
901 }
902 }
903
904 typedef struct Qcow2ReopenState {
905 Qcow2Cache *l2_table_cache;
906 Qcow2Cache *refcount_block_cache;
907 int l2_slice_size; /* Number of entries in a slice of the L2 table */
908 bool use_lazy_refcounts;
909 int overlap_check;
910 bool discard_passthrough[QCOW2_DISCARD_MAX];
911 uint64_t cache_clean_interval;
912 QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */
913 } Qcow2ReopenState;
914
915 static int qcow2_update_options_prepare(BlockDriverState *bs,
916 Qcow2ReopenState *r,
917 QDict *options, int flags,
918 Error **errp)
919 {
920 BDRVQcow2State *s = bs->opaque;
921 QemuOpts *opts = NULL;
922 const char *opt_overlap_check, *opt_overlap_check_template;
923 int overlap_check_template = 0;
924 uint64_t l2_cache_size, l2_cache_entry_size, refcount_cache_size;
925 int i;
926 const char *encryptfmt;
927 QDict *encryptopts = NULL;
928 Error *local_err = NULL;
929 int ret;
930
931 qdict_extract_subqdict(options, &encryptopts, "encrypt.");
932 encryptfmt = qdict_get_try_str(encryptopts, "format");
933
934 opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
935 qemu_opts_absorb_qdict(opts, options, &local_err);
936 if (local_err) {
937 error_propagate(errp, local_err);
938 ret = -EINVAL;
939 goto fail;
940 }
941
942 /* get L2 table/refcount block cache size from command line options */
943 read_cache_sizes(bs, opts, &l2_cache_size, &l2_cache_entry_size,
944 &refcount_cache_size, &local_err);
945 if (local_err) {
946 error_propagate(errp, local_err);
947 ret = -EINVAL;
948 goto fail;
949 }
950
951 l2_cache_size /= l2_cache_entry_size;
952 if (l2_cache_size < MIN_L2_CACHE_SIZE) {
953 l2_cache_size = MIN_L2_CACHE_SIZE;
954 }
955 if (l2_cache_size > INT_MAX) {
956 error_setg(errp, "L2 cache size too big");
957 ret = -EINVAL;
958 goto fail;
959 }
960
961 refcount_cache_size /= s->cluster_size;
962 if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
963 refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
964 }
965 if (refcount_cache_size > INT_MAX) {
966 error_setg(errp, "Refcount cache size too big");
967 ret = -EINVAL;
968 goto fail;
969 }
970
971 /* alloc new L2 table/refcount block cache, flush old one */
972 if (s->l2_table_cache) {
973 ret = qcow2_cache_flush(bs, s->l2_table_cache);
974 if (ret) {
975 error_setg_errno(errp, -ret, "Failed to flush the L2 table cache");
976 goto fail;
977 }
978 }
979
980 if (s->refcount_block_cache) {
981 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
982 if (ret) {
983 error_setg_errno(errp, -ret,
984 "Failed to flush the refcount block cache");
985 goto fail;
986 }
987 }
988
989 r->l2_slice_size = l2_cache_entry_size / sizeof(uint64_t);
990 r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size,
991 l2_cache_entry_size);
992 r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size,
993 s->cluster_size);
994 if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) {
995 error_setg(errp, "Could not allocate metadata caches");
996 ret = -ENOMEM;
997 goto fail;
998 }
999
1000 /* New interval for cache cleanup timer */
1001 r->cache_clean_interval =
1002 qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
1003 DEFAULT_CACHE_CLEAN_INTERVAL);
1004 #ifndef CONFIG_LINUX
1005 if (r->cache_clean_interval != 0) {
1006 error_setg(errp, QCOW2_OPT_CACHE_CLEAN_INTERVAL
1007 " not supported on this host");
1008 ret = -EINVAL;
1009 goto fail;
1010 }
1011 #endif
1012 if (r->cache_clean_interval > UINT_MAX) {
1013 error_setg(errp, "Cache clean interval too big");
1014 ret = -EINVAL;
1015 goto fail;
1016 }
1017
1018 /* lazy-refcounts; flush if going from enabled to disabled */
1019 r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
1020 (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
1021 if (r->use_lazy_refcounts && s->qcow_version < 3) {
1022 error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
1023 "qemu 1.1 compatibility level");
1024 ret = -EINVAL;
1025 goto fail;
1026 }
1027
1028 if (s->use_lazy_refcounts && !r->use_lazy_refcounts) {
1029 ret = qcow2_mark_clean(bs);
1030 if (ret < 0) {
1031 error_setg_errno(errp, -ret, "Failed to disable lazy refcounts");
1032 goto fail;
1033 }
1034 }
1035
1036 /* Overlap check options */
1037 opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
1038 opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
1039 if (opt_overlap_check_template && opt_overlap_check &&
1040 strcmp(opt_overlap_check_template, opt_overlap_check))
1041 {
1042 error_setg(errp, "Conflicting values for qcow2 options '"
1043 QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
1044 "' ('%s')", opt_overlap_check, opt_overlap_check_template);
1045 ret = -EINVAL;
1046 goto fail;
1047 }
1048 if (!opt_overlap_check) {
1049 opt_overlap_check = opt_overlap_check_template ?: "cached";
1050 }
1051
1052 if (!strcmp(opt_overlap_check, "none")) {
1053 overlap_check_template = 0;
1054 } else if (!strcmp(opt_overlap_check, "constant")) {
1055 overlap_check_template = QCOW2_OL_CONSTANT;
1056 } else if (!strcmp(opt_overlap_check, "cached")) {
1057 overlap_check_template = QCOW2_OL_CACHED;
1058 } else if (!strcmp(opt_overlap_check, "all")) {
1059 overlap_check_template = QCOW2_OL_ALL;
1060 } else {
1061 error_setg(errp, "Unsupported value '%s' for qcow2 option "
1062 "'overlap-check'. Allowed are any of the following: "
1063 "none, constant, cached, all", opt_overlap_check);
1064 ret = -EINVAL;
1065 goto fail;
1066 }
1067
1068 r->overlap_check = 0;
1069 for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
1070 /* overlap-check defines a template bitmask, but every flag may be
1071 * overwritten through the associated boolean option */
1072 r->overlap_check |=
1073 qemu_opt_get_bool(opts, overlap_bool_option_names[i],
1074 overlap_check_template & (1 << i)) << i;
1075 }
1076
1077 r->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
1078 r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
1079 r->discard_passthrough[QCOW2_DISCARD_REQUEST] =
1080 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
1081 flags & BDRV_O_UNMAP);
1082 r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
1083 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
1084 r->discard_passthrough[QCOW2_DISCARD_OTHER] =
1085 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);
1086
1087 switch (s->crypt_method_header) {
1088 case QCOW_CRYPT_NONE:
1089 if (encryptfmt) {
1090 error_setg(errp, "No encryption in image header, but options "
1091 "specified format '%s'", encryptfmt);
1092 ret = -EINVAL;
1093 goto fail;
1094 }
1095 break;
1096
1097 case QCOW_CRYPT_AES:
1098 if (encryptfmt && !g_str_equal(encryptfmt, "aes")) {
1099 error_setg(errp,
1100 "Header reported 'aes' encryption format but "
1101 "options specify '%s'", encryptfmt);
1102 ret = -EINVAL;
1103 goto fail;
1104 }
1105 qdict_put_str(encryptopts, "format", "qcow");
1106 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1107 break;
1108
1109 case QCOW_CRYPT_LUKS:
1110 if (encryptfmt && !g_str_equal(encryptfmt, "luks")) {
1111 error_setg(errp,
1112 "Header reported 'luks' encryption format but "
1113 "options specify '%s'", encryptfmt);
1114 ret = -EINVAL;
1115 goto fail;
1116 }
1117 qdict_put_str(encryptopts, "format", "luks");
1118 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1119 break;
1120
1121 default:
1122 error_setg(errp, "Unsupported encryption method %d",
1123 s->crypt_method_header);
1124 break;
1125 }
1126 if (s->crypt_method_header != QCOW_CRYPT_NONE && !r->crypto_opts) {
1127 ret = -EINVAL;
1128 goto fail;
1129 }
1130
1131 ret = 0;
1132 fail:
1133 qobject_unref(encryptopts);
1134 qemu_opts_del(opts);
1135 opts = NULL;
1136 return ret;
1137 }
1138
1139 static void qcow2_update_options_commit(BlockDriverState *bs,
1140 Qcow2ReopenState *r)
1141 {
1142 BDRVQcow2State *s = bs->opaque;
1143 int i;
1144
1145 if (s->l2_table_cache) {
1146 qcow2_cache_destroy(s->l2_table_cache);
1147 }
1148 if (s->refcount_block_cache) {
1149 qcow2_cache_destroy(s->refcount_block_cache);
1150 }
1151 s->l2_table_cache = r->l2_table_cache;
1152 s->refcount_block_cache = r->refcount_block_cache;
1153 s->l2_slice_size = r->l2_slice_size;
1154
1155 s->overlap_check = r->overlap_check;
1156 s->use_lazy_refcounts = r->use_lazy_refcounts;
1157
1158 for (i = 0; i < QCOW2_DISCARD_MAX; i++) {
1159 s->discard_passthrough[i] = r->discard_passthrough[i];
1160 }
1161
1162 if (s->cache_clean_interval != r->cache_clean_interval) {
1163 cache_clean_timer_del(bs);
1164 s->cache_clean_interval = r->cache_clean_interval;
1165 cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
1166 }
1167
1168 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1169 s->crypto_opts = r->crypto_opts;
1170 }
1171
1172 static void qcow2_update_options_abort(BlockDriverState *bs,
1173 Qcow2ReopenState *r)
1174 {
1175 if (r->l2_table_cache) {
1176 qcow2_cache_destroy(r->l2_table_cache);
1177 }
1178 if (r->refcount_block_cache) {
1179 qcow2_cache_destroy(r->refcount_block_cache);
1180 }
1181 qapi_free_QCryptoBlockOpenOptions(r->crypto_opts);
1182 }
1183
1184 static int qcow2_update_options(BlockDriverState *bs, QDict *options,
1185 int flags, Error **errp)
1186 {
1187 Qcow2ReopenState r = {};
1188 int ret;
1189
1190 ret = qcow2_update_options_prepare(bs, &r, options, flags, errp);
1191 if (ret >= 0) {
1192 qcow2_update_options_commit(bs, &r);
1193 } else {
1194 qcow2_update_options_abort(bs, &r);
1195 }
1196
1197 return ret;
1198 }
1199
1200 /* Called with s->lock held. */
1201 static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
1202 int flags, Error **errp)
1203 {
1204 BDRVQcow2State *s = bs->opaque;
1205 unsigned int len, i;
1206 int ret = 0;
1207 QCowHeader header;
1208 Error *local_err = NULL;
1209 uint64_t ext_end;
1210 uint64_t l1_vm_state_index;
1211 bool update_header = false;
1212
1213 ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
1214 if (ret < 0) {
1215 error_setg_errno(errp, -ret, "Could not read qcow2 header");
1216 goto fail;
1217 }
1218 header.magic = be32_to_cpu(header.magic);
1219 header.version = be32_to_cpu(header.version);
1220 header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
1221 header.backing_file_size = be32_to_cpu(header.backing_file_size);
1222 header.size = be64_to_cpu(header.size);
1223 header.cluster_bits = be32_to_cpu(header.cluster_bits);
1224 header.crypt_method = be32_to_cpu(header.crypt_method);
1225 header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
1226 header.l1_size = be32_to_cpu(header.l1_size);
1227 header.refcount_table_offset = be64_to_cpu(header.refcount_table_offset);
1228 header.refcount_table_clusters =
1229 be32_to_cpu(header.refcount_table_clusters);
1230 header.snapshots_offset = be64_to_cpu(header.snapshots_offset);
1231 header.nb_snapshots = be32_to_cpu(header.nb_snapshots);
1232
1233 if (header.magic != QCOW_MAGIC) {
1234 error_setg(errp, "Image is not in qcow2 format");
1235 ret = -EINVAL;
1236 goto fail;
1237 }
1238 if (header.version < 2 || header.version > 3) {
1239 error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version);
1240 ret = -ENOTSUP;
1241 goto fail;
1242 }
1243
1244 s->qcow_version = header.version;
1245
1246 /* Initialise cluster size */
1247 if (header.cluster_bits < MIN_CLUSTER_BITS ||
1248 header.cluster_bits > MAX_CLUSTER_BITS) {
1249 error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
1250 header.cluster_bits);
1251 ret = -EINVAL;
1252 goto fail;
1253 }
1254
1255 s->cluster_bits = header.cluster_bits;
1256 s->cluster_size = 1 << s->cluster_bits;
1257
1258 /* Initialise version 3 header fields */
1259 if (header.version == 2) {
1260 header.incompatible_features = 0;
1261 header.compatible_features = 0;
1262 header.autoclear_features = 0;
1263 header.refcount_order = 4;
1264 header.header_length = 72;
1265 } else {
1266 header.incompatible_features =
1267 be64_to_cpu(header.incompatible_features);
1268 header.compatible_features = be64_to_cpu(header.compatible_features);
1269 header.autoclear_features = be64_to_cpu(header.autoclear_features);
1270 header.refcount_order = be32_to_cpu(header.refcount_order);
1271 header.header_length = be32_to_cpu(header.header_length);
1272
1273 if (header.header_length < 104) {
1274 error_setg(errp, "qcow2 header too short");
1275 ret = -EINVAL;
1276 goto fail;
1277 }
1278 }
1279
1280 if (header.header_length > s->cluster_size) {
1281 error_setg(errp, "qcow2 header exceeds cluster size");
1282 ret = -EINVAL;
1283 goto fail;
1284 }
1285
1286 if (header.header_length > sizeof(header)) {
1287 s->unknown_header_fields_size = header.header_length - sizeof(header);
1288 s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
1289 ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
1290 s->unknown_header_fields_size);
1291 if (ret < 0) {
1292 error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
1293 "fields");
1294 goto fail;
1295 }
1296 }
1297
1298 if (header.backing_file_offset > s->cluster_size) {
1299 error_setg(errp, "Invalid backing file offset");
1300 ret = -EINVAL;
1301 goto fail;
1302 }
1303
1304 if (header.backing_file_offset) {
1305 ext_end = header.backing_file_offset;
1306 } else {
1307 ext_end = 1 << header.cluster_bits;
1308 }
1309
1310 /* Handle feature bits */
1311 s->incompatible_features = header.incompatible_features;
1312 s->compatible_features = header.compatible_features;
1313 s->autoclear_features = header.autoclear_features;
1314
1315 if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
1316 void *feature_table = NULL;
1317 qcow2_read_extensions(bs, header.header_length, ext_end,
1318 &feature_table, flags, NULL, NULL);
1319 report_unsupported_feature(errp, feature_table,
1320 s->incompatible_features &
1321 ~QCOW2_INCOMPAT_MASK);
1322 ret = -ENOTSUP;
1323 g_free(feature_table);
1324 goto fail;
1325 }
1326
1327 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
1328 /* Corrupt images may not be written to unless they are being repaired
1329 */
1330 if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
1331 error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
1332 "read/write");
1333 ret = -EACCES;
1334 goto fail;
1335 }
1336 }
1337
1338 /* Check support for various header values */
1339 if (header.refcount_order > 6) {
1340 error_setg(errp, "Reference count entry width too large; may not "
1341 "exceed 64 bits");
1342 ret = -EINVAL;
1343 goto fail;
1344 }
1345 s->refcount_order = header.refcount_order;
1346 s->refcount_bits = 1 << s->refcount_order;
1347 s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
1348 s->refcount_max += s->refcount_max - 1;
1349
1350 s->crypt_method_header = header.crypt_method;
1351 if (s->crypt_method_header) {
1352 if (bdrv_uses_whitelist() &&
1353 s->crypt_method_header == QCOW_CRYPT_AES) {
1354 error_setg(errp,
1355 "Use of AES-CBC encrypted qcow2 images is no longer "
1356 "supported in system emulators");
1357 error_append_hint(errp,
1358 "You can use 'qemu-img convert' to convert your "
1359 "image to an alternative supported format, such "
1360 "as unencrypted qcow2, or raw with the LUKS "
1361 "format instead.\n");
1362 ret = -ENOSYS;
1363 goto fail;
1364 }
1365
1366 if (s->crypt_method_header == QCOW_CRYPT_AES) {
1367 s->crypt_physical_offset = false;
1368 } else {
1369 /* Assuming LUKS and any future crypt methods we
1370 * add will all use physical offsets, due to the
1371 * fact that the alternative is insecure... */
1372 s->crypt_physical_offset = true;
1373 }
1374
1375 bs->encrypted = true;
1376 }
1377
1378 s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
1379 s->l2_size = 1 << s->l2_bits;
1380 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1381 s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
1382 s->refcount_block_size = 1 << s->refcount_block_bits;
1383 bs->total_sectors = header.size / BDRV_SECTOR_SIZE;
1384 s->csize_shift = (62 - (s->cluster_bits - 8));
1385 s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
1386 s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
1387
1388 s->refcount_table_offset = header.refcount_table_offset;
1389 s->refcount_table_size =
1390 header.refcount_table_clusters << (s->cluster_bits - 3);
1391
1392 if (header.refcount_table_clusters == 0 && !(flags & BDRV_O_CHECK)) {
1393 error_setg(errp, "Image does not contain a reference count table");
1394 ret = -EINVAL;
1395 goto fail;
1396 }
1397
1398 ret = qcow2_validate_table(bs, s->refcount_table_offset,
1399 header.refcount_table_clusters,
1400 s->cluster_size, QCOW_MAX_REFTABLE_SIZE,
1401 "Reference count table", errp);
1402 if (ret < 0) {
1403 goto fail;
1404 }
1405
1406 /* The total size in bytes of the snapshot table is checked in
1407 * qcow2_read_snapshots() because the size of each snapshot is
1408 * variable and we don't know it yet.
1409 * Here we only check the offset and number of snapshots. */
1410 ret = qcow2_validate_table(bs, header.snapshots_offset,
1411 header.nb_snapshots,
1412 sizeof(QCowSnapshotHeader),
1413 sizeof(QCowSnapshotHeader) * QCOW_MAX_SNAPSHOTS,
1414 "Snapshot table", errp);
1415 if (ret < 0) {
1416 goto fail;
1417 }
1418
1419 /* read the level 1 table */
1420 ret = qcow2_validate_table(bs, header.l1_table_offset,
1421 header.l1_size, sizeof(uint64_t),
1422 QCOW_MAX_L1_SIZE, "Active L1 table", errp);
1423 if (ret < 0) {
1424 goto fail;
1425 }
1426 s->l1_size = header.l1_size;
1427 s->l1_table_offset = header.l1_table_offset;
1428
1429 l1_vm_state_index = size_to_l1(s, header.size);
1430 if (l1_vm_state_index > INT_MAX) {
1431 error_setg(errp, "Image is too big");
1432 ret = -EFBIG;
1433 goto fail;
1434 }
1435 s->l1_vm_state_index = l1_vm_state_index;
1436
1437 /* the L1 table must contain at least enough entries to put
1438 header.size bytes */
1439 if (s->l1_size < s->l1_vm_state_index) {
1440 error_setg(errp, "L1 table is too small");
1441 ret = -EINVAL;
1442 goto fail;
1443 }
1444
1445 if (s->l1_size > 0) {
1446 s->l1_table = qemu_try_blockalign(bs->file->bs,
1447 ROUND_UP(s->l1_size * sizeof(uint64_t), 512));
1448 if (s->l1_table == NULL) {
1449 error_setg(errp, "Could not allocate L1 table");
1450 ret = -ENOMEM;
1451 goto fail;
1452 }
1453 ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
1454 s->l1_size * sizeof(uint64_t));
1455 if (ret < 0) {
1456 error_setg_errno(errp, -ret, "Could not read L1 table");
1457 goto fail;
1458 }
1459 for(i = 0;i < s->l1_size; i++) {
1460 s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
1461 }
1462 }
1463
1464 /* Parse driver-specific options */
1465 ret = qcow2_update_options(bs, options, flags, errp);
1466 if (ret < 0) {
1467 goto fail;
1468 }
1469
1470 s->flags = flags;
1471
1472 ret = qcow2_refcount_init(bs);
1473 if (ret != 0) {
1474 error_setg_errno(errp, -ret, "Could not initialize refcount handling");
1475 goto fail;
1476 }
1477
1478 QLIST_INIT(&s->cluster_allocs);
1479 QTAILQ_INIT(&s->discards);
1480
1481 /* read qcow2 extensions */
1482 if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
1483 flags, &update_header, &local_err)) {
1484 error_propagate(errp, local_err);
1485 ret = -EINVAL;
1486 goto fail;
1487 }
1488
1489 /* Open external data file */
1490 s->data_file = bdrv_open_child(NULL, options, "data-file", bs, &child_file,
1491 true, &local_err);
1492 if (local_err) {
1493 error_propagate(errp, local_err);
1494 ret = -EINVAL;
1495 goto fail;
1496 }
1497
1498 if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
1499 if (!s->data_file && s->image_data_file) {
1500 s->data_file = bdrv_open_child(s->image_data_file, options,
1501 "data-file", bs, &child_file,
1502 false, errp);
1503 if (!s->data_file) {
1504 ret = -EINVAL;
1505 goto fail;
1506 }
1507 }
1508 if (!s->data_file) {
1509 error_setg(errp, "'data-file' is required for this image");
1510 ret = -EINVAL;
1511 goto fail;
1512 }
1513 } else {
1514 if (s->data_file) {
1515 error_setg(errp, "'data-file' can only be set for images with an "
1516 "external data file");
1517 ret = -EINVAL;
1518 goto fail;
1519 }
1520
1521 s->data_file = bs->file;
1522
1523 if (data_file_is_raw(bs)) {
1524 error_setg(errp, "data-file-raw requires a data file");
1525 ret = -EINVAL;
1526 goto fail;
1527 }
1528 }
1529
1530 /* qcow2_read_extension may have set up the crypto context
1531 * if the crypt method needs a header region, some methods
1532 * don't need header extensions, so must check here
1533 */
1534 if (s->crypt_method_header && !s->crypto) {
1535 if (s->crypt_method_header == QCOW_CRYPT_AES) {
1536 unsigned int cflags = 0;
1537 if (flags & BDRV_O_NO_IO) {
1538 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
1539 }
1540 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
1541 NULL, NULL, cflags,
1542 QCOW2_MAX_THREADS, errp);
1543 if (!s->crypto) {
1544 ret = -EINVAL;
1545 goto fail;
1546 }
1547 } else if (!(flags & BDRV_O_NO_IO)) {
1548 error_setg(errp, "Missing CRYPTO header for crypt method %d",
1549 s->crypt_method_header);
1550 ret = -EINVAL;
1551 goto fail;
1552 }
1553 }
1554
1555 /* read the backing file name */
1556 if (header.backing_file_offset != 0) {
1557 len = header.backing_file_size;
1558 if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
1559 len >= sizeof(bs->backing_file)) {
1560 error_setg(errp, "Backing file name too long");
1561 ret = -EINVAL;
1562 goto fail;
1563 }
1564 ret = bdrv_pread(bs->file, header.backing_file_offset,
1565 bs->auto_backing_file, len);
1566 if (ret < 0) {
1567 error_setg_errno(errp, -ret, "Could not read backing file name");
1568 goto fail;
1569 }
1570 bs->auto_backing_file[len] = '\0';
1571 pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1572 bs->auto_backing_file);
1573 s->image_backing_file = g_strdup(bs->auto_backing_file);
1574 }
1575
1576 /* Internal snapshots */
1577 s->snapshots_offset = header.snapshots_offset;
1578 s->nb_snapshots = header.nb_snapshots;
1579
1580 ret = qcow2_read_snapshots(bs);
1581 if (ret < 0) {
1582 error_setg_errno(errp, -ret, "Could not read snapshots");
1583 goto fail;
1584 }
1585
1586 /* Clear unknown autoclear feature bits */
1587 update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK;
1588 update_header =
1589 update_header && !bs->read_only && !(flags & BDRV_O_INACTIVE);
1590 if (update_header) {
1591 s->autoclear_features &= QCOW2_AUTOCLEAR_MASK;
1592 }
1593
1594 /* == Handle persistent dirty bitmaps ==
1595 *
1596 * We want load dirty bitmaps in three cases:
1597 *
1598 * 1. Normal open of the disk in active mode, not related to invalidation
1599 * after migration.
1600 *
1601 * 2. Invalidation of the target vm after pre-copy phase of migration, if
1602 * bitmaps are _not_ migrating through migration channel, i.e.
1603 * 'dirty-bitmaps' capability is disabled.
1604 *
1605 * 3. Invalidation of source vm after failed or canceled migration.
1606 * This is a very interesting case. There are two possible types of
1607 * bitmaps:
1608 *
1609 * A. Stored on inactivation and removed. They should be loaded from the
1610 * image.
1611 *
1612 * B. Not stored: not-persistent bitmaps and bitmaps, migrated through
1613 * the migration channel (with dirty-bitmaps capability).
1614 *
1615 * On the other hand, there are two possible sub-cases:
1616 *
1617 * 3.1 disk was changed by somebody else while were inactive. In this
1618 * case all in-RAM dirty bitmaps (both persistent and not) are
1619 * definitely invalid. And we don't have any method to determine
1620 * this.
1621 *
1622 * Simple and safe thing is to just drop all the bitmaps of type B on
1623 * inactivation. But in this case we lose bitmaps in valid 4.2 case.
1624 *
1625 * On the other hand, resuming source vm, if disk was already changed
1626 * is a bad thing anyway: not only bitmaps, the whole vm state is
1627 * out of sync with disk.
1628 *
1629 * This means, that user or management tool, who for some reason
1630 * decided to resume source vm, after disk was already changed by
1631 * target vm, should at least drop all dirty bitmaps by hand.
1632 *
1633 * So, we can ignore this case for now, but TODO: "generation"
1634 * extension for qcow2, to determine, that image was changed after
1635 * last inactivation. And if it is changed, we will drop (or at least
1636 * mark as 'invalid' all the bitmaps of type B, both persistent
1637 * and not).
1638 *
1639 * 3.2 disk was _not_ changed while were inactive. Bitmaps may be saved
1640 * to disk ('dirty-bitmaps' capability disabled), or not saved
1641 * ('dirty-bitmaps' capability enabled), but we don't need to care
1642 * of: let's load bitmaps as always: stored bitmaps will be loaded,
1643 * and not stored has flag IN_USE=1 in the image and will be skipped
1644 * on loading.
1645 *
1646 * One remaining possible case when we don't want load bitmaps:
1647 *
1648 * 4. Open disk in inactive mode in target vm (bitmaps are migrating or
1649 * will be loaded on invalidation, no needs try loading them before)
1650 */
1651
1652 if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) {
1653 /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
1654 bool header_updated = qcow2_load_dirty_bitmaps(bs, &local_err);
1655
1656 update_header = update_header && !header_updated;
1657 }
1658 if (local_err != NULL) {
1659 error_propagate(errp, local_err);
1660 ret = -EINVAL;
1661 goto fail;
1662 }
1663
1664 if (update_header) {
1665 ret = qcow2_update_header(bs);
1666 if (ret < 0) {
1667 error_setg_errno(errp, -ret, "Could not update qcow2 header");
1668 goto fail;
1669 }
1670 }
1671
1672 bs->supported_zero_flags = header.version >= 3 ? BDRV_REQ_MAY_UNMAP : 0;
1673
1674 /* Repair image if dirty */
1675 if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
1676 (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
1677 BdrvCheckResult result = {0};
1678
1679 ret = qcow2_co_check_locked(bs, &result,
1680 BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
1681 if (ret < 0 || result.check_errors) {
1682 if (ret >= 0) {
1683 ret = -EIO;
1684 }
1685 error_setg_errno(errp, -ret, "Could not repair dirty image");
1686 goto fail;
1687 }
1688 }
1689
1690 #ifdef DEBUG_ALLOC
1691 {
1692 BdrvCheckResult result = {0};
1693 qcow2_check_refcounts(bs, &result, 0);
1694 }
1695 #endif
1696
1697 qemu_co_queue_init(&s->thread_task_queue);
1698
1699 return ret;
1700
1701 fail:
1702 g_free(s->image_data_file);
1703 if (has_data_file(bs)) {
1704 bdrv_unref_child(bs, s->data_file);
1705 }
1706 g_free(s->unknown_header_fields);
1707 cleanup_unknown_header_ext(bs);
1708 qcow2_free_snapshots(bs);
1709 qcow2_refcount_close(bs);
1710 qemu_vfree(s->l1_table);
1711 /* else pre-write overlap checks in cache_destroy may crash */
1712 s->l1_table = NULL;
1713 cache_clean_timer_del(bs);
1714 if (s->l2_table_cache) {
1715 qcow2_cache_destroy(s->l2_table_cache);
1716 }
1717 if (s->refcount_block_cache) {
1718 qcow2_cache_destroy(s->refcount_block_cache);
1719 }
1720 qcrypto_block_free(s->crypto);
1721 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1722 return ret;
1723 }
1724
1725 typedef struct QCow2OpenCo {
1726 BlockDriverState *bs;
1727 QDict *options;
1728 int flags;
1729 Error **errp;
1730 int ret;
1731 } QCow2OpenCo;
1732
1733 static void coroutine_fn qcow2_open_entry(void *opaque)
1734 {
1735 QCow2OpenCo *qoc = opaque;
1736 BDRVQcow2State *s = qoc->bs->opaque;
1737
1738 qemu_co_mutex_lock(&s->lock);
1739 qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, qoc->errp);
1740 qemu_co_mutex_unlock(&s->lock);
1741 }
1742
1743 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
1744 Error **errp)
1745 {
1746 BDRVQcow2State *s = bs->opaque;
1747 QCow2OpenCo qoc = {
1748 .bs = bs,
1749 .options = options,
1750 .flags = flags,
1751 .errp = errp,
1752 .ret = -EINPROGRESS
1753 };
1754
1755 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
1756 false, errp);
1757 if (!bs->file) {
1758 return -EINVAL;
1759 }
1760
1761 /* Initialise locks */
1762 qemu_co_mutex_init(&s->lock);
1763
1764 if (qemu_in_coroutine()) {
1765 /* From bdrv_co_create. */
1766 qcow2_open_entry(&qoc);
1767 } else {
1768 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
1769 qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry, &qoc));
1770 BDRV_POLL_WHILE(bs, qoc.ret == -EINPROGRESS);
1771 }
1772 return qoc.ret;
1773 }
1774
1775 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
1776 {
1777 BDRVQcow2State *s = bs->opaque;
1778
1779 if (bs->encrypted) {
1780 /* Encryption works on a sector granularity */
1781 bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto);
1782 }
1783 bs->bl.pwrite_zeroes_alignment = s->cluster_size;
1784 bs->bl.pdiscard_alignment = s->cluster_size;
1785 }
1786
1787 static int qcow2_reopen_prepare(BDRVReopenState *state,
1788 BlockReopenQueue *queue, Error **errp)
1789 {
1790 Qcow2ReopenState *r;
1791 int ret;
1792
1793 r = g_new0(Qcow2ReopenState, 1);
1794 state->opaque = r;
1795
1796 ret = qcow2_update_options_prepare(state->bs, r, state->options,
1797 state->flags, errp);
1798 if (ret < 0) {
1799 goto fail;
1800 }
1801
1802 /* We need to write out any unwritten data if we reopen read-only. */
1803 if ((state->flags & BDRV_O_RDWR) == 0) {
1804 ret = qcow2_reopen_bitmaps_ro(state->bs, errp);
1805 if (ret < 0) {
1806 goto fail;
1807 }
1808
1809 ret = bdrv_flush(state->bs);
1810 if (ret < 0) {
1811 goto fail;
1812 }
1813
1814 ret = qcow2_mark_clean(state->bs);
1815 if (ret < 0) {
1816 goto fail;
1817 }
1818 }
1819
1820 return 0;
1821
1822 fail:
1823 qcow2_update_options_abort(state->bs, r);
1824 g_free(r);
1825 return ret;
1826 }
1827
1828 static void qcow2_reopen_commit(BDRVReopenState *state)
1829 {
1830 qcow2_update_options_commit(state->bs, state->opaque);
1831 g_free(state->opaque);
1832 }
1833
1834 static void qcow2_reopen_abort(BDRVReopenState *state)
1835 {
1836 qcow2_update_options_abort(state->bs, state->opaque);
1837 g_free(state->opaque);
1838 }
1839
1840 static void qcow2_join_options(QDict *options, QDict *old_options)
1841 {
1842 bool has_new_overlap_template =
1843 qdict_haskey(options, QCOW2_OPT_OVERLAP) ||
1844 qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE);
1845 bool has_new_total_cache_size =
1846 qdict_haskey(options, QCOW2_OPT_CACHE_SIZE);
1847 bool has_all_cache_options;
1848
1849 /* New overlap template overrides all old overlap options */
1850 if (has_new_overlap_template) {
1851 qdict_del(old_options, QCOW2_OPT_OVERLAP);
1852 qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE);
1853 qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER);
1854 qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1);
1855 qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2);
1856 qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE);
1857 qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK);
1858 qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE);
1859 qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1);
1860 qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2);
1861 }
1862
1863 /* New total cache size overrides all old options */
1864 if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) {
1865 qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE);
1866 qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
1867 }
1868
1869 qdict_join(options, old_options, false);
1870
1871 /*
1872 * If after merging all cache size options are set, an old total size is
1873 * overwritten. Do keep all options, however, if all three are new. The
1874 * resulting error message is what we want to happen.
1875 */
1876 has_all_cache_options =
1877 qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) ||
1878 qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) ||
1879 qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
1880
1881 if (has_all_cache_options && !has_new_total_cache_size) {
1882 qdict_del(options, QCOW2_OPT_CACHE_SIZE);
1883 }
1884 }
1885
1886 static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
1887 bool want_zero,
1888 int64_t offset, int64_t count,
1889 int64_t *pnum, int64_t *map,
1890 BlockDriverState **file)
1891 {
1892 BDRVQcow2State *s = bs->opaque;
1893 uint64_t cluster_offset;
1894 int index_in_cluster, ret;
1895 unsigned int bytes;
1896 int status = 0;
1897
1898 bytes = MIN(INT_MAX, count);
1899 qemu_co_mutex_lock(&s->lock);
1900 ret = qcow2_get_cluster_offset(bs, offset, &bytes, &cluster_offset);
1901 qemu_co_mutex_unlock(&s->lock);
1902 if (ret < 0) {
1903 return ret;
1904 }
1905
1906 *pnum = bytes;
1907
1908 if ((ret == QCOW2_CLUSTER_NORMAL || ret == QCOW2_CLUSTER_ZERO_ALLOC) &&
1909 !s->crypto) {
1910 index_in_cluster = offset & (s->cluster_size - 1);
1911 *map = cluster_offset | index_in_cluster;
1912 *file = s->data_file->bs;
1913 status |= BDRV_BLOCK_OFFSET_VALID;
1914 }
1915 if (ret == QCOW2_CLUSTER_ZERO_PLAIN || ret == QCOW2_CLUSTER_ZERO_ALLOC) {
1916 status |= BDRV_BLOCK_ZERO;
1917 } else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
1918 status |= BDRV_BLOCK_DATA;
1919 }
1920 return status;
1921 }
1922
1923 static coroutine_fn int qcow2_handle_l2meta(BlockDriverState *bs,
1924 QCowL2Meta **pl2meta,
1925 bool link_l2)
1926 {
1927 int ret = 0;
1928 QCowL2Meta *l2meta = *pl2meta;
1929
1930 while (l2meta != NULL) {
1931 QCowL2Meta *next;
1932
1933 if (link_l2) {
1934 ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
1935 if (ret) {
1936 goto out;
1937 }
1938 } else {
1939 qcow2_alloc_cluster_abort(bs, l2meta);
1940 }
1941
1942 /* Take the request off the list of running requests */
1943 if (l2meta->nb_clusters != 0) {
1944 QLIST_REMOVE(l2meta, next_in_flight);
1945 }
1946
1947 qemu_co_queue_restart_all(&l2meta->dependent_requests);
1948
1949 next = l2meta->next;
1950 g_free(l2meta);
1951 l2meta = next;
1952 }
1953 out:
1954 *pl2meta = l2meta;
1955 return ret;
1956 }
1957
1958 static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
1959 uint64_t bytes, QEMUIOVector *qiov,
1960 int flags)
1961 {
1962 BDRVQcow2State *s = bs->opaque;
1963 int offset_in_cluster;
1964 int ret;
1965 unsigned int cur_bytes; /* number of bytes in current iteration */
1966 uint64_t cluster_offset = 0;
1967 uint64_t bytes_done = 0;
1968 QEMUIOVector hd_qiov;
1969 uint8_t *cluster_data = NULL;
1970
1971 qemu_iovec_init(&hd_qiov, qiov->niov);
1972
1973 while (bytes != 0) {
1974
1975 /* prepare next request */
1976 cur_bytes = MIN(bytes, INT_MAX);
1977 if (s->crypto) {
1978 cur_bytes = MIN(cur_bytes,
1979 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
1980 }
1981
1982 qemu_co_mutex_lock(&s->lock);
1983 ret = qcow2_get_cluster_offset(bs, offset, &cur_bytes, &cluster_offset);
1984 qemu_co_mutex_unlock(&s->lock);
1985 if (ret < 0) {
1986 goto fail;
1987 }
1988
1989 offset_in_cluster = offset_into_cluster(s, offset);
1990
1991 qemu_iovec_reset(&hd_qiov);
1992 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
1993
1994 switch (ret) {
1995 case QCOW2_CLUSTER_UNALLOCATED:
1996
1997 if (bs->backing) {
1998 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
1999 ret = bdrv_co_preadv(bs->backing, offset, cur_bytes,
2000 &hd_qiov, 0);
2001 if (ret < 0) {
2002 goto fail;
2003 }
2004 } else {
2005 /* Note: in this case, no need to wait */
2006 qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
2007 }
2008 break;
2009
2010 case QCOW2_CLUSTER_ZERO_PLAIN:
2011 case QCOW2_CLUSTER_ZERO_ALLOC:
2012 qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
2013 break;
2014
2015 case QCOW2_CLUSTER_COMPRESSED:
2016 ret = qcow2_co_preadv_compressed(bs, cluster_offset,
2017 offset, cur_bytes,
2018 &hd_qiov);
2019 if (ret < 0) {
2020 goto fail;
2021 }
2022
2023 break;
2024
2025 case QCOW2_CLUSTER_NORMAL:
2026 if ((cluster_offset & 511) != 0) {
2027 ret = -EIO;
2028 goto fail;
2029 }
2030
2031 if (bs->encrypted) {
2032 assert(s->crypto);
2033
2034 /*
2035 * For encrypted images, read everything into a temporary
2036 * contiguous buffer on which the AES functions can work.
2037 */
2038 if (!cluster_data) {
2039 cluster_data =
2040 qemu_try_blockalign(s->data_file->bs,
2041 QCOW_MAX_CRYPT_CLUSTERS
2042 * s->cluster_size);
2043 if (cluster_data == NULL) {
2044 ret = -ENOMEM;
2045 goto fail;
2046 }
2047 }
2048
2049 assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2050 qemu_iovec_reset(&hd_qiov);
2051 qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
2052 }
2053
2054 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
2055 ret = bdrv_co_preadv(s->data_file,
2056 cluster_offset + offset_in_cluster,
2057 cur_bytes, &hd_qiov, 0);
2058 if (ret < 0) {
2059 goto fail;
2060 }
2061 if (bs->encrypted) {
2062 assert(s->crypto);
2063 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
2064 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
2065 if (qcow2_co_decrypt(bs, cluster_offset, offset,
2066 cluster_data, cur_bytes) < 0) {
2067 ret = -EIO;
2068 goto fail;
2069 }
2070 qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes);
2071 }
2072 break;
2073
2074 default:
2075 g_assert_not_reached();
2076 ret = -EIO;
2077 goto fail;
2078 }
2079
2080 bytes -= cur_bytes;
2081 offset += cur_bytes;
2082 bytes_done += cur_bytes;
2083 }
2084 ret = 0;
2085
2086 fail:
2087 qemu_iovec_destroy(&hd_qiov);
2088 qemu_vfree(cluster_data);
2089
2090 return ret;
2091 }
2092
2093 /* Check if it's possible to merge a write request with the writing of
2094 * the data from the COW regions */
2095 static bool merge_cow(uint64_t offset, unsigned bytes,
2096 QEMUIOVector *hd_qiov, QCowL2Meta *l2meta)
2097 {
2098 QCowL2Meta *m;
2099
2100 for (m = l2meta; m != NULL; m = m->next) {
2101 /* If both COW regions are empty then there's nothing to merge */
2102 if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) {
2103 continue;
2104 }
2105
2106 /* If COW regions are handled already, skip this too */
2107 if (m->skip_cow) {
2108 continue;
2109 }
2110
2111 /* The data (middle) region must be immediately after the
2112 * start region */
2113 if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) {
2114 continue;
2115 }
2116
2117 /* The end region must be immediately after the data (middle)
2118 * region */
2119 if (m->offset + m->cow_end.offset != offset + bytes) {
2120 continue;
2121 }
2122
2123 /* Make sure that adding both COW regions to the QEMUIOVector
2124 * does not exceed IOV_MAX */
2125 if (hd_qiov->niov > IOV_MAX - 2) {
2126 continue;
2127 }
2128
2129 m->data_qiov = hd_qiov;
2130 return true;
2131 }
2132
2133 return false;
2134 }
2135
2136 static bool is_unallocated(BlockDriverState *bs, int64_t offset, int64_t bytes)
2137 {
2138 int64_t nr;
2139 return !bytes ||
2140 (!bdrv_is_allocated_above(bs, NULL, offset, bytes, &nr) && nr == bytes);
2141 }
2142
2143 static bool is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)
2144 {
2145 /*
2146 * This check is designed for optimization shortcut so it must be
2147 * efficient.
2148 * Instead of is_zero(), use is_unallocated() as it is faster (but not
2149 * as accurate and can result in false negatives).
2150 */
2151 return is_unallocated(bs, m->offset + m->cow_start.offset,
2152 m->cow_start.nb_bytes) &&
2153 is_unallocated(bs, m->offset + m->cow_end.offset,
2154 m->cow_end.nb_bytes);
2155 }
2156
2157 static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
2158 {
2159 BDRVQcow2State *s = bs->opaque;
2160 QCowL2Meta *m;
2161
2162 if (!(s->data_file->bs->supported_zero_flags & BDRV_REQ_NO_FALLBACK)) {
2163 return 0;
2164 }
2165
2166 if (bs->encrypted) {
2167 return 0;
2168 }
2169
2170 for (m = l2meta; m != NULL; m = m->next) {
2171 int ret;
2172
2173 if (!m->cow_start.nb_bytes && !m->cow_end.nb_bytes) {
2174 continue;
2175 }
2176
2177 if (!is_zero_cow(bs, m)) {
2178 continue;
2179 }
2180
2181 /*
2182 * instead of writing zero COW buffers,
2183 * efficiently zero out the whole clusters
2184 */
2185
2186 ret = qcow2_pre_write_overlap_check(bs, 0, m->alloc_offset,
2187 m->nb_clusters * s->cluster_size,
2188 true);
2189 if (ret < 0) {
2190 return ret;
2191 }
2192
2193 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
2194 ret = bdrv_co_pwrite_zeroes(s->data_file, m->alloc_offset,
2195 m->nb_clusters * s->cluster_size,
2196 BDRV_REQ_NO_FALLBACK);
2197 if (ret < 0) {
2198 if (ret != -ENOTSUP && ret != -EAGAIN) {
2199 return ret;
2200 }
2201 continue;
2202 }
2203
2204 trace_qcow2_skip_cow(qemu_coroutine_self(), m->offset, m->nb_clusters);
2205 m->skip_cow = true;
2206 }
2207 return 0;
2208 }
2209
2210 static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
2211 uint64_t bytes, QEMUIOVector *qiov,
2212 int flags)
2213 {
2214 BDRVQcow2State *s = bs->opaque;
2215 int offset_in_cluster;
2216 int ret;
2217 unsigned int cur_bytes; /* number of sectors in current iteration */
2218 uint64_t cluster_offset;
2219 QEMUIOVector hd_qiov;
2220 uint64_t bytes_done = 0;
2221 uint8_t *cluster_data = NULL;
2222 QCowL2Meta *l2meta = NULL;
2223
2224 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
2225
2226 qemu_iovec_init(&hd_qiov, qiov->niov);
2227
2228 qemu_co_mutex_lock(&s->lock);
2229
2230 while (bytes != 0) {
2231
2232 l2meta = NULL;
2233
2234 trace_qcow2_writev_start_part(qemu_coroutine_self());
2235 offset_in_cluster = offset_into_cluster(s, offset);
2236 cur_bytes = MIN(bytes, INT_MAX);
2237 if (bs->encrypted) {
2238 cur_bytes = MIN(cur_bytes,
2239 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size
2240 - offset_in_cluster);
2241 }
2242
2243 ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,
2244 &cluster_offset, &l2meta);
2245 if (ret < 0) {
2246 goto out_locked;
2247 }
2248
2249 assert((cluster_offset & 511) == 0);
2250
2251 ret = qcow2_pre_write_overlap_check(bs, 0,
2252 cluster_offset + offset_in_cluster,
2253 cur_bytes, true);
2254 if (ret < 0) {
2255 goto out_locked;
2256 }
2257
2258 qemu_co_mutex_unlock(&s->lock);
2259
2260 qemu_iovec_reset(&hd_qiov);
2261 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
2262
2263 if (bs->encrypted) {
2264 assert(s->crypto);
2265 if (!cluster_data) {
2266 cluster_data = qemu_try_blockalign(bs->file->bs,
2267 QCOW_MAX_CRYPT_CLUSTERS
2268 * s->cluster_size);
2269 if (cluster_data == NULL) {
2270 ret = -ENOMEM;
2271 goto out_unlocked;
2272 }
2273 }
2274
2275 assert(hd_qiov.size <=
2276 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2277 qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
2278
2279 if (qcow2_co_encrypt(bs, cluster_offset, offset,
2280 cluster_data, cur_bytes) < 0) {
2281 ret = -EIO;
2282 goto out_unlocked;
2283 }
2284
2285 qemu_iovec_reset(&hd_qiov);
2286 qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
2287 }
2288
2289 /* Try to efficiently initialize the physical space with zeroes */
2290 ret = handle_alloc_space(bs, l2meta);
2291 if (ret < 0) {
2292 goto out_unlocked;
2293 }
2294
2295 /* If we need to do COW, check if it's possible to merge the
2296 * writing of the guest data together with that of the COW regions.
2297 * If it's not possible (or not necessary) then write the
2298 * guest data now. */
2299 if (!merge_cow(offset, cur_bytes, &hd_qiov, l2meta)) {
2300 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
2301 trace_qcow2_writev_data(qemu_coroutine_self(),
2302 cluster_offset + offset_in_cluster);
2303 ret = bdrv_co_pwritev(s->data_file,
2304 cluster_offset + offset_in_cluster,
2305 cur_bytes, &hd_qiov, 0);
2306 if (ret < 0) {
2307 goto out_unlocked;
2308 }
2309 }
2310
2311 qemu_co_mutex_lock(&s->lock);
2312
2313 ret = qcow2_handle_l2meta(bs, &l2meta, true);
2314 if (ret) {
2315 goto out_locked;
2316 }
2317
2318 bytes -= cur_bytes;
2319 offset += cur_bytes;
2320 bytes_done += cur_bytes;
2321 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes);
2322 }
2323 ret = 0;
2324 goto out_locked;
2325
2326 out_unlocked:
2327 qemu_co_mutex_lock(&s->lock);
2328
2329 out_locked:
2330 qcow2_handle_l2meta(bs, &l2meta, false);
2331
2332 qemu_co_mutex_unlock(&s->lock);
2333
2334 qemu_iovec_destroy(&hd_qiov);
2335 qemu_vfree(cluster_data);
2336 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
2337
2338 return ret;
2339 }
2340
2341 static int qcow2_inactivate(BlockDriverState *bs)
2342 {
2343 BDRVQcow2State *s = bs->opaque;
2344 int ret, result = 0;
2345 Error *local_err = NULL;
2346
2347 qcow2_store_persistent_dirty_bitmaps(bs, &local_err);
2348 if (local_err != NULL) {
2349 result = -EINVAL;
2350 error_reportf_err(local_err, "Lost persistent bitmaps during "
2351 "inactivation of node '%s': ",
2352 bdrv_get_device_or_node_name(bs));
2353 }
2354
2355 ret = qcow2_cache_flush(bs, s->l2_table_cache);
2356 if (ret) {
2357 result = ret;
2358 error_report("Failed to flush the L2 table cache: %s",
2359 strerror(-ret));
2360 }
2361
2362 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2363 if (ret) {
2364 result = ret;
2365 error_report("Failed to flush the refcount block cache: %s",
2366 strerror(-ret));
2367 }
2368
2369 if (result == 0) {
2370 qcow2_mark_clean(bs);
2371 }
2372
2373 return result;
2374 }
2375
2376 static void qcow2_close(BlockDriverState *bs)
2377 {
2378 BDRVQcow2State *s = bs->opaque;
2379 qemu_vfree(s->l1_table);
2380 /* else pre-write overlap checks in cache_destroy may crash */
2381 s->l1_table = NULL;
2382
2383 if (!(s->flags & BDRV_O_INACTIVE)) {
2384 qcow2_inactivate(bs);
2385 }
2386
2387 cache_clean_timer_del(bs);
2388 qcow2_cache_destroy(s->l2_table_cache);
2389 qcow2_cache_destroy(s->refcount_block_cache);
2390
2391 qcrypto_block_free(s->crypto);
2392 s->crypto = NULL;
2393
2394 g_free(s->unknown_header_fields);
2395 cleanup_unknown_header_ext(bs);
2396
2397 g_free(s->image_data_file);
2398 g_free(s->image_backing_file);
2399 g_free(s->image_backing_format);
2400
2401 if (has_data_file(bs)) {
2402 bdrv_unref_child(bs, s->data_file);
2403 }
2404
2405 qcow2_refcount_close(bs);
2406 qcow2_free_snapshots(bs);
2407 }
2408
2409 static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
2410 Error **errp)
2411 {
2412 BDRVQcow2State *s = bs->opaque;
2413 int flags = s->flags;
2414 QCryptoBlock *crypto = NULL;
2415 QDict *options;
2416 Error *local_err = NULL;
2417 int ret;
2418
2419 /*
2420 * Backing files are read-only which makes all of their metadata immutable,
2421 * that means we don't have to worry about reopening them here.
2422 */
2423
2424 crypto = s->crypto;
2425 s->crypto = NULL;
2426
2427 qcow2_close(bs);
2428
2429 memset(s, 0, sizeof(BDRVQcow2State));
2430 options = qdict_clone_shallow(bs->options);
2431
2432 flags &= ~BDRV_O_INACTIVE;
2433 qemu_co_mutex_lock(&s->lock);
2434 ret = qcow2_do_open(bs, options, flags, &local_err);
2435 qemu_co_mutex_unlock(&s->lock);
2436 qobject_unref(options);
2437 if (local_err) {
2438 error_propagate_prepend(errp, local_err,
2439 "Could not reopen qcow2 layer: ");
2440 bs->drv = NULL;
2441 return;
2442 } else if (ret < 0) {
2443 error_setg_errno(errp, -ret, "Could not reopen qcow2 layer");
2444 bs->drv = NULL;
2445 return;
2446 }
2447
2448 s->crypto = crypto;
2449 }
2450
2451 static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
2452 size_t len, size_t buflen)
2453 {
2454 QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
2455 size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
2456
2457 if (buflen < ext_len) {
2458 return -ENOSPC;
2459 }
2460
2461 *ext_backing_fmt = (QCowExtension) {
2462 .magic = cpu_to_be32(magic),
2463 .len = cpu_to_be32(len),
2464 };
2465
2466 if (len) {
2467 memcpy(buf + sizeof(QCowExtension), s, len);
2468 }
2469
2470 return ext_len;
2471 }
2472
2473 /*
2474 * Updates the qcow2 header, including the variable length parts of it, i.e.
2475 * the backing file name and all extensions. qcow2 was not designed to allow
2476 * such changes, so if we run out of space (we can only use the first cluster)
2477 * this function may fail.
2478 *
2479 * Returns 0 on success, -errno in error cases.
2480 */
2481 int qcow2_update_header(BlockDriverState *bs)
2482 {
2483 BDRVQcow2State *s = bs->opaque;
2484 QCowHeader *header;
2485 char *buf;
2486 size_t buflen = s->cluster_size;
2487 int ret;
2488 uint64_t total_size;
2489 uint32_t refcount_table_clusters;
2490 size_t header_length;
2491 Qcow2UnknownHeaderExtension *uext;
2492
2493 buf = qemu_blockalign(bs, buflen);
2494
2495 /* Header structure */
2496 header = (QCowHeader*) buf;
2497
2498 if (buflen < sizeof(*header)) {
2499 ret = -ENOSPC;
2500 goto fail;
2501 }
2502
2503 header_length = sizeof(*header) + s->unknown_header_fields_size;
2504 total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
2505 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
2506
2507 *header = (QCowHeader) {
2508 /* Version 2 fields */
2509 .magic = cpu_to_be32(QCOW_MAGIC),
2510 .version = cpu_to_be32(s->qcow_version),
2511 .backing_file_offset = 0,
2512 .backing_file_size = 0,
2513 .cluster_bits = cpu_to_be32(s->cluster_bits),
2514 .size = cpu_to_be64(total_size),
2515 .crypt_method = cpu_to_be32(s->crypt_method_header),
2516 .l1_size = cpu_to_be32(s->l1_size),
2517 .l1_table_offset = cpu_to_be64(s->l1_table_offset),
2518 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset),
2519 .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
2520 .nb_snapshots = cpu_to_be32(s->nb_snapshots),
2521 .snapshots_offset = cpu_to_be64(s->snapshots_offset),
2522
2523 /* Version 3 fields */
2524 .incompatible_features = cpu_to_be64(s->incompatible_features),
2525 .compatible_features = cpu_to_be64(s->compatible_features),
2526 .autoclear_features = cpu_to_be64(s->autoclear_features),
2527 .refcount_order = cpu_to_be32(s->refcount_order),
2528 .header_length = cpu_to_be32(header_length),
2529 };
2530
2531 /* For older versions, write a shorter header */
2532 switch (s->qcow_version) {
2533 case 2:
2534 ret = offsetof(QCowHeader, incompatible_features);
2535 break;
2536 case 3:
2537 ret = sizeof(*header);
2538 break;
2539 default:
2540 ret = -EINVAL;
2541 goto fail;
2542 }
2543
2544 buf += ret;
2545 buflen -= ret;
2546 memset(buf, 0, buflen);
2547
2548 /* Preserve any unknown field in the header */
2549 if (s->unknown_header_fields_size) {
2550 if (buflen < s->unknown_header_fields_size) {
2551 ret = -ENOSPC;
2552 goto fail;
2553 }
2554
2555 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
2556 buf += s->unknown_header_fields_size;
2557 buflen -= s->unknown_header_fields_size;
2558 }
2559
2560 /* Backing file format header extension */
2561 if (s->image_backing_format) {
2562 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
2563 s->image_backing_format,
2564 strlen(s->image_backing_format),
2565 buflen);
2566 if (ret < 0) {
2567 goto fail;
2568 }
2569
2570 buf += ret;
2571 buflen -= ret;
2572 }
2573
2574 /* External data file header extension */
2575 if (has_data_file(bs) && s->image_data_file) {
2576 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_DATA_FILE,
2577 s->image_data_file, strlen(s->image_data_file),
2578 buflen);
2579 if (ret < 0) {
2580 goto fail;
2581 }
2582
2583 buf += ret;
2584 buflen -= ret;
2585 }
2586
2587 /* Full disk encryption header pointer extension */
2588 if (s->crypto_header.offset != 0) {
2589 s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset);
2590 s->crypto_header.length = cpu_to_be64(s->crypto_header.length);
2591 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
2592 &s->crypto_header, sizeof(s->crypto_header),
2593 buflen);
2594 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
2595 s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
2596 if (ret < 0) {
2597 goto fail;
2598 }
2599 buf += ret;
2600 buflen -= ret;
2601 }
2602
2603 /* Feature table */
2604 if (s->qcow_version >= 3) {
2605 Qcow2Feature features[] = {
2606 {
2607 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2608 .bit = QCOW2_INCOMPAT_DIRTY_BITNR,
2609 .name = "dirty bit",
2610 },
2611 {
2612 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2613 .bit = QCOW2_INCOMPAT_CORRUPT_BITNR,
2614 .name = "corrupt bit",
2615 },
2616 {
2617 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2618 .bit = QCOW2_INCOMPAT_DATA_FILE_BITNR,
2619 .name = "external data file",
2620 },
2621 {
2622 .type = QCOW2_FEAT_TYPE_COMPATIBLE,
2623 .bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
2624 .name = "lazy refcounts",
2625 },
2626 };
2627
2628 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
2629 features, sizeof(features), buflen);
2630 if (ret < 0) {
2631 goto fail;
2632 }
2633 buf += ret;
2634 buflen -= ret;
2635 }
2636
2637 /* Bitmap extension */
2638 if (s->nb_bitmaps > 0) {
2639 Qcow2BitmapHeaderExt bitmaps_header = {
2640 .nb_bitmaps = cpu_to_be32(s->nb_bitmaps),
2641 .bitmap_directory_size =
2642 cpu_to_be64(s->bitmap_directory_size),
2643 .bitmap_directory_offset =
2644 cpu_to_be64(s->bitmap_directory_offset)
2645 };
2646 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS,
2647 &bitmaps_header, sizeof(bitmaps_header),
2648 buflen);
2649 if (ret < 0) {
2650 goto fail;
2651 }
2652 buf += ret;
2653 buflen -= ret;
2654 }
2655
2656 /* Keep unknown header extensions */
2657 QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
2658 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
2659 if (ret < 0) {
2660 goto fail;
2661 }
2662
2663 buf += ret;
2664 buflen -= ret;
2665 }
2666
2667 /* End of header extensions */
2668 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
2669 if (ret < 0) {
2670 goto fail;
2671 }
2672
2673 buf += ret;
2674 buflen -= ret;
2675
2676 /* Backing file name */
2677 if (s->image_backing_file) {
2678 size_t backing_file_len = strlen(s->image_backing_file);
2679
2680 if (buflen < backing_file_len) {
2681 ret = -ENOSPC;
2682 goto fail;
2683 }
2684
2685 /* Using strncpy is ok here, since buf is not NUL-terminated. */
2686 strncpy(buf, s->image_backing_file, buflen);
2687
2688 header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
2689 header->backing_file_size = cpu_to_be32(backing_file_len);
2690 }
2691
2692 /* Write the new header */
2693 ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
2694 if (ret < 0) {
2695 goto fail;
2696 }
2697
2698 ret = 0;
2699 fail:
2700 qemu_vfree(header);
2701 return ret;
2702 }
2703
2704 static int qcow2_change_backing_file(BlockDriverState *bs,
2705 const char *backing_file, const char *backing_fmt)
2706 {
2707 BDRVQcow2State *s = bs->opaque;
2708
2709 /* Adding a backing file means that the external data file alone won't be
2710 * enough to make sense of the content */
2711 if (backing_file && data_file_is_raw(bs)) {
2712 return -EINVAL;
2713 }
2714
2715 if (backing_file && strlen(backing_file) > 1023) {
2716 return -EINVAL;
2717 }
2718
2719 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
2720 backing_file ?: "");
2721 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2722 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2723
2724 g_free(s->image_backing_file);
2725 g_free(s->image_backing_format);
2726
2727 s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
2728 s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
2729
2730 return qcow2_update_header(bs);
2731 }
2732
2733 static int qcow2_crypt_method_from_format(const char *encryptfmt)
2734 {
2735 if (g_str_equal(encryptfmt, "luks")) {
2736 return QCOW_CRYPT_LUKS;
2737 } else if (g_str_equal(encryptfmt, "aes")) {
2738 return QCOW_CRYPT_AES;
2739 } else {
2740 return -EINVAL;
2741 }
2742 }
2743
2744 static int qcow2_set_up_encryption(BlockDriverState *bs,
2745 QCryptoBlockCreateOptions *cryptoopts,
2746 Error **errp)
2747 {
2748 BDRVQcow2State *s = bs->opaque;
2749 QCryptoBlock *crypto = NULL;
2750 int fmt, ret;
2751
2752 switch (cryptoopts->format) {
2753 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
2754 fmt = QCOW_CRYPT_LUKS;
2755 break;
2756 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
2757 fmt = QCOW_CRYPT_AES;
2758 break;
2759 default:
2760 error_setg(errp, "Crypto format not supported in qcow2");
2761 return -EINVAL;
2762 }
2763
2764 s->crypt_method_header = fmt;
2765
2766 crypto = qcrypto_block_create(cryptoopts, "encrypt.",
2767 qcow2_crypto_hdr_init_func,
2768 qcow2_crypto_hdr_write_func,
2769 bs, errp);
2770 if (!crypto) {
2771 return -EINVAL;
2772 }
2773
2774 ret = qcow2_update_header(bs);
2775 if (ret < 0) {
2776 error_setg_errno(errp, -ret, "Could not write encryption header");
2777 goto out;
2778 }
2779
2780 ret = 0;
2781 out:
2782 qcrypto_block_free(crypto);
2783 return ret;
2784 }
2785
2786 /**
2787 * Preallocates metadata structures for data clusters between @offset (in the
2788 * guest disk) and @new_length (which is thus generally the new guest disk
2789 * size).
2790 *
2791 * Returns: 0 on success, -errno on failure.
2792 */
2793 static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
2794 uint64_t new_length, PreallocMode mode,
2795 Error **errp)
2796 {
2797 BDRVQcow2State *s = bs->opaque;
2798 uint64_t bytes;
2799 uint64_t host_offset = 0;
2800 int64_t file_length;
2801 unsigned int cur_bytes;
2802 int ret;
2803 QCowL2Meta *meta;
2804
2805 assert(offset <= new_length);
2806 bytes = new_length - offset;
2807
2808 while (bytes) {
2809 cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size));
2810 ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,
2811 &host_offset, &meta);
2812 if (ret < 0) {
2813 error_setg_errno(errp, -ret, "Allocating clusters failed");
2814 return ret;
2815 }
2816
2817 while (meta) {
2818 QCowL2Meta *next = meta->next;
2819
2820 ret = qcow2_alloc_cluster_link_l2(bs, meta);
2821 if (ret < 0) {
2822 error_setg_errno(errp, -ret, "Mapping clusters failed");
2823 qcow2_free_any_clusters(bs, meta->alloc_offset,
2824 meta->nb_clusters, QCOW2_DISCARD_NEVER);
2825 return ret;
2826 }
2827
2828 /* There are no dependent requests, but we need to remove our
2829 * request from the list of in-flight requests */
2830 QLIST_REMOVE(meta, next_in_flight);
2831
2832 g_free(meta);
2833 meta = next;
2834 }
2835
2836 /* TODO Preallocate data if requested */
2837
2838 bytes -= cur_bytes;
2839 offset += cur_bytes;
2840 }
2841
2842 /*
2843 * It is expected that the image file is large enough to actually contain
2844 * all of the allocated clusters (otherwise we get failing reads after
2845 * EOF). Extend the image to the last allocated sector.
2846 */
2847 file_length = bdrv_getlength(s->data_file->bs);
2848 if (file_length < 0) {
2849 error_setg_errno(errp, -file_length, "Could not get file size");
2850 return file_length;
2851 }
2852
2853 if (host_offset + cur_bytes > file_length) {
2854 if (mode == PREALLOC_MODE_METADATA) {
2855 mode = PREALLOC_MODE_OFF;
2856 }
2857 ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, mode,
2858 errp);
2859 if (ret < 0) {
2860 return ret;
2861 }
2862 }
2863
2864 return 0;
2865 }
2866
2867 /* qcow2_refcount_metadata_size:
2868 * @clusters: number of clusters to refcount (including data and L1/L2 tables)
2869 * @cluster_size: size of a cluster, in bytes
2870 * @refcount_order: refcount bits power-of-2 exponent
2871 * @generous_increase: allow for the refcount table to be 1.5x as large as it
2872 * needs to be
2873 *
2874 * Returns: Number of bytes required for refcount blocks and table metadata.
2875 */
2876 int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
2877 int refcount_order, bool generous_increase,
2878 uint64_t *refblock_count)
2879 {
2880 /*
2881 * Every host cluster is reference-counted, including metadata (even
2882 * refcount metadata is recursively included).
2883 *
2884 * An accurate formula for the size of refcount metadata size is difficult
2885 * to derive. An easier method of calculation is finding the fixed point
2886 * where no further refcount blocks or table clusters are required to
2887 * reference count every cluster.
2888 */
2889 int64_t blocks_per_table_cluster = cluster_size / sizeof(uint64_t);
2890 int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order);
2891 int64_t table = 0; /* number of refcount table clusters */
2892 int64_t blocks = 0; /* number of refcount block clusters */
2893 int64_t last;
2894 int64_t n = 0;
2895
2896 do {
2897 last = n;
2898 blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block);
2899 table = DIV_ROUND_UP(blocks, blocks_per_table_cluster);
2900 n = clusters + blocks + table;
2901
2902 if (n == last && generous_increase) {
2903 clusters += DIV_ROUND_UP(table, 2);
2904 n = 0; /* force another loop */
2905 generous_increase = false;
2906 }
2907 } while (n != last);
2908
2909 if (refblock_count) {
2910 *refblock_count = blocks;
2911 }
2912
2913 return (blocks + table) * cluster_size;
2914 }
2915
2916 /**
2917 * qcow2_calc_prealloc_size:
2918 * @total_size: virtual disk size in bytes
2919 * @cluster_size: cluster size in bytes
2920 * @refcount_order: refcount bits power-of-2 exponent
2921 *
2922 * Returns: Total number of bytes required for the fully allocated image
2923 * (including metadata).
2924 */
2925 static int64_t qcow2_calc_prealloc_size(int64_t total_size,
2926 size_t cluster_size,
2927 int refcount_order)
2928 {
2929 int64_t meta_size = 0;
2930 uint64_t nl1e, nl2e;
2931 int64_t aligned_total_size = ROUND_UP(total_size, cluster_size);
2932
2933 /* header: 1 cluster */
2934 meta_size += cluster_size;
2935
2936 /* total size of L2 tables */
2937 nl2e = aligned_total_size / cluster_size;
2938 nl2e = ROUND_UP(nl2e, cluster_size / sizeof(uint64_t));
2939 meta_size += nl2e * sizeof(uint64_t);
2940
2941 /* total size of L1 tables */
2942 nl1e = nl2e * sizeof(uint64_t) / cluster_size;
2943 nl1e = ROUND_UP(nl1e, cluster_size / sizeof(uint64_t));
2944 meta_size += nl1e * sizeof(uint64_t);
2945
2946 /* total size of refcount table and blocks */
2947 meta_size += qcow2_refcount_metadata_size(
2948 (meta_size + aligned_total_size) / cluster_size,
2949 cluster_size, refcount_order, false, NULL);
2950
2951 return meta_size + aligned_total_size;
2952 }
2953
2954 static bool validate_cluster_size(size_t cluster_size, Error **errp)
2955 {
2956 int cluster_bits = ctz32(cluster_size);
2957 if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
2958 (1 << cluster_bits) != cluster_size)
2959 {
2960 error_setg(errp, "Cluster size must be a power of two between %d and "
2961 "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
2962 return false;
2963 }
2964 return true;
2965 }
2966
2967 static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, Error **errp)
2968 {
2969 size_t cluster_size;
2970
2971 cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
2972 DEFAULT_CLUSTER_SIZE);
2973 if (!validate_cluster_size(cluster_size, errp)) {
2974 return 0;
2975 }
2976 return cluster_size;
2977 }
2978
2979 static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp)
2980 {
2981 char *buf;
2982 int ret;
2983
2984 buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
2985 if (!buf) {
2986 ret = 3; /* default */
2987 } else if (!strcmp(buf, "0.10")) {
2988 ret = 2;
2989 } else if (!strcmp(buf, "1.1")) {
2990 ret = 3;
2991 } else {
2992 error_setg(errp, "Invalid compatibility level: '%s'", buf);
2993 ret = -EINVAL;
2994 }
2995 g_free(buf);
2996 return ret;
2997 }
2998
2999 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
3000 Error **errp)
3001 {
3002 uint64_t refcount_bits;
3003
3004 refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16);
3005 if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
3006 error_setg(errp, "Refcount width must be a power of two and may not "
3007 "exceed 64 bits");
3008 return 0;
3009 }
3010
3011 if (version < 3 && refcount_bits != 16) {
3012 error_setg(errp, "Different refcount widths than 16 bits require "
3013 "compatibility level 1.1 or above (use compat=1.1 or "
3014 "greater)");
3015 return 0;
3016 }
3017
3018 return refcount_bits;
3019 }
3020
3021 static int coroutine_fn
3022 qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
3023 {
3024 BlockdevCreateOptionsQcow2 *qcow2_opts;
3025 QDict *options;
3026
3027 /*
3028 * Open the image file and write a minimal qcow2 header.
3029 *
3030 * We keep things simple and start with a zero-sized image. We also
3031 * do without refcount blocks or a L1 table for now. We'll fix the
3032 * inconsistency later.
3033 *
3034 * We do need a refcount table because growing the refcount table means
3035 * allocating two new refcount blocks - the seconds of which would be at
3036 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
3037 * size for any qcow2 image.
3038 */
3039 BlockBackend *blk = NULL;
3040 BlockDriverState *bs = NULL;
3041 BlockDriverState *data_bs = NULL;
3042 QCowHeader *header;
3043 size_t cluster_size;
3044 int version;
3045 int refcount_order;
3046 uint64_t* refcount_table;
3047 Error *local_err = NULL;
3048 int ret;
3049
3050 assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2);
3051 qcow2_opts = &create_options->u.qcow2;
3052
3053 bs = bdrv_open_blockdev_ref(qcow2_opts->file, errp);
3054 if (bs == NULL) {
3055 return -EIO;
3056 }
3057
3058 /* Validate options and set default values */
3059 if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) {
3060 error_setg(errp, "Image size must be a multiple of 512 bytes");
3061 ret = -EINVAL;
3062 goto out;
3063 }
3064
3065 if (qcow2_opts->has_version) {
3066 switch (qcow2_opts->version) {
3067 case BLOCKDEV_QCOW2_VERSION_V2:
3068 version = 2;
3069 break;
3070 case BLOCKDEV_QCOW2_VERSION_V3:
3071 version = 3;
3072 break;
3073 default:
3074 g_assert_not_reached();
3075 }
3076 } else {
3077 version = 3;
3078 }
3079
3080 if (qcow2_opts->has_cluster_size) {
3081 cluster_size = qcow2_opts->cluster_size;
3082 } else {
3083 cluster_size = DEFAULT_CLUSTER_SIZE;
3084 }
3085
3086 if (!validate_cluster_size(cluster_size, errp)) {
3087 ret = -EINVAL;
3088 goto out;
3089 }
3090
3091 if (!qcow2_opts->has_preallocation) {
3092 qcow2_opts->preallocation = PREALLOC_MODE_OFF;
3093 }
3094 if (qcow2_opts->has_backing_file &&
3095 qcow2_opts->preallocation != PREALLOC_MODE_OFF)
3096 {
3097 error_setg(errp, "Backing file and preallocation cannot be used at "
3098 "the same time");
3099 ret = -EINVAL;
3100 goto out;
3101 }
3102 if (qcow2_opts->has_backing_fmt && !qcow2_opts->has_backing_file) {
3103 error_setg(errp, "Backing format cannot be used without backing file");
3104 ret = -EINVAL;
3105 goto out;
3106 }
3107
3108 if (!qcow2_opts->has_lazy_refcounts) {
3109 qcow2_opts->lazy_refcounts = false;
3110 }
3111 if (version < 3 && qcow2_opts->lazy_refcounts) {
3112 error_setg(errp, "Lazy refcounts only supported with compatibility "
3113 "level 1.1 and above (use version=v3 or greater)");
3114 ret = -EINVAL;
3115 goto out;
3116 }
3117
3118 if (!qcow2_opts->has_refcount_bits) {
3119 qcow2_opts->refcount_bits = 16;
3120 }
3121 if (qcow2_opts->refcount_bits > 64 ||
3122 !is_power_of_2(qcow2_opts->refcount_bits))
3123 {
3124 error_setg(errp, "Refcount width must be a power of two and may not "
3125 "exceed 64 bits");
3126 ret = -EINVAL;
3127 goto out;
3128 }
3129 if (version < 3 && qcow2_opts->refcount_bits != 16) {
3130 error_setg(errp, "Different refcount widths than 16 bits require "
3131 "compatibility level 1.1 or above (use version=v3 or "
3132 "greater)");
3133 ret = -EINVAL;
3134 goto out;
3135 }
3136 refcount_order = ctz32(qcow2_opts->refcount_bits);
3137
3138 if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) {
3139 error_setg(errp, "data-file-raw requires data-file");
3140 ret = -EINVAL;
3141 goto out;
3142 }
3143 if (qcow2_opts->data_file_raw && qcow2_opts->has_backing_file) {
3144 error_setg(errp, "Backing file and data-file-raw cannot be used at "
3145 "the same time");
3146 ret = -EINVAL;
3147 goto out;
3148 }
3149
3150 if (qcow2_opts->data_file) {
3151 if (version < 3) {
3152 error_setg(errp, "External data files are only supported with "
3153 "compatibility level 1.1 and above (use version=v3 or "
3154 "greater)");
3155 ret = -EINVAL;
3156 goto out;
3157 }
3158 data_bs = bdrv_open_blockdev_ref(qcow2_opts->data_file, errp);
3159 if (data_bs == NULL) {
3160 ret = -EIO;
3161 goto out;
3162 }
3163 }
3164
3165 /* Create BlockBackend to write to the image */
3166 blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
3167 ret = blk_insert_bs(blk, bs, errp);
3168 if (ret < 0) {
3169 goto out;
3170 }
3171 blk_set_allow_write_beyond_eof(blk, true);
3172
3173 /* Clear the protocol layer and preallocate it if necessary */
3174 ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp);
3175 if (ret < 0) {
3176 goto out;
3177 }
3178
3179 /* Write the header */
3180 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
3181 header = g_malloc0(cluster_size);
3182 *header = (QCowHeader) {
3183 .magic = cpu_to_be32(QCOW_MAGIC),
3184 .version = cpu_to_be32(version),
3185 .cluster_bits = cpu_to_be32(ctz32(cluster_size)),
3186 .size = cpu_to_be64(0),
3187 .l1_table_offset = cpu_to_be64(0),
3188 .l1_size = cpu_to_be32(0),
3189 .refcount_table_offset = cpu_to_be64(cluster_size),
3190 .refcount_table_clusters = cpu_to_be32(1),
3191 .refcount_order = cpu_to_be32(refcount_order),
3192 .header_length = cpu_to_be32(sizeof(*header)),
3193 };
3194
3195 /* We'll update this to correct value later */
3196 header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
3197
3198 if (qcow2_opts->lazy_refcounts) {
3199 header->compatible_features |=
3200 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
3201 }
3202 if (data_bs) {
3203 header->incompatible_features |=
3204 cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE);
3205 }
3206 if (qcow2_opts->data_file_raw) {
3207 header->autoclear_features |=
3208 cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW);
3209 }
3210
3211 ret = blk_pwrite(blk, 0, header, cluster_size, 0);
3212 g_free(header);
3213 if (ret < 0) {
3214 error_setg_errno(errp, -ret, "Could not write qcow2 header");
3215 goto out;
3216 }
3217
3218 /* Write a refcount table with one refcount block */
3219 refcount_table = g_malloc0(2 * cluster_size);
3220 refcount_table[0] = cpu_to_be64(2 * cluster_size);
3221 ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
3222 g_free(refcount_table);
3223
3224 if (ret < 0) {
3225 error_setg_errno(errp, -ret, "Could not write refcount table");
3226 goto out;
3227 }
3228
3229 blk_unref(blk);
3230 blk = NULL;
3231
3232 /*
3233 * And now open the image and make it consistent first (i.e. increase the
3234 * refcount of the cluster that is occupied by the header and the refcount
3235 * table)
3236 */
3237 options = qdict_new();
3238 qdict_put_str(options, "driver", "qcow2");
3239 qdict_put_str(options, "file", bs->node_name);
3240 if (data_bs) {
3241 qdict_put_str(options, "data-file", data_bs->node_name);
3242 }
3243 blk = blk_new_open(NULL, NULL, options,
3244 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
3245 &local_err);
3246 if (blk == NULL) {
3247 error_propagate(errp, local_err);
3248 ret = -EIO;
3249 goto out;
3250 }
3251
3252 ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
3253 if (ret < 0) {
3254 error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
3255 "header and refcount table");
3256 goto out;
3257
3258 } else if (ret != 0) {
3259 error_report("Huh, first cluster in empty image is already in use?");
3260 abort();
3261 }
3262
3263 /* Set the external data file if necessary */
3264 if (data_bs) {
3265 BDRVQcow2State *s = blk_bs(blk)->opaque;
3266 s->image_data_file = g_strdup(data_bs->filename);
3267 }
3268
3269 /* Create a full header (including things like feature table) */
3270 ret = qcow2_update_header(blk_bs(blk));
3271 if (ret < 0) {
3272 error_setg_errno(errp, -ret, "Could not update qcow2 header");
3273 goto out;
3274 }
3275
3276 /* Okay, now that we have a valid image, let's give it the right size */
3277 ret = blk_truncate(blk, qcow2_opts->size, qcow2_opts->preallocation, errp);
3278 if (ret < 0) {
3279 error_prepend(errp, "Could not resize image: ");
3280 goto out;
3281 }
3282
3283 /* Want a backing file? There you go.*/
3284 if (qcow2_opts->has_backing_file) {
3285 const char *backing_format = NULL;
3286
3287 if (qcow2_opts->has_backing_fmt) {
3288 backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt);
3289 }
3290
3291 ret = bdrv_change_backing_file(blk_bs(blk), qcow2_opts->backing_file,
3292 backing_format);
3293 if (ret < 0) {
3294 error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
3295 "with format '%s'", qcow2_opts->backing_file,
3296 backing_format);
3297 goto out;
3298 }
3299 }
3300
3301 /* Want encryption? There you go. */
3302 if (qcow2_opts->has_encrypt) {
3303 ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
3304 if (ret < 0) {
3305 goto out;
3306 }
3307 }
3308
3309 blk_unref(blk);
3310 blk = NULL;
3311
3312 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
3313 * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
3314 * have to setup decryption context. We're not doing any I/O on the top
3315 * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
3316 * not have effect.
3317 */
3318 options = qdict_new();
3319 qdict_put_str(options, "driver", "qcow2");
3320 qdict_put_str(options, "file", bs->node_name);
3321 if (data_bs) {
3322 qdict_put_str(options, "data-file", data_bs->node_name);
3323 }
3324 blk = blk_new_open(NULL, NULL, options,
3325 BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
3326 &local_err);
3327 if (blk == NULL) {
3328 error_propagate(errp, local_err);
3329 ret = -EIO;
3330 goto out;
3331 }
3332
3333 ret = 0;
3334 out:
3335 blk_unref(blk);
3336 bdrv_unref(bs);
3337 bdrv_unref(data_bs);
3338 return ret;
3339 }
3340
3341 static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opts,
3342 Error **errp)
3343 {
3344 BlockdevCreateOptions *create_options = NULL;
3345 QDict *qdict;
3346 Visitor *v;
3347 BlockDriverState *bs = NULL;
3348 BlockDriverState *data_bs = NULL;
3349 Error *local_err = NULL;
3350 const char *val;
3351 int ret;
3352
3353 /* Only the keyval visitor supports the dotted syntax needed for
3354 * encryption, so go through a QDict before getting a QAPI type. Ignore
3355 * options meant for the protocol layer so that the visitor doesn't
3356 * complain. */
3357 qdict = qemu_opts_to_qdict_filtered(opts, NULL, bdrv_qcow2.create_opts,
3358 true);
3359
3360 /* Handle encryption options */
3361 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT);
3362 if (val && !strcmp(val, "on")) {
3363 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow");
3364 } else if (val && !strcmp(val, "off")) {
3365 qdict_del(qdict, BLOCK_OPT_ENCRYPT);
3366 }
3367
3368 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT);
3369 if (val && !strcmp(val, "aes")) {
3370 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow");
3371 }
3372
3373 /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into
3374 * version=v2/v3 below. */
3375 val = qdict_get_try_str(qdict, BLOCK_OPT_COMPAT_LEVEL);
3376 if (val && !strcmp(val, "0.10")) {
3377 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v2");
3378 } else if (val && !strcmp(val, "1.1")) {
3379 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v3");
3380 }
3381
3382 /* Change legacy command line options into QMP ones */
3383 static const QDictRenames opt_renames[] = {
3384 { BLOCK_OPT_BACKING_FILE, "backing-file" },
3385 { BLOCK_OPT_BACKING_FMT, "backing-fmt" },
3386 { BLOCK_OPT_CLUSTER_SIZE, "cluster-size" },
3387 { BLOCK_OPT_LAZY_REFCOUNTS, "lazy-refcounts" },
3388 { BLOCK_OPT_REFCOUNT_BITS, "refcount-bits" },
3389 { BLOCK_OPT_ENCRYPT, BLOCK_OPT_ENCRYPT_FORMAT },
3390 { BLOCK_OPT_COMPAT_LEVEL, "version" },
3391 { BLOCK_OPT_DATA_FILE_RAW, "data-file-raw" },
3392 { NULL, NULL },
3393 };
3394
3395 if (!qdict_rename_keys(qdict, opt_renames, errp)) {
3396 ret = -EINVAL;
3397 goto finish;
3398 }
3399
3400 /* Create and open the file (protocol layer) */
3401 ret = bdrv_create_file(filename, opts, errp);
3402 if (ret < 0) {
3403 goto finish;
3404 }
3405
3406 bs = bdrv_open(filename, NULL, NULL,
3407 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
3408 if (bs == NULL) {
3409 ret = -EIO;
3410 goto finish;
3411 }
3412
3413 /* Create and open an external data file (protocol layer) */
3414 val = qdict_get_try_str(qdict, BLOCK_OPT_DATA_FILE);
3415 if (val) {
3416 ret = bdrv_create_file(val, opts, errp);
3417 if (ret < 0) {
3418 goto finish;
3419 }
3420
3421 data_bs = bdrv_open(val, NULL, NULL,
3422 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
3423 errp);
3424 if (data_bs == NULL) {
3425 ret = -EIO;
3426 goto finish;
3427 }
3428
3429 qdict_del(qdict, BLOCK_OPT_DATA_FILE);
3430 qdict_put_str(qdict, "data-file", data_bs->node_name);
3431 }
3432
3433 /* Set 'driver' and 'node' options */
3434 qdict_put_str(qdict, "driver", "qcow2");
3435 qdict_put_str(qdict, "file", bs->node_name);
3436
3437 /* Now get the QAPI type BlockdevCreateOptions */
3438 v = qobject_input_visitor_new_flat_confused(qdict, errp);
3439 if (!v) {
3440 ret = -EINVAL;
3441 goto finish;
3442 }
3443
3444 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
3445 visit_free(v);
3446
3447 if (local_err) {
3448 error_propagate(errp, local_err);
3449 ret = -EINVAL;
3450 goto finish;
3451 }
3452
3453 /* Silently round up size */
3454 create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size,
3455 BDRV_SECTOR_SIZE);
3456
3457 /* Create the qcow2 image (format layer) */
3458 ret = qcow2_co_create(create_options, errp);
3459 if (ret < 0) {
3460 goto finish;
3461 }
3462
3463 ret = 0;
3464 finish:
3465 qobject_unref(qdict);
3466 bdrv_unref(bs);
3467 bdrv_unref(data_bs);
3468 qapi_free_BlockdevCreateOptions(create_options);
3469 return ret;
3470 }
3471
3472
3473 static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
3474 {
3475 int64_t nr;
3476 int res;
3477
3478 /* Clamp to image length, before checking status of underlying sectors */
3479 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3480 bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset;
3481 }
3482
3483 if (!bytes) {
3484 return true;
3485 }
3486 res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
3487 return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;
3488 }
3489
3490 static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
3491 int64_t offset, int bytes, BdrvRequestFlags flags)
3492 {
3493 int ret;
3494 BDRVQcow2State *s = bs->opaque;
3495
3496 uint32_t head = offset % s->cluster_size;
3497 uint32_t tail = (offset + bytes) % s->cluster_size;
3498
3499 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes);
3500 if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) {
3501 tail = 0;
3502 }
3503
3504 if (head || tail) {
3505 uint64_t off;
3506 unsigned int nr;
3507
3508 assert(head + bytes <= s->cluster_size);
3509
3510 /* check whether remainder of cluster already reads as zero */
3511 if (!(is_zero(bs, offset - head, head) &&
3512 is_zero(bs, offset + bytes,
3513 tail ? s->cluster_size - tail : 0))) {
3514 return -ENOTSUP;
3515 }
3516
3517 qemu_co_mutex_lock(&s->lock);
3518 /* We can have new write after previous check */
3519 offset = QEMU_ALIGN_DOWN(offset, s->cluster_size);
3520 bytes = s->cluster_size;
3521 nr = s->cluster_size;
3522 ret = qcow2_get_cluster_offset(bs, offset, &nr, &off);
3523 if (ret != QCOW2_CLUSTER_UNALLOCATED &&
3524 ret != QCOW2_CLUSTER_ZERO_PLAIN &&
3525 ret != QCOW2_CLUSTER_ZERO_ALLOC) {
3526 qemu_co_mutex_unlock(&s->lock);
3527 return -ENOTSUP;
3528 }
3529 } else {
3530 qemu_co_mutex_lock(&s->lock);
3531 }
3532
3533 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes);
3534
3535 /* Whatever is left can use real zero clusters */
3536 ret = qcow2_cluster_zeroize(bs, offset, bytes, flags);
3537 qemu_co_mutex_unlock(&s->lock);
3538
3539 return ret;
3540 }
3541
3542 static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
3543 int64_t offset, int bytes)
3544 {
3545 int ret;
3546 BDRVQcow2State *s = bs->opaque;
3547
3548 if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) {
3549 assert(bytes < s->cluster_size);
3550 /* Ignore partial clusters, except for the special case of the
3551 * complete partial cluster at the end of an unaligned file */
3552 if (!QEMU_IS_ALIGNED(offset, s->cluster_size) ||
3553 offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) {
3554 return -ENOTSUP;
3555 }
3556 }
3557
3558 qemu_co_mutex_lock(&s->lock);
3559 ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST,
3560 false);
3561 qemu_co_mutex_unlock(&s->lock);
3562 return ret;
3563 }
3564
3565 static int coroutine_fn
3566 qcow2_co_copy_range_from(BlockDriverState *bs,
3567 BdrvChild *src, uint64_t src_offset,
3568 BdrvChild *dst, uint64_t dst_offset,
3569 uint64_t bytes, BdrvRequestFlags read_flags,
3570 BdrvRequestFlags write_flags)
3571 {
3572 BDRVQcow2State *s = bs->opaque;
3573 int ret;
3574 unsigned int cur_bytes; /* number of bytes in current iteration */
3575 BdrvChild *child = NULL;
3576 BdrvRequestFlags cur_write_flags;
3577
3578 assert(!bs->encrypted);
3579 qemu_co_mutex_lock(&s->lock);
3580
3581 while (bytes != 0) {
3582 uint64_t copy_offset = 0;
3583 /* prepare next request */
3584 cur_bytes = MIN(bytes, INT_MAX);
3585 cur_write_flags = write_flags;
3586
3587 ret = qcow2_get_cluster_offset(bs, src_offset, &cur_bytes, &copy_offset);
3588 if (ret < 0) {
3589 goto out;
3590 }
3591
3592 switch (ret) {
3593 case QCOW2_CLUSTER_UNALLOCATED:
3594 if (bs->backing && bs->backing->bs) {
3595 int64_t backing_length = bdrv_getlength(bs->backing->bs);
3596 if (src_offset >= backing_length) {
3597 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
3598 } else {
3599 child = bs->backing;
3600 cur_bytes = MIN(cur_bytes, backing_length - src_offset);
3601 copy_offset = src_offset;
3602 }
3603 } else {
3604 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
3605 }
3606 break;
3607
3608 case QCOW2_CLUSTER_ZERO_PLAIN:
3609 case QCOW2_CLUSTER_ZERO_ALLOC:
3610 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
3611 break;
3612
3613 case QCOW2_CLUSTER_COMPRESSED:
3614 ret = -ENOTSUP;
3615 goto out;
3616
3617 case QCOW2_CLUSTER_NORMAL:
3618 child = s->data_file;
3619 copy_offset += offset_into_cluster(s, src_offset);
3620 if ((copy_offset & 511) != 0) {
3621 ret = -EIO;
3622 goto out;
3623 }
3624 break;
3625
3626 default:
3627 abort();
3628 }
3629 qemu_co_mutex_unlock(&s->lock);
3630 ret = bdrv_co_copy_range_from(child,
3631 copy_offset,
3632 dst, dst_offset,
3633 cur_bytes, read_flags, cur_write_flags);
3634 qemu_co_mutex_lock(&s->lock);
3635 if (ret < 0) {
3636 goto out;
3637 }
3638
3639 bytes -= cur_bytes;
3640 src_offset += cur_bytes;
3641 dst_offset += cur_bytes;
3642 }
3643 ret = 0;
3644
3645 out:
3646 qemu_co_mutex_unlock(&s->lock);
3647 return ret;
3648 }
3649
3650 static int coroutine_fn
3651 qcow2_co_copy_range_to(BlockDriverState *bs,
3652 BdrvChild *src, uint64_t src_offset,
3653 BdrvChild *dst, uint64_t dst_offset,
3654 uint64_t bytes, BdrvRequestFlags read_flags,
3655 BdrvRequestFlags write_flags)
3656 {
3657 BDRVQcow2State *s = bs->opaque;
3658 int offset_in_cluster;
3659 int ret;
3660 unsigned int cur_bytes; /* number of sectors in current iteration */
3661 uint64_t cluster_offset;
3662 QCowL2Meta *l2meta = NULL;
3663
3664 assert(!bs->encrypted);
3665
3666 qemu_co_mutex_lock(&s->lock);
3667
3668 while (bytes != 0) {
3669
3670 l2meta = NULL;
3671
3672 offset_in_cluster = offset_into_cluster(s, dst_offset);
3673 cur_bytes = MIN(bytes, INT_MAX);
3674
3675 /* TODO:
3676 * If src->bs == dst->bs, we could simply copy by incrementing
3677 * the refcnt, without copying user data.
3678 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
3679 ret = qcow2_alloc_cluster_offset(bs, dst_offset, &cur_bytes,
3680 &cluster_offset, &l2meta);
3681 if (ret < 0) {
3682 goto fail;
3683 }
3684
3685 assert((cluster_offset & 511) == 0);
3686
3687 ret = qcow2_pre_write_overlap_check(bs, 0,
3688 cluster_offset + offset_in_cluster, cur_bytes, true);
3689 if (ret < 0) {
3690 goto fail;
3691 }
3692
3693 qemu_co_mutex_unlock(&s->lock);
3694 ret = bdrv_co_copy_range_to(src, src_offset,
3695 s->data_file,
3696 cluster_offset + offset_in_cluster,
3697 cur_bytes, read_flags, write_flags);
3698 qemu_co_mutex_lock(&s->lock);
3699 if (ret < 0) {
3700 goto fail;
3701 }
3702
3703 ret = qcow2_handle_l2meta(bs, &l2meta, true);
3704 if (ret) {
3705 goto fail;
3706 }
3707
3708 bytes -= cur_bytes;