2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
27 #include "block/qdict.h"
28 #include "sysemu/block-backend.h"
29 #include "qemu/main-loop.h"
30 #include "qemu/module.h"
32 #include "qemu/error-report.h"
33 #include "qapi/error.h"
34 #include "qapi/qapi-events-block-core.h"
35 #include "qapi/qmp/qdict.h"
36 #include "qapi/qmp/qstring.h"
38 #include "qemu/option_int.h"
39 #include "qemu/cutils.h"
40 #include "qemu/bswap.h"
41 #include "qemu/memalign.h"
42 #include "qapi/qobject-input-visitor.h"
43 #include "qapi/qapi-visit-block-core.h"
45 #include "block/aio_task.h"
46 #include "block/dirty-bitmap.h"
49 Differences with QCOW:
51 - Support for multiple incremental snapshots.
52 - Memory management by reference counts.
53 - Clusters which have a reference count of one have the bit
54 QCOW_OFLAG_COPIED to optimize write performance.
55 - Size of compressed clusters is stored in sectors to reduce bit usage
56 in the cluster offsets.
57 - Support for storing additional data (such as the VM state) in the
59 - If a backing store is used, the cluster size is not constrained
60 (could be backported to QCOW).
61 - L2 tables have always a size of one cluster.
68 } QEMU_PACKED QCowExtension
;
70 #define QCOW2_EXT_MAGIC_END 0
71 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xe2792aca
72 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
73 #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
74 #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875
75 #define QCOW2_EXT_MAGIC_DATA_FILE 0x44415441
77 static int coroutine_fn
78 qcow2_co_preadv_compressed(BlockDriverState
*bs
,
85 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
87 const QCowHeader
*cow_header
= (const void *)buf
;
89 if (buf_size
>= sizeof(QCowHeader
) &&
90 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
91 be32_to_cpu(cow_header
->version
) >= 2)
98 static int qcow2_crypto_hdr_read_func(QCryptoBlock
*block
, size_t offset
,
99 uint8_t *buf
, size_t buflen
,
100 void *opaque
, Error
**errp
)
102 BlockDriverState
*bs
= opaque
;
103 BDRVQcow2State
*s
= bs
->opaque
;
106 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
107 error_setg(errp
, "Request for data outside of extension header");
111 ret
= bdrv_pread(bs
->file
, s
->crypto_header
.offset
+ offset
, buflen
, buf
,
114 error_setg_errno(errp
, -ret
, "Could not read encryption header");
121 static int coroutine_fn GRAPH_RDLOCK
122 qcow2_crypto_hdr_init_func(QCryptoBlock
*block
, size_t headerlen
, void *opaque
,
125 BlockDriverState
*bs
= opaque
;
126 BDRVQcow2State
*s
= bs
->opaque
;
130 ret
= qcow2_alloc_clusters(bs
, headerlen
);
132 error_setg_errno(errp
, -ret
,
133 "Cannot allocate cluster for LUKS header size %zu",
138 s
->crypto_header
.length
= headerlen
;
139 s
->crypto_header
.offset
= ret
;
142 * Zero fill all space in cluster so it has predictable
143 * content, as we may not initialize some regions of the
144 * header (eg only 1 out of 8 key slots will be initialized)
146 clusterlen
= size_to_clusters(s
, headerlen
) * s
->cluster_size
;
147 assert(qcow2_pre_write_overlap_check(bs
, 0, ret
, clusterlen
, false) == 0);
148 ret
= bdrv_co_pwrite_zeroes(bs
->file
, ret
, clusterlen
, 0);
150 error_setg_errno(errp
, -ret
, "Could not zero fill encryption header");
158 /* The graph lock must be held when called in coroutine context */
159 static int coroutine_mixed_fn
160 qcow2_crypto_hdr_write_func(QCryptoBlock
*block
, size_t offset
,
161 const uint8_t *buf
, size_t buflen
,
162 void *opaque
, Error
**errp
)
164 BlockDriverState
*bs
= opaque
;
165 BDRVQcow2State
*s
= bs
->opaque
;
168 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
169 error_setg(errp
, "Request for data outside of extension header");
173 ret
= bdrv_pwrite(bs
->file
, s
->crypto_header
.offset
+ offset
, buflen
, buf
,
176 error_setg_errno(errp
, -ret
, "Could not read encryption header");
183 qcow2_extract_crypto_opts(QemuOpts
*opts
, const char *fmt
, Error
**errp
)
185 QDict
*cryptoopts_qdict
;
188 /* Extract "encrypt." options into a qdict */
189 opts_qdict
= qemu_opts_to_qdict(opts
, NULL
);
190 qdict_extract_subqdict(opts_qdict
, &cryptoopts_qdict
, "encrypt.");
191 qobject_unref(opts_qdict
);
192 qdict_put_str(cryptoopts_qdict
, "format", fmt
);
193 return cryptoopts_qdict
;
197 * read qcow2 extension and fill bs
198 * start reading from start_offset
199 * finish reading upon magic of value 0 or when end_offset reached
200 * unknown magic is skipped (future extension this version knows nothing about)
201 * return 0 upon success, non-0 otherwise
203 static int coroutine_fn GRAPH_RDLOCK
204 qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
205 uint64_t end_offset
, void **p_feature_table
,
206 int flags
, bool *need_update_header
, Error
**errp
)
208 BDRVQcow2State
*s
= bs
->opaque
;
212 Qcow2BitmapHeaderExt bitmaps_ext
;
214 if (need_update_header
!= NULL
) {
215 *need_update_header
= false;
219 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
221 offset
= start_offset
;
222 while (offset
< end_offset
) {
226 if (offset
> s
->cluster_size
)
227 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
229 printf("attempting to read extended header in offset %lu\n", offset
);
232 ret
= bdrv_co_pread(bs
->file
, offset
, sizeof(ext
), &ext
, 0);
234 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
235 "pread fail from offset %" PRIu64
, offset
);
238 ext
.magic
= be32_to_cpu(ext
.magic
);
239 ext
.len
= be32_to_cpu(ext
.len
);
240 offset
+= sizeof(ext
);
242 printf("ext.magic = 0x%x\n", ext
.magic
);
244 if (offset
> end_offset
|| ext
.len
> end_offset
- offset
) {
245 error_setg(errp
, "Header extension too large");
250 case QCOW2_EXT_MAGIC_END
:
253 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
254 if (ext
.len
>= sizeof(bs
->backing_format
)) {
255 error_setg(errp
, "ERROR: ext_backing_format: len=%" PRIu32
256 " too large (>=%zu)", ext
.len
,
257 sizeof(bs
->backing_format
));
260 ret
= bdrv_co_pread(bs
->file
, offset
, ext
.len
, bs
->backing_format
, 0);
262 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
263 "Could not read format name");
266 bs
->backing_format
[ext
.len
] = '\0';
267 s
->image_backing_format
= g_strdup(bs
->backing_format
);
269 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
273 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
274 if (p_feature_table
!= NULL
) {
275 void *feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
276 ret
= bdrv_co_pread(bs
->file
, offset
, ext
.len
, feature_table
, 0);
278 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
279 "Could not read table");
280 g_free(feature_table
);
284 *p_feature_table
= feature_table
;
288 case QCOW2_EXT_MAGIC_CRYPTO_HEADER
: {
289 unsigned int cflags
= 0;
290 if (s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
291 error_setg(errp
, "CRYPTO header extension only "
292 "expected with LUKS encryption method");
295 if (ext
.len
!= sizeof(Qcow2CryptoHeaderExtension
)) {
296 error_setg(errp
, "CRYPTO header extension size %u, "
297 "but expected size %zu", ext
.len
,
298 sizeof(Qcow2CryptoHeaderExtension
));
302 ret
= bdrv_co_pread(bs
->file
, offset
, ext
.len
, &s
->crypto_header
, 0);
304 error_setg_errno(errp
, -ret
,
305 "Unable to read CRYPTO header extension");
308 s
->crypto_header
.offset
= be64_to_cpu(s
->crypto_header
.offset
);
309 s
->crypto_header
.length
= be64_to_cpu(s
->crypto_header
.length
);
311 if ((s
->crypto_header
.offset
% s
->cluster_size
) != 0) {
312 error_setg(errp
, "Encryption header offset '%" PRIu64
"' is "
313 "not a multiple of cluster size '%u'",
314 s
->crypto_header
.offset
, s
->cluster_size
);
318 if (flags
& BDRV_O_NO_IO
) {
319 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
321 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
322 qcow2_crypto_hdr_read_func
,
323 bs
, cflags
, QCOW2_MAX_THREADS
, errp
);
329 case QCOW2_EXT_MAGIC_BITMAPS
:
330 if (ext
.len
!= sizeof(bitmaps_ext
)) {
331 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
332 "Invalid extension length");
336 if (!(s
->autoclear_features
& QCOW2_AUTOCLEAR_BITMAPS
)) {
337 if (s
->qcow_version
< 3) {
338 /* Let's be a bit more specific */
339 warn_report("This qcow2 v2 image contains bitmaps, but "
340 "they may have been modified by a program "
341 "without persistent bitmap support; so now "
342 "they must all be considered inconsistent");
344 warn_report("a program lacking bitmap support "
345 "modified this file, so all bitmaps are now "
346 "considered inconsistent");
348 error_printf("Some clusters may be leaked, "
349 "run 'qemu-img check -r' on the image "
351 if (need_update_header
!= NULL
) {
352 /* Updating is needed to drop invalid bitmap extension. */
353 *need_update_header
= true;
358 ret
= bdrv_co_pread(bs
->file
, offset
, ext
.len
, &bitmaps_ext
, 0);
360 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
361 "Could not read ext header");
365 if (bitmaps_ext
.reserved32
!= 0) {
366 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
367 "Reserved field is not zero");
371 bitmaps_ext
.nb_bitmaps
= be32_to_cpu(bitmaps_ext
.nb_bitmaps
);
372 bitmaps_ext
.bitmap_directory_size
=
373 be64_to_cpu(bitmaps_ext
.bitmap_directory_size
);
374 bitmaps_ext
.bitmap_directory_offset
=
375 be64_to_cpu(bitmaps_ext
.bitmap_directory_offset
);
377 if (bitmaps_ext
.nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
379 "bitmaps_ext: Image has %" PRIu32
" bitmaps, "
380 "exceeding the QEMU supported maximum of %d",
381 bitmaps_ext
.nb_bitmaps
, QCOW2_MAX_BITMAPS
);
385 if (bitmaps_ext
.nb_bitmaps
== 0) {
386 error_setg(errp
, "found bitmaps extension with zero bitmaps");
390 if (offset_into_cluster(s
, bitmaps_ext
.bitmap_directory_offset
)) {
391 error_setg(errp
, "bitmaps_ext: "
392 "invalid bitmap directory offset");
396 if (bitmaps_ext
.bitmap_directory_size
>
397 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
398 error_setg(errp
, "bitmaps_ext: "
399 "bitmap directory size (%" PRIu64
") exceeds "
400 "the maximum supported size (%d)",
401 bitmaps_ext
.bitmap_directory_size
,
402 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
);
406 s
->nb_bitmaps
= bitmaps_ext
.nb_bitmaps
;
407 s
->bitmap_directory_offset
=
408 bitmaps_ext
.bitmap_directory_offset
;
409 s
->bitmap_directory_size
=
410 bitmaps_ext
.bitmap_directory_size
;
413 printf("Qcow2: Got bitmaps extension: "
414 "offset=%" PRIu64
" nb_bitmaps=%" PRIu32
"\n",
415 s
->bitmap_directory_offset
, s
->nb_bitmaps
);
419 case QCOW2_EXT_MAGIC_DATA_FILE
:
421 s
->image_data_file
= g_malloc0(ext
.len
+ 1);
422 ret
= bdrv_co_pread(bs
->file
, offset
, ext
.len
, s
->image_data_file
, 0);
424 error_setg_errno(errp
, -ret
,
425 "ERROR: Could not read data file name");
429 printf("Qcow2: Got external data file %s\n", s
->image_data_file
);
435 /* unknown magic - save it in case we need to rewrite the header */
436 /* If you add a new feature, make sure to also update the fast
437 * path of qcow2_make_empty() to deal with it. */
439 Qcow2UnknownHeaderExtension
*uext
;
441 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
442 uext
->magic
= ext
.magic
;
444 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
446 ret
= bdrv_co_pread(bs
->file
, offset
, uext
->len
, uext
->data
, 0);
448 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
449 "Could not read data");
456 offset
+= ((ext
.len
+ 7) & ~7);
462 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
464 BDRVQcow2State
*s
= bs
->opaque
;
465 Qcow2UnknownHeaderExtension
*uext
, *next
;
467 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
468 QLIST_REMOVE(uext
, next
);
473 static void report_unsupported_feature(Error
**errp
, Qcow2Feature
*table
,
476 g_autoptr(GString
) features
= g_string_sized_new(60);
478 while (table
&& table
->name
[0] != '\0') {
479 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
480 if (mask
& (1ULL << table
->bit
)) {
481 if (features
->len
> 0) {
482 g_string_append(features
, ", ");
484 g_string_append_printf(features
, "%.46s", table
->name
);
485 mask
&= ~(1ULL << table
->bit
);
492 if (features
->len
> 0) {
493 g_string_append(features
, ", ");
495 g_string_append_printf(features
,
496 "Unknown incompatible feature: %" PRIx64
, mask
);
499 error_setg(errp
, "Unsupported qcow2 feature(s): %s", features
->str
);
503 * Sets the dirty bit and flushes afterwards if necessary.
505 * The incompatible_features bit is only set if the image file header was
506 * updated successfully. Therefore it is not required to check the return
507 * value of this function.
509 int qcow2_mark_dirty(BlockDriverState
*bs
)
511 BDRVQcow2State
*s
= bs
->opaque
;
515 assert(s
->qcow_version
>= 3);
517 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
518 return 0; /* already dirty */
521 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
522 ret
= bdrv_pwrite_sync(bs
->file
,
523 offsetof(QCowHeader
, incompatible_features
),
524 sizeof(val
), &val
, 0);
529 /* Only treat image as dirty if the header was updated successfully */
530 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
535 * Clears the dirty bit and flushes before if necessary. Only call this
536 * function when there are no pending requests, it does not guard against
537 * concurrent requests dirtying the image.
539 static int qcow2_mark_clean(BlockDriverState
*bs
)
541 BDRVQcow2State
*s
= bs
->opaque
;
543 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
546 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
548 ret
= qcow2_flush_caches(bs
);
553 return qcow2_update_header(bs
);
559 * Marks the image as corrupt.
561 int qcow2_mark_corrupt(BlockDriverState
*bs
)
563 BDRVQcow2State
*s
= bs
->opaque
;
565 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
566 return qcow2_update_header(bs
);
570 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
571 * before if necessary.
573 static int coroutine_fn
qcow2_mark_consistent(BlockDriverState
*bs
)
575 BDRVQcow2State
*s
= bs
->opaque
;
577 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
578 int ret
= qcow2_flush_caches(bs
);
583 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
584 return qcow2_update_header(bs
);
589 static void qcow2_add_check_result(BdrvCheckResult
*out
,
590 const BdrvCheckResult
*src
,
591 bool set_allocation_info
)
593 out
->corruptions
+= src
->corruptions
;
594 out
->leaks
+= src
->leaks
;
595 out
->check_errors
+= src
->check_errors
;
596 out
->corruptions_fixed
+= src
->corruptions_fixed
;
597 out
->leaks_fixed
+= src
->leaks_fixed
;
599 if (set_allocation_info
) {
600 out
->image_end_offset
= src
->image_end_offset
;
605 static int coroutine_fn GRAPH_RDLOCK
606 qcow2_co_check_locked(BlockDriverState
*bs
, BdrvCheckResult
*result
,
609 BdrvCheckResult snapshot_res
= {};
610 BdrvCheckResult refcount_res
= {};
613 memset(result
, 0, sizeof(*result
));
615 ret
= qcow2_check_read_snapshot_table(bs
, &snapshot_res
, fix
);
617 qcow2_add_check_result(result
, &snapshot_res
, false);
621 ret
= qcow2_check_refcounts(bs
, &refcount_res
, fix
);
622 qcow2_add_check_result(result
, &refcount_res
, true);
624 qcow2_add_check_result(result
, &snapshot_res
, false);
628 ret
= qcow2_check_fix_snapshot_table(bs
, &snapshot_res
, fix
);
629 qcow2_add_check_result(result
, &snapshot_res
, false);
634 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
635 ret
= qcow2_mark_clean(bs
);
639 return qcow2_mark_consistent(bs
);
644 static int coroutine_fn GRAPH_RDLOCK
645 qcow2_co_check(BlockDriverState
*bs
, BdrvCheckResult
*result
,
648 BDRVQcow2State
*s
= bs
->opaque
;
651 qemu_co_mutex_lock(&s
->lock
);
652 ret
= qcow2_co_check_locked(bs
, result
, fix
);
653 qemu_co_mutex_unlock(&s
->lock
);
657 int qcow2_validate_table(BlockDriverState
*bs
, uint64_t offset
,
658 uint64_t entries
, size_t entry_len
,
659 int64_t max_size_bytes
, const char *table_name
,
662 BDRVQcow2State
*s
= bs
->opaque
;
664 if (entries
> max_size_bytes
/ entry_len
) {
665 error_setg(errp
, "%s too large", table_name
);
669 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
670 * because values will be passed to qemu functions taking int64_t. */
671 if ((INT64_MAX
- entries
* entry_len
< offset
) ||
672 (offset_into_cluster(s
, offset
) != 0)) {
673 error_setg(errp
, "%s offset invalid", table_name
);
680 static const char *const mutable_opts
[] = {
681 QCOW2_OPT_LAZY_REFCOUNTS
,
682 QCOW2_OPT_DISCARD_REQUEST
,
683 QCOW2_OPT_DISCARD_SNAPSHOT
,
684 QCOW2_OPT_DISCARD_OTHER
,
685 QCOW2_OPT_DISCARD_NO_UNREF
,
687 QCOW2_OPT_OVERLAP_TEMPLATE
,
688 QCOW2_OPT_OVERLAP_MAIN_HEADER
,
689 QCOW2_OPT_OVERLAP_ACTIVE_L1
,
690 QCOW2_OPT_OVERLAP_ACTIVE_L2
,
691 QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
692 QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
693 QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
694 QCOW2_OPT_OVERLAP_INACTIVE_L1
,
695 QCOW2_OPT_OVERLAP_INACTIVE_L2
,
696 QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
697 QCOW2_OPT_CACHE_SIZE
,
698 QCOW2_OPT_L2_CACHE_SIZE
,
699 QCOW2_OPT_L2_CACHE_ENTRY_SIZE
,
700 QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
701 QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
705 static QemuOptsList qcow2_runtime_opts
= {
707 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
710 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
711 .type
= QEMU_OPT_BOOL
,
712 .help
= "Postpone refcount updates",
715 .name
= QCOW2_OPT_DISCARD_REQUEST
,
716 .type
= QEMU_OPT_BOOL
,
717 .help
= "Pass guest discard requests to the layer below",
720 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
721 .type
= QEMU_OPT_BOOL
,
722 .help
= "Generate discard requests when snapshot related space "
726 .name
= QCOW2_OPT_DISCARD_OTHER
,
727 .type
= QEMU_OPT_BOOL
,
728 .help
= "Generate discard requests when other clusters are freed",
731 .name
= QCOW2_OPT_DISCARD_NO_UNREF
,
732 .type
= QEMU_OPT_BOOL
,
733 .help
= "Do not unreference discarded clusters",
736 .name
= QCOW2_OPT_OVERLAP
,
737 .type
= QEMU_OPT_STRING
,
738 .help
= "Selects which overlap checks to perform from a range of "
739 "templates (none, constant, cached, all)",
742 .name
= QCOW2_OPT_OVERLAP_TEMPLATE
,
743 .type
= QEMU_OPT_STRING
,
744 .help
= "Selects which overlap checks to perform from a range of "
745 "templates (none, constant, cached, all)",
748 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
749 .type
= QEMU_OPT_BOOL
,
750 .help
= "Check for unintended writes into the main qcow2 header",
753 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
754 .type
= QEMU_OPT_BOOL
,
755 .help
= "Check for unintended writes into the active L1 table",
758 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
759 .type
= QEMU_OPT_BOOL
,
760 .help
= "Check for unintended writes into an active L2 table",
763 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
764 .type
= QEMU_OPT_BOOL
,
765 .help
= "Check for unintended writes into the refcount table",
768 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
769 .type
= QEMU_OPT_BOOL
,
770 .help
= "Check for unintended writes into a refcount block",
773 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
774 .type
= QEMU_OPT_BOOL
,
775 .help
= "Check for unintended writes into the snapshot table",
778 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
779 .type
= QEMU_OPT_BOOL
,
780 .help
= "Check for unintended writes into an inactive L1 table",
783 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
784 .type
= QEMU_OPT_BOOL
,
785 .help
= "Check for unintended writes into an inactive L2 table",
788 .name
= QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
789 .type
= QEMU_OPT_BOOL
,
790 .help
= "Check for unintended writes into the bitmap directory",
793 .name
= QCOW2_OPT_CACHE_SIZE
,
794 .type
= QEMU_OPT_SIZE
,
795 .help
= "Maximum combined metadata (L2 tables and refcount blocks) "
799 .name
= QCOW2_OPT_L2_CACHE_SIZE
,
800 .type
= QEMU_OPT_SIZE
,
801 .help
= "Maximum L2 table cache size",
804 .name
= QCOW2_OPT_L2_CACHE_ENTRY_SIZE
,
805 .type
= QEMU_OPT_SIZE
,
806 .help
= "Size of each entry in the L2 cache",
809 .name
= QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
810 .type
= QEMU_OPT_SIZE
,
811 .help
= "Maximum refcount block cache size",
814 .name
= QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
815 .type
= QEMU_OPT_NUMBER
,
816 .help
= "Clean unused cache entries after this time (in seconds)",
818 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
819 "ID of secret providing qcow2 AES key or LUKS passphrase"),
820 { /* end of list */ }
824 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
825 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
826 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
827 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
828 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
829 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
830 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
831 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
832 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
833 [QCOW2_OL_BITMAP_DIRECTORY_BITNR
] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
836 static void cache_clean_timer_cb(void *opaque
)
838 BlockDriverState
*bs
= opaque
;
839 BDRVQcow2State
*s
= bs
->opaque
;
840 qcow2_cache_clean_unused(s
->l2_table_cache
);
841 qcow2_cache_clean_unused(s
->refcount_block_cache
);
842 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
843 (int64_t) s
->cache_clean_interval
* 1000);
846 static void cache_clean_timer_init(BlockDriverState
*bs
, AioContext
*context
)
848 BDRVQcow2State
*s
= bs
->opaque
;
849 if (s
->cache_clean_interval
> 0) {
850 s
->cache_clean_timer
=
851 aio_timer_new_with_attrs(context
, QEMU_CLOCK_VIRTUAL
,
852 SCALE_MS
, QEMU_TIMER_ATTR_EXTERNAL
,
853 cache_clean_timer_cb
, bs
);
854 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
855 (int64_t) s
->cache_clean_interval
* 1000);
859 static void cache_clean_timer_del(BlockDriverState
*bs
)
861 BDRVQcow2State
*s
= bs
->opaque
;
862 if (s
->cache_clean_timer
) {
863 timer_free(s
->cache_clean_timer
);
864 s
->cache_clean_timer
= NULL
;
868 static void qcow2_detach_aio_context(BlockDriverState
*bs
)
870 cache_clean_timer_del(bs
);
873 static void qcow2_attach_aio_context(BlockDriverState
*bs
,
874 AioContext
*new_context
)
876 cache_clean_timer_init(bs
, new_context
);
879 static bool read_cache_sizes(BlockDriverState
*bs
, QemuOpts
*opts
,
880 uint64_t *l2_cache_size
,
881 uint64_t *l2_cache_entry_size
,
882 uint64_t *refcount_cache_size
, Error
**errp
)
884 BDRVQcow2State
*s
= bs
->opaque
;
885 uint64_t combined_cache_size
, l2_cache_max_setting
;
886 bool l2_cache_size_set
, refcount_cache_size_set
, combined_cache_size_set
;
887 bool l2_cache_entry_size_set
;
888 int min_refcount_cache
= MIN_REFCOUNT_CACHE_SIZE
* s
->cluster_size
;
889 uint64_t virtual_disk_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
890 uint64_t max_l2_entries
= DIV_ROUND_UP(virtual_disk_size
, s
->cluster_size
);
891 /* An L2 table is always one cluster in size so the max cache size
892 * should be a multiple of the cluster size. */
893 uint64_t max_l2_cache
= ROUND_UP(max_l2_entries
* l2_entry_size(s
),
896 combined_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_CACHE_SIZE
);
897 l2_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_SIZE
);
898 refcount_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
899 l2_cache_entry_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_ENTRY_SIZE
);
901 combined_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_CACHE_SIZE
, 0);
902 l2_cache_max_setting
= qemu_opt_get_size(opts
, QCOW2_OPT_L2_CACHE_SIZE
,
903 DEFAULT_L2_CACHE_MAX_SIZE
);
904 *refcount_cache_size
= qemu_opt_get_size(opts
,
905 QCOW2_OPT_REFCOUNT_CACHE_SIZE
, 0);
907 *l2_cache_entry_size
= qemu_opt_get_size(
908 opts
, QCOW2_OPT_L2_CACHE_ENTRY_SIZE
, s
->cluster_size
);
910 *l2_cache_size
= MIN(max_l2_cache
, l2_cache_max_setting
);
912 if (combined_cache_size_set
) {
913 if (l2_cache_size_set
&& refcount_cache_size_set
) {
914 error_setg(errp
, QCOW2_OPT_CACHE_SIZE
", " QCOW2_OPT_L2_CACHE_SIZE
915 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not be set "
918 } else if (l2_cache_size_set
&&
919 (l2_cache_max_setting
> combined_cache_size
)) {
920 error_setg(errp
, QCOW2_OPT_L2_CACHE_SIZE
" may not exceed "
921 QCOW2_OPT_CACHE_SIZE
);
923 } else if (*refcount_cache_size
> combined_cache_size
) {
924 error_setg(errp
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not exceed "
925 QCOW2_OPT_CACHE_SIZE
);
929 if (l2_cache_size_set
) {
930 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
931 } else if (refcount_cache_size_set
) {
932 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
934 /* Assign as much memory as possible to the L2 cache, and
935 * use the remainder for the refcount cache */
936 if (combined_cache_size
>= max_l2_cache
+ min_refcount_cache
) {
937 *l2_cache_size
= max_l2_cache
;
938 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
940 *refcount_cache_size
=
941 MIN(combined_cache_size
, min_refcount_cache
);
942 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
948 * If the L2 cache is not enough to cover the whole disk then
949 * default to 4KB entries. Smaller entries reduce the cost of
950 * loads and evictions and increase I/O performance.
952 if (*l2_cache_size
< max_l2_cache
&& !l2_cache_entry_size_set
) {
953 *l2_cache_entry_size
= MIN(s
->cluster_size
, 4096);
956 /* l2_cache_size and refcount_cache_size are ensured to have at least
957 * their minimum values in qcow2_update_options_prepare() */
959 if (*l2_cache_entry_size
< (1 << MIN_CLUSTER_BITS
) ||
960 *l2_cache_entry_size
> s
->cluster_size
||
961 !is_power_of_2(*l2_cache_entry_size
)) {
962 error_setg(errp
, "L2 cache entry size must be a power of two "
963 "between %d and the cluster size (%d)",
964 1 << MIN_CLUSTER_BITS
, s
->cluster_size
);
971 typedef struct Qcow2ReopenState
{
972 Qcow2Cache
*l2_table_cache
;
973 Qcow2Cache
*refcount_block_cache
;
974 int l2_slice_size
; /* Number of entries in a slice of the L2 table */
975 bool use_lazy_refcounts
;
977 bool discard_passthrough
[QCOW2_DISCARD_MAX
];
978 bool discard_no_unref
;
979 uint64_t cache_clean_interval
;
980 QCryptoBlockOpenOptions
*crypto_opts
; /* Disk encryption runtime options */
983 static int qcow2_update_options_prepare(BlockDriverState
*bs
,
985 QDict
*options
, int flags
,
988 BDRVQcow2State
*s
= bs
->opaque
;
989 QemuOpts
*opts
= NULL
;
990 const char *opt_overlap_check
, *opt_overlap_check_template
;
991 int overlap_check_template
= 0;
992 uint64_t l2_cache_size
, l2_cache_entry_size
, refcount_cache_size
;
994 const char *encryptfmt
;
995 QDict
*encryptopts
= NULL
;
998 qdict_extract_subqdict(options
, &encryptopts
, "encrypt.");
999 encryptfmt
= qdict_get_try_str(encryptopts
, "format");
1001 opts
= qemu_opts_create(&qcow2_runtime_opts
, NULL
, 0, &error_abort
);
1002 if (!qemu_opts_absorb_qdict(opts
, options
, errp
)) {
1007 /* get L2 table/refcount block cache size from command line options */
1008 if (!read_cache_sizes(bs
, opts
, &l2_cache_size
, &l2_cache_entry_size
,
1009 &refcount_cache_size
, errp
)) {
1014 l2_cache_size
/= l2_cache_entry_size
;
1015 if (l2_cache_size
< MIN_L2_CACHE_SIZE
) {
1016 l2_cache_size
= MIN_L2_CACHE_SIZE
;
1018 if (l2_cache_size
> INT_MAX
) {
1019 error_setg(errp
, "L2 cache size too big");
1024 refcount_cache_size
/= s
->cluster_size
;
1025 if (refcount_cache_size
< MIN_REFCOUNT_CACHE_SIZE
) {
1026 refcount_cache_size
= MIN_REFCOUNT_CACHE_SIZE
;
1028 if (refcount_cache_size
> INT_MAX
) {
1029 error_setg(errp
, "Refcount cache size too big");
1034 /* alloc new L2 table/refcount block cache, flush old one */
1035 if (s
->l2_table_cache
) {
1036 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1038 error_setg_errno(errp
, -ret
, "Failed to flush the L2 table cache");
1043 if (s
->refcount_block_cache
) {
1044 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1046 error_setg_errno(errp
, -ret
,
1047 "Failed to flush the refcount block cache");
1052 r
->l2_slice_size
= l2_cache_entry_size
/ l2_entry_size(s
);
1053 r
->l2_table_cache
= qcow2_cache_create(bs
, l2_cache_size
,
1054 l2_cache_entry_size
);
1055 r
->refcount_block_cache
= qcow2_cache_create(bs
, refcount_cache_size
,
1057 if (r
->l2_table_cache
== NULL
|| r
->refcount_block_cache
== NULL
) {
1058 error_setg(errp
, "Could not allocate metadata caches");
1063 /* New interval for cache cleanup timer */
1064 r
->cache_clean_interval
=
1065 qemu_opt_get_number(opts
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
1066 DEFAULT_CACHE_CLEAN_INTERVAL
);
1067 #ifndef CONFIG_LINUX
1068 if (r
->cache_clean_interval
!= 0) {
1069 error_setg(errp
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
1070 " not supported on this host");
1075 if (r
->cache_clean_interval
> UINT_MAX
) {
1076 error_setg(errp
, "Cache clean interval too big");
1081 /* lazy-refcounts; flush if going from enabled to disabled */
1082 r
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
1083 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
1084 if (r
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
1085 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
1086 "qemu 1.1 compatibility level");
1091 if (s
->use_lazy_refcounts
&& !r
->use_lazy_refcounts
) {
1092 ret
= qcow2_mark_clean(bs
);
1094 error_setg_errno(errp
, -ret
, "Failed to disable lazy refcounts");
1099 /* Overlap check options */
1100 opt_overlap_check
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP
);
1101 opt_overlap_check_template
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1102 if (opt_overlap_check_template
&& opt_overlap_check
&&
1103 strcmp(opt_overlap_check_template
, opt_overlap_check
))
1105 error_setg(errp
, "Conflicting values for qcow2 options '"
1106 QCOW2_OPT_OVERLAP
"' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
1107 "' ('%s')", opt_overlap_check
, opt_overlap_check_template
);
1111 if (!opt_overlap_check
) {
1112 opt_overlap_check
= opt_overlap_check_template
?: "cached";
1115 if (!strcmp(opt_overlap_check
, "none")) {
1116 overlap_check_template
= 0;
1117 } else if (!strcmp(opt_overlap_check
, "constant")) {
1118 overlap_check_template
= QCOW2_OL_CONSTANT
;
1119 } else if (!strcmp(opt_overlap_check
, "cached")) {
1120 overlap_check_template
= QCOW2_OL_CACHED
;
1121 } else if (!strcmp(opt_overlap_check
, "all")) {
1122 overlap_check_template
= QCOW2_OL_ALL
;
1124 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
1125 "'overlap-check'. Allowed are any of the following: "
1126 "none, constant, cached, all", opt_overlap_check
);
1131 r
->overlap_check
= 0;
1132 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
1133 /* overlap-check defines a template bitmask, but every flag may be
1134 * overwritten through the associated boolean option */
1136 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
1137 overlap_check_template
& (1 << i
)) << i
;
1140 r
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
1141 r
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
1142 r
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
1143 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
1144 flags
& BDRV_O_UNMAP
);
1145 r
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
1146 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
1147 r
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
1148 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
1150 r
->discard_no_unref
= qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_NO_UNREF
,
1152 if (r
->discard_no_unref
&& s
->qcow_version
< 3) {
1154 "discard-no-unref is only supported since qcow2 version 3");
1159 switch (s
->crypt_method_header
) {
1160 case QCOW_CRYPT_NONE
:
1162 error_setg(errp
, "No encryption in image header, but options "
1163 "specified format '%s'", encryptfmt
);
1169 case QCOW_CRYPT_AES
:
1170 if (encryptfmt
&& !g_str_equal(encryptfmt
, "aes")) {
1172 "Header reported 'aes' encryption format but "
1173 "options specify '%s'", encryptfmt
);
1177 qdict_put_str(encryptopts
, "format", "qcow");
1178 r
->crypto_opts
= block_crypto_open_opts_init(encryptopts
, errp
);
1179 if (!r
->crypto_opts
) {
1185 case QCOW_CRYPT_LUKS
:
1186 if (encryptfmt
&& !g_str_equal(encryptfmt
, "luks")) {
1188 "Header reported 'luks' encryption format but "
1189 "options specify '%s'", encryptfmt
);
1193 qdict_put_str(encryptopts
, "format", "luks");
1194 r
->crypto_opts
= block_crypto_open_opts_init(encryptopts
, errp
);
1195 if (!r
->crypto_opts
) {
1202 error_setg(errp
, "Unsupported encryption method %d",
1203 s
->crypt_method_header
);
1210 qobject_unref(encryptopts
);
1211 qemu_opts_del(opts
);
1216 static void qcow2_update_options_commit(BlockDriverState
*bs
,
1217 Qcow2ReopenState
*r
)
1219 BDRVQcow2State
*s
= bs
->opaque
;
1222 if (s
->l2_table_cache
) {
1223 qcow2_cache_destroy(s
->l2_table_cache
);
1225 if (s
->refcount_block_cache
) {
1226 qcow2_cache_destroy(s
->refcount_block_cache
);
1228 s
->l2_table_cache
= r
->l2_table_cache
;
1229 s
->refcount_block_cache
= r
->refcount_block_cache
;
1230 s
->l2_slice_size
= r
->l2_slice_size
;
1232 s
->overlap_check
= r
->overlap_check
;
1233 s
->use_lazy_refcounts
= r
->use_lazy_refcounts
;
1235 for (i
= 0; i
< QCOW2_DISCARD_MAX
; i
++) {
1236 s
->discard_passthrough
[i
] = r
->discard_passthrough
[i
];
1239 s
->discard_no_unref
= r
->discard_no_unref
;
1241 if (s
->cache_clean_interval
!= r
->cache_clean_interval
) {
1242 cache_clean_timer_del(bs
);
1243 s
->cache_clean_interval
= r
->cache_clean_interval
;
1244 cache_clean_timer_init(bs
, bdrv_get_aio_context(bs
));
1247 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1248 s
->crypto_opts
= r
->crypto_opts
;
1251 static void qcow2_update_options_abort(BlockDriverState
*bs
,
1252 Qcow2ReopenState
*r
)
1254 if (r
->l2_table_cache
) {
1255 qcow2_cache_destroy(r
->l2_table_cache
);
1257 if (r
->refcount_block_cache
) {
1258 qcow2_cache_destroy(r
->refcount_block_cache
);
1260 qapi_free_QCryptoBlockOpenOptions(r
->crypto_opts
);
1263 static int coroutine_fn
1264 qcow2_update_options(BlockDriverState
*bs
, QDict
*options
, int flags
,
1267 Qcow2ReopenState r
= {};
1270 ret
= qcow2_update_options_prepare(bs
, &r
, options
, flags
, errp
);
1272 qcow2_update_options_commit(bs
, &r
);
1274 qcow2_update_options_abort(bs
, &r
);
1280 static int validate_compression_type(BDRVQcow2State
*s
, Error
**errp
)
1282 switch (s
->compression_type
) {
1283 case QCOW2_COMPRESSION_TYPE_ZLIB
:
1285 case QCOW2_COMPRESSION_TYPE_ZSTD
:
1290 error_setg(errp
, "qcow2: unknown compression type: %u",
1291 s
->compression_type
);
1296 * if the compression type differs from QCOW2_COMPRESSION_TYPE_ZLIB
1297 * the incompatible feature flag must be set
1299 if (s
->compression_type
== QCOW2_COMPRESSION_TYPE_ZLIB
) {
1300 if (s
->incompatible_features
& QCOW2_INCOMPAT_COMPRESSION
) {
1301 error_setg(errp
, "qcow2: Compression type incompatible feature "
1302 "bit must not be set");
1306 if (!(s
->incompatible_features
& QCOW2_INCOMPAT_COMPRESSION
)) {
1307 error_setg(errp
, "qcow2: Compression type incompatible feature "
1316 /* Called with s->lock held. */
1317 static int coroutine_fn GRAPH_RDLOCK
1318 qcow2_do_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1319 bool open_data_file
, Error
**errp
)
1322 BDRVQcow2State
*s
= bs
->opaque
;
1323 unsigned int len
, i
;
1327 uint64_t l1_vm_state_index
;
1328 bool update_header
= false;
1330 ret
= bdrv_co_pread(bs
->file
, 0, sizeof(header
), &header
, 0);
1332 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
1335 header
.magic
= be32_to_cpu(header
.magic
);
1336 header
.version
= be32_to_cpu(header
.version
);
1337 header
.backing_file_offset
= be64_to_cpu(header
.backing_file_offset
);
1338 header
.backing_file_size
= be32_to_cpu(header
.backing_file_size
);
1339 header
.size
= be64_to_cpu(header
.size
);
1340 header
.cluster_bits
= be32_to_cpu(header
.cluster_bits
);
1341 header
.crypt_method
= be32_to_cpu(header
.crypt_method
);
1342 header
.l1_table_offset
= be64_to_cpu(header
.l1_table_offset
);
1343 header
.l1_size
= be32_to_cpu(header
.l1_size
);
1344 header
.refcount_table_offset
= be64_to_cpu(header
.refcount_table_offset
);
1345 header
.refcount_table_clusters
=
1346 be32_to_cpu(header
.refcount_table_clusters
);
1347 header
.snapshots_offset
= be64_to_cpu(header
.snapshots_offset
);
1348 header
.nb_snapshots
= be32_to_cpu(header
.nb_snapshots
);
1350 if (header
.magic
!= QCOW_MAGIC
) {
1351 error_setg(errp
, "Image is not in qcow2 format");
1355 if (header
.version
< 2 || header
.version
> 3) {
1356 error_setg(errp
, "Unsupported qcow2 version %" PRIu32
, header
.version
);
1361 s
->qcow_version
= header
.version
;
1363 /* Initialise cluster size */
1364 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
1365 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
1366 error_setg(errp
, "Unsupported cluster size: 2^%" PRIu32
,
1367 header
.cluster_bits
);
1372 s
->cluster_bits
= header
.cluster_bits
;
1373 s
->cluster_size
= 1 << s
->cluster_bits
;
1375 /* Initialise version 3 header fields */
1376 if (header
.version
== 2) {
1377 header
.incompatible_features
= 0;
1378 header
.compatible_features
= 0;
1379 header
.autoclear_features
= 0;
1380 header
.refcount_order
= 4;
1381 header
.header_length
= 72;
1383 header
.incompatible_features
=
1384 be64_to_cpu(header
.incompatible_features
);
1385 header
.compatible_features
= be64_to_cpu(header
.compatible_features
);
1386 header
.autoclear_features
= be64_to_cpu(header
.autoclear_features
);
1387 header
.refcount_order
= be32_to_cpu(header
.refcount_order
);
1388 header
.header_length
= be32_to_cpu(header
.header_length
);
1390 if (header
.header_length
< 104) {
1391 error_setg(errp
, "qcow2 header too short");
1397 if (header
.header_length
> s
->cluster_size
) {
1398 error_setg(errp
, "qcow2 header exceeds cluster size");
1403 if (header
.header_length
> sizeof(header
)) {
1404 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
1405 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
1406 ret
= bdrv_co_pread(bs
->file
, sizeof(header
),
1407 s
->unknown_header_fields_size
,
1408 s
->unknown_header_fields
, 0);
1410 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
1416 if (header
.backing_file_offset
> s
->cluster_size
) {
1417 error_setg(errp
, "Invalid backing file offset");
1422 if (header
.backing_file_offset
) {
1423 ext_end
= header
.backing_file_offset
;
1425 ext_end
= 1 << header
.cluster_bits
;
1428 /* Handle feature bits */
1429 s
->incompatible_features
= header
.incompatible_features
;
1430 s
->compatible_features
= header
.compatible_features
;
1431 s
->autoclear_features
= header
.autoclear_features
;
1434 * Handle compression type
1435 * Older qcow2 images don't contain the compression type header.
1436 * Distinguish them by the header length and use
1437 * the only valid (default) compression type in that case
1439 if (header
.header_length
> offsetof(QCowHeader
, compression_type
)) {
1440 s
->compression_type
= header
.compression_type
;
1442 s
->compression_type
= QCOW2_COMPRESSION_TYPE_ZLIB
;
1445 ret
= validate_compression_type(s
, errp
);
1450 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
1451 void *feature_table
= NULL
;
1452 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
1453 &feature_table
, flags
, NULL
, NULL
);
1454 report_unsupported_feature(errp
, feature_table
,
1455 s
->incompatible_features
&
1456 ~QCOW2_INCOMPAT_MASK
);
1458 g_free(feature_table
);
1462 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
1463 /* Corrupt images may not be written to unless they are being repaired
1465 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
1466 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
1473 s
->subclusters_per_cluster
=
1474 has_subclusters(s
) ? QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER
: 1;
1475 s
->subcluster_size
= s
->cluster_size
/ s
->subclusters_per_cluster
;
1476 s
->subcluster_bits
= ctz32(s
->subcluster_size
);
1478 if (s
->subcluster_size
< (1 << MIN_CLUSTER_BITS
)) {
1479 error_setg(errp
, "Unsupported subcluster size: %d", s
->subcluster_size
);
1484 /* Check support for various header values */
1485 if (header
.refcount_order
> 6) {
1486 error_setg(errp
, "Reference count entry width too large; may not "
1491 s
->refcount_order
= header
.refcount_order
;
1492 s
->refcount_bits
= 1 << s
->refcount_order
;
1493 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
1494 s
->refcount_max
+= s
->refcount_max
- 1;
1496 s
->crypt_method_header
= header
.crypt_method
;
1497 if (s
->crypt_method_header
) {
1498 if (bdrv_uses_whitelist() &&
1499 s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1501 "Use of AES-CBC encrypted qcow2 images is no longer "
1502 "supported in system emulators");
1503 error_append_hint(errp
,
1504 "You can use 'qemu-img convert' to convert your "
1505 "image to an alternative supported format, such "
1506 "as unencrypted qcow2, or raw with the LUKS "
1507 "format instead.\n");
1512 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1513 s
->crypt_physical_offset
= false;
1515 /* Assuming LUKS and any future crypt methods we
1516 * add will all use physical offsets, due to the
1517 * fact that the alternative is insecure... */
1518 s
->crypt_physical_offset
= true;
1521 bs
->encrypted
= true;
1524 s
->l2_bits
= s
->cluster_bits
- ctz32(l2_entry_size(s
));
1525 s
->l2_size
= 1 << s
->l2_bits
;
1526 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1527 s
->refcount_block_bits
= s
->cluster_bits
- (s
->refcount_order
- 3);
1528 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
1529 bs
->total_sectors
= header
.size
/ BDRV_SECTOR_SIZE
;
1530 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
1531 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
1532 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
1534 s
->refcount_table_offset
= header
.refcount_table_offset
;
1535 s
->refcount_table_size
=
1536 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
1538 if (header
.refcount_table_clusters
== 0 && !(flags
& BDRV_O_CHECK
)) {
1539 error_setg(errp
, "Image does not contain a reference count table");
1544 ret
= qcow2_validate_table(bs
, s
->refcount_table_offset
,
1545 header
.refcount_table_clusters
,
1546 s
->cluster_size
, QCOW_MAX_REFTABLE_SIZE
,
1547 "Reference count table", errp
);
1552 if (!(flags
& BDRV_O_CHECK
)) {
1554 * The total size in bytes of the snapshot table is checked in
1555 * qcow2_read_snapshots() because the size of each snapshot is
1556 * variable and we don't know it yet.
1557 * Here we only check the offset and number of snapshots.
1559 ret
= qcow2_validate_table(bs
, header
.snapshots_offset
,
1560 header
.nb_snapshots
,
1561 sizeof(QCowSnapshotHeader
),
1562 sizeof(QCowSnapshotHeader
) *
1564 "Snapshot table", errp
);
1570 /* read the level 1 table */
1571 ret
= qcow2_validate_table(bs
, header
.l1_table_offset
,
1572 header
.l1_size
, L1E_SIZE
,
1573 QCOW_MAX_L1_SIZE
, "Active L1 table", errp
);
1577 s
->l1_size
= header
.l1_size
;
1578 s
->l1_table_offset
= header
.l1_table_offset
;
1580 l1_vm_state_index
= size_to_l1(s
, header
.size
);
1581 if (l1_vm_state_index
> INT_MAX
) {
1582 error_setg(errp
, "Image is too big");
1586 s
->l1_vm_state_index
= l1_vm_state_index
;
1588 /* the L1 table must contain at least enough entries to put
1589 header.size bytes */
1590 if (s
->l1_size
< s
->l1_vm_state_index
) {
1591 error_setg(errp
, "L1 table is too small");
1596 if (s
->l1_size
> 0) {
1597 s
->l1_table
= qemu_try_blockalign(bs
->file
->bs
, s
->l1_size
* L1E_SIZE
);
1598 if (s
->l1_table
== NULL
) {
1599 error_setg(errp
, "Could not allocate L1 table");
1603 ret
= bdrv_co_pread(bs
->file
, s
->l1_table_offset
, s
->l1_size
* L1E_SIZE
,
1606 error_setg_errno(errp
, -ret
, "Could not read L1 table");
1609 for(i
= 0;i
< s
->l1_size
; i
++) {
1610 s
->l1_table
[i
] = be64_to_cpu(s
->l1_table
[i
]);
1614 /* Parse driver-specific options */
1615 ret
= qcow2_update_options(bs
, options
, flags
, errp
);
1622 ret
= qcow2_refcount_init(bs
);
1624 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
1628 QLIST_INIT(&s
->cluster_allocs
);
1629 QTAILQ_INIT(&s
->discards
);
1631 /* read qcow2 extensions */
1632 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
1633 flags
, &update_header
, errp
)) {
1638 if (open_data_file
) {
1639 /* Open external data file */
1640 bdrv_graph_co_rdunlock();
1641 s
->data_file
= bdrv_co_open_child(NULL
, options
, "data-file", bs
,
1642 &child_of_bds
, BDRV_CHILD_DATA
,
1644 bdrv_graph_co_rdlock();
1650 if (s
->incompatible_features
& QCOW2_INCOMPAT_DATA_FILE
) {
1651 if (!s
->data_file
&& s
->image_data_file
) {
1652 bdrv_graph_co_rdunlock();
1653 s
->data_file
= bdrv_co_open_child(s
->image_data_file
, options
,
1656 BDRV_CHILD_DATA
, false, errp
);
1657 bdrv_graph_co_rdlock();
1658 if (!s
->data_file
) {
1663 if (!s
->data_file
) {
1664 error_setg(errp
, "'data-file' is required for this image");
1670 bs
->file
->role
&= ~BDRV_CHILD_DATA
;
1672 /* Must succeed because we have given up permissions if anything */
1673 bdrv_child_refresh_perms(bs
, bs
->file
, &error_abort
);
1676 error_setg(errp
, "'data-file' can only be set for images with "
1677 "an external data file");
1682 s
->data_file
= bs
->file
;
1684 if (data_file_is_raw(bs
)) {
1685 error_setg(errp
, "data-file-raw requires a data file");
1692 /* qcow2_read_extension may have set up the crypto context
1693 * if the crypt method needs a header region, some methods
1694 * don't need header extensions, so must check here
1696 if (s
->crypt_method_header
&& !s
->crypto
) {
1697 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1698 unsigned int cflags
= 0;
1699 if (flags
& BDRV_O_NO_IO
) {
1700 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
1702 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
1704 QCOW2_MAX_THREADS
, errp
);
1709 } else if (!(flags
& BDRV_O_NO_IO
)) {
1710 error_setg(errp
, "Missing CRYPTO header for crypt method %d",
1711 s
->crypt_method_header
);
1717 /* read the backing file name */
1718 if (header
.backing_file_offset
!= 0) {
1719 len
= header
.backing_file_size
;
1720 if (len
> MIN(1023, s
->cluster_size
- header
.backing_file_offset
) ||
1721 len
>= sizeof(bs
->backing_file
)) {
1722 error_setg(errp
, "Backing file name too long");
1727 s
->image_backing_file
= g_malloc(len
+ 1);
1728 ret
= bdrv_co_pread(bs
->file
, header
.backing_file_offset
, len
,
1729 s
->image_backing_file
, 0);
1731 error_setg_errno(errp
, -ret
, "Could not read backing file name");
1734 s
->image_backing_file
[len
] = '\0';
1737 * Update only when something has changed. This function is called by
1738 * qcow2_co_invalidate_cache(), and we do not want to reset
1739 * auto_backing_file unless necessary.
1741 if (!g_str_equal(s
->image_backing_file
, bs
->backing_file
)) {
1742 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
),
1743 s
->image_backing_file
);
1744 pstrcpy(bs
->auto_backing_file
, sizeof(bs
->auto_backing_file
),
1745 s
->image_backing_file
);
1750 * Internal snapshots; skip reading them in check mode, because
1751 * we do not need them then, and we do not want to abort because
1752 * of a broken table.
1754 if (!(flags
& BDRV_O_CHECK
)) {
1755 s
->snapshots_offset
= header
.snapshots_offset
;
1756 s
->nb_snapshots
= header
.nb_snapshots
;
1758 ret
= qcow2_read_snapshots(bs
, errp
);
1764 /* Clear unknown autoclear feature bits */
1765 update_header
|= s
->autoclear_features
& ~QCOW2_AUTOCLEAR_MASK
;
1766 update_header
= update_header
&& bdrv_is_writable(bs
);
1767 if (update_header
) {
1768 s
->autoclear_features
&= QCOW2_AUTOCLEAR_MASK
;
1771 /* == Handle persistent dirty bitmaps ==
1773 * We want load dirty bitmaps in three cases:
1775 * 1. Normal open of the disk in active mode, not related to invalidation
1778 * 2. Invalidation of the target vm after pre-copy phase of migration, if
1779 * bitmaps are _not_ migrating through migration channel, i.e.
1780 * 'dirty-bitmaps' capability is disabled.
1782 * 3. Invalidation of source vm after failed or canceled migration.
1783 * This is a very interesting case. There are two possible types of
1786 * A. Stored on inactivation and removed. They should be loaded from the
1789 * B. Not stored: not-persistent bitmaps and bitmaps, migrated through
1790 * the migration channel (with dirty-bitmaps capability).
1792 * On the other hand, there are two possible sub-cases:
1794 * 3.1 disk was changed by somebody else while were inactive. In this
1795 * case all in-RAM dirty bitmaps (both persistent and not) are
1796 * definitely invalid. And we don't have any method to determine
1799 * Simple and safe thing is to just drop all the bitmaps of type B on
1800 * inactivation. But in this case we lose bitmaps in valid 4.2 case.
1802 * On the other hand, resuming source vm, if disk was already changed
1803 * is a bad thing anyway: not only bitmaps, the whole vm state is
1804 * out of sync with disk.
1806 * This means, that user or management tool, who for some reason
1807 * decided to resume source vm, after disk was already changed by
1808 * target vm, should at least drop all dirty bitmaps by hand.
1810 * So, we can ignore this case for now, but TODO: "generation"
1811 * extension for qcow2, to determine, that image was changed after
1812 * last inactivation. And if it is changed, we will drop (or at least
1813 * mark as 'invalid' all the bitmaps of type B, both persistent
1816 * 3.2 disk was _not_ changed while were inactive. Bitmaps may be saved
1817 * to disk ('dirty-bitmaps' capability disabled), or not saved
1818 * ('dirty-bitmaps' capability enabled), but we don't need to care
1819 * of: let's load bitmaps as always: stored bitmaps will be loaded,
1820 * and not stored has flag IN_USE=1 in the image and will be skipped
1823 * One remaining possible case when we don't want load bitmaps:
1825 * 4. Open disk in inactive mode in target vm (bitmaps are migrating or
1826 * will be loaded on invalidation, no needs try loading them before)
1829 if (!(bdrv_get_flags(bs
) & BDRV_O_INACTIVE
)) {
1830 /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
1831 bool header_updated
;
1832 if (!qcow2_load_dirty_bitmaps(bs
, &header_updated
, errp
)) {
1837 update_header
= update_header
&& !header_updated
;
1840 if (update_header
) {
1841 ret
= qcow2_update_header(bs
);
1843 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
1848 bs
->supported_zero_flags
= header
.version
>= 3 ?
1849 BDRV_REQ_MAY_UNMAP
| BDRV_REQ_NO_FALLBACK
: 0;
1850 bs
->supported_truncate_flags
= BDRV_REQ_ZERO_WRITE
;
1852 /* Repair image if dirty */
1853 if (!(flags
& BDRV_O_CHECK
) && bdrv_is_writable(bs
) &&
1854 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
1855 BdrvCheckResult result
= {0};
1857 ret
= qcow2_co_check_locked(bs
, &result
,
1858 BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1859 if (ret
< 0 || result
.check_errors
) {
1863 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
1870 BdrvCheckResult result
= {0};
1871 qcow2_check_refcounts(bs
, &result
, 0);
1875 qemu_co_queue_init(&s
->thread_task_queue
);
1880 g_free(s
->image_data_file
);
1881 if (open_data_file
&& has_data_file(bs
)) {
1882 bdrv_graph_co_rdunlock();
1883 bdrv_co_unref_child(bs
, s
->data_file
);
1884 bdrv_graph_co_rdlock();
1885 s
->data_file
= NULL
;
1887 g_free(s
->unknown_header_fields
);
1888 cleanup_unknown_header_ext(bs
);
1889 qcow2_free_snapshots(bs
);
1890 qcow2_refcount_close(bs
);
1891 qemu_vfree(s
->l1_table
);
1892 /* else pre-write overlap checks in cache_destroy may crash */
1894 cache_clean_timer_del(bs
);
1895 if (s
->l2_table_cache
) {
1896 qcow2_cache_destroy(s
->l2_table_cache
);
1898 if (s
->refcount_block_cache
) {
1899 qcow2_cache_destroy(s
->refcount_block_cache
);
1901 qcrypto_block_free(s
->crypto
);
1902 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1906 typedef struct QCow2OpenCo
{
1907 BlockDriverState
*bs
;
1914 static void coroutine_fn
qcow2_open_entry(void *opaque
)
1916 QCow2OpenCo
*qoc
= opaque
;
1917 BDRVQcow2State
*s
= qoc
->bs
->opaque
;
1919 GRAPH_RDLOCK_GUARD();
1921 qemu_co_mutex_lock(&s
->lock
);
1922 qoc
->ret
= qcow2_do_open(qoc
->bs
, qoc
->options
, qoc
->flags
, true,
1924 qemu_co_mutex_unlock(&s
->lock
);
1929 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1932 BDRVQcow2State
*s
= bs
->opaque
;
1942 ret
= bdrv_open_file_child(NULL
, options
, "file", bs
, errp
);
1947 /* Initialise locks */
1948 qemu_co_mutex_init(&s
->lock
);
1950 assert(!qemu_in_coroutine());
1951 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
1953 aio_co_enter(bdrv_get_aio_context(bs
),
1954 qemu_coroutine_create(qcow2_open_entry
, &qoc
));
1955 AIO_WAIT_WHILE_UNLOCKED(NULL
, qoc
.ret
== -EINPROGRESS
);
1960 static void qcow2_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
1962 BDRVQcow2State
*s
= bs
->opaque
;
1964 if (bs
->encrypted
) {
1965 /* Encryption works on a sector granularity */
1966 bs
->bl
.request_alignment
= qcrypto_block_get_sector_size(s
->crypto
);
1968 bs
->bl
.pwrite_zeroes_alignment
= s
->subcluster_size
;
1969 bs
->bl
.pdiscard_alignment
= s
->cluster_size
;
1972 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
1973 BlockReopenQueue
*queue
, Error
**errp
)
1975 BDRVQcow2State
*s
= state
->bs
->opaque
;
1976 Qcow2ReopenState
*r
;
1979 r
= g_new0(Qcow2ReopenState
, 1);
1982 ret
= qcow2_update_options_prepare(state
->bs
, r
, state
->options
,
1983 state
->flags
, errp
);
1988 /* We need to write out any unwritten data if we reopen read-only. */
1989 if ((state
->flags
& BDRV_O_RDWR
) == 0) {
1990 ret
= qcow2_reopen_bitmaps_ro(state
->bs
, errp
);
1995 ret
= bdrv_flush(state
->bs
);
2000 ret
= qcow2_mark_clean(state
->bs
);
2007 * Without an external data file, s->data_file points to the same BdrvChild
2008 * as bs->file. It needs to be resynced after reopen because bs->file may
2009 * be changed. We can't use it in the meantime.
2011 if (!has_data_file(state
->bs
)) {
2012 assert(s
->data_file
== state
->bs
->file
);
2013 s
->data_file
= NULL
;
2019 qcow2_update_options_abort(state
->bs
, r
);
2024 static void qcow2_reopen_commit(BDRVReopenState
*state
)
2026 BDRVQcow2State
*s
= state
->bs
->opaque
;
2028 qcow2_update_options_commit(state
->bs
, state
->opaque
);
2029 if (!s
->data_file
) {
2031 * If we don't have an external data file, s->data_file was cleared by
2032 * qcow2_reopen_prepare() and needs to be updated.
2034 s
->data_file
= state
->bs
->file
;
2036 g_free(state
->opaque
);
2039 static void qcow2_reopen_commit_post(BDRVReopenState
*state
)
2041 if (state
->flags
& BDRV_O_RDWR
) {
2042 Error
*local_err
= NULL
;
2044 if (qcow2_reopen_bitmaps_rw(state
->bs
, &local_err
) < 0) {
2046 * This is not fatal, bitmaps just left read-only, so all following
2047 * writes will fail. User can remove read-only bitmaps to unblock
2048 * writes or retry reopen.
2050 error_reportf_err(local_err
,
2051 "%s: Failed to make dirty bitmaps writable: ",
2052 bdrv_get_node_name(state
->bs
));
2057 static void qcow2_reopen_abort(BDRVReopenState
*state
)
2059 BDRVQcow2State
*s
= state
->bs
->opaque
;
2061 if (!s
->data_file
) {
2063 * If we don't have an external data file, s->data_file was cleared by
2064 * qcow2_reopen_prepare() and needs to be restored.
2066 s
->data_file
= state
->bs
->file
;
2068 qcow2_update_options_abort(state
->bs
, state
->opaque
);
2069 g_free(state
->opaque
);
2072 static void qcow2_join_options(QDict
*options
, QDict
*old_options
)
2074 bool has_new_overlap_template
=
2075 qdict_haskey(options
, QCOW2_OPT_OVERLAP
) ||
2076 qdict_haskey(options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
2077 bool has_new_total_cache_size
=
2078 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
);
2079 bool has_all_cache_options
;
2081 /* New overlap template overrides all old overlap options */
2082 if (has_new_overlap_template
) {
2083 qdict_del(old_options
, QCOW2_OPT_OVERLAP
);
2084 qdict_del(old_options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
2085 qdict_del(old_options
, QCOW2_OPT_OVERLAP_MAIN_HEADER
);
2086 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L1
);
2087 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L2
);
2088 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
);
2089 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
);
2090 qdict_del(old_options
, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
);
2091 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L1
);
2092 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L2
);
2095 /* New total cache size overrides all old options */
2096 if (qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
)) {
2097 qdict_del(old_options
, QCOW2_OPT_L2_CACHE_SIZE
);
2098 qdict_del(old_options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
2101 qdict_join(options
, old_options
, false);
2104 * If after merging all cache size options are set, an old total size is
2105 * overwritten. Do keep all options, however, if all three are new. The
2106 * resulting error message is what we want to happen.
2108 has_all_cache_options
=
2109 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
) ||
2110 qdict_haskey(options
, QCOW2_OPT_L2_CACHE_SIZE
) ||
2111 qdict_haskey(options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
2113 if (has_all_cache_options
&& !has_new_total_cache_size
) {
2114 qdict_del(options
, QCOW2_OPT_CACHE_SIZE
);
2118 static int coroutine_fn GRAPH_RDLOCK
2119 qcow2_co_block_status(BlockDriverState
*bs
, bool want_zero
, int64_t offset
,
2120 int64_t count
, int64_t *pnum
, int64_t *map
,
2121 BlockDriverState
**file
)
2123 BDRVQcow2State
*s
= bs
->opaque
;
2124 uint64_t host_offset
;
2126 QCow2SubclusterType type
;
2127 int ret
, status
= 0;
2129 qemu_co_mutex_lock(&s
->lock
);
2131 if (!s
->metadata_preallocation_checked
) {
2132 ret
= qcow2_detect_metadata_preallocation(bs
);
2133 s
->metadata_preallocation
= (ret
== 1);
2134 s
->metadata_preallocation_checked
= true;
2137 bytes
= MIN(INT_MAX
, count
);
2138 ret
= qcow2_get_host_offset(bs
, offset
, &bytes
, &host_offset
, &type
);
2139 qemu_co_mutex_unlock(&s
->lock
);
2146 if ((type
== QCOW2_SUBCLUSTER_NORMAL
||
2147 type
== QCOW2_SUBCLUSTER_ZERO_ALLOC
||
2148 type
== QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
) && !s
->crypto
) {
2150 *file
= s
->data_file
->bs
;
2151 status
|= BDRV_BLOCK_OFFSET_VALID
;
2153 if (type
== QCOW2_SUBCLUSTER_ZERO_PLAIN
||
2154 type
== QCOW2_SUBCLUSTER_ZERO_ALLOC
) {
2155 status
|= BDRV_BLOCK_ZERO
;
2156 } else if (type
!= QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN
&&
2157 type
!= QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
) {
2158 status
|= BDRV_BLOCK_DATA
;
2160 if (s
->metadata_preallocation
&& (status
& BDRV_BLOCK_DATA
) &&
2161 (status
& BDRV_BLOCK_OFFSET_VALID
))
2163 status
|= BDRV_BLOCK_RECURSE
;
2165 if (type
== QCOW2_SUBCLUSTER_COMPRESSED
) {
2166 status
|= BDRV_BLOCK_COMPRESSED
;
2171 static int coroutine_fn GRAPH_RDLOCK
2172 qcow2_handle_l2meta(BlockDriverState
*bs
, QCowL2Meta
**pl2meta
, bool link_l2
)
2175 QCowL2Meta
*l2meta
= *pl2meta
;
2177 while (l2meta
!= NULL
) {
2181 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
2186 qcow2_alloc_cluster_abort(bs
, l2meta
);
2189 /* Take the request off the list of running requests */
2190 QLIST_REMOVE(l2meta
, next_in_flight
);
2192 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
2194 next
= l2meta
->next
;
2203 static int coroutine_fn GRAPH_RDLOCK
2204 qcow2_co_preadv_encrypted(BlockDriverState
*bs
,
2205 uint64_t host_offset
,
2209 uint64_t qiov_offset
)
2212 BDRVQcow2State
*s
= bs
->opaque
;
2215 assert(bs
->encrypted
&& s
->crypto
);
2216 assert(bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2219 * For encrypted images, read everything into a temporary
2220 * contiguous buffer on which the AES functions can work.
2221 * Also, decryption in a separate buffer is better as it
2222 * prevents the guest from learning information about the
2223 * encrypted nature of the virtual disk.
2226 buf
= qemu_try_blockalign(s
->data_file
->bs
, bytes
);
2231 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_READ_AIO
);
2232 ret
= bdrv_co_pread(s
->data_file
, host_offset
, bytes
, buf
, 0);
2237 if (qcow2_co_decrypt(bs
, host_offset
, offset
, buf
, bytes
) < 0)
2242 qemu_iovec_from_buf(qiov
, qiov_offset
, buf
, bytes
);
2250 typedef struct Qcow2AioTask
{
2253 BlockDriverState
*bs
;
2254 QCow2SubclusterType subcluster_type
; /* only for read */
2255 uint64_t host_offset
; /* or l2_entry for compressed read */
2259 uint64_t qiov_offset
;
2260 QCowL2Meta
*l2meta
; /* only for write */
2263 static coroutine_fn
int qcow2_co_preadv_task_entry(AioTask
*task
);
2264 static coroutine_fn
int qcow2_add_task(BlockDriverState
*bs
,
2267 QCow2SubclusterType subcluster_type
,
2268 uint64_t host_offset
,
2275 Qcow2AioTask local_task
;
2276 Qcow2AioTask
*task
= pool
? g_new(Qcow2AioTask
, 1) : &local_task
;
2278 *task
= (Qcow2AioTask
) {
2281 .subcluster_type
= subcluster_type
,
2283 .host_offset
= host_offset
,
2286 .qiov_offset
= qiov_offset
,
2290 trace_qcow2_add_task(qemu_coroutine_self(), bs
, pool
,
2291 func
== qcow2_co_preadv_task_entry
? "read" : "write",
2292 subcluster_type
, host_offset
, offset
, bytes
,
2296 return func(&task
->task
);
2299 aio_task_pool_start_task(pool
, &task
->task
);
2304 static int coroutine_fn GRAPH_RDLOCK
2305 qcow2_co_preadv_task(BlockDriverState
*bs
, QCow2SubclusterType subc_type
,
2306 uint64_t host_offset
, uint64_t offset
, uint64_t bytes
,
2307 QEMUIOVector
*qiov
, size_t qiov_offset
)
2309 BDRVQcow2State
*s
= bs
->opaque
;
2311 switch (subc_type
) {
2312 case QCOW2_SUBCLUSTER_ZERO_PLAIN
:
2313 case QCOW2_SUBCLUSTER_ZERO_ALLOC
:
2314 /* Both zero types are handled in qcow2_co_preadv_part */
2315 g_assert_not_reached();
2317 case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN
:
2318 case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
:
2319 assert(bs
->backing
); /* otherwise handled in qcow2_co_preadv_part */
2321 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
2322 return bdrv_co_preadv_part(bs
->backing
, offset
, bytes
,
2323 qiov
, qiov_offset
, 0);
2325 case QCOW2_SUBCLUSTER_COMPRESSED
:
2326 return qcow2_co_preadv_compressed(bs
, host_offset
,
2327 offset
, bytes
, qiov
, qiov_offset
);
2329 case QCOW2_SUBCLUSTER_NORMAL
:
2330 if (bs
->encrypted
) {
2331 return qcow2_co_preadv_encrypted(bs
, host_offset
,
2332 offset
, bytes
, qiov
, qiov_offset
);
2335 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_READ_AIO
);
2336 return bdrv_co_preadv_part(s
->data_file
, host_offset
,
2337 bytes
, qiov
, qiov_offset
, 0);
2340 g_assert_not_reached();
2343 g_assert_not_reached();
2347 * This function can count as GRAPH_RDLOCK because qcow2_co_preadv_part() holds
2348 * the graph lock and keeps it until this coroutine has terminated.
2350 static int coroutine_fn GRAPH_RDLOCK
qcow2_co_preadv_task_entry(AioTask
*task
)
2352 Qcow2AioTask
*t
= container_of(task
, Qcow2AioTask
, task
);
2356 return qcow2_co_preadv_task(t
->bs
, t
->subcluster_type
,
2357 t
->host_offset
, t
->offset
, t
->bytes
,
2358 t
->qiov
, t
->qiov_offset
);
2361 static int coroutine_fn GRAPH_RDLOCK
2362 qcow2_co_preadv_part(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
,
2363 QEMUIOVector
*qiov
, size_t qiov_offset
,
2364 BdrvRequestFlags flags
)
2366 BDRVQcow2State
*s
= bs
->opaque
;
2368 unsigned int cur_bytes
; /* number of bytes in current iteration */
2369 uint64_t host_offset
= 0;
2370 QCow2SubclusterType type
;
2371 AioTaskPool
*aio
= NULL
;
2373 while (bytes
!= 0 && aio_task_pool_status(aio
) == 0) {
2374 /* prepare next request */
2375 cur_bytes
= MIN(bytes
, INT_MAX
);
2377 cur_bytes
= MIN(cur_bytes
,
2378 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2381 qemu_co_mutex_lock(&s
->lock
);
2382 ret
= qcow2_get_host_offset(bs
, offset
, &cur_bytes
,
2383 &host_offset
, &type
);
2384 qemu_co_mutex_unlock(&s
->lock
);
2389 if (type
== QCOW2_SUBCLUSTER_ZERO_PLAIN
||
2390 type
== QCOW2_SUBCLUSTER_ZERO_ALLOC
||
2391 (type
== QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN
&& !bs
->backing
) ||
2392 (type
== QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
&& !bs
->backing
))
2394 qemu_iovec_memset(qiov
, qiov_offset
, 0, cur_bytes
);
2396 if (!aio
&& cur_bytes
!= bytes
) {
2397 aio
= aio_task_pool_new(QCOW2_MAX_WORKERS
);
2399 ret
= qcow2_add_task(bs
, aio
, qcow2_co_preadv_task_entry
, type
,
2400 host_offset
, offset
, cur_bytes
,
2401 qiov
, qiov_offset
, NULL
);
2408 offset
+= cur_bytes
;
2409 qiov_offset
+= cur_bytes
;
2414 aio_task_pool_wait_all(aio
);
2416 ret
= aio_task_pool_status(aio
);
2424 /* Check if it's possible to merge a write request with the writing of
2425 * the data from the COW regions */
2426 static bool merge_cow(uint64_t offset
, unsigned bytes
,
2427 QEMUIOVector
*qiov
, size_t qiov_offset
,
2432 for (m
= l2meta
; m
!= NULL
; m
= m
->next
) {
2433 /* If both COW regions are empty then there's nothing to merge */
2434 if (m
->cow_start
.nb_bytes
== 0 && m
->cow_end
.nb_bytes
== 0) {
2438 /* If COW regions are handled already, skip this too */
2444 * The write request should start immediately after the first
2445 * COW region. This does not always happen because the area
2446 * touched by the request can be larger than the one defined
2447 * by @m (a single request can span an area consisting of a
2448 * mix of previously unallocated and allocated clusters, that
2449 * is why @l2meta is a list).
2451 if (l2meta_cow_start(m
) + m
->cow_start
.nb_bytes
!= offset
) {
2452 /* In this case the request starts before this region */
2453 assert(offset
< l2meta_cow_start(m
));
2454 assert(m
->cow_start
.nb_bytes
== 0);
2458 /* The write request should end immediately before the second
2459 * COW region (see above for why it does not always happen) */
2460 if (m
->offset
+ m
->cow_end
.offset
!= offset
+ bytes
) {
2461 assert(offset
+ bytes
> m
->offset
+ m
->cow_end
.offset
);
2462 assert(m
->cow_end
.nb_bytes
== 0);
2466 /* Make sure that adding both COW regions to the QEMUIOVector
2467 * does not exceed IOV_MAX */
2468 if (qemu_iovec_subvec_niov(qiov
, qiov_offset
, bytes
) > IOV_MAX
- 2) {
2472 m
->data_qiov
= qiov
;
2473 m
->data_qiov_offset
= qiov_offset
;
2481 * Return 1 if the COW regions read as zeroes, 0 if not, < 0 on error.
2482 * Note that returning 0 does not guarantee non-zero data.
2484 static int coroutine_fn GRAPH_RDLOCK
2485 is_zero_cow(BlockDriverState
*bs
, QCowL2Meta
*m
)
2488 * This check is designed for optimization shortcut so it must be
2490 * Instead of is_zero(), use bdrv_co_is_zero_fast() as it is
2491 * faster (but not as accurate and can result in false negatives).
2493 int ret
= bdrv_co_is_zero_fast(bs
, m
->offset
+ m
->cow_start
.offset
,
2494 m
->cow_start
.nb_bytes
);
2499 return bdrv_co_is_zero_fast(bs
, m
->offset
+ m
->cow_end
.offset
,
2500 m
->cow_end
.nb_bytes
);
2503 static int coroutine_fn GRAPH_RDLOCK
2504 handle_alloc_space(BlockDriverState
*bs
, QCowL2Meta
*l2meta
)
2506 BDRVQcow2State
*s
= bs
->opaque
;
2509 if (!(s
->data_file
->bs
->supported_zero_flags
& BDRV_REQ_NO_FALLBACK
)) {
2513 if (bs
->encrypted
) {
2517 for (m
= l2meta
; m
!= NULL
; m
= m
->next
) {
2519 uint64_t start_offset
= m
->alloc_offset
+ m
->cow_start
.offset
;
2520 unsigned nb_bytes
= m
->cow_end
.offset
+ m
->cow_end
.nb_bytes
-
2521 m
->cow_start
.offset
;
2523 if (!m
->cow_start
.nb_bytes
&& !m
->cow_end
.nb_bytes
) {
2527 ret
= is_zero_cow(bs
, m
);
2530 } else if (ret
== 0) {
2535 * instead of writing zero COW buffers,
2536 * efficiently zero out the whole clusters
2539 ret
= qcow2_pre_write_overlap_check(bs
, 0, start_offset
, nb_bytes
,
2545 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_CLUSTER_ALLOC_SPACE
);
2546 ret
= bdrv_co_pwrite_zeroes(s
->data_file
, start_offset
, nb_bytes
,
2547 BDRV_REQ_NO_FALLBACK
);
2549 if (ret
!= -ENOTSUP
&& ret
!= -EAGAIN
) {
2555 trace_qcow2_skip_cow(qemu_coroutine_self(), m
->offset
, m
->nb_clusters
);
2562 * qcow2_co_pwritev_task
2563 * Called with s->lock unlocked
2564 * l2meta - if not NULL, qcow2_co_pwritev_task() will consume it. Caller must
2565 * not use it somehow after qcow2_co_pwritev_task() call
2567 static coroutine_fn GRAPH_RDLOCK
2568 int qcow2_co_pwritev_task(BlockDriverState
*bs
, uint64_t host_offset
,
2569 uint64_t offset
, uint64_t bytes
, QEMUIOVector
*qiov
,
2570 uint64_t qiov_offset
, QCowL2Meta
*l2meta
)
2573 BDRVQcow2State
*s
= bs
->opaque
;
2574 void *crypt_buf
= NULL
;
2575 QEMUIOVector encrypted_qiov
;
2577 if (bs
->encrypted
) {
2579 assert(bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2580 crypt_buf
= qemu_try_blockalign(bs
->file
->bs
, bytes
);
2581 if (crypt_buf
== NULL
) {
2585 qemu_iovec_to_buf(qiov
, qiov_offset
, crypt_buf
, bytes
);
2587 if (qcow2_co_encrypt(bs
, host_offset
, offset
, crypt_buf
, bytes
) < 0) {
2592 qemu_iovec_init_buf(&encrypted_qiov
, crypt_buf
, bytes
);
2593 qiov
= &encrypted_qiov
;
2597 /* Try to efficiently initialize the physical space with zeroes */
2598 ret
= handle_alloc_space(bs
, l2meta
);
2604 * If we need to do COW, check if it's possible to merge the
2605 * writing of the guest data together with that of the COW regions.
2606 * If it's not possible (or not necessary) then write the
2609 if (!merge_cow(offset
, bytes
, qiov
, qiov_offset
, l2meta
)) {
2610 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
2611 trace_qcow2_writev_data(qemu_coroutine_self(), host_offset
);
2612 ret
= bdrv_co_pwritev_part(s
->data_file
, host_offset
,
2613 bytes
, qiov
, qiov_offset
, 0);
2619 qemu_co_mutex_lock(&s
->lock
);
2621 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
2625 qemu_co_mutex_lock(&s
->lock
);
2628 qcow2_handle_l2meta(bs
, &l2meta
, false);
2629 qemu_co_mutex_unlock(&s
->lock
);
2631 qemu_vfree(crypt_buf
);
2637 * This function can count as GRAPH_RDLOCK because qcow2_co_pwritev_part() holds
2638 * the graph lock and keeps it until this coroutine has terminated.
2640 static coroutine_fn GRAPH_RDLOCK
int qcow2_co_pwritev_task_entry(AioTask
*task
)
2642 Qcow2AioTask
*t
= container_of(task
, Qcow2AioTask
, task
);
2644 assert(!t
->subcluster_type
);
2646 return qcow2_co_pwritev_task(t
->bs
, t
->host_offset
,
2647 t
->offset
, t
->bytes
, t
->qiov
, t
->qiov_offset
,
2651 static int coroutine_fn GRAPH_RDLOCK
2652 qcow2_co_pwritev_part(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
,
2653 QEMUIOVector
*qiov
, size_t qiov_offset
,
2654 BdrvRequestFlags flags
)
2656 BDRVQcow2State
*s
= bs
->opaque
;
2657 int offset_in_cluster
;
2659 unsigned int cur_bytes
; /* number of sectors in current iteration */
2660 uint64_t host_offset
;
2661 QCowL2Meta
*l2meta
= NULL
;
2662 AioTaskPool
*aio
= NULL
;
2664 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset
, bytes
);
2666 while (bytes
!= 0 && aio_task_pool_status(aio
) == 0) {
2670 trace_qcow2_writev_start_part(qemu_coroutine_self());
2671 offset_in_cluster
= offset_into_cluster(s
, offset
);
2672 cur_bytes
= MIN(bytes
, INT_MAX
);
2673 if (bs
->encrypted
) {
2674 cur_bytes
= MIN(cur_bytes
,
2675 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
2676 - offset_in_cluster
);
2679 qemu_co_mutex_lock(&s
->lock
);
2681 ret
= qcow2_alloc_host_offset(bs
, offset
, &cur_bytes
,
2682 &host_offset
, &l2meta
);
2687 ret
= qcow2_pre_write_overlap_check(bs
, 0, host_offset
,
2693 qemu_co_mutex_unlock(&s
->lock
);
2695 if (!aio
&& cur_bytes
!= bytes
) {
2696 aio
= aio_task_pool_new(QCOW2_MAX_WORKERS
);
2698 ret
= qcow2_add_task(bs
, aio
, qcow2_co_pwritev_task_entry
, 0,
2699 host_offset
, offset
,
2700 cur_bytes
, qiov
, qiov_offset
, l2meta
);
2701 l2meta
= NULL
; /* l2meta is consumed by qcow2_co_pwritev_task() */
2707 offset
+= cur_bytes
;
2708 qiov_offset
+= cur_bytes
;
2709 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes
);
2713 qemu_co_mutex_lock(&s
->lock
);
2716 qcow2_handle_l2meta(bs
, &l2meta
, false);
2718 qemu_co_mutex_unlock(&s
->lock
);
2722 aio_task_pool_wait_all(aio
);
2724 ret
= aio_task_pool_status(aio
);
2729 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
2734 static int qcow2_inactivate(BlockDriverState
*bs
)
2736 BDRVQcow2State
*s
= bs
->opaque
;
2737 int ret
, result
= 0;
2738 Error
*local_err
= NULL
;
2740 assume_graph_lock(); /* FIXME */
2742 qcow2_store_persistent_dirty_bitmaps(bs
, true, &local_err
);
2743 if (local_err
!= NULL
) {
2745 error_reportf_err(local_err
, "Lost persistent bitmaps during "
2746 "inactivation of node '%s': ",
2747 bdrv_get_device_or_node_name(bs
));
2750 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
2753 error_report("Failed to flush the L2 table cache: %s",
2757 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
2760 error_report("Failed to flush the refcount block cache: %s",
2765 qcow2_mark_clean(bs
);
2771 static void qcow2_do_close(BlockDriverState
*bs
, bool close_data_file
)
2773 BDRVQcow2State
*s
= bs
->opaque
;
2774 qemu_vfree(s
->l1_table
);
2775 /* else pre-write overlap checks in cache_destroy may crash */
2778 if (!(s
->flags
& BDRV_O_INACTIVE
)) {
2779 qcow2_inactivate(bs
);
2782 cache_clean_timer_del(bs
);
2783 qcow2_cache_destroy(s
->l2_table_cache
);
2784 qcow2_cache_destroy(s
->refcount_block_cache
);
2786 qcrypto_block_free(s
->crypto
);
2788 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
2790 g_free(s
->unknown_header_fields
);
2791 cleanup_unknown_header_ext(bs
);
2793 g_free(s
->image_data_file
);
2794 g_free(s
->image_backing_file
);
2795 g_free(s
->image_backing_format
);
2797 if (close_data_file
&& has_data_file(bs
)) {
2798 bdrv_graph_wrlock(NULL
);
2799 bdrv_unref_child(bs
, s
->data_file
);
2800 bdrv_graph_wrunlock();
2801 s
->data_file
= NULL
;
2804 qcow2_refcount_close(bs
);
2805 qcow2_free_snapshots(bs
);
2808 static void qcow2_close(BlockDriverState
*bs
)
2810 qcow2_do_close(bs
, true);
2813 static void coroutine_fn GRAPH_RDLOCK
2814 qcow2_co_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
2817 BDRVQcow2State
*s
= bs
->opaque
;
2818 BdrvChild
*data_file
;
2819 int flags
= s
->flags
;
2820 QCryptoBlock
*crypto
= NULL
;
2825 * Backing files are read-only which makes all of their metadata immutable,
2826 * that means we don't have to worry about reopening them here.
2833 * Do not reopen s->data_file (i.e., have qcow2_do_close() not close it,
2834 * and then prevent qcow2_do_open() from opening it), because this function
2835 * runs in the I/O path and as such we must not invoke global-state
2836 * functions like bdrv_unref_child() and bdrv_open_child().
2839 qcow2_do_close(bs
, false);
2841 data_file
= s
->data_file
;
2842 memset(s
, 0, sizeof(BDRVQcow2State
));
2843 s
->data_file
= data_file
;
2845 options
= qdict_clone_shallow(bs
->options
);
2847 flags
&= ~BDRV_O_INACTIVE
;
2848 qemu_co_mutex_lock(&s
->lock
);
2849 ret
= qcow2_do_open(bs
, options
, flags
, false, errp
);
2850 qemu_co_mutex_unlock(&s
->lock
);
2851 qobject_unref(options
);
2853 error_prepend(errp
, "Could not reopen qcow2 layer: ");
2861 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
2862 size_t len
, size_t buflen
)
2864 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
2865 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
2867 if (buflen
< ext_len
) {
2871 *ext_backing_fmt
= (QCowExtension
) {
2872 .magic
= cpu_to_be32(magic
),
2873 .len
= cpu_to_be32(len
),
2877 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
2884 * Updates the qcow2 header, including the variable length parts of it, i.e.
2885 * the backing file name and all extensions. qcow2 was not designed to allow
2886 * such changes, so if we run out of space (we can only use the first cluster)
2887 * this function may fail.
2889 * Returns 0 on success, -errno in error cases.
2891 int qcow2_update_header(BlockDriverState
*bs
)
2893 BDRVQcow2State
*s
= bs
->opaque
;
2896 size_t buflen
= s
->cluster_size
;
2898 uint64_t total_size
;
2899 uint32_t refcount_table_clusters
;
2900 size_t header_length
;
2901 Qcow2UnknownHeaderExtension
*uext
;
2903 buf
= qemu_blockalign(bs
, buflen
);
2905 /* Header structure */
2906 header
= (QCowHeader
*) buf
;
2908 if (buflen
< sizeof(*header
)) {
2913 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
2914 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2915 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
2917 ret
= validate_compression_type(s
, NULL
);
2922 *header
= (QCowHeader
) {
2923 /* Version 2 fields */
2924 .magic
= cpu_to_be32(QCOW_MAGIC
),
2925 .version
= cpu_to_be32(s
->qcow_version
),
2926 .backing_file_offset
= 0,
2927 .backing_file_size
= 0,
2928 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
2929 .size
= cpu_to_be64(total_size
),
2930 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
2931 .l1_size
= cpu_to_be32(s
->l1_size
),
2932 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
2933 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
2934 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
2935 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
2936 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
2938 /* Version 3 fields */
2939 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
2940 .compatible_features
= cpu_to_be64(s
->compatible_features
),
2941 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
2942 .refcount_order
= cpu_to_be32(s
->refcount_order
),
2943 .header_length
= cpu_to_be32(header_length
),
2944 .compression_type
= s
->compression_type
,
2947 /* For older versions, write a shorter header */
2948 switch (s
->qcow_version
) {
2950 ret
= offsetof(QCowHeader
, incompatible_features
);
2953 ret
= sizeof(*header
);
2962 memset(buf
, 0, buflen
);
2964 /* Preserve any unknown field in the header */
2965 if (s
->unknown_header_fields_size
) {
2966 if (buflen
< s
->unknown_header_fields_size
) {
2971 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
2972 buf
+= s
->unknown_header_fields_size
;
2973 buflen
-= s
->unknown_header_fields_size
;
2976 /* Backing file format header extension */
2977 if (s
->image_backing_format
) {
2978 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
2979 s
->image_backing_format
,
2980 strlen(s
->image_backing_format
),
2990 /* External data file header extension */
2991 if (has_data_file(bs
) && s
->image_data_file
) {
2992 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_DATA_FILE
,
2993 s
->image_data_file
, strlen(s
->image_data_file
),
3003 /* Full disk encryption header pointer extension */
3004 if (s
->crypto_header
.offset
!= 0) {
3005 s
->crypto_header
.offset
= cpu_to_be64(s
->crypto_header
.offset
);
3006 s
->crypto_header
.length
= cpu_to_be64(s
->crypto_header
.length
);
3007 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_CRYPTO_HEADER
,
3008 &s
->crypto_header
, sizeof(s
->crypto_header
),
3010 s
->crypto_header
.offset
= be64_to_cpu(s
->crypto_header
.offset
);
3011 s
->crypto_header
.length
= be64_to_cpu(s
->crypto_header
.length
);
3020 * Feature table. A mere 8 feature names occupies 392 bytes, and
3021 * when coupled with the v3 minimum header of 104 bytes plus the
3022 * 8-byte end-of-extension marker, that would leave only 8 bytes
3023 * for a backing file name in an image with 512-byte clusters.
3024 * Thus, we choose to omit this header for cluster sizes 4k and
3027 if (s
->qcow_version
>= 3 && s
->cluster_size
> 4096) {
3028 static const Qcow2Feature features
[] = {
3030 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
3031 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
3032 .name
= "dirty bit",
3035 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
3036 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
3037 .name
= "corrupt bit",
3040 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
3041 .bit
= QCOW2_INCOMPAT_DATA_FILE_BITNR
,
3042 .name
= "external data file",
3045 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
3046 .bit
= QCOW2_INCOMPAT_COMPRESSION_BITNR
,
3047 .name
= "compression type",
3050 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
3051 .bit
= QCOW2_INCOMPAT_EXTL2_BITNR
,
3052 .name
= "extended L2 entries",
3055 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
3056 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
3057 .name
= "lazy refcounts",
3060 .type
= QCOW2_FEAT_TYPE_AUTOCLEAR
,
3061 .bit
= QCOW2_AUTOCLEAR_BITMAPS_BITNR
,
3065 .type
= QCOW2_FEAT_TYPE_AUTOCLEAR
,
3066 .bit
= QCOW2_AUTOCLEAR_DATA_FILE_RAW_BITNR
,
3067 .name
= "raw external data",
3071 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
3072 features
, sizeof(features
), buflen
);
3080 /* Bitmap extension */
3081 if (s
->nb_bitmaps
> 0) {
3082 Qcow2BitmapHeaderExt bitmaps_header
= {
3083 .nb_bitmaps
= cpu_to_be32(s
->nb_bitmaps
),
3084 .bitmap_directory_size
=
3085 cpu_to_be64(s
->bitmap_directory_size
),
3086 .bitmap_directory_offset
=
3087 cpu_to_be64(s
->bitmap_directory_offset
)
3089 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BITMAPS
,
3090 &bitmaps_header
, sizeof(bitmaps_header
),
3099 /* Keep unknown header extensions */
3100 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
3101 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
3110 /* End of header extensions */
3111 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
3119 /* Backing file name */
3120 if (s
->image_backing_file
) {
3121 size_t backing_file_len
= strlen(s
->image_backing_file
);
3123 if (buflen
< backing_file_len
) {
3128 /* Using strncpy is ok here, since buf is not NUL-terminated. */
3129 strncpy(buf
, s
->image_backing_file
, buflen
);
3131 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
3132 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
3135 /* Write the new header */
3136 ret
= bdrv_pwrite(bs
->file
, 0, s
->cluster_size
, header
, 0);
3147 static int qcow2_change_backing_file(BlockDriverState
*bs
,
3148 const char *backing_file
, const char *backing_fmt
)
3150 BDRVQcow2State
*s
= bs
->opaque
;
3152 /* Adding a backing file means that the external data file alone won't be
3153 * enough to make sense of the content */
3154 if (backing_file
&& data_file_is_raw(bs
)) {
3158 if (backing_file
&& strlen(backing_file
) > 1023) {
3162 pstrcpy(bs
->auto_backing_file
, sizeof(bs
->auto_backing_file
),
3163 backing_file
?: "");
3164 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
3165 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
3167 g_free(s
->image_backing_file
);
3168 g_free(s
->image_backing_format
);
3170 s
->image_backing_file
= backing_file
? g_strdup(bs
->backing_file
) : NULL
;
3171 s
->image_backing_format
= backing_fmt
? g_strdup(bs
->backing_format
) : NULL
;
3173 return qcow2_update_header(bs
);
3176 static int coroutine_fn GRAPH_RDLOCK
3177 qcow2_set_up_encryption(BlockDriverState
*bs
,
3178 QCryptoBlockCreateOptions
*cryptoopts
,
3181 BDRVQcow2State
*s
= bs
->opaque
;
3182 QCryptoBlock
*crypto
= NULL
;
3185 switch (cryptoopts
->format
) {
3186 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
3187 fmt
= QCOW_CRYPT_LUKS
;
3189 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
3190 fmt
= QCOW_CRYPT_AES
;
3193 error_setg(errp
, "Crypto format not supported in qcow2");
3197 s
->crypt_method_header
= fmt
;
3199 crypto
= qcrypto_block_create(cryptoopts
, "encrypt.",
3200 qcow2_crypto_hdr_init_func
,
3201 qcow2_crypto_hdr_write_func
,
3207 ret
= qcow2_update_header(bs
);
3209 error_setg_errno(errp
, -ret
, "Could not write encryption header");
3215 qcrypto_block_free(crypto
);
3220 * Preallocates metadata structures for data clusters between @offset (in the
3221 * guest disk) and @new_length (which is thus generally the new guest disk
3224 * Returns: 0 on success, -errno on failure.
3226 static int coroutine_fn GRAPH_RDLOCK
3227 preallocate_co(BlockDriverState
*bs
, uint64_t offset
, uint64_t new_length
,
3228 PreallocMode mode
, Error
**errp
)
3230 BDRVQcow2State
*s
= bs
->opaque
;
3232 uint64_t host_offset
= 0;
3233 int64_t file_length
;
3234 unsigned int cur_bytes
;
3236 QCowL2Meta
*meta
= NULL
, *m
;
3238 assert(offset
<= new_length
);
3239 bytes
= new_length
- offset
;
3242 cur_bytes
= MIN(bytes
, QEMU_ALIGN_DOWN(INT_MAX
, s
->cluster_size
));
3243 ret
= qcow2_alloc_host_offset(bs
, offset
, &cur_bytes
,
3244 &host_offset
, &meta
);
3246 error_setg_errno(errp
, -ret
, "Allocating clusters failed");
3250 for (m
= meta
; m
!= NULL
; m
= m
->next
) {
3254 ret
= qcow2_handle_l2meta(bs
, &meta
, true);
3256 error_setg_errno(errp
, -ret
, "Mapping clusters failed");
3260 /* TODO Preallocate data if requested */
3263 offset
+= cur_bytes
;
3267 * It is expected that the image file is large enough to actually contain
3268 * all of the allocated clusters (otherwise we get failing reads after
3269 * EOF). Extend the image to the last allocated sector.
3271 file_length
= bdrv_co_getlength(s
->data_file
->bs
);
3272 if (file_length
< 0) {
3273 error_setg_errno(errp
, -file_length
, "Could not get file size");
3278 if (host_offset
+ cur_bytes
> file_length
) {
3279 if (mode
== PREALLOC_MODE_METADATA
) {
3280 mode
= PREALLOC_MODE_OFF
;
3282 ret
= bdrv_co_truncate(s
->data_file
, host_offset
+ cur_bytes
, false,
3292 qcow2_handle_l2meta(bs
, &meta
, false);
3296 /* qcow2_refcount_metadata_size:
3297 * @clusters: number of clusters to refcount (including data and L1/L2 tables)
3298 * @cluster_size: size of a cluster, in bytes
3299 * @refcount_order: refcount bits power-of-2 exponent
3300 * @generous_increase: allow for the refcount table to be 1.5x as large as it
3303 * Returns: Number of bytes required for refcount blocks and table metadata.
3305 int64_t qcow2_refcount_metadata_size(int64_t clusters
, size_t cluster_size
,
3306 int refcount_order
, bool generous_increase
,
3307 uint64_t *refblock_count
)
3310 * Every host cluster is reference-counted, including metadata (even
3311 * refcount metadata is recursively included).
3313 * An accurate formula for the size of refcount metadata size is difficult
3314 * to derive. An easier method of calculation is finding the fixed point
3315 * where no further refcount blocks or table clusters are required to
3316 * reference count every cluster.
3318 int64_t blocks_per_table_cluster
= cluster_size
/ REFTABLE_ENTRY_SIZE
;
3319 int64_t refcounts_per_block
= cluster_size
* 8 / (1 << refcount_order
);
3320 int64_t table
= 0; /* number of refcount table clusters */
3321 int64_t blocks
= 0; /* number of refcount block clusters */
3327 blocks
= DIV_ROUND_UP(clusters
+ table
+ blocks
, refcounts_per_block
);
3328 table
= DIV_ROUND_UP(blocks
, blocks_per_table_cluster
);
3329 n
= clusters
+ blocks
+ table
;
3331 if (n
== last
&& generous_increase
) {
3332 clusters
+= DIV_ROUND_UP(table
, 2);
3333 n
= 0; /* force another loop */
3334 generous_increase
= false;
3336 } while (n
!= last
);
3338 if (refblock_count
) {
3339 *refblock_count
= blocks
;
3342 return (blocks
+ table
) * cluster_size
;
3346 * qcow2_calc_prealloc_size:
3347 * @total_size: virtual disk size in bytes
3348 * @cluster_size: cluster size in bytes
3349 * @refcount_order: refcount bits power-of-2 exponent
3350 * @extended_l2: true if the image has extended L2 entries
3352 * Returns: Total number of bytes required for the fully allocated image
3353 * (including metadata).
3355 static int64_t qcow2_calc_prealloc_size(int64_t total_size
,
3356 size_t cluster_size
,
3360 int64_t meta_size
= 0;
3361 uint64_t nl1e
, nl2e
;
3362 int64_t aligned_total_size
= ROUND_UP(total_size
, cluster_size
);
3363 size_t l2e_size
= extended_l2
? L2E_SIZE_EXTENDED
: L2E_SIZE_NORMAL
;
3365 /* header: 1 cluster */
3366 meta_size
+= cluster_size
;
3368 /* total size of L2 tables */
3369 nl2e
= aligned_total_size
/ cluster_size
;
3370 nl2e
= ROUND_UP(nl2e
, cluster_size
/ l2e_size
);
3371 meta_size
+= nl2e
* l2e_size
;
3373 /* total size of L1 tables */
3374 nl1e
= nl2e
* l2e_size
/ cluster_size
;
3375 nl1e
= ROUND_UP(nl1e
, cluster_size
/ L1E_SIZE
);
3376 meta_size
+= nl1e
* L1E_SIZE
;
3378 /* total size of refcount table and blocks */
3379 meta_size
+= qcow2_refcount_metadata_size(
3380 (meta_size
+ aligned_total_size
) / cluster_size
,
3381 cluster_size
, refcount_order
, false, NULL
);
3383 return meta_size
+ aligned_total_size
;
3386 static bool validate_cluster_size(size_t cluster_size
, bool extended_l2
,
3389 int cluster_bits
= ctz32(cluster_size
);
3390 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
3391 (1 << cluster_bits
) != cluster_size
)
3393 error_setg(errp
, "Cluster size must be a power of two between %d and "
3394 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
3399 unsigned min_cluster_size
=
3400 (1 << MIN_CLUSTER_BITS
) * QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER
;
3401 if (cluster_size
< min_cluster_size
) {
3402 error_setg(errp
, "Extended L2 entries are only supported with "
3403 "cluster sizes of at least %u bytes", min_cluster_size
);
3411 static size_t qcow2_opt_get_cluster_size_del(QemuOpts
*opts
, bool extended_l2
,
3414 size_t cluster_size
;
3416 cluster_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
3417 DEFAULT_CLUSTER_SIZE
);
3418 if (!validate_cluster_size(cluster_size
, extended_l2
, errp
)) {
3421 return cluster_size
;
3424 static int qcow2_opt_get_version_del(QemuOpts
*opts
, Error
**errp
)
3429 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_COMPAT_LEVEL
);
3431 ret
= 3; /* default */
3432 } else if (!strcmp(buf
, "0.10")) {
3434 } else if (!strcmp(buf
, "1.1")) {
3437 error_setg(errp
, "Invalid compatibility level: '%s'", buf
);
3444 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts
*opts
, int version
,
3447 uint64_t refcount_bits
;
3449 refcount_bits
= qemu_opt_get_number_del(opts
, BLOCK_OPT_REFCOUNT_BITS
, 16);
3450 if (refcount_bits
> 64 || !is_power_of_2(refcount_bits
)) {
3451 error_setg(errp
, "Refcount width must be a power of two and may not "
3456 if (version
< 3 && refcount_bits
!= 16) {
3457 error_setg(errp
, "Different refcount widths than 16 bits require "
3458 "compatibility level 1.1 or above (use compat=1.1 or "
3463 return refcount_bits
;
3466 static int coroutine_fn GRAPH_UNLOCKED
3467 qcow2_co_create(BlockdevCreateOptions
*create_options
, Error
**errp
)
3469 BlockdevCreateOptionsQcow2
*qcow2_opts
;
3473 * Open the image file and write a minimal qcow2 header.
3475 * We keep things simple and start with a zero-sized image. We also
3476 * do without refcount blocks or a L1 table for now. We'll fix the
3477 * inconsistency later.
3479 * We do need a refcount table because growing the refcount table means
3480 * allocating two new refcount blocks - the second of which would be at
3481 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
3482 * size for any qcow2 image.
3484 BlockBackend
*blk
= NULL
;
3485 BlockDriverState
*bs
= NULL
;
3486 BlockDriverState
*data_bs
= NULL
;
3488 size_t cluster_size
;
3491 uint64_t *refcount_table
;
3493 uint8_t compression_type
= QCOW2_COMPRESSION_TYPE_ZLIB
;
3495 assert(create_options
->driver
== BLOCKDEV_DRIVER_QCOW2
);
3496 qcow2_opts
= &create_options
->u
.qcow2
;
3498 bs
= bdrv_co_open_blockdev_ref(qcow2_opts
->file
, errp
);
3503 /* Validate options and set default values */
3504 if (!QEMU_IS_ALIGNED(qcow2_opts
->size
, BDRV_SECTOR_SIZE
)) {
3505 error_setg(errp
, "Image size must be a multiple of %u bytes",
3506 (unsigned) BDRV_SECTOR_SIZE
);
3511 if (qcow2_opts
->has_version
) {
3512 switch (qcow2_opts
->version
) {
3513 case BLOCKDEV_QCOW2_VERSION_V2
:
3516 case BLOCKDEV_QCOW2_VERSION_V3
:
3520 g_assert_not_reached();
3526 if (qcow2_opts
->has_cluster_size
) {
3527 cluster_size
= qcow2_opts
->cluster_size
;
3529 cluster_size
= DEFAULT_CLUSTER_SIZE
;
3532 if (!qcow2_opts
->has_extended_l2
) {
3533 qcow2_opts
->extended_l2
= false;
3535 if (qcow2_opts
->extended_l2
) {
3537 error_setg(errp
, "Extended L2 entries are only supported with "
3538 "compatibility level 1.1 and above (use version=v3 or "
3545 if (!validate_cluster_size(cluster_size
, qcow2_opts
->extended_l2
, errp
)) {
3550 if (!qcow2_opts
->has_preallocation
) {
3551 qcow2_opts
->preallocation
= PREALLOC_MODE_OFF
;
3553 if (qcow2_opts
->backing_file
&&
3554 qcow2_opts
->preallocation
!= PREALLOC_MODE_OFF
&&
3555 !qcow2_opts
->extended_l2
)
3557 error_setg(errp
, "Backing file and preallocation can only be used at "
3558 "the same time if extended_l2 is on");
3562 if (qcow2_opts
->has_backing_fmt
&& !qcow2_opts
->backing_file
) {
3563 error_setg(errp
, "Backing format cannot be used without backing file");
3568 if (!qcow2_opts
->has_lazy_refcounts
) {
3569 qcow2_opts
->lazy_refcounts
= false;
3571 if (version
< 3 && qcow2_opts
->lazy_refcounts
) {
3572 error_setg(errp
, "Lazy refcounts only supported with compatibility "
3573 "level 1.1 and above (use version=v3 or greater)");
3578 if (!qcow2_opts
->has_refcount_bits
) {
3579 qcow2_opts
->refcount_bits
= 16;
3581 if (qcow2_opts
->refcount_bits
> 64 ||
3582 !is_power_of_2(qcow2_opts
->refcount_bits
))
3584 error_setg(errp
, "Refcount width must be a power of two and may not "
3589 if (version
< 3 && qcow2_opts
->refcount_bits
!= 16) {
3590 error_setg(errp
, "Different refcount widths than 16 bits require "
3591 "compatibility level 1.1 or above (use version=v3 or "
3596 refcount_order
= ctz32(qcow2_opts
->refcount_bits
);
3598 if (qcow2_opts
->data_file_raw
&& !qcow2_opts
->data_file
) {
3599 error_setg(errp
, "data-file-raw requires data-file");
3603 if (qcow2_opts
->data_file_raw
&& qcow2_opts
->backing_file
) {
3604 error_setg(errp
, "Backing file and data-file-raw cannot be used at "
3609 if (qcow2_opts
->data_file_raw
&&
3610 qcow2_opts
->preallocation
== PREALLOC_MODE_OFF
)
3613 * data-file-raw means that "the external data file can be
3614 * read as a consistent standalone raw image without looking
3615 * at the qcow2 metadata." It does not say that the metadata
3616 * must be ignored, though (and the qcow2 driver in fact does
3617 * not ignore it), so the L1/L2 tables must be present and
3618 * give a 1:1 mapping, so you get the same result regardless
3619 * of whether you look at the metadata or whether you ignore
3622 qcow2_opts
->preallocation
= PREALLOC_MODE_METADATA
;
3625 * Cannot use preallocation with backing files, but giving a
3626 * backing file when specifying data_file_raw is an error
3629 assert(!qcow2_opts
->backing_file
);
3632 if (qcow2_opts
->data_file
) {
3634 error_setg(errp
, "External data files are only supported with "
3635 "compatibility level 1.1 and above (use version=v3 or "
3640 data_bs
= bdrv_co_open_blockdev_ref(qcow2_opts
->data_file
, errp
);
3641 if (data_bs
== NULL
) {
3647 if (qcow2_opts
->has_compression_type
&&
3648 qcow2_opts
->compression_type
!= QCOW2_COMPRESSION_TYPE_ZLIB
) {
3653 error_setg(errp
, "Non-zlib compression type is only supported with "
3654 "compatibility level 1.1 and above (use version=v3 or "
3659 switch (qcow2_opts
->compression_type
) {
3661 case QCOW2_COMPRESSION_TYPE_ZSTD
:
3665 error_setg(errp
, "Unknown compression type");
3669 compression_type
= qcow2_opts
->compression_type
;
3672 /* Create BlockBackend to write to the image */
3673 blk
= blk_co_new_with_bs(bs
, BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
,
3679 blk_set_allow_write_beyond_eof(blk
, true);
3681 /* Write the header */
3682 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS
) < sizeof(*header
));
3683 header
= g_malloc0(cluster_size
);
3684 *header
= (QCowHeader
) {
3685 .magic
= cpu_to_be32(QCOW_MAGIC
),
3686 .version
= cpu_to_be32(version
),
3687 .cluster_bits
= cpu_to_be32(ctz32(cluster_size
)),
3688 .size
= cpu_to_be64(0),
3689 .l1_table_offset
= cpu_to_be64(0),
3690 .l1_size
= cpu_to_be32(0),
3691 .refcount_table_offset
= cpu_to_be64(cluster_size
),
3692 .refcount_table_clusters
= cpu_to_be32(1),
3693 .refcount_order
= cpu_to_be32(refcount_order
),
3694 /* don't deal with endianness since compression_type is 1 byte long */
3695 .compression_type
= compression_type
,
3696 .header_length
= cpu_to_be32(sizeof(*header
)),
3699 /* We'll update this to correct value later */
3700 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
3702 if (qcow2_opts
->lazy_refcounts
) {
3703 header
->compatible_features
|=
3704 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
3707 header
->incompatible_features
|=
3708 cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE
);
3710 if (qcow2_opts
->data_file_raw
) {
3711 header
->autoclear_features
|=
3712 cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW
);
3714 if (compression_type
!= QCOW2_COMPRESSION_TYPE_ZLIB
) {
3715 header
->incompatible_features
|=
3716 cpu_to_be64(QCOW2_INCOMPAT_COMPRESSION
);
3719 if (qcow2_opts
->extended_l2
) {
3720 header
->incompatible_features
|=
3721 cpu_to_be64(QCOW2_INCOMPAT_EXTL2
);
3724 ret
= blk_co_pwrite(blk
, 0, cluster_size
, header
, 0);
3727 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
3731 /* Write a refcount table with one refcount block */
3732 refcount_table
= g_malloc0(2 * cluster_size
);
3733 refcount_table
[0] = cpu_to_be64(2 * cluster_size
);
3734 ret
= blk_co_pwrite(blk
, cluster_size
, 2 * cluster_size
, refcount_table
, 0);
3735 g_free(refcount_table
);
3738 error_setg_errno(errp
, -ret
, "Could not write refcount table");
3746 * And now open the image and make it consistent first (i.e. increase the
3747 * refcount of the cluster that is occupied by the header and the refcount
3750 options
= qdict_new();
3751 qdict_put_str(options
, "driver", "qcow2");
3752 qdict_put_str(options
, "file", bs
->node_name
);
3754 qdict_put_str(options
, "data-file", data_bs
->node_name
);
3756 blk
= blk_co_new_open(NULL
, NULL
, options
,
3757 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_NO_FLUSH
,
3764 bdrv_graph_co_rdlock();
3765 ret
= qcow2_alloc_clusters(blk_bs(blk
), 3 * cluster_size
);
3767 bdrv_graph_co_rdunlock();
3768 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
3769 "header and refcount table");
3772 } else if (ret
!= 0) {
3773 error_report("Huh, first cluster in empty image is already in use?");
3777 /* Set the external data file if necessary */
3779 BDRVQcow2State
*s
= blk_bs(blk
)->opaque
;
3780 s
->image_data_file
= g_strdup(data_bs
->filename
);
3783 /* Create a full header (including things like feature table) */
3784 ret
= qcow2_update_header(blk_bs(blk
));
3785 bdrv_graph_co_rdunlock();
3788 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
3792 /* Okay, now that we have a valid image, let's give it the right size */
3793 ret
= blk_co_truncate(blk
, qcow2_opts
->size
, false,
3794 qcow2_opts
->preallocation
, 0, errp
);
3796 error_prepend(errp
, "Could not resize image: ");
3800 /* Want a backing file? There you go. */
3801 if (qcow2_opts
->backing_file
) {
3802 const char *backing_format
= NULL
;
3804 if (qcow2_opts
->has_backing_fmt
) {
3805 backing_format
= BlockdevDriver_str(qcow2_opts
->backing_fmt
);
3808 ret
= bdrv_change_backing_file(blk_bs(blk
), qcow2_opts
->backing_file
,
3809 backing_format
, false);
3811 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
3812 "with format '%s'", qcow2_opts
->backing_file
,
3818 /* Want encryption? There you go. */
3819 if (qcow2_opts
->encrypt
) {
3820 bdrv_graph_co_rdlock();
3821 ret
= qcow2_set_up_encryption(blk_bs(blk
), qcow2_opts
->encrypt
, errp
);
3822 bdrv_graph_co_rdunlock();
3832 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
3833 * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
3834 * have to setup decryption context. We're not doing any I/O on the top
3835 * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
3838 options
= qdict_new();
3839 qdict_put_str(options
, "driver", "qcow2");
3840 qdict_put_str(options
, "file", bs
->node_name
);
3842 qdict_put_str(options
, "data-file", data_bs
->node_name
);
3844 blk
= blk_co_new_open(NULL
, NULL
, options
,
3845 BDRV_O_RDWR
| BDRV_O_NO_BACKING
| BDRV_O_NO_IO
,
3856 bdrv_co_unref(data_bs
);
3860 static int coroutine_fn GRAPH_UNLOCKED
3861 qcow2_co_create_opts(BlockDriver
*drv
, const char *filename
, QemuOpts
*opts
,
3864 BlockdevCreateOptions
*create_options
= NULL
;
3867 BlockDriverState
*bs
= NULL
;
3868 BlockDriverState
*data_bs
= NULL
;
3872 /* Only the keyval visitor supports the dotted syntax needed for
3873 * encryption, so go through a QDict before getting a QAPI type. Ignore
3874 * options meant for the protocol layer so that the visitor doesn't
3876 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, bdrv_qcow2
.create_opts
,
3879 /* Handle encryption options */
3880 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT
);
3881 if (val
&& !strcmp(val
, "on")) {
3882 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT
, "qcow");
3883 } else if (val
&& !strcmp(val
, "off")) {
3884 qdict_del(qdict
, BLOCK_OPT_ENCRYPT
);
3887 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
);
3888 if (val
&& !strcmp(val
, "aes")) {
3889 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
, "qcow");
3892 /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into
3893 * version=v2/v3 below. */
3894 val
= qdict_get_try_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
);
3895 if (val
&& !strcmp(val
, "0.10")) {
3896 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v2");
3897 } else if (val
&& !strcmp(val
, "1.1")) {
3898 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v3");
3901 /* Change legacy command line options into QMP ones */
3902 static const QDictRenames opt_renames
[] = {
3903 { BLOCK_OPT_BACKING_FILE
, "backing-file" },
3904 { BLOCK_OPT_BACKING_FMT
, "backing-fmt" },
3905 { BLOCK_OPT_CLUSTER_SIZE
, "cluster-size" },
3906 { BLOCK_OPT_LAZY_REFCOUNTS
, "lazy-refcounts" },
3907 { BLOCK_OPT_EXTL2
, "extended-l2" },
3908 { BLOCK_OPT_REFCOUNT_BITS
, "refcount-bits" },
3909 { BLOCK_OPT_ENCRYPT
, BLOCK_OPT_ENCRYPT_FORMAT
},
3910 { BLOCK_OPT_COMPAT_LEVEL
, "version" },
3911 { BLOCK_OPT_DATA_FILE_RAW
, "data-file-raw" },
3912 { BLOCK_OPT_COMPRESSION_TYPE
, "compression-type" },
3916 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
3921 /* Create and open the file (protocol layer) */
3922 ret
= bdrv_co_create_file(filename
, opts
, errp
);
3927 bs
= bdrv_co_open(filename
, NULL
, NULL
,
3928 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
3934 /* Create and open an external data file (protocol layer) */
3935 val
= qdict_get_try_str(qdict
, BLOCK_OPT_DATA_FILE
);
3937 ret
= bdrv_co_create_file(val
, opts
, errp
);
3942 data_bs
= bdrv_co_open(val
, NULL
, NULL
,
3943 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
,
3945 if (data_bs
== NULL
) {
3950 qdict_del(qdict
, BLOCK_OPT_DATA_FILE
);
3951 qdict_put_str(qdict
, "data-file", data_bs
->node_name
);
3954 /* Set 'driver' and 'node' options */
3955 qdict_put_str(qdict
, "driver", "qcow2");
3956 qdict_put_str(qdict
, "file", bs
->node_name
);
3958 /* Now get the QAPI type BlockdevCreateOptions */
3959 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
3965 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, errp
);
3967 if (!create_options
) {
3972 /* Silently round up size */
3973 create_options
->u
.qcow2
.size
= ROUND_UP(create_options
->u
.qcow2
.size
,
3976 /* Create the qcow2 image (format layer) */
3977 ret
= qcow2_co_create(create_options
, errp
);
3980 bdrv_graph_co_rdlock();
3981 bdrv_co_delete_file_noerr(bs
);
3982 bdrv_co_delete_file_noerr(data_bs
);
3983 bdrv_graph_co_rdunlock();
3988 qobject_unref(qdict
);
3990 bdrv_co_unref(data_bs
);
3991 qapi_free_BlockdevCreateOptions(create_options
);
3996 static bool coroutine_fn GRAPH_RDLOCK
3997 is_zero(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
4002 /* Clamp to image length, before checking status of underlying sectors */
4003 if (offset
+ bytes
> bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
4004 bytes
= bs
->total_sectors
* BDRV_SECTOR_SIZE
- offset
;
4012 * bdrv_block_status_above doesn't merge different types of zeros, for
4013 * example, zeros which come from the region which is unallocated in
4014 * the whole backing chain, and zeros which come because of a short
4015 * backing file. So, we need a loop.
4018 res
= bdrv_co_block_status_above(bs
, NULL
, offset
, bytes
, &nr
, NULL
, NULL
);
4021 } while (res
>= 0 && (res
& BDRV_BLOCK_ZERO
) && nr
&& bytes
);
4023 return res
>= 0 && (res
& BDRV_BLOCK_ZERO
) && bytes
== 0;
4026 static int coroutine_fn GRAPH_RDLOCK
4027 qcow2_co_pwrite_zeroes(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
,
4028 BdrvRequestFlags flags
)
4031 BDRVQcow2State
*s
= bs
->opaque
;
4033 uint32_t head
= offset_into_subcluster(s
, offset
);
4034 uint32_t tail
= ROUND_UP(offset
+ bytes
, s
->subcluster_size
) -
4037 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset
, bytes
);
4038 if (offset
+ bytes
== bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
4045 QCow2SubclusterType type
;
4047 assert(head
+ bytes
+ tail
<= s
->subcluster_size
);
4049 /* check whether remainder of cluster already reads as zero */
4050 if (!(is_zero(bs
, offset
- head
, head
) &&
4051 is_zero(bs
, offset
+ bytes
, tail
))) {
4055 qemu_co_mutex_lock(&s
->lock
);
4056 /* We can have new write after previous check */
4058 bytes
= s
->subcluster_size
;
4059 nr
= s
->subcluster_size
;
4060 ret
= qcow2_get_host_offset(bs
, offset
, &nr
, &off
, &type
);
4062 (type
!= QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN
&&
4063 type
!= QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
&&
4064 type
!= QCOW2_SUBCLUSTER_ZERO_PLAIN
&&
4065 type
!= QCOW2_SUBCLUSTER_ZERO_ALLOC
)) {
4066 qemu_co_mutex_unlock(&s
->lock
);
4067 return ret
< 0 ? ret
: -ENOTSUP
;
4070 qemu_co_mutex_lock(&s
->lock
);
4073 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset
, bytes
);
4075 /* Whatever is left can use real zero subclusters */
4076 ret
= qcow2_subcluster_zeroize(bs
, offset
, bytes
, flags
);
4077 qemu_co_mutex_unlock(&s
->lock
);
4082 static coroutine_fn
int qcow2_co_pdiscard(BlockDriverState
*bs
,
4083 int64_t offset
, int64_t bytes
)
4086 BDRVQcow2State
*s
= bs
->opaque
;
4088 /* If the image does not support QCOW_OFLAG_ZERO then discarding
4089 * clusters could expose stale data from the backing file. */
4090 if (s
->qcow_version
< 3 && bs
->backing
) {
4094 if (!QEMU_IS_ALIGNED(offset
| bytes
, s
->cluster_size
)) {
4095 assert(bytes
< s
->cluster_size
);
4096 /* Ignore partial clusters, except for the special case of the
4097 * complete partial cluster at the end of an unaligned file */
4098 if (!QEMU_IS_ALIGNED(offset
, s
->cluster_size
) ||
4099 offset
+ bytes
!= bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
4104 qemu_co_mutex_lock(&s
->lock
);
4105 ret
= qcow2_cluster_discard(bs
, offset
, bytes
, QCOW2_DISCARD_REQUEST
,
4107 qemu_co_mutex_unlock(&s
->lock
);
4111 static int coroutine_fn GRAPH_RDLOCK
4112 qcow2_co_copy_range_from(BlockDriverState
*bs
,
4113 BdrvChild
*src
, int64_t src_offset
,
4114 BdrvChild
*dst
, int64_t dst_offset
,
4115 int64_t bytes
, BdrvRequestFlags read_flags
,
4116 BdrvRequestFlags write_flags
)
4118 BDRVQcow2State
*s
= bs
->opaque
;
4120 unsigned int cur_bytes
; /* number of bytes in current iteration */
4121 BdrvChild
*child
= NULL
;
4122 BdrvRequestFlags cur_write_flags
;
4124 assert(!bs
->encrypted
);
4125 qemu_co_mutex_lock(&s
->lock
);
4127 while (bytes
!= 0) {
4128 uint64_t copy_offset
= 0;
4129 QCow2SubclusterType type
;
4130 /* prepare next request */
4131 cur_bytes
= MIN(bytes
, INT_MAX
);
4132 cur_write_flags
= write_flags
;
4134 ret
= qcow2_get_host_offset(bs
, src_offset
, &cur_bytes
,
4135 ©_offset
, &type
);
4141 case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN
:
4142 case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC
:
4143 if (bs
->backing
&& bs
->backing
->bs
) {
4144 int64_t backing_length
= bdrv_co_getlength(bs
->backing
->bs
);
4145 if (src_offset
>= backing_length
) {
4146 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
4148 child
= bs
->backing
;
4149 cur_bytes
= MIN(cur_bytes
, backing_length
- src_offset
);
4150 copy_offset
= src_offset
;
4153 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
4157 case QCOW2_SUBCLUSTER_ZERO_PLAIN
:
4158 case QCOW2_SUBCLUSTER_ZERO_ALLOC
:
4159 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
4162 case QCOW2_SUBCLUSTER_COMPRESSED
:
4166 case QCOW2_SUBCLUSTER_NORMAL
:
4167 child
= s
->data_file
;
4173 qemu_co_mutex_unlock(&s
->lock
);
4174 ret
= bdrv_co_copy_range_from(child
,
4177 cur_bytes
, read_flags
, cur_write_flags
);
4178 qemu_co_mutex_lock(&s
->lock
);
4184 src_offset
+= cur_bytes
;
4185 dst_offset
+= cur_bytes
;
4190 qemu_co_mutex_unlock(&s
->lock
);
4194 static int coroutine_fn GRAPH_RDLOCK
4195 qcow2_co_copy_range_to(BlockDriverState
*bs
,
4196 BdrvChild
*src
, int64_t src_offset
,
4197 BdrvChild
*dst
, int64_t dst_offset
,
4198 int64_t bytes
, BdrvRequestFlags read_flags
,
4199 BdrvRequestFlags write_flags
)
4201 BDRVQcow2State
*s
= bs
->opaque
;
4203 unsigned int cur_bytes
; /* number of sectors in current iteration */
4204 uint64_t host_offset
;
4205 QCowL2Meta
*l2meta
= NULL
;
4207 assert(!bs
->encrypted
);
4209 qemu_co_mutex_lock(&s
->lock
);
4211 while (bytes
!= 0) {
4215 cur_bytes
= MIN(bytes
, INT_MAX
);
4218 * If src->bs == dst->bs, we could simply copy by incrementing
4219 * the refcnt, without copying user data.
4220 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
4221 ret
= qcow2_alloc_host_offset(bs
, dst_offset
, &cur_bytes
,
4222 &host_offset
, &l2meta
);
4227 ret
= qcow2_pre_write_overlap_check(bs
, 0, host_offset
, cur_bytes
,
4233 qemu_co_mutex_unlock(&s
->lock
);
4234 ret
= bdrv_co_copy_range_to(src
, src_offset
, s
->data_file
, host_offset
,
4235 cur_bytes
, read_flags
, write_flags
);
4236 qemu_co_mutex_lock(&s
->lock
);
4241 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
4247 src_offset
+= cur_bytes
;
4248 dst_offset
+= cur_bytes
;
4253 qcow2_handle_l2meta(bs
, &l2meta
, false);
4255 qemu_co_mutex_unlock(&s
->lock
);
4257 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
4262 static int coroutine_fn GRAPH_RDLOCK
4263 qcow2_co_truncate(BlockDriverState
*bs
, int64_t offset
, bool exact
,
4264 PreallocMode prealloc
, BdrvRequestFlags flags
, Error
**errp
)
4266 BDRVQcow2State
*s
= bs
->opaque
;
4267 uint64_t old_length
;
4268 int64_t new_l1_size
;
4272 if (prealloc
!= PREALLOC_MODE_OFF
&& prealloc
!= PREALLOC_MODE_METADATA
&&
4273 prealloc
!= PREALLOC_MODE_FALLOC
&& prealloc
!= PREALLOC_MODE_FULL
)
4275 error_setg(errp
, "Unsupported preallocation mode '%s'",
4276 PreallocMode_str(prealloc
));
4280 if (!QEMU_IS_ALIGNED(offset
, BDRV_SECTOR_SIZE
)) {
4281 error_setg(errp
, "The new size must be a multiple of %u",
4282 (unsigned) BDRV_SECTOR_SIZE
);
4286 qemu_co_mutex_lock(&s
->lock
);
4289 * Even though we store snapshot size for all images, it was not
4290 * required until v3, so it is not safe to proceed for v2.
4292 if (s
->nb_snapshots
&& s
->qcow_version
< 3) {
4293 error_setg(errp
, "Can't resize a v2 image which has snapshots");
4298 /* See qcow2-bitmap.c for which bitmap scenarios prevent a resize. */
4299 if (qcow2_truncate_bitmaps_check(bs
, errp
)) {
4304 old_length
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
4305 new_l1_size
= size_to_l1(s
, offset
);
4307 if (offset
< old_length
) {
4308 int64_t last_cluster
, old_file_size
;
4309 if (prealloc
!= PREALLOC_MODE_OFF
) {
4311 "Preallocation can't be used for shrinking an image");
4316 ret
= qcow2_cluster_discard(bs
, ROUND_UP(offset
, s
->cluster_size
),
4317 old_length
- ROUND_UP(offset
,
4319 QCOW2_DISCARD_ALWAYS
, true);
4321 error_setg_errno(errp
, -ret
, "Failed to discard cropped clusters");
4325 ret
= qcow2_shrink_l1_table(bs
, new_l1_size
);
4327 error_setg_errno(errp
, -ret
,
4328 "Failed to reduce the number of L2 tables");
4332 ret
= qcow2_shrink_reftable(bs
);
4334 error_setg_errno(errp
, -ret
,
4335 "Failed to discard unused refblocks");
4339 old_file_size
= bdrv_co_getlength(bs
->file
->bs
);
4340 if (old_file_size
< 0) {
4341 error_setg_errno(errp
, -old_file_size
,
4342 "Failed to inquire current file length");
4343 ret
= old_file_size
;
4346 last_cluster
= qcow2_get_last_cluster(bs
, old_file_size
);
4347 if (last_cluster
< 0) {
4348 error_setg_errno(errp
, -last_cluster
,
4349 "Failed to find the last cluster");
4353 if ((last_cluster
+ 1) * s
->cluster_size
< old_file_size
) {
4354 Error
*local_err
= NULL
;
4357 * Do not pass @exact here: It will not help the user if
4358 * we get an error here just because they wanted to shrink
4359 * their qcow2 image (on a block device) with qemu-img.
4360 * (And on the qcow2 layer, the @exact requirement is
4361 * always fulfilled, so there is no need to pass it on.)
4363 bdrv_co_truncate(bs
->file
, (last_cluster
+ 1) * s
->cluster_size
,
4364 false, PREALLOC_MODE_OFF
, 0, &local_err
);
4366 warn_reportf_err(local_err
,
4367 "Failed to truncate the tail of the image: ");
4371 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
4373 error_setg_errno(errp
, -ret
, "Failed to grow the L1 table");
4377 if (data_file_is_raw(bs
) && prealloc
== PREALLOC_MODE_OFF
) {
4379 * When creating a qcow2 image with data-file-raw, we enforce
4380 * at least prealloc=metadata, so that the L1/L2 tables are
4381 * fully allocated and reading from the data file will return
4382 * the same data as reading from the qcow2 image. When the
4383 * image is grown, we must consequently preallocate the
4384 * metadata structures to cover the added area.
4386 prealloc
= PREALLOC_MODE_METADATA
;
4391 case PREALLOC_MODE_OFF
:
4392 if (has_data_file(bs
)) {
4394 * If the caller wants an exact resize, the external data
4395 * file should be resized to the exact target size, too,
4396 * so we pass @exact here.
4398 ret
= bdrv_co_truncate(s
->data_file
, offset
, exact
, prealloc
, 0,
4406 case PREALLOC_MODE_METADATA
:
4407 ret
= preallocate_co(bs
, old_length
, offset
, prealloc
, errp
);
4413 case PREALLOC_MODE_FALLOC
:
4414 case PREALLOC_MODE_FULL
:
4416 int64_t allocation_start
, host_offset
, guest_offset
;
4417 int64_t clusters_allocated
;
4418 int64_t old_file_size
, last_cluster
, new_file_size
;
4419 uint64_t nb_new_data_clusters
, nb_new_l2_tables
;
4420 bool subclusters_need_allocation
= false;
4422 /* With a data file, preallocation means just allocating the metadata
4423 * and forwarding the truncate request to the data file */
4424 if (has_data_file(bs
)) {
4425 ret
= preallocate_co(bs
, old_length
, offset
, prealloc
, errp
);
4432 old_file_size
= bdrv_co_getlength(bs
->file
->bs
);
4433 if (old_file_size
< 0) {
4434 error_setg_errno(errp
, -old_file_size
,
4435 "Failed to inquire current file length");
4436 ret
= old_file_size
;
4440 last_cluster
= qcow2_get_last_cluster(bs
, old_file_size
);
4441 if (last_cluster
>= 0) {
4442 old_file_size
= (last_cluster
+ 1) * s
->cluster_size
;
4444 old_file_size
= ROUND_UP(old_file_size
, s
->cluster_size
);
4447 nb_new_data_clusters
= (ROUND_UP(offset
, s
->cluster_size
) -
4448 start_of_cluster(s
, old_length
)) >> s
->cluster_bits
;
4450 /* This is an overestimation; we will not actually allocate space for
4451 * these in the file but just make sure the new refcount structures are
4452 * able to cover them so we will not have to allocate new refblocks
4453 * while entering the data blocks in the potentially new L2 tables.
4454 * (We do not actually care where the L2 tables are placed. Maybe they
4455 * are already allocated or they can be placed somewhere before
4456 * @old_file_size. It does not matter because they will be fully
4457 * allocated automatically, so they do not need to be covered by the
4458 * preallocation. All that matters is that we will not have to allocate
4459 * new refcount structures for them.) */
4460 nb_new_l2_tables
= DIV_ROUND_UP(nb_new_data_clusters
,
4461 s
->cluster_size
/ l2_entry_size(s
));
4462 /* The cluster range may not be aligned to L2 boundaries, so add one L2
4463 * table for a potential head/tail */
4466 allocation_start
= qcow2_refcount_area(bs
, old_file_size
,
4467 nb_new_data_clusters
+
4470 if (allocation_start
< 0) {
4471 error_setg_errno(errp
, -allocation_start
,
4472 "Failed to resize refcount structures");
4473 ret
= allocation_start
;
4477 clusters_allocated
= qcow2_alloc_clusters_at(bs
, allocation_start
,
4478 nb_new_data_clusters
);
4479 if (clusters_allocated
< 0) {
4480 error_setg_errno(errp
, -clusters_allocated
,
4481 "Failed to allocate data clusters");
4482 ret
= clusters_allocated
;
4486 assert(clusters_allocated
== nb_new_data_clusters
);
4488 /* Allocate the data area */
4489 new_file_size
= allocation_start
+
4490 nb_new_data_clusters
* s
->cluster_size
;
4492 * Image file grows, so @exact does not matter.
4494 * If we need to zero out the new area, try first whether the protocol
4495 * driver can already take care of this.
4497 if (flags
& BDRV_REQ_ZERO_WRITE
) {
4498 ret
= bdrv_co_truncate(bs
->file
, new_file_size
, false, prealloc
,
4499 BDRV_REQ_ZERO_WRITE
, NULL
);
4501 flags
&= ~BDRV_REQ_ZERO_WRITE
;
4502 /* Ensure that we read zeroes and not backing file data */
4503 subclusters_need_allocation
= true;
4509 ret
= bdrv_co_truncate(bs
->file
, new_file_size
, false, prealloc
, 0,
4513 error_prepend(errp
, "Failed to resize underlying file: ");
4514 qcow2_free_clusters(bs
, allocation_start
,
4515 nb_new_data_clusters
* s
->cluster_size
,
4516 QCOW2_DISCARD_OTHER
);
4520 /* Create the necessary L2 entries */
4521 host_offset
= allocation_start
;
4522 guest_offset
= old_length
;
4523 while (nb_new_data_clusters
) {
4524 int64_t nb_clusters
= MIN(
4525 nb_new_data_clusters
,
4526 s
->l2_slice_size
- offset_to_l2_slice_index(s
, guest_offset
));
4527 unsigned cow_start_length
= offset_into_cluster(s
, guest_offset
);
4528 QCowL2Meta allocation
;
4529 guest_offset
= start_of_cluster(s
, guest_offset
);
4530 allocation
= (QCowL2Meta
) {
4531 .offset
= guest_offset
,
4532 .alloc_offset
= host_offset
,
4533 .nb_clusters
= nb_clusters
,
4536 .nb_bytes
= cow_start_length
,
4539 .offset
= nb_clusters
<< s
->cluster_bits
,
4542 .prealloc
= !subclusters_need_allocation
,
4544 qemu_co_queue_init(&allocation
.dependent_requests
);
4546 ret
= qcow2_alloc_cluster_link_l2(bs
, &allocation
);
4548 error_setg_errno(errp
, -ret
, "Failed to update L2 tables");
4549 qcow2_free_clusters(bs
, host_offset
,
4550 nb_new_data_clusters
* s
->cluster_size
,
4551 QCOW2_DISCARD_OTHER
);
4555 guest_offset
+= nb_clusters
* s
->cluster_size
;
4556 host_offset
+= nb_clusters
* s
->cluster_size
;
4557 nb_new_data_clusters
-= nb_clusters
;
4563 g_assert_not_reached();
4566 if ((flags
& BDRV_REQ_ZERO_WRITE
) && offset
> old_length
) {
4567 uint64_t zero_start
= QEMU_ALIGN_UP(old_length
, s
->subcluster_size
);
4570 * Use zero clusters as much as we can. qcow2_subcluster_zeroize()
4571 * requires a subcluster-aligned start. The end may be unaligned if
4572 * it is at the end of the image (which it is here).
4574 if (offset
> zero_start
) {
4575 ret
= qcow2_subcluster_zeroize(bs
, zero_start
, offset
- zero_start
,
4578 error_setg_errno(errp
, -ret
, "Failed to zero out new clusters");
4583 /* Write explicit zeros for the unaligned head */
4584 if (zero_start
> old_length
) {
4585 uint64_t len
= MIN(zero_start
, offset
) - old_length
;
4586 uint8_t *buf
= qemu_blockalign0(bs
, len
);
4588 qemu_iovec_init_buf(&qiov
, buf
, len
);
4590 qemu_co_mutex_unlock(&s
->lock
);
4591 ret
= qcow2_co_pwritev_part(bs
, old_length
, len
, &qiov
, 0, 0);
4592 qemu_co_mutex_lock(&s
->lock
);
4596 error_setg_errno(errp
, -ret
, "Failed to zero out the new area");
4602 if (prealloc
!= PREALLOC_MODE_OFF
) {
4603 /* Flush metadata before actually changing the image size */
4604 ret
= qcow2_write_caches(bs
);
4606 error_setg_errno(errp
, -ret
,
4607 "Failed to flush the preallocated area to disk");
4612 bs
->total_sectors
= offset
/ BDRV_SECTOR_SIZE
;
4614 /* write updated header.size */
4615 offset
= cpu_to_be64(offset
);
4616 ret
= bdrv_co_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
4617 sizeof(offset
), &offset
, 0);
4619 error_setg_errno(errp
, -ret
, "Failed to update the image size");
4623 s
->l1_vm_state_index
= new_l1_size
;
4625 /* Update cache sizes */
4626 options
= qdict_clone_shallow(bs
->options
);
4627 ret
= qcow2_update_options(bs
, options
, s
->flags
, errp
);
4628 qobject_unref(options
);
4634 qemu_co_mutex_unlock(&s
->lock
);
4638 static int coroutine_fn GRAPH_RDLOCK
4639 qcow2_co_pwritev_compressed_task(BlockDriverState
*bs
,
4640 uint64_t offset
, uint64_t bytes
,
4641 QEMUIOVector
*qiov
, size_t qiov_offset
)
4643 BDRVQcow2State
*s
= bs
->opaque
;
4646 uint8_t *buf
, *out_buf
;
4647 uint64_t cluster_offset
;
4649 assert(bytes
== s
->cluster_size
|| (bytes
< s
->cluster_size
&&
4650 (offset
+ bytes
== bs
->total_sectors
<< BDRV_SECTOR_BITS
)));
4652 buf
= qemu_blockalign(bs
, s
->cluster_size
);
4653 if (bytes
< s
->cluster_size
) {
4654 /* Zero-pad last write if image size is not cluster aligned */
4655 memset(buf
+ bytes
, 0, s
->cluster_size
- bytes
);
4657 qemu_iovec_to_buf(qiov
, qiov_offset
, buf
, bytes
);
4659 out_buf
= g_malloc(s
->cluster_size
);
4661 out_len
= qcow2_co_compress(bs
, out_buf
, s
->cluster_size
- 1,
4662 buf
, s
->cluster_size
);
4663 if (out_len
== -ENOMEM
) {
4664 /* could not compress: write normal cluster */
4665 ret
= qcow2_co_pwritev_part(bs
, offset
, bytes
, qiov
, qiov_offset
, 0);
4670 } else if (out_len
< 0) {
4675 qemu_co_mutex_lock(&s
->lock
);
4676 ret
= qcow2_alloc_compressed_cluster_offset(bs
, offset
, out_len
,
4679 qemu_co_mutex_unlock(&s
->lock
);
4683 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
, true);
4684 qemu_co_mutex_unlock(&s
->lock
);
4689 BLKDBG_CO_EVENT(s
->data_file
, BLKDBG_WRITE_COMPRESSED
);
4690 ret
= bdrv_co_pwrite(s
->data_file
, cluster_offset
, out_len
, out_buf
, 0);
4703 * This function can count as GRAPH_RDLOCK because
4704 * qcow2_co_pwritev_compressed_part() holds the graph lock and keeps it until
4705 * this coroutine has terminated.
4707 static int coroutine_fn GRAPH_RDLOCK
4708 qcow2_co_pwritev_compressed_task_entry(AioTask
*task
)
4710 Qcow2AioTask
*t
= container_of(task
, Qcow2AioTask
, task
);
4712 assert(!t
->subcluster_type
&& !t
->l2meta
);
4714 return qcow2_co_pwritev_compressed_task(t
->bs
, t
->offset
, t
->bytes
, t
->qiov
,
4719 * XXX: put compressed sectors first, then all the cluster aligned
4720 * tables to avoid losing bytes in alignment
4722 static int coroutine_fn GRAPH_RDLOCK
4723 qcow2_co_pwritev_compressed_part(BlockDriverState
*bs
,
4724 int64_t offset
, int64_t bytes
,
4725 QEMUIOVector
*qiov
, size_t qiov_offset
)
4727 BDRVQcow2State
*s
= bs
->opaque
;
4728 AioTaskPool
*aio
= NULL
;
4731 if (has_data_file(bs
)) {
4737 * align end of file to a sector boundary to ease reading with
4740 int64_t len
= bdrv_co_getlength(bs
->file
->bs
);
4744 return bdrv_co_truncate(bs
->file
, len
, false, PREALLOC_MODE_OFF
, 0,
4748 if (offset_into_cluster(s
, offset
)) {
4752 if (offset_into_cluster(s
, bytes
) &&
4753 (offset
+ bytes
) != (bs
->total_sectors
<< BDRV_SECTOR_BITS
)) {
4757 while (bytes
&& aio_task_pool_status(aio
) == 0) {
4758 uint64_t chunk_size
= MIN(bytes
, s
->cluster_size
);
4760 if (!aio
&& chunk_size
!= bytes
) {
4761 aio
= aio_task_pool_new(QCOW2_MAX_WORKERS
);
4764 ret
= qcow2_add_task(bs
, aio
, qcow2_co_pwritev_compressed_task_entry
,
4765 0, 0, offset
, chunk_size
, qiov
, qiov_offset
, NULL
);
4769 qiov_offset
+= chunk_size
;
4770 offset
+= chunk_size
;
4771 bytes
-= chunk_size
;
4775 aio_task_pool_wait_all(aio
);
4777 ret
= aio_task_pool_status(aio
);
4785 static int coroutine_fn GRAPH_RDLOCK
4786 qcow2_co_preadv_compressed(BlockDriverState
*bs
,
4793 BDRVQcow2State
*s
= bs
->opaque
;
4796 uint8_t *buf
, *out_buf
;
4797 int offset_in_cluster
= offset_into_cluster(s
, offset
);
4799 qcow2_parse_compressed_l2_entry(bs
, l2_entry
, &coffset
, &csize
);
4801 buf
= g_try_malloc(csize
);
4806 out_buf
= qemu_blockalign(bs
, s
->cluster_size
);
4808 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_READ_COMPRESSED
);
4809 ret
= bdrv_co_pread(bs
->file
, coffset
, csize
, buf
, 0);
4814 if (qcow2_co_decompress(bs
, out_buf
, s
->cluster_size
, buf
, csize
) < 0) {
4819 qemu_iovec_from_buf(qiov
, qiov_offset
, out_buf
+ offset_in_cluster
, bytes
);
4822 qemu_vfree(out_buf
);
4828 static int make_completely_empty(BlockDriverState
*bs
)
4830 BDRVQcow2State
*s
= bs
->opaque
;
4831 Error
*local_err
= NULL
;
4832 int ret
, l1_clusters
;
4834 uint64_t *new_reftable
= NULL
;
4835 uint64_t rt_entry
, l1_size2
;
4838 uint64_t reftable_offset
;
4839 uint32_t reftable_clusters
;
4840 } QEMU_PACKED l1_ofs_rt_ofs_cls
;
4842 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
4847 ret
= qcow2_cache_empty(bs
, s
->refcount_block_cache
);
4852 /* Refcounts will be broken utterly */
4853 ret
= qcow2_mark_dirty(bs
);
4858 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
4860 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ L1E_SIZE
);
4861 l1_size2
= (uint64_t)s
->l1_size
* L1E_SIZE
;
4863 /* After this call, neither the in-memory nor the on-disk refcount
4864 * information accurately describe the actual references */
4866 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->l1_table_offset
,
4867 l1_clusters
* s
->cluster_size
, 0);
4869 goto fail_broken_refcounts
;
4871 memset(s
->l1_table
, 0, l1_size2
);
4873 BLKDBG_EVENT(bs
->file
, BLKDBG_EMPTY_IMAGE_PREPARE
);
4875 /* Overwrite enough clusters at the beginning of the sectors to place
4876 * the refcount table, a refcount block and the L1 table in; this may
4877 * overwrite parts of the existing refcount and L1 table, which is not
4878 * an issue because the dirty flag is set, complete data loss is in fact
4879 * desired and partial data loss is consequently fine as well */
4880 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->cluster_size
,
4881 (2 + l1_clusters
) * s
->cluster_size
, 0);
4882 /* This call (even if it failed overall) may have overwritten on-disk
4883 * refcount structures; in that case, the in-memory refcount information
4884 * will probably differ from the on-disk information which makes the BDS
4887 goto fail_broken_refcounts
;
4890 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
4891 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_UPDATE
);
4893 /* "Create" an empty reftable (one cluster) directly after the image
4894 * header and an empty L1 table three clusters after the image header;
4895 * the cluster between those two will be used as the first refblock */
4896 l1_ofs_rt_ofs_cls
.l1_offset
= cpu_to_be64(3 * s
->cluster_size
);
4897 l1_ofs_rt_ofs_cls
.reftable_offset
= cpu_to_be64(s
->cluster_size
);
4898 l1_ofs_rt_ofs_cls
.reftable_clusters
= cpu_to_be32(1);
4899 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, l1_table_offset
),
4900 sizeof(l1_ofs_rt_ofs_cls
), &l1_ofs_rt_ofs_cls
, 0);
4902 goto fail_broken_refcounts
;
4905 s
->l1_table_offset
= 3 * s
->cluster_size
;
4907 new_reftable
= g_try_new0(uint64_t, s
->cluster_size
/ REFTABLE_ENTRY_SIZE
);
4908 if (!new_reftable
) {
4910 goto fail_broken_refcounts
;
4913 s
->refcount_table_offset
= s
->cluster_size
;
4914 s
->refcount_table_size
= s
->cluster_size
/ REFTABLE_ENTRY_SIZE
;
4915 s
->max_refcount_table_index
= 0;
4917 g_free(s
->refcount_table
);
4918 s
->refcount_table
= new_reftable
;
4919 new_reftable
= NULL
;
4921 /* Now the in-memory refcount information again corresponds to the on-disk
4922 * information (reftable is empty and no refblocks (the refblock cache is
4923 * empty)); however, this means some clusters (e.g. the image header) are
4924 * referenced, but not refcounted, but the normal qcow2 code assumes that
4925 * the in-memory information is always correct */
4927 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
4929 /* Enter the first refblock into the reftable */
4930 rt_entry
= cpu_to_be64(2 * s
->cluster_size
);
4931 ret
= bdrv_pwrite_sync(bs
->file
, s
->cluster_size
, sizeof(rt_entry
),
4934 goto fail_broken_refcounts
;
4936 s
->refcount_table
[0] = 2 * s
->cluster_size
;
4938 s
->free_cluster_index
= 0;
4939 assert(3 + l1_clusters
<= s
->refcount_block_size
);
4940 offset
= qcow2_alloc_clusters(bs
, 3 * s
->cluster_size
+ l1_size2
);
4943 goto fail_broken_refcounts
;
4944 } else if (offset
> 0) {
4945 error_report("First cluster in emptied image is in use");
4949 /* Now finally the in-memory information corresponds to the on-disk
4950 * structures and is correct */
4951 ret
= qcow2_mark_clean(bs
);
4956 ret
= bdrv_truncate(bs
->file
, (3 + l1_clusters
) * s
->cluster_size
, false,
4957 PREALLOC_MODE_OFF
, 0, &local_err
);
4959 error_report_err(local_err
);
4965 fail_broken_refcounts
:
4966 /* The BDS is unusable at this point. If we wanted to make it usable, we
4967 * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
4968 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
4969 * again. However, because the functions which could have caused this error
4970 * path to be taken are used by those functions as well, it's very likely
4971 * that that sequence will fail as well. Therefore, just eject the BDS. */
4975 g_free(new_reftable
);
4979 static int qcow2_make_empty(BlockDriverState
*bs
)
4981 BDRVQcow2State
*s
= bs
->opaque
;
4982 uint64_t offset
, end_offset
;
4983 int step
= QEMU_ALIGN_DOWN(INT_MAX
, s
->cluster_size
);
4984 int l1_clusters
, ret
= 0;
4986 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ L1E_SIZE
);
4988 if (s
->qcow_version
>= 3 && !s
->snapshots
&& !s
->nb_bitmaps
&&
4989 3 + l1_clusters
<= s
->refcount_block_size
&&
4990 s
->crypt_method_header
!= QCOW_CRYPT_LUKS
&&
4991 !has_data_file(bs
)) {
4992 /* The following function only works for qcow2 v3 images (it
4993 * requires the dirty flag) and only as long as there are no
4994 * features that reserve extra clusters (such as snapshots,
4995 * LUKS header, or persistent bitmaps), because it completely
4996 * empties the image. Furthermore, the L1 table and three
4997 * additional clusters (image header, refcount table, one
4998 * refcount block) have to fit inside one refcount block. It
4999 * only resets the image file, i.e. does not work with an
5000 * external data file. */
5001 return make_completely_empty(bs
);
5004 /* This fallback code simply discards every active cluster; this is slow,
5005 * but works in all cases */
5006 end_offset
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
5007 for (offset
= 0; offset
< end_offset
; offset
+= step
) {
5008 /* As this function is generally used after committing an external
5009 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
5010 * default action for this kind of discard is to pass the discard,
5011 * which will ideally result in an actually smaller image file, as
5012 * is probably desired. */
5013 ret
= qcow2_cluster_discard(bs
, offset
, MIN(step
, end_offset
- offset
),
5014 QCOW2_DISCARD_SNAPSHOT
, true);
5023 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
5025 BDRVQcow2State
*s
= bs
->opaque
;
5028 qemu_co_mutex_lock(&s
->lock
);
5029 ret
= qcow2_write_caches(bs
);
5030 qemu_co_mutex_unlock(&s
->lock
);
5035 static BlockMeasureInfo
*qcow2_measure(QemuOpts
*opts
, BlockDriverState
*in_bs
,
5038 Error
*local_err
= NULL
;
5039 BlockMeasureInfo
*info
;
5040 uint64_t required
= 0; /* bytes that contribute to required size */
5041 uint64_t virtual_size
; /* disk size as seen by guest */
5042 uint64_t refcount_bits
;
5044 uint64_t luks_payload_size
= 0;
5045 size_t cluster_size
;
5048 PreallocMode prealloc
;
5049 bool has_backing_file
;
5054 /* Parse image creation options */
5055 extended_l2
= qemu_opt_get_bool_del(opts
, BLOCK_OPT_EXTL2
, false);
5057 cluster_size
= qcow2_opt_get_cluster_size_del(opts
, extended_l2
,
5063 version
= qcow2_opt_get_version_del(opts
, &local_err
);
5068 refcount_bits
= qcow2_opt_get_refcount_bits_del(opts
, version
, &local_err
);
5073 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
5074 prealloc
= qapi_enum_parse(&PreallocMode_lookup
, optstr
,
5075 PREALLOC_MODE_OFF
, &local_err
);
5081 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
5082 has_backing_file
= !!optstr
;
5085 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_ENCRYPT_FORMAT
);
5086 has_luks
= optstr
&& strcmp(optstr
, "luks") == 0;
5090 g_autoptr(QCryptoBlockCreateOptions
) create_opts
= NULL
;
5091 QDict
*cryptoopts
= qcow2_extract_crypto_opts(opts
, "luks", errp
);
5094 create_opts
= block_crypto_create_opts_init(cryptoopts
, errp
);
5095 qobject_unref(cryptoopts
);
5100 if (!qcrypto_block_calculate_payload_offset(create_opts
,
5107 luks_payload_size
= ROUND_UP(headerlen
, cluster_size
);
5110 virtual_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0);
5111 virtual_size
= ROUND_UP(virtual_size
, cluster_size
);
5113 /* Check that virtual disk size is valid */
5114 l2e_size
= extended_l2
? L2E_SIZE_EXTENDED
: L2E_SIZE_NORMAL
;
5115 l2_tables
= DIV_ROUND_UP(virtual_size
/ cluster_size
,
5116 cluster_size
/ l2e_size
);
5117 if (l2_tables
* L1E_SIZE
> QCOW_MAX_L1_SIZE
) {
5118 error_setg(&local_err
, "The image size is too large "
5119 "(try using a larger cluster size)");
5123 /* Account for input image */
5125 int64_t ssize
= bdrv_getlength(in_bs
);
5127 error_setg_errno(&local_err
, -ssize
,
5128 "Unable to get image virtual_size");
5132 virtual_size
= ROUND_UP(ssize
, cluster_size
);
5134 if (has_backing_file
) {
5135 /* We don't how much of the backing chain is shared by the input
5136 * image and the new image file. In the worst case the new image's
5137 * backing file has nothing in common with the input image. Be
5138 * conservative and assume all clusters need to be written.
5140 required
= virtual_size
;
5145 for (offset
= 0; offset
< ssize
; offset
+= pnum
) {
5148 ret
= bdrv_block_status_above(in_bs
, NULL
, offset
,
5149 ssize
- offset
, &pnum
, NULL
,
5152 error_setg_errno(&local_err
, -ret
,
5153 "Unable to get block status");
5157 if (ret
& BDRV_BLOCK_ZERO
) {
5158 /* Skip zero regions (safe with no backing file) */
5159 } else if ((ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) ==
5160 (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) {
5161 /* Extend pnum to end of cluster for next iteration */
5162 pnum
= ROUND_UP(offset
+ pnum
, cluster_size
) - offset
;
5164 /* Count clusters we've seen */
5165 required
+= offset
% cluster_size
+ pnum
;
5171 /* Take into account preallocation. Nothing special is needed for
5172 * PREALLOC_MODE_METADATA since metadata is always counted.
5174 if (prealloc
== PREALLOC_MODE_FULL
|| prealloc
== PREALLOC_MODE_FALLOC
) {
5175 required
= virtual_size
;
5178 info
= g_new0(BlockMeasureInfo
, 1);
5179 info
->fully_allocated
= luks_payload_size
+
5180 qcow2_calc_prealloc_size(virtual_size
, cluster_size
,
5181 ctz32(refcount_bits
), extended_l2
);
5184 * Remove data clusters that are not required. This overestimates the
5185 * required size because metadata needed for the fully allocated file is
5186 * still counted. Show bitmaps only if both source and destination
5187 * would support them.
5189 info
->required
= info
->fully_allocated
- virtual_size
+ required
;
5190 info
->has_bitmaps
= version
>= 3 && in_bs
&&
5191 bdrv_supports_persistent_dirty_bitmap(in_bs
);
5192 if (info
->has_bitmaps
) {
5193 info
->bitmaps
= qcow2_get_persistent_dirty_bitmap_size(in_bs
,
5199 error_propagate(errp
, local_err
);
5203 static int coroutine_fn
5204 qcow2_co_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
5206 BDRVQcow2State
*s
= bs
->opaque
;
5207 bdi
->cluster_size
= s
->cluster_size
;
5208 bdi
->subcluster_size
= s
->subcluster_size
;
5209 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
5210 bdi
->is_dirty
= s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
;
5214 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
,
5217 BDRVQcow2State
*s
= bs
->opaque
;
5218 ImageInfoSpecific
*spec_info
;
5219 QCryptoBlockInfo
*encrypt_info
= NULL
;
5221 if (s
->crypto
!= NULL
) {
5222 encrypt_info
= qcrypto_block_get_info(s
->crypto
, errp
);
5223 if (!encrypt_info
) {
5228 spec_info
= g_new(ImageInfoSpecific
, 1);
5229 *spec_info
= (ImageInfoSpecific
){
5230 .type
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
5231 .u
.qcow2
.data
= g_new0(ImageInfoSpecificQCow2
, 1),
5233 if (s
->qcow_version
== 2) {
5234 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
5235 .compat
= g_strdup("0.10"),
5236 .refcount_bits
= s
->refcount_bits
,
5238 } else if (s
->qcow_version
== 3) {
5239 Qcow2BitmapInfoList
*bitmaps
;
5240 if (!qcow2_get_bitmap_info_list(bs
, &bitmaps
, errp
)) {
5241 qapi_free_ImageInfoSpecific(spec_info
);
5242 qapi_free_QCryptoBlockInfo(encrypt_info
);
5245 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
5246 .compat
= g_strdup("1.1"),
5247 .lazy_refcounts
= s
->compatible_features
&
5248 QCOW2_COMPAT_LAZY_REFCOUNTS
,
5249 .has_lazy_refcounts
= true,
5250 .corrupt
= s
->incompatible_features
&
5251 QCOW2_INCOMPAT_CORRUPT
,
5252 .has_corrupt
= true,
5253 .has_extended_l2
= true,
5254 .extended_l2
= has_subclusters(s
),
5255 .refcount_bits
= s
->refcount_bits
,
5256 .has_bitmaps
= !!bitmaps
,
5258 .data_file
= g_strdup(s
->image_data_file
),
5259 .has_data_file_raw
= has_data_file(bs
),
5260 .data_file_raw
= data_file_is_raw(bs
),
5261 .compression_type
= s
->compression_type
,
5264 /* if this assertion fails, this probably means a new version was
5265 * added without having it covered here */
5270 ImageInfoSpecificQCow2Encryption
*qencrypt
=
5271 g_new(ImageInfoSpecificQCow2Encryption
, 1);
5272 switch (encrypt_info
->format
) {
5273 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
5274 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES
;
5276 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
5277 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS
;
5278 qencrypt
->u
.luks
= encrypt_info
->u
.luks
;
5283 /* Since we did shallow copy above, erase any pointers
5284 * in the original info */
5285 memset(&encrypt_info
->u
, 0, sizeof(encrypt_info
->u
));
5286 qapi_free_QCryptoBlockInfo(encrypt_info
);
5288 spec_info
->u
.qcow2
.data
->encrypt
= qencrypt
;
5294 static int coroutine_mixed_fn
qcow2_has_zero_init(BlockDriverState
*bs
)
5296 BDRVQcow2State
*s
= bs
->opaque
;
5299 if (qemu_in_coroutine()) {
5300 qemu_co_mutex_lock(&s
->lock
);
5303 * Check preallocation status: Preallocated images have all L2
5304 * tables allocated, nonpreallocated images have none. It is
5305 * therefore enough to check the first one.
5307 preallocated
= s
->l1_size
> 0 && s
->l1_table
[0] != 0;
5308 if (qemu_in_coroutine()) {
5309 qemu_co_mutex_unlock(&s
->lock
);
5312 if (!preallocated
) {
5314 } else if (bs
->encrypted
) {
5317 return bdrv_has_zero_init(s
->data_file
->bs
);
5322 * Check the request to vmstate. On success return
5323 * qcow2_vm_state_offset(bs) + @pos
5325 static int64_t qcow2_check_vmstate_request(BlockDriverState
*bs
,
5326 QEMUIOVector
*qiov
, int64_t pos
)
5328 BDRVQcow2State
*s
= bs
->opaque
;
5329 int64_t vmstate_offset
= qcow2_vm_state_offset(s
);
5332 /* Incoming requests must be OK */
5333 bdrv_check_qiov_request(pos
, qiov
->size
, qiov
, 0, &error_abort
);
5335 if (INT64_MAX
- pos
< vmstate_offset
) {
5339 pos
+= vmstate_offset
;
5340 ret
= bdrv_check_qiov_request(pos
, qiov
->size
, qiov
, 0, NULL
);
5348 static int coroutine_fn GRAPH_RDLOCK
5349 qcow2_co_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
5351 int64_t offset
= qcow2_check_vmstate_request(bs
, qiov
, pos
);
5356 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
5357 return bs
->drv
->bdrv_co_pwritev_part(bs
, offset
, qiov
->size
, qiov
, 0, 0);
5360 static int coroutine_fn GRAPH_RDLOCK
5361 qcow2_co_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
5363 int64_t offset
= qcow2_check_vmstate_request(bs
, qiov
, pos
);
5368 BLKDBG_CO_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
5369 return bs
->drv
->bdrv_co_preadv_part(bs
, offset
, qiov
->size
, qiov
, 0, 0);
5372 static int qcow2_has_compressed_clusters(BlockDriverState
*bs
)
5375 int64_t bytes
= bdrv_getlength(bs
);
5381 while (bytes
!= 0) {
5383 QCow2SubclusterType type
;
5384 unsigned int cur_bytes
= MIN(INT_MAX
, bytes
);
5385 uint64_t host_offset
;
5387 ret
= qcow2_get_host_offset(bs
, offset
, &cur_bytes
, &host_offset
,
5393 if (type
== QCOW2_SUBCLUSTER_COMPRESSED
) {
5397 offset
+= cur_bytes
;
5405 * Downgrades an image's version. To achieve this, any incompatible features
5406 * have to be removed.
5408 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
,
5409 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
,
5412 BDRVQcow2State
*s
= bs
->opaque
;
5413 int current_version
= s
->qcow_version
;
5417 /* This is qcow2_downgrade(), not qcow2_upgrade() */
5418 assert(target_version
< current_version
);
5420 /* There are no other versions (now) that you can downgrade to */
5421 assert(target_version
== 2);
5423 if (s
->refcount_order
!= 4) {
5424 error_setg(errp
, "compat=0.10 requires refcount_bits=16");
5428 if (has_data_file(bs
)) {
5429 error_setg(errp
, "Cannot downgrade an image with a data file");
5434 * If any internal snapshot has a different size than the current
5435 * image size, or VM state size that exceeds 32 bits, downgrading
5436 * is unsafe. Even though we would still use v3-compliant output
5437 * to preserve that data, other v2 programs might not realize
5438 * those optional fields are important.
5440 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
5441 if (s
->snapshots
[i
].vm_state_size
> UINT32_MAX
||
5442 s
->snapshots
[i
].disk_size
!= bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
5443 error_setg(errp
, "Internal snapshots prevent downgrade of image");
5448 /* clear incompatible features */
5449 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
5450 ret
= qcow2_mark_clean(bs
);
5452 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
5457 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
5458 * the first place; if that happens nonetheless, returning -ENOTSUP is the
5459 * best thing to do anyway */
5461 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_COMPRESSION
) {
5462 error_setg(errp
, "Cannot downgrade an image with incompatible features "
5463 "0x%" PRIx64
" set",
5464 s
->incompatible_features
& ~QCOW2_INCOMPAT_COMPRESSION
);
5468 /* since we can ignore compatible features, we can set them to 0 as well */
5469 s
->compatible_features
= 0;
5470 /* if lazy refcounts have been used, they have already been fixed through
5471 * clearing the dirty flag */
5473 /* clearing autoclear features is trivial */
5474 s
->autoclear_features
= 0;
5476 ret
= qcow2_expand_zero_clusters(bs
, status_cb
, cb_opaque
);
5478 error_setg_errno(errp
, -ret
, "Failed to turn zero into data clusters");
5482 if (s
->incompatible_features
& QCOW2_INCOMPAT_COMPRESSION
) {
5483 ret
= qcow2_has_compressed_clusters(bs
);
5485 error_setg(errp
, "Failed to check block status");
5489 error_setg(errp
, "Cannot downgrade an image with zstd compression "
5490 "type and existing compressed clusters");
5494 * No compressed clusters for now, so just chose default zlib
5497 s
->incompatible_features
&= ~QCOW2_INCOMPAT_COMPRESSION
;
5498 s
->compression_type
= QCOW2_COMPRESSION_TYPE_ZLIB
;
5501 assert(s
->incompatible_features
== 0);
5503 s
->qcow_version
= target_version
;
5504 ret
= qcow2_update_header(bs
);
5506 s
->qcow_version
= current_version
;
5507 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5514 * Upgrades an image's version. While newer versions encompass all
5515 * features of older versions, some things may have to be presented
5518 static int qcow2_upgrade(BlockDriverState
*bs
, int target_version
,
5519 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
,
5522 BDRVQcow2State
*s
= bs
->opaque
;
5523 bool need_snapshot_update
;
5524 int current_version
= s
->qcow_version
;
5528 /* This is qcow2_upgrade(), not qcow2_downgrade() */
5529 assert(target_version
> current_version
);
5531 /* There are no other versions (yet) that you can upgrade to */
5532 assert(target_version
== 3);
5534 status_cb(bs
, 0, 2, cb_opaque
);
5537 * In v2, snapshots do not need to have extra data. v3 requires
5538 * the 64-bit VM state size and the virtual disk size to be
5540 * qcow2_write_snapshots() will always write the list in the
5541 * v3-compliant format.
5543 need_snapshot_update
= false;
5544 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
5545 if (s
->snapshots
[i
].extra_data_size
<
5546 sizeof_field(QCowSnapshotExtraData
, vm_state_size_large
) +
5547 sizeof_field(QCowSnapshotExtraData
, disk_size
))
5549 need_snapshot_update
= true;
5553 if (need_snapshot_update
) {
5554 ret
= qcow2_write_snapshots(bs
);
5556 error_setg_errno(errp
, -ret
, "Failed to update the snapshot table");
5560 status_cb(bs
, 1, 2, cb_opaque
);
5562 s
->qcow_version
= target_version
;
5563 ret
= qcow2_update_header(bs
);
5565 s
->qcow_version
= current_version
;
5566 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5569 status_cb(bs
, 2, 2, cb_opaque
);
5574 typedef enum Qcow2AmendOperation
{
5575 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
5576 * statically initialized to so that the helper CB can discern the first
5577 * invocation from an operation change */
5578 QCOW2_NO_OPERATION
= 0,
5581 QCOW2_UPDATING_ENCRYPTION
,
5582 QCOW2_CHANGING_REFCOUNT_ORDER
,
5584 } Qcow2AmendOperation
;
5586 typedef struct Qcow2AmendHelperCBInfo
{
5587 /* The code coordinating the amend operations should only modify
5588 * these four fields; the rest will be managed by the CB */
5589 BlockDriverAmendStatusCB
*original_status_cb
;
5590 void *original_cb_opaque
;
5592 Qcow2AmendOperation current_operation
;
5594 /* Total number of operations to perform (only set once) */
5595 int total_operations
;
5597 /* The following fields are managed by the CB */
5599 /* Number of operations completed */
5600 int operations_completed
;
5602 /* Cumulative offset of all completed operations */
5603 int64_t offset_completed
;
5605 Qcow2AmendOperation last_operation
;
5606 int64_t last_work_size
;
5607 } Qcow2AmendHelperCBInfo
;
5609 static void qcow2_amend_helper_cb(BlockDriverState
*bs
,
5610 int64_t operation_offset
,
5611 int64_t operation_work_size
, void *opaque
)
5613 Qcow2AmendHelperCBInfo
*info
= opaque
;
5614 int64_t current_work_size
;
5615 int64_t projected_work_size
;
5617 if (info
->current_operation
!= info
->last_operation
) {
5618 if (info
->last_operation
!= QCOW2_NO_OPERATION
) {
5619 info
->offset_completed
+= info
->last_work_size
;
5620 info
->operations_completed
++;
5623 info
->last_operation
= info
->current_operation
;
5626 assert(info
->total_operations
> 0);
5627 assert(info
->operations_completed
< info
->total_operations
);
5629 info
->last_work_size
= operation_work_size
;
5631 current_work_size
= info
->offset_completed
+ operation_work_size
;
5633 /* current_work_size is the total work size for (operations_completed + 1)
5634 * operations (which includes this one), so multiply it by the number of
5635 * operations not covered and divide it by the number of operations
5636 * covered to get a projection for the operations not covered */
5637 projected_work_size
= current_work_size
* (info
->total_operations
-
5638 info
->operations_completed
- 1)
5639 / (info
->operations_completed
+ 1);
5641 info
->original_status_cb(bs
, info
->offset_completed
+ operation_offset
,
5642 current_work_size
+ projected_work_size
,
5643 info
->original_cb_opaque
);
5646 static int qcow2_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
5647 BlockDriverAmendStatusCB
*status_cb
,
5652 BDRVQcow2State
*s
= bs
->opaque
;
5653 int old_version
= s
->qcow_version
, new_version
= old_version
;
5654 uint64_t new_size
= 0;
5655 const char *backing_file
= NULL
, *backing_format
= NULL
, *data_file
= NULL
;
5656 bool lazy_refcounts
= s
->use_lazy_refcounts
;
5657 bool data_file_raw
= data_file_is_raw(bs
);
5658 const char *compat
= NULL
;
5659 int refcount_bits
= s
->refcount_bits
;
5661 QemuOptDesc
*desc
= opts
->list
->desc
;
5662 Qcow2AmendHelperCBInfo helper_cb_info
;
5663 bool encryption_update
= false;
5665 while (desc
&& desc
->name
) {
5666 if (!qemu_opt_find(opts
, desc
->name
)) {
5667 /* only change explicitly defined options */
5672 if (!strcmp(desc
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
5673 compat
= qemu_opt_get(opts
, BLOCK_OPT_COMPAT_LEVEL
);
5675 /* preserve default */
5676 } else if (!strcmp(compat
, "0.10") || !strcmp(compat
, "v2")) {
5678 } else if (!strcmp(compat
, "1.1") || !strcmp(compat
, "v3")) {
5681 error_setg(errp
, "Unknown compatibility level %s", compat
);
5684 } else if (!strcmp(desc
->name
, BLOCK_OPT_SIZE
)) {
5685 new_size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
5686 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FILE
)) {
5687 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
5688 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FMT
)) {
5689 backing_format
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
5690 } else if (g_str_has_prefix(desc
->name
, "encrypt.")) {
5693 "Can't amend encryption options - encryption not present");
5696 if (s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
5698 "Only LUKS encryption options can be amended");
5701 encryption_update
= true;
5702 } else if (!strcmp(desc
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
5703 lazy_refcounts
= qemu_opt_get_bool(opts
, BLOCK_OPT_LAZY_REFCOUNTS
,
5705 } else if (!strcmp(desc
->name
, BLOCK_OPT_REFCOUNT_BITS
)) {
5706 refcount_bits
= qemu_opt_get_number(opts
, BLOCK_OPT_REFCOUNT_BITS
,
5709 if (refcount_bits
<= 0 || refcount_bits
> 64 ||
5710 !is_power_of_2(refcount_bits
))
5712 error_setg(errp
, "Refcount width must be a power of two and "
5713 "may not exceed 64 bits");
5716 } else if (!strcmp(desc
->name
, BLOCK_OPT_DATA_FILE
)) {
5717 data_file
= qemu_opt_get(opts
, BLOCK_OPT_DATA_FILE
);
5718 if (data_file
&& !has_data_file(bs
)) {
5719 error_setg(errp
, "data-file can only be set for images that "
5720 "use an external data file");
5723 } else if (!strcmp(desc
->name
, BLOCK_OPT_DATA_FILE_RAW
)) {
5724 data_file_raw
= qemu_opt_get_bool(opts
, BLOCK_OPT_DATA_FILE_RAW
,
5726 if (data_file_raw
&& !data_file_is_raw(bs
)) {
5727 error_setg(errp
, "data-file-raw cannot be set on existing "
5732 /* if this point is reached, this probably means a new option was
5733 * added without having it covered here */
5740 helper_cb_info
= (Qcow2AmendHelperCBInfo
){
5741 .original_status_cb
= status_cb
,
5742 .original_cb_opaque
= cb_opaque
,
5743 .total_operations
= (new_version
!= old_version
)
5744 + (s
->refcount_bits
!= refcount_bits
) +
5745 (encryption_update
== true)
5748 /* Upgrade first (some features may require compat=1.1) */
5749 if (new_version
> old_version
) {
5750 helper_cb_info
.current_operation
= QCOW2_UPGRADING
;
5751 ret
= qcow2_upgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
5752 &helper_cb_info
, errp
);
5758 if (encryption_update
) {
5759 QDict
*amend_opts_dict
;
5760 QCryptoBlockAmendOptions
*amend_opts
;
5762 helper_cb_info
.current_operation
= QCOW2_UPDATING_ENCRYPTION
;
5763 amend_opts_dict
= qcow2_extract_crypto_opts(opts
, "luks", errp
);
5764 if (!amend_opts_dict
) {
5767 amend_opts
= block_crypto_amend_opts_init(amend_opts_dict
, errp
);
5768 qobject_unref(amend_opts_dict
);
5772 ret
= qcrypto_block_amend_options(s
->crypto
,
5773 qcow2_crypto_hdr_read_func
,
5774 qcow2_crypto_hdr_write_func
,
5779 qapi_free_QCryptoBlockAmendOptions(amend_opts
);
5785 if (s
->refcount_bits
!= refcount_bits
) {
5786 int refcount_order
= ctz32(refcount_bits
);
5788 if (new_version
< 3 && refcount_bits
!= 16) {
5789 error_setg(errp
, "Refcount widths other than 16 bits require "
5790 "compatibility level 1.1 or above (use compat=1.1 or "
5795 helper_cb_info
.current_operation
= QCOW2_CHANGING_REFCOUNT_ORDER
;
5796 ret
= qcow2_change_refcount_order(bs
, refcount_order
,
5797 &qcow2_amend_helper_cb
,
5798 &helper_cb_info
, errp
);
5804 /* data-file-raw blocks backing files, so clear it first if requested */
5805 if (data_file_raw
) {
5806 s
->autoclear_features
|= QCOW2_AUTOCLEAR_DATA_FILE_RAW
;
5808 s
->autoclear_features
&= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW
;
5812 g_free(s
->image_data_file
);
5813 s
->image_data_file
= *data_file
? g_strdup(data_file
) : NULL
;
5816 ret
= qcow2_update_header(bs
);
5818 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5822 if (backing_file
|| backing_format
) {
5823 if (g_strcmp0(backing_file
, s
->image_backing_file
) ||
5824 g_strcmp0(backing_format
, s
->image_backing_format
)) {
5825 error_setg(errp
, "Cannot amend the backing file");
5826 error_append_hint(errp
,
5827 "You can use 'qemu-img rebase' instead.\n");
5832 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
5833 if (lazy_refcounts
) {
5834 if (new_version
< 3) {
5835 error_setg(errp
, "Lazy refcounts only supported with "
5836 "compatibility level 1.1 and above (use compat=1.1 "
5840 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
5841 ret
= qcow2_update_header(bs
);
5843 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
5844 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5847 s
->use_lazy_refcounts
= true;
5849 /* make image clean first */
5850 ret
= qcow2_mark_clean(bs
);
5852 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
5855 /* now disallow lazy refcounts */
5856 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
5857 ret
= qcow2_update_header(bs
);
5859 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
5860 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5863 s
->use_lazy_refcounts
= false;
5868 BlockBackend
*blk
= blk_new_with_bs(bs
, BLK_PERM_RESIZE
, BLK_PERM_ALL
,
5875 * Amending image options should ensure that the image has
5876 * exactly the given new values, so pass exact=true here.
5878 ret
= blk_truncate(blk
, new_size
, true, PREALLOC_MODE_OFF
, 0, errp
);
5885 /* Downgrade last (so unsupported features can be removed before) */
5886 if (new_version
< old_version
) {
5887 helper_cb_info
.current_operation
= QCOW2_DOWNGRADING
;
5888 ret
= qcow2_downgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
5889 &helper_cb_info
, errp
);
5898 static int coroutine_fn
qcow2_co_amend(BlockDriverState
*bs
,
5899 BlockdevAmendOptions
*opts
,
5903 BlockdevAmendOptionsQcow2
*qopts
= &opts
->u
.qcow2
;
5904 BDRVQcow2State
*s
= bs
->opaque
;
5907 if (qopts
->encrypt
) {
5909 error_setg(errp
, "image is not encrypted, can't amend");
5913 if (qopts
->encrypt
->format
!= Q_CRYPTO_BLOCK_FORMAT_LUKS
) {
5915 "Amend can't be used to change the qcow2 encryption format");
5919 if (s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
5921 "Only LUKS encryption options can be amended for qcow2 with blockdev-amend");
5925 ret
= qcrypto_block_amend_options(s
->crypto
,
5926 qcow2_crypto_hdr_read_func
,
5927 qcow2_crypto_hdr_write_func
,
5937 * If offset or size are negative, respectively, they will not be included in
5938 * the BLOCK_IMAGE_CORRUPTED event emitted.
5939 * fatal will be ignored for read-only BDS; corruptions found there will always
5940 * be considered non-fatal.
5942 void qcow2_signal_corruption(BlockDriverState
*bs
, bool fatal
, int64_t offset
,
5943 int64_t size
, const char *message_format
, ...)
5945 BDRVQcow2State
*s
= bs
->opaque
;
5946 const char *node_name
;
5950 assume_graph_lock(); /* FIXME */
5952 fatal
= fatal
&& bdrv_is_writable(bs
);
5954 if (s
->signaled_corruption
&&
5955 (!fatal
|| (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
)))
5960 va_start(ap
, message_format
);
5961 message
= g_strdup_vprintf(message_format
, ap
);
5965 fprintf(stderr
, "qcow2: Marking image as corrupt: %s; further "
5966 "corruption events will be suppressed\n", message
);
5968 fprintf(stderr
, "qcow2: Image is corrupt: %s; further non-fatal "
5969 "corruption events will be suppressed\n", message
);
5972 node_name
= bdrv_get_node_name(bs
);
5973 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs
),
5974 *node_name
? node_name
: NULL
,
5975 message
, offset
>= 0, offset
,
5981 qcow2_mark_corrupt(bs
);
5982 bs
->drv
= NULL
; /* make BDS unusable */
5985 s
->signaled_corruption
= true;
5988 #define QCOW_COMMON_OPTIONS \
5990 .name = BLOCK_OPT_SIZE, \
5991 .type = QEMU_OPT_SIZE, \
5992 .help = "Virtual disk size" \
5995 .name = BLOCK_OPT_COMPAT_LEVEL, \
5996 .type = QEMU_OPT_STRING, \
5997 .help = "Compatibility level (v2 [0.10] or v3 [1.1])" \
6000 .name = BLOCK_OPT_BACKING_FILE, \
6001 .type = QEMU_OPT_STRING, \
6002 .help = "File name of a base image" \
6005 .name = BLOCK_OPT_BACKING_FMT, \
6006 .type = QEMU_OPT_STRING, \
6007 .help = "Image format of the base image" \
6010 .name = BLOCK_OPT_DATA_FILE, \
6011 .type = QEMU_OPT_STRING, \
6012 .help = "File name of an external data file" \
6015 .name = BLOCK_OPT_DATA_FILE_RAW, \
6016 .type = QEMU_OPT_BOOL, \
6017 .help = "The external data file must stay valid " \
6021 .name = BLOCK_OPT_LAZY_REFCOUNTS, \
6022 .type = QEMU_OPT_BOOL, \
6023 .help = "Postpone refcount updates", \
6024 .def_value_str = "off" \
6027 .name = BLOCK_OPT_REFCOUNT_BITS, \
6028 .type = QEMU_OPT_NUMBER, \
6029 .help = "Width of a reference count entry in bits", \
6030 .def_value_str = "16" \
6033 static QemuOptsList qcow2_create_opts
= {
6034 .name
= "qcow2-create-opts",
6035 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_create_opts
.head
),
6038 .name
= BLOCK_OPT_ENCRYPT
, \
6039 .type
= QEMU_OPT_BOOL
, \
6040 .help
= "Encrypt the image with format 'aes'. (Deprecated " \
6041 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT
"=aes)", \
6044 .name
= BLOCK_OPT_ENCRYPT_FORMAT
, \
6045 .type
= QEMU_OPT_STRING
, \
6046 .help
= "Encrypt the image, format choices: 'aes', 'luks'", \
6048 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", \
6049 "ID of secret providing qcow AES key or LUKS passphrase"), \
6050 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."), \
6051 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."), \
6052 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."), \
6053 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."), \
6054 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."), \
6055 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."), \
6057 .name
= BLOCK_OPT_CLUSTER_SIZE
, \
6058 .type
= QEMU_OPT_SIZE
, \
6059 .help
= "qcow2 cluster size", \
6060 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
) \
6063 .name
= BLOCK_OPT_EXTL2
, \
6064 .type
= QEMU_OPT_BOOL
, \
6065 .help
= "Extended L2 tables", \
6066 .def_value_str
= "off" \
6069 .name
= BLOCK_OPT_PREALLOC
, \
6070 .type
= QEMU_OPT_STRING
, \
6071 .help
= "Preallocation mode (allowed values: off, " \
6072 "metadata, falloc, full)" \
6075 .name
= BLOCK_OPT_COMPRESSION_TYPE
, \
6076 .type
= QEMU_OPT_STRING
, \
6077 .help
= "Compression method used for image cluster " \
6079 .def_value_str
= "zlib" \
6081 QCOW_COMMON_OPTIONS
,
6082 { /* end of list */ }
6086 static QemuOptsList qcow2_amend_opts
= {
6087 .name
= "qcow2-amend-opts",
6088 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_amend_opts
.head
),
6090 BLOCK_CRYPTO_OPT_DEF_LUKS_STATE("encrypt."),
6091 BLOCK_CRYPTO_OPT_DEF_LUKS_KEYSLOT("encrypt."),
6092 BLOCK_CRYPTO_OPT_DEF_LUKS_OLD_SECRET("encrypt."),
6093 BLOCK_CRYPTO_OPT_DEF_LUKS_NEW_SECRET("encrypt."),
6094 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
6095 QCOW_COMMON_OPTIONS
,
6096 { /* end of list */ }
6100 static const char *const qcow2_strong_runtime_opts
[] = {
6101 "encrypt." BLOCK_CRYPTO_OPT_QCOW_KEY_SECRET
,
6106 BlockDriver bdrv_qcow2
= {
6107 .format_name
= "qcow2",
6108 .instance_size
= sizeof(BDRVQcow2State
),
6109 .bdrv_probe
= qcow2_probe
,
6110 .bdrv_open
= qcow2_open
,
6111 .bdrv_close
= qcow2_close
,
6112 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
6113 .bdrv_reopen_commit
= qcow2_reopen_commit
,
6114 .bdrv_reopen_commit_post
= qcow2_reopen_commit_post
,
6115 .bdrv_reopen_abort
= qcow2_reopen_abort
,
6116 .bdrv_join_options
= qcow2_join_options
,
6117 .bdrv_child_perm
= bdrv_default_perms
,
6118 .bdrv_co_create_opts
= qcow2_co_create_opts
,
6119 .bdrv_co_create
= qcow2_co_create
,
6120 .bdrv_has_zero_init
= qcow2_has_zero_init
,
6121 .bdrv_co_block_status
= qcow2_co_block_status
,
6123 .bdrv_co_preadv_part
= qcow2_co_preadv_part
,
6124 .bdrv_co_pwritev_part
= qcow2_co_pwritev_part
,
6125 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
6127 .bdrv_co_pwrite_zeroes
= qcow2_co_pwrite_zeroes
,
6128 .bdrv_co_pdiscard
= qcow2_co_pdiscard
,
6129 .bdrv_co_copy_range_from
= qcow2_co_copy_range_from
,
6130 .bdrv_co_copy_range_to
= qcow2_co_copy_range_to
,
6131 .bdrv_co_truncate
= qcow2_co_truncate
,
6132 .bdrv_co_pwritev_compressed_part
= qcow2_co_pwritev_compressed_part
,
6133 .bdrv_make_empty
= qcow2_make_empty
,
6135 .bdrv_snapshot_create
= qcow2_snapshot_create
,
6136 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
6137 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
6138 .bdrv_snapshot_list
= qcow2_snapshot_list
,
6139 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
6140 .bdrv_measure
= qcow2_measure
,
6141 .bdrv_co_get_info
= qcow2_co_get_info
,
6142 .bdrv_get_specific_info
= qcow2_get_specific_info
,
6144 .bdrv_co_save_vmstate
= qcow2_co_save_vmstate
,
6145 .bdrv_co_load_vmstate
= qcow2_co_load_vmstate
,
6148 .supports_backing
= true,
6149 .bdrv_change_backing_file
= qcow2_change_backing_file
,
6151 .bdrv_refresh_limits
= qcow2_refresh_limits
,
6152 .bdrv_co_invalidate_cache
= qcow2_co_invalidate_cache
,
6153 .bdrv_inactivate
= qcow2_inactivate
,
6155 .create_opts
= &qcow2_create_opts
,
6156 .amend_opts
= &qcow2_amend_opts
,
6157 .strong_runtime_opts
= qcow2_strong_runtime_opts
,
6158 .mutable_opts
= mutable_opts
,
6159 .bdrv_co_check
= qcow2_co_check
,
6160 .bdrv_amend_options
= qcow2_amend_options
,
6161 .bdrv_co_amend
= qcow2_co_amend
,
6163 .bdrv_detach_aio_context
= qcow2_detach_aio_context
,
6164 .bdrv_attach_aio_context
= qcow2_attach_aio_context
,
6166 .bdrv_supports_persistent_dirty_bitmap
=
6167 qcow2_supports_persistent_dirty_bitmap
,
6168 .bdrv_co_can_store_new_dirty_bitmap
= qcow2_co_can_store_new_dirty_bitmap
,
6169 .bdrv_co_remove_persistent_dirty_bitmap
=
6170 qcow2_co_remove_persistent_dirty_bitmap
,
6173 static void bdrv_qcow2_init(void)
6175 bdrv_register(&bdrv_qcow2
);
6178 block_init(bdrv_qcow2_init
);