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"
30 #include "block/block_int.h"
31 #include "block/qdict.h"
32 #include "sysemu/block-backend.h"
33 #include "qemu/module.h"
35 #include "qemu/error-report.h"
36 #include "qapi/error.h"
37 #include "qapi/qapi-events-block-core.h"
38 #include "qapi/qmp/qdict.h"
39 #include "qapi/qmp/qstring.h"
41 #include "qemu/option_int.h"
42 #include "qemu/cutils.h"
43 #include "qemu/bswap.h"
44 #include "qapi/qobject-input-visitor.h"
45 #include "qapi/qapi-visit-block-core.h"
47 #include "block/thread-pool.h"
50 Differences with QCOW:
52 - Support for multiple incremental snapshots.
53 - Memory management by reference counts.
54 - Clusters which have a reference count of one have the bit
55 QCOW_OFLAG_COPIED to optimize write performance.
56 - Size of compressed clusters is stored in sectors to reduce bit usage
57 in the cluster offsets.
58 - Support for storing additional data (such as the VM state) in the
60 - If a backing store is used, the cluster size is not constrained
61 (could be backported to QCOW).
62 - L2 tables have always a size of one cluster.
69 } QEMU_PACKED QCowExtension
;
71 #define QCOW2_EXT_MAGIC_END 0
72 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
73 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
74 #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
75 #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875
77 static int coroutine_fn
78 qcow2_co_preadv_compressed(BlockDriverState
*bs
,
79 uint64_t file_cluster_offset
,
84 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
86 const QCowHeader
*cow_header
= (const void *)buf
;
88 if (buf_size
>= sizeof(QCowHeader
) &&
89 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
90 be32_to_cpu(cow_header
->version
) >= 2)
97 static ssize_t
qcow2_crypto_hdr_read_func(QCryptoBlock
*block
, size_t offset
,
98 uint8_t *buf
, size_t buflen
,
99 void *opaque
, Error
**errp
)
101 BlockDriverState
*bs
= opaque
;
102 BDRVQcow2State
*s
= bs
->opaque
;
105 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
106 error_setg(errp
, "Request for data outside of extension header");
110 ret
= bdrv_pread(bs
->file
,
111 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
113 error_setg_errno(errp
, -ret
, "Could not read encryption header");
120 static ssize_t
qcow2_crypto_hdr_init_func(QCryptoBlock
*block
, size_t headerlen
,
121 void *opaque
, Error
**errp
)
123 BlockDriverState
*bs
= opaque
;
124 BDRVQcow2State
*s
= bs
->opaque
;
128 ret
= qcow2_alloc_clusters(bs
, headerlen
);
130 error_setg_errno(errp
, -ret
,
131 "Cannot allocate cluster for LUKS header size %zu",
136 s
->crypto_header
.length
= headerlen
;
137 s
->crypto_header
.offset
= ret
;
139 /* Zero fill remaining space in cluster so it has predictable
140 * content in case of future spec changes */
141 clusterlen
= size_to_clusters(s
, headerlen
) * s
->cluster_size
;
142 assert(qcow2_pre_write_overlap_check(bs
, 0, ret
, clusterlen
) == 0);
143 ret
= bdrv_pwrite_zeroes(bs
->file
,
145 clusterlen
- headerlen
, 0);
147 error_setg_errno(errp
, -ret
, "Could not zero fill encryption header");
155 static ssize_t
qcow2_crypto_hdr_write_func(QCryptoBlock
*block
, size_t offset
,
156 const uint8_t *buf
, size_t buflen
,
157 void *opaque
, Error
**errp
)
159 BlockDriverState
*bs
= opaque
;
160 BDRVQcow2State
*s
= bs
->opaque
;
163 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
164 error_setg(errp
, "Request for data outside of extension header");
168 ret
= bdrv_pwrite(bs
->file
,
169 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
171 error_setg_errno(errp
, -ret
, "Could not read encryption header");
179 * read qcow2 extension and fill bs
180 * start reading from start_offset
181 * finish reading upon magic of value 0 or when end_offset reached
182 * unknown magic is skipped (future extension this version knows nothing about)
183 * return 0 upon success, non-0 otherwise
185 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
186 uint64_t end_offset
, void **p_feature_table
,
187 int flags
, bool *need_update_header
,
190 BDRVQcow2State
*s
= bs
->opaque
;
194 Qcow2BitmapHeaderExt bitmaps_ext
;
196 if (need_update_header
!= NULL
) {
197 *need_update_header
= false;
201 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
203 offset
= start_offset
;
204 while (offset
< end_offset
) {
208 if (offset
> s
->cluster_size
)
209 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
211 printf("attempting to read extended header in offset %lu\n", offset
);
214 ret
= bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
));
216 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
217 "pread fail from offset %" PRIu64
, offset
);
220 ext
.magic
= be32_to_cpu(ext
.magic
);
221 ext
.len
= be32_to_cpu(ext
.len
);
222 offset
+= sizeof(ext
);
224 printf("ext.magic = 0x%x\n", ext
.magic
);
226 if (offset
> end_offset
|| ext
.len
> end_offset
- offset
) {
227 error_setg(errp
, "Header extension too large");
232 case QCOW2_EXT_MAGIC_END
:
235 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
236 if (ext
.len
>= sizeof(bs
->backing_format
)) {
237 error_setg(errp
, "ERROR: ext_backing_format: len=%" PRIu32
238 " too large (>=%zu)", ext
.len
,
239 sizeof(bs
->backing_format
));
242 ret
= bdrv_pread(bs
->file
, offset
, bs
->backing_format
, ext
.len
);
244 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
245 "Could not read format name");
248 bs
->backing_format
[ext
.len
] = '\0';
249 s
->image_backing_format
= g_strdup(bs
->backing_format
);
251 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
255 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
256 if (p_feature_table
!= NULL
) {
257 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
258 ret
= bdrv_pread(bs
->file
, offset
, feature_table
, ext
.len
);
260 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
261 "Could not read table");
265 *p_feature_table
= feature_table
;
269 case QCOW2_EXT_MAGIC_CRYPTO_HEADER
: {
270 unsigned int cflags
= 0;
271 if (s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
272 error_setg(errp
, "CRYPTO header extension only "
273 "expected with LUKS encryption method");
276 if (ext
.len
!= sizeof(Qcow2CryptoHeaderExtension
)) {
277 error_setg(errp
, "CRYPTO header extension size %u, "
278 "but expected size %zu", ext
.len
,
279 sizeof(Qcow2CryptoHeaderExtension
));
283 ret
= bdrv_pread(bs
->file
, offset
, &s
->crypto_header
, ext
.len
);
285 error_setg_errno(errp
, -ret
,
286 "Unable to read CRYPTO header extension");
289 s
->crypto_header
.offset
= be64_to_cpu(s
->crypto_header
.offset
);
290 s
->crypto_header
.length
= be64_to_cpu(s
->crypto_header
.length
);
292 if ((s
->crypto_header
.offset
% s
->cluster_size
) != 0) {
293 error_setg(errp
, "Encryption header offset '%" PRIu64
"' is "
294 "not a multiple of cluster size '%u'",
295 s
->crypto_header
.offset
, s
->cluster_size
);
299 if (flags
& BDRV_O_NO_IO
) {
300 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
302 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
303 qcow2_crypto_hdr_read_func
,
304 bs
, cflags
, 1, errp
);
310 case QCOW2_EXT_MAGIC_BITMAPS
:
311 if (ext
.len
!= sizeof(bitmaps_ext
)) {
312 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
313 "Invalid extension length");
317 if (!(s
->autoclear_features
& QCOW2_AUTOCLEAR_BITMAPS
)) {
318 if (s
->qcow_version
< 3) {
319 /* Let's be a bit more specific */
320 warn_report("This qcow2 v2 image contains bitmaps, but "
321 "they may have been modified by a program "
322 "without persistent bitmap support; so now "
323 "they must all be considered inconsistent");
325 warn_report("a program lacking bitmap support "
326 "modified this file, so all bitmaps are now "
327 "considered inconsistent");
329 error_printf("Some clusters may be leaked, "
330 "run 'qemu-img check -r' on the image "
332 if (need_update_header
!= NULL
) {
333 /* Updating is needed to drop invalid bitmap extension. */
334 *need_update_header
= true;
339 ret
= bdrv_pread(bs
->file
, offset
, &bitmaps_ext
, ext
.len
);
341 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
342 "Could not read ext header");
346 if (bitmaps_ext
.reserved32
!= 0) {
347 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
348 "Reserved field is not zero");
352 bitmaps_ext
.nb_bitmaps
= be32_to_cpu(bitmaps_ext
.nb_bitmaps
);
353 bitmaps_ext
.bitmap_directory_size
=
354 be64_to_cpu(bitmaps_ext
.bitmap_directory_size
);
355 bitmaps_ext
.bitmap_directory_offset
=
356 be64_to_cpu(bitmaps_ext
.bitmap_directory_offset
);
358 if (bitmaps_ext
.nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
360 "bitmaps_ext: Image has %" PRIu32
" bitmaps, "
361 "exceeding the QEMU supported maximum of %d",
362 bitmaps_ext
.nb_bitmaps
, QCOW2_MAX_BITMAPS
);
366 if (bitmaps_ext
.nb_bitmaps
== 0) {
367 error_setg(errp
, "found bitmaps extension with zero bitmaps");
371 if (bitmaps_ext
.bitmap_directory_offset
& (s
->cluster_size
- 1)) {
372 error_setg(errp
, "bitmaps_ext: "
373 "invalid bitmap directory offset");
377 if (bitmaps_ext
.bitmap_directory_size
>
378 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
379 error_setg(errp
, "bitmaps_ext: "
380 "bitmap directory size (%" PRIu64
") exceeds "
381 "the maximum supported size (%d)",
382 bitmaps_ext
.bitmap_directory_size
,
383 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
);
387 s
->nb_bitmaps
= bitmaps_ext
.nb_bitmaps
;
388 s
->bitmap_directory_offset
=
389 bitmaps_ext
.bitmap_directory_offset
;
390 s
->bitmap_directory_size
=
391 bitmaps_ext
.bitmap_directory_size
;
394 printf("Qcow2: Got bitmaps extension: "
395 "offset=%" PRIu64
" nb_bitmaps=%" PRIu32
"\n",
396 s
->bitmap_directory_offset
, s
->nb_bitmaps
);
401 /* unknown magic - save it in case we need to rewrite the header */
402 /* If you add a new feature, make sure to also update the fast
403 * path of qcow2_make_empty() to deal with it. */
405 Qcow2UnknownHeaderExtension
*uext
;
407 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
408 uext
->magic
= ext
.magic
;
410 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
412 ret
= bdrv_pread(bs
->file
, offset
, uext
->data
, uext
->len
);
414 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
415 "Could not read data");
422 offset
+= ((ext
.len
+ 7) & ~7);
428 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
430 BDRVQcow2State
*s
= bs
->opaque
;
431 Qcow2UnknownHeaderExtension
*uext
, *next
;
433 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
434 QLIST_REMOVE(uext
, next
);
439 static void report_unsupported_feature(Error
**errp
, Qcow2Feature
*table
,
442 char *features
= g_strdup("");
445 while (table
&& table
->name
[0] != '\0') {
446 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
447 if (mask
& (1ULL << table
->bit
)) {
449 features
= g_strdup_printf("%s%s%.46s", old
, *old
? ", " : "",
452 mask
&= ~(1ULL << table
->bit
);
460 features
= g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64
,
461 old
, *old
? ", " : "", mask
);
465 error_setg(errp
, "Unsupported qcow2 feature(s): %s", features
);
470 * Sets the dirty bit and flushes afterwards if necessary.
472 * The incompatible_features bit is only set if the image file header was
473 * updated successfully. Therefore it is not required to check the return
474 * value of this function.
476 int qcow2_mark_dirty(BlockDriverState
*bs
)
478 BDRVQcow2State
*s
= bs
->opaque
;
482 assert(s
->qcow_version
>= 3);
484 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
485 return 0; /* already dirty */
488 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
489 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, incompatible_features
),
494 ret
= bdrv_flush(bs
->file
->bs
);
499 /* Only treat image as dirty if the header was updated successfully */
500 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
505 * Clears the dirty bit and flushes before if necessary. Only call this
506 * function when there are no pending requests, it does not guard against
507 * concurrent requests dirtying the image.
509 static int qcow2_mark_clean(BlockDriverState
*bs
)
511 BDRVQcow2State
*s
= bs
->opaque
;
513 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
516 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
518 ret
= qcow2_flush_caches(bs
);
523 return qcow2_update_header(bs
);
529 * Marks the image as corrupt.
531 int qcow2_mark_corrupt(BlockDriverState
*bs
)
533 BDRVQcow2State
*s
= bs
->opaque
;
535 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
536 return qcow2_update_header(bs
);
540 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
541 * before if necessary.
543 int qcow2_mark_consistent(BlockDriverState
*bs
)
545 BDRVQcow2State
*s
= bs
->opaque
;
547 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
548 int ret
= qcow2_flush_caches(bs
);
553 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
554 return qcow2_update_header(bs
);
559 static int coroutine_fn
qcow2_co_check_locked(BlockDriverState
*bs
,
560 BdrvCheckResult
*result
,
563 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
568 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
569 ret
= qcow2_mark_clean(bs
);
573 return qcow2_mark_consistent(bs
);
578 static int coroutine_fn
qcow2_co_check(BlockDriverState
*bs
,
579 BdrvCheckResult
*result
,
582 BDRVQcow2State
*s
= bs
->opaque
;
585 qemu_co_mutex_lock(&s
->lock
);
586 ret
= qcow2_co_check_locked(bs
, result
, fix
);
587 qemu_co_mutex_unlock(&s
->lock
);
591 int qcow2_validate_table(BlockDriverState
*bs
, uint64_t offset
,
592 uint64_t entries
, size_t entry_len
,
593 int64_t max_size_bytes
, const char *table_name
,
596 BDRVQcow2State
*s
= bs
->opaque
;
598 if (entries
> max_size_bytes
/ entry_len
) {
599 error_setg(errp
, "%s too large", table_name
);
603 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
604 * because values will be passed to qemu functions taking int64_t. */
605 if ((INT64_MAX
- entries
* entry_len
< offset
) ||
606 (offset_into_cluster(s
, offset
) != 0)) {
607 error_setg(errp
, "%s offset invalid", table_name
);
614 static QemuOptsList qcow2_runtime_opts
= {
616 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
619 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
620 .type
= QEMU_OPT_BOOL
,
621 .help
= "Postpone refcount updates",
624 .name
= QCOW2_OPT_DISCARD_REQUEST
,
625 .type
= QEMU_OPT_BOOL
,
626 .help
= "Pass guest discard requests to the layer below",
629 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
630 .type
= QEMU_OPT_BOOL
,
631 .help
= "Generate discard requests when snapshot related space "
635 .name
= QCOW2_OPT_DISCARD_OTHER
,
636 .type
= QEMU_OPT_BOOL
,
637 .help
= "Generate discard requests when other clusters are freed",
640 .name
= QCOW2_OPT_OVERLAP
,
641 .type
= QEMU_OPT_STRING
,
642 .help
= "Selects which overlap checks to perform from a range of "
643 "templates (none, constant, cached, all)",
646 .name
= QCOW2_OPT_OVERLAP_TEMPLATE
,
647 .type
= QEMU_OPT_STRING
,
648 .help
= "Selects which overlap checks to perform from a range of "
649 "templates (none, constant, cached, all)",
652 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
653 .type
= QEMU_OPT_BOOL
,
654 .help
= "Check for unintended writes into the main qcow2 header",
657 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
658 .type
= QEMU_OPT_BOOL
,
659 .help
= "Check for unintended writes into the active L1 table",
662 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
663 .type
= QEMU_OPT_BOOL
,
664 .help
= "Check for unintended writes into an active L2 table",
667 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
668 .type
= QEMU_OPT_BOOL
,
669 .help
= "Check for unintended writes into the refcount table",
672 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
673 .type
= QEMU_OPT_BOOL
,
674 .help
= "Check for unintended writes into a refcount block",
677 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
678 .type
= QEMU_OPT_BOOL
,
679 .help
= "Check for unintended writes into the snapshot table",
682 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
683 .type
= QEMU_OPT_BOOL
,
684 .help
= "Check for unintended writes into an inactive L1 table",
687 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
688 .type
= QEMU_OPT_BOOL
,
689 .help
= "Check for unintended writes into an inactive L2 table",
692 .name
= QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
693 .type
= QEMU_OPT_BOOL
,
694 .help
= "Check for unintended writes into the bitmap directory",
697 .name
= QCOW2_OPT_CACHE_SIZE
,
698 .type
= QEMU_OPT_SIZE
,
699 .help
= "Maximum combined metadata (L2 tables and refcount blocks) "
703 .name
= QCOW2_OPT_L2_CACHE_SIZE
,
704 .type
= QEMU_OPT_SIZE
,
705 .help
= "Maximum L2 table cache size",
708 .name
= QCOW2_OPT_L2_CACHE_ENTRY_SIZE
,
709 .type
= QEMU_OPT_SIZE
,
710 .help
= "Size of each entry in the L2 cache",
713 .name
= QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
714 .type
= QEMU_OPT_SIZE
,
715 .help
= "Maximum refcount block cache size",
718 .name
= QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
719 .type
= QEMU_OPT_NUMBER
,
720 .help
= "Clean unused cache entries after this time (in seconds)",
722 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
723 "ID of secret providing qcow2 AES key or LUKS passphrase"),
724 { /* end of list */ }
728 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
729 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
730 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
731 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
732 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
733 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
734 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
735 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
736 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
737 [QCOW2_OL_BITMAP_DIRECTORY_BITNR
] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
740 static void cache_clean_timer_cb(void *opaque
)
742 BlockDriverState
*bs
= opaque
;
743 BDRVQcow2State
*s
= bs
->opaque
;
744 qcow2_cache_clean_unused(s
->l2_table_cache
);
745 qcow2_cache_clean_unused(s
->refcount_block_cache
);
746 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
747 (int64_t) s
->cache_clean_interval
* 1000);
750 static void cache_clean_timer_init(BlockDriverState
*bs
, AioContext
*context
)
752 BDRVQcow2State
*s
= bs
->opaque
;
753 if (s
->cache_clean_interval
> 0) {
754 s
->cache_clean_timer
= aio_timer_new(context
, QEMU_CLOCK_VIRTUAL
,
755 SCALE_MS
, cache_clean_timer_cb
,
757 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
758 (int64_t) s
->cache_clean_interval
* 1000);
762 static void cache_clean_timer_del(BlockDriverState
*bs
)
764 BDRVQcow2State
*s
= bs
->opaque
;
765 if (s
->cache_clean_timer
) {
766 timer_del(s
->cache_clean_timer
);
767 timer_free(s
->cache_clean_timer
);
768 s
->cache_clean_timer
= NULL
;
772 static void qcow2_detach_aio_context(BlockDriverState
*bs
)
774 cache_clean_timer_del(bs
);
777 static void qcow2_attach_aio_context(BlockDriverState
*bs
,
778 AioContext
*new_context
)
780 cache_clean_timer_init(bs
, new_context
);
783 static void read_cache_sizes(BlockDriverState
*bs
, QemuOpts
*opts
,
784 uint64_t *l2_cache_size
,
785 uint64_t *l2_cache_entry_size
,
786 uint64_t *refcount_cache_size
, Error
**errp
)
788 BDRVQcow2State
*s
= bs
->opaque
;
789 uint64_t combined_cache_size
, l2_cache_max_setting
;
790 bool l2_cache_size_set
, refcount_cache_size_set
, combined_cache_size_set
;
791 int min_refcount_cache
= MIN_REFCOUNT_CACHE_SIZE
* s
->cluster_size
;
792 uint64_t virtual_disk_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
793 uint64_t max_l2_cache
= virtual_disk_size
/ (s
->cluster_size
/ 8);
795 combined_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_CACHE_SIZE
);
796 l2_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_SIZE
);
797 refcount_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
799 combined_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_CACHE_SIZE
, 0);
800 l2_cache_max_setting
= qemu_opt_get_size(opts
, QCOW2_OPT_L2_CACHE_SIZE
,
801 DEFAULT_L2_CACHE_MAX_SIZE
);
802 *refcount_cache_size
= qemu_opt_get_size(opts
,
803 QCOW2_OPT_REFCOUNT_CACHE_SIZE
, 0);
805 *l2_cache_entry_size
= qemu_opt_get_size(
806 opts
, QCOW2_OPT_L2_CACHE_ENTRY_SIZE
, s
->cluster_size
);
808 *l2_cache_size
= MIN(max_l2_cache
, l2_cache_max_setting
);
810 if (combined_cache_size_set
) {
811 if (l2_cache_size_set
&& refcount_cache_size_set
) {
812 error_setg(errp
, QCOW2_OPT_CACHE_SIZE
", " QCOW2_OPT_L2_CACHE_SIZE
813 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not be set "
816 } else if (l2_cache_size_set
&&
817 (l2_cache_max_setting
> combined_cache_size
)) {
818 error_setg(errp
, QCOW2_OPT_L2_CACHE_SIZE
" may not exceed "
819 QCOW2_OPT_CACHE_SIZE
);
821 } else if (*refcount_cache_size
> combined_cache_size
) {
822 error_setg(errp
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not exceed "
823 QCOW2_OPT_CACHE_SIZE
);
827 if (l2_cache_size_set
) {
828 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
829 } else if (refcount_cache_size_set
) {
830 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
832 /* Assign as much memory as possible to the L2 cache, and
833 * use the remainder for the refcount cache */
834 if (combined_cache_size
>= max_l2_cache
+ min_refcount_cache
) {
835 *l2_cache_size
= max_l2_cache
;
836 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
838 *refcount_cache_size
=
839 MIN(combined_cache_size
, min_refcount_cache
);
840 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
844 /* l2_cache_size and refcount_cache_size are ensured to have at least
845 * their minimum values in qcow2_update_options_prepare() */
847 if (*l2_cache_entry_size
< (1 << MIN_CLUSTER_BITS
) ||
848 *l2_cache_entry_size
> s
->cluster_size
||
849 !is_power_of_2(*l2_cache_entry_size
)) {
850 error_setg(errp
, "L2 cache entry size must be a power of two "
851 "between %d and the cluster size (%d)",
852 1 << MIN_CLUSTER_BITS
, s
->cluster_size
);
857 typedef struct Qcow2ReopenState
{
858 Qcow2Cache
*l2_table_cache
;
859 Qcow2Cache
*refcount_block_cache
;
860 int l2_slice_size
; /* Number of entries in a slice of the L2 table */
861 bool use_lazy_refcounts
;
863 bool discard_passthrough
[QCOW2_DISCARD_MAX
];
864 uint64_t cache_clean_interval
;
865 QCryptoBlockOpenOptions
*crypto_opts
; /* Disk encryption runtime options */
868 static int qcow2_update_options_prepare(BlockDriverState
*bs
,
870 QDict
*options
, int flags
,
873 BDRVQcow2State
*s
= bs
->opaque
;
874 QemuOpts
*opts
= NULL
;
875 const char *opt_overlap_check
, *opt_overlap_check_template
;
876 int overlap_check_template
= 0;
877 uint64_t l2_cache_size
, l2_cache_entry_size
, refcount_cache_size
;
879 const char *encryptfmt
;
880 QDict
*encryptopts
= NULL
;
881 Error
*local_err
= NULL
;
884 qdict_extract_subqdict(options
, &encryptopts
, "encrypt.");
885 encryptfmt
= qdict_get_try_str(encryptopts
, "format");
887 opts
= qemu_opts_create(&qcow2_runtime_opts
, NULL
, 0, &error_abort
);
888 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
890 error_propagate(errp
, local_err
);
895 /* get L2 table/refcount block cache size from command line options */
896 read_cache_sizes(bs
, opts
, &l2_cache_size
, &l2_cache_entry_size
,
897 &refcount_cache_size
, &local_err
);
899 error_propagate(errp
, local_err
);
904 l2_cache_size
/= l2_cache_entry_size
;
905 if (l2_cache_size
< MIN_L2_CACHE_SIZE
) {
906 l2_cache_size
= MIN_L2_CACHE_SIZE
;
908 if (l2_cache_size
> INT_MAX
) {
909 error_setg(errp
, "L2 cache size too big");
914 refcount_cache_size
/= s
->cluster_size
;
915 if (refcount_cache_size
< MIN_REFCOUNT_CACHE_SIZE
) {
916 refcount_cache_size
= MIN_REFCOUNT_CACHE_SIZE
;
918 if (refcount_cache_size
> INT_MAX
) {
919 error_setg(errp
, "Refcount cache size too big");
924 /* alloc new L2 table/refcount block cache, flush old one */
925 if (s
->l2_table_cache
) {
926 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
928 error_setg_errno(errp
, -ret
, "Failed to flush the L2 table cache");
933 if (s
->refcount_block_cache
) {
934 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
936 error_setg_errno(errp
, -ret
,
937 "Failed to flush the refcount block cache");
942 r
->l2_slice_size
= l2_cache_entry_size
/ sizeof(uint64_t);
943 r
->l2_table_cache
= qcow2_cache_create(bs
, l2_cache_size
,
944 l2_cache_entry_size
);
945 r
->refcount_block_cache
= qcow2_cache_create(bs
, refcount_cache_size
,
947 if (r
->l2_table_cache
== NULL
|| r
->refcount_block_cache
== NULL
) {
948 error_setg(errp
, "Could not allocate metadata caches");
953 /* New interval for cache cleanup timer */
954 r
->cache_clean_interval
=
955 qemu_opt_get_number(opts
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
956 DEFAULT_CACHE_CLEAN_INTERVAL
);
958 if (r
->cache_clean_interval
!= 0) {
959 error_setg(errp
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
960 " not supported on this host");
965 if (r
->cache_clean_interval
> UINT_MAX
) {
966 error_setg(errp
, "Cache clean interval too big");
971 /* lazy-refcounts; flush if going from enabled to disabled */
972 r
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
973 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
974 if (r
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
975 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
976 "qemu 1.1 compatibility level");
981 if (s
->use_lazy_refcounts
&& !r
->use_lazy_refcounts
) {
982 ret
= qcow2_mark_clean(bs
);
984 error_setg_errno(errp
, -ret
, "Failed to disable lazy refcounts");
989 /* Overlap check options */
990 opt_overlap_check
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP
);
991 opt_overlap_check_template
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP_TEMPLATE
);
992 if (opt_overlap_check_template
&& opt_overlap_check
&&
993 strcmp(opt_overlap_check_template
, opt_overlap_check
))
995 error_setg(errp
, "Conflicting values for qcow2 options '"
996 QCOW2_OPT_OVERLAP
"' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
997 "' ('%s')", opt_overlap_check
, opt_overlap_check_template
);
1001 if (!opt_overlap_check
) {
1002 opt_overlap_check
= opt_overlap_check_template
?: "cached";
1005 if (!strcmp(opt_overlap_check
, "none")) {
1006 overlap_check_template
= 0;
1007 } else if (!strcmp(opt_overlap_check
, "constant")) {
1008 overlap_check_template
= QCOW2_OL_CONSTANT
;
1009 } else if (!strcmp(opt_overlap_check
, "cached")) {
1010 overlap_check_template
= QCOW2_OL_CACHED
;
1011 } else if (!strcmp(opt_overlap_check
, "all")) {
1012 overlap_check_template
= QCOW2_OL_ALL
;
1014 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
1015 "'overlap-check'. Allowed are any of the following: "
1016 "none, constant, cached, all", opt_overlap_check
);
1021 r
->overlap_check
= 0;
1022 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
1023 /* overlap-check defines a template bitmask, but every flag may be
1024 * overwritten through the associated boolean option */
1026 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
1027 overlap_check_template
& (1 << i
)) << i
;
1030 r
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
1031 r
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
1032 r
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
1033 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
1034 flags
& BDRV_O_UNMAP
);
1035 r
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
1036 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
1037 r
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
1038 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
1040 switch (s
->crypt_method_header
) {
1041 case QCOW_CRYPT_NONE
:
1043 error_setg(errp
, "No encryption in image header, but options "
1044 "specified format '%s'", encryptfmt
);
1050 case QCOW_CRYPT_AES
:
1051 if (encryptfmt
&& !g_str_equal(encryptfmt
, "aes")) {
1053 "Header reported 'aes' encryption format but "
1054 "options specify '%s'", encryptfmt
);
1058 qdict_put_str(encryptopts
, "format", "qcow");
1059 r
->crypto_opts
= block_crypto_open_opts_init(encryptopts
, errp
);
1062 case QCOW_CRYPT_LUKS
:
1063 if (encryptfmt
&& !g_str_equal(encryptfmt
, "luks")) {
1065 "Header reported 'luks' encryption format but "
1066 "options specify '%s'", encryptfmt
);
1070 qdict_put_str(encryptopts
, "format", "luks");
1071 r
->crypto_opts
= block_crypto_open_opts_init(encryptopts
, errp
);
1075 error_setg(errp
, "Unsupported encryption method %d",
1076 s
->crypt_method_header
);
1079 if (s
->crypt_method_header
!= QCOW_CRYPT_NONE
&& !r
->crypto_opts
) {
1086 qobject_unref(encryptopts
);
1087 qemu_opts_del(opts
);
1092 static void qcow2_update_options_commit(BlockDriverState
*bs
,
1093 Qcow2ReopenState
*r
)
1095 BDRVQcow2State
*s
= bs
->opaque
;
1098 if (s
->l2_table_cache
) {
1099 qcow2_cache_destroy(s
->l2_table_cache
);
1101 if (s
->refcount_block_cache
) {
1102 qcow2_cache_destroy(s
->refcount_block_cache
);
1104 s
->l2_table_cache
= r
->l2_table_cache
;
1105 s
->refcount_block_cache
= r
->refcount_block_cache
;
1106 s
->l2_slice_size
= r
->l2_slice_size
;
1108 s
->overlap_check
= r
->overlap_check
;
1109 s
->use_lazy_refcounts
= r
->use_lazy_refcounts
;
1111 for (i
= 0; i
< QCOW2_DISCARD_MAX
; i
++) {
1112 s
->discard_passthrough
[i
] = r
->discard_passthrough
[i
];
1115 if (s
->cache_clean_interval
!= r
->cache_clean_interval
) {
1116 cache_clean_timer_del(bs
);
1117 s
->cache_clean_interval
= r
->cache_clean_interval
;
1118 cache_clean_timer_init(bs
, bdrv_get_aio_context(bs
));
1121 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1122 s
->crypto_opts
= r
->crypto_opts
;
1125 static void qcow2_update_options_abort(BlockDriverState
*bs
,
1126 Qcow2ReopenState
*r
)
1128 if (r
->l2_table_cache
) {
1129 qcow2_cache_destroy(r
->l2_table_cache
);
1131 if (r
->refcount_block_cache
) {
1132 qcow2_cache_destroy(r
->refcount_block_cache
);
1134 qapi_free_QCryptoBlockOpenOptions(r
->crypto_opts
);
1137 static int qcow2_update_options(BlockDriverState
*bs
, QDict
*options
,
1138 int flags
, Error
**errp
)
1140 Qcow2ReopenState r
= {};
1143 ret
= qcow2_update_options_prepare(bs
, &r
, options
, flags
, errp
);
1145 qcow2_update_options_commit(bs
, &r
);
1147 qcow2_update_options_abort(bs
, &r
);
1153 /* Called with s->lock held. */
1154 static int coroutine_fn
qcow2_do_open(BlockDriverState
*bs
, QDict
*options
,
1155 int flags
, Error
**errp
)
1157 BDRVQcow2State
*s
= bs
->opaque
;
1158 unsigned int len
, i
;
1161 Error
*local_err
= NULL
;
1163 uint64_t l1_vm_state_index
;
1164 bool update_header
= false;
1166 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
1168 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
1171 header
.magic
= be32_to_cpu(header
.magic
);
1172 header
.version
= be32_to_cpu(header
.version
);
1173 header
.backing_file_offset
= be64_to_cpu(header
.backing_file_offset
);
1174 header
.backing_file_size
= be32_to_cpu(header
.backing_file_size
);
1175 header
.size
= be64_to_cpu(header
.size
);
1176 header
.cluster_bits
= be32_to_cpu(header
.cluster_bits
);
1177 header
.crypt_method
= be32_to_cpu(header
.crypt_method
);
1178 header
.l1_table_offset
= be64_to_cpu(header
.l1_table_offset
);
1179 header
.l1_size
= be32_to_cpu(header
.l1_size
);
1180 header
.refcount_table_offset
= be64_to_cpu(header
.refcount_table_offset
);
1181 header
.refcount_table_clusters
=
1182 be32_to_cpu(header
.refcount_table_clusters
);
1183 header
.snapshots_offset
= be64_to_cpu(header
.snapshots_offset
);
1184 header
.nb_snapshots
= be32_to_cpu(header
.nb_snapshots
);
1186 if (header
.magic
!= QCOW_MAGIC
) {
1187 error_setg(errp
, "Image is not in qcow2 format");
1191 if (header
.version
< 2 || header
.version
> 3) {
1192 error_setg(errp
, "Unsupported qcow2 version %" PRIu32
, header
.version
);
1197 s
->qcow_version
= header
.version
;
1199 /* Initialise cluster size */
1200 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
1201 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
1202 error_setg(errp
, "Unsupported cluster size: 2^%" PRIu32
,
1203 header
.cluster_bits
);
1208 s
->cluster_bits
= header
.cluster_bits
;
1209 s
->cluster_size
= 1 << s
->cluster_bits
;
1210 s
->cluster_sectors
= 1 << (s
->cluster_bits
- BDRV_SECTOR_BITS
);
1212 /* Initialise version 3 header fields */
1213 if (header
.version
== 2) {
1214 header
.incompatible_features
= 0;
1215 header
.compatible_features
= 0;
1216 header
.autoclear_features
= 0;
1217 header
.refcount_order
= 4;
1218 header
.header_length
= 72;
1220 header
.incompatible_features
=
1221 be64_to_cpu(header
.incompatible_features
);
1222 header
.compatible_features
= be64_to_cpu(header
.compatible_features
);
1223 header
.autoclear_features
= be64_to_cpu(header
.autoclear_features
);
1224 header
.refcount_order
= be32_to_cpu(header
.refcount_order
);
1225 header
.header_length
= be32_to_cpu(header
.header_length
);
1227 if (header
.header_length
< 104) {
1228 error_setg(errp
, "qcow2 header too short");
1234 if (header
.header_length
> s
->cluster_size
) {
1235 error_setg(errp
, "qcow2 header exceeds cluster size");
1240 if (header
.header_length
> sizeof(header
)) {
1241 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
1242 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
1243 ret
= bdrv_pread(bs
->file
, sizeof(header
), s
->unknown_header_fields
,
1244 s
->unknown_header_fields_size
);
1246 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
1252 if (header
.backing_file_offset
> s
->cluster_size
) {
1253 error_setg(errp
, "Invalid backing file offset");
1258 if (header
.backing_file_offset
) {
1259 ext_end
= header
.backing_file_offset
;
1261 ext_end
= 1 << header
.cluster_bits
;
1264 /* Handle feature bits */
1265 s
->incompatible_features
= header
.incompatible_features
;
1266 s
->compatible_features
= header
.compatible_features
;
1267 s
->autoclear_features
= header
.autoclear_features
;
1269 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
1270 void *feature_table
= NULL
;
1271 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
1272 &feature_table
, flags
, NULL
, NULL
);
1273 report_unsupported_feature(errp
, feature_table
,
1274 s
->incompatible_features
&
1275 ~QCOW2_INCOMPAT_MASK
);
1277 g_free(feature_table
);
1281 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
1282 /* Corrupt images may not be written to unless they are being repaired
1284 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
1285 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
1292 /* Check support for various header values */
1293 if (header
.refcount_order
> 6) {
1294 error_setg(errp
, "Reference count entry width too large; may not "
1299 s
->refcount_order
= header
.refcount_order
;
1300 s
->refcount_bits
= 1 << s
->refcount_order
;
1301 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
1302 s
->refcount_max
+= s
->refcount_max
- 1;
1304 s
->crypt_method_header
= header
.crypt_method
;
1305 if (s
->crypt_method_header
) {
1306 if (bdrv_uses_whitelist() &&
1307 s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1309 "Use of AES-CBC encrypted qcow2 images is no longer "
1310 "supported in system emulators");
1311 error_append_hint(errp
,
1312 "You can use 'qemu-img convert' to convert your "
1313 "image to an alternative supported format, such "
1314 "as unencrypted qcow2, or raw with the LUKS "
1315 "format instead.\n");
1320 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1321 s
->crypt_physical_offset
= false;
1323 /* Assuming LUKS and any future crypt methods we
1324 * add will all use physical offsets, due to the
1325 * fact that the alternative is insecure... */
1326 s
->crypt_physical_offset
= true;
1329 bs
->encrypted
= true;
1332 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
1333 s
->l2_size
= 1 << s
->l2_bits
;
1334 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1335 s
->refcount_block_bits
= s
->cluster_bits
- (s
->refcount_order
- 3);
1336 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
1337 bs
->total_sectors
= header
.size
/ BDRV_SECTOR_SIZE
;
1338 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
1339 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
1340 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
1342 s
->refcount_table_offset
= header
.refcount_table_offset
;
1343 s
->refcount_table_size
=
1344 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
1346 if (header
.refcount_table_clusters
== 0 && !(flags
& BDRV_O_CHECK
)) {
1347 error_setg(errp
, "Image does not contain a reference count table");
1352 ret
= qcow2_validate_table(bs
, s
->refcount_table_offset
,
1353 header
.refcount_table_clusters
,
1354 s
->cluster_size
, QCOW_MAX_REFTABLE_SIZE
,
1355 "Reference count table", errp
);
1360 /* The total size in bytes of the snapshot table is checked in
1361 * qcow2_read_snapshots() because the size of each snapshot is
1362 * variable and we don't know it yet.
1363 * Here we only check the offset and number of snapshots. */
1364 ret
= qcow2_validate_table(bs
, header
.snapshots_offset
,
1365 header
.nb_snapshots
,
1366 sizeof(QCowSnapshotHeader
),
1367 sizeof(QCowSnapshotHeader
) * QCOW_MAX_SNAPSHOTS
,
1368 "Snapshot table", errp
);
1373 /* read the level 1 table */
1374 ret
= qcow2_validate_table(bs
, header
.l1_table_offset
,
1375 header
.l1_size
, sizeof(uint64_t),
1376 QCOW_MAX_L1_SIZE
, "Active L1 table", errp
);
1380 s
->l1_size
= header
.l1_size
;
1381 s
->l1_table_offset
= header
.l1_table_offset
;
1383 l1_vm_state_index
= size_to_l1(s
, header
.size
);
1384 if (l1_vm_state_index
> INT_MAX
) {
1385 error_setg(errp
, "Image is too big");
1389 s
->l1_vm_state_index
= l1_vm_state_index
;
1391 /* the L1 table must contain at least enough entries to put
1392 header.size bytes */
1393 if (s
->l1_size
< s
->l1_vm_state_index
) {
1394 error_setg(errp
, "L1 table is too small");
1399 if (s
->l1_size
> 0) {
1400 s
->l1_table
= qemu_try_blockalign(bs
->file
->bs
,
1401 ROUND_UP(s
->l1_size
* sizeof(uint64_t), 512));
1402 if (s
->l1_table
== NULL
) {
1403 error_setg(errp
, "Could not allocate L1 table");
1407 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
1408 s
->l1_size
* sizeof(uint64_t));
1410 error_setg_errno(errp
, -ret
, "Could not read L1 table");
1413 for(i
= 0;i
< s
->l1_size
; i
++) {
1414 s
->l1_table
[i
] = be64_to_cpu(s
->l1_table
[i
]);
1418 /* Parse driver-specific options */
1419 ret
= qcow2_update_options(bs
, options
, flags
, errp
);
1426 ret
= qcow2_refcount_init(bs
);
1428 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
1432 QLIST_INIT(&s
->cluster_allocs
);
1433 QTAILQ_INIT(&s
->discards
);
1435 /* read qcow2 extensions */
1436 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
1437 flags
, &update_header
, &local_err
)) {
1438 error_propagate(errp
, local_err
);
1443 /* qcow2_read_extension may have set up the crypto context
1444 * if the crypt method needs a header region, some methods
1445 * don't need header extensions, so must check here
1447 if (s
->crypt_method_header
&& !s
->crypto
) {
1448 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1449 unsigned int cflags
= 0;
1450 if (flags
& BDRV_O_NO_IO
) {
1451 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
1453 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
1454 NULL
, NULL
, cflags
, 1, errp
);
1459 } else if (!(flags
& BDRV_O_NO_IO
)) {
1460 error_setg(errp
, "Missing CRYPTO header for crypt method %d",
1461 s
->crypt_method_header
);
1467 /* read the backing file name */
1468 if (header
.backing_file_offset
!= 0) {
1469 len
= header
.backing_file_size
;
1470 if (len
> MIN(1023, s
->cluster_size
- header
.backing_file_offset
) ||
1471 len
>= sizeof(bs
->backing_file
)) {
1472 error_setg(errp
, "Backing file name too long");
1476 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
1477 bs
->backing_file
, len
);
1479 error_setg_errno(errp
, -ret
, "Could not read backing file name");
1482 bs
->backing_file
[len
] = '\0';
1483 s
->image_backing_file
= g_strdup(bs
->backing_file
);
1486 /* Internal snapshots */
1487 s
->snapshots_offset
= header
.snapshots_offset
;
1488 s
->nb_snapshots
= header
.nb_snapshots
;
1490 ret
= qcow2_read_snapshots(bs
);
1492 error_setg_errno(errp
, -ret
, "Could not read snapshots");
1496 /* Clear unknown autoclear feature bits */
1497 update_header
|= s
->autoclear_features
& ~QCOW2_AUTOCLEAR_MASK
;
1499 update_header
&& !bs
->read_only
&& !(flags
& BDRV_O_INACTIVE
);
1500 if (update_header
) {
1501 s
->autoclear_features
&= QCOW2_AUTOCLEAR_MASK
;
1504 /* == Handle persistent dirty bitmaps ==
1506 * We want load dirty bitmaps in three cases:
1508 * 1. Normal open of the disk in active mode, not related to invalidation
1511 * 2. Invalidation of the target vm after pre-copy phase of migration, if
1512 * bitmaps are _not_ migrating through migration channel, i.e.
1513 * 'dirty-bitmaps' capability is disabled.
1515 * 3. Invalidation of source vm after failed or canceled migration.
1516 * This is a very interesting case. There are two possible types of
1519 * A. Stored on inactivation and removed. They should be loaded from the
1522 * B. Not stored: not-persistent bitmaps and bitmaps, migrated through
1523 * the migration channel (with dirty-bitmaps capability).
1525 * On the other hand, there are two possible sub-cases:
1527 * 3.1 disk was changed by somebody else while were inactive. In this
1528 * case all in-RAM dirty bitmaps (both persistent and not) are
1529 * definitely invalid. And we don't have any method to determine
1532 * Simple and safe thing is to just drop all the bitmaps of type B on
1533 * inactivation. But in this case we lose bitmaps in valid 4.2 case.
1535 * On the other hand, resuming source vm, if disk was already changed
1536 * is a bad thing anyway: not only bitmaps, the whole vm state is
1537 * out of sync with disk.
1539 * This means, that user or management tool, who for some reason
1540 * decided to resume source vm, after disk was already changed by
1541 * target vm, should at least drop all dirty bitmaps by hand.
1543 * So, we can ignore this case for now, but TODO: "generation"
1544 * extension for qcow2, to determine, that image was changed after
1545 * last inactivation. And if it is changed, we will drop (or at least
1546 * mark as 'invalid' all the bitmaps of type B, both persistent
1549 * 3.2 disk was _not_ changed while were inactive. Bitmaps may be saved
1550 * to disk ('dirty-bitmaps' capability disabled), or not saved
1551 * ('dirty-bitmaps' capability enabled), but we don't need to care
1552 * of: let's load bitmaps as always: stored bitmaps will be loaded,
1553 * and not stored has flag IN_USE=1 in the image and will be skipped
1556 * One remaining possible case when we don't want load bitmaps:
1558 * 4. Open disk in inactive mode in target vm (bitmaps are migrating or
1559 * will be loaded on invalidation, no needs try loading them before)
1562 if (!(bdrv_get_flags(bs
) & BDRV_O_INACTIVE
)) {
1563 /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
1564 bool header_updated
= qcow2_load_dirty_bitmaps(bs
, &local_err
);
1566 update_header
= update_header
&& !header_updated
;
1568 if (local_err
!= NULL
) {
1569 error_propagate(errp
, local_err
);
1574 if (update_header
) {
1575 ret
= qcow2_update_header(bs
);
1577 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
1582 bs
->supported_zero_flags
= header
.version
>= 3 ? BDRV_REQ_MAY_UNMAP
: 0;
1584 /* Repair image if dirty */
1585 if (!(flags
& (BDRV_O_CHECK
| BDRV_O_INACTIVE
)) && !bs
->read_only
&&
1586 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
1587 BdrvCheckResult result
= {0};
1589 ret
= qcow2_co_check_locked(bs
, &result
,
1590 BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1591 if (ret
< 0 || result
.check_errors
) {
1595 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
1602 BdrvCheckResult result
= {0};
1603 qcow2_check_refcounts(bs
, &result
, 0);
1607 qemu_co_queue_init(&s
->compress_wait_queue
);
1612 g_free(s
->unknown_header_fields
);
1613 cleanup_unknown_header_ext(bs
);
1614 qcow2_free_snapshots(bs
);
1615 qcow2_refcount_close(bs
);
1616 qemu_vfree(s
->l1_table
);
1617 /* else pre-write overlap checks in cache_destroy may crash */
1619 cache_clean_timer_del(bs
);
1620 if (s
->l2_table_cache
) {
1621 qcow2_cache_destroy(s
->l2_table_cache
);
1623 if (s
->refcount_block_cache
) {
1624 qcow2_cache_destroy(s
->refcount_block_cache
);
1626 qcrypto_block_free(s
->crypto
);
1627 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1631 typedef struct QCow2OpenCo
{
1632 BlockDriverState
*bs
;
1639 static void coroutine_fn
qcow2_open_entry(void *opaque
)
1641 QCow2OpenCo
*qoc
= opaque
;
1642 BDRVQcow2State
*s
= qoc
->bs
->opaque
;
1644 qemu_co_mutex_lock(&s
->lock
);
1645 qoc
->ret
= qcow2_do_open(qoc
->bs
, qoc
->options
, qoc
->flags
, qoc
->errp
);
1646 qemu_co_mutex_unlock(&s
->lock
);
1649 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1652 BDRVQcow2State
*s
= bs
->opaque
;
1661 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
1667 /* Initialise locks */
1668 qemu_co_mutex_init(&s
->lock
);
1670 if (qemu_in_coroutine()) {
1671 /* From bdrv_co_create. */
1672 qcow2_open_entry(&qoc
);
1674 qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry
, &qoc
));
1675 BDRV_POLL_WHILE(bs
, qoc
.ret
== -EINPROGRESS
);
1680 static void qcow2_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
1682 BDRVQcow2State
*s
= bs
->opaque
;
1684 if (bs
->encrypted
) {
1685 /* Encryption works on a sector granularity */
1686 bs
->bl
.request_alignment
= qcrypto_block_get_sector_size(s
->crypto
);
1688 bs
->bl
.pwrite_zeroes_alignment
= s
->cluster_size
;
1689 bs
->bl
.pdiscard_alignment
= s
->cluster_size
;
1692 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
1693 BlockReopenQueue
*queue
, Error
**errp
)
1695 Qcow2ReopenState
*r
;
1698 r
= g_new0(Qcow2ReopenState
, 1);
1701 ret
= qcow2_update_options_prepare(state
->bs
, r
, state
->options
,
1702 state
->flags
, errp
);
1707 /* We need to write out any unwritten data if we reopen read-only. */
1708 if ((state
->flags
& BDRV_O_RDWR
) == 0) {
1709 ret
= qcow2_reopen_bitmaps_ro(state
->bs
, errp
);
1714 ret
= bdrv_flush(state
->bs
);
1719 ret
= qcow2_mark_clean(state
->bs
);
1728 qcow2_update_options_abort(state
->bs
, r
);
1733 static void qcow2_reopen_commit(BDRVReopenState
*state
)
1735 qcow2_update_options_commit(state
->bs
, state
->opaque
);
1736 g_free(state
->opaque
);
1739 static void qcow2_reopen_abort(BDRVReopenState
*state
)
1741 qcow2_update_options_abort(state
->bs
, state
->opaque
);
1742 g_free(state
->opaque
);
1745 static void qcow2_join_options(QDict
*options
, QDict
*old_options
)
1747 bool has_new_overlap_template
=
1748 qdict_haskey(options
, QCOW2_OPT_OVERLAP
) ||
1749 qdict_haskey(options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1750 bool has_new_total_cache_size
=
1751 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
);
1752 bool has_all_cache_options
;
1754 /* New overlap template overrides all old overlap options */
1755 if (has_new_overlap_template
) {
1756 qdict_del(old_options
, QCOW2_OPT_OVERLAP
);
1757 qdict_del(old_options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1758 qdict_del(old_options
, QCOW2_OPT_OVERLAP_MAIN_HEADER
);
1759 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L1
);
1760 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L2
);
1761 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
);
1762 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
);
1763 qdict_del(old_options
, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
);
1764 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L1
);
1765 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L2
);
1768 /* New total cache size overrides all old options */
1769 if (qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
)) {
1770 qdict_del(old_options
, QCOW2_OPT_L2_CACHE_SIZE
);
1771 qdict_del(old_options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1774 qdict_join(options
, old_options
, false);
1777 * If after merging all cache size options are set, an old total size is
1778 * overwritten. Do keep all options, however, if all three are new. The
1779 * resulting error message is what we want to happen.
1781 has_all_cache_options
=
1782 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
) ||
1783 qdict_haskey(options
, QCOW2_OPT_L2_CACHE_SIZE
) ||
1784 qdict_haskey(options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1786 if (has_all_cache_options
&& !has_new_total_cache_size
) {
1787 qdict_del(options
, QCOW2_OPT_CACHE_SIZE
);
1791 static int coroutine_fn
qcow2_co_block_status(BlockDriverState
*bs
,
1793 int64_t offset
, int64_t count
,
1794 int64_t *pnum
, int64_t *map
,
1795 BlockDriverState
**file
)
1797 BDRVQcow2State
*s
= bs
->opaque
;
1798 uint64_t cluster_offset
;
1799 int index_in_cluster
, ret
;
1803 bytes
= MIN(INT_MAX
, count
);
1804 qemu_co_mutex_lock(&s
->lock
);
1805 ret
= qcow2_get_cluster_offset(bs
, offset
, &bytes
, &cluster_offset
);
1806 qemu_co_mutex_unlock(&s
->lock
);
1813 if (cluster_offset
!= 0 && ret
!= QCOW2_CLUSTER_COMPRESSED
&&
1815 index_in_cluster
= offset
& (s
->cluster_size
- 1);
1816 *map
= cluster_offset
| index_in_cluster
;
1817 *file
= bs
->file
->bs
;
1818 status
|= BDRV_BLOCK_OFFSET_VALID
;
1820 if (ret
== QCOW2_CLUSTER_ZERO_PLAIN
|| ret
== QCOW2_CLUSTER_ZERO_ALLOC
) {
1821 status
|= BDRV_BLOCK_ZERO
;
1822 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
1823 status
|= BDRV_BLOCK_DATA
;
1828 static coroutine_fn
int qcow2_handle_l2meta(BlockDriverState
*bs
,
1829 QCowL2Meta
**pl2meta
,
1833 QCowL2Meta
*l2meta
= *pl2meta
;
1835 while (l2meta
!= NULL
) {
1839 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
1844 qcow2_alloc_cluster_abort(bs
, l2meta
);
1847 /* Take the request off the list of running requests */
1848 if (l2meta
->nb_clusters
!= 0) {
1849 QLIST_REMOVE(l2meta
, next_in_flight
);
1852 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1854 next
= l2meta
->next
;
1863 static coroutine_fn
int qcow2_co_preadv(BlockDriverState
*bs
, uint64_t offset
,
1864 uint64_t bytes
, QEMUIOVector
*qiov
,
1867 BDRVQcow2State
*s
= bs
->opaque
;
1868 int offset_in_cluster
;
1870 unsigned int cur_bytes
; /* number of bytes in current iteration */
1871 uint64_t cluster_offset
= 0;
1872 uint64_t bytes_done
= 0;
1873 QEMUIOVector hd_qiov
;
1874 uint8_t *cluster_data
= NULL
;
1876 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1878 qemu_co_mutex_lock(&s
->lock
);
1880 while (bytes
!= 0) {
1882 /* prepare next request */
1883 cur_bytes
= MIN(bytes
, INT_MAX
);
1885 cur_bytes
= MIN(cur_bytes
,
1886 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1889 ret
= qcow2_get_cluster_offset(bs
, offset
, &cur_bytes
, &cluster_offset
);
1894 offset_in_cluster
= offset_into_cluster(s
, offset
);
1896 qemu_iovec_reset(&hd_qiov
);
1897 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
1900 case QCOW2_CLUSTER_UNALLOCATED
:
1903 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
1904 qemu_co_mutex_unlock(&s
->lock
);
1905 ret
= bdrv_co_preadv(bs
->backing
, offset
, cur_bytes
,
1907 qemu_co_mutex_lock(&s
->lock
);
1912 /* Note: in this case, no need to wait */
1913 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1917 case QCOW2_CLUSTER_ZERO_PLAIN
:
1918 case QCOW2_CLUSTER_ZERO_ALLOC
:
1919 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1922 case QCOW2_CLUSTER_COMPRESSED
:
1923 qemu_co_mutex_unlock(&s
->lock
);
1924 ret
= qcow2_co_preadv_compressed(bs
, cluster_offset
,
1927 qemu_co_mutex_lock(&s
->lock
);
1934 case QCOW2_CLUSTER_NORMAL
:
1935 if ((cluster_offset
& 511) != 0) {
1940 if (bs
->encrypted
) {
1944 * For encrypted images, read everything into a temporary
1945 * contiguous buffer on which the AES functions can work.
1947 if (!cluster_data
) {
1949 qemu_try_blockalign(bs
->file
->bs
,
1950 QCOW_MAX_CRYPT_CLUSTERS
1952 if (cluster_data
== NULL
) {
1958 assert(cur_bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1959 qemu_iovec_reset(&hd_qiov
);
1960 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
1963 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
1964 qemu_co_mutex_unlock(&s
->lock
);
1965 ret
= bdrv_co_preadv(bs
->file
,
1966 cluster_offset
+ offset_in_cluster
,
1967 cur_bytes
, &hd_qiov
, 0);
1968 qemu_co_mutex_lock(&s
->lock
);
1972 if (bs
->encrypted
) {
1974 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1975 assert((cur_bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1976 if (qcrypto_block_decrypt(s
->crypto
,
1977 (s
->crypt_physical_offset
?
1978 cluster_offset
+ offset_in_cluster
:
1986 qemu_iovec_from_buf(qiov
, bytes_done
, cluster_data
, cur_bytes
);
1991 g_assert_not_reached();
1997 offset
+= cur_bytes
;
1998 bytes_done
+= cur_bytes
;
2003 qemu_co_mutex_unlock(&s
->lock
);
2005 qemu_iovec_destroy(&hd_qiov
);
2006 qemu_vfree(cluster_data
);
2011 /* Check if it's possible to merge a write request with the writing of
2012 * the data from the COW regions */
2013 static bool merge_cow(uint64_t offset
, unsigned bytes
,
2014 QEMUIOVector
*hd_qiov
, QCowL2Meta
*l2meta
)
2018 for (m
= l2meta
; m
!= NULL
; m
= m
->next
) {
2019 /* If both COW regions are empty then there's nothing to merge */
2020 if (m
->cow_start
.nb_bytes
== 0 && m
->cow_end
.nb_bytes
== 0) {
2024 /* The data (middle) region must be immediately after the
2026 if (l2meta_cow_start(m
) + m
->cow_start
.nb_bytes
!= offset
) {
2030 /* The end region must be immediately after the data (middle)
2032 if (m
->offset
+ m
->cow_end
.offset
!= offset
+ bytes
) {
2036 /* Make sure that adding both COW regions to the QEMUIOVector
2037 * does not exceed IOV_MAX */
2038 if (hd_qiov
->niov
> IOV_MAX
- 2) {
2042 m
->data_qiov
= hd_qiov
;
2049 static coroutine_fn
int qcow2_co_pwritev(BlockDriverState
*bs
, uint64_t offset
,
2050 uint64_t bytes
, QEMUIOVector
*qiov
,
2053 BDRVQcow2State
*s
= bs
->opaque
;
2054 int offset_in_cluster
;
2056 unsigned int cur_bytes
; /* number of sectors in current iteration */
2057 uint64_t cluster_offset
;
2058 QEMUIOVector hd_qiov
;
2059 uint64_t bytes_done
= 0;
2060 uint8_t *cluster_data
= NULL
;
2061 QCowL2Meta
*l2meta
= NULL
;
2063 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset
, bytes
);
2065 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
2067 qemu_co_mutex_lock(&s
->lock
);
2069 while (bytes
!= 0) {
2073 trace_qcow2_writev_start_part(qemu_coroutine_self());
2074 offset_in_cluster
= offset_into_cluster(s
, offset
);
2075 cur_bytes
= MIN(bytes
, INT_MAX
);
2076 if (bs
->encrypted
) {
2077 cur_bytes
= MIN(cur_bytes
,
2078 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
2079 - offset_in_cluster
);
2082 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2083 &cluster_offset
, &l2meta
);
2088 assert((cluster_offset
& 511) == 0);
2090 qemu_iovec_reset(&hd_qiov
);
2091 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
2093 if (bs
->encrypted
) {
2095 if (!cluster_data
) {
2096 cluster_data
= qemu_try_blockalign(bs
->file
->bs
,
2097 QCOW_MAX_CRYPT_CLUSTERS
2099 if (cluster_data
== NULL
) {
2105 assert(hd_qiov
.size
<=
2106 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2107 qemu_iovec_to_buf(&hd_qiov
, 0, cluster_data
, hd_qiov
.size
);
2109 if (qcrypto_block_encrypt(s
->crypto
,
2110 (s
->crypt_physical_offset
?
2111 cluster_offset
+ offset_in_cluster
:
2114 cur_bytes
, NULL
) < 0) {
2119 qemu_iovec_reset(&hd_qiov
);
2120 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
2123 ret
= qcow2_pre_write_overlap_check(bs
, 0,
2124 cluster_offset
+ offset_in_cluster
, cur_bytes
);
2129 /* If we need to do COW, check if it's possible to merge the
2130 * writing of the guest data together with that of the COW regions.
2131 * If it's not possible (or not necessary) then write the
2132 * guest data now. */
2133 if (!merge_cow(offset
, cur_bytes
, &hd_qiov
, l2meta
)) {
2134 qemu_co_mutex_unlock(&s
->lock
);
2135 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
2136 trace_qcow2_writev_data(qemu_coroutine_self(),
2137 cluster_offset
+ offset_in_cluster
);
2138 ret
= bdrv_co_pwritev(bs
->file
,
2139 cluster_offset
+ offset_in_cluster
,
2140 cur_bytes
, &hd_qiov
, 0);
2141 qemu_co_mutex_lock(&s
->lock
);
2147 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
2153 offset
+= cur_bytes
;
2154 bytes_done
+= cur_bytes
;
2155 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes
);
2160 qcow2_handle_l2meta(bs
, &l2meta
, false);
2162 qemu_co_mutex_unlock(&s
->lock
);
2164 qemu_iovec_destroy(&hd_qiov
);
2165 qemu_vfree(cluster_data
);
2166 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
2171 static int qcow2_inactivate(BlockDriverState
*bs
)
2173 BDRVQcow2State
*s
= bs
->opaque
;
2174 int ret
, result
= 0;
2175 Error
*local_err
= NULL
;
2177 qcow2_store_persistent_dirty_bitmaps(bs
, &local_err
);
2178 if (local_err
!= NULL
) {
2180 error_reportf_err(local_err
, "Lost persistent bitmaps during "
2181 "inactivation of node '%s': ",
2182 bdrv_get_device_or_node_name(bs
));
2185 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
2188 error_report("Failed to flush the L2 table cache: %s",
2192 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
2195 error_report("Failed to flush the refcount block cache: %s",
2200 qcow2_mark_clean(bs
);
2206 static void qcow2_close(BlockDriverState
*bs
)
2208 BDRVQcow2State
*s
= bs
->opaque
;
2209 qemu_vfree(s
->l1_table
);
2210 /* else pre-write overlap checks in cache_destroy may crash */
2213 if (!(s
->flags
& BDRV_O_INACTIVE
)) {
2214 qcow2_inactivate(bs
);
2217 cache_clean_timer_del(bs
);
2218 qcow2_cache_destroy(s
->l2_table_cache
);
2219 qcow2_cache_destroy(s
->refcount_block_cache
);
2221 qcrypto_block_free(s
->crypto
);
2224 g_free(s
->unknown_header_fields
);
2225 cleanup_unknown_header_ext(bs
);
2227 g_free(s
->image_backing_file
);
2228 g_free(s
->image_backing_format
);
2230 qcow2_refcount_close(bs
);
2231 qcow2_free_snapshots(bs
);
2234 static void coroutine_fn
qcow2_co_invalidate_cache(BlockDriverState
*bs
,
2237 BDRVQcow2State
*s
= bs
->opaque
;
2238 int flags
= s
->flags
;
2239 QCryptoBlock
*crypto
= NULL
;
2241 Error
*local_err
= NULL
;
2245 * Backing files are read-only which makes all of their metadata immutable,
2246 * that means we don't have to worry about reopening them here.
2254 memset(s
, 0, sizeof(BDRVQcow2State
));
2255 options
= qdict_clone_shallow(bs
->options
);
2257 flags
&= ~BDRV_O_INACTIVE
;
2258 qemu_co_mutex_lock(&s
->lock
);
2259 ret
= qcow2_do_open(bs
, options
, flags
, &local_err
);
2260 qemu_co_mutex_unlock(&s
->lock
);
2261 qobject_unref(options
);
2263 error_propagate_prepend(errp
, local_err
,
2264 "Could not reopen qcow2 layer: ");
2267 } else if (ret
< 0) {
2268 error_setg_errno(errp
, -ret
, "Could not reopen qcow2 layer");
2276 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
2277 size_t len
, size_t buflen
)
2279 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
2280 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
2282 if (buflen
< ext_len
) {
2286 *ext_backing_fmt
= (QCowExtension
) {
2287 .magic
= cpu_to_be32(magic
),
2288 .len
= cpu_to_be32(len
),
2292 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
2299 * Updates the qcow2 header, including the variable length parts of it, i.e.
2300 * the backing file name and all extensions. qcow2 was not designed to allow
2301 * such changes, so if we run out of space (we can only use the first cluster)
2302 * this function may fail.
2304 * Returns 0 on success, -errno in error cases.
2306 int qcow2_update_header(BlockDriverState
*bs
)
2308 BDRVQcow2State
*s
= bs
->opaque
;
2311 size_t buflen
= s
->cluster_size
;
2313 uint64_t total_size
;
2314 uint32_t refcount_table_clusters
;
2315 size_t header_length
;
2316 Qcow2UnknownHeaderExtension
*uext
;
2318 buf
= qemu_blockalign(bs
, buflen
);
2320 /* Header structure */
2321 header
= (QCowHeader
*) buf
;
2323 if (buflen
< sizeof(*header
)) {
2328 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
2329 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2330 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
2332 *header
= (QCowHeader
) {
2333 /* Version 2 fields */
2334 .magic
= cpu_to_be32(QCOW_MAGIC
),
2335 .version
= cpu_to_be32(s
->qcow_version
),
2336 .backing_file_offset
= 0,
2337 .backing_file_size
= 0,
2338 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
2339 .size
= cpu_to_be64(total_size
),
2340 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
2341 .l1_size
= cpu_to_be32(s
->l1_size
),
2342 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
2343 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
2344 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
2345 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
2346 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
2348 /* Version 3 fields */
2349 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
2350 .compatible_features
= cpu_to_be64(s
->compatible_features
),
2351 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
2352 .refcount_order
= cpu_to_be32(s
->refcount_order
),
2353 .header_length
= cpu_to_be32(header_length
),
2356 /* For older versions, write a shorter header */
2357 switch (s
->qcow_version
) {
2359 ret
= offsetof(QCowHeader
, incompatible_features
);
2362 ret
= sizeof(*header
);
2371 memset(buf
, 0, buflen
);
2373 /* Preserve any unknown field in the header */
2374 if (s
->unknown_header_fields_size
) {
2375 if (buflen
< s
->unknown_header_fields_size
) {
2380 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
2381 buf
+= s
->unknown_header_fields_size
;
2382 buflen
-= s
->unknown_header_fields_size
;
2385 /* Backing file format header extension */
2386 if (s
->image_backing_format
) {
2387 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
2388 s
->image_backing_format
,
2389 strlen(s
->image_backing_format
),
2399 /* Full disk encryption header pointer extension */
2400 if (s
->crypto_header
.offset
!= 0) {
2401 s
->crypto_header
.offset
= cpu_to_be64(s
->crypto_header
.offset
);
2402 s
->crypto_header
.length
= cpu_to_be64(s
->crypto_header
.length
);
2403 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_CRYPTO_HEADER
,
2404 &s
->crypto_header
, sizeof(s
->crypto_header
),
2406 s
->crypto_header
.offset
= be64_to_cpu(s
->crypto_header
.offset
);
2407 s
->crypto_header
.length
= be64_to_cpu(s
->crypto_header
.length
);
2416 if (s
->qcow_version
>= 3) {
2417 Qcow2Feature features
[] = {
2419 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2420 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
2421 .name
= "dirty bit",
2424 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2425 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
2426 .name
= "corrupt bit",
2429 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
2430 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
2431 .name
= "lazy refcounts",
2435 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
2436 features
, sizeof(features
), buflen
);
2444 /* Bitmap extension */
2445 if (s
->nb_bitmaps
> 0) {
2446 Qcow2BitmapHeaderExt bitmaps_header
= {
2447 .nb_bitmaps
= cpu_to_be32(s
->nb_bitmaps
),
2448 .bitmap_directory_size
=
2449 cpu_to_be64(s
->bitmap_directory_size
),
2450 .bitmap_directory_offset
=
2451 cpu_to_be64(s
->bitmap_directory_offset
)
2453 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BITMAPS
,
2454 &bitmaps_header
, sizeof(bitmaps_header
),
2463 /* Keep unknown header extensions */
2464 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
2465 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
2474 /* End of header extensions */
2475 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
2483 /* Backing file name */
2484 if (s
->image_backing_file
) {
2485 size_t backing_file_len
= strlen(s
->image_backing_file
);
2487 if (buflen
< backing_file_len
) {
2492 /* Using strncpy is ok here, since buf is not NUL-terminated. */
2493 strncpy(buf
, s
->image_backing_file
, buflen
);
2495 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
2496 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
2499 /* Write the new header */
2500 ret
= bdrv_pwrite(bs
->file
, 0, header
, s
->cluster_size
);
2511 static int qcow2_change_backing_file(BlockDriverState
*bs
,
2512 const char *backing_file
, const char *backing_fmt
)
2514 BDRVQcow2State
*s
= bs
->opaque
;
2516 if (backing_file
&& strlen(backing_file
) > 1023) {
2520 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2521 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2523 g_free(s
->image_backing_file
);
2524 g_free(s
->image_backing_format
);
2526 s
->image_backing_file
= backing_file
? g_strdup(bs
->backing_file
) : NULL
;
2527 s
->image_backing_format
= backing_fmt
? g_strdup(bs
->backing_format
) : NULL
;
2529 return qcow2_update_header(bs
);
2532 static int qcow2_crypt_method_from_format(const char *encryptfmt
)
2534 if (g_str_equal(encryptfmt
, "luks")) {
2535 return QCOW_CRYPT_LUKS
;
2536 } else if (g_str_equal(encryptfmt
, "aes")) {
2537 return QCOW_CRYPT_AES
;
2543 static int qcow2_set_up_encryption(BlockDriverState
*bs
,
2544 QCryptoBlockCreateOptions
*cryptoopts
,
2547 BDRVQcow2State
*s
= bs
->opaque
;
2548 QCryptoBlock
*crypto
= NULL
;
2551 switch (cryptoopts
->format
) {
2552 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
2553 fmt
= QCOW_CRYPT_LUKS
;
2555 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
2556 fmt
= QCOW_CRYPT_AES
;
2559 error_setg(errp
, "Crypto format not supported in qcow2");
2563 s
->crypt_method_header
= fmt
;
2565 crypto
= qcrypto_block_create(cryptoopts
, "encrypt.",
2566 qcow2_crypto_hdr_init_func
,
2567 qcow2_crypto_hdr_write_func
,
2573 ret
= qcow2_update_header(bs
);
2575 error_setg_errno(errp
, -ret
, "Could not write encryption header");
2581 qcrypto_block_free(crypto
);
2586 * Preallocates metadata structures for data clusters between @offset (in the
2587 * guest disk) and @new_length (which is thus generally the new guest disk
2590 * Returns: 0 on success, -errno on failure.
2592 static int coroutine_fn
preallocate_co(BlockDriverState
*bs
, uint64_t offset
,
2593 uint64_t new_length
)
2596 uint64_t host_offset
= 0;
2597 unsigned int cur_bytes
;
2601 assert(offset
<= new_length
);
2602 bytes
= new_length
- offset
;
2605 cur_bytes
= MIN(bytes
, INT_MAX
);
2606 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2607 &host_offset
, &meta
);
2613 QCowL2Meta
*next
= meta
->next
;
2615 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
2617 qcow2_free_any_clusters(bs
, meta
->alloc_offset
,
2618 meta
->nb_clusters
, QCOW2_DISCARD_NEVER
);
2622 /* There are no dependent requests, but we need to remove our
2623 * request from the list of in-flight requests */
2624 QLIST_REMOVE(meta
, next_in_flight
);
2630 /* TODO Preallocate data if requested */
2633 offset
+= cur_bytes
;
2637 * It is expected that the image file is large enough to actually contain
2638 * all of the allocated clusters (otherwise we get failing reads after
2639 * EOF). Extend the image to the last allocated sector.
2641 if (host_offset
!= 0) {
2643 ret
= bdrv_pwrite(bs
->file
, (host_offset
+ cur_bytes
) - 1,
2653 /* qcow2_refcount_metadata_size:
2654 * @clusters: number of clusters to refcount (including data and L1/L2 tables)
2655 * @cluster_size: size of a cluster, in bytes
2656 * @refcount_order: refcount bits power-of-2 exponent
2657 * @generous_increase: allow for the refcount table to be 1.5x as large as it
2660 * Returns: Number of bytes required for refcount blocks and table metadata.
2662 int64_t qcow2_refcount_metadata_size(int64_t clusters
, size_t cluster_size
,
2663 int refcount_order
, bool generous_increase
,
2664 uint64_t *refblock_count
)
2667 * Every host cluster is reference-counted, including metadata (even
2668 * refcount metadata is recursively included).
2670 * An accurate formula for the size of refcount metadata size is difficult
2671 * to derive. An easier method of calculation is finding the fixed point
2672 * where no further refcount blocks or table clusters are required to
2673 * reference count every cluster.
2675 int64_t blocks_per_table_cluster
= cluster_size
/ sizeof(uint64_t);
2676 int64_t refcounts_per_block
= cluster_size
* 8 / (1 << refcount_order
);
2677 int64_t table
= 0; /* number of refcount table clusters */
2678 int64_t blocks
= 0; /* number of refcount block clusters */
2684 blocks
= DIV_ROUND_UP(clusters
+ table
+ blocks
, refcounts_per_block
);
2685 table
= DIV_ROUND_UP(blocks
, blocks_per_table_cluster
);
2686 n
= clusters
+ blocks
+ table
;
2688 if (n
== last
&& generous_increase
) {
2689 clusters
+= DIV_ROUND_UP(table
, 2);
2690 n
= 0; /* force another loop */
2691 generous_increase
= false;
2693 } while (n
!= last
);
2695 if (refblock_count
) {
2696 *refblock_count
= blocks
;
2699 return (blocks
+ table
) * cluster_size
;
2703 * qcow2_calc_prealloc_size:
2704 * @total_size: virtual disk size in bytes
2705 * @cluster_size: cluster size in bytes
2706 * @refcount_order: refcount bits power-of-2 exponent
2708 * Returns: Total number of bytes required for the fully allocated image
2709 * (including metadata).
2711 static int64_t qcow2_calc_prealloc_size(int64_t total_size
,
2712 size_t cluster_size
,
2715 int64_t meta_size
= 0;
2716 uint64_t nl1e
, nl2e
;
2717 int64_t aligned_total_size
= ROUND_UP(total_size
, cluster_size
);
2719 /* header: 1 cluster */
2720 meta_size
+= cluster_size
;
2722 /* total size of L2 tables */
2723 nl2e
= aligned_total_size
/ cluster_size
;
2724 nl2e
= ROUND_UP(nl2e
, cluster_size
/ sizeof(uint64_t));
2725 meta_size
+= nl2e
* sizeof(uint64_t);
2727 /* total size of L1 tables */
2728 nl1e
= nl2e
* sizeof(uint64_t) / cluster_size
;
2729 nl1e
= ROUND_UP(nl1e
, cluster_size
/ sizeof(uint64_t));
2730 meta_size
+= nl1e
* sizeof(uint64_t);
2732 /* total size of refcount table and blocks */
2733 meta_size
+= qcow2_refcount_metadata_size(
2734 (meta_size
+ aligned_total_size
) / cluster_size
,
2735 cluster_size
, refcount_order
, false, NULL
);
2737 return meta_size
+ aligned_total_size
;
2740 static bool validate_cluster_size(size_t cluster_size
, Error
**errp
)
2742 int cluster_bits
= ctz32(cluster_size
);
2743 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
2744 (1 << cluster_bits
) != cluster_size
)
2746 error_setg(errp
, "Cluster size must be a power of two between %d and "
2747 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
2753 static size_t qcow2_opt_get_cluster_size_del(QemuOpts
*opts
, Error
**errp
)
2755 size_t cluster_size
;
2757 cluster_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
2758 DEFAULT_CLUSTER_SIZE
);
2759 if (!validate_cluster_size(cluster_size
, errp
)) {
2762 return cluster_size
;
2765 static int qcow2_opt_get_version_del(QemuOpts
*opts
, Error
**errp
)
2770 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_COMPAT_LEVEL
);
2772 ret
= 3; /* default */
2773 } else if (!strcmp(buf
, "0.10")) {
2775 } else if (!strcmp(buf
, "1.1")) {
2778 error_setg(errp
, "Invalid compatibility level: '%s'", buf
);
2785 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts
*opts
, int version
,
2788 uint64_t refcount_bits
;
2790 refcount_bits
= qemu_opt_get_number_del(opts
, BLOCK_OPT_REFCOUNT_BITS
, 16);
2791 if (refcount_bits
> 64 || !is_power_of_2(refcount_bits
)) {
2792 error_setg(errp
, "Refcount width must be a power of two and may not "
2797 if (version
< 3 && refcount_bits
!= 16) {
2798 error_setg(errp
, "Different refcount widths than 16 bits require "
2799 "compatibility level 1.1 or above (use compat=1.1 or "
2804 return refcount_bits
;
2807 static int coroutine_fn
2808 qcow2_co_create(BlockdevCreateOptions
*create_options
, Error
**errp
)
2810 BlockdevCreateOptionsQcow2
*qcow2_opts
;
2814 * Open the image file and write a minimal qcow2 header.
2816 * We keep things simple and start with a zero-sized image. We also
2817 * do without refcount blocks or a L1 table for now. We'll fix the
2818 * inconsistency later.
2820 * We do need a refcount table because growing the refcount table means
2821 * allocating two new refcount blocks - the seconds of which would be at
2822 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
2823 * size for any qcow2 image.
2825 BlockBackend
*blk
= NULL
;
2826 BlockDriverState
*bs
= NULL
;
2828 size_t cluster_size
;
2831 uint64_t* refcount_table
;
2832 Error
*local_err
= NULL
;
2835 assert(create_options
->driver
== BLOCKDEV_DRIVER_QCOW2
);
2836 qcow2_opts
= &create_options
->u
.qcow2
;
2838 bs
= bdrv_open_blockdev_ref(qcow2_opts
->file
, errp
);
2843 /* Validate options and set default values */
2844 if (!QEMU_IS_ALIGNED(qcow2_opts
->size
, BDRV_SECTOR_SIZE
)) {
2845 error_setg(errp
, "Image size must be a multiple of 512 bytes");
2850 if (qcow2_opts
->has_version
) {
2851 switch (qcow2_opts
->version
) {
2852 case BLOCKDEV_QCOW2_VERSION_V2
:
2855 case BLOCKDEV_QCOW2_VERSION_V3
:
2859 g_assert_not_reached();
2865 if (qcow2_opts
->has_cluster_size
) {
2866 cluster_size
= qcow2_opts
->cluster_size
;
2868 cluster_size
= DEFAULT_CLUSTER_SIZE
;
2871 if (!validate_cluster_size(cluster_size
, errp
)) {
2876 if (!qcow2_opts
->has_preallocation
) {
2877 qcow2_opts
->preallocation
= PREALLOC_MODE_OFF
;
2879 if (qcow2_opts
->has_backing_file
&&
2880 qcow2_opts
->preallocation
!= PREALLOC_MODE_OFF
)
2882 error_setg(errp
, "Backing file and preallocation cannot be used at "
2887 if (qcow2_opts
->has_backing_fmt
&& !qcow2_opts
->has_backing_file
) {
2888 error_setg(errp
, "Backing format cannot be used without backing file");
2893 if (!qcow2_opts
->has_lazy_refcounts
) {
2894 qcow2_opts
->lazy_refcounts
= false;
2896 if (version
< 3 && qcow2_opts
->lazy_refcounts
) {
2897 error_setg(errp
, "Lazy refcounts only supported with compatibility "
2898 "level 1.1 and above (use version=v3 or greater)");
2903 if (!qcow2_opts
->has_refcount_bits
) {
2904 qcow2_opts
->refcount_bits
= 16;
2906 if (qcow2_opts
->refcount_bits
> 64 ||
2907 !is_power_of_2(qcow2_opts
->refcount_bits
))
2909 error_setg(errp
, "Refcount width must be a power of two and may not "
2914 if (version
< 3 && qcow2_opts
->refcount_bits
!= 16) {
2915 error_setg(errp
, "Different refcount widths than 16 bits require "
2916 "compatibility level 1.1 or above (use version=v3 or "
2921 refcount_order
= ctz32(qcow2_opts
->refcount_bits
);
2924 /* Create BlockBackend to write to the image */
2925 blk
= blk_new(BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
);
2926 ret
= blk_insert_bs(blk
, bs
, errp
);
2930 blk_set_allow_write_beyond_eof(blk
, true);
2932 /* Clear the protocol layer and preallocate it if necessary */
2933 ret
= blk_truncate(blk
, 0, PREALLOC_MODE_OFF
, errp
);
2938 if (qcow2_opts
->preallocation
== PREALLOC_MODE_FULL
||
2939 qcow2_opts
->preallocation
== PREALLOC_MODE_FALLOC
)
2941 int64_t prealloc_size
=
2942 qcow2_calc_prealloc_size(qcow2_opts
->size
, cluster_size
,
2945 ret
= blk_truncate(blk
, prealloc_size
, qcow2_opts
->preallocation
, errp
);
2951 /* Write the header */
2952 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS
) < sizeof(*header
));
2953 header
= g_malloc0(cluster_size
);
2954 *header
= (QCowHeader
) {
2955 .magic
= cpu_to_be32(QCOW_MAGIC
),
2956 .version
= cpu_to_be32(version
),
2957 .cluster_bits
= cpu_to_be32(ctz32(cluster_size
)),
2958 .size
= cpu_to_be64(0),
2959 .l1_table_offset
= cpu_to_be64(0),
2960 .l1_size
= cpu_to_be32(0),
2961 .refcount_table_offset
= cpu_to_be64(cluster_size
),
2962 .refcount_table_clusters
= cpu_to_be32(1),
2963 .refcount_order
= cpu_to_be32(refcount_order
),
2964 .header_length
= cpu_to_be32(sizeof(*header
)),
2967 /* We'll update this to correct value later */
2968 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
2970 if (qcow2_opts
->lazy_refcounts
) {
2971 header
->compatible_features
|=
2972 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
2975 ret
= blk_pwrite(blk
, 0, header
, cluster_size
, 0);
2978 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
2982 /* Write a refcount table with one refcount block */
2983 refcount_table
= g_malloc0(2 * cluster_size
);
2984 refcount_table
[0] = cpu_to_be64(2 * cluster_size
);
2985 ret
= blk_pwrite(blk
, cluster_size
, refcount_table
, 2 * cluster_size
, 0);
2986 g_free(refcount_table
);
2989 error_setg_errno(errp
, -ret
, "Could not write refcount table");
2997 * And now open the image and make it consistent first (i.e. increase the
2998 * refcount of the cluster that is occupied by the header and the refcount
3001 options
= qdict_new();
3002 qdict_put_str(options
, "driver", "qcow2");
3003 qdict_put_str(options
, "file", bs
->node_name
);
3004 blk
= blk_new_open(NULL
, NULL
, options
,
3005 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_NO_FLUSH
,
3008 error_propagate(errp
, local_err
);
3013 ret
= qcow2_alloc_clusters(blk_bs(blk
), 3 * cluster_size
);
3015 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
3016 "header and refcount table");
3019 } else if (ret
!= 0) {
3020 error_report("Huh, first cluster in empty image is already in use?");
3024 /* Create a full header (including things like feature table) */
3025 ret
= qcow2_update_header(blk_bs(blk
));
3027 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
3031 /* Okay, now that we have a valid image, let's give it the right size */
3032 ret
= blk_truncate(blk
, qcow2_opts
->size
, PREALLOC_MODE_OFF
, errp
);
3034 error_prepend(errp
, "Could not resize image: ");
3038 /* Want a backing file? There you go.*/
3039 if (qcow2_opts
->has_backing_file
) {
3040 const char *backing_format
= NULL
;
3042 if (qcow2_opts
->has_backing_fmt
) {
3043 backing_format
= BlockdevDriver_str(qcow2_opts
->backing_fmt
);
3046 ret
= bdrv_change_backing_file(blk_bs(blk
), qcow2_opts
->backing_file
,
3049 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
3050 "with format '%s'", qcow2_opts
->backing_file
,
3056 /* Want encryption? There you go. */
3057 if (qcow2_opts
->has_encrypt
) {
3058 ret
= qcow2_set_up_encryption(blk_bs(blk
), qcow2_opts
->encrypt
, errp
);
3064 /* And if we're supposed to preallocate metadata, do that now */
3065 if (qcow2_opts
->preallocation
!= PREALLOC_MODE_OFF
) {
3066 BDRVQcow2State
*s
= blk_bs(blk
)->opaque
;
3067 qemu_co_mutex_lock(&s
->lock
);
3068 ret
= preallocate_co(blk_bs(blk
), 0, qcow2_opts
->size
);
3069 qemu_co_mutex_unlock(&s
->lock
);
3072 error_setg_errno(errp
, -ret
, "Could not preallocate metadata");
3080 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
3081 * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
3082 * have to setup decryption context. We're not doing any I/O on the top
3083 * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
3086 options
= qdict_new();
3087 qdict_put_str(options
, "driver", "qcow2");
3088 qdict_put_str(options
, "file", bs
->node_name
);
3089 blk
= blk_new_open(NULL
, NULL
, options
,
3090 BDRV_O_RDWR
| BDRV_O_NO_BACKING
| BDRV_O_NO_IO
,
3093 error_propagate(errp
, local_err
);
3105 static int coroutine_fn
qcow2_co_create_opts(const char *filename
, QemuOpts
*opts
,
3108 BlockdevCreateOptions
*create_options
= NULL
;
3111 BlockDriverState
*bs
= NULL
;
3112 Error
*local_err
= NULL
;
3116 /* Only the keyval visitor supports the dotted syntax needed for
3117 * encryption, so go through a QDict before getting a QAPI type. Ignore
3118 * options meant for the protocol layer so that the visitor doesn't
3120 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, bdrv_qcow2
.create_opts
,
3123 /* Handle encryption options */
3124 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT
);
3125 if (val
&& !strcmp(val
, "on")) {
3126 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT
, "qcow");
3127 } else if (val
&& !strcmp(val
, "off")) {
3128 qdict_del(qdict
, BLOCK_OPT_ENCRYPT
);
3131 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
);
3132 if (val
&& !strcmp(val
, "aes")) {
3133 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
, "qcow");
3136 /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into
3137 * version=v2/v3 below. */
3138 val
= qdict_get_try_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
);
3139 if (val
&& !strcmp(val
, "0.10")) {
3140 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v2");
3141 } else if (val
&& !strcmp(val
, "1.1")) {
3142 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v3");
3145 /* Change legacy command line options into QMP ones */
3146 static const QDictRenames opt_renames
[] = {
3147 { BLOCK_OPT_BACKING_FILE
, "backing-file" },
3148 { BLOCK_OPT_BACKING_FMT
, "backing-fmt" },
3149 { BLOCK_OPT_CLUSTER_SIZE
, "cluster-size" },
3150 { BLOCK_OPT_LAZY_REFCOUNTS
, "lazy-refcounts" },
3151 { BLOCK_OPT_REFCOUNT_BITS
, "refcount-bits" },
3152 { BLOCK_OPT_ENCRYPT
, BLOCK_OPT_ENCRYPT_FORMAT
},
3153 { BLOCK_OPT_COMPAT_LEVEL
, "version" },
3157 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
3162 /* Create and open the file (protocol layer) */
3163 ret
= bdrv_create_file(filename
, opts
, errp
);
3168 bs
= bdrv_open(filename
, NULL
, NULL
,
3169 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
3175 /* Set 'driver' and 'node' options */
3176 qdict_put_str(qdict
, "driver", "qcow2");
3177 qdict_put_str(qdict
, "file", bs
->node_name
);
3179 /* Now get the QAPI type BlockdevCreateOptions */
3180 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
3186 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, &local_err
);
3190 error_propagate(errp
, local_err
);
3195 /* Silently round up size */
3196 create_options
->u
.qcow2
.size
= ROUND_UP(create_options
->u
.qcow2
.size
,
3199 /* Create the qcow2 image (format layer) */
3200 ret
= qcow2_co_create(create_options
, errp
);
3207 qobject_unref(qdict
);
3209 qapi_free_BlockdevCreateOptions(create_options
);
3214 static bool is_zero(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
3219 /* Clamp to image length, before checking status of underlying sectors */
3220 if (offset
+ bytes
> bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3221 bytes
= bs
->total_sectors
* BDRV_SECTOR_SIZE
- offset
;
3227 res
= bdrv_block_status_above(bs
, NULL
, offset
, bytes
, &nr
, NULL
, NULL
);
3228 return res
>= 0 && (res
& BDRV_BLOCK_ZERO
) && nr
== bytes
;
3231 static coroutine_fn
int qcow2_co_pwrite_zeroes(BlockDriverState
*bs
,
3232 int64_t offset
, int bytes
, BdrvRequestFlags flags
)
3235 BDRVQcow2State
*s
= bs
->opaque
;
3237 uint32_t head
= offset
% s
->cluster_size
;
3238 uint32_t tail
= (offset
+ bytes
) % s
->cluster_size
;
3240 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset
, bytes
);
3241 if (offset
+ bytes
== bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3249 assert(head
+ bytes
<= s
->cluster_size
);
3251 /* check whether remainder of cluster already reads as zero */
3252 if (!(is_zero(bs
, offset
- head
, head
) &&
3253 is_zero(bs
, offset
+ bytes
,
3254 tail
? s
->cluster_size
- tail
: 0))) {
3258 qemu_co_mutex_lock(&s
->lock
);
3259 /* We can have new write after previous check */
3260 offset
= QEMU_ALIGN_DOWN(offset
, s
->cluster_size
);
3261 bytes
= s
->cluster_size
;
3262 nr
= s
->cluster_size
;
3263 ret
= qcow2_get_cluster_offset(bs
, offset
, &nr
, &off
);
3264 if (ret
!= QCOW2_CLUSTER_UNALLOCATED
&&
3265 ret
!= QCOW2_CLUSTER_ZERO_PLAIN
&&
3266 ret
!= QCOW2_CLUSTER_ZERO_ALLOC
) {
3267 qemu_co_mutex_unlock(&s
->lock
);
3271 qemu_co_mutex_lock(&s
->lock
);
3274 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset
, bytes
);
3276 /* Whatever is left can use real zero clusters */
3277 ret
= qcow2_cluster_zeroize(bs
, offset
, bytes
, flags
);
3278 qemu_co_mutex_unlock(&s
->lock
);
3283 static coroutine_fn
int qcow2_co_pdiscard(BlockDriverState
*bs
,
3284 int64_t offset
, int bytes
)
3287 BDRVQcow2State
*s
= bs
->opaque
;
3289 if (!QEMU_IS_ALIGNED(offset
| bytes
, s
->cluster_size
)) {
3290 assert(bytes
< s
->cluster_size
);
3291 /* Ignore partial clusters, except for the special case of the
3292 * complete partial cluster at the end of an unaligned file */
3293 if (!QEMU_IS_ALIGNED(offset
, s
->cluster_size
) ||
3294 offset
+ bytes
!= bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3299 qemu_co_mutex_lock(&s
->lock
);
3300 ret
= qcow2_cluster_discard(bs
, offset
, bytes
, QCOW2_DISCARD_REQUEST
,
3302 qemu_co_mutex_unlock(&s
->lock
);
3306 static int coroutine_fn
3307 qcow2_co_copy_range_from(BlockDriverState
*bs
,
3308 BdrvChild
*src
, uint64_t src_offset
,
3309 BdrvChild
*dst
, uint64_t dst_offset
,
3310 uint64_t bytes
, BdrvRequestFlags read_flags
,
3311 BdrvRequestFlags write_flags
)
3313 BDRVQcow2State
*s
= bs
->opaque
;
3315 unsigned int cur_bytes
; /* number of bytes in current iteration */
3316 BdrvChild
*child
= NULL
;
3317 BdrvRequestFlags cur_write_flags
;
3319 assert(!bs
->encrypted
);
3320 qemu_co_mutex_lock(&s
->lock
);
3322 while (bytes
!= 0) {
3323 uint64_t copy_offset
= 0;
3324 /* prepare next request */
3325 cur_bytes
= MIN(bytes
, INT_MAX
);
3326 cur_write_flags
= write_flags
;
3328 ret
= qcow2_get_cluster_offset(bs
, src_offset
, &cur_bytes
, ©_offset
);
3334 case QCOW2_CLUSTER_UNALLOCATED
:
3335 if (bs
->backing
&& bs
->backing
->bs
) {
3336 int64_t backing_length
= bdrv_getlength(bs
->backing
->bs
);
3337 if (src_offset
>= backing_length
) {
3338 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
3340 child
= bs
->backing
;
3341 cur_bytes
= MIN(cur_bytes
, backing_length
- src_offset
);
3342 copy_offset
= src_offset
;
3345 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
3349 case QCOW2_CLUSTER_ZERO_PLAIN
:
3350 case QCOW2_CLUSTER_ZERO_ALLOC
:
3351 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
3354 case QCOW2_CLUSTER_COMPRESSED
:
3358 case QCOW2_CLUSTER_NORMAL
:
3360 copy_offset
+= offset_into_cluster(s
, src_offset
);
3361 if ((copy_offset
& 511) != 0) {
3370 qemu_co_mutex_unlock(&s
->lock
);
3371 ret
= bdrv_co_copy_range_from(child
,
3374 cur_bytes
, read_flags
, cur_write_flags
);
3375 qemu_co_mutex_lock(&s
->lock
);
3381 src_offset
+= cur_bytes
;
3382 dst_offset
+= cur_bytes
;
3387 qemu_co_mutex_unlock(&s
->lock
);
3391 static int coroutine_fn
3392 qcow2_co_copy_range_to(BlockDriverState
*bs
,
3393 BdrvChild
*src
, uint64_t src_offset
,
3394 BdrvChild
*dst
, uint64_t dst_offset
,
3395 uint64_t bytes
, BdrvRequestFlags read_flags
,
3396 BdrvRequestFlags write_flags
)
3398 BDRVQcow2State
*s
= bs
->opaque
;
3399 int offset_in_cluster
;
3401 unsigned int cur_bytes
; /* number of sectors in current iteration */
3402 uint64_t cluster_offset
;
3403 QCowL2Meta
*l2meta
= NULL
;
3405 assert(!bs
->encrypted
);
3407 qemu_co_mutex_lock(&s
->lock
);
3409 while (bytes
!= 0) {
3413 offset_in_cluster
= offset_into_cluster(s
, dst_offset
);
3414 cur_bytes
= MIN(bytes
, INT_MAX
);
3417 * If src->bs == dst->bs, we could simply copy by incrementing
3418 * the refcnt, without copying user data.
3419 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
3420 ret
= qcow2_alloc_cluster_offset(bs
, dst_offset
, &cur_bytes
,
3421 &cluster_offset
, &l2meta
);
3426 assert((cluster_offset
& 511) == 0);
3428 ret
= qcow2_pre_write_overlap_check(bs
, 0,
3429 cluster_offset
+ offset_in_cluster
, cur_bytes
);
3434 qemu_co_mutex_unlock(&s
->lock
);
3435 ret
= bdrv_co_copy_range_to(src
, src_offset
,
3437 cluster_offset
+ offset_in_cluster
,
3438 cur_bytes
, read_flags
, write_flags
);
3439 qemu_co_mutex_lock(&s
->lock
);
3444 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
3450 src_offset
+= cur_bytes
;
3451 dst_offset
+= cur_bytes
;
3456 qcow2_handle_l2meta(bs
, &l2meta
, false);
3458 qemu_co_mutex_unlock(&s
->lock
);
3460 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
3465 static int coroutine_fn
qcow2_co_truncate(BlockDriverState
*bs
, int64_t offset
,
3466 PreallocMode prealloc
, Error
**errp
)
3468 BDRVQcow2State
*s
= bs
->opaque
;
3469 uint64_t old_length
;
3470 int64_t new_l1_size
;
3474 if (prealloc
!= PREALLOC_MODE_OFF
&& prealloc
!= PREALLOC_MODE_METADATA
&&
3475 prealloc
!= PREALLOC_MODE_FALLOC
&& prealloc
!= PREALLOC_MODE_FULL
)
3477 error_setg(errp
, "Unsupported preallocation mode '%s'",
3478 PreallocMode_str(prealloc
));
3483 error_setg(errp
, "The new size must be a multiple of 512");
3487 qemu_co_mutex_lock(&s
->lock
);
3489 /* cannot proceed if image has snapshots */
3490 if (s
->nb_snapshots
) {
3491 error_setg(errp
, "Can't resize an image which has snapshots");
3496 /* cannot proceed if image has bitmaps */
3497 if (s
->nb_bitmaps
) {
3498 /* TODO: resize bitmaps in the image */
3499 error_setg(errp
, "Can't resize an image which has bitmaps");
3504 old_length
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3505 new_l1_size
= size_to_l1(s
, offset
);
3507 if (offset
< old_length
) {
3508 int64_t last_cluster
, old_file_size
;
3509 if (prealloc
!= PREALLOC_MODE_OFF
) {
3511 "Preallocation can't be used for shrinking an image");
3516 ret
= qcow2_cluster_discard(bs
, ROUND_UP(offset
, s
->cluster_size
),
3517 old_length
- ROUND_UP(offset
,
3519 QCOW2_DISCARD_ALWAYS
, true);
3521 error_setg_errno(errp
, -ret
, "Failed to discard cropped clusters");
3525 ret
= qcow2_shrink_l1_table(bs
, new_l1_size
);
3527 error_setg_errno(errp
, -ret
,
3528 "Failed to reduce the number of L2 tables");
3532 ret
= qcow2_shrink_reftable(bs
);
3534 error_setg_errno(errp
, -ret
,
3535 "Failed to discard unused refblocks");
3539 old_file_size
= bdrv_getlength(bs
->file
->bs
);
3540 if (old_file_size
< 0) {
3541 error_setg_errno(errp
, -old_file_size
,
3542 "Failed to inquire current file length");
3543 ret
= old_file_size
;
3546 last_cluster
= qcow2_get_last_cluster(bs
, old_file_size
);
3547 if (last_cluster
< 0) {
3548 error_setg_errno(errp
, -last_cluster
,
3549 "Failed to find the last cluster");
3553 if ((last_cluster
+ 1) * s
->cluster_size
< old_file_size
) {
3554 Error
*local_err
= NULL
;
3556 bdrv_co_truncate(bs
->file
, (last_cluster
+ 1) * s
->cluster_size
,
3557 PREALLOC_MODE_OFF
, &local_err
);
3559 warn_reportf_err(local_err
,
3560 "Failed to truncate the tail of the image: ");
3564 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
3566 error_setg_errno(errp
, -ret
, "Failed to grow the L1 table");
3572 case PREALLOC_MODE_OFF
:
3575 case PREALLOC_MODE_METADATA
:
3576 ret
= preallocate_co(bs
, old_length
, offset
);
3578 error_setg_errno(errp
, -ret
, "Preallocation failed");
3583 case PREALLOC_MODE_FALLOC
:
3584 case PREALLOC_MODE_FULL
:
3586 int64_t allocation_start
, host_offset
, guest_offset
;
3587 int64_t clusters_allocated
;
3588 int64_t old_file_size
, new_file_size
;
3589 uint64_t nb_new_data_clusters
, nb_new_l2_tables
;
3591 old_file_size
= bdrv_getlength(bs
->file
->bs
);
3592 if (old_file_size
< 0) {
3593 error_setg_errno(errp
, -old_file_size
,
3594 "Failed to inquire current file length");
3595 ret
= old_file_size
;
3598 old_file_size
= ROUND_UP(old_file_size
, s
->cluster_size
);
3600 nb_new_data_clusters
= DIV_ROUND_UP(offset
- old_length
,
3603 /* This is an overestimation; we will not actually allocate space for
3604 * these in the file but just make sure the new refcount structures are
3605 * able to cover them so we will not have to allocate new refblocks
3606 * while entering the data blocks in the potentially new L2 tables.
3607 * (We do not actually care where the L2 tables are placed. Maybe they
3608 * are already allocated or they can be placed somewhere before
3609 * @old_file_size. It does not matter because they will be fully
3610 * allocated automatically, so they do not need to be covered by the
3611 * preallocation. All that matters is that we will not have to allocate
3612 * new refcount structures for them.) */
3613 nb_new_l2_tables
= DIV_ROUND_UP(nb_new_data_clusters
,
3614 s
->cluster_size
/ sizeof(uint64_t));
3615 /* The cluster range may not be aligned to L2 boundaries, so add one L2
3616 * table for a potential head/tail */
3619 allocation_start
= qcow2_refcount_area(bs
, old_file_size
,
3620 nb_new_data_clusters
+
3623 if (allocation_start
< 0) {
3624 error_setg_errno(errp
, -allocation_start
,
3625 "Failed to resize refcount structures");
3626 ret
= allocation_start
;
3630 clusters_allocated
= qcow2_alloc_clusters_at(bs
, allocation_start
,
3631 nb_new_data_clusters
);
3632 if (clusters_allocated
< 0) {
3633 error_setg_errno(errp
, -clusters_allocated
,
3634 "Failed to allocate data clusters");
3635 ret
= clusters_allocated
;
3639 assert(clusters_allocated
== nb_new_data_clusters
);
3641 /* Allocate the data area */
3642 new_file_size
= allocation_start
+
3643 nb_new_data_clusters
* s
->cluster_size
;
3644 ret
= bdrv_co_truncate(bs
->file
, new_file_size
, prealloc
, errp
);
3646 error_prepend(errp
, "Failed to resize underlying file: ");
3647 qcow2_free_clusters(bs
, allocation_start
,
3648 nb_new_data_clusters
* s
->cluster_size
,
3649 QCOW2_DISCARD_OTHER
);
3653 /* Create the necessary L2 entries */
3654 host_offset
= allocation_start
;
3655 guest_offset
= old_length
;
3656 while (nb_new_data_clusters
) {
3657 int64_t nb_clusters
= MIN(
3658 nb_new_data_clusters
,
3659 s
->l2_slice_size
- offset_to_l2_slice_index(s
, guest_offset
));
3660 QCowL2Meta allocation
= {
3661 .offset
= guest_offset
,
3662 .alloc_offset
= host_offset
,
3663 .nb_clusters
= nb_clusters
,
3665 qemu_co_queue_init(&allocation
.dependent_requests
);
3667 ret
= qcow2_alloc_cluster_link_l2(bs
, &allocation
);
3669 error_setg_errno(errp
, -ret
, "Failed to update L2 tables");
3670 qcow2_free_clusters(bs
, host_offset
,
3671 nb_new_data_clusters
* s
->cluster_size
,
3672 QCOW2_DISCARD_OTHER
);
3676 guest_offset
+= nb_clusters
* s
->cluster_size
;
3677 host_offset
+= nb_clusters
* s
->cluster_size
;
3678 nb_new_data_clusters
-= nb_clusters
;
3684 g_assert_not_reached();
3687 if (prealloc
!= PREALLOC_MODE_OFF
) {
3688 /* Flush metadata before actually changing the image size */
3689 ret
= qcow2_write_caches(bs
);
3691 error_setg_errno(errp
, -ret
,
3692 "Failed to flush the preallocated area to disk");
3697 bs
->total_sectors
= offset
/ BDRV_SECTOR_SIZE
;
3699 /* write updated header.size */
3700 offset
= cpu_to_be64(offset
);
3701 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
3702 &offset
, sizeof(uint64_t));
3704 error_setg_errno(errp
, -ret
, "Failed to update the image size");
3708 s
->l1_vm_state_index
= new_l1_size
;
3710 /* Update cache sizes */
3711 options
= qdict_clone_shallow(bs
->options
);
3712 ret
= qcow2_update_options(bs
, options
, s
->flags
, errp
);
3713 qobject_unref(options
);
3719 qemu_co_mutex_unlock(&s
->lock
);
3726 * @dest - destination buffer, @dest_size bytes
3727 * @src - source buffer, @src_size bytes
3729 * Returns: compressed size on success
3730 * -1 destination buffer is not enough to store compressed data
3731 * -2 on any other error
3733 static ssize_t
qcow2_compress(void *dest
, size_t dest_size
,
3734 const void *src
, size_t src_size
)
3739 /* best compression, small window, no zlib header */
3740 memset(&strm
, 0, sizeof(strm
));
3741 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
, Z_DEFLATED
,
3742 -12, 9, Z_DEFAULT_STRATEGY
);
3747 /* strm.next_in is not const in old zlib versions, such as those used on
3748 * OpenBSD/NetBSD, so cast the const away */
3749 strm
.avail_in
= src_size
;
3750 strm
.next_in
= (void *) src
;
3751 strm
.avail_out
= dest_size
;
3752 strm
.next_out
= dest
;
3754 ret
= deflate(&strm
, Z_FINISH
);
3755 if (ret
== Z_STREAM_END
) {
3756 ret
= dest_size
- strm
.avail_out
;
3758 ret
= (ret
== Z_OK
? -1 : -2);
3767 * qcow2_decompress()
3769 * Decompress some data (not more than @src_size bytes) to produce exactly
3772 * @dest - destination buffer, @dest_size bytes
3773 * @src - source buffer, @src_size bytes
3775 * Returns: 0 on success
3778 static ssize_t
qcow2_decompress(void *dest
, size_t dest_size
,
3779 const void *src
, size_t src_size
)
3784 memset(&strm
, 0, sizeof(strm
));
3785 strm
.avail_in
= src_size
;
3786 strm
.next_in
= (void *) src
;
3787 strm
.avail_out
= dest_size
;
3788 strm
.next_out
= dest
;
3790 ret
= inflateInit2(&strm
, -12);
3795 ret
= inflate(&strm
, Z_FINISH
);
3796 if ((ret
!= Z_STREAM_END
&& ret
!= Z_BUF_ERROR
) || strm
.avail_out
!= 0) {
3797 /* We approve Z_BUF_ERROR because we need @dest buffer to be filled, but
3798 * @src buffer may be processed partly (because in qcow2 we know size of
3799 * compressed data with precision of one sector) */
3808 #define MAX_COMPRESS_THREADS 4
3810 typedef ssize_t (*Qcow2CompressFunc
)(void *dest
, size_t dest_size
,
3811 const void *src
, size_t src_size
);
3812 typedef struct Qcow2CompressData
{
3819 Qcow2CompressFunc func
;
3820 } Qcow2CompressData
;
3822 static int qcow2_compress_pool_func(void *opaque
)
3824 Qcow2CompressData
*data
= opaque
;
3826 data
->ret
= data
->func(data
->dest
, data
->dest_size
,
3827 data
->src
, data
->src_size
);
3832 static void qcow2_compress_complete(void *opaque
, int ret
)
3834 qemu_coroutine_enter(opaque
);
3837 static ssize_t coroutine_fn
3838 qcow2_co_do_compress(BlockDriverState
*bs
, void *dest
, size_t dest_size
,
3839 const void *src
, size_t src_size
, Qcow2CompressFunc func
)
3841 BDRVQcow2State
*s
= bs
->opaque
;
3843 ThreadPool
*pool
= aio_get_thread_pool(bdrv_get_aio_context(bs
));
3844 Qcow2CompressData arg
= {
3846 .dest_size
= dest_size
,
3848 .src_size
= src_size
,
3852 while (s
->nb_compress_threads
>= MAX_COMPRESS_THREADS
) {
3853 qemu_co_queue_wait(&s
->compress_wait_queue
, NULL
);
3856 s
->nb_compress_threads
++;
3857 acb
= thread_pool_submit_aio(pool
, qcow2_compress_pool_func
, &arg
,
3858 qcow2_compress_complete
,
3859 qemu_coroutine_self());
3862 s
->nb_compress_threads
--;
3865 qemu_coroutine_yield();
3866 s
->nb_compress_threads
--;
3867 qemu_co_queue_next(&s
->compress_wait_queue
);
3872 static ssize_t coroutine_fn
3873 qcow2_co_compress(BlockDriverState
*bs
, void *dest
, size_t dest_size
,
3874 const void *src
, size_t src_size
)
3876 return qcow2_co_do_compress(bs
, dest
, dest_size
, src
, src_size
,
3880 static ssize_t coroutine_fn
3881 qcow2_co_decompress(BlockDriverState
*bs
, void *dest
, size_t dest_size
,
3882 const void *src
, size_t src_size
)
3884 return qcow2_co_do_compress(bs
, dest
, dest_size
, src
, src_size
,
3888 /* XXX: put compressed sectors first, then all the cluster aligned
3889 tables to avoid losing bytes in alignment */
3890 static coroutine_fn
int
3891 qcow2_co_pwritev_compressed(BlockDriverState
*bs
, uint64_t offset
,
3892 uint64_t bytes
, QEMUIOVector
*qiov
)
3894 BDRVQcow2State
*s
= bs
->opaque
;
3895 QEMUIOVector hd_qiov
;
3899 uint8_t *buf
, *out_buf
;
3900 int64_t cluster_offset
;
3903 /* align end of file to a sector boundary to ease reading with
3904 sector based I/Os */
3905 cluster_offset
= bdrv_getlength(bs
->file
->bs
);
3906 if (cluster_offset
< 0) {
3907 return cluster_offset
;
3909 return bdrv_co_truncate(bs
->file
, cluster_offset
, PREALLOC_MODE_OFF
,
3913 if (offset_into_cluster(s
, offset
)) {
3917 buf
= qemu_blockalign(bs
, s
->cluster_size
);
3918 if (bytes
!= s
->cluster_size
) {
3919 if (bytes
> s
->cluster_size
||
3920 offset
+ bytes
!= bs
->total_sectors
<< BDRV_SECTOR_BITS
)
3925 /* Zero-pad last write if image size is not cluster aligned */
3926 memset(buf
+ bytes
, 0, s
->cluster_size
- bytes
);
3928 qemu_iovec_to_buf(qiov
, 0, buf
, bytes
);
3930 out_buf
= g_malloc(s
->cluster_size
);
3932 out_len
= qcow2_co_compress(bs
, out_buf
, s
->cluster_size
- 1,
3933 buf
, s
->cluster_size
);
3934 if (out_len
== -2) {
3937 } else if (out_len
== -1) {
3938 /* could not compress: write normal cluster */
3939 ret
= qcow2_co_pwritev(bs
, offset
, bytes
, qiov
, 0);
3946 qemu_co_mutex_lock(&s
->lock
);
3948 qcow2_alloc_compressed_cluster_offset(bs
, offset
, out_len
);
3949 if (!cluster_offset
) {
3950 qemu_co_mutex_unlock(&s
->lock
);
3954 cluster_offset
&= s
->cluster_offset_mask
;
3956 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
);
3957 qemu_co_mutex_unlock(&s
->lock
);
3962 iov
= (struct iovec
) {
3963 .iov_base
= out_buf
,
3966 qemu_iovec_init_external(&hd_qiov
, &iov
, 1);
3968 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
3969 ret
= bdrv_co_pwritev(bs
->file
, cluster_offset
, out_len
, &hd_qiov
, 0);
3981 static int coroutine_fn
3982 qcow2_co_preadv_compressed(BlockDriverState
*bs
,
3983 uint64_t file_cluster_offset
,
3988 BDRVQcow2State
*s
= bs
->opaque
;
3989 int ret
= 0, csize
, nb_csectors
;
3991 uint8_t *buf
, *out_buf
;
3993 QEMUIOVector local_qiov
;
3994 int offset_in_cluster
= offset_into_cluster(s
, offset
);
3996 coffset
= file_cluster_offset
& s
->cluster_offset_mask
;
3997 nb_csectors
= ((file_cluster_offset
>> s
->csize_shift
) & s
->csize_mask
) + 1;
3998 csize
= nb_csectors
* 512 - (coffset
& 511);
4000 buf
= g_try_malloc(csize
);
4005 iov
.iov_len
= csize
;
4006 qemu_iovec_init_external(&local_qiov
, &iov
, 1);
4008 out_buf
= qemu_blockalign(bs
, s
->cluster_size
);
4010 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_COMPRESSED
);
4011 ret
= bdrv_co_preadv(bs
->file
, coffset
, csize
, &local_qiov
, 0);
4016 if (qcow2_co_decompress(bs
, out_buf
, s
->cluster_size
, buf
, csize
) < 0) {
4021 qemu_iovec_from_buf(qiov
, 0, out_buf
+ offset_in_cluster
, bytes
);
4024 qemu_vfree(out_buf
);
4030 static int make_completely_empty(BlockDriverState
*bs
)
4032 BDRVQcow2State
*s
= bs
->opaque
;
4033 Error
*local_err
= NULL
;
4034 int ret
, l1_clusters
;
4036 uint64_t *new_reftable
= NULL
;
4037 uint64_t rt_entry
, l1_size2
;
4040 uint64_t reftable_offset
;
4041 uint32_t reftable_clusters
;
4042 } QEMU_PACKED l1_ofs_rt_ofs_cls
;
4044 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
4049 ret
= qcow2_cache_empty(bs
, s
->refcount_block_cache
);
4054 /* Refcounts will be broken utterly */
4055 ret
= qcow2_mark_dirty(bs
);
4060 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
4062 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
4063 l1_size2
= (uint64_t)s
->l1_size
* sizeof(uint64_t);
4065 /* After this call, neither the in-memory nor the on-disk refcount
4066 * information accurately describe the actual references */
4068 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->l1_table_offset
,
4069 l1_clusters
* s
->cluster_size
, 0);
4071 goto fail_broken_refcounts
;
4073 memset(s
->l1_table
, 0, l1_size2
);
4075 BLKDBG_EVENT(bs
->file
, BLKDBG_EMPTY_IMAGE_PREPARE
);
4077 /* Overwrite enough clusters at the beginning of the sectors to place
4078 * the refcount table, a refcount block and the L1 table in; this may
4079 * overwrite parts of the existing refcount and L1 table, which is not
4080 * an issue because the dirty flag is set, complete data loss is in fact
4081 * desired and partial data loss is consequently fine as well */
4082 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->cluster_size
,
4083 (2 + l1_clusters
) * s
->cluster_size
, 0);
4084 /* This call (even if it failed overall) may have overwritten on-disk
4085 * refcount structures; in that case, the in-memory refcount information
4086 * will probably differ from the on-disk information which makes the BDS
4089 goto fail_broken_refcounts
;
4092 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
4093 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_UPDATE
);
4095 /* "Create" an empty reftable (one cluster) directly after the image
4096 * header and an empty L1 table three clusters after the image header;
4097 * the cluster between those two will be used as the first refblock */
4098 l1_ofs_rt_ofs_cls
.l1_offset
= cpu_to_be64(3 * s
->cluster_size
);
4099 l1_ofs_rt_ofs_cls
.reftable_offset
= cpu_to_be64(s
->cluster_size
);
4100 l1_ofs_rt_ofs_cls
.reftable_clusters
= cpu_to_be32(1);
4101 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, l1_table_offset
),
4102 &l1_ofs_rt_ofs_cls
, sizeof(l1_ofs_rt_ofs_cls
));
4104 goto fail_broken_refcounts
;
4107 s
->l1_table_offset
= 3 * s
->cluster_size
;
4109 new_reftable
= g_try_new0(uint64_t, s
->cluster_size
/ sizeof(uint64_t));
4110 if (!new_reftable
) {
4112 goto fail_broken_refcounts
;
4115 s
->refcount_table_offset
= s
->cluster_size
;
4116 s
->refcount_table_size
= s
->cluster_size
/ sizeof(uint64_t);
4117 s
->max_refcount_table_index
= 0;
4119 g_free(s
->refcount_table
);
4120 s
->refcount_table
= new_reftable
;
4121 new_reftable
= NULL
;
4123 /* Now the in-memory refcount information again corresponds to the on-disk
4124 * information (reftable is empty and no refblocks (the refblock cache is
4125 * empty)); however, this means some clusters (e.g. the image header) are
4126 * referenced, but not refcounted, but the normal qcow2 code assumes that
4127 * the in-memory information is always correct */
4129 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
4131 /* Enter the first refblock into the reftable */
4132 rt_entry
= cpu_to_be64(2 * s
->cluster_size
);
4133 ret
= bdrv_pwrite_sync(bs
->file
, s
->cluster_size
,
4134 &rt_entry
, sizeof(rt_entry
));
4136 goto fail_broken_refcounts
;
4138 s
->refcount_table
[0] = 2 * s
->cluster_size
;
4140 s
->free_cluster_index
= 0;
4141 assert(3 + l1_clusters
<= s
->refcount_block_size
);
4142 offset
= qcow2_alloc_clusters(bs
, 3 * s
->cluster_size
+ l1_size2
);
4145 goto fail_broken_refcounts
;
4146 } else if (offset
> 0) {
4147 error_report("First cluster in emptied image is in use");
4151 /* Now finally the in-memory information corresponds to the on-disk
4152 * structures and is correct */
4153 ret
= qcow2_mark_clean(bs
);
4158 ret
= bdrv_truncate(bs
->file
, (3 + l1_clusters
) * s
->cluster_size
,
4159 PREALLOC_MODE_OFF
, &local_err
);
4161 error_report_err(local_err
);
4167 fail_broken_refcounts
:
4168 /* The BDS is unusable at this point. If we wanted to make it usable, we
4169 * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
4170 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
4171 * again. However, because the functions which could have caused this error
4172 * path to be taken are used by those functions as well, it's very likely
4173 * that that sequence will fail as well. Therefore, just eject the BDS. */
4177 g_free(new_reftable
);
4181 static int qcow2_make_empty(BlockDriverState
*bs
)
4183 BDRVQcow2State
*s
= bs
->opaque
;
4184 uint64_t offset
, end_offset
;
4185 int step
= QEMU_ALIGN_DOWN(INT_MAX
, s
->cluster_size
);
4186 int l1_clusters
, ret
= 0;
4188 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
4190 if (s
->qcow_version
>= 3 && !s
->snapshots
&& !s
->nb_bitmaps
&&
4191 3 + l1_clusters
<= s
->refcount_block_size
&&
4192 s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
4193 /* The following function only works for qcow2 v3 images (it
4194 * requires the dirty flag) and only as long as there are no
4195 * features that reserve extra clusters (such as snapshots,
4196 * LUKS header, or persistent bitmaps), because it completely
4197 * empties the image. Furthermore, the L1 table and three
4198 * additional clusters (image header, refcount table, one
4199 * refcount block) have to fit inside one refcount block. */
4200 return make_completely_empty(bs
);
4203 /* This fallback code simply discards every active cluster; this is slow,
4204 * but works in all cases */
4205 end_offset
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
4206 for (offset
= 0; offset
< end_offset
; offset
+= step
) {
4207 /* As this function is generally used after committing an external
4208 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
4209 * default action for this kind of discard is to pass the discard,
4210 * which will ideally result in an actually smaller image file, as
4211 * is probably desired. */
4212 ret
= qcow2_cluster_discard(bs
, offset
, MIN(step
, end_offset
- offset
),
4213 QCOW2_DISCARD_SNAPSHOT
, true);
4222 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
4224 BDRVQcow2State
*s
= bs
->opaque
;
4227 qemu_co_mutex_lock(&s
->lock
);
4228 ret
= qcow2_write_caches(bs
);
4229 qemu_co_mutex_unlock(&s
->lock
);
4234 static BlockMeasureInfo
*qcow2_measure(QemuOpts
*opts
, BlockDriverState
*in_bs
,
4237 Error
*local_err
= NULL
;
4238 BlockMeasureInfo
*info
;
4239 uint64_t required
= 0; /* bytes that contribute to required size */
4240 uint64_t virtual_size
; /* disk size as seen by guest */
4241 uint64_t refcount_bits
;
4243 size_t cluster_size
;
4246 PreallocMode prealloc
;
4247 bool has_backing_file
;
4249 /* Parse image creation options */
4250 cluster_size
= qcow2_opt_get_cluster_size_del(opts
, &local_err
);
4255 version
= qcow2_opt_get_version_del(opts
, &local_err
);
4260 refcount_bits
= qcow2_opt_get_refcount_bits_del(opts
, version
, &local_err
);
4265 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
4266 prealloc
= qapi_enum_parse(&PreallocMode_lookup
, optstr
,
4267 PREALLOC_MODE_OFF
, &local_err
);
4273 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
4274 has_backing_file
= !!optstr
;
4277 virtual_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0);
4278 virtual_size
= ROUND_UP(virtual_size
, cluster_size
);
4280 /* Check that virtual disk size is valid */
4281 l2_tables
= DIV_ROUND_UP(virtual_size
/ cluster_size
,
4282 cluster_size
/ sizeof(uint64_t));
4283 if (l2_tables
* sizeof(uint64_t) > QCOW_MAX_L1_SIZE
) {
4284 error_setg(&local_err
, "The image size is too large "
4285 "(try using a larger cluster size)");
4289 /* Account for input image */
4291 int64_t ssize
= bdrv_getlength(in_bs
);
4293 error_setg_errno(&local_err
, -ssize
,
4294 "Unable to get image virtual_size");
4298 virtual_size
= ROUND_UP(ssize
, cluster_size
);
4300 if (has_backing_file
) {
4301 /* We don't how much of the backing chain is shared by the input
4302 * image and the new image file. In the worst case the new image's
4303 * backing file has nothing in common with the input image. Be
4304 * conservative and assume all clusters need to be written.
4306 required
= virtual_size
;
4311 for (offset
= 0; offset
< ssize
; offset
+= pnum
) {
4314 ret
= bdrv_block_status_above(in_bs
, NULL
, offset
,
4315 ssize
- offset
, &pnum
, NULL
,
4318 error_setg_errno(&local_err
, -ret
,
4319 "Unable to get block status");
4323 if (ret
& BDRV_BLOCK_ZERO
) {
4324 /* Skip zero regions (safe with no backing file) */
4325 } else if ((ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) ==
4326 (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) {
4327 /* Extend pnum to end of cluster for next iteration */
4328 pnum
= ROUND_UP(offset
+ pnum
, cluster_size
) - offset
;
4330 /* Count clusters we've seen */
4331 required
+= offset
% cluster_size
+ pnum
;
4337 /* Take into account preallocation. Nothing special is needed for
4338 * PREALLOC_MODE_METADATA since metadata is always counted.
4340 if (prealloc
== PREALLOC_MODE_FULL
|| prealloc
== PREALLOC_MODE_FALLOC
) {
4341 required
= virtual_size
;
4344 info
= g_new(BlockMeasureInfo
, 1);
4345 info
->fully_allocated
=
4346 qcow2_calc_prealloc_size(virtual_size
, cluster_size
,
4347 ctz32(refcount_bits
));
4349 /* Remove data clusters that are not required. This overestimates the
4350 * required size because metadata needed for the fully allocated file is
4353 info
->required
= info
->fully_allocated
- virtual_size
+ required
;
4357 error_propagate(errp
, local_err
);
4361 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4363 BDRVQcow2State
*s
= bs
->opaque
;
4364 bdi
->unallocated_blocks_are_zero
= true;
4365 bdi
->cluster_size
= s
->cluster_size
;
4366 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
4370 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
)
4372 BDRVQcow2State
*s
= bs
->opaque
;
4373 ImageInfoSpecific
*spec_info
;
4374 QCryptoBlockInfo
*encrypt_info
= NULL
;
4376 if (s
->crypto
!= NULL
) {
4377 encrypt_info
= qcrypto_block_get_info(s
->crypto
, &error_abort
);
4380 spec_info
= g_new(ImageInfoSpecific
, 1);
4381 *spec_info
= (ImageInfoSpecific
){
4382 .type
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
4383 .u
.qcow2
.data
= g_new(ImageInfoSpecificQCow2
, 1),
4385 if (s
->qcow_version
== 2) {
4386 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
4387 .compat
= g_strdup("0.10"),
4388 .refcount_bits
= s
->refcount_bits
,
4390 } else if (s
->qcow_version
== 3) {
4391 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
4392 .compat
= g_strdup("1.1"),
4393 .lazy_refcounts
= s
->compatible_features
&
4394 QCOW2_COMPAT_LAZY_REFCOUNTS
,
4395 .has_lazy_refcounts
= true,
4396 .corrupt
= s
->incompatible_features
&
4397 QCOW2_INCOMPAT_CORRUPT
,
4398 .has_corrupt
= true,
4399 .refcount_bits
= s
->refcount_bits
,
4402 /* if this assertion fails, this probably means a new version was
4403 * added without having it covered here */
4408 ImageInfoSpecificQCow2Encryption
*qencrypt
=
4409 g_new(ImageInfoSpecificQCow2Encryption
, 1);
4410 switch (encrypt_info
->format
) {
4411 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
4412 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES
;
4414 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
4415 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS
;
4416 qencrypt
->u
.luks
= encrypt_info
->u
.luks
;
4421 /* Since we did shallow copy above, erase any pointers
4422 * in the original info */
4423 memset(&encrypt_info
->u
, 0, sizeof(encrypt_info
->u
));
4424 qapi_free_QCryptoBlockInfo(encrypt_info
);
4426 spec_info
->u
.qcow2
.data
->has_encrypt
= true;
4427 spec_info
->u
.qcow2
.data
->encrypt
= qencrypt
;
4433 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
4436 BDRVQcow2State
*s
= bs
->opaque
;
4438 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
4439 return bs
->drv
->bdrv_co_pwritev(bs
, qcow2_vm_state_offset(s
) + pos
,
4440 qiov
->size
, qiov
, 0);
4443 static int qcow2_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
4446 BDRVQcow2State
*s
= bs
->opaque
;
4448 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
4449 return bs
->drv
->bdrv_co_preadv(bs
, qcow2_vm_state_offset(s
) + pos
,
4450 qiov
->size
, qiov
, 0);
4454 * Downgrades an image's version. To achieve this, any incompatible features
4455 * have to be removed.
4457 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
,
4458 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
,
4461 BDRVQcow2State
*s
= bs
->opaque
;
4462 int current_version
= s
->qcow_version
;
4465 /* This is qcow2_downgrade(), not qcow2_upgrade() */
4466 assert(target_version
< current_version
);
4468 /* There are no other versions (now) that you can downgrade to */
4469 assert(target_version
== 2);
4471 if (s
->refcount_order
!= 4) {
4472 error_setg(errp
, "compat=0.10 requires refcount_bits=16");
4476 /* clear incompatible features */
4477 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
4478 ret
= qcow2_mark_clean(bs
);
4480 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
4485 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
4486 * the first place; if that happens nonetheless, returning -ENOTSUP is the
4487 * best thing to do anyway */
4489 if (s
->incompatible_features
) {
4490 error_setg(errp
, "Cannot downgrade an image with incompatible features "
4491 "%#" PRIx64
" set", s
->incompatible_features
);
4495 /* since we can ignore compatible features, we can set them to 0 as well */
4496 s
->compatible_features
= 0;
4497 /* if lazy refcounts have been used, they have already been fixed through
4498 * clearing the dirty flag */
4500 /* clearing autoclear features is trivial */
4501 s
->autoclear_features
= 0;
4503 ret
= qcow2_expand_zero_clusters(bs
, status_cb
, cb_opaque
);
4505 error_setg_errno(errp
, -ret
, "Failed to turn zero into data clusters");
4509 s
->qcow_version
= target_version
;
4510 ret
= qcow2_update_header(bs
);
4512 s
->qcow_version
= current_version
;
4513 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4519 typedef enum Qcow2AmendOperation
{
4520 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
4521 * statically initialized to so that the helper CB can discern the first
4522 * invocation from an operation change */
4523 QCOW2_NO_OPERATION
= 0,
4525 QCOW2_CHANGING_REFCOUNT_ORDER
,
4527 } Qcow2AmendOperation
;
4529 typedef struct Qcow2AmendHelperCBInfo
{
4530 /* The code coordinating the amend operations should only modify
4531 * these four fields; the rest will be managed by the CB */
4532 BlockDriverAmendStatusCB
*original_status_cb
;
4533 void *original_cb_opaque
;
4535 Qcow2AmendOperation current_operation
;
4537 /* Total number of operations to perform (only set once) */
4538 int total_operations
;
4540 /* The following fields are managed by the CB */
4542 /* Number of operations completed */
4543 int operations_completed
;
4545 /* Cumulative offset of all completed operations */
4546 int64_t offset_completed
;
4548 Qcow2AmendOperation last_operation
;
4549 int64_t last_work_size
;
4550 } Qcow2AmendHelperCBInfo
;
4552 static void qcow2_amend_helper_cb(BlockDriverState
*bs
,
4553 int64_t operation_offset
,
4554 int64_t operation_work_size
, void *opaque
)
4556 Qcow2AmendHelperCBInfo
*info
= opaque
;
4557 int64_t current_work_size
;
4558 int64_t projected_work_size
;
4560 if (info
->current_operation
!= info
->last_operation
) {
4561 if (info
->last_operation
!= QCOW2_NO_OPERATION
) {
4562 info
->offset_completed
+= info
->last_work_size
;
4563 info
->operations_completed
++;
4566 info
->last_operation
= info
->current_operation
;
4569 assert(info
->total_operations
> 0);
4570 assert(info
->operations_completed
< info
->total_operations
);
4572 info
->last_work_size
= operation_work_size
;
4574 current_work_size
= info
->offset_completed
+ operation_work_size
;
4576 /* current_work_size is the total work size for (operations_completed + 1)
4577 * operations (which includes this one), so multiply it by the number of
4578 * operations not covered and divide it by the number of operations
4579 * covered to get a projection for the operations not covered */
4580 projected_work_size
= current_work_size
* (info
->total_operations
-
4581 info
->operations_completed
- 1)
4582 / (info
->operations_completed
+ 1);
4584 info
->original_status_cb(bs
, info
->offset_completed
+ operation_offset
,
4585 current_work_size
+ projected_work_size
,
4586 info
->original_cb_opaque
);
4589 static int qcow2_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
4590 BlockDriverAmendStatusCB
*status_cb
,
4594 BDRVQcow2State
*s
= bs
->opaque
;
4595 int old_version
= s
->qcow_version
, new_version
= old_version
;
4596 uint64_t new_size
= 0;
4597 const char *backing_file
= NULL
, *backing_format
= NULL
;
4598 bool lazy_refcounts
= s
->use_lazy_refcounts
;
4599 const char *compat
= NULL
;
4600 uint64_t cluster_size
= s
->cluster_size
;
4603 int refcount_bits
= s
->refcount_bits
;
4605 QemuOptDesc
*desc
= opts
->list
->desc
;
4606 Qcow2AmendHelperCBInfo helper_cb_info
;
4608 while (desc
&& desc
->name
) {
4609 if (!qemu_opt_find(opts
, desc
->name
)) {
4610 /* only change explicitly defined options */
4615 if (!strcmp(desc
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
4616 compat
= qemu_opt_get(opts
, BLOCK_OPT_COMPAT_LEVEL
);
4618 /* preserve default */
4619 } else if (!strcmp(compat
, "0.10")) {
4621 } else if (!strcmp(compat
, "1.1")) {
4624 error_setg(errp
, "Unknown compatibility level %s", compat
);
4627 } else if (!strcmp(desc
->name
, BLOCK_OPT_PREALLOC
)) {
4628 error_setg(errp
, "Cannot change preallocation mode");
4630 } else if (!strcmp(desc
->name
, BLOCK_OPT_SIZE
)) {
4631 new_size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
4632 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FILE
)) {
4633 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
4634 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FMT
)) {
4635 backing_format
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
4636 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT
)) {
4637 encrypt
= qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
,
4640 if (encrypt
!= !!s
->crypto
) {
4642 "Changing the encryption flag is not supported");
4645 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT_FORMAT
)) {
4646 encformat
= qcow2_crypt_method_from_format(
4647 qemu_opt_get(opts
, BLOCK_OPT_ENCRYPT_FORMAT
));
4649 if (encformat
!= s
->crypt_method_header
) {
4651 "Changing the encryption format is not supported");
4654 } else if (g_str_has_prefix(desc
->name
, "encrypt.")) {
4656 "Changing the encryption parameters is not supported");
4658 } else if (!strcmp(desc
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
4659 cluster_size
= qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
,
4661 if (cluster_size
!= s
->cluster_size
) {
4662 error_setg(errp
, "Changing the cluster size is not supported");
4665 } else if (!strcmp(desc
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
4666 lazy_refcounts
= qemu_opt_get_bool(opts
, BLOCK_OPT_LAZY_REFCOUNTS
,
4668 } else if (!strcmp(desc
->name
, BLOCK_OPT_REFCOUNT_BITS
)) {
4669 refcount_bits
= qemu_opt_get_number(opts
, BLOCK_OPT_REFCOUNT_BITS
,
4672 if (refcount_bits
<= 0 || refcount_bits
> 64 ||
4673 !is_power_of_2(refcount_bits
))
4675 error_setg(errp
, "Refcount width must be a power of two and "
4676 "may not exceed 64 bits");
4680 /* if this point is reached, this probably means a new option was
4681 * added without having it covered here */
4688 helper_cb_info
= (Qcow2AmendHelperCBInfo
){
4689 .original_status_cb
= status_cb
,
4690 .original_cb_opaque
= cb_opaque
,
4691 .total_operations
= (new_version
< old_version
)
4692 + (s
->refcount_bits
!= refcount_bits
)
4695 /* Upgrade first (some features may require compat=1.1) */
4696 if (new_version
> old_version
) {
4697 s
->qcow_version
= new_version
;
4698 ret
= qcow2_update_header(bs
);
4700 s
->qcow_version
= old_version
;
4701 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4706 if (s
->refcount_bits
!= refcount_bits
) {
4707 int refcount_order
= ctz32(refcount_bits
);
4709 if (new_version
< 3 && refcount_bits
!= 16) {
4710 error_setg(errp
, "Refcount widths other than 16 bits require "
4711 "compatibility level 1.1 or above (use compat=1.1 or "
4716 helper_cb_info
.current_operation
= QCOW2_CHANGING_REFCOUNT_ORDER
;
4717 ret
= qcow2_change_refcount_order(bs
, refcount_order
,
4718 &qcow2_amend_helper_cb
,
4719 &helper_cb_info
, errp
);
4725 if (backing_file
|| backing_format
) {
4726 ret
= qcow2_change_backing_file(bs
,
4727 backing_file
?: s
->image_backing_file
,
4728 backing_format
?: s
->image_backing_format
);
4730 error_setg_errno(errp
, -ret
, "Failed to change the backing file");
4735 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
4736 if (lazy_refcounts
) {
4737 if (new_version
< 3) {
4738 error_setg(errp
, "Lazy refcounts only supported with "
4739 "compatibility level 1.1 and above (use compat=1.1 "
4743 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
4744 ret
= qcow2_update_header(bs
);
4746 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
4747 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4750 s
->use_lazy_refcounts
= true;
4752 /* make image clean first */
4753 ret
= qcow2_mark_clean(bs
);
4755 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
4758 /* now disallow lazy refcounts */
4759 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
4760 ret
= qcow2_update_header(bs
);
4762 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
4763 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4766 s
->use_lazy_refcounts
= false;
4771 BlockBackend
*blk
= blk_new(BLK_PERM_RESIZE
, BLK_PERM_ALL
);
4772 ret
= blk_insert_bs(blk
, bs
, errp
);
4778 ret
= blk_truncate(blk
, new_size
, PREALLOC_MODE_OFF
, errp
);
4785 /* Downgrade last (so unsupported features can be removed before) */
4786 if (new_version
< old_version
) {
4787 helper_cb_info
.current_operation
= QCOW2_DOWNGRADING
;
4788 ret
= qcow2_downgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
4789 &helper_cb_info
, errp
);
4799 * If offset or size are negative, respectively, they will not be included in
4800 * the BLOCK_IMAGE_CORRUPTED event emitted.
4801 * fatal will be ignored for read-only BDS; corruptions found there will always
4802 * be considered non-fatal.
4804 void qcow2_signal_corruption(BlockDriverState
*bs
, bool fatal
, int64_t offset
,
4805 int64_t size
, const char *message_format
, ...)
4807 BDRVQcow2State
*s
= bs
->opaque
;
4808 const char *node_name
;
4812 fatal
= fatal
&& bdrv_is_writable(bs
);
4814 if (s
->signaled_corruption
&&
4815 (!fatal
|| (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
)))
4820 va_start(ap
, message_format
);
4821 message
= g_strdup_vprintf(message_format
, ap
);
4825 fprintf(stderr
, "qcow2: Marking image as corrupt: %s; further "
4826 "corruption events will be suppressed\n", message
);
4828 fprintf(stderr
, "qcow2: Image is corrupt: %s; further non-fatal "
4829 "corruption events will be suppressed\n", message
);
4832 node_name
= bdrv_get_node_name(bs
);
4833 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs
),
4834 *node_name
!= '\0', node_name
,
4835 message
, offset
>= 0, offset
,
4841 qcow2_mark_corrupt(bs
);
4842 bs
->drv
= NULL
; /* make BDS unusable */
4845 s
->signaled_corruption
= true;
4848 static QemuOptsList qcow2_create_opts
= {
4849 .name
= "qcow2-create-opts",
4850 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_create_opts
.head
),
4853 .name
= BLOCK_OPT_SIZE
,
4854 .type
= QEMU_OPT_SIZE
,
4855 .help
= "Virtual disk size"
4858 .name
= BLOCK_OPT_COMPAT_LEVEL
,
4859 .type
= QEMU_OPT_STRING
,
4860 .help
= "Compatibility level (0.10 or 1.1)"
4863 .name
= BLOCK_OPT_BACKING_FILE
,
4864 .type
= QEMU_OPT_STRING
,
4865 .help
= "File name of a base image"
4868 .name
= BLOCK_OPT_BACKING_FMT
,
4869 .type
= QEMU_OPT_STRING
,
4870 .help
= "Image format of the base image"
4873 .name
= BLOCK_OPT_ENCRYPT
,
4874 .type
= QEMU_OPT_BOOL
,
4875 .help
= "Encrypt the image with format 'aes'. (Deprecated "
4876 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT
"=aes)",
4879 .name
= BLOCK_OPT_ENCRYPT_FORMAT
,
4880 .type
= QEMU_OPT_STRING
,
4881 .help
= "Encrypt the image, format choices: 'aes', 'luks'",
4883 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
4884 "ID of secret providing qcow AES key or LUKS passphrase"),
4885 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."),
4886 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."),
4887 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."),
4888 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."),
4889 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."),
4890 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
4892 .name
= BLOCK_OPT_CLUSTER_SIZE
,
4893 .type
= QEMU_OPT_SIZE
,
4894 .help
= "qcow2 cluster size",
4895 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
)
4898 .name
= BLOCK_OPT_PREALLOC
,
4899 .type
= QEMU_OPT_STRING
,
4900 .help
= "Preallocation mode (allowed values: off, metadata, "
4904 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
4905 .type
= QEMU_OPT_BOOL
,
4906 .help
= "Postpone refcount updates",
4907 .def_value_str
= "off"
4910 .name
= BLOCK_OPT_REFCOUNT_BITS
,
4911 .type
= QEMU_OPT_NUMBER
,
4912 .help
= "Width of a reference count entry in bits",
4913 .def_value_str
= "16"
4915 { /* end of list */ }
4919 BlockDriver bdrv_qcow2
= {
4920 .format_name
= "qcow2",
4921 .instance_size
= sizeof(BDRVQcow2State
),
4922 .bdrv_probe
= qcow2_probe
,
4923 .bdrv_open
= qcow2_open
,
4924 .bdrv_close
= qcow2_close
,
4925 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
4926 .bdrv_reopen_commit
= qcow2_reopen_commit
,
4927 .bdrv_reopen_abort
= qcow2_reopen_abort
,
4928 .bdrv_join_options
= qcow2_join_options
,
4929 .bdrv_child_perm
= bdrv_format_default_perms
,
4930 .bdrv_co_create_opts
= qcow2_co_create_opts
,
4931 .bdrv_co_create
= qcow2_co_create
,
4932 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
4933 .bdrv_co_block_status
= qcow2_co_block_status
,
4935 .bdrv_co_preadv
= qcow2_co_preadv
,
4936 .bdrv_co_pwritev
= qcow2_co_pwritev
,
4937 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
4939 .bdrv_co_pwrite_zeroes
= qcow2_co_pwrite_zeroes
,
4940 .bdrv_co_pdiscard
= qcow2_co_pdiscard
,
4941 .bdrv_co_copy_range_from
= qcow2_co_copy_range_from
,
4942 .bdrv_co_copy_range_to
= qcow2_co_copy_range_to
,
4943 .bdrv_co_truncate
= qcow2_co_truncate
,
4944 .bdrv_co_pwritev_compressed
= qcow2_co_pwritev_compressed
,
4945 .bdrv_make_empty
= qcow2_make_empty
,
4947 .bdrv_snapshot_create
= qcow2_snapshot_create
,
4948 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
4949 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
4950 .bdrv_snapshot_list
= qcow2_snapshot_list
,
4951 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
4952 .bdrv_measure
= qcow2_measure
,
4953 .bdrv_get_info
= qcow2_get_info
,
4954 .bdrv_get_specific_info
= qcow2_get_specific_info
,
4956 .bdrv_save_vmstate
= qcow2_save_vmstate
,
4957 .bdrv_load_vmstate
= qcow2_load_vmstate
,
4959 .supports_backing
= true,
4960 .bdrv_change_backing_file
= qcow2_change_backing_file
,
4962 .bdrv_refresh_limits
= qcow2_refresh_limits
,
4963 .bdrv_co_invalidate_cache
= qcow2_co_invalidate_cache
,
4964 .bdrv_inactivate
= qcow2_inactivate
,
4966 .create_opts
= &qcow2_create_opts
,
4967 .bdrv_co_check
= qcow2_co_check
,
4968 .bdrv_amend_options
= qcow2_amend_options
,
4970 .bdrv_detach_aio_context
= qcow2_detach_aio_context
,
4971 .bdrv_attach_aio_context
= qcow2_attach_aio_context
,
4973 .bdrv_reopen_bitmaps_rw
= qcow2_reopen_bitmaps_rw
,
4974 .bdrv_can_store_new_dirty_bitmap
= qcow2_can_store_new_dirty_bitmap
,
4975 .bdrv_remove_persistent_dirty_bitmap
= qcow2_remove_persistent_dirty_bitmap
,
4978 static void bdrv_qcow2_init(void)
4980 bdrv_register(&bdrv_qcow2
);
4983 block_init(bdrv_qcow2_init
);