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
24 #include "qemu/osdep.h"
25 #include "block/block_int.h"
26 #include "sysemu/block-backend.h"
27 #include "qemu/module.h"
29 #include "block/qcow2.h"
30 #include "qemu/error-report.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qbool.h"
33 #include "qapi/util.h"
34 #include "qapi/qmp/types.h"
35 #include "qapi-event.h"
37 #include "qemu/option_int.h"
38 #include "qemu/cutils.h"
39 #include "qemu/bswap.h"
40 #include "qapi/opts-visitor.h"
41 #include "qapi-visit.h"
42 #include "block/crypto.h"
45 Differences with QCOW:
47 - Support for multiple incremental snapshots.
48 - Memory management by reference counts.
49 - Clusters which have a reference count of one have the bit
50 QCOW_OFLAG_COPIED to optimize write performance.
51 - Size of compressed clusters is stored in sectors to reduce bit usage
52 in the cluster offsets.
53 - Support for storing additional data (such as the VM state) in the
55 - If a backing store is used, the cluster size is not constrained
56 (could be backported to QCOW).
57 - L2 tables have always a size of one cluster.
64 } QEMU_PACKED QCowExtension
;
66 #define QCOW2_EXT_MAGIC_END 0
67 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
68 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
69 #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
71 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
73 const QCowHeader
*cow_header
= (const void *)buf
;
75 if (buf_size
>= sizeof(QCowHeader
) &&
76 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
77 be32_to_cpu(cow_header
->version
) >= 2)
84 static ssize_t
qcow2_crypto_hdr_read_func(QCryptoBlock
*block
, size_t offset
,
85 uint8_t *buf
, size_t buflen
,
86 void *opaque
, Error
**errp
)
88 BlockDriverState
*bs
= opaque
;
89 BDRVQcow2State
*s
= bs
->opaque
;
92 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
93 error_setg(errp
, "Request for data outside of extension header");
97 ret
= bdrv_pread(bs
->file
,
98 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
100 error_setg_errno(errp
, -ret
, "Could not read encryption header");
107 static ssize_t
qcow2_crypto_hdr_init_func(QCryptoBlock
*block
, size_t headerlen
,
108 void *opaque
, Error
**errp
)
110 BlockDriverState
*bs
= opaque
;
111 BDRVQcow2State
*s
= bs
->opaque
;
115 ret
= qcow2_alloc_clusters(bs
, headerlen
);
117 error_setg_errno(errp
, -ret
,
118 "Cannot allocate cluster for LUKS header size %zu",
123 s
->crypto_header
.length
= headerlen
;
124 s
->crypto_header
.offset
= ret
;
126 /* Zero fill remaining space in cluster so it has predictable
127 * content in case of future spec changes */
128 clusterlen
= size_to_clusters(s
, headerlen
) * s
->cluster_size
;
129 ret
= bdrv_pwrite_zeroes(bs
->file
,
131 clusterlen
- headerlen
, 0);
133 error_setg_errno(errp
, -ret
, "Could not zero fill encryption header");
141 static ssize_t
qcow2_crypto_hdr_write_func(QCryptoBlock
*block
, size_t offset
,
142 const uint8_t *buf
, size_t buflen
,
143 void *opaque
, Error
**errp
)
145 BlockDriverState
*bs
= opaque
;
146 BDRVQcow2State
*s
= bs
->opaque
;
149 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
150 error_setg(errp
, "Request for data outside of extension header");
154 ret
= bdrv_pwrite(bs
->file
,
155 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
157 error_setg_errno(errp
, -ret
, "Could not read encryption header");
165 * read qcow2 extension and fill bs
166 * start reading from start_offset
167 * finish reading upon magic of value 0 or when end_offset reached
168 * unknown magic is skipped (future extension this version knows nothing about)
169 * return 0 upon success, non-0 otherwise
171 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
172 uint64_t end_offset
, void **p_feature_table
,
173 int flags
, Error
**errp
)
175 BDRVQcow2State
*s
= bs
->opaque
;
181 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
183 offset
= start_offset
;
184 while (offset
< end_offset
) {
188 if (offset
> s
->cluster_size
)
189 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
191 printf("attempting to read extended header in offset %lu\n", offset
);
194 ret
= bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
));
196 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
197 "pread fail from offset %" PRIu64
, offset
);
200 be32_to_cpus(&ext
.magic
);
201 be32_to_cpus(&ext
.len
);
202 offset
+= sizeof(ext
);
204 printf("ext.magic = 0x%x\n", ext
.magic
);
206 if (offset
> end_offset
|| ext
.len
> end_offset
- offset
) {
207 error_setg(errp
, "Header extension too large");
212 case QCOW2_EXT_MAGIC_END
:
215 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
216 if (ext
.len
>= sizeof(bs
->backing_format
)) {
217 error_setg(errp
, "ERROR: ext_backing_format: len=%" PRIu32
218 " too large (>=%zu)", ext
.len
,
219 sizeof(bs
->backing_format
));
222 ret
= bdrv_pread(bs
->file
, offset
, bs
->backing_format
, ext
.len
);
224 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
225 "Could not read format name");
228 bs
->backing_format
[ext
.len
] = '\0';
229 s
->image_backing_format
= g_strdup(bs
->backing_format
);
231 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
235 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
236 if (p_feature_table
!= NULL
) {
237 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
238 ret
= bdrv_pread(bs
->file
, offset
, feature_table
, ext
.len
);
240 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
241 "Could not read table");
245 *p_feature_table
= feature_table
;
249 case QCOW2_EXT_MAGIC_CRYPTO_HEADER
: {
250 unsigned int cflags
= 0;
251 if (s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
252 error_setg(errp
, "CRYPTO header extension only "
253 "expected with LUKS encryption method");
256 if (ext
.len
!= sizeof(Qcow2CryptoHeaderExtension
)) {
257 error_setg(errp
, "CRYPTO header extension size %u, "
258 "but expected size %zu", ext
.len
,
259 sizeof(Qcow2CryptoHeaderExtension
));
263 ret
= bdrv_pread(bs
->file
, offset
, &s
->crypto_header
, ext
.len
);
265 error_setg_errno(errp
, -ret
,
266 "Unable to read CRYPTO header extension");
269 be64_to_cpus(&s
->crypto_header
.offset
);
270 be64_to_cpus(&s
->crypto_header
.length
);
272 if ((s
->crypto_header
.offset
% s
->cluster_size
) != 0) {
273 error_setg(errp
, "Encryption header offset '%" PRIu64
"' is "
274 "not a multiple of cluster size '%u'",
275 s
->crypto_header
.offset
, s
->cluster_size
);
279 if (flags
& BDRV_O_NO_IO
) {
280 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
282 s
->crypto
= qcrypto_block_open(s
->crypto_opts
,
283 qcow2_crypto_hdr_read_func
,
291 /* unknown magic - save it in case we need to rewrite the header */
293 Qcow2UnknownHeaderExtension
*uext
;
295 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
296 uext
->magic
= ext
.magic
;
298 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
300 ret
= bdrv_pread(bs
->file
, offset
, uext
->data
, uext
->len
);
302 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
303 "Could not read data");
310 offset
+= ((ext
.len
+ 7) & ~7);
316 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
318 BDRVQcow2State
*s
= bs
->opaque
;
319 Qcow2UnknownHeaderExtension
*uext
, *next
;
321 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
322 QLIST_REMOVE(uext
, next
);
327 static void report_unsupported_feature(Error
**errp
, Qcow2Feature
*table
,
330 char *features
= g_strdup("");
333 while (table
&& table
->name
[0] != '\0') {
334 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
335 if (mask
& (1ULL << table
->bit
)) {
337 features
= g_strdup_printf("%s%s%.46s", old
, *old
? ", " : "",
340 mask
&= ~(1ULL << table
->bit
);
348 features
= g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64
,
349 old
, *old
? ", " : "", mask
);
353 error_setg(errp
, "Unsupported qcow2 feature(s): %s", features
);
358 * Sets the dirty bit and flushes afterwards if necessary.
360 * The incompatible_features bit is only set if the image file header was
361 * updated successfully. Therefore it is not required to check the return
362 * value of this function.
364 int qcow2_mark_dirty(BlockDriverState
*bs
)
366 BDRVQcow2State
*s
= bs
->opaque
;
370 assert(s
->qcow_version
>= 3);
372 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
373 return 0; /* already dirty */
376 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
377 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, incompatible_features
),
382 ret
= bdrv_flush(bs
->file
->bs
);
387 /* Only treat image as dirty if the header was updated successfully */
388 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
393 * Clears the dirty bit and flushes before if necessary. Only call this
394 * function when there are no pending requests, it does not guard against
395 * concurrent requests dirtying the image.
397 static int qcow2_mark_clean(BlockDriverState
*bs
)
399 BDRVQcow2State
*s
= bs
->opaque
;
401 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
404 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
406 ret
= bdrv_flush(bs
);
411 return qcow2_update_header(bs
);
417 * Marks the image as corrupt.
419 int qcow2_mark_corrupt(BlockDriverState
*bs
)
421 BDRVQcow2State
*s
= bs
->opaque
;
423 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
424 return qcow2_update_header(bs
);
428 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
429 * before if necessary.
431 int qcow2_mark_consistent(BlockDriverState
*bs
)
433 BDRVQcow2State
*s
= bs
->opaque
;
435 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
436 int ret
= bdrv_flush(bs
);
441 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
442 return qcow2_update_header(bs
);
447 static int qcow2_check(BlockDriverState
*bs
, BdrvCheckResult
*result
,
450 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
455 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
456 ret
= qcow2_mark_clean(bs
);
460 return qcow2_mark_consistent(bs
);
465 static int validate_table_offset(BlockDriverState
*bs
, uint64_t offset
,
466 uint64_t entries
, size_t entry_len
)
468 BDRVQcow2State
*s
= bs
->opaque
;
471 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
472 * because values will be passed to qemu functions taking int64_t. */
473 if (entries
> INT64_MAX
/ entry_len
) {
477 size
= entries
* entry_len
;
479 if (INT64_MAX
- size
< offset
) {
483 /* Tables must be cluster aligned */
484 if (offset_into_cluster(s
, offset
) != 0) {
491 static QemuOptsList qcow2_runtime_opts
= {
493 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
496 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
497 .type
= QEMU_OPT_BOOL
,
498 .help
= "Postpone refcount updates",
501 .name
= QCOW2_OPT_DISCARD_REQUEST
,
502 .type
= QEMU_OPT_BOOL
,
503 .help
= "Pass guest discard requests to the layer below",
506 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
507 .type
= QEMU_OPT_BOOL
,
508 .help
= "Generate discard requests when snapshot related space "
512 .name
= QCOW2_OPT_DISCARD_OTHER
,
513 .type
= QEMU_OPT_BOOL
,
514 .help
= "Generate discard requests when other clusters are freed",
517 .name
= QCOW2_OPT_OVERLAP
,
518 .type
= QEMU_OPT_STRING
,
519 .help
= "Selects which overlap checks to perform from a range of "
520 "templates (none, constant, cached, all)",
523 .name
= QCOW2_OPT_OVERLAP_TEMPLATE
,
524 .type
= QEMU_OPT_STRING
,
525 .help
= "Selects which overlap checks to perform from a range of "
526 "templates (none, constant, cached, all)",
529 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
530 .type
= QEMU_OPT_BOOL
,
531 .help
= "Check for unintended writes into the main qcow2 header",
534 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
535 .type
= QEMU_OPT_BOOL
,
536 .help
= "Check for unintended writes into the active L1 table",
539 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
540 .type
= QEMU_OPT_BOOL
,
541 .help
= "Check for unintended writes into an active L2 table",
544 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
545 .type
= QEMU_OPT_BOOL
,
546 .help
= "Check for unintended writes into the refcount table",
549 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
550 .type
= QEMU_OPT_BOOL
,
551 .help
= "Check for unintended writes into a refcount block",
554 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
555 .type
= QEMU_OPT_BOOL
,
556 .help
= "Check for unintended writes into the snapshot table",
559 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
560 .type
= QEMU_OPT_BOOL
,
561 .help
= "Check for unintended writes into an inactive L1 table",
564 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
565 .type
= QEMU_OPT_BOOL
,
566 .help
= "Check for unintended writes into an inactive L2 table",
569 .name
= QCOW2_OPT_CACHE_SIZE
,
570 .type
= QEMU_OPT_SIZE
,
571 .help
= "Maximum combined metadata (L2 tables and refcount blocks) "
575 .name
= QCOW2_OPT_L2_CACHE_SIZE
,
576 .type
= QEMU_OPT_SIZE
,
577 .help
= "Maximum L2 table cache size",
580 .name
= QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
581 .type
= QEMU_OPT_SIZE
,
582 .help
= "Maximum refcount block cache size",
585 .name
= QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
586 .type
= QEMU_OPT_NUMBER
,
587 .help
= "Clean unused cache entries after this time (in seconds)",
589 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
590 "ID of secret providing qcow2 AES key or LUKS passphrase"),
591 { /* end of list */ }
595 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
596 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
597 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
598 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
599 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
600 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
601 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
602 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
603 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
606 static void cache_clean_timer_cb(void *opaque
)
608 BlockDriverState
*bs
= opaque
;
609 BDRVQcow2State
*s
= bs
->opaque
;
610 qcow2_cache_clean_unused(bs
, s
->l2_table_cache
);
611 qcow2_cache_clean_unused(bs
, s
->refcount_block_cache
);
612 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
613 (int64_t) s
->cache_clean_interval
* 1000);
616 static void cache_clean_timer_init(BlockDriverState
*bs
, AioContext
*context
)
618 BDRVQcow2State
*s
= bs
->opaque
;
619 if (s
->cache_clean_interval
> 0) {
620 s
->cache_clean_timer
= aio_timer_new(context
, QEMU_CLOCK_VIRTUAL
,
621 SCALE_MS
, cache_clean_timer_cb
,
623 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
624 (int64_t) s
->cache_clean_interval
* 1000);
628 static void cache_clean_timer_del(BlockDriverState
*bs
)
630 BDRVQcow2State
*s
= bs
->opaque
;
631 if (s
->cache_clean_timer
) {
632 timer_del(s
->cache_clean_timer
);
633 timer_free(s
->cache_clean_timer
);
634 s
->cache_clean_timer
= NULL
;
638 static void qcow2_detach_aio_context(BlockDriverState
*bs
)
640 cache_clean_timer_del(bs
);
643 static void qcow2_attach_aio_context(BlockDriverState
*bs
,
644 AioContext
*new_context
)
646 cache_clean_timer_init(bs
, new_context
);
649 static void read_cache_sizes(BlockDriverState
*bs
, QemuOpts
*opts
,
650 uint64_t *l2_cache_size
,
651 uint64_t *refcount_cache_size
, Error
**errp
)
653 BDRVQcow2State
*s
= bs
->opaque
;
654 uint64_t combined_cache_size
;
655 bool l2_cache_size_set
, refcount_cache_size_set
, combined_cache_size_set
;
657 combined_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_CACHE_SIZE
);
658 l2_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_SIZE
);
659 refcount_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
661 combined_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_CACHE_SIZE
, 0);
662 *l2_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_L2_CACHE_SIZE
, 0);
663 *refcount_cache_size
= qemu_opt_get_size(opts
,
664 QCOW2_OPT_REFCOUNT_CACHE_SIZE
, 0);
666 if (combined_cache_size_set
) {
667 if (l2_cache_size_set
&& refcount_cache_size_set
) {
668 error_setg(errp
, QCOW2_OPT_CACHE_SIZE
", " QCOW2_OPT_L2_CACHE_SIZE
669 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not be set "
672 } else if (*l2_cache_size
> combined_cache_size
) {
673 error_setg(errp
, QCOW2_OPT_L2_CACHE_SIZE
" may not exceed "
674 QCOW2_OPT_CACHE_SIZE
);
676 } else if (*refcount_cache_size
> combined_cache_size
) {
677 error_setg(errp
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not exceed "
678 QCOW2_OPT_CACHE_SIZE
);
682 if (l2_cache_size_set
) {
683 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
684 } else if (refcount_cache_size_set
) {
685 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
687 *refcount_cache_size
= combined_cache_size
688 / (DEFAULT_L2_REFCOUNT_SIZE_RATIO
+ 1);
689 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
692 if (!l2_cache_size_set
&& !refcount_cache_size_set
) {
693 *l2_cache_size
= MAX(DEFAULT_L2_CACHE_BYTE_SIZE
,
694 (uint64_t)DEFAULT_L2_CACHE_CLUSTERS
696 *refcount_cache_size
= *l2_cache_size
697 / DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
698 } else if (!l2_cache_size_set
) {
699 *l2_cache_size
= *refcount_cache_size
700 * DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
701 } else if (!refcount_cache_size_set
) {
702 *refcount_cache_size
= *l2_cache_size
703 / DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
708 typedef struct Qcow2ReopenState
{
709 Qcow2Cache
*l2_table_cache
;
710 Qcow2Cache
*refcount_block_cache
;
711 bool use_lazy_refcounts
;
713 bool discard_passthrough
[QCOW2_DISCARD_MAX
];
714 uint64_t cache_clean_interval
;
715 QCryptoBlockOpenOptions
*crypto_opts
; /* Disk encryption runtime options */
718 static int qcow2_update_options_prepare(BlockDriverState
*bs
,
720 QDict
*options
, int flags
,
723 BDRVQcow2State
*s
= bs
->opaque
;
724 QemuOpts
*opts
= NULL
;
725 const char *opt_overlap_check
, *opt_overlap_check_template
;
726 int overlap_check_template
= 0;
727 uint64_t l2_cache_size
, refcount_cache_size
;
729 const char *encryptfmt
;
730 QDict
*encryptopts
= NULL
;
731 Error
*local_err
= NULL
;
734 qdict_extract_subqdict(options
, &encryptopts
, "encrypt.");
735 encryptfmt
= qdict_get_try_str(encryptopts
, "format");
737 opts
= qemu_opts_create(&qcow2_runtime_opts
, NULL
, 0, &error_abort
);
738 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
740 error_propagate(errp
, local_err
);
745 /* get L2 table/refcount block cache size from command line options */
746 read_cache_sizes(bs
, opts
, &l2_cache_size
, &refcount_cache_size
,
749 error_propagate(errp
, local_err
);
754 l2_cache_size
/= s
->cluster_size
;
755 if (l2_cache_size
< MIN_L2_CACHE_SIZE
) {
756 l2_cache_size
= MIN_L2_CACHE_SIZE
;
758 if (l2_cache_size
> INT_MAX
) {
759 error_setg(errp
, "L2 cache size too big");
764 refcount_cache_size
/= s
->cluster_size
;
765 if (refcount_cache_size
< MIN_REFCOUNT_CACHE_SIZE
) {
766 refcount_cache_size
= MIN_REFCOUNT_CACHE_SIZE
;
768 if (refcount_cache_size
> INT_MAX
) {
769 error_setg(errp
, "Refcount cache size too big");
774 /* alloc new L2 table/refcount block cache, flush old one */
775 if (s
->l2_table_cache
) {
776 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
778 error_setg_errno(errp
, -ret
, "Failed to flush the L2 table cache");
783 if (s
->refcount_block_cache
) {
784 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
786 error_setg_errno(errp
, -ret
,
787 "Failed to flush the refcount block cache");
792 r
->l2_table_cache
= qcow2_cache_create(bs
, l2_cache_size
);
793 r
->refcount_block_cache
= qcow2_cache_create(bs
, refcount_cache_size
);
794 if (r
->l2_table_cache
== NULL
|| r
->refcount_block_cache
== NULL
) {
795 error_setg(errp
, "Could not allocate metadata caches");
800 /* New interval for cache cleanup timer */
801 r
->cache_clean_interval
=
802 qemu_opt_get_number(opts
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
803 s
->cache_clean_interval
);
805 if (r
->cache_clean_interval
!= 0) {
806 error_setg(errp
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
807 " not supported on this host");
812 if (r
->cache_clean_interval
> UINT_MAX
) {
813 error_setg(errp
, "Cache clean interval too big");
818 /* lazy-refcounts; flush if going from enabled to disabled */
819 r
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
820 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
821 if (r
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
822 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
823 "qemu 1.1 compatibility level");
828 if (s
->use_lazy_refcounts
&& !r
->use_lazy_refcounts
) {
829 ret
= qcow2_mark_clean(bs
);
831 error_setg_errno(errp
, -ret
, "Failed to disable lazy refcounts");
836 /* Overlap check options */
837 opt_overlap_check
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP
);
838 opt_overlap_check_template
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP_TEMPLATE
);
839 if (opt_overlap_check_template
&& opt_overlap_check
&&
840 strcmp(opt_overlap_check_template
, opt_overlap_check
))
842 error_setg(errp
, "Conflicting values for qcow2 options '"
843 QCOW2_OPT_OVERLAP
"' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
844 "' ('%s')", opt_overlap_check
, opt_overlap_check_template
);
848 if (!opt_overlap_check
) {
849 opt_overlap_check
= opt_overlap_check_template
?: "cached";
852 if (!strcmp(opt_overlap_check
, "none")) {
853 overlap_check_template
= 0;
854 } else if (!strcmp(opt_overlap_check
, "constant")) {
855 overlap_check_template
= QCOW2_OL_CONSTANT
;
856 } else if (!strcmp(opt_overlap_check
, "cached")) {
857 overlap_check_template
= QCOW2_OL_CACHED
;
858 } else if (!strcmp(opt_overlap_check
, "all")) {
859 overlap_check_template
= QCOW2_OL_ALL
;
861 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
862 "'overlap-check'. Allowed are any of the following: "
863 "none, constant, cached, all", opt_overlap_check
);
868 r
->overlap_check
= 0;
869 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
870 /* overlap-check defines a template bitmask, but every flag may be
871 * overwritten through the associated boolean option */
873 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
874 overlap_check_template
& (1 << i
)) << i
;
877 r
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
878 r
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
879 r
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
880 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
881 flags
& BDRV_O_UNMAP
);
882 r
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
883 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
884 r
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
885 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
887 switch (s
->crypt_method_header
) {
888 case QCOW_CRYPT_NONE
:
890 error_setg(errp
, "No encryption in image header, but options "
891 "specified format '%s'", encryptfmt
);
898 if (encryptfmt
&& !g_str_equal(encryptfmt
, "aes")) {
900 "Header reported 'aes' encryption format but "
901 "options specify '%s'", encryptfmt
);
905 qdict_del(encryptopts
, "format");
906 r
->crypto_opts
= block_crypto_open_opts_init(
907 Q_CRYPTO_BLOCK_FORMAT_QCOW
, encryptopts
, errp
);
910 case QCOW_CRYPT_LUKS
:
911 if (encryptfmt
&& !g_str_equal(encryptfmt
, "luks")) {
913 "Header reported 'luks' encryption format but "
914 "options specify '%s'", encryptfmt
);
918 qdict_del(encryptopts
, "format");
919 r
->crypto_opts
= block_crypto_open_opts_init(
920 Q_CRYPTO_BLOCK_FORMAT_LUKS
, encryptopts
, errp
);
924 error_setg(errp
, "Unsupported encryption method %d",
925 s
->crypt_method_header
);
928 if (s
->crypt_method_header
!= QCOW_CRYPT_NONE
&& !r
->crypto_opts
) {
935 QDECREF(encryptopts
);
941 static void qcow2_update_options_commit(BlockDriverState
*bs
,
944 BDRVQcow2State
*s
= bs
->opaque
;
947 if (s
->l2_table_cache
) {
948 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
950 if (s
->refcount_block_cache
) {
951 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
953 s
->l2_table_cache
= r
->l2_table_cache
;
954 s
->refcount_block_cache
= r
->refcount_block_cache
;
956 s
->overlap_check
= r
->overlap_check
;
957 s
->use_lazy_refcounts
= r
->use_lazy_refcounts
;
959 for (i
= 0; i
< QCOW2_DISCARD_MAX
; i
++) {
960 s
->discard_passthrough
[i
] = r
->discard_passthrough
[i
];
963 if (s
->cache_clean_interval
!= r
->cache_clean_interval
) {
964 cache_clean_timer_del(bs
);
965 s
->cache_clean_interval
= r
->cache_clean_interval
;
966 cache_clean_timer_init(bs
, bdrv_get_aio_context(bs
));
969 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
970 s
->crypto_opts
= r
->crypto_opts
;
973 static void qcow2_update_options_abort(BlockDriverState
*bs
,
976 if (r
->l2_table_cache
) {
977 qcow2_cache_destroy(bs
, r
->l2_table_cache
);
979 if (r
->refcount_block_cache
) {
980 qcow2_cache_destroy(bs
, r
->refcount_block_cache
);
982 qapi_free_QCryptoBlockOpenOptions(r
->crypto_opts
);
985 static int qcow2_update_options(BlockDriverState
*bs
, QDict
*options
,
986 int flags
, Error
**errp
)
988 Qcow2ReopenState r
= {};
991 ret
= qcow2_update_options_prepare(bs
, &r
, options
, flags
, errp
);
993 qcow2_update_options_commit(bs
, &r
);
995 qcow2_update_options_abort(bs
, &r
);
1001 static int qcow2_do_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1004 BDRVQcow2State
*s
= bs
->opaque
;
1005 unsigned int len
, i
;
1008 Error
*local_err
= NULL
;
1010 uint64_t l1_vm_state_index
;
1012 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
1014 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
1017 be32_to_cpus(&header
.magic
);
1018 be32_to_cpus(&header
.version
);
1019 be64_to_cpus(&header
.backing_file_offset
);
1020 be32_to_cpus(&header
.backing_file_size
);
1021 be64_to_cpus(&header
.size
);
1022 be32_to_cpus(&header
.cluster_bits
);
1023 be32_to_cpus(&header
.crypt_method
);
1024 be64_to_cpus(&header
.l1_table_offset
);
1025 be32_to_cpus(&header
.l1_size
);
1026 be64_to_cpus(&header
.refcount_table_offset
);
1027 be32_to_cpus(&header
.refcount_table_clusters
);
1028 be64_to_cpus(&header
.snapshots_offset
);
1029 be32_to_cpus(&header
.nb_snapshots
);
1031 if (header
.magic
!= QCOW_MAGIC
) {
1032 error_setg(errp
, "Image is not in qcow2 format");
1036 if (header
.version
< 2 || header
.version
> 3) {
1037 error_setg(errp
, "Unsupported qcow2 version %" PRIu32
, header
.version
);
1042 s
->qcow_version
= header
.version
;
1044 /* Initialise cluster size */
1045 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
1046 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
1047 error_setg(errp
, "Unsupported cluster size: 2^%" PRIu32
,
1048 header
.cluster_bits
);
1053 s
->cluster_bits
= header
.cluster_bits
;
1054 s
->cluster_size
= 1 << s
->cluster_bits
;
1055 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
1057 /* Initialise version 3 header fields */
1058 if (header
.version
== 2) {
1059 header
.incompatible_features
= 0;
1060 header
.compatible_features
= 0;
1061 header
.autoclear_features
= 0;
1062 header
.refcount_order
= 4;
1063 header
.header_length
= 72;
1065 be64_to_cpus(&header
.incompatible_features
);
1066 be64_to_cpus(&header
.compatible_features
);
1067 be64_to_cpus(&header
.autoclear_features
);
1068 be32_to_cpus(&header
.refcount_order
);
1069 be32_to_cpus(&header
.header_length
);
1071 if (header
.header_length
< 104) {
1072 error_setg(errp
, "qcow2 header too short");
1078 if (header
.header_length
> s
->cluster_size
) {
1079 error_setg(errp
, "qcow2 header exceeds cluster size");
1084 if (header
.header_length
> sizeof(header
)) {
1085 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
1086 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
1087 ret
= bdrv_pread(bs
->file
, sizeof(header
), s
->unknown_header_fields
,
1088 s
->unknown_header_fields_size
);
1090 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
1096 if (header
.backing_file_offset
> s
->cluster_size
) {
1097 error_setg(errp
, "Invalid backing file offset");
1102 if (header
.backing_file_offset
) {
1103 ext_end
= header
.backing_file_offset
;
1105 ext_end
= 1 << header
.cluster_bits
;
1108 /* Handle feature bits */
1109 s
->incompatible_features
= header
.incompatible_features
;
1110 s
->compatible_features
= header
.compatible_features
;
1111 s
->autoclear_features
= header
.autoclear_features
;
1113 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
1114 void *feature_table
= NULL
;
1115 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
1116 &feature_table
, flags
, NULL
);
1117 report_unsupported_feature(errp
, feature_table
,
1118 s
->incompatible_features
&
1119 ~QCOW2_INCOMPAT_MASK
);
1121 g_free(feature_table
);
1125 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
1126 /* Corrupt images may not be written to unless they are being repaired
1128 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
1129 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
1136 /* Check support for various header values */
1137 if (header
.refcount_order
> 6) {
1138 error_setg(errp
, "Reference count entry width too large; may not "
1143 s
->refcount_order
= header
.refcount_order
;
1144 s
->refcount_bits
= 1 << s
->refcount_order
;
1145 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
1146 s
->refcount_max
+= s
->refcount_max
- 1;
1148 s
->crypt_method_header
= header
.crypt_method
;
1149 if (s
->crypt_method_header
) {
1150 if (bdrv_uses_whitelist() &&
1151 s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1153 "Use of AES-CBC encrypted qcow2 images is no longer "
1154 "supported in system emulators");
1155 error_append_hint(errp
,
1156 "You can use 'qemu-img convert' to convert your "
1157 "image to an alternative supported format, such "
1158 "as unencrypted qcow2, or raw with the LUKS "
1159 "format instead.\n");
1164 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1165 s
->crypt_physical_offset
= false;
1167 /* Assuming LUKS and any future crypt methods we
1168 * add will all use physical offsets, due to the
1169 * fact that the alternative is insecure... */
1170 s
->crypt_physical_offset
= true;
1173 bs
->encrypted
= true;
1174 bs
->valid_key
= true;
1177 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
1178 s
->l2_size
= 1 << s
->l2_bits
;
1179 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1180 s
->refcount_block_bits
= s
->cluster_bits
- (s
->refcount_order
- 3);
1181 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
1182 bs
->total_sectors
= header
.size
/ 512;
1183 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
1184 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
1185 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
1187 s
->refcount_table_offset
= header
.refcount_table_offset
;
1188 s
->refcount_table_size
=
1189 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
1191 if (header
.refcount_table_clusters
> qcow2_max_refcount_clusters(s
)) {
1192 error_setg(errp
, "Reference count table too large");
1197 ret
= validate_table_offset(bs
, s
->refcount_table_offset
,
1198 s
->refcount_table_size
, sizeof(uint64_t));
1200 error_setg(errp
, "Invalid reference count table offset");
1204 /* Snapshot table offset/length */
1205 if (header
.nb_snapshots
> QCOW_MAX_SNAPSHOTS
) {
1206 error_setg(errp
, "Too many snapshots");
1211 ret
= validate_table_offset(bs
, header
.snapshots_offset
,
1212 header
.nb_snapshots
,
1213 sizeof(QCowSnapshotHeader
));
1215 error_setg(errp
, "Invalid snapshot table offset");
1219 /* read the level 1 table */
1220 if (header
.l1_size
> QCOW_MAX_L1_SIZE
/ sizeof(uint64_t)) {
1221 error_setg(errp
, "Active L1 table too large");
1225 s
->l1_size
= header
.l1_size
;
1227 l1_vm_state_index
= size_to_l1(s
, header
.size
);
1228 if (l1_vm_state_index
> INT_MAX
) {
1229 error_setg(errp
, "Image is too big");
1233 s
->l1_vm_state_index
= l1_vm_state_index
;
1235 /* the L1 table must contain at least enough entries to put
1236 header.size bytes */
1237 if (s
->l1_size
< s
->l1_vm_state_index
) {
1238 error_setg(errp
, "L1 table is too small");
1243 ret
= validate_table_offset(bs
, header
.l1_table_offset
,
1244 header
.l1_size
, sizeof(uint64_t));
1246 error_setg(errp
, "Invalid L1 table offset");
1249 s
->l1_table_offset
= header
.l1_table_offset
;
1252 if (s
->l1_size
> 0) {
1253 s
->l1_table
= qemu_try_blockalign(bs
->file
->bs
,
1254 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
1255 if (s
->l1_table
== NULL
) {
1256 error_setg(errp
, "Could not allocate L1 table");
1260 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
1261 s
->l1_size
* sizeof(uint64_t));
1263 error_setg_errno(errp
, -ret
, "Could not read L1 table");
1266 for(i
= 0;i
< s
->l1_size
; i
++) {
1267 be64_to_cpus(&s
->l1_table
[i
]);
1271 /* Parse driver-specific options */
1272 ret
= qcow2_update_options(bs
, options
, flags
, errp
);
1277 s
->cluster_cache
= g_malloc(s
->cluster_size
);
1278 /* one more sector for decompressed data alignment */
1279 s
->cluster_data
= qemu_try_blockalign(bs
->file
->bs
, QCOW_MAX_CRYPT_CLUSTERS
1280 * s
->cluster_size
+ 512);
1281 if (s
->cluster_data
== NULL
) {
1282 error_setg(errp
, "Could not allocate temporary cluster buffer");
1287 s
->cluster_cache_offset
= -1;
1290 ret
= qcow2_refcount_init(bs
);
1292 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
1296 QLIST_INIT(&s
->cluster_allocs
);
1297 QTAILQ_INIT(&s
->discards
);
1299 /* read qcow2 extensions */
1300 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
1301 flags
, &local_err
)) {
1302 error_propagate(errp
, local_err
);
1307 /* qcow2_read_extension may have set up the crypto context
1308 * if the crypt method needs a header region, some methods
1309 * don't need header extensions, so must check here
1311 if (s
->crypt_method_header
&& !s
->crypto
) {
1312 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1313 unsigned int cflags
= 0;
1314 if (flags
& BDRV_O_NO_IO
) {
1315 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
1317 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, NULL
, NULL
,
1323 } else if (!(flags
& BDRV_O_NO_IO
)) {
1324 error_setg(errp
, "Missing CRYPTO header for crypt method %d",
1325 s
->crypt_method_header
);
1331 /* read the backing file name */
1332 if (header
.backing_file_offset
!= 0) {
1333 len
= header
.backing_file_size
;
1334 if (len
> MIN(1023, s
->cluster_size
- header
.backing_file_offset
) ||
1335 len
>= sizeof(bs
->backing_file
)) {
1336 error_setg(errp
, "Backing file name too long");
1340 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
1341 bs
->backing_file
, len
);
1343 error_setg_errno(errp
, -ret
, "Could not read backing file name");
1346 bs
->backing_file
[len
] = '\0';
1347 s
->image_backing_file
= g_strdup(bs
->backing_file
);
1350 /* Internal snapshots */
1351 s
->snapshots_offset
= header
.snapshots_offset
;
1352 s
->nb_snapshots
= header
.nb_snapshots
;
1354 ret
= qcow2_read_snapshots(bs
);
1356 error_setg_errno(errp
, -ret
, "Could not read snapshots");
1360 /* Clear unknown autoclear feature bits */
1361 if (!bs
->read_only
&& !(flags
& BDRV_O_INACTIVE
) && s
->autoclear_features
) {
1362 s
->autoclear_features
= 0;
1363 ret
= qcow2_update_header(bs
);
1365 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
1370 /* Initialise locks */
1371 qemu_co_mutex_init(&s
->lock
);
1372 bs
->supported_zero_flags
= BDRV_REQ_MAY_UNMAP
;
1374 /* Repair image if dirty */
1375 if (!(flags
& (BDRV_O_CHECK
| BDRV_O_INACTIVE
)) && !bs
->read_only
&&
1376 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
1377 BdrvCheckResult result
= {0};
1379 ret
= qcow2_check(bs
, &result
, BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1381 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
1388 BdrvCheckResult result
= {0};
1389 qcow2_check_refcounts(bs
, &result
, 0);
1395 g_free(s
->unknown_header_fields
);
1396 cleanup_unknown_header_ext(bs
);
1397 qcow2_free_snapshots(bs
);
1398 qcow2_refcount_close(bs
);
1399 qemu_vfree(s
->l1_table
);
1400 /* else pre-write overlap checks in cache_destroy may crash */
1402 cache_clean_timer_del(bs
);
1403 if (s
->l2_table_cache
) {
1404 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1406 if (s
->refcount_block_cache
) {
1407 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1409 g_free(s
->cluster_cache
);
1410 qemu_vfree(s
->cluster_data
);
1411 qcrypto_block_free(s
->crypto
);
1412 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1416 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1419 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
1425 return qcow2_do_open(bs
, options
, flags
, errp
);
1428 static void qcow2_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
1430 BDRVQcow2State
*s
= bs
->opaque
;
1432 if (bs
->encrypted
) {
1433 /* Encryption works on a sector granularity */
1434 bs
->bl
.request_alignment
= BDRV_SECTOR_SIZE
;
1436 bs
->bl
.pwrite_zeroes_alignment
= s
->cluster_size
;
1437 bs
->bl
.pdiscard_alignment
= s
->cluster_size
;
1440 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
1441 BlockReopenQueue
*queue
, Error
**errp
)
1443 Qcow2ReopenState
*r
;
1446 r
= g_new0(Qcow2ReopenState
, 1);
1449 ret
= qcow2_update_options_prepare(state
->bs
, r
, state
->options
,
1450 state
->flags
, errp
);
1455 /* We need to write out any unwritten data if we reopen read-only. */
1456 if ((state
->flags
& BDRV_O_RDWR
) == 0) {
1457 ret
= bdrv_flush(state
->bs
);
1462 ret
= qcow2_mark_clean(state
->bs
);
1471 qcow2_update_options_abort(state
->bs
, r
);
1476 static void qcow2_reopen_commit(BDRVReopenState
*state
)
1478 qcow2_update_options_commit(state
->bs
, state
->opaque
);
1479 g_free(state
->opaque
);
1482 static void qcow2_reopen_abort(BDRVReopenState
*state
)
1484 qcow2_update_options_abort(state
->bs
, state
->opaque
);
1485 g_free(state
->opaque
);
1488 static void qcow2_join_options(QDict
*options
, QDict
*old_options
)
1490 bool has_new_overlap_template
=
1491 qdict_haskey(options
, QCOW2_OPT_OVERLAP
) ||
1492 qdict_haskey(options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1493 bool has_new_total_cache_size
=
1494 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
);
1495 bool has_all_cache_options
;
1497 /* New overlap template overrides all old overlap options */
1498 if (has_new_overlap_template
) {
1499 qdict_del(old_options
, QCOW2_OPT_OVERLAP
);
1500 qdict_del(old_options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1501 qdict_del(old_options
, QCOW2_OPT_OVERLAP_MAIN_HEADER
);
1502 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L1
);
1503 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L2
);
1504 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
);
1505 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
);
1506 qdict_del(old_options
, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
);
1507 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L1
);
1508 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L2
);
1511 /* New total cache size overrides all old options */
1512 if (qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
)) {
1513 qdict_del(old_options
, QCOW2_OPT_L2_CACHE_SIZE
);
1514 qdict_del(old_options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1517 qdict_join(options
, old_options
, false);
1520 * If after merging all cache size options are set, an old total size is
1521 * overwritten. Do keep all options, however, if all three are new. The
1522 * resulting error message is what we want to happen.
1524 has_all_cache_options
=
1525 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
) ||
1526 qdict_haskey(options
, QCOW2_OPT_L2_CACHE_SIZE
) ||
1527 qdict_haskey(options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1529 if (has_all_cache_options
&& !has_new_total_cache_size
) {
1530 qdict_del(options
, QCOW2_OPT_CACHE_SIZE
);
1534 static int64_t coroutine_fn
qcow2_co_get_block_status(BlockDriverState
*bs
,
1535 int64_t sector_num
, int nb_sectors
, int *pnum
, BlockDriverState
**file
)
1537 BDRVQcow2State
*s
= bs
->opaque
;
1538 uint64_t cluster_offset
;
1539 int index_in_cluster
, ret
;
1543 bytes
= MIN(INT_MAX
, nb_sectors
* BDRV_SECTOR_SIZE
);
1544 qemu_co_mutex_lock(&s
->lock
);
1545 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9, &bytes
,
1547 qemu_co_mutex_unlock(&s
->lock
);
1552 *pnum
= bytes
>> BDRV_SECTOR_BITS
;
1554 if (cluster_offset
!= 0 && ret
!= QCOW2_CLUSTER_COMPRESSED
&&
1556 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1557 cluster_offset
|= (index_in_cluster
<< BDRV_SECTOR_BITS
);
1558 *file
= bs
->file
->bs
;
1559 status
|= BDRV_BLOCK_OFFSET_VALID
| cluster_offset
;
1561 if (ret
== QCOW2_CLUSTER_ZERO_PLAIN
|| ret
== QCOW2_CLUSTER_ZERO_ALLOC
) {
1562 status
|= BDRV_BLOCK_ZERO
;
1563 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
1564 status
|= BDRV_BLOCK_DATA
;
1569 /* handle reading after the end of the backing file */
1570 int qcow2_backing_read1(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
1571 int64_t offset
, int bytes
)
1573 uint64_t bs_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1576 if ((offset
+ bytes
) <= bs_size
) {
1580 if (offset
>= bs_size
) {
1583 n1
= bs_size
- offset
;
1586 qemu_iovec_memset(qiov
, n1
, 0, bytes
- n1
);
1591 static coroutine_fn
int qcow2_co_preadv(BlockDriverState
*bs
, uint64_t offset
,
1592 uint64_t bytes
, QEMUIOVector
*qiov
,
1595 BDRVQcow2State
*s
= bs
->opaque
;
1596 int offset_in_cluster
, n1
;
1598 unsigned int cur_bytes
; /* number of bytes in current iteration */
1599 uint64_t cluster_offset
= 0;
1600 uint64_t bytes_done
= 0;
1601 QEMUIOVector hd_qiov
;
1602 uint8_t *cluster_data
= NULL
;
1604 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1606 qemu_co_mutex_lock(&s
->lock
);
1608 while (bytes
!= 0) {
1610 /* prepare next request */
1611 cur_bytes
= MIN(bytes
, INT_MAX
);
1613 cur_bytes
= MIN(cur_bytes
,
1614 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1617 ret
= qcow2_get_cluster_offset(bs
, offset
, &cur_bytes
, &cluster_offset
);
1622 offset_in_cluster
= offset_into_cluster(s
, offset
);
1624 qemu_iovec_reset(&hd_qiov
);
1625 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
1628 case QCOW2_CLUSTER_UNALLOCATED
:
1631 /* read from the base image */
1632 n1
= qcow2_backing_read1(bs
->backing
->bs
, &hd_qiov
,
1635 QEMUIOVector local_qiov
;
1637 qemu_iovec_init(&local_qiov
, hd_qiov
.niov
);
1638 qemu_iovec_concat(&local_qiov
, &hd_qiov
, 0, n1
);
1640 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
1641 qemu_co_mutex_unlock(&s
->lock
);
1642 ret
= bdrv_co_preadv(bs
->backing
, offset
, n1
,
1644 qemu_co_mutex_lock(&s
->lock
);
1646 qemu_iovec_destroy(&local_qiov
);
1653 /* Note: in this case, no need to wait */
1654 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1658 case QCOW2_CLUSTER_ZERO_PLAIN
:
1659 case QCOW2_CLUSTER_ZERO_ALLOC
:
1660 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1663 case QCOW2_CLUSTER_COMPRESSED
:
1664 /* add AIO support for compressed blocks ? */
1665 ret
= qcow2_decompress_cluster(bs
, cluster_offset
);
1670 qemu_iovec_from_buf(&hd_qiov
, 0,
1671 s
->cluster_cache
+ offset_in_cluster
,
1675 case QCOW2_CLUSTER_NORMAL
:
1676 if ((cluster_offset
& 511) != 0) {
1681 if (bs
->encrypted
) {
1685 * For encrypted images, read everything into a temporary
1686 * contiguous buffer on which the AES functions can work.
1688 if (!cluster_data
) {
1690 qemu_try_blockalign(bs
->file
->bs
,
1691 QCOW_MAX_CRYPT_CLUSTERS
1693 if (cluster_data
== NULL
) {
1699 assert(cur_bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1700 qemu_iovec_reset(&hd_qiov
);
1701 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
1704 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
1705 qemu_co_mutex_unlock(&s
->lock
);
1706 ret
= bdrv_co_preadv(bs
->file
,
1707 cluster_offset
+ offset_in_cluster
,
1708 cur_bytes
, &hd_qiov
, 0);
1709 qemu_co_mutex_lock(&s
->lock
);
1713 if (bs
->encrypted
) {
1715 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1716 assert((cur_bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1718 if (qcrypto_block_decrypt(s
->crypto
,
1719 (s
->crypt_physical_offset
?
1720 cluster_offset
+ offset_in_cluster
:
1721 offset
) >> BDRV_SECTOR_BITS
,
1729 qemu_iovec_from_buf(qiov
, bytes_done
, cluster_data
, cur_bytes
);
1734 g_assert_not_reached();
1740 offset
+= cur_bytes
;
1741 bytes_done
+= cur_bytes
;
1746 qemu_co_mutex_unlock(&s
->lock
);
1748 qemu_iovec_destroy(&hd_qiov
);
1749 qemu_vfree(cluster_data
);
1754 /* Check if it's possible to merge a write request with the writing of
1755 * the data from the COW regions */
1756 static bool merge_cow(uint64_t offset
, unsigned bytes
,
1757 QEMUIOVector
*hd_qiov
, QCowL2Meta
*l2meta
)
1761 for (m
= l2meta
; m
!= NULL
; m
= m
->next
) {
1762 /* If both COW regions are empty then there's nothing to merge */
1763 if (m
->cow_start
.nb_bytes
== 0 && m
->cow_end
.nb_bytes
== 0) {
1767 /* The data (middle) region must be immediately after the
1769 if (l2meta_cow_start(m
) + m
->cow_start
.nb_bytes
!= offset
) {
1773 /* The end region must be immediately after the data (middle)
1775 if (m
->offset
+ m
->cow_end
.offset
!= offset
+ bytes
) {
1779 /* Make sure that adding both COW regions to the QEMUIOVector
1780 * does not exceed IOV_MAX */
1781 if (hd_qiov
->niov
> IOV_MAX
- 2) {
1785 m
->data_qiov
= hd_qiov
;
1792 static coroutine_fn
int qcow2_co_pwritev(BlockDriverState
*bs
, uint64_t offset
,
1793 uint64_t bytes
, QEMUIOVector
*qiov
,
1796 BDRVQcow2State
*s
= bs
->opaque
;
1797 int offset_in_cluster
;
1799 unsigned int cur_bytes
; /* number of sectors in current iteration */
1800 uint64_t cluster_offset
;
1801 QEMUIOVector hd_qiov
;
1802 uint64_t bytes_done
= 0;
1803 uint8_t *cluster_data
= NULL
;
1804 QCowL2Meta
*l2meta
= NULL
;
1806 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset
, bytes
);
1808 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1810 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1812 qemu_co_mutex_lock(&s
->lock
);
1814 while (bytes
!= 0) {
1818 trace_qcow2_writev_start_part(qemu_coroutine_self());
1819 offset_in_cluster
= offset_into_cluster(s
, offset
);
1820 cur_bytes
= MIN(bytes
, INT_MAX
);
1821 if (bs
->encrypted
) {
1822 cur_bytes
= MIN(cur_bytes
,
1823 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
1824 - offset_in_cluster
);
1827 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
1828 &cluster_offset
, &l2meta
);
1833 assert((cluster_offset
& 511) == 0);
1835 qemu_iovec_reset(&hd_qiov
);
1836 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
1838 if (bs
->encrypted
) {
1841 if (!cluster_data
) {
1842 cluster_data
= qemu_try_blockalign(bs
->file
->bs
,
1843 QCOW_MAX_CRYPT_CLUSTERS
1845 if (cluster_data
== NULL
) {
1851 assert(hd_qiov
.size
<=
1852 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1853 qemu_iovec_to_buf(&hd_qiov
, 0, cluster_data
, hd_qiov
.size
);
1855 if (qcrypto_block_encrypt(s
->crypto
,
1856 (s
->crypt_physical_offset
?
1857 cluster_offset
+ offset_in_cluster
:
1858 offset
) >> BDRV_SECTOR_BITS
,
1860 cur_bytes
, &err
) < 0) {
1866 qemu_iovec_reset(&hd_qiov
);
1867 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
1870 ret
= qcow2_pre_write_overlap_check(bs
, 0,
1871 cluster_offset
+ offset_in_cluster
, cur_bytes
);
1876 /* If we need to do COW, check if it's possible to merge the
1877 * writing of the guest data together with that of the COW regions.
1878 * If it's not possible (or not necessary) then write the
1879 * guest data now. */
1880 if (!merge_cow(offset
, cur_bytes
, &hd_qiov
, l2meta
)) {
1881 qemu_co_mutex_unlock(&s
->lock
);
1882 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
1883 trace_qcow2_writev_data(qemu_coroutine_self(),
1884 cluster_offset
+ offset_in_cluster
);
1885 ret
= bdrv_co_pwritev(bs
->file
,
1886 cluster_offset
+ offset_in_cluster
,
1887 cur_bytes
, &hd_qiov
, 0);
1888 qemu_co_mutex_lock(&s
->lock
);
1894 while (l2meta
!= NULL
) {
1897 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
1902 /* Take the request off the list of running requests */
1903 if (l2meta
->nb_clusters
!= 0) {
1904 QLIST_REMOVE(l2meta
, next_in_flight
);
1907 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1909 next
= l2meta
->next
;
1915 offset
+= cur_bytes
;
1916 bytes_done
+= cur_bytes
;
1917 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes
);
1922 qemu_co_mutex_unlock(&s
->lock
);
1924 while (l2meta
!= NULL
) {
1927 if (l2meta
->nb_clusters
!= 0) {
1928 QLIST_REMOVE(l2meta
, next_in_flight
);
1930 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1932 next
= l2meta
->next
;
1937 qemu_iovec_destroy(&hd_qiov
);
1938 qemu_vfree(cluster_data
);
1939 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
1944 static int qcow2_inactivate(BlockDriverState
*bs
)
1946 BDRVQcow2State
*s
= bs
->opaque
;
1947 int ret
, result
= 0;
1949 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1952 error_report("Failed to flush the L2 table cache: %s",
1956 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1959 error_report("Failed to flush the refcount block cache: %s",
1964 qcow2_mark_clean(bs
);
1970 static void qcow2_close(BlockDriverState
*bs
)
1972 BDRVQcow2State
*s
= bs
->opaque
;
1973 qemu_vfree(s
->l1_table
);
1974 /* else pre-write overlap checks in cache_destroy may crash */
1977 if (!(s
->flags
& BDRV_O_INACTIVE
)) {
1978 qcow2_inactivate(bs
);
1981 cache_clean_timer_del(bs
);
1982 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1983 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1985 qcrypto_block_free(s
->crypto
);
1988 g_free(s
->unknown_header_fields
);
1989 cleanup_unknown_header_ext(bs
);
1991 g_free(s
->image_backing_file
);
1992 g_free(s
->image_backing_format
);
1994 g_free(s
->cluster_cache
);
1995 qemu_vfree(s
->cluster_data
);
1996 qcow2_refcount_close(bs
);
1997 qcow2_free_snapshots(bs
);
2000 static void qcow2_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
2002 BDRVQcow2State
*s
= bs
->opaque
;
2003 int flags
= s
->flags
;
2004 QCryptoBlock
*crypto
= NULL
;
2006 Error
*local_err
= NULL
;
2010 * Backing files are read-only which makes all of their metadata immutable,
2011 * that means we don't have to worry about reopening them here.
2019 memset(s
, 0, sizeof(BDRVQcow2State
));
2020 options
= qdict_clone_shallow(bs
->options
);
2022 flags
&= ~BDRV_O_INACTIVE
;
2023 ret
= qcow2_do_open(bs
, options
, flags
, &local_err
);
2026 error_propagate(errp
, local_err
);
2027 error_prepend(errp
, "Could not reopen qcow2 layer: ");
2030 } else if (ret
< 0) {
2031 error_setg_errno(errp
, -ret
, "Could not reopen qcow2 layer");
2039 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
2040 size_t len
, size_t buflen
)
2042 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
2043 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
2045 if (buflen
< ext_len
) {
2049 *ext_backing_fmt
= (QCowExtension
) {
2050 .magic
= cpu_to_be32(magic
),
2051 .len
= cpu_to_be32(len
),
2055 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
2062 * Updates the qcow2 header, including the variable length parts of it, i.e.
2063 * the backing file name and all extensions. qcow2 was not designed to allow
2064 * such changes, so if we run out of space (we can only use the first cluster)
2065 * this function may fail.
2067 * Returns 0 on success, -errno in error cases.
2069 int qcow2_update_header(BlockDriverState
*bs
)
2071 BDRVQcow2State
*s
= bs
->opaque
;
2074 size_t buflen
= s
->cluster_size
;
2076 uint64_t total_size
;
2077 uint32_t refcount_table_clusters
;
2078 size_t header_length
;
2079 Qcow2UnknownHeaderExtension
*uext
;
2081 buf
= qemu_blockalign(bs
, buflen
);
2083 /* Header structure */
2084 header
= (QCowHeader
*) buf
;
2086 if (buflen
< sizeof(*header
)) {
2091 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
2092 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2093 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
2095 *header
= (QCowHeader
) {
2096 /* Version 2 fields */
2097 .magic
= cpu_to_be32(QCOW_MAGIC
),
2098 .version
= cpu_to_be32(s
->qcow_version
),
2099 .backing_file_offset
= 0,
2100 .backing_file_size
= 0,
2101 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
2102 .size
= cpu_to_be64(total_size
),
2103 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
2104 .l1_size
= cpu_to_be32(s
->l1_size
),
2105 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
2106 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
2107 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
2108 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
2109 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
2111 /* Version 3 fields */
2112 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
2113 .compatible_features
= cpu_to_be64(s
->compatible_features
),
2114 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
2115 .refcount_order
= cpu_to_be32(s
->refcount_order
),
2116 .header_length
= cpu_to_be32(header_length
),
2119 /* For older versions, write a shorter header */
2120 switch (s
->qcow_version
) {
2122 ret
= offsetof(QCowHeader
, incompatible_features
);
2125 ret
= sizeof(*header
);
2134 memset(buf
, 0, buflen
);
2136 /* Preserve any unknown field in the header */
2137 if (s
->unknown_header_fields_size
) {
2138 if (buflen
< s
->unknown_header_fields_size
) {
2143 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
2144 buf
+= s
->unknown_header_fields_size
;
2145 buflen
-= s
->unknown_header_fields_size
;
2148 /* Backing file format header extension */
2149 if (s
->image_backing_format
) {
2150 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
2151 s
->image_backing_format
,
2152 strlen(s
->image_backing_format
),
2162 /* Full disk encryption header pointer extension */
2163 if (s
->crypto_header
.offset
!= 0) {
2164 cpu_to_be64s(&s
->crypto_header
.offset
);
2165 cpu_to_be64s(&s
->crypto_header
.length
);
2166 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_CRYPTO_HEADER
,
2167 &s
->crypto_header
, sizeof(s
->crypto_header
),
2169 be64_to_cpus(&s
->crypto_header
.offset
);
2170 be64_to_cpus(&s
->crypto_header
.length
);
2179 if (s
->qcow_version
>= 3) {
2180 Qcow2Feature features
[] = {
2182 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2183 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
2184 .name
= "dirty bit",
2187 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2188 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
2189 .name
= "corrupt bit",
2192 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
2193 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
2194 .name
= "lazy refcounts",
2198 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
2199 features
, sizeof(features
), buflen
);
2207 /* Keep unknown header extensions */
2208 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
2209 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
2218 /* End of header extensions */
2219 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
2227 /* Backing file name */
2228 if (s
->image_backing_file
) {
2229 size_t backing_file_len
= strlen(s
->image_backing_file
);
2231 if (buflen
< backing_file_len
) {
2236 /* Using strncpy is ok here, since buf is not NUL-terminated. */
2237 strncpy(buf
, s
->image_backing_file
, buflen
);
2239 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
2240 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
2243 /* Write the new header */
2244 ret
= bdrv_pwrite(bs
->file
, 0, header
, s
->cluster_size
);
2255 static int qcow2_change_backing_file(BlockDriverState
*bs
,
2256 const char *backing_file
, const char *backing_fmt
)
2258 BDRVQcow2State
*s
= bs
->opaque
;
2260 if (backing_file
&& strlen(backing_file
) > 1023) {
2264 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2265 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2267 g_free(s
->image_backing_file
);
2268 g_free(s
->image_backing_format
);
2270 s
->image_backing_file
= backing_file
? g_strdup(bs
->backing_file
) : NULL
;
2271 s
->image_backing_format
= backing_fmt
? g_strdup(bs
->backing_format
) : NULL
;
2273 return qcow2_update_header(bs
);
2276 static int qcow2_crypt_method_from_format(const char *encryptfmt
)
2278 if (g_str_equal(encryptfmt
, "luks")) {
2279 return QCOW_CRYPT_LUKS
;
2280 } else if (g_str_equal(encryptfmt
, "aes")) {
2281 return QCOW_CRYPT_AES
;
2287 static int qcow2_set_up_encryption(BlockDriverState
*bs
, const char *encryptfmt
,
2288 QemuOpts
*opts
, Error
**errp
)
2290 BDRVQcow2State
*s
= bs
->opaque
;
2291 QCryptoBlockCreateOptions
*cryptoopts
= NULL
;
2292 QCryptoBlock
*crypto
= NULL
;
2294 QDict
*options
, *encryptopts
;
2297 options
= qemu_opts_to_qdict(opts
, NULL
);
2298 qdict_extract_subqdict(options
, &encryptopts
, "encrypt.");
2301 fmt
= qcow2_crypt_method_from_format(encryptfmt
);
2304 case QCOW_CRYPT_LUKS
:
2305 cryptoopts
= block_crypto_create_opts_init(
2306 Q_CRYPTO_BLOCK_FORMAT_LUKS
, encryptopts
, errp
);
2308 case QCOW_CRYPT_AES
:
2309 cryptoopts
= block_crypto_create_opts_init(
2310 Q_CRYPTO_BLOCK_FORMAT_QCOW
, encryptopts
, errp
);
2313 error_setg(errp
, "Unknown encryption format '%s'", encryptfmt
);
2320 s
->crypt_method_header
= fmt
;
2322 crypto
= qcrypto_block_create(cryptoopts
,
2323 qcow2_crypto_hdr_init_func
,
2324 qcow2_crypto_hdr_write_func
,
2331 ret
= qcow2_update_header(bs
);
2333 error_setg_errno(errp
, -ret
, "Could not write encryption header");
2338 QDECREF(encryptopts
);
2339 qcrypto_block_free(crypto
);
2340 qapi_free_QCryptoBlockCreateOptions(cryptoopts
);
2345 static int preallocate(BlockDriverState
*bs
)
2349 uint64_t host_offset
= 0;
2350 unsigned int cur_bytes
;
2354 bytes
= bdrv_getlength(bs
);
2358 cur_bytes
= MIN(bytes
, INT_MAX
);
2359 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2360 &host_offset
, &meta
);
2366 QCowL2Meta
*next
= meta
->next
;
2368 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
2370 qcow2_free_any_clusters(bs
, meta
->alloc_offset
,
2371 meta
->nb_clusters
, QCOW2_DISCARD_NEVER
);
2375 /* There are no dependent requests, but we need to remove our
2376 * request from the list of in-flight requests */
2377 QLIST_REMOVE(meta
, next_in_flight
);
2383 /* TODO Preallocate data if requested */
2386 offset
+= cur_bytes
;
2390 * It is expected that the image file is large enough to actually contain
2391 * all of the allocated clusters (otherwise we get failing reads after
2392 * EOF). Extend the image to the last allocated sector.
2394 if (host_offset
!= 0) {
2396 ret
= bdrv_pwrite(bs
->file
, (host_offset
+ cur_bytes
) - 1,
2406 static int qcow2_create2(const char *filename
, int64_t total_size
,
2407 const char *backing_file
, const char *backing_format
,
2408 int flags
, size_t cluster_size
, PreallocMode prealloc
,
2409 QemuOpts
*opts
, int version
, int refcount_order
,
2410 const char *encryptfmt
, Error
**errp
)
2415 /* Calculate cluster_bits */
2416 cluster_bits
= ctz32(cluster_size
);
2417 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
2418 (1 << cluster_bits
) != cluster_size
)
2420 error_setg(errp
, "Cluster size must be a power of two between %d and "
2421 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
2426 * Open the image file and write a minimal qcow2 header.
2428 * We keep things simple and start with a zero-sized image. We also
2429 * do without refcount blocks or a L1 table for now. We'll fix the
2430 * inconsistency later.
2432 * We do need a refcount table because growing the refcount table means
2433 * allocating two new refcount blocks - the seconds of which would be at
2434 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
2435 * size for any qcow2 image.
2439 uint64_t* refcount_table
;
2440 Error
*local_err
= NULL
;
2443 if (prealloc
== PREALLOC_MODE_FULL
|| prealloc
== PREALLOC_MODE_FALLOC
) {
2444 /* Note: The following calculation does not need to be exact; if it is a
2445 * bit off, either some bytes will be "leaked" (which is fine) or we
2446 * will need to increase the file size by some bytes (which is fine,
2447 * too, as long as the bulk is allocated here). Therefore, using
2448 * floating point arithmetic is fine. */
2449 int64_t meta_size
= 0;
2450 uint64_t nreftablee
, nrefblocke
, nl1e
, nl2e
, refblock_count
;
2451 int64_t aligned_total_size
= align_offset(total_size
, cluster_size
);
2452 int refblock_bits
, refblock_size
;
2453 /* refcount entry size in bytes */
2454 double rces
= (1 << refcount_order
) / 8.;
2456 /* see qcow2_open() */
2457 refblock_bits
= cluster_bits
- (refcount_order
- 3);
2458 refblock_size
= 1 << refblock_bits
;
2460 /* header: 1 cluster */
2461 meta_size
+= cluster_size
;
2463 /* total size of L2 tables */
2464 nl2e
= aligned_total_size
/ cluster_size
;
2465 nl2e
= align_offset(nl2e
, cluster_size
/ sizeof(uint64_t));
2466 meta_size
+= nl2e
* sizeof(uint64_t);
2468 /* total size of L1 tables */
2469 nl1e
= nl2e
* sizeof(uint64_t) / cluster_size
;
2470 nl1e
= align_offset(nl1e
, cluster_size
/ sizeof(uint64_t));
2471 meta_size
+= nl1e
* sizeof(uint64_t);
2473 /* total size of refcount blocks
2475 * note: every host cluster is reference-counted, including metadata
2476 * (even refcount blocks are recursively included).
2478 * a = total_size (this is the guest disk size)
2479 * m = meta size not including refcount blocks and refcount tables
2481 * y1 = number of refcount blocks entries
2482 * y2 = meta size including everything
2483 * rces = refcount entry size in bytes
2486 * y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m
2488 * y1 = (a + m) / (c - rces - rces * sizeof(u64) / c)
2490 nrefblocke
= (aligned_total_size
+ meta_size
+ cluster_size
)
2491 / (cluster_size
- rces
- rces
* sizeof(uint64_t)
2493 refblock_count
= DIV_ROUND_UP(nrefblocke
, refblock_size
);
2494 meta_size
+= refblock_count
* cluster_size
;
2496 /* total size of refcount tables */
2497 nreftablee
= align_offset(refblock_count
,
2498 cluster_size
/ sizeof(uint64_t));
2499 meta_size
+= nreftablee
* sizeof(uint64_t);
2501 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
,
2502 aligned_total_size
+ meta_size
, &error_abort
);
2503 qemu_opt_set(opts
, BLOCK_OPT_PREALLOC
, PreallocMode_lookup
[prealloc
],
2507 ret
= bdrv_create_file(filename
, opts
, &local_err
);
2509 error_propagate(errp
, local_err
);
2513 blk
= blk_new_open(filename
, NULL
, NULL
,
2514 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
,
2517 error_propagate(errp
, local_err
);
2521 blk_set_allow_write_beyond_eof(blk
, true);
2523 /* Write the header */
2524 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS
) < sizeof(*header
));
2525 header
= g_malloc0(cluster_size
);
2526 *header
= (QCowHeader
) {
2527 .magic
= cpu_to_be32(QCOW_MAGIC
),
2528 .version
= cpu_to_be32(version
),
2529 .cluster_bits
= cpu_to_be32(cluster_bits
),
2530 .size
= cpu_to_be64(0),
2531 .l1_table_offset
= cpu_to_be64(0),
2532 .l1_size
= cpu_to_be32(0),
2533 .refcount_table_offset
= cpu_to_be64(cluster_size
),
2534 .refcount_table_clusters
= cpu_to_be32(1),
2535 .refcount_order
= cpu_to_be32(refcount_order
),
2536 .header_length
= cpu_to_be32(sizeof(*header
)),
2539 /* We'll update this to correct value later */
2540 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
2542 if (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
) {
2543 header
->compatible_features
|=
2544 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
2547 ret
= blk_pwrite(blk
, 0, header
, cluster_size
, 0);
2550 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
2554 /* Write a refcount table with one refcount block */
2555 refcount_table
= g_malloc0(2 * cluster_size
);
2556 refcount_table
[0] = cpu_to_be64(2 * cluster_size
);
2557 ret
= blk_pwrite(blk
, cluster_size
, refcount_table
, 2 * cluster_size
, 0);
2558 g_free(refcount_table
);
2561 error_setg_errno(errp
, -ret
, "Could not write refcount table");
2569 * And now open the image and make it consistent first (i.e. increase the
2570 * refcount of the cluster that is occupied by the header and the refcount
2573 options
= qdict_new();
2574 qdict_put_str(options
, "driver", "qcow2");
2575 blk
= blk_new_open(filename
, NULL
, options
,
2576 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_NO_FLUSH
,
2579 error_propagate(errp
, local_err
);
2584 ret
= qcow2_alloc_clusters(blk_bs(blk
), 3 * cluster_size
);
2586 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
2587 "header and refcount table");
2590 } else if (ret
!= 0) {
2591 error_report("Huh, first cluster in empty image is already in use?");
2595 /* Create a full header (including things like feature table) */
2596 ret
= qcow2_update_header(blk_bs(blk
));
2598 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
2602 /* Okay, now that we have a valid image, let's give it the right size */
2603 ret
= blk_truncate(blk
, total_size
, errp
);
2605 error_prepend(errp
, "Could not resize image: ");
2609 /* Want a backing file? There you go.*/
2611 ret
= bdrv_change_backing_file(blk_bs(blk
), backing_file
, backing_format
);
2613 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
2614 "with format '%s'", backing_file
, backing_format
);
2619 /* Want encryption? There you go. */
2621 ret
= qcow2_set_up_encryption(blk_bs(blk
), encryptfmt
, opts
, errp
);
2627 /* And if we're supposed to preallocate metadata, do that now */
2628 if (prealloc
!= PREALLOC_MODE_OFF
) {
2629 BDRVQcow2State
*s
= blk_bs(blk
)->opaque
;
2630 qemu_co_mutex_lock(&s
->lock
);
2631 ret
= preallocate(blk_bs(blk
));
2632 qemu_co_mutex_unlock(&s
->lock
);
2634 error_setg_errno(errp
, -ret
, "Could not preallocate metadata");
2642 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
2643 * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
2644 * have to setup decryption context. We're not doing any I/O on the top
2645 * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
2648 options
= qdict_new();
2649 qdict_put_str(options
, "driver", "qcow2");
2650 blk
= blk_new_open(filename
, NULL
, options
,
2651 BDRV_O_RDWR
| BDRV_O_NO_BACKING
| BDRV_O_NO_IO
,
2654 error_propagate(errp
, local_err
);
2667 static int qcow2_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
2669 char *backing_file
= NULL
;
2670 char *backing_fmt
= NULL
;
2674 size_t cluster_size
= DEFAULT_CLUSTER_SIZE
;
2675 PreallocMode prealloc
;
2677 uint64_t refcount_bits
= 16;
2679 const char *encryptfmt
= NULL
;
2680 Error
*local_err
= NULL
;
2683 /* Read out options */
2684 size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
2686 backing_file
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
2687 backing_fmt
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FMT
);
2688 encryptfmt
= qemu_opt_get_del(opts
, BLOCK_OPT_ENCRYPT_FORMAT
);
2690 if (qemu_opt_get_del(opts
, BLOCK_OPT_ENCRYPT
)) {
2691 error_setg(errp
, "Options " BLOCK_OPT_ENCRYPT
" and "
2692 BLOCK_OPT_ENCRYPT_FORMAT
" are mutually exclusive");
2696 } else if (qemu_opt_get_bool_del(opts
, BLOCK_OPT_ENCRYPT
, false)) {
2699 cluster_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
2700 DEFAULT_CLUSTER_SIZE
);
2701 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
2702 prealloc
= qapi_enum_parse(PreallocMode_lookup
, buf
,
2703 PREALLOC_MODE__MAX
, PREALLOC_MODE_OFF
,
2706 error_propagate(errp
, local_err
);
2711 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_COMPAT_LEVEL
);
2713 /* keep the default */
2714 } else if (!strcmp(buf
, "0.10")) {
2716 } else if (!strcmp(buf
, "1.1")) {
2719 error_setg(errp
, "Invalid compatibility level: '%s'", buf
);
2724 if (qemu_opt_get_bool_del(opts
, BLOCK_OPT_LAZY_REFCOUNTS
, false)) {
2725 flags
|= BLOCK_FLAG_LAZY_REFCOUNTS
;
2728 if (backing_file
&& prealloc
!= PREALLOC_MODE_OFF
) {
2729 error_setg(errp
, "Backing file and preallocation cannot be used at "
2735 if (version
< 3 && (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
)) {
2736 error_setg(errp
, "Lazy refcounts only supported with compatibility "
2737 "level 1.1 and above (use compat=1.1 or greater)");
2742 refcount_bits
= qemu_opt_get_number_del(opts
, BLOCK_OPT_REFCOUNT_BITS
,
2744 if (refcount_bits
> 64 || !is_power_of_2(refcount_bits
)) {
2745 error_setg(errp
, "Refcount width must be a power of two and may not "
2751 if (version
< 3 && refcount_bits
!= 16) {
2752 error_setg(errp
, "Different refcount widths than 16 bits require "
2753 "compatibility level 1.1 or above (use compat=1.1 or "
2759 refcount_order
= ctz32(refcount_bits
);
2761 ret
= qcow2_create2(filename
, size
, backing_file
, backing_fmt
, flags
,
2762 cluster_size
, prealloc
, opts
, version
, refcount_order
,
2763 encryptfmt
, &local_err
);
2764 error_propagate(errp
, local_err
);
2767 g_free(backing_file
);
2768 g_free(backing_fmt
);
2774 static bool is_zero_sectors(BlockDriverState
*bs
, int64_t start
,
2778 BlockDriverState
*file
;
2781 if (start
+ count
> bs
->total_sectors
) {
2782 count
= bs
->total_sectors
- start
;
2788 res
= bdrv_get_block_status_above(bs
, NULL
, start
, count
,
2790 return res
>= 0 && (res
& BDRV_BLOCK_ZERO
) && nr
== count
;
2793 static coroutine_fn
int qcow2_co_pwrite_zeroes(BlockDriverState
*bs
,
2794 int64_t offset
, int bytes
, BdrvRequestFlags flags
)
2797 BDRVQcow2State
*s
= bs
->opaque
;
2799 uint32_t head
= offset
% s
->cluster_size
;
2800 uint32_t tail
= (offset
+ bytes
) % s
->cluster_size
;
2802 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset
, bytes
);
2803 if (offset
+ bytes
== bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
2808 int64_t cl_start
= (offset
- head
) >> BDRV_SECTOR_BITS
;
2812 assert(head
+ bytes
<= s
->cluster_size
);
2814 /* check whether remainder of cluster already reads as zero */
2815 if (!(is_zero_sectors(bs
, cl_start
,
2816 DIV_ROUND_UP(head
, BDRV_SECTOR_SIZE
)) &&
2817 is_zero_sectors(bs
, (offset
+ bytes
) >> BDRV_SECTOR_BITS
,
2818 DIV_ROUND_UP(-tail
& (s
->cluster_size
- 1),
2819 BDRV_SECTOR_SIZE
)))) {
2823 qemu_co_mutex_lock(&s
->lock
);
2824 /* We can have new write after previous check */
2825 offset
= cl_start
<< BDRV_SECTOR_BITS
;
2826 bytes
= s
->cluster_size
;
2827 nr
= s
->cluster_size
;
2828 ret
= qcow2_get_cluster_offset(bs
, offset
, &nr
, &off
);
2829 if (ret
!= QCOW2_CLUSTER_UNALLOCATED
&&
2830 ret
!= QCOW2_CLUSTER_ZERO_PLAIN
&&
2831 ret
!= QCOW2_CLUSTER_ZERO_ALLOC
) {
2832 qemu_co_mutex_unlock(&s
->lock
);
2836 qemu_co_mutex_lock(&s
->lock
);
2839 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset
, bytes
);
2841 /* Whatever is left can use real zero clusters */
2842 ret
= qcow2_cluster_zeroize(bs
, offset
, bytes
, flags
);
2843 qemu_co_mutex_unlock(&s
->lock
);
2848 static coroutine_fn
int qcow2_co_pdiscard(BlockDriverState
*bs
,
2849 int64_t offset
, int bytes
)
2852 BDRVQcow2State
*s
= bs
->opaque
;
2854 if (!QEMU_IS_ALIGNED(offset
| bytes
, s
->cluster_size
)) {
2855 assert(bytes
< s
->cluster_size
);
2856 /* Ignore partial clusters, except for the special case of the
2857 * complete partial cluster at the end of an unaligned file */
2858 if (!QEMU_IS_ALIGNED(offset
, s
->cluster_size
) ||
2859 offset
+ bytes
!= bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
2864 qemu_co_mutex_lock(&s
->lock
);
2865 ret
= qcow2_cluster_discard(bs
, offset
, bytes
, QCOW2_DISCARD_REQUEST
,
2867 qemu_co_mutex_unlock(&s
->lock
);
2871 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
, Error
**errp
)
2873 BDRVQcow2State
*s
= bs
->opaque
;
2874 int64_t new_l1_size
;
2878 error_setg(errp
, "The new size must be a multiple of 512");
2882 /* cannot proceed if image has snapshots */
2883 if (s
->nb_snapshots
) {
2884 error_setg(errp
, "Can't resize an image which has snapshots");
2888 /* shrinking is currently not supported */
2889 if (offset
< bs
->total_sectors
* 512) {
2890 error_setg(errp
, "qcow2 doesn't support shrinking images yet");
2894 new_l1_size
= size_to_l1(s
, offset
);
2895 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
2897 error_setg_errno(errp
, -ret
, "Failed to grow the L1 table");
2901 /* write updated header.size */
2902 offset
= cpu_to_be64(offset
);
2903 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
2904 &offset
, sizeof(uint64_t));
2906 error_setg_errno(errp
, -ret
, "Failed to update the image size");
2910 s
->l1_vm_state_index
= new_l1_size
;
2914 /* XXX: put compressed sectors first, then all the cluster aligned
2915 tables to avoid losing bytes in alignment */
2916 static coroutine_fn
int
2917 qcow2_co_pwritev_compressed(BlockDriverState
*bs
, uint64_t offset
,
2918 uint64_t bytes
, QEMUIOVector
*qiov
)
2920 BDRVQcow2State
*s
= bs
->opaque
;
2921 QEMUIOVector hd_qiov
;
2925 uint8_t *buf
, *out_buf
;
2926 uint64_t cluster_offset
;
2929 /* align end of file to a sector boundary to ease reading with
2930 sector based I/Os */
2931 cluster_offset
= bdrv_getlength(bs
->file
->bs
);
2932 return bdrv_truncate(bs
->file
, cluster_offset
, NULL
);
2935 buf
= qemu_blockalign(bs
, s
->cluster_size
);
2936 if (bytes
!= s
->cluster_size
) {
2937 if (bytes
> s
->cluster_size
||
2938 offset
+ bytes
!= bs
->total_sectors
<< BDRV_SECTOR_BITS
)
2943 /* Zero-pad last write if image size is not cluster aligned */
2944 memset(buf
+ bytes
, 0, s
->cluster_size
- bytes
);
2946 qemu_iovec_to_buf(qiov
, 0, buf
, bytes
);
2948 out_buf
= g_malloc(s
->cluster_size
);
2950 /* best compression, small window, no zlib header */
2951 memset(&strm
, 0, sizeof(strm
));
2952 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
2954 9, Z_DEFAULT_STRATEGY
);
2960 strm
.avail_in
= s
->cluster_size
;
2961 strm
.next_in
= (uint8_t *)buf
;
2962 strm
.avail_out
= s
->cluster_size
;
2963 strm
.next_out
= out_buf
;
2965 ret
= deflate(&strm
, Z_FINISH
);
2966 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
2971 out_len
= strm
.next_out
- out_buf
;
2975 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
2976 /* could not compress: write normal cluster */
2977 ret
= qcow2_co_pwritev(bs
, offset
, bytes
, qiov
, 0);
2984 qemu_co_mutex_lock(&s
->lock
);
2986 qcow2_alloc_compressed_cluster_offset(bs
, offset
, out_len
);
2987 if (!cluster_offset
) {
2988 qemu_co_mutex_unlock(&s
->lock
);
2992 cluster_offset
&= s
->cluster_offset_mask
;
2994 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
);
2995 qemu_co_mutex_unlock(&s
->lock
);
3000 iov
= (struct iovec
) {
3001 .iov_base
= out_buf
,
3004 qemu_iovec_init_external(&hd_qiov
, &iov
, 1);
3006 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
3007 ret
= bdrv_co_pwritev(bs
->file
, cluster_offset
, out_len
, &hd_qiov
, 0);
3019 static int make_completely_empty(BlockDriverState
*bs
)
3021 BDRVQcow2State
*s
= bs
->opaque
;
3022 Error
*local_err
= NULL
;
3023 int ret
, l1_clusters
;
3025 uint64_t *new_reftable
= NULL
;
3026 uint64_t rt_entry
, l1_size2
;
3029 uint64_t reftable_offset
;
3030 uint32_t reftable_clusters
;
3031 } QEMU_PACKED l1_ofs_rt_ofs_cls
;
3033 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
3038 ret
= qcow2_cache_empty(bs
, s
->refcount_block_cache
);
3043 /* Refcounts will be broken utterly */
3044 ret
= qcow2_mark_dirty(bs
);
3049 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
3051 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
3052 l1_size2
= (uint64_t)s
->l1_size
* sizeof(uint64_t);
3054 /* After this call, neither the in-memory nor the on-disk refcount
3055 * information accurately describe the actual references */
3057 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->l1_table_offset
,
3058 l1_clusters
* s
->cluster_size
, 0);
3060 goto fail_broken_refcounts
;
3062 memset(s
->l1_table
, 0, l1_size2
);
3064 BLKDBG_EVENT(bs
->file
, BLKDBG_EMPTY_IMAGE_PREPARE
);
3066 /* Overwrite enough clusters at the beginning of the sectors to place
3067 * the refcount table, a refcount block and the L1 table in; this may
3068 * overwrite parts of the existing refcount and L1 table, which is not
3069 * an issue because the dirty flag is set, complete data loss is in fact
3070 * desired and partial data loss is consequently fine as well */
3071 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->cluster_size
,
3072 (2 + l1_clusters
) * s
->cluster_size
, 0);
3073 /* This call (even if it failed overall) may have overwritten on-disk
3074 * refcount structures; in that case, the in-memory refcount information
3075 * will probably differ from the on-disk information which makes the BDS
3078 goto fail_broken_refcounts
;
3081 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
3082 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_UPDATE
);
3084 /* "Create" an empty reftable (one cluster) directly after the image
3085 * header and an empty L1 table three clusters after the image header;
3086 * the cluster between those two will be used as the first refblock */
3087 l1_ofs_rt_ofs_cls
.l1_offset
= cpu_to_be64(3 * s
->cluster_size
);
3088 l1_ofs_rt_ofs_cls
.reftable_offset
= cpu_to_be64(s
->cluster_size
);
3089 l1_ofs_rt_ofs_cls
.reftable_clusters
= cpu_to_be32(1);
3090 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, l1_table_offset
),
3091 &l1_ofs_rt_ofs_cls
, sizeof(l1_ofs_rt_ofs_cls
));
3093 goto fail_broken_refcounts
;
3096 s
->l1_table_offset
= 3 * s
->cluster_size
;
3098 new_reftable
= g_try_new0(uint64_t, s
->cluster_size
/ sizeof(uint64_t));
3099 if (!new_reftable
) {
3101 goto fail_broken_refcounts
;
3104 s
->refcount_table_offset
= s
->cluster_size
;
3105 s
->refcount_table_size
= s
->cluster_size
/ sizeof(uint64_t);
3106 s
->max_refcount_table_index
= 0;
3108 g_free(s
->refcount_table
);
3109 s
->refcount_table
= new_reftable
;
3110 new_reftable
= NULL
;
3112 /* Now the in-memory refcount information again corresponds to the on-disk
3113 * information (reftable is empty and no refblocks (the refblock cache is
3114 * empty)); however, this means some clusters (e.g. the image header) are
3115 * referenced, but not refcounted, but the normal qcow2 code assumes that
3116 * the in-memory information is always correct */
3118 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
3120 /* Enter the first refblock into the reftable */
3121 rt_entry
= cpu_to_be64(2 * s
->cluster_size
);
3122 ret
= bdrv_pwrite_sync(bs
->file
, s
->cluster_size
,
3123 &rt_entry
, sizeof(rt_entry
));
3125 goto fail_broken_refcounts
;
3127 s
->refcount_table
[0] = 2 * s
->cluster_size
;
3129 s
->free_cluster_index
= 0;
3130 assert(3 + l1_clusters
<= s
->refcount_block_size
);
3131 offset
= qcow2_alloc_clusters(bs
, 3 * s
->cluster_size
+ l1_size2
);
3134 goto fail_broken_refcounts
;
3135 } else if (offset
> 0) {
3136 error_report("First cluster in emptied image is in use");
3140 /* Now finally the in-memory information corresponds to the on-disk
3141 * structures and is correct */
3142 ret
= qcow2_mark_clean(bs
);
3147 ret
= bdrv_truncate(bs
->file
, (3 + l1_clusters
) * s
->cluster_size
,
3150 error_report_err(local_err
);
3156 fail_broken_refcounts
:
3157 /* The BDS is unusable at this point. If we wanted to make it usable, we
3158 * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
3159 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
3160 * again. However, because the functions which could have caused this error
3161 * path to be taken are used by those functions as well, it's very likely
3162 * that that sequence will fail as well. Therefore, just eject the BDS. */
3166 g_free(new_reftable
);
3170 static int qcow2_make_empty(BlockDriverState
*bs
)
3172 BDRVQcow2State
*s
= bs
->opaque
;
3173 uint64_t offset
, end_offset
;
3174 int step
= QEMU_ALIGN_DOWN(INT_MAX
, s
->cluster_size
);
3175 int l1_clusters
, ret
= 0;
3177 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
3179 if (s
->qcow_version
>= 3 && !s
->snapshots
&&
3180 3 + l1_clusters
<= s
->refcount_block_size
) {
3181 /* The following function only works for qcow2 v3 images (it requires
3182 * the dirty flag) and only as long as there are no snapshots (because
3183 * it completely empties the image). Furthermore, the L1 table and three
3184 * additional clusters (image header, refcount table, one refcount
3185 * block) have to fit inside one refcount block. */
3186 return make_completely_empty(bs
);
3189 /* This fallback code simply discards every active cluster; this is slow,
3190 * but works in all cases */
3191 end_offset
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3192 for (offset
= 0; offset
< end_offset
; offset
+= step
) {
3193 /* As this function is generally used after committing an external
3194 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
3195 * default action for this kind of discard is to pass the discard,
3196 * which will ideally result in an actually smaller image file, as
3197 * is probably desired. */
3198 ret
= qcow2_cluster_discard(bs
, offset
, MIN(step
, end_offset
- offset
),
3199 QCOW2_DISCARD_SNAPSHOT
, true);
3208 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
3210 BDRVQcow2State
*s
= bs
->opaque
;
3213 qemu_co_mutex_lock(&s
->lock
);
3214 ret
= qcow2_cache_write(bs
, s
->l2_table_cache
);
3216 qemu_co_mutex_unlock(&s
->lock
);
3220 if (qcow2_need_accurate_refcounts(s
)) {
3221 ret
= qcow2_cache_write(bs
, s
->refcount_block_cache
);
3223 qemu_co_mutex_unlock(&s
->lock
);
3227 qemu_co_mutex_unlock(&s
->lock
);
3232 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3234 BDRVQcow2State
*s
= bs
->opaque
;
3235 bdi
->unallocated_blocks_are_zero
= true;
3236 bdi
->can_write_zeroes_with_unmap
= (s
->qcow_version
>= 3);
3237 bdi
->cluster_size
= s
->cluster_size
;
3238 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
3242 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
)
3244 BDRVQcow2State
*s
= bs
->opaque
;
3245 ImageInfoSpecific
*spec_info
= g_new(ImageInfoSpecific
, 1);
3247 *spec_info
= (ImageInfoSpecific
){
3248 .type
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
3249 .u
.qcow2
.data
= g_new(ImageInfoSpecificQCow2
, 1),
3251 if (s
->qcow_version
== 2) {
3252 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
3253 .compat
= g_strdup("0.10"),
3254 .refcount_bits
= s
->refcount_bits
,
3256 } else if (s
->qcow_version
== 3) {
3257 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
3258 .compat
= g_strdup("1.1"),
3259 .lazy_refcounts
= s
->compatible_features
&
3260 QCOW2_COMPAT_LAZY_REFCOUNTS
,
3261 .has_lazy_refcounts
= true,
3262 .corrupt
= s
->incompatible_features
&
3263 QCOW2_INCOMPAT_CORRUPT
,
3264 .has_corrupt
= true,
3265 .refcount_bits
= s
->refcount_bits
,
3268 /* if this assertion fails, this probably means a new version was
3269 * added without having it covered here */
3277 static void dump_refcounts(BlockDriverState
*bs
)
3279 BDRVQcow2State
*s
= bs
->opaque
;
3280 int64_t nb_clusters
, k
, k1
, size
;
3283 size
= bdrv_getlength(bs
->file
->bs
);
3284 nb_clusters
= size_to_clusters(s
, size
);
3285 for(k
= 0; k
< nb_clusters
;) {
3287 refcount
= get_refcount(bs
, k
);
3289 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
3291 printf("%" PRId64
": refcount=%d nb=%" PRId64
"\n", k
, refcount
,
3297 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
3300 BDRVQcow2State
*s
= bs
->opaque
;
3302 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
3303 return bs
->drv
->bdrv_co_pwritev(bs
, qcow2_vm_state_offset(s
) + pos
,
3304 qiov
->size
, qiov
, 0);
3307 static int qcow2_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
3310 BDRVQcow2State
*s
= bs
->opaque
;
3312 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
3313 return bs
->drv
->bdrv_co_preadv(bs
, qcow2_vm_state_offset(s
) + pos
,
3314 qiov
->size
, qiov
, 0);
3318 * Downgrades an image's version. To achieve this, any incompatible features
3319 * have to be removed.
3321 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
,
3322 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
)
3324 BDRVQcow2State
*s
= bs
->opaque
;
3325 int current_version
= s
->qcow_version
;
3328 if (target_version
== current_version
) {
3330 } else if (target_version
> current_version
) {
3332 } else if (target_version
!= 2) {
3336 if (s
->refcount_order
!= 4) {
3337 error_report("compat=0.10 requires refcount_bits=16");
3341 /* clear incompatible features */
3342 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
3343 ret
= qcow2_mark_clean(bs
);
3349 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
3350 * the first place; if that happens nonetheless, returning -ENOTSUP is the
3351 * best thing to do anyway */
3353 if (s
->incompatible_features
) {
3357 /* since we can ignore compatible features, we can set them to 0 as well */
3358 s
->compatible_features
= 0;
3359 /* if lazy refcounts have been used, they have already been fixed through
3360 * clearing the dirty flag */
3362 /* clearing autoclear features is trivial */
3363 s
->autoclear_features
= 0;
3365 ret
= qcow2_expand_zero_clusters(bs
, status_cb
, cb_opaque
);
3370 s
->qcow_version
= target_version
;
3371 ret
= qcow2_update_header(bs
);
3373 s
->qcow_version
= current_version
;
3379 typedef enum Qcow2AmendOperation
{
3380 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
3381 * statically initialized to so that the helper CB can discern the first
3382 * invocation from an operation change */
3383 QCOW2_NO_OPERATION
= 0,
3385 QCOW2_CHANGING_REFCOUNT_ORDER
,
3387 } Qcow2AmendOperation
;
3389 typedef struct Qcow2AmendHelperCBInfo
{
3390 /* The code coordinating the amend operations should only modify
3391 * these four fields; the rest will be managed by the CB */
3392 BlockDriverAmendStatusCB
*original_status_cb
;
3393 void *original_cb_opaque
;
3395 Qcow2AmendOperation current_operation
;
3397 /* Total number of operations to perform (only set once) */
3398 int total_operations
;
3400 /* The following fields are managed by the CB */
3402 /* Number of operations completed */
3403 int operations_completed
;
3405 /* Cumulative offset of all completed operations */
3406 int64_t offset_completed
;
3408 Qcow2AmendOperation last_operation
;
3409 int64_t last_work_size
;
3410 } Qcow2AmendHelperCBInfo
;
3412 static void qcow2_amend_helper_cb(BlockDriverState
*bs
,
3413 int64_t operation_offset
,
3414 int64_t operation_work_size
, void *opaque
)
3416 Qcow2AmendHelperCBInfo
*info
= opaque
;
3417 int64_t current_work_size
;
3418 int64_t projected_work_size
;
3420 if (info
->current_operation
!= info
->last_operation
) {
3421 if (info
->last_operation
!= QCOW2_NO_OPERATION
) {
3422 info
->offset_completed
+= info
->last_work_size
;
3423 info
->operations_completed
++;
3426 info
->last_operation
= info
->current_operation
;
3429 assert(info
->total_operations
> 0);
3430 assert(info
->operations_completed
< info
->total_operations
);
3432 info
->last_work_size
= operation_work_size
;
3434 current_work_size
= info
->offset_completed
+ operation_work_size
;
3436 /* current_work_size is the total work size for (operations_completed + 1)
3437 * operations (which includes this one), so multiply it by the number of
3438 * operations not covered and divide it by the number of operations
3439 * covered to get a projection for the operations not covered */
3440 projected_work_size
= current_work_size
* (info
->total_operations
-
3441 info
->operations_completed
- 1)
3442 / (info
->operations_completed
+ 1);
3444 info
->original_status_cb(bs
, info
->offset_completed
+ operation_offset
,
3445 current_work_size
+ projected_work_size
,
3446 info
->original_cb_opaque
);
3449 static int qcow2_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3450 BlockDriverAmendStatusCB
*status_cb
,
3453 BDRVQcow2State
*s
= bs
->opaque
;
3454 int old_version
= s
->qcow_version
, new_version
= old_version
;
3455 uint64_t new_size
= 0;
3456 const char *backing_file
= NULL
, *backing_format
= NULL
;
3457 bool lazy_refcounts
= s
->use_lazy_refcounts
;
3458 const char *compat
= NULL
;
3459 uint64_t cluster_size
= s
->cluster_size
;
3462 int refcount_bits
= s
->refcount_bits
;
3463 Error
*local_err
= NULL
;
3465 QemuOptDesc
*desc
= opts
->list
->desc
;
3466 Qcow2AmendHelperCBInfo helper_cb_info
;
3468 while (desc
&& desc
->name
) {
3469 if (!qemu_opt_find(opts
, desc
->name
)) {
3470 /* only change explicitly defined options */
3475 if (!strcmp(desc
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
3476 compat
= qemu_opt_get(opts
, BLOCK_OPT_COMPAT_LEVEL
);
3478 /* preserve default */
3479 } else if (!strcmp(compat
, "0.10")) {
3481 } else if (!strcmp(compat
, "1.1")) {
3484 error_report("Unknown compatibility level %s", compat
);
3487 } else if (!strcmp(desc
->name
, BLOCK_OPT_PREALLOC
)) {
3488 error_report("Cannot change preallocation mode");
3490 } else if (!strcmp(desc
->name
, BLOCK_OPT_SIZE
)) {
3491 new_size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3492 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FILE
)) {
3493 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3494 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FMT
)) {
3495 backing_format
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3496 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT
)) {
3497 encrypt
= qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
,
3500 if (encrypt
!= !!s
->crypto
) {
3501 error_report("Changing the encryption flag is not supported");
3504 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT_FORMAT
)) {
3505 encformat
= qcow2_crypt_method_from_format(
3506 qemu_opt_get(opts
, BLOCK_OPT_ENCRYPT_FORMAT
));
3508 if (encformat
!= s
->crypt_method_header
) {
3509 error_report("Changing the encryption format is not supported");
3512 } else if (!strcmp(desc
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
3513 cluster_size
= qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
,
3515 if (cluster_size
!= s
->cluster_size
) {
3516 error_report("Changing the cluster size is not supported");
3519 } else if (!strcmp(desc
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
3520 lazy_refcounts
= qemu_opt_get_bool(opts
, BLOCK_OPT_LAZY_REFCOUNTS
,
3522 } else if (!strcmp(desc
->name
, BLOCK_OPT_REFCOUNT_BITS
)) {
3523 refcount_bits
= qemu_opt_get_number(opts
, BLOCK_OPT_REFCOUNT_BITS
,
3526 if (refcount_bits
<= 0 || refcount_bits
> 64 ||
3527 !is_power_of_2(refcount_bits
))
3529 error_report("Refcount width must be a power of two and may "
3530 "not exceed 64 bits");
3534 /* if this point is reached, this probably means a new option was
3535 * added without having it covered here */
3542 helper_cb_info
= (Qcow2AmendHelperCBInfo
){
3543 .original_status_cb
= status_cb
,
3544 .original_cb_opaque
= cb_opaque
,
3545 .total_operations
= (new_version
< old_version
)
3546 + (s
->refcount_bits
!= refcount_bits
)
3549 /* Upgrade first (some features may require compat=1.1) */
3550 if (new_version
> old_version
) {
3551 s
->qcow_version
= new_version
;
3552 ret
= qcow2_update_header(bs
);
3554 s
->qcow_version
= old_version
;
3559 if (s
->refcount_bits
!= refcount_bits
) {
3560 int refcount_order
= ctz32(refcount_bits
);
3562 if (new_version
< 3 && refcount_bits
!= 16) {
3563 error_report("Different refcount widths than 16 bits require "
3564 "compatibility level 1.1 or above (use compat=1.1 or "
3569 helper_cb_info
.current_operation
= QCOW2_CHANGING_REFCOUNT_ORDER
;
3570 ret
= qcow2_change_refcount_order(bs
, refcount_order
,
3571 &qcow2_amend_helper_cb
,
3572 &helper_cb_info
, &local_err
);
3574 error_report_err(local_err
);
3579 if (backing_file
|| backing_format
) {
3580 ret
= qcow2_change_backing_file(bs
,
3581 backing_file
?: s
->image_backing_file
,
3582 backing_format
?: s
->image_backing_format
);
3588 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
3589 if (lazy_refcounts
) {
3590 if (new_version
< 3) {
3591 error_report("Lazy refcounts only supported with compatibility "
3592 "level 1.1 and above (use compat=1.1 or greater)");
3595 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
3596 ret
= qcow2_update_header(bs
);
3598 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
3601 s
->use_lazy_refcounts
= true;
3603 /* make image clean first */
3604 ret
= qcow2_mark_clean(bs
);
3608 /* now disallow lazy refcounts */
3609 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
3610 ret
= qcow2_update_header(bs
);
3612 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
3615 s
->use_lazy_refcounts
= false;
3620 BlockBackend
*blk
= blk_new(BLK_PERM_RESIZE
, BLK_PERM_ALL
);
3621 ret
= blk_insert_bs(blk
, bs
, &local_err
);
3623 error_report_err(local_err
);
3628 ret
= blk_truncate(blk
, new_size
, &local_err
);
3631 error_report_err(local_err
);
3636 /* Downgrade last (so unsupported features can be removed before) */
3637 if (new_version
< old_version
) {
3638 helper_cb_info
.current_operation
= QCOW2_DOWNGRADING
;
3639 ret
= qcow2_downgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
3650 * If offset or size are negative, respectively, they will not be included in
3651 * the BLOCK_IMAGE_CORRUPTED event emitted.
3652 * fatal will be ignored for read-only BDS; corruptions found there will always
3653 * be considered non-fatal.
3655 void qcow2_signal_corruption(BlockDriverState
*bs
, bool fatal
, int64_t offset
,
3656 int64_t size
, const char *message_format
, ...)
3658 BDRVQcow2State
*s
= bs
->opaque
;
3659 const char *node_name
;
3663 fatal
= fatal
&& !bs
->read_only
;
3665 if (s
->signaled_corruption
&&
3666 (!fatal
|| (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
)))
3671 va_start(ap
, message_format
);
3672 message
= g_strdup_vprintf(message_format
, ap
);
3676 fprintf(stderr
, "qcow2: Marking image as corrupt: %s; further "
3677 "corruption events will be suppressed\n", message
);
3679 fprintf(stderr
, "qcow2: Image is corrupt: %s; further non-fatal "
3680 "corruption events will be suppressed\n", message
);
3683 node_name
= bdrv_get_node_name(bs
);
3684 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs
),
3685 *node_name
!= '\0', node_name
,
3686 message
, offset
>= 0, offset
,
3688 fatal
, &error_abort
);
3692 qcow2_mark_corrupt(bs
);
3693 bs
->drv
= NULL
; /* make BDS unusable */
3696 s
->signaled_corruption
= true;
3699 static QemuOptsList qcow2_create_opts
= {
3700 .name
= "qcow2-create-opts",
3701 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_create_opts
.head
),
3704 .name
= BLOCK_OPT_SIZE
,
3705 .type
= QEMU_OPT_SIZE
,
3706 .help
= "Virtual disk size"
3709 .name
= BLOCK_OPT_COMPAT_LEVEL
,
3710 .type
= QEMU_OPT_STRING
,
3711 .help
= "Compatibility level (0.10 or 1.1)"
3714 .name
= BLOCK_OPT_BACKING_FILE
,
3715 .type
= QEMU_OPT_STRING
,
3716 .help
= "File name of a base image"
3719 .name
= BLOCK_OPT_BACKING_FMT
,
3720 .type
= QEMU_OPT_STRING
,
3721 .help
= "Image format of the base image"
3724 .name
= BLOCK_OPT_ENCRYPT
,
3725 .type
= QEMU_OPT_BOOL
,
3726 .help
= "Encrypt the image with format 'aes'. (Deprecated "
3727 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT
"=aes)",
3730 .name
= BLOCK_OPT_ENCRYPT_FORMAT
,
3731 .type
= QEMU_OPT_STRING
,
3732 .help
= "Encrypt the image, format choices: 'aes', 'luks'",
3734 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
3735 "ID of secret providing qcow AES key or LUKS passphrase"),
3736 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."),
3737 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."),
3738 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."),
3739 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."),
3740 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."),
3741 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
3743 .name
= BLOCK_OPT_CLUSTER_SIZE
,
3744 .type
= QEMU_OPT_SIZE
,
3745 .help
= "qcow2 cluster size",
3746 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
)
3749 .name
= BLOCK_OPT_PREALLOC
,
3750 .type
= QEMU_OPT_STRING
,
3751 .help
= "Preallocation mode (allowed values: off, metadata, "
3755 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
3756 .type
= QEMU_OPT_BOOL
,
3757 .help
= "Postpone refcount updates",
3758 .def_value_str
= "off"
3761 .name
= BLOCK_OPT_REFCOUNT_BITS
,
3762 .type
= QEMU_OPT_NUMBER
,
3763 .help
= "Width of a reference count entry in bits",
3764 .def_value_str
= "16"
3766 { /* end of list */ }
3770 BlockDriver bdrv_qcow2
= {
3771 .format_name
= "qcow2",
3772 .instance_size
= sizeof(BDRVQcow2State
),
3773 .bdrv_probe
= qcow2_probe
,
3774 .bdrv_open
= qcow2_open
,
3775 .bdrv_close
= qcow2_close
,
3776 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
3777 .bdrv_reopen_commit
= qcow2_reopen_commit
,
3778 .bdrv_reopen_abort
= qcow2_reopen_abort
,
3779 .bdrv_join_options
= qcow2_join_options
,
3780 .bdrv_child_perm
= bdrv_format_default_perms
,
3781 .bdrv_create
= qcow2_create
,
3782 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
3783 .bdrv_co_get_block_status
= qcow2_co_get_block_status
,
3785 .bdrv_co_preadv
= qcow2_co_preadv
,
3786 .bdrv_co_pwritev
= qcow2_co_pwritev
,
3787 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
3789 .bdrv_co_pwrite_zeroes
= qcow2_co_pwrite_zeroes
,
3790 .bdrv_co_pdiscard
= qcow2_co_pdiscard
,
3791 .bdrv_truncate
= qcow2_truncate
,
3792 .bdrv_co_pwritev_compressed
= qcow2_co_pwritev_compressed
,
3793 .bdrv_make_empty
= qcow2_make_empty
,
3795 .bdrv_snapshot_create
= qcow2_snapshot_create
,
3796 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
3797 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
3798 .bdrv_snapshot_list
= qcow2_snapshot_list
,
3799 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
3800 .bdrv_get_info
= qcow2_get_info
,
3801 .bdrv_get_specific_info
= qcow2_get_specific_info
,
3803 .bdrv_save_vmstate
= qcow2_save_vmstate
,
3804 .bdrv_load_vmstate
= qcow2_load_vmstate
,
3806 .supports_backing
= true,
3807 .bdrv_change_backing_file
= qcow2_change_backing_file
,
3809 .bdrv_refresh_limits
= qcow2_refresh_limits
,
3810 .bdrv_invalidate_cache
= qcow2_invalidate_cache
,
3811 .bdrv_inactivate
= qcow2_inactivate
,
3813 .create_opts
= &qcow2_create_opts
,
3814 .bdrv_check
= qcow2_check
,
3815 .bdrv_amend_options
= qcow2_amend_options
,
3817 .bdrv_detach_aio_context
= qcow2_detach_aio_context
,
3818 .bdrv_attach_aio_context
= qcow2_attach_aio_context
,
3821 static void bdrv_qcow2_init(void)
3823 bdrv_register(&bdrv_qcow2
);
3826 block_init(bdrv_qcow2_init
);