2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "block/block_int.h"
27 #include "block/qdict.h"
28 #include "sysemu/block-backend.h"
29 #include "qemu/module.h"
32 #include "qemu/error-report.h"
33 #include "qapi/error.h"
34 #include "qapi/qapi-events-block-core.h"
35 #include "qapi/qmp/qdict.h"
36 #include "qapi/qmp/qstring.h"
38 #include "qemu/option_int.h"
39 #include "qemu/cutils.h"
40 #include "qemu/bswap.h"
41 #include "qapi/qobject-input-visitor.h"
42 #include "qapi/qapi-visit-block-core.h"
46 Differences with QCOW:
48 - Support for multiple incremental snapshots.
49 - Memory management by reference counts.
50 - Clusters which have a reference count of one have the bit
51 QCOW_OFLAG_COPIED to optimize write performance.
52 - Size of compressed clusters is stored in sectors to reduce bit usage
53 in the cluster offsets.
54 - Support for storing additional data (such as the VM state) in the
56 - If a backing store is used, the cluster size is not constrained
57 (could be backported to QCOW).
58 - L2 tables have always a size of one cluster.
65 } QEMU_PACKED QCowExtension
;
67 #define QCOW2_EXT_MAGIC_END 0
68 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
69 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
70 #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
71 #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875
73 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
75 const QCowHeader
*cow_header
= (const void *)buf
;
77 if (buf_size
>= sizeof(QCowHeader
) &&
78 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
79 be32_to_cpu(cow_header
->version
) >= 2)
86 static ssize_t
qcow2_crypto_hdr_read_func(QCryptoBlock
*block
, size_t offset
,
87 uint8_t *buf
, size_t buflen
,
88 void *opaque
, Error
**errp
)
90 BlockDriverState
*bs
= opaque
;
91 BDRVQcow2State
*s
= bs
->opaque
;
94 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
95 error_setg(errp
, "Request for data outside of extension header");
99 ret
= bdrv_pread(bs
->file
,
100 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
102 error_setg_errno(errp
, -ret
, "Could not read encryption header");
109 static ssize_t
qcow2_crypto_hdr_init_func(QCryptoBlock
*block
, size_t headerlen
,
110 void *opaque
, Error
**errp
)
112 BlockDriverState
*bs
= opaque
;
113 BDRVQcow2State
*s
= bs
->opaque
;
117 ret
= qcow2_alloc_clusters(bs
, headerlen
);
119 error_setg_errno(errp
, -ret
,
120 "Cannot allocate cluster for LUKS header size %zu",
125 s
->crypto_header
.length
= headerlen
;
126 s
->crypto_header
.offset
= ret
;
128 /* Zero fill remaining space in cluster so it has predictable
129 * content in case of future spec changes */
130 clusterlen
= size_to_clusters(s
, headerlen
) * s
->cluster_size
;
131 assert(qcow2_pre_write_overlap_check(bs
, 0, ret
, clusterlen
) == 0);
132 ret
= bdrv_pwrite_zeroes(bs
->file
,
134 clusterlen
- headerlen
, 0);
136 error_setg_errno(errp
, -ret
, "Could not zero fill encryption header");
144 static ssize_t
qcow2_crypto_hdr_write_func(QCryptoBlock
*block
, size_t offset
,
145 const uint8_t *buf
, size_t buflen
,
146 void *opaque
, Error
**errp
)
148 BlockDriverState
*bs
= opaque
;
149 BDRVQcow2State
*s
= bs
->opaque
;
152 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
153 error_setg(errp
, "Request for data outside of extension header");
157 ret
= bdrv_pwrite(bs
->file
,
158 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
160 error_setg_errno(errp
, -ret
, "Could not read encryption header");
168 * read qcow2 extension and fill bs
169 * start reading from start_offset
170 * finish reading upon magic of value 0 or when end_offset reached
171 * unknown magic is skipped (future extension this version knows nothing about)
172 * return 0 upon success, non-0 otherwise
174 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
175 uint64_t end_offset
, void **p_feature_table
,
176 int flags
, bool *need_update_header
,
179 BDRVQcow2State
*s
= bs
->opaque
;
183 Qcow2BitmapHeaderExt bitmaps_ext
;
185 if (need_update_header
!= NULL
) {
186 *need_update_header
= false;
190 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
192 offset
= start_offset
;
193 while (offset
< end_offset
) {
197 if (offset
> s
->cluster_size
)
198 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
200 printf("attempting to read extended header in offset %lu\n", offset
);
203 ret
= bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
));
205 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
206 "pread fail from offset %" PRIu64
, offset
);
209 be32_to_cpus(&ext
.magic
);
210 be32_to_cpus(&ext
.len
);
211 offset
+= sizeof(ext
);
213 printf("ext.magic = 0x%x\n", ext
.magic
);
215 if (offset
> end_offset
|| ext
.len
> end_offset
- offset
) {
216 error_setg(errp
, "Header extension too large");
221 case QCOW2_EXT_MAGIC_END
:
224 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
225 if (ext
.len
>= sizeof(bs
->backing_format
)) {
226 error_setg(errp
, "ERROR: ext_backing_format: len=%" PRIu32
227 " too large (>=%zu)", ext
.len
,
228 sizeof(bs
->backing_format
));
231 ret
= bdrv_pread(bs
->file
, offset
, bs
->backing_format
, ext
.len
);
233 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
234 "Could not read format name");
237 bs
->backing_format
[ext
.len
] = '\0';
238 s
->image_backing_format
= g_strdup(bs
->backing_format
);
240 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
244 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
245 if (p_feature_table
!= NULL
) {
246 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
247 ret
= bdrv_pread(bs
->file
, offset
, feature_table
, ext
.len
);
249 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
250 "Could not read table");
254 *p_feature_table
= feature_table
;
258 case QCOW2_EXT_MAGIC_CRYPTO_HEADER
: {
259 unsigned int cflags
= 0;
260 if (s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
261 error_setg(errp
, "CRYPTO header extension only "
262 "expected with LUKS encryption method");
265 if (ext
.len
!= sizeof(Qcow2CryptoHeaderExtension
)) {
266 error_setg(errp
, "CRYPTO header extension size %u, "
267 "but expected size %zu", ext
.len
,
268 sizeof(Qcow2CryptoHeaderExtension
));
272 ret
= bdrv_pread(bs
->file
, offset
, &s
->crypto_header
, ext
.len
);
274 error_setg_errno(errp
, -ret
,
275 "Unable to read CRYPTO header extension");
278 be64_to_cpus(&s
->crypto_header
.offset
);
279 be64_to_cpus(&s
->crypto_header
.length
);
281 if ((s
->crypto_header
.offset
% s
->cluster_size
) != 0) {
282 error_setg(errp
, "Encryption header offset '%" PRIu64
"' is "
283 "not a multiple of cluster size '%u'",
284 s
->crypto_header
.offset
, s
->cluster_size
);
288 if (flags
& BDRV_O_NO_IO
) {
289 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
291 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
292 qcow2_crypto_hdr_read_func
,
299 case QCOW2_EXT_MAGIC_BITMAPS
:
300 if (ext
.len
!= sizeof(bitmaps_ext
)) {
301 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
302 "Invalid extension length");
306 if (!(s
->autoclear_features
& QCOW2_AUTOCLEAR_BITMAPS
)) {
307 if (s
->qcow_version
< 3) {
308 /* Let's be a bit more specific */
309 warn_report("This qcow2 v2 image contains bitmaps, but "
310 "they may have been modified by a program "
311 "without persistent bitmap support; so now "
312 "they must all be considered inconsistent");
314 warn_report("a program lacking bitmap support "
315 "modified this file, so all bitmaps are now "
316 "considered inconsistent");
318 error_printf("Some clusters may be leaked, "
319 "run 'qemu-img check -r' on the image "
321 if (need_update_header
!= NULL
) {
322 /* Updating is needed to drop invalid bitmap extension. */
323 *need_update_header
= true;
328 ret
= bdrv_pread(bs
->file
, offset
, &bitmaps_ext
, ext
.len
);
330 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
331 "Could not read ext header");
335 if (bitmaps_ext
.reserved32
!= 0) {
336 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
337 "Reserved field is not zero");
341 be32_to_cpus(&bitmaps_ext
.nb_bitmaps
);
342 be64_to_cpus(&bitmaps_ext
.bitmap_directory_size
);
343 be64_to_cpus(&bitmaps_ext
.bitmap_directory_offset
);
345 if (bitmaps_ext
.nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
347 "bitmaps_ext: Image has %" PRIu32
" bitmaps, "
348 "exceeding the QEMU supported maximum of %d",
349 bitmaps_ext
.nb_bitmaps
, QCOW2_MAX_BITMAPS
);
353 if (bitmaps_ext
.nb_bitmaps
== 0) {
354 error_setg(errp
, "found bitmaps extension with zero bitmaps");
358 if (bitmaps_ext
.bitmap_directory_offset
& (s
->cluster_size
- 1)) {
359 error_setg(errp
, "bitmaps_ext: "
360 "invalid bitmap directory offset");
364 if (bitmaps_ext
.bitmap_directory_size
>
365 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
366 error_setg(errp
, "bitmaps_ext: "
367 "bitmap directory size (%" PRIu64
") exceeds "
368 "the maximum supported size (%d)",
369 bitmaps_ext
.bitmap_directory_size
,
370 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
);
374 s
->nb_bitmaps
= bitmaps_ext
.nb_bitmaps
;
375 s
->bitmap_directory_offset
=
376 bitmaps_ext
.bitmap_directory_offset
;
377 s
->bitmap_directory_size
=
378 bitmaps_ext
.bitmap_directory_size
;
381 printf("Qcow2: Got bitmaps extension: "
382 "offset=%" PRIu64
" nb_bitmaps=%" PRIu32
"\n",
383 s
->bitmap_directory_offset
, s
->nb_bitmaps
);
388 /* unknown magic - save it in case we need to rewrite the header */
389 /* If you add a new feature, make sure to also update the fast
390 * path of qcow2_make_empty() to deal with it. */
392 Qcow2UnknownHeaderExtension
*uext
;
394 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
395 uext
->magic
= ext
.magic
;
397 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
399 ret
= bdrv_pread(bs
->file
, offset
, uext
->data
, uext
->len
);
401 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
402 "Could not read data");
409 offset
+= ((ext
.len
+ 7) & ~7);
415 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
417 BDRVQcow2State
*s
= bs
->opaque
;
418 Qcow2UnknownHeaderExtension
*uext
, *next
;
420 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
421 QLIST_REMOVE(uext
, next
);
426 static void report_unsupported_feature(Error
**errp
, Qcow2Feature
*table
,
429 char *features
= g_strdup("");
432 while (table
&& table
->name
[0] != '\0') {
433 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
434 if (mask
& (1ULL << table
->bit
)) {
436 features
= g_strdup_printf("%s%s%.46s", old
, *old
? ", " : "",
439 mask
&= ~(1ULL << table
->bit
);
447 features
= g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64
,
448 old
, *old
? ", " : "", mask
);
452 error_setg(errp
, "Unsupported qcow2 feature(s): %s", features
);
457 * Sets the dirty bit and flushes afterwards if necessary.
459 * The incompatible_features bit is only set if the image file header was
460 * updated successfully. Therefore it is not required to check the return
461 * value of this function.
463 int qcow2_mark_dirty(BlockDriverState
*bs
)
465 BDRVQcow2State
*s
= bs
->opaque
;
469 assert(s
->qcow_version
>= 3);
471 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
472 return 0; /* already dirty */
475 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
476 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, incompatible_features
),
481 ret
= bdrv_flush(bs
->file
->bs
);
486 /* Only treat image as dirty if the header was updated successfully */
487 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
492 * Clears the dirty bit and flushes before if necessary. Only call this
493 * function when there are no pending requests, it does not guard against
494 * concurrent requests dirtying the image.
496 static int qcow2_mark_clean(BlockDriverState
*bs
)
498 BDRVQcow2State
*s
= bs
->opaque
;
500 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
503 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
505 ret
= qcow2_flush_caches(bs
);
510 return qcow2_update_header(bs
);
516 * Marks the image as corrupt.
518 int qcow2_mark_corrupt(BlockDriverState
*bs
)
520 BDRVQcow2State
*s
= bs
->opaque
;
522 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
523 return qcow2_update_header(bs
);
527 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
528 * before if necessary.
530 int qcow2_mark_consistent(BlockDriverState
*bs
)
532 BDRVQcow2State
*s
= bs
->opaque
;
534 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
535 int ret
= qcow2_flush_caches(bs
);
540 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
541 return qcow2_update_header(bs
);
546 static int coroutine_fn
qcow2_co_check_locked(BlockDriverState
*bs
,
547 BdrvCheckResult
*result
,
550 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
555 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
556 ret
= qcow2_mark_clean(bs
);
560 return qcow2_mark_consistent(bs
);
565 static int coroutine_fn
qcow2_co_check(BlockDriverState
*bs
,
566 BdrvCheckResult
*result
,
569 BDRVQcow2State
*s
= bs
->opaque
;
572 qemu_co_mutex_lock(&s
->lock
);
573 ret
= qcow2_co_check_locked(bs
, result
, fix
);
574 qemu_co_mutex_unlock(&s
->lock
);
578 int qcow2_validate_table(BlockDriverState
*bs
, uint64_t offset
,
579 uint64_t entries
, size_t entry_len
,
580 int64_t max_size_bytes
, const char *table_name
,
583 BDRVQcow2State
*s
= bs
->opaque
;
585 if (entries
> max_size_bytes
/ entry_len
) {
586 error_setg(errp
, "%s too large", table_name
);
590 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
591 * because values will be passed to qemu functions taking int64_t. */
592 if ((INT64_MAX
- entries
* entry_len
< offset
) ||
593 (offset_into_cluster(s
, offset
) != 0)) {
594 error_setg(errp
, "%s offset invalid", table_name
);
601 static QemuOptsList qcow2_runtime_opts
= {
603 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
606 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
607 .type
= QEMU_OPT_BOOL
,
608 .help
= "Postpone refcount updates",
611 .name
= QCOW2_OPT_DISCARD_REQUEST
,
612 .type
= QEMU_OPT_BOOL
,
613 .help
= "Pass guest discard requests to the layer below",
616 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
617 .type
= QEMU_OPT_BOOL
,
618 .help
= "Generate discard requests when snapshot related space "
622 .name
= QCOW2_OPT_DISCARD_OTHER
,
623 .type
= QEMU_OPT_BOOL
,
624 .help
= "Generate discard requests when other clusters are freed",
627 .name
= QCOW2_OPT_OVERLAP
,
628 .type
= QEMU_OPT_STRING
,
629 .help
= "Selects which overlap checks to perform from a range of "
630 "templates (none, constant, cached, all)",
633 .name
= QCOW2_OPT_OVERLAP_TEMPLATE
,
634 .type
= QEMU_OPT_STRING
,
635 .help
= "Selects which overlap checks to perform from a range of "
636 "templates (none, constant, cached, all)",
639 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
640 .type
= QEMU_OPT_BOOL
,
641 .help
= "Check for unintended writes into the main qcow2 header",
644 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
645 .type
= QEMU_OPT_BOOL
,
646 .help
= "Check for unintended writes into the active L1 table",
649 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
650 .type
= QEMU_OPT_BOOL
,
651 .help
= "Check for unintended writes into an active L2 table",
654 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
655 .type
= QEMU_OPT_BOOL
,
656 .help
= "Check for unintended writes into the refcount table",
659 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
660 .type
= QEMU_OPT_BOOL
,
661 .help
= "Check for unintended writes into a refcount block",
664 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
665 .type
= QEMU_OPT_BOOL
,
666 .help
= "Check for unintended writes into the snapshot table",
669 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
670 .type
= QEMU_OPT_BOOL
,
671 .help
= "Check for unintended writes into an inactive L1 table",
674 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
675 .type
= QEMU_OPT_BOOL
,
676 .help
= "Check for unintended writes into an inactive L2 table",
679 .name
= QCOW2_OPT_CACHE_SIZE
,
680 .type
= QEMU_OPT_SIZE
,
681 .help
= "Maximum combined metadata (L2 tables and refcount blocks) "
685 .name
= QCOW2_OPT_L2_CACHE_SIZE
,
686 .type
= QEMU_OPT_SIZE
,
687 .help
= "Maximum L2 table cache size",
690 .name
= QCOW2_OPT_L2_CACHE_ENTRY_SIZE
,
691 .type
= QEMU_OPT_SIZE
,
692 .help
= "Size of each entry in the L2 cache",
695 .name
= QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
696 .type
= QEMU_OPT_SIZE
,
697 .help
= "Maximum refcount block cache size",
700 .name
= QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
701 .type
= QEMU_OPT_NUMBER
,
702 .help
= "Clean unused cache entries after this time (in seconds)",
704 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
705 "ID of secret providing qcow2 AES key or LUKS passphrase"),
706 { /* end of list */ }
710 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
711 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
712 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
713 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
714 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
715 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
716 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
717 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
718 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
721 static void cache_clean_timer_cb(void *opaque
)
723 BlockDriverState
*bs
= opaque
;
724 BDRVQcow2State
*s
= bs
->opaque
;
725 qcow2_cache_clean_unused(s
->l2_table_cache
);
726 qcow2_cache_clean_unused(s
->refcount_block_cache
);
727 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
728 (int64_t) s
->cache_clean_interval
* 1000);
731 static void cache_clean_timer_init(BlockDriverState
*bs
, AioContext
*context
)
733 BDRVQcow2State
*s
= bs
->opaque
;
734 if (s
->cache_clean_interval
> 0) {
735 s
->cache_clean_timer
= aio_timer_new(context
, QEMU_CLOCK_VIRTUAL
,
736 SCALE_MS
, cache_clean_timer_cb
,
738 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
739 (int64_t) s
->cache_clean_interval
* 1000);
743 static void cache_clean_timer_del(BlockDriverState
*bs
)
745 BDRVQcow2State
*s
= bs
->opaque
;
746 if (s
->cache_clean_timer
) {
747 timer_del(s
->cache_clean_timer
);
748 timer_free(s
->cache_clean_timer
);
749 s
->cache_clean_timer
= NULL
;
753 static void qcow2_detach_aio_context(BlockDriverState
*bs
)
755 cache_clean_timer_del(bs
);
758 static void qcow2_attach_aio_context(BlockDriverState
*bs
,
759 AioContext
*new_context
)
761 cache_clean_timer_init(bs
, new_context
);
764 static void read_cache_sizes(BlockDriverState
*bs
, QemuOpts
*opts
,
765 uint64_t *l2_cache_size
,
766 uint64_t *l2_cache_entry_size
,
767 uint64_t *refcount_cache_size
, Error
**errp
)
769 BDRVQcow2State
*s
= bs
->opaque
;
770 uint64_t combined_cache_size
;
771 bool l2_cache_size_set
, refcount_cache_size_set
, combined_cache_size_set
;
772 int min_refcount_cache
= MIN_REFCOUNT_CACHE_SIZE
* s
->cluster_size
;
774 combined_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_CACHE_SIZE
);
775 l2_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_SIZE
);
776 refcount_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
778 combined_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_CACHE_SIZE
, 0);
779 *l2_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_L2_CACHE_SIZE
, 0);
780 *refcount_cache_size
= qemu_opt_get_size(opts
,
781 QCOW2_OPT_REFCOUNT_CACHE_SIZE
, 0);
783 *l2_cache_entry_size
= qemu_opt_get_size(
784 opts
, QCOW2_OPT_L2_CACHE_ENTRY_SIZE
, s
->cluster_size
);
786 if (combined_cache_size_set
) {
787 if (l2_cache_size_set
&& refcount_cache_size_set
) {
788 error_setg(errp
, QCOW2_OPT_CACHE_SIZE
", " QCOW2_OPT_L2_CACHE_SIZE
789 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not be set "
792 } else if (*l2_cache_size
> combined_cache_size
) {
793 error_setg(errp
, QCOW2_OPT_L2_CACHE_SIZE
" may not exceed "
794 QCOW2_OPT_CACHE_SIZE
);
796 } else if (*refcount_cache_size
> combined_cache_size
) {
797 error_setg(errp
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not exceed "
798 QCOW2_OPT_CACHE_SIZE
);
802 if (l2_cache_size_set
) {
803 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
804 } else if (refcount_cache_size_set
) {
805 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
807 uint64_t virtual_disk_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
808 uint64_t max_l2_cache
= virtual_disk_size
/ (s
->cluster_size
/ 8);
810 /* Assign as much memory as possible to the L2 cache, and
811 * use the remainder for the refcount cache */
812 if (combined_cache_size
>= max_l2_cache
+ min_refcount_cache
) {
813 *l2_cache_size
= max_l2_cache
;
814 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
816 *refcount_cache_size
=
817 MIN(combined_cache_size
, min_refcount_cache
);
818 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
822 if (!l2_cache_size_set
) {
823 *l2_cache_size
= MAX(DEFAULT_L2_CACHE_BYTE_SIZE
,
824 (uint64_t)DEFAULT_L2_CACHE_CLUSTERS
827 if (!refcount_cache_size_set
) {
828 *refcount_cache_size
= min_refcount_cache
;
832 if (*l2_cache_entry_size
< (1 << MIN_CLUSTER_BITS
) ||
833 *l2_cache_entry_size
> s
->cluster_size
||
834 !is_power_of_2(*l2_cache_entry_size
)) {
835 error_setg(errp
, "L2 cache entry size must be a power of two "
836 "between %d and the cluster size (%d)",
837 1 << MIN_CLUSTER_BITS
, s
->cluster_size
);
842 typedef struct Qcow2ReopenState
{
843 Qcow2Cache
*l2_table_cache
;
844 Qcow2Cache
*refcount_block_cache
;
845 int l2_slice_size
; /* Number of entries in a slice of the L2 table */
846 bool use_lazy_refcounts
;
848 bool discard_passthrough
[QCOW2_DISCARD_MAX
];
849 uint64_t cache_clean_interval
;
850 QCryptoBlockOpenOptions
*crypto_opts
; /* Disk encryption runtime options */
853 static int qcow2_update_options_prepare(BlockDriverState
*bs
,
855 QDict
*options
, int flags
,
858 BDRVQcow2State
*s
= bs
->opaque
;
859 QemuOpts
*opts
= NULL
;
860 const char *opt_overlap_check
, *opt_overlap_check_template
;
861 int overlap_check_template
= 0;
862 uint64_t l2_cache_size
, l2_cache_entry_size
, refcount_cache_size
;
864 const char *encryptfmt
;
865 QDict
*encryptopts
= NULL
;
866 Error
*local_err
= NULL
;
869 qdict_extract_subqdict(options
, &encryptopts
, "encrypt.");
870 encryptfmt
= qdict_get_try_str(encryptopts
, "format");
872 opts
= qemu_opts_create(&qcow2_runtime_opts
, NULL
, 0, &error_abort
);
873 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
875 error_propagate(errp
, local_err
);
880 /* get L2 table/refcount block cache size from command line options */
881 read_cache_sizes(bs
, opts
, &l2_cache_size
, &l2_cache_entry_size
,
882 &refcount_cache_size
, &local_err
);
884 error_propagate(errp
, local_err
);
889 l2_cache_size
/= l2_cache_entry_size
;
890 if (l2_cache_size
< MIN_L2_CACHE_SIZE
) {
891 l2_cache_size
= MIN_L2_CACHE_SIZE
;
893 if (l2_cache_size
> INT_MAX
) {
894 error_setg(errp
, "L2 cache size too big");
899 refcount_cache_size
/= s
->cluster_size
;
900 if (refcount_cache_size
< MIN_REFCOUNT_CACHE_SIZE
) {
901 refcount_cache_size
= MIN_REFCOUNT_CACHE_SIZE
;
903 if (refcount_cache_size
> INT_MAX
) {
904 error_setg(errp
, "Refcount cache size too big");
909 /* alloc new L2 table/refcount block cache, flush old one */
910 if (s
->l2_table_cache
) {
911 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
913 error_setg_errno(errp
, -ret
, "Failed to flush the L2 table cache");
918 if (s
->refcount_block_cache
) {
919 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
921 error_setg_errno(errp
, -ret
,
922 "Failed to flush the refcount block cache");
927 r
->l2_slice_size
= l2_cache_entry_size
/ sizeof(uint64_t);
928 r
->l2_table_cache
= qcow2_cache_create(bs
, l2_cache_size
,
929 l2_cache_entry_size
);
930 r
->refcount_block_cache
= qcow2_cache_create(bs
, refcount_cache_size
,
932 if (r
->l2_table_cache
== NULL
|| r
->refcount_block_cache
== NULL
) {
933 error_setg(errp
, "Could not allocate metadata caches");
938 /* New interval for cache cleanup timer */
939 r
->cache_clean_interval
=
940 qemu_opt_get_number(opts
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
941 s
->cache_clean_interval
);
943 if (r
->cache_clean_interval
!= 0) {
944 error_setg(errp
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
945 " not supported on this host");
950 if (r
->cache_clean_interval
> UINT_MAX
) {
951 error_setg(errp
, "Cache clean interval too big");
956 /* lazy-refcounts; flush if going from enabled to disabled */
957 r
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
958 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
959 if (r
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
960 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
961 "qemu 1.1 compatibility level");
966 if (s
->use_lazy_refcounts
&& !r
->use_lazy_refcounts
) {
967 ret
= qcow2_mark_clean(bs
);
969 error_setg_errno(errp
, -ret
, "Failed to disable lazy refcounts");
974 /* Overlap check options */
975 opt_overlap_check
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP
);
976 opt_overlap_check_template
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP_TEMPLATE
);
977 if (opt_overlap_check_template
&& opt_overlap_check
&&
978 strcmp(opt_overlap_check_template
, opt_overlap_check
))
980 error_setg(errp
, "Conflicting values for qcow2 options '"
981 QCOW2_OPT_OVERLAP
"' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
982 "' ('%s')", opt_overlap_check
, opt_overlap_check_template
);
986 if (!opt_overlap_check
) {
987 opt_overlap_check
= opt_overlap_check_template
?: "cached";
990 if (!strcmp(opt_overlap_check
, "none")) {
991 overlap_check_template
= 0;
992 } else if (!strcmp(opt_overlap_check
, "constant")) {
993 overlap_check_template
= QCOW2_OL_CONSTANT
;
994 } else if (!strcmp(opt_overlap_check
, "cached")) {
995 overlap_check_template
= QCOW2_OL_CACHED
;
996 } else if (!strcmp(opt_overlap_check
, "all")) {
997 overlap_check_template
= QCOW2_OL_ALL
;
999 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
1000 "'overlap-check'. Allowed are any of the following: "
1001 "none, constant, cached, all", opt_overlap_check
);
1006 r
->overlap_check
= 0;
1007 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
1008 /* overlap-check defines a template bitmask, but every flag may be
1009 * overwritten through the associated boolean option */
1011 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
1012 overlap_check_template
& (1 << i
)) << i
;
1015 r
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
1016 r
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
1017 r
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
1018 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
1019 flags
& BDRV_O_UNMAP
);
1020 r
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
1021 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
1022 r
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
1023 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
1025 switch (s
->crypt_method_header
) {
1026 case QCOW_CRYPT_NONE
:
1028 error_setg(errp
, "No encryption in image header, but options "
1029 "specified format '%s'", encryptfmt
);
1035 case QCOW_CRYPT_AES
:
1036 if (encryptfmt
&& !g_str_equal(encryptfmt
, "aes")) {
1038 "Header reported 'aes' encryption format but "
1039 "options specify '%s'", encryptfmt
);
1043 qdict_del(encryptopts
, "format");
1044 r
->crypto_opts
= block_crypto_open_opts_init(
1045 Q_CRYPTO_BLOCK_FORMAT_QCOW
, encryptopts
, errp
);
1048 case QCOW_CRYPT_LUKS
:
1049 if (encryptfmt
&& !g_str_equal(encryptfmt
, "luks")) {
1051 "Header reported 'luks' encryption format but "
1052 "options specify '%s'", encryptfmt
);
1056 qdict_del(encryptopts
, "format");
1057 r
->crypto_opts
= block_crypto_open_opts_init(
1058 Q_CRYPTO_BLOCK_FORMAT_LUKS
, encryptopts
, errp
);
1062 error_setg(errp
, "Unsupported encryption method %d",
1063 s
->crypt_method_header
);
1066 if (s
->crypt_method_header
!= QCOW_CRYPT_NONE
&& !r
->crypto_opts
) {
1073 qobject_unref(encryptopts
);
1074 qemu_opts_del(opts
);
1079 static void qcow2_update_options_commit(BlockDriverState
*bs
,
1080 Qcow2ReopenState
*r
)
1082 BDRVQcow2State
*s
= bs
->opaque
;
1085 if (s
->l2_table_cache
) {
1086 qcow2_cache_destroy(s
->l2_table_cache
);
1088 if (s
->refcount_block_cache
) {
1089 qcow2_cache_destroy(s
->refcount_block_cache
);
1091 s
->l2_table_cache
= r
->l2_table_cache
;
1092 s
->refcount_block_cache
= r
->refcount_block_cache
;
1093 s
->l2_slice_size
= r
->l2_slice_size
;
1095 s
->overlap_check
= r
->overlap_check
;
1096 s
->use_lazy_refcounts
= r
->use_lazy_refcounts
;
1098 for (i
= 0; i
< QCOW2_DISCARD_MAX
; i
++) {
1099 s
->discard_passthrough
[i
] = r
->discard_passthrough
[i
];
1102 if (s
->cache_clean_interval
!= r
->cache_clean_interval
) {
1103 cache_clean_timer_del(bs
);
1104 s
->cache_clean_interval
= r
->cache_clean_interval
;
1105 cache_clean_timer_init(bs
, bdrv_get_aio_context(bs
));
1108 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1109 s
->crypto_opts
= r
->crypto_opts
;
1112 static void qcow2_update_options_abort(BlockDriverState
*bs
,
1113 Qcow2ReopenState
*r
)
1115 if (r
->l2_table_cache
) {
1116 qcow2_cache_destroy(r
->l2_table_cache
);
1118 if (r
->refcount_block_cache
) {
1119 qcow2_cache_destroy(r
->refcount_block_cache
);
1121 qapi_free_QCryptoBlockOpenOptions(r
->crypto_opts
);
1124 static int qcow2_update_options(BlockDriverState
*bs
, QDict
*options
,
1125 int flags
, Error
**errp
)
1127 Qcow2ReopenState r
= {};
1130 ret
= qcow2_update_options_prepare(bs
, &r
, options
, flags
, errp
);
1132 qcow2_update_options_commit(bs
, &r
);
1134 qcow2_update_options_abort(bs
, &r
);
1140 /* Called with s->lock held. */
1141 static int coroutine_fn
qcow2_do_open(BlockDriverState
*bs
, QDict
*options
,
1142 int flags
, Error
**errp
)
1144 BDRVQcow2State
*s
= bs
->opaque
;
1145 unsigned int len
, i
;
1148 Error
*local_err
= NULL
;
1150 uint64_t l1_vm_state_index
;
1151 bool update_header
= false;
1152 bool header_updated
= false;
1154 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
1156 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
1159 be32_to_cpus(&header
.magic
);
1160 be32_to_cpus(&header
.version
);
1161 be64_to_cpus(&header
.backing_file_offset
);
1162 be32_to_cpus(&header
.backing_file_size
);
1163 be64_to_cpus(&header
.size
);
1164 be32_to_cpus(&header
.cluster_bits
);
1165 be32_to_cpus(&header
.crypt_method
);
1166 be64_to_cpus(&header
.l1_table_offset
);
1167 be32_to_cpus(&header
.l1_size
);
1168 be64_to_cpus(&header
.refcount_table_offset
);
1169 be32_to_cpus(&header
.refcount_table_clusters
);
1170 be64_to_cpus(&header
.snapshots_offset
);
1171 be32_to_cpus(&header
.nb_snapshots
);
1173 if (header
.magic
!= QCOW_MAGIC
) {
1174 error_setg(errp
, "Image is not in qcow2 format");
1178 if (header
.version
< 2 || header
.version
> 3) {
1179 error_setg(errp
, "Unsupported qcow2 version %" PRIu32
, header
.version
);
1184 s
->qcow_version
= header
.version
;
1186 /* Initialise cluster size */
1187 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
1188 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
1189 error_setg(errp
, "Unsupported cluster size: 2^%" PRIu32
,
1190 header
.cluster_bits
);
1195 s
->cluster_bits
= header
.cluster_bits
;
1196 s
->cluster_size
= 1 << s
->cluster_bits
;
1197 s
->cluster_sectors
= 1 << (s
->cluster_bits
- BDRV_SECTOR_BITS
);
1199 /* Initialise version 3 header fields */
1200 if (header
.version
== 2) {
1201 header
.incompatible_features
= 0;
1202 header
.compatible_features
= 0;
1203 header
.autoclear_features
= 0;
1204 header
.refcount_order
= 4;
1205 header
.header_length
= 72;
1207 be64_to_cpus(&header
.incompatible_features
);
1208 be64_to_cpus(&header
.compatible_features
);
1209 be64_to_cpus(&header
.autoclear_features
);
1210 be32_to_cpus(&header
.refcount_order
);
1211 be32_to_cpus(&header
.header_length
);
1213 if (header
.header_length
< 104) {
1214 error_setg(errp
, "qcow2 header too short");
1220 if (header
.header_length
> s
->cluster_size
) {
1221 error_setg(errp
, "qcow2 header exceeds cluster size");
1226 if (header
.header_length
> sizeof(header
)) {
1227 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
1228 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
1229 ret
= bdrv_pread(bs
->file
, sizeof(header
), s
->unknown_header_fields
,
1230 s
->unknown_header_fields_size
);
1232 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
1238 if (header
.backing_file_offset
> s
->cluster_size
) {
1239 error_setg(errp
, "Invalid backing file offset");
1244 if (header
.backing_file_offset
) {
1245 ext_end
= header
.backing_file_offset
;
1247 ext_end
= 1 << header
.cluster_bits
;
1250 /* Handle feature bits */
1251 s
->incompatible_features
= header
.incompatible_features
;
1252 s
->compatible_features
= header
.compatible_features
;
1253 s
->autoclear_features
= header
.autoclear_features
;
1255 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
1256 void *feature_table
= NULL
;
1257 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
1258 &feature_table
, flags
, NULL
, NULL
);
1259 report_unsupported_feature(errp
, feature_table
,
1260 s
->incompatible_features
&
1261 ~QCOW2_INCOMPAT_MASK
);
1263 g_free(feature_table
);
1267 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
1268 /* Corrupt images may not be written to unless they are being repaired
1270 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
1271 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
1278 /* Check support for various header values */
1279 if (header
.refcount_order
> 6) {
1280 error_setg(errp
, "Reference count entry width too large; may not "
1285 s
->refcount_order
= header
.refcount_order
;
1286 s
->refcount_bits
= 1 << s
->refcount_order
;
1287 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
1288 s
->refcount_max
+= s
->refcount_max
- 1;
1290 s
->crypt_method_header
= header
.crypt_method
;
1291 if (s
->crypt_method_header
) {
1292 if (bdrv_uses_whitelist() &&
1293 s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1295 "Use of AES-CBC encrypted qcow2 images is no longer "
1296 "supported in system emulators");
1297 error_append_hint(errp
,
1298 "You can use 'qemu-img convert' to convert your "
1299 "image to an alternative supported format, such "
1300 "as unencrypted qcow2, or raw with the LUKS "
1301 "format instead.\n");
1306 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1307 s
->crypt_physical_offset
= false;
1309 /* Assuming LUKS and any future crypt methods we
1310 * add will all use physical offsets, due to the
1311 * fact that the alternative is insecure... */
1312 s
->crypt_physical_offset
= true;
1315 bs
->encrypted
= true;
1318 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
1319 s
->l2_size
= 1 << s
->l2_bits
;
1320 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1321 s
->refcount_block_bits
= s
->cluster_bits
- (s
->refcount_order
- 3);
1322 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
1323 bs
->total_sectors
= header
.size
/ 512;
1324 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
1325 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
1326 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
1328 s
->refcount_table_offset
= header
.refcount_table_offset
;
1329 s
->refcount_table_size
=
1330 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
1332 if (header
.refcount_table_clusters
== 0 && !(flags
& BDRV_O_CHECK
)) {
1333 error_setg(errp
, "Image does not contain a reference count table");
1338 ret
= qcow2_validate_table(bs
, s
->refcount_table_offset
,
1339 header
.refcount_table_clusters
,
1340 s
->cluster_size
, QCOW_MAX_REFTABLE_SIZE
,
1341 "Reference count table", errp
);
1346 /* The total size in bytes of the snapshot table is checked in
1347 * qcow2_read_snapshots() because the size of each snapshot is
1348 * variable and we don't know it yet.
1349 * Here we only check the offset and number of snapshots. */
1350 ret
= qcow2_validate_table(bs
, header
.snapshots_offset
,
1351 header
.nb_snapshots
,
1352 sizeof(QCowSnapshotHeader
),
1353 sizeof(QCowSnapshotHeader
) * QCOW_MAX_SNAPSHOTS
,
1354 "Snapshot table", errp
);
1359 /* read the level 1 table */
1360 ret
= qcow2_validate_table(bs
, header
.l1_table_offset
,
1361 header
.l1_size
, sizeof(uint64_t),
1362 QCOW_MAX_L1_SIZE
, "Active L1 table", errp
);
1366 s
->l1_size
= header
.l1_size
;
1367 s
->l1_table_offset
= header
.l1_table_offset
;
1369 l1_vm_state_index
= size_to_l1(s
, header
.size
);
1370 if (l1_vm_state_index
> INT_MAX
) {
1371 error_setg(errp
, "Image is too big");
1375 s
->l1_vm_state_index
= l1_vm_state_index
;
1377 /* the L1 table must contain at least enough entries to put
1378 header.size bytes */
1379 if (s
->l1_size
< s
->l1_vm_state_index
) {
1380 error_setg(errp
, "L1 table is too small");
1385 if (s
->l1_size
> 0) {
1386 s
->l1_table
= qemu_try_blockalign(bs
->file
->bs
,
1387 ROUND_UP(s
->l1_size
* sizeof(uint64_t), 512));
1388 if (s
->l1_table
== NULL
) {
1389 error_setg(errp
, "Could not allocate L1 table");
1393 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
1394 s
->l1_size
* sizeof(uint64_t));
1396 error_setg_errno(errp
, -ret
, "Could not read L1 table");
1399 for(i
= 0;i
< s
->l1_size
; i
++) {
1400 be64_to_cpus(&s
->l1_table
[i
]);
1404 /* Parse driver-specific options */
1405 ret
= qcow2_update_options(bs
, options
, flags
, errp
);
1410 s
->cluster_cache_offset
= -1;
1413 ret
= qcow2_refcount_init(bs
);
1415 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
1419 QLIST_INIT(&s
->cluster_allocs
);
1420 QTAILQ_INIT(&s
->discards
);
1422 /* read qcow2 extensions */
1423 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
1424 flags
, &update_header
, &local_err
)) {
1425 error_propagate(errp
, local_err
);
1430 /* qcow2_read_extension may have set up the crypto context
1431 * if the crypt method needs a header region, some methods
1432 * don't need header extensions, so must check here
1434 if (s
->crypt_method_header
&& !s
->crypto
) {
1435 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1436 unsigned int cflags
= 0;
1437 if (flags
& BDRV_O_NO_IO
) {
1438 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
1440 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
1441 NULL
, NULL
, cflags
, errp
);
1446 } else if (!(flags
& BDRV_O_NO_IO
)) {
1447 error_setg(errp
, "Missing CRYPTO header for crypt method %d",
1448 s
->crypt_method_header
);
1454 /* read the backing file name */
1455 if (header
.backing_file_offset
!= 0) {
1456 len
= header
.backing_file_size
;
1457 if (len
> MIN(1023, s
->cluster_size
- header
.backing_file_offset
) ||
1458 len
>= sizeof(bs
->backing_file
)) {
1459 error_setg(errp
, "Backing file name too long");
1463 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
1464 bs
->backing_file
, len
);
1466 error_setg_errno(errp
, -ret
, "Could not read backing file name");
1469 bs
->backing_file
[len
] = '\0';
1470 s
->image_backing_file
= g_strdup(bs
->backing_file
);
1473 /* Internal snapshots */
1474 s
->snapshots_offset
= header
.snapshots_offset
;
1475 s
->nb_snapshots
= header
.nb_snapshots
;
1477 ret
= qcow2_read_snapshots(bs
);
1479 error_setg_errno(errp
, -ret
, "Could not read snapshots");
1483 /* Clear unknown autoclear feature bits */
1484 update_header
|= s
->autoclear_features
& ~QCOW2_AUTOCLEAR_MASK
;
1486 update_header
&& !bs
->read_only
&& !(flags
& BDRV_O_INACTIVE
);
1487 if (update_header
) {
1488 s
->autoclear_features
&= QCOW2_AUTOCLEAR_MASK
;
1491 if (s
->dirty_bitmaps_loaded
) {
1492 /* It's some kind of reopen. There are no known cases where we need to
1493 * reload bitmaps in such a situation, so it's safer to skip them.
1495 * Moreover, if we have some readonly bitmaps and we are reopening for
1496 * rw we should reopen bitmaps correspondingly.
1498 if (bdrv_has_readonly_bitmaps(bs
) &&
1499 !bdrv_is_read_only(bs
) && !(bdrv_get_flags(bs
) & BDRV_O_INACTIVE
))
1501 qcow2_reopen_bitmaps_rw_hint(bs
, &header_updated
, &local_err
);
1504 header_updated
= qcow2_load_dirty_bitmaps(bs
, &local_err
);
1505 s
->dirty_bitmaps_loaded
= true;
1507 update_header
= update_header
&& !header_updated
;
1508 if (local_err
!= NULL
) {
1509 error_propagate(errp
, local_err
);
1514 if (update_header
) {
1515 ret
= qcow2_update_header(bs
);
1517 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
1522 bs
->supported_zero_flags
= header
.version
>= 3 ? BDRV_REQ_MAY_UNMAP
: 0;
1524 /* Repair image if dirty */
1525 if (!(flags
& (BDRV_O_CHECK
| BDRV_O_INACTIVE
)) && !bs
->read_only
&&
1526 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
1527 BdrvCheckResult result
= {0};
1529 ret
= qcow2_co_check_locked(bs
, &result
,
1530 BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1531 if (ret
< 0 || result
.check_errors
) {
1535 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
1542 BdrvCheckResult result
= {0};
1543 qcow2_check_refcounts(bs
, &result
, 0);
1549 g_free(s
->unknown_header_fields
);
1550 cleanup_unknown_header_ext(bs
);
1551 qcow2_free_snapshots(bs
);
1552 qcow2_refcount_close(bs
);
1553 qemu_vfree(s
->l1_table
);
1554 /* else pre-write overlap checks in cache_destroy may crash */
1556 cache_clean_timer_del(bs
);
1557 if (s
->l2_table_cache
) {
1558 qcow2_cache_destroy(s
->l2_table_cache
);
1560 if (s
->refcount_block_cache
) {
1561 qcow2_cache_destroy(s
->refcount_block_cache
);
1563 qcrypto_block_free(s
->crypto
);
1564 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1568 typedef struct QCow2OpenCo
{
1569 BlockDriverState
*bs
;
1576 static void coroutine_fn
qcow2_open_entry(void *opaque
)
1578 QCow2OpenCo
*qoc
= opaque
;
1579 BDRVQcow2State
*s
= qoc
->bs
->opaque
;
1581 qemu_co_mutex_lock(&s
->lock
);
1582 qoc
->ret
= qcow2_do_open(qoc
->bs
, qoc
->options
, qoc
->flags
, qoc
->errp
);
1583 qemu_co_mutex_unlock(&s
->lock
);
1586 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1589 BDRVQcow2State
*s
= bs
->opaque
;
1598 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
1604 /* Initialise locks */
1605 qemu_co_mutex_init(&s
->lock
);
1607 if (qemu_in_coroutine()) {
1608 /* From bdrv_co_create. */
1609 qcow2_open_entry(&qoc
);
1611 qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry
, &qoc
));
1612 BDRV_POLL_WHILE(bs
, qoc
.ret
== -EINPROGRESS
);
1617 static void qcow2_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
1619 BDRVQcow2State
*s
= bs
->opaque
;
1621 if (bs
->encrypted
) {
1622 /* Encryption works on a sector granularity */
1623 bs
->bl
.request_alignment
= BDRV_SECTOR_SIZE
;
1625 bs
->bl
.pwrite_zeroes_alignment
= s
->cluster_size
;
1626 bs
->bl
.pdiscard_alignment
= s
->cluster_size
;
1629 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
1630 BlockReopenQueue
*queue
, Error
**errp
)
1632 Qcow2ReopenState
*r
;
1635 r
= g_new0(Qcow2ReopenState
, 1);
1638 ret
= qcow2_update_options_prepare(state
->bs
, r
, state
->options
,
1639 state
->flags
, errp
);
1644 /* We need to write out any unwritten data if we reopen read-only. */
1645 if ((state
->flags
& BDRV_O_RDWR
) == 0) {
1646 ret
= qcow2_reopen_bitmaps_ro(state
->bs
, errp
);
1651 ret
= bdrv_flush(state
->bs
);
1656 ret
= qcow2_mark_clean(state
->bs
);
1665 qcow2_update_options_abort(state
->bs
, r
);
1670 static void qcow2_reopen_commit(BDRVReopenState
*state
)
1672 qcow2_update_options_commit(state
->bs
, state
->opaque
);
1673 g_free(state
->opaque
);
1676 static void qcow2_reopen_abort(BDRVReopenState
*state
)
1678 qcow2_update_options_abort(state
->bs
, state
->opaque
);
1679 g_free(state
->opaque
);
1682 static void qcow2_join_options(QDict
*options
, QDict
*old_options
)
1684 bool has_new_overlap_template
=
1685 qdict_haskey(options
, QCOW2_OPT_OVERLAP
) ||
1686 qdict_haskey(options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1687 bool has_new_total_cache_size
=
1688 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
);
1689 bool has_all_cache_options
;
1691 /* New overlap template overrides all old overlap options */
1692 if (has_new_overlap_template
) {
1693 qdict_del(old_options
, QCOW2_OPT_OVERLAP
);
1694 qdict_del(old_options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1695 qdict_del(old_options
, QCOW2_OPT_OVERLAP_MAIN_HEADER
);
1696 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L1
);
1697 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L2
);
1698 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
);
1699 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
);
1700 qdict_del(old_options
, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
);
1701 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L1
);
1702 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L2
);
1705 /* New total cache size overrides all old options */
1706 if (qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
)) {
1707 qdict_del(old_options
, QCOW2_OPT_L2_CACHE_SIZE
);
1708 qdict_del(old_options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1711 qdict_join(options
, old_options
, false);
1714 * If after merging all cache size options are set, an old total size is
1715 * overwritten. Do keep all options, however, if all three are new. The
1716 * resulting error message is what we want to happen.
1718 has_all_cache_options
=
1719 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
) ||
1720 qdict_haskey(options
, QCOW2_OPT_L2_CACHE_SIZE
) ||
1721 qdict_haskey(options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1723 if (has_all_cache_options
&& !has_new_total_cache_size
) {
1724 qdict_del(options
, QCOW2_OPT_CACHE_SIZE
);
1728 static int coroutine_fn
qcow2_co_block_status(BlockDriverState
*bs
,
1730 int64_t offset
, int64_t count
,
1731 int64_t *pnum
, int64_t *map
,
1732 BlockDriverState
**file
)
1734 BDRVQcow2State
*s
= bs
->opaque
;
1735 uint64_t cluster_offset
;
1736 int index_in_cluster
, ret
;
1740 bytes
= MIN(INT_MAX
, count
);
1741 qemu_co_mutex_lock(&s
->lock
);
1742 ret
= qcow2_get_cluster_offset(bs
, offset
, &bytes
, &cluster_offset
);
1743 qemu_co_mutex_unlock(&s
->lock
);
1750 if (cluster_offset
!= 0 && ret
!= QCOW2_CLUSTER_COMPRESSED
&&
1752 index_in_cluster
= offset
& (s
->cluster_size
- 1);
1753 *map
= cluster_offset
| index_in_cluster
;
1754 *file
= bs
->file
->bs
;
1755 status
|= BDRV_BLOCK_OFFSET_VALID
;
1757 if (ret
== QCOW2_CLUSTER_ZERO_PLAIN
|| ret
== QCOW2_CLUSTER_ZERO_ALLOC
) {
1758 status
|= BDRV_BLOCK_ZERO
;
1759 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
1760 status
|= BDRV_BLOCK_DATA
;
1765 static coroutine_fn
int qcow2_handle_l2meta(BlockDriverState
*bs
,
1766 QCowL2Meta
**pl2meta
,
1770 QCowL2Meta
*l2meta
= *pl2meta
;
1772 while (l2meta
!= NULL
) {
1775 if (!ret
&& link_l2
) {
1776 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
1782 /* Take the request off the list of running requests */
1783 if (l2meta
->nb_clusters
!= 0) {
1784 QLIST_REMOVE(l2meta
, next_in_flight
);
1787 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1789 next
= l2meta
->next
;
1798 static coroutine_fn
int qcow2_co_preadv(BlockDriverState
*bs
, uint64_t offset
,
1799 uint64_t bytes
, QEMUIOVector
*qiov
,
1802 BDRVQcow2State
*s
= bs
->opaque
;
1803 int offset_in_cluster
;
1805 unsigned int cur_bytes
; /* number of bytes in current iteration */
1806 uint64_t cluster_offset
= 0;
1807 uint64_t bytes_done
= 0;
1808 QEMUIOVector hd_qiov
;
1809 uint8_t *cluster_data
= NULL
;
1811 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1813 qemu_co_mutex_lock(&s
->lock
);
1815 while (bytes
!= 0) {
1817 /* prepare next request */
1818 cur_bytes
= MIN(bytes
, INT_MAX
);
1820 cur_bytes
= MIN(cur_bytes
,
1821 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1824 ret
= qcow2_get_cluster_offset(bs
, offset
, &cur_bytes
, &cluster_offset
);
1829 offset_in_cluster
= offset_into_cluster(s
, offset
);
1831 qemu_iovec_reset(&hd_qiov
);
1832 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
1835 case QCOW2_CLUSTER_UNALLOCATED
:
1838 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
1839 qemu_co_mutex_unlock(&s
->lock
);
1840 ret
= bdrv_co_preadv(bs
->backing
, offset
, cur_bytes
,
1842 qemu_co_mutex_lock(&s
->lock
);
1847 /* Note: in this case, no need to wait */
1848 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1852 case QCOW2_CLUSTER_ZERO_PLAIN
:
1853 case QCOW2_CLUSTER_ZERO_ALLOC
:
1854 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1857 case QCOW2_CLUSTER_COMPRESSED
:
1858 /* add AIO support for compressed blocks ? */
1859 ret
= qcow2_decompress_cluster(bs
, cluster_offset
);
1864 qemu_iovec_from_buf(&hd_qiov
, 0,
1865 s
->cluster_cache
+ offset_in_cluster
,
1869 case QCOW2_CLUSTER_NORMAL
:
1870 if ((cluster_offset
& 511) != 0) {
1875 if (bs
->encrypted
) {
1879 * For encrypted images, read everything into a temporary
1880 * contiguous buffer on which the AES functions can work.
1882 if (!cluster_data
) {
1884 qemu_try_blockalign(bs
->file
->bs
,
1885 QCOW_MAX_CRYPT_CLUSTERS
1887 if (cluster_data
== NULL
) {
1893 assert(cur_bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1894 qemu_iovec_reset(&hd_qiov
);
1895 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
1898 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
1899 qemu_co_mutex_unlock(&s
->lock
);
1900 ret
= bdrv_co_preadv(bs
->file
,
1901 cluster_offset
+ offset_in_cluster
,
1902 cur_bytes
, &hd_qiov
, 0);
1903 qemu_co_mutex_lock(&s
->lock
);
1907 if (bs
->encrypted
) {
1909 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1910 assert((cur_bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1911 if (qcrypto_block_decrypt(s
->crypto
,
1912 (s
->crypt_physical_offset
?
1913 cluster_offset
+ offset_in_cluster
:
1921 qemu_iovec_from_buf(qiov
, bytes_done
, cluster_data
, cur_bytes
);
1926 g_assert_not_reached();
1932 offset
+= cur_bytes
;
1933 bytes_done
+= cur_bytes
;
1938 qemu_co_mutex_unlock(&s
->lock
);
1940 qemu_iovec_destroy(&hd_qiov
);
1941 qemu_vfree(cluster_data
);
1946 /* Check if it's possible to merge a write request with the writing of
1947 * the data from the COW regions */
1948 static bool merge_cow(uint64_t offset
, unsigned bytes
,
1949 QEMUIOVector
*hd_qiov
, QCowL2Meta
*l2meta
)
1953 for (m
= l2meta
; m
!= NULL
; m
= m
->next
) {
1954 /* If both COW regions are empty then there's nothing to merge */
1955 if (m
->cow_start
.nb_bytes
== 0 && m
->cow_end
.nb_bytes
== 0) {
1959 /* The data (middle) region must be immediately after the
1961 if (l2meta_cow_start(m
) + m
->cow_start
.nb_bytes
!= offset
) {
1965 /* The end region must be immediately after the data (middle)
1967 if (m
->offset
+ m
->cow_end
.offset
!= offset
+ bytes
) {
1971 /* Make sure that adding both COW regions to the QEMUIOVector
1972 * does not exceed IOV_MAX */
1973 if (hd_qiov
->niov
> IOV_MAX
- 2) {
1977 m
->data_qiov
= hd_qiov
;
1984 static coroutine_fn
int qcow2_co_pwritev(BlockDriverState
*bs
, uint64_t offset
,
1985 uint64_t bytes
, QEMUIOVector
*qiov
,
1988 BDRVQcow2State
*s
= bs
->opaque
;
1989 int offset_in_cluster
;
1991 unsigned int cur_bytes
; /* number of sectors in current iteration */
1992 uint64_t cluster_offset
;
1993 QEMUIOVector hd_qiov
;
1994 uint64_t bytes_done
= 0;
1995 uint8_t *cluster_data
= NULL
;
1996 QCowL2Meta
*l2meta
= NULL
;
1998 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset
, bytes
);
2000 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
2002 s
->cluster_cache_offset
= -1; /* disable compressed cache */
2004 qemu_co_mutex_lock(&s
->lock
);
2006 while (bytes
!= 0) {
2010 trace_qcow2_writev_start_part(qemu_coroutine_self());
2011 offset_in_cluster
= offset_into_cluster(s
, offset
);
2012 cur_bytes
= MIN(bytes
, INT_MAX
);
2013 if (bs
->encrypted
) {
2014 cur_bytes
= MIN(cur_bytes
,
2015 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
2016 - offset_in_cluster
);
2019 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2020 &cluster_offset
, &l2meta
);
2025 assert((cluster_offset
& 511) == 0);
2027 qemu_iovec_reset(&hd_qiov
);
2028 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
2030 if (bs
->encrypted
) {
2032 if (!cluster_data
) {
2033 cluster_data
= qemu_try_blockalign(bs
->file
->bs
,
2034 QCOW_MAX_CRYPT_CLUSTERS
2036 if (cluster_data
== NULL
) {
2042 assert(hd_qiov
.size
<=
2043 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2044 qemu_iovec_to_buf(&hd_qiov
, 0, cluster_data
, hd_qiov
.size
);
2046 if (qcrypto_block_encrypt(s
->crypto
,
2047 (s
->crypt_physical_offset
?
2048 cluster_offset
+ offset_in_cluster
:
2051 cur_bytes
, NULL
) < 0) {
2056 qemu_iovec_reset(&hd_qiov
);
2057 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
2060 ret
= qcow2_pre_write_overlap_check(bs
, 0,
2061 cluster_offset
+ offset_in_cluster
, cur_bytes
);
2066 /* If we need to do COW, check if it's possible to merge the
2067 * writing of the guest data together with that of the COW regions.
2068 * If it's not possible (or not necessary) then write the
2069 * guest data now. */
2070 if (!merge_cow(offset
, cur_bytes
, &hd_qiov
, l2meta
)) {
2071 qemu_co_mutex_unlock(&s
->lock
);
2072 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
2073 trace_qcow2_writev_data(qemu_coroutine_self(),
2074 cluster_offset
+ offset_in_cluster
);
2075 ret
= bdrv_co_pwritev(bs
->file
,
2076 cluster_offset
+ offset_in_cluster
,
2077 cur_bytes
, &hd_qiov
, 0);
2078 qemu_co_mutex_lock(&s
->lock
);
2084 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
2090 offset
+= cur_bytes
;
2091 bytes_done
+= cur_bytes
;
2092 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes
);
2097 qcow2_handle_l2meta(bs
, &l2meta
, false);
2099 qemu_co_mutex_unlock(&s
->lock
);
2101 qemu_iovec_destroy(&hd_qiov
);
2102 qemu_vfree(cluster_data
);
2103 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
2108 static int qcow2_inactivate(BlockDriverState
*bs
)
2110 BDRVQcow2State
*s
= bs
->opaque
;
2111 int ret
, result
= 0;
2112 Error
*local_err
= NULL
;
2114 qcow2_store_persistent_dirty_bitmaps(bs
, &local_err
);
2115 if (local_err
!= NULL
) {
2117 error_report_err(local_err
);
2118 error_report("Persistent bitmaps are lost for node '%s'",
2119 bdrv_get_device_or_node_name(bs
));
2122 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
2125 error_report("Failed to flush the L2 table cache: %s",
2129 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
2132 error_report("Failed to flush the refcount block cache: %s",
2137 qcow2_mark_clean(bs
);
2143 static void qcow2_close(BlockDriverState
*bs
)
2145 BDRVQcow2State
*s
= bs
->opaque
;
2146 qemu_vfree(s
->l1_table
);
2147 /* else pre-write overlap checks in cache_destroy may crash */
2150 if (!(s
->flags
& BDRV_O_INACTIVE
)) {
2151 qcow2_inactivate(bs
);
2154 cache_clean_timer_del(bs
);
2155 qcow2_cache_destroy(s
->l2_table_cache
);
2156 qcow2_cache_destroy(s
->refcount_block_cache
);
2158 qcrypto_block_free(s
->crypto
);
2161 g_free(s
->unknown_header_fields
);
2162 cleanup_unknown_header_ext(bs
);
2164 g_free(s
->image_backing_file
);
2165 g_free(s
->image_backing_format
);
2167 g_free(s
->cluster_cache
);
2168 qemu_vfree(s
->cluster_data
);
2169 qcow2_refcount_close(bs
);
2170 qcow2_free_snapshots(bs
);
2173 static void coroutine_fn
qcow2_co_invalidate_cache(BlockDriverState
*bs
,
2176 BDRVQcow2State
*s
= bs
->opaque
;
2177 int flags
= s
->flags
;
2178 QCryptoBlock
*crypto
= NULL
;
2180 Error
*local_err
= NULL
;
2184 * Backing files are read-only which makes all of their metadata immutable,
2185 * that means we don't have to worry about reopening them here.
2193 memset(s
, 0, sizeof(BDRVQcow2State
));
2194 options
= qdict_clone_shallow(bs
->options
);
2196 flags
&= ~BDRV_O_INACTIVE
;
2197 qemu_co_mutex_lock(&s
->lock
);
2198 ret
= qcow2_do_open(bs
, options
, flags
, &local_err
);
2199 qemu_co_mutex_unlock(&s
->lock
);
2200 qobject_unref(options
);
2202 error_propagate(errp
, local_err
);
2203 error_prepend(errp
, "Could not reopen qcow2 layer: ");
2206 } else if (ret
< 0) {
2207 error_setg_errno(errp
, -ret
, "Could not reopen qcow2 layer");
2215 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
2216 size_t len
, size_t buflen
)
2218 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
2219 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
2221 if (buflen
< ext_len
) {
2225 *ext_backing_fmt
= (QCowExtension
) {
2226 .magic
= cpu_to_be32(magic
),
2227 .len
= cpu_to_be32(len
),
2231 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
2238 * Updates the qcow2 header, including the variable length parts of it, i.e.
2239 * the backing file name and all extensions. qcow2 was not designed to allow
2240 * such changes, so if we run out of space (we can only use the first cluster)
2241 * this function may fail.
2243 * Returns 0 on success, -errno in error cases.
2245 int qcow2_update_header(BlockDriverState
*bs
)
2247 BDRVQcow2State
*s
= bs
->opaque
;
2250 size_t buflen
= s
->cluster_size
;
2252 uint64_t total_size
;
2253 uint32_t refcount_table_clusters
;
2254 size_t header_length
;
2255 Qcow2UnknownHeaderExtension
*uext
;
2257 buf
= qemu_blockalign(bs
, buflen
);
2259 /* Header structure */
2260 header
= (QCowHeader
*) buf
;
2262 if (buflen
< sizeof(*header
)) {
2267 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
2268 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2269 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
2271 *header
= (QCowHeader
) {
2272 /* Version 2 fields */
2273 .magic
= cpu_to_be32(QCOW_MAGIC
),
2274 .version
= cpu_to_be32(s
->qcow_version
),
2275 .backing_file_offset
= 0,
2276 .backing_file_size
= 0,
2277 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
2278 .size
= cpu_to_be64(total_size
),
2279 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
2280 .l1_size
= cpu_to_be32(s
->l1_size
),
2281 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
2282 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
2283 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
2284 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
2285 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
2287 /* Version 3 fields */
2288 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
2289 .compatible_features
= cpu_to_be64(s
->compatible_features
),
2290 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
2291 .refcount_order
= cpu_to_be32(s
->refcount_order
),
2292 .header_length
= cpu_to_be32(header_length
),
2295 /* For older versions, write a shorter header */
2296 switch (s
->qcow_version
) {
2298 ret
= offsetof(QCowHeader
, incompatible_features
);
2301 ret
= sizeof(*header
);
2310 memset(buf
, 0, buflen
);
2312 /* Preserve any unknown field in the header */
2313 if (s
->unknown_header_fields_size
) {
2314 if (buflen
< s
->unknown_header_fields_size
) {
2319 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
2320 buf
+= s
->unknown_header_fields_size
;
2321 buflen
-= s
->unknown_header_fields_size
;
2324 /* Backing file format header extension */
2325 if (s
->image_backing_format
) {
2326 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
2327 s
->image_backing_format
,
2328 strlen(s
->image_backing_format
),
2338 /* Full disk encryption header pointer extension */
2339 if (s
->crypto_header
.offset
!= 0) {
2340 cpu_to_be64s(&s
->crypto_header
.offset
);
2341 cpu_to_be64s(&s
->crypto_header
.length
);
2342 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_CRYPTO_HEADER
,
2343 &s
->crypto_header
, sizeof(s
->crypto_header
),
2345 be64_to_cpus(&s
->crypto_header
.offset
);
2346 be64_to_cpus(&s
->crypto_header
.length
);
2355 if (s
->qcow_version
>= 3) {
2356 Qcow2Feature features
[] = {
2358 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2359 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
2360 .name
= "dirty bit",
2363 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2364 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
2365 .name
= "corrupt bit",
2368 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
2369 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
2370 .name
= "lazy refcounts",
2374 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
2375 features
, sizeof(features
), buflen
);
2383 /* Bitmap extension */
2384 if (s
->nb_bitmaps
> 0) {
2385 Qcow2BitmapHeaderExt bitmaps_header
= {
2386 .nb_bitmaps
= cpu_to_be32(s
->nb_bitmaps
),
2387 .bitmap_directory_size
=
2388 cpu_to_be64(s
->bitmap_directory_size
),
2389 .bitmap_directory_offset
=
2390 cpu_to_be64(s
->bitmap_directory_offset
)
2392 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BITMAPS
,
2393 &bitmaps_header
, sizeof(bitmaps_header
),
2402 /* Keep unknown header extensions */
2403 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
2404 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
2413 /* End of header extensions */
2414 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
2422 /* Backing file name */
2423 if (s
->image_backing_file
) {
2424 size_t backing_file_len
= strlen(s
->image_backing_file
);
2426 if (buflen
< backing_file_len
) {
2431 /* Using strncpy is ok here, since buf is not NUL-terminated. */
2432 strncpy(buf
, s
->image_backing_file
, buflen
);
2434 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
2435 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
2438 /* Write the new header */
2439 ret
= bdrv_pwrite(bs
->file
, 0, header
, s
->cluster_size
);
2450 static int qcow2_change_backing_file(BlockDriverState
*bs
,
2451 const char *backing_file
, const char *backing_fmt
)
2453 BDRVQcow2State
*s
= bs
->opaque
;
2455 if (backing_file
&& strlen(backing_file
) > 1023) {
2459 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2460 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2462 g_free(s
->image_backing_file
);
2463 g_free(s
->image_backing_format
);
2465 s
->image_backing_file
= backing_file
? g_strdup(bs
->backing_file
) : NULL
;
2466 s
->image_backing_format
= backing_fmt
? g_strdup(bs
->backing_format
) : NULL
;
2468 return qcow2_update_header(bs
);
2471 static int qcow2_crypt_method_from_format(const char *encryptfmt
)
2473 if (g_str_equal(encryptfmt
, "luks")) {
2474 return QCOW_CRYPT_LUKS
;
2475 } else if (g_str_equal(encryptfmt
, "aes")) {
2476 return QCOW_CRYPT_AES
;
2482 static int qcow2_set_up_encryption(BlockDriverState
*bs
,
2483 QCryptoBlockCreateOptions
*cryptoopts
,
2486 BDRVQcow2State
*s
= bs
->opaque
;
2487 QCryptoBlock
*crypto
= NULL
;
2490 switch (cryptoopts
->format
) {
2491 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
2492 fmt
= QCOW_CRYPT_LUKS
;
2494 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
2495 fmt
= QCOW_CRYPT_AES
;
2498 error_setg(errp
, "Crypto format not supported in qcow2");
2502 s
->crypt_method_header
= fmt
;
2504 crypto
= qcrypto_block_create(cryptoopts
, "encrypt.",
2505 qcow2_crypto_hdr_init_func
,
2506 qcow2_crypto_hdr_write_func
,
2512 ret
= qcow2_update_header(bs
);
2514 error_setg_errno(errp
, -ret
, "Could not write encryption header");
2520 qcrypto_block_free(crypto
);
2525 typedef struct PreallocCo
{
2526 BlockDriverState
*bs
;
2528 uint64_t new_length
;
2534 * Preallocates metadata structures for data clusters between @offset (in the
2535 * guest disk) and @new_length (which is thus generally the new guest disk
2538 * Returns: 0 on success, -errno on failure.
2540 static void coroutine_fn
preallocate_co(void *opaque
)
2542 PreallocCo
*params
= opaque
;
2543 BlockDriverState
*bs
= params
->bs
;
2544 uint64_t offset
= params
->offset
;
2545 uint64_t new_length
= params
->new_length
;
2546 BDRVQcow2State
*s
= bs
->opaque
;
2548 uint64_t host_offset
= 0;
2549 unsigned int cur_bytes
;
2553 qemu_co_mutex_lock(&s
->lock
);
2555 assert(offset
<= new_length
);
2556 bytes
= new_length
- offset
;
2559 cur_bytes
= MIN(bytes
, INT_MAX
);
2560 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2561 &host_offset
, &meta
);
2567 QCowL2Meta
*next
= meta
->next
;
2569 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
2571 qcow2_free_any_clusters(bs
, meta
->alloc_offset
,
2572 meta
->nb_clusters
, QCOW2_DISCARD_NEVER
);
2576 /* There are no dependent requests, but we need to remove our
2577 * request from the list of in-flight requests */
2578 QLIST_REMOVE(meta
, next_in_flight
);
2584 /* TODO Preallocate data if requested */
2587 offset
+= cur_bytes
;
2591 * It is expected that the image file is large enough to actually contain
2592 * all of the allocated clusters (otherwise we get failing reads after
2593 * EOF). Extend the image to the last allocated sector.
2595 if (host_offset
!= 0) {
2597 ret
= bdrv_pwrite(bs
->file
, (host_offset
+ cur_bytes
) - 1,
2607 qemu_co_mutex_unlock(&s
->lock
);
2611 static int preallocate(BlockDriverState
*bs
,
2612 uint64_t offset
, uint64_t new_length
)
2614 PreallocCo params
= {
2617 .new_length
= new_length
,
2618 .ret
= -EINPROGRESS
,
2621 if (qemu_in_coroutine()) {
2622 preallocate_co(¶ms
);
2624 Coroutine
*co
= qemu_coroutine_create(preallocate_co
, ¶ms
);
2625 bdrv_coroutine_enter(bs
, co
);
2626 BDRV_POLL_WHILE(bs
, params
.ret
== -EINPROGRESS
);
2631 /* qcow2_refcount_metadata_size:
2632 * @clusters: number of clusters to refcount (including data and L1/L2 tables)
2633 * @cluster_size: size of a cluster, in bytes
2634 * @refcount_order: refcount bits power-of-2 exponent
2635 * @generous_increase: allow for the refcount table to be 1.5x as large as it
2638 * Returns: Number of bytes required for refcount blocks and table metadata.
2640 int64_t qcow2_refcount_metadata_size(int64_t clusters
, size_t cluster_size
,
2641 int refcount_order
, bool generous_increase
,
2642 uint64_t *refblock_count
)
2645 * Every host cluster is reference-counted, including metadata (even
2646 * refcount metadata is recursively included).
2648 * An accurate formula for the size of refcount metadata size is difficult
2649 * to derive. An easier method of calculation is finding the fixed point
2650 * where no further refcount blocks or table clusters are required to
2651 * reference count every cluster.
2653 int64_t blocks_per_table_cluster
= cluster_size
/ sizeof(uint64_t);
2654 int64_t refcounts_per_block
= cluster_size
* 8 / (1 << refcount_order
);
2655 int64_t table
= 0; /* number of refcount table clusters */
2656 int64_t blocks
= 0; /* number of refcount block clusters */
2662 blocks
= DIV_ROUND_UP(clusters
+ table
+ blocks
, refcounts_per_block
);
2663 table
= DIV_ROUND_UP(blocks
, blocks_per_table_cluster
);
2664 n
= clusters
+ blocks
+ table
;
2666 if (n
== last
&& generous_increase
) {
2667 clusters
+= DIV_ROUND_UP(table
, 2);
2668 n
= 0; /* force another loop */
2669 generous_increase
= false;
2671 } while (n
!= last
);
2673 if (refblock_count
) {
2674 *refblock_count
= blocks
;
2677 return (blocks
+ table
) * cluster_size
;
2681 * qcow2_calc_prealloc_size:
2682 * @total_size: virtual disk size in bytes
2683 * @cluster_size: cluster size in bytes
2684 * @refcount_order: refcount bits power-of-2 exponent
2686 * Returns: Total number of bytes required for the fully allocated image
2687 * (including metadata).
2689 static int64_t qcow2_calc_prealloc_size(int64_t total_size
,
2690 size_t cluster_size
,
2693 int64_t meta_size
= 0;
2694 uint64_t nl1e
, nl2e
;
2695 int64_t aligned_total_size
= ROUND_UP(total_size
, cluster_size
);
2697 /* header: 1 cluster */
2698 meta_size
+= cluster_size
;
2700 /* total size of L2 tables */
2701 nl2e
= aligned_total_size
/ cluster_size
;
2702 nl2e
= ROUND_UP(nl2e
, cluster_size
/ sizeof(uint64_t));
2703 meta_size
+= nl2e
* sizeof(uint64_t);
2705 /* total size of L1 tables */
2706 nl1e
= nl2e
* sizeof(uint64_t) / cluster_size
;
2707 nl1e
= ROUND_UP(nl1e
, cluster_size
/ sizeof(uint64_t));
2708 meta_size
+= nl1e
* sizeof(uint64_t);
2710 /* total size of refcount table and blocks */
2711 meta_size
+= qcow2_refcount_metadata_size(
2712 (meta_size
+ aligned_total_size
) / cluster_size
,
2713 cluster_size
, refcount_order
, false, NULL
);
2715 return meta_size
+ aligned_total_size
;
2718 static bool validate_cluster_size(size_t cluster_size
, Error
**errp
)
2720 int cluster_bits
= ctz32(cluster_size
);
2721 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
2722 (1 << cluster_bits
) != cluster_size
)
2724 error_setg(errp
, "Cluster size must be a power of two between %d and "
2725 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
2731 static size_t qcow2_opt_get_cluster_size_del(QemuOpts
*opts
, Error
**errp
)
2733 size_t cluster_size
;
2735 cluster_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
2736 DEFAULT_CLUSTER_SIZE
);
2737 if (!validate_cluster_size(cluster_size
, errp
)) {
2740 return cluster_size
;
2743 static int qcow2_opt_get_version_del(QemuOpts
*opts
, Error
**errp
)
2748 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_COMPAT_LEVEL
);
2750 ret
= 3; /* default */
2751 } else if (!strcmp(buf
, "0.10")) {
2753 } else if (!strcmp(buf
, "1.1")) {
2756 error_setg(errp
, "Invalid compatibility level: '%s'", buf
);
2763 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts
*opts
, int version
,
2766 uint64_t refcount_bits
;
2768 refcount_bits
= qemu_opt_get_number_del(opts
, BLOCK_OPT_REFCOUNT_BITS
, 16);
2769 if (refcount_bits
> 64 || !is_power_of_2(refcount_bits
)) {
2770 error_setg(errp
, "Refcount width must be a power of two and may not "
2775 if (version
< 3 && refcount_bits
!= 16) {
2776 error_setg(errp
, "Different refcount widths than 16 bits require "
2777 "compatibility level 1.1 or above (use compat=1.1 or "
2782 return refcount_bits
;
2785 static int coroutine_fn
2786 qcow2_co_create(BlockdevCreateOptions
*create_options
, Error
**errp
)
2788 BlockdevCreateOptionsQcow2
*qcow2_opts
;
2792 * Open the image file and write a minimal qcow2 header.
2794 * We keep things simple and start with a zero-sized image. We also
2795 * do without refcount blocks or a L1 table for now. We'll fix the
2796 * inconsistency later.
2798 * We do need a refcount table because growing the refcount table means
2799 * allocating two new refcount blocks - the seconds of which would be at
2800 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
2801 * size for any qcow2 image.
2803 BlockBackend
*blk
= NULL
;
2804 BlockDriverState
*bs
= NULL
;
2806 size_t cluster_size
;
2809 uint64_t* refcount_table
;
2810 Error
*local_err
= NULL
;
2813 assert(create_options
->driver
== BLOCKDEV_DRIVER_QCOW2
);
2814 qcow2_opts
= &create_options
->u
.qcow2
;
2816 bs
= bdrv_open_blockdev_ref(qcow2_opts
->file
, errp
);
2821 /* Validate options and set default values */
2822 if (!QEMU_IS_ALIGNED(qcow2_opts
->size
, BDRV_SECTOR_SIZE
)) {
2823 error_setg(errp
, "Image size must be a multiple of 512 bytes");
2828 if (qcow2_opts
->has_version
) {
2829 switch (qcow2_opts
->version
) {
2830 case BLOCKDEV_QCOW2_VERSION_V2
:
2833 case BLOCKDEV_QCOW2_VERSION_V3
:
2837 g_assert_not_reached();
2843 if (qcow2_opts
->has_cluster_size
) {
2844 cluster_size
= qcow2_opts
->cluster_size
;
2846 cluster_size
= DEFAULT_CLUSTER_SIZE
;
2849 if (!validate_cluster_size(cluster_size
, errp
)) {
2854 if (!qcow2_opts
->has_preallocation
) {
2855 qcow2_opts
->preallocation
= PREALLOC_MODE_OFF
;
2857 if (qcow2_opts
->has_backing_file
&&
2858 qcow2_opts
->preallocation
!= PREALLOC_MODE_OFF
)
2860 error_setg(errp
, "Backing file and preallocation cannot be used at "
2865 if (qcow2_opts
->has_backing_fmt
&& !qcow2_opts
->has_backing_file
) {
2866 error_setg(errp
, "Backing format cannot be used without backing file");
2871 if (!qcow2_opts
->has_lazy_refcounts
) {
2872 qcow2_opts
->lazy_refcounts
= false;
2874 if (version
< 3 && qcow2_opts
->lazy_refcounts
) {
2875 error_setg(errp
, "Lazy refcounts only supported with compatibility "
2876 "level 1.1 and above (use version=v3 or greater)");
2881 if (!qcow2_opts
->has_refcount_bits
) {
2882 qcow2_opts
->refcount_bits
= 16;
2884 if (qcow2_opts
->refcount_bits
> 64 ||
2885 !is_power_of_2(qcow2_opts
->refcount_bits
))
2887 error_setg(errp
, "Refcount width must be a power of two and may not "
2892 if (version
< 3 && qcow2_opts
->refcount_bits
!= 16) {
2893 error_setg(errp
, "Different refcount widths than 16 bits require "
2894 "compatibility level 1.1 or above (use version=v3 or "
2899 refcount_order
= ctz32(qcow2_opts
->refcount_bits
);
2902 /* Create BlockBackend to write to the image */
2903 blk
= blk_new(BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
);
2904 ret
= blk_insert_bs(blk
, bs
, errp
);
2908 blk_set_allow_write_beyond_eof(blk
, true);
2910 /* Clear the protocol layer and preallocate it if necessary */
2911 ret
= blk_truncate(blk
, 0, PREALLOC_MODE_OFF
, errp
);
2916 if (qcow2_opts
->preallocation
== PREALLOC_MODE_FULL
||
2917 qcow2_opts
->preallocation
== PREALLOC_MODE_FALLOC
)
2919 int64_t prealloc_size
=
2920 qcow2_calc_prealloc_size(qcow2_opts
->size
, cluster_size
,
2923 ret
= blk_truncate(blk
, prealloc_size
, qcow2_opts
->preallocation
, errp
);
2929 /* Write the header */
2930 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS
) < sizeof(*header
));
2931 header
= g_malloc0(cluster_size
);
2932 *header
= (QCowHeader
) {
2933 .magic
= cpu_to_be32(QCOW_MAGIC
),
2934 .version
= cpu_to_be32(version
),
2935 .cluster_bits
= cpu_to_be32(ctz32(cluster_size
)),
2936 .size
= cpu_to_be64(0),
2937 .l1_table_offset
= cpu_to_be64(0),
2938 .l1_size
= cpu_to_be32(0),
2939 .refcount_table_offset
= cpu_to_be64(cluster_size
),
2940 .refcount_table_clusters
= cpu_to_be32(1),
2941 .refcount_order
= cpu_to_be32(refcount_order
),
2942 .header_length
= cpu_to_be32(sizeof(*header
)),
2945 /* We'll update this to correct value later */
2946 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
2948 if (qcow2_opts
->lazy_refcounts
) {
2949 header
->compatible_features
|=
2950 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
2953 ret
= blk_pwrite(blk
, 0, header
, cluster_size
, 0);
2956 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
2960 /* Write a refcount table with one refcount block */
2961 refcount_table
= g_malloc0(2 * cluster_size
);
2962 refcount_table
[0] = cpu_to_be64(2 * cluster_size
);
2963 ret
= blk_pwrite(blk
, cluster_size
, refcount_table
, 2 * cluster_size
, 0);
2964 g_free(refcount_table
);
2967 error_setg_errno(errp
, -ret
, "Could not write refcount table");
2975 * And now open the image and make it consistent first (i.e. increase the
2976 * refcount of the cluster that is occupied by the header and the refcount
2979 options
= qdict_new();
2980 qdict_put_str(options
, "driver", "qcow2");
2981 qdict_put_str(options
, "file", bs
->node_name
);
2982 blk
= blk_new_open(NULL
, NULL
, options
,
2983 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_NO_FLUSH
,
2986 error_propagate(errp
, local_err
);
2991 ret
= qcow2_alloc_clusters(blk_bs(blk
), 3 * cluster_size
);
2993 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
2994 "header and refcount table");
2997 } else if (ret
!= 0) {
2998 error_report("Huh, first cluster in empty image is already in use?");
3002 /* Create a full header (including things like feature table) */
3003 ret
= qcow2_update_header(blk_bs(blk
));
3005 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
3009 /* Okay, now that we have a valid image, let's give it the right size */
3010 ret
= blk_truncate(blk
, qcow2_opts
->size
, PREALLOC_MODE_OFF
, errp
);
3012 error_prepend(errp
, "Could not resize image: ");
3016 /* Want a backing file? There you go.*/
3017 if (qcow2_opts
->has_backing_file
) {
3018 const char *backing_format
= NULL
;
3020 if (qcow2_opts
->has_backing_fmt
) {
3021 backing_format
= BlockdevDriver_str(qcow2_opts
->backing_fmt
);
3024 ret
= bdrv_change_backing_file(blk_bs(blk
), qcow2_opts
->backing_file
,
3027 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
3028 "with format '%s'", qcow2_opts
->backing_file
,
3034 /* Want encryption? There you go. */
3035 if (qcow2_opts
->has_encrypt
) {
3036 ret
= qcow2_set_up_encryption(blk_bs(blk
), qcow2_opts
->encrypt
, errp
);
3042 /* And if we're supposed to preallocate metadata, do that now */
3043 if (qcow2_opts
->preallocation
!= PREALLOC_MODE_OFF
) {
3044 ret
= preallocate(blk_bs(blk
), 0, qcow2_opts
->size
);
3046 error_setg_errno(errp
, -ret
, "Could not preallocate metadata");
3054 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
3055 * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
3056 * have to setup decryption context. We're not doing any I/O on the top
3057 * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
3060 options
= qdict_new();
3061 qdict_put_str(options
, "driver", "qcow2");
3062 qdict_put_str(options
, "file", bs
->node_name
);
3063 blk
= blk_new_open(NULL
, NULL
, options
,
3064 BDRV_O_RDWR
| BDRV_O_NO_BACKING
| BDRV_O_NO_IO
,
3067 error_propagate(errp
, local_err
);
3079 static int coroutine_fn
qcow2_co_create_opts(const char *filename
, QemuOpts
*opts
,
3082 BlockdevCreateOptions
*create_options
= NULL
;
3085 BlockDriverState
*bs
= NULL
;
3086 Error
*local_err
= NULL
;
3090 /* Only the keyval visitor supports the dotted syntax needed for
3091 * encryption, so go through a QDict before getting a QAPI type. Ignore
3092 * options meant for the protocol layer so that the visitor doesn't
3094 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, bdrv_qcow2
.create_opts
,
3097 /* Handle encryption options */
3098 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT
);
3099 if (val
&& !strcmp(val
, "on")) {
3100 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT
, "qcow");
3101 } else if (val
&& !strcmp(val
, "off")) {
3102 qdict_del(qdict
, BLOCK_OPT_ENCRYPT
);
3105 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
);
3106 if (val
&& !strcmp(val
, "aes")) {
3107 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
, "qcow");
3110 /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into
3111 * version=v2/v3 below. */
3112 val
= qdict_get_try_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
);
3113 if (val
&& !strcmp(val
, "0.10")) {
3114 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v2");
3115 } else if (val
&& !strcmp(val
, "1.1")) {
3116 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v3");
3119 /* Change legacy command line options into QMP ones */
3120 static const QDictRenames opt_renames
[] = {
3121 { BLOCK_OPT_BACKING_FILE
, "backing-file" },
3122 { BLOCK_OPT_BACKING_FMT
, "backing-fmt" },
3123 { BLOCK_OPT_CLUSTER_SIZE
, "cluster-size" },
3124 { BLOCK_OPT_LAZY_REFCOUNTS
, "lazy-refcounts" },
3125 { BLOCK_OPT_REFCOUNT_BITS
, "refcount-bits" },
3126 { BLOCK_OPT_ENCRYPT
, BLOCK_OPT_ENCRYPT_FORMAT
},
3127 { BLOCK_OPT_COMPAT_LEVEL
, "version" },
3131 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
3136 /* Create and open the file (protocol layer) */
3137 ret
= bdrv_create_file(filename
, opts
, errp
);
3142 bs
= bdrv_open(filename
, NULL
, NULL
,
3143 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
3149 /* Set 'driver' and 'node' options */
3150 qdict_put_str(qdict
, "driver", "qcow2");
3151 qdict_put_str(qdict
, "file", bs
->node_name
);
3153 /* Now get the QAPI type BlockdevCreateOptions */
3154 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
3160 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, &local_err
);
3164 error_propagate(errp
, local_err
);
3169 /* Silently round up size */
3170 create_options
->u
.qcow2
.size
= ROUND_UP(create_options
->u
.qcow2
.size
,
3173 /* Create the qcow2 image (format layer) */
3174 ret
= qcow2_co_create(create_options
, errp
);
3181 qobject_unref(qdict
);
3183 qapi_free_BlockdevCreateOptions(create_options
);
3188 static bool is_zero(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
3193 /* Clamp to image length, before checking status of underlying sectors */
3194 if (offset
+ bytes
> bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3195 bytes
= bs
->total_sectors
* BDRV_SECTOR_SIZE
- offset
;
3201 res
= bdrv_block_status_above(bs
, NULL
, offset
, bytes
, &nr
, NULL
, NULL
);
3202 return res
>= 0 && (res
& BDRV_BLOCK_ZERO
) && nr
== bytes
;
3205 static coroutine_fn
int qcow2_co_pwrite_zeroes(BlockDriverState
*bs
,
3206 int64_t offset
, int bytes
, BdrvRequestFlags flags
)
3209 BDRVQcow2State
*s
= bs
->opaque
;
3211 uint32_t head
= offset
% s
->cluster_size
;
3212 uint32_t tail
= (offset
+ bytes
) % s
->cluster_size
;
3214 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset
, bytes
);
3215 if (offset
+ bytes
== bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3223 assert(head
+ bytes
<= s
->cluster_size
);
3225 /* check whether remainder of cluster already reads as zero */
3226 if (!(is_zero(bs
, offset
- head
, head
) &&
3227 is_zero(bs
, offset
+ bytes
,
3228 tail
? s
->cluster_size
- tail
: 0))) {
3232 qemu_co_mutex_lock(&s
->lock
);
3233 /* We can have new write after previous check */
3234 offset
= QEMU_ALIGN_DOWN(offset
, s
->cluster_size
);
3235 bytes
= s
->cluster_size
;
3236 nr
= s
->cluster_size
;
3237 ret
= qcow2_get_cluster_offset(bs
, offset
, &nr
, &off
);
3238 if (ret
!= QCOW2_CLUSTER_UNALLOCATED
&&
3239 ret
!= QCOW2_CLUSTER_ZERO_PLAIN
&&
3240 ret
!= QCOW2_CLUSTER_ZERO_ALLOC
) {
3241 qemu_co_mutex_unlock(&s
->lock
);
3245 qemu_co_mutex_lock(&s
->lock
);
3248 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset
, bytes
);
3250 /* Whatever is left can use real zero clusters */
3251 ret
= qcow2_cluster_zeroize(bs
, offset
, bytes
, flags
);
3252 qemu_co_mutex_unlock(&s
->lock
);
3257 static coroutine_fn
int qcow2_co_pdiscard(BlockDriverState
*bs
,
3258 int64_t offset
, int bytes
)
3261 BDRVQcow2State
*s
= bs
->opaque
;
3263 if (!QEMU_IS_ALIGNED(offset
| bytes
, s
->cluster_size
)) {
3264 assert(bytes
< s
->cluster_size
);
3265 /* Ignore partial clusters, except for the special case of the
3266 * complete partial cluster at the end of an unaligned file */
3267 if (!QEMU_IS_ALIGNED(offset
, s
->cluster_size
) ||
3268 offset
+ bytes
!= bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3273 qemu_co_mutex_lock(&s
->lock
);
3274 ret
= qcow2_cluster_discard(bs
, offset
, bytes
, QCOW2_DISCARD_REQUEST
,
3276 qemu_co_mutex_unlock(&s
->lock
);
3280 static int coroutine_fn
3281 qcow2_co_copy_range_from(BlockDriverState
*bs
,
3282 BdrvChild
*src
, uint64_t src_offset
,
3283 BdrvChild
*dst
, uint64_t dst_offset
,
3284 uint64_t bytes
, BdrvRequestFlags flags
)
3286 BDRVQcow2State
*s
= bs
->opaque
;
3288 unsigned int cur_bytes
; /* number of bytes in current iteration */
3289 BdrvChild
*child
= NULL
;
3290 BdrvRequestFlags cur_flags
;
3292 assert(!bs
->encrypted
);
3293 qemu_co_mutex_lock(&s
->lock
);
3295 while (bytes
!= 0) {
3296 uint64_t copy_offset
= 0;
3297 /* prepare next request */
3298 cur_bytes
= MIN(bytes
, INT_MAX
);
3301 ret
= qcow2_get_cluster_offset(bs
, src_offset
, &cur_bytes
, ©_offset
);
3307 case QCOW2_CLUSTER_UNALLOCATED
:
3308 if (bs
->backing
&& bs
->backing
->bs
) {
3309 int64_t backing_length
= bdrv_getlength(bs
->backing
->bs
);
3310 if (src_offset
>= backing_length
) {
3311 cur_flags
|= BDRV_REQ_ZERO_WRITE
;
3313 child
= bs
->backing
;
3314 cur_bytes
= MIN(cur_bytes
, backing_length
- src_offset
);
3315 copy_offset
= src_offset
;
3318 cur_flags
|= BDRV_REQ_ZERO_WRITE
;
3322 case QCOW2_CLUSTER_ZERO_PLAIN
:
3323 case QCOW2_CLUSTER_ZERO_ALLOC
:
3324 cur_flags
|= BDRV_REQ_ZERO_WRITE
;
3327 case QCOW2_CLUSTER_COMPRESSED
:
3332 case QCOW2_CLUSTER_NORMAL
:
3334 copy_offset
+= offset_into_cluster(s
, src_offset
);
3335 if ((copy_offset
& 511) != 0) {
3344 qemu_co_mutex_unlock(&s
->lock
);
3345 ret
= bdrv_co_copy_range_from(child
,
3348 cur_bytes
, cur_flags
);
3349 qemu_co_mutex_lock(&s
->lock
);
3355 src_offset
+= cur_bytes
;
3356 dst_offset
+= cur_bytes
;
3361 qemu_co_mutex_unlock(&s
->lock
);
3365 static int coroutine_fn
3366 qcow2_co_copy_range_to(BlockDriverState
*bs
,
3367 BdrvChild
*src
, uint64_t src_offset
,
3368 BdrvChild
*dst
, uint64_t dst_offset
,
3369 uint64_t bytes
, BdrvRequestFlags flags
)
3371 BDRVQcow2State
*s
= bs
->opaque
;
3372 int offset_in_cluster
;
3374 unsigned int cur_bytes
; /* number of sectors in current iteration */
3375 uint64_t cluster_offset
;
3376 uint8_t *cluster_data
= NULL
;
3377 QCowL2Meta
*l2meta
= NULL
;
3379 assert(!bs
->encrypted
);
3380 s
->cluster_cache_offset
= -1; /* disable compressed cache */
3382 qemu_co_mutex_lock(&s
->lock
);
3384 while (bytes
!= 0) {
3388 offset_in_cluster
= offset_into_cluster(s
, dst_offset
);
3389 cur_bytes
= MIN(bytes
, INT_MAX
);
3392 * If src->bs == dst->bs, we could simply copy by incrementing
3393 * the refcnt, without copying user data.
3394 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
3395 ret
= qcow2_alloc_cluster_offset(bs
, dst_offset
, &cur_bytes
,
3396 &cluster_offset
, &l2meta
);
3401 assert((cluster_offset
& 511) == 0);
3403 ret
= qcow2_pre_write_overlap_check(bs
, 0,
3404 cluster_offset
+ offset_in_cluster
, cur_bytes
);
3409 qemu_co_mutex_unlock(&s
->lock
);
3410 ret
= bdrv_co_copy_range_to(src
, src_offset
,
3412 cluster_offset
+ offset_in_cluster
,
3414 qemu_co_mutex_lock(&s
->lock
);
3419 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
3425 dst_offset
+= cur_bytes
;
3430 qcow2_handle_l2meta(bs
, &l2meta
, false);
3432 qemu_co_mutex_unlock(&s
->lock
);
3434 qemu_vfree(cluster_data
);
3435 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
3440 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
,
3441 PreallocMode prealloc
, Error
**errp
)
3443 BDRVQcow2State
*s
= bs
->opaque
;
3444 uint64_t old_length
;
3445 int64_t new_l1_size
;
3448 if (prealloc
!= PREALLOC_MODE_OFF
&& prealloc
!= PREALLOC_MODE_METADATA
&&
3449 prealloc
!= PREALLOC_MODE_FALLOC
&& prealloc
!= PREALLOC_MODE_FULL
)
3451 error_setg(errp
, "Unsupported preallocation mode '%s'",
3452 PreallocMode_str(prealloc
));
3457 error_setg(errp
, "The new size must be a multiple of 512");
3461 /* cannot proceed if image has snapshots */
3462 if (s
->nb_snapshots
) {
3463 error_setg(errp
, "Can't resize an image which has snapshots");
3467 /* cannot proceed if image has bitmaps */
3468 if (s
->nb_bitmaps
) {
3469 /* TODO: resize bitmaps in the image */
3470 error_setg(errp
, "Can't resize an image which has bitmaps");
3474 old_length
= bs
->total_sectors
* 512;
3475 new_l1_size
= size_to_l1(s
, offset
);
3477 if (offset
< old_length
) {
3478 int64_t last_cluster
, old_file_size
;
3479 if (prealloc
!= PREALLOC_MODE_OFF
) {
3481 "Preallocation can't be used for shrinking an image");
3485 ret
= qcow2_cluster_discard(bs
, ROUND_UP(offset
, s
->cluster_size
),
3486 old_length
- ROUND_UP(offset
,
3488 QCOW2_DISCARD_ALWAYS
, true);
3490 error_setg_errno(errp
, -ret
, "Failed to discard cropped clusters");
3494 ret
= qcow2_shrink_l1_table(bs
, new_l1_size
);
3496 error_setg_errno(errp
, -ret
,
3497 "Failed to reduce the number of L2 tables");
3501 ret
= qcow2_shrink_reftable(bs
);
3503 error_setg_errno(errp
, -ret
,
3504 "Failed to discard unused refblocks");
3508 old_file_size
= bdrv_getlength(bs
->file
->bs
);
3509 if (old_file_size
< 0) {
3510 error_setg_errno(errp
, -old_file_size
,
3511 "Failed to inquire current file length");
3512 return old_file_size
;
3514 last_cluster
= qcow2_get_last_cluster(bs
, old_file_size
);
3515 if (last_cluster
< 0) {
3516 error_setg_errno(errp
, -last_cluster
,
3517 "Failed to find the last cluster");
3518 return last_cluster
;
3520 if ((last_cluster
+ 1) * s
->cluster_size
< old_file_size
) {
3521 Error
*local_err
= NULL
;
3523 bdrv_truncate(bs
->file
, (last_cluster
+ 1) * s
->cluster_size
,
3524 PREALLOC_MODE_OFF
, &local_err
);
3526 warn_reportf_err(local_err
,
3527 "Failed to truncate the tail of the image: ");
3531 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
3533 error_setg_errno(errp
, -ret
, "Failed to grow the L1 table");
3539 case PREALLOC_MODE_OFF
:
3542 case PREALLOC_MODE_METADATA
:
3543 ret
= preallocate(bs
, old_length
, offset
);
3545 error_setg_errno(errp
, -ret
, "Preallocation failed");
3550 case PREALLOC_MODE_FALLOC
:
3551 case PREALLOC_MODE_FULL
:
3553 int64_t allocation_start
, host_offset
, guest_offset
;
3554 int64_t clusters_allocated
;
3555 int64_t old_file_size
, new_file_size
;
3556 uint64_t nb_new_data_clusters
, nb_new_l2_tables
;
3558 old_file_size
= bdrv_getlength(bs
->file
->bs
);
3559 if (old_file_size
< 0) {
3560 error_setg_errno(errp
, -old_file_size
,
3561 "Failed to inquire current file length");
3562 return old_file_size
;
3564 old_file_size
= ROUND_UP(old_file_size
, s
->cluster_size
);
3566 nb_new_data_clusters
= DIV_ROUND_UP(offset
- old_length
,
3569 /* This is an overestimation; we will not actually allocate space for
3570 * these in the file but just make sure the new refcount structures are
3571 * able to cover them so we will not have to allocate new refblocks
3572 * while entering the data blocks in the potentially new L2 tables.
3573 * (We do not actually care where the L2 tables are placed. Maybe they
3574 * are already allocated or they can be placed somewhere before
3575 * @old_file_size. It does not matter because they will be fully
3576 * allocated automatically, so they do not need to be covered by the
3577 * preallocation. All that matters is that we will not have to allocate
3578 * new refcount structures for them.) */
3579 nb_new_l2_tables
= DIV_ROUND_UP(nb_new_data_clusters
,
3580 s
->cluster_size
/ sizeof(uint64_t));
3581 /* The cluster range may not be aligned to L2 boundaries, so add one L2
3582 * table for a potential head/tail */
3585 allocation_start
= qcow2_refcount_area(bs
, old_file_size
,
3586 nb_new_data_clusters
+
3589 if (allocation_start
< 0) {
3590 error_setg_errno(errp
, -allocation_start
,
3591 "Failed to resize refcount structures");
3592 return allocation_start
;
3595 clusters_allocated
= qcow2_alloc_clusters_at(bs
, allocation_start
,
3596 nb_new_data_clusters
);
3597 if (clusters_allocated
< 0) {
3598 error_setg_errno(errp
, -clusters_allocated
,
3599 "Failed to allocate data clusters");
3600 return -clusters_allocated
;
3603 assert(clusters_allocated
== nb_new_data_clusters
);
3605 /* Allocate the data area */
3606 new_file_size
= allocation_start
+
3607 nb_new_data_clusters
* s
->cluster_size
;
3608 ret
= bdrv_truncate(bs
->file
, new_file_size
, prealloc
, errp
);
3610 error_prepend(errp
, "Failed to resize underlying file: ");
3611 qcow2_free_clusters(bs
, allocation_start
,
3612 nb_new_data_clusters
* s
->cluster_size
,
3613 QCOW2_DISCARD_OTHER
);
3617 /* Create the necessary L2 entries */
3618 host_offset
= allocation_start
;
3619 guest_offset
= old_length
;
3620 while (nb_new_data_clusters
) {
3621 int64_t nb_clusters
= MIN(
3622 nb_new_data_clusters
,
3623 s
->l2_slice_size
- offset_to_l2_slice_index(s
, guest_offset
));
3624 QCowL2Meta allocation
= {
3625 .offset
= guest_offset
,
3626 .alloc_offset
= host_offset
,
3627 .nb_clusters
= nb_clusters
,
3629 qemu_co_queue_init(&allocation
.dependent_requests
);
3631 ret
= qcow2_alloc_cluster_link_l2(bs
, &allocation
);
3633 error_setg_errno(errp
, -ret
, "Failed to update L2 tables");
3634 qcow2_free_clusters(bs
, host_offset
,
3635 nb_new_data_clusters
* s
->cluster_size
,
3636 QCOW2_DISCARD_OTHER
);
3640 guest_offset
+= nb_clusters
* s
->cluster_size
;
3641 host_offset
+= nb_clusters
* s
->cluster_size
;
3642 nb_new_data_clusters
-= nb_clusters
;
3648 g_assert_not_reached();
3651 if (prealloc
!= PREALLOC_MODE_OFF
) {
3652 /* Flush metadata before actually changing the image size */
3653 ret
= bdrv_flush(bs
);
3655 error_setg_errno(errp
, -ret
,
3656 "Failed to flush the preallocated area to disk");
3661 /* write updated header.size */
3662 offset
= cpu_to_be64(offset
);
3663 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
3664 &offset
, sizeof(uint64_t));
3666 error_setg_errno(errp
, -ret
, "Failed to update the image size");
3670 s
->l1_vm_state_index
= new_l1_size
;
3674 /* XXX: put compressed sectors first, then all the cluster aligned
3675 tables to avoid losing bytes in alignment */
3676 static coroutine_fn
int
3677 qcow2_co_pwritev_compressed(BlockDriverState
*bs
, uint64_t offset
,
3678 uint64_t bytes
, QEMUIOVector
*qiov
)
3680 BDRVQcow2State
*s
= bs
->opaque
;
3681 QEMUIOVector hd_qiov
;
3685 uint8_t *buf
, *out_buf
;
3686 int64_t cluster_offset
;
3689 /* align end of file to a sector boundary to ease reading with
3690 sector based I/Os */
3691 cluster_offset
= bdrv_getlength(bs
->file
->bs
);
3692 if (cluster_offset
< 0) {
3693 return cluster_offset
;
3695 return bdrv_truncate(bs
->file
, cluster_offset
, PREALLOC_MODE_OFF
, NULL
);
3698 if (offset_into_cluster(s
, offset
)) {
3702 buf
= qemu_blockalign(bs
, s
->cluster_size
);
3703 if (bytes
!= s
->cluster_size
) {
3704 if (bytes
> s
->cluster_size
||
3705 offset
+ bytes
!= bs
->total_sectors
<< BDRV_SECTOR_BITS
)
3710 /* Zero-pad last write if image size is not cluster aligned */
3711 memset(buf
+ bytes
, 0, s
->cluster_size
- bytes
);
3713 qemu_iovec_to_buf(qiov
, 0, buf
, bytes
);
3715 out_buf
= g_malloc(s
->cluster_size
);
3717 /* best compression, small window, no zlib header */
3718 memset(&strm
, 0, sizeof(strm
));
3719 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
3721 9, Z_DEFAULT_STRATEGY
);
3727 strm
.avail_in
= s
->cluster_size
;
3728 strm
.next_in
= (uint8_t *)buf
;
3729 strm
.avail_out
= s
->cluster_size
;
3730 strm
.next_out
= out_buf
;
3732 ret
= deflate(&strm
, Z_FINISH
);
3733 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
3738 out_len
= strm
.next_out
- out_buf
;
3742 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
3743 /* could not compress: write normal cluster */
3744 ret
= qcow2_co_pwritev(bs
, offset
, bytes
, qiov
, 0);
3751 qemu_co_mutex_lock(&s
->lock
);
3753 qcow2_alloc_compressed_cluster_offset(bs
, offset
, out_len
);
3754 if (!cluster_offset
) {
3755 qemu_co_mutex_unlock(&s
->lock
);
3759 cluster_offset
&= s
->cluster_offset_mask
;
3761 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
);
3762 qemu_co_mutex_unlock(&s
->lock
);
3767 iov
= (struct iovec
) {
3768 .iov_base
= out_buf
,
3771 qemu_iovec_init_external(&hd_qiov
, &iov
, 1);
3773 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
3774 ret
= bdrv_co_pwritev(bs
->file
, cluster_offset
, out_len
, &hd_qiov
, 0);
3786 static int make_completely_empty(BlockDriverState
*bs
)
3788 BDRVQcow2State
*s
= bs
->opaque
;
3789 Error
*local_err
= NULL
;
3790 int ret
, l1_clusters
;
3792 uint64_t *new_reftable
= NULL
;
3793 uint64_t rt_entry
, l1_size2
;
3796 uint64_t reftable_offset
;
3797 uint32_t reftable_clusters
;
3798 } QEMU_PACKED l1_ofs_rt_ofs_cls
;
3800 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
3805 ret
= qcow2_cache_empty(bs
, s
->refcount_block_cache
);
3810 /* Refcounts will be broken utterly */
3811 ret
= qcow2_mark_dirty(bs
);
3816 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
3818 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
3819 l1_size2
= (uint64_t)s
->l1_size
* sizeof(uint64_t);
3821 /* After this call, neither the in-memory nor the on-disk refcount
3822 * information accurately describe the actual references */
3824 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->l1_table_offset
,
3825 l1_clusters
* s
->cluster_size
, 0);
3827 goto fail_broken_refcounts
;
3829 memset(s
->l1_table
, 0, l1_size2
);
3831 BLKDBG_EVENT(bs
->file
, BLKDBG_EMPTY_IMAGE_PREPARE
);
3833 /* Overwrite enough clusters at the beginning of the sectors to place
3834 * the refcount table, a refcount block and the L1 table in; this may
3835 * overwrite parts of the existing refcount and L1 table, which is not
3836 * an issue because the dirty flag is set, complete data loss is in fact
3837 * desired and partial data loss is consequently fine as well */
3838 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->cluster_size
,
3839 (2 + l1_clusters
) * s
->cluster_size
, 0);
3840 /* This call (even if it failed overall) may have overwritten on-disk
3841 * refcount structures; in that case, the in-memory refcount information
3842 * will probably differ from the on-disk information which makes the BDS
3845 goto fail_broken_refcounts
;
3848 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
3849 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_UPDATE
);
3851 /* "Create" an empty reftable (one cluster) directly after the image
3852 * header and an empty L1 table three clusters after the image header;
3853 * the cluster between those two will be used as the first refblock */
3854 l1_ofs_rt_ofs_cls
.l1_offset
= cpu_to_be64(3 * s
->cluster_size
);
3855 l1_ofs_rt_ofs_cls
.reftable_offset
= cpu_to_be64(s
->cluster_size
);
3856 l1_ofs_rt_ofs_cls
.reftable_clusters
= cpu_to_be32(1);
3857 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, l1_table_offset
),
3858 &l1_ofs_rt_ofs_cls
, sizeof(l1_ofs_rt_ofs_cls
));
3860 goto fail_broken_refcounts
;
3863 s
->l1_table_offset
= 3 * s
->cluster_size
;
3865 new_reftable
= g_try_new0(uint64_t, s
->cluster_size
/ sizeof(uint64_t));
3866 if (!new_reftable
) {
3868 goto fail_broken_refcounts
;
3871 s
->refcount_table_offset
= s
->cluster_size
;
3872 s
->refcount_table_size
= s
->cluster_size
/ sizeof(uint64_t);
3873 s
->max_refcount_table_index
= 0;
3875 g_free(s
->refcount_table
);
3876 s
->refcount_table
= new_reftable
;
3877 new_reftable
= NULL
;
3879 /* Now the in-memory refcount information again corresponds to the on-disk
3880 * information (reftable is empty and no refblocks (the refblock cache is
3881 * empty)); however, this means some clusters (e.g. the image header) are
3882 * referenced, but not refcounted, but the normal qcow2 code assumes that
3883 * the in-memory information is always correct */
3885 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
3887 /* Enter the first refblock into the reftable */
3888 rt_entry
= cpu_to_be64(2 * s
->cluster_size
);
3889 ret
= bdrv_pwrite_sync(bs
->file
, s
->cluster_size
,
3890 &rt_entry
, sizeof(rt_entry
));
3892 goto fail_broken_refcounts
;
3894 s
->refcount_table
[0] = 2 * s
->cluster_size
;
3896 s
->free_cluster_index
= 0;
3897 assert(3 + l1_clusters
<= s
->refcount_block_size
);
3898 offset
= qcow2_alloc_clusters(bs
, 3 * s
->cluster_size
+ l1_size2
);
3901 goto fail_broken_refcounts
;
3902 } else if (offset
> 0) {
3903 error_report("First cluster in emptied image is in use");
3907 /* Now finally the in-memory information corresponds to the on-disk
3908 * structures and is correct */
3909 ret
= qcow2_mark_clean(bs
);
3914 ret
= bdrv_truncate(bs
->file
, (3 + l1_clusters
) * s
->cluster_size
,
3915 PREALLOC_MODE_OFF
, &local_err
);
3917 error_report_err(local_err
);
3923 fail_broken_refcounts
:
3924 /* The BDS is unusable at this point. If we wanted to make it usable, we
3925 * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
3926 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
3927 * again. However, because the functions which could have caused this error
3928 * path to be taken are used by those functions as well, it's very likely
3929 * that that sequence will fail as well. Therefore, just eject the BDS. */
3933 g_free(new_reftable
);
3937 static int qcow2_make_empty(BlockDriverState
*bs
)
3939 BDRVQcow2State
*s
= bs
->opaque
;
3940 uint64_t offset
, end_offset
;
3941 int step
= QEMU_ALIGN_DOWN(INT_MAX
, s
->cluster_size
);
3942 int l1_clusters
, ret
= 0;
3944 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
3946 if (s
->qcow_version
>= 3 && !s
->snapshots
&& !s
->nb_bitmaps
&&
3947 3 + l1_clusters
<= s
->refcount_block_size
&&
3948 s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
3949 /* The following function only works for qcow2 v3 images (it
3950 * requires the dirty flag) and only as long as there are no
3951 * features that reserve extra clusters (such as snapshots,
3952 * LUKS header, or persistent bitmaps), because it completely
3953 * empties the image. Furthermore, the L1 table and three
3954 * additional clusters (image header, refcount table, one
3955 * refcount block) have to fit inside one refcount block. */
3956 return make_completely_empty(bs
);
3959 /* This fallback code simply discards every active cluster; this is slow,
3960 * but works in all cases */
3961 end_offset
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3962 for (offset
= 0; offset
< end_offset
; offset
+= step
) {
3963 /* As this function is generally used after committing an external
3964 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
3965 * default action for this kind of discard is to pass the discard,
3966 * which will ideally result in an actually smaller image file, as
3967 * is probably desired. */
3968 ret
= qcow2_cluster_discard(bs
, offset
, MIN(step
, end_offset
- offset
),
3969 QCOW2_DISCARD_SNAPSHOT
, true);
3978 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
3980 BDRVQcow2State
*s
= bs
->opaque
;
3983 qemu_co_mutex_lock(&s
->lock
);
3984 ret
= qcow2_write_caches(bs
);
3985 qemu_co_mutex_unlock(&s
->lock
);
3990 static BlockMeasureInfo
*qcow2_measure(QemuOpts
*opts
, BlockDriverState
*in_bs
,
3993 Error
*local_err
= NULL
;
3994 BlockMeasureInfo
*info
;
3995 uint64_t required
= 0; /* bytes that contribute to required size */
3996 uint64_t virtual_size
; /* disk size as seen by guest */
3997 uint64_t refcount_bits
;
3999 size_t cluster_size
;
4002 PreallocMode prealloc
;
4003 bool has_backing_file
;
4005 /* Parse image creation options */
4006 cluster_size
= qcow2_opt_get_cluster_size_del(opts
, &local_err
);
4011 version
= qcow2_opt_get_version_del(opts
, &local_err
);
4016 refcount_bits
= qcow2_opt_get_refcount_bits_del(opts
, version
, &local_err
);
4021 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
4022 prealloc
= qapi_enum_parse(&PreallocMode_lookup
, optstr
,
4023 PREALLOC_MODE_OFF
, &local_err
);
4029 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
4030 has_backing_file
= !!optstr
;
4033 virtual_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0);
4034 virtual_size
= ROUND_UP(virtual_size
, cluster_size
);
4036 /* Check that virtual disk size is valid */
4037 l2_tables
= DIV_ROUND_UP(virtual_size
/ cluster_size
,
4038 cluster_size
/ sizeof(uint64_t));
4039 if (l2_tables
* sizeof(uint64_t) > QCOW_MAX_L1_SIZE
) {
4040 error_setg(&local_err
, "The image size is too large "
4041 "(try using a larger cluster size)");
4045 /* Account for input image */
4047 int64_t ssize
= bdrv_getlength(in_bs
);
4049 error_setg_errno(&local_err
, -ssize
,
4050 "Unable to get image virtual_size");
4054 virtual_size
= ROUND_UP(ssize
, cluster_size
);
4056 if (has_backing_file
) {
4057 /* We don't how much of the backing chain is shared by the input
4058 * image and the new image file. In the worst case the new image's
4059 * backing file has nothing in common with the input image. Be
4060 * conservative and assume all clusters need to be written.
4062 required
= virtual_size
;
4067 for (offset
= 0; offset
< ssize
; offset
+= pnum
) {
4070 ret
= bdrv_block_status_above(in_bs
, NULL
, offset
,
4071 ssize
- offset
, &pnum
, NULL
,
4074 error_setg_errno(&local_err
, -ret
,
4075 "Unable to get block status");
4079 if (ret
& BDRV_BLOCK_ZERO
) {
4080 /* Skip zero regions (safe with no backing file) */
4081 } else if ((ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) ==
4082 (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) {
4083 /* Extend pnum to end of cluster for next iteration */
4084 pnum
= ROUND_UP(offset
+ pnum
, cluster_size
) - offset
;
4086 /* Count clusters we've seen */
4087 required
+= offset
% cluster_size
+ pnum
;
4093 /* Take into account preallocation. Nothing special is needed for
4094 * PREALLOC_MODE_METADATA since metadata is always counted.
4096 if (prealloc
== PREALLOC_MODE_FULL
|| prealloc
== PREALLOC_MODE_FALLOC
) {
4097 required
= virtual_size
;
4100 info
= g_new(BlockMeasureInfo
, 1);
4101 info
->fully_allocated
=
4102 qcow2_calc_prealloc_size(virtual_size
, cluster_size
,
4103 ctz32(refcount_bits
));
4105 /* Remove data clusters that are not required. This overestimates the
4106 * required size because metadata needed for the fully allocated file is
4109 info
->required
= info
->fully_allocated
- virtual_size
+ required
;
4113 error_propagate(errp
, local_err
);
4117 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4119 BDRVQcow2State
*s
= bs
->opaque
;
4120 bdi
->unallocated_blocks_are_zero
= true;
4121 bdi
->cluster_size
= s
->cluster_size
;
4122 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
4126 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
)
4128 BDRVQcow2State
*s
= bs
->opaque
;
4129 ImageInfoSpecific
*spec_info
;
4130 QCryptoBlockInfo
*encrypt_info
= NULL
;
4132 if (s
->crypto
!= NULL
) {
4133 encrypt_info
= qcrypto_block_get_info(s
->crypto
, &error_abort
);
4136 spec_info
= g_new(ImageInfoSpecific
, 1);
4137 *spec_info
= (ImageInfoSpecific
){
4138 .type
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
4139 .u
.qcow2
.data
= g_new(ImageInfoSpecificQCow2
, 1),
4141 if (s
->qcow_version
== 2) {
4142 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
4143 .compat
= g_strdup("0.10"),
4144 .refcount_bits
= s
->refcount_bits
,
4146 } else if (s
->qcow_version
== 3) {
4147 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
4148 .compat
= g_strdup("1.1"),
4149 .lazy_refcounts
= s
->compatible_features
&
4150 QCOW2_COMPAT_LAZY_REFCOUNTS
,
4151 .has_lazy_refcounts
= true,
4152 .corrupt
= s
->incompatible_features
&
4153 QCOW2_INCOMPAT_CORRUPT
,
4154 .has_corrupt
= true,
4155 .refcount_bits
= s
->refcount_bits
,
4158 /* if this assertion fails, this probably means a new version was
4159 * added without having it covered here */
4164 ImageInfoSpecificQCow2Encryption
*qencrypt
=
4165 g_new(ImageInfoSpecificQCow2Encryption
, 1);
4166 switch (encrypt_info
->format
) {
4167 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
4168 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES
;
4169 qencrypt
->u
.aes
= encrypt_info
->u
.qcow
;
4171 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
4172 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS
;
4173 qencrypt
->u
.luks
= encrypt_info
->u
.luks
;
4178 /* Since we did shallow copy above, erase any pointers
4179 * in the original info */
4180 memset(&encrypt_info
->u
, 0, sizeof(encrypt_info
->u
));
4181 qapi_free_QCryptoBlockInfo(encrypt_info
);
4183 spec_info
->u
.qcow2
.data
->has_encrypt
= true;
4184 spec_info
->u
.qcow2
.data
->encrypt
= qencrypt
;
4190 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
4193 BDRVQcow2State
*s
= bs
->opaque
;
4195 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
4196 return bs
->drv
->bdrv_co_pwritev(bs
, qcow2_vm_state_offset(s
) + pos
,
4197 qiov
->size
, qiov
, 0);
4200 static int qcow2_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
4203 BDRVQcow2State
*s
= bs
->opaque
;
4205 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
4206 return bs
->drv
->bdrv_co_preadv(bs
, qcow2_vm_state_offset(s
) + pos
,
4207 qiov
->size
, qiov
, 0);
4211 * Downgrades an image's version. To achieve this, any incompatible features
4212 * have to be removed.
4214 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
,
4215 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
,
4218 BDRVQcow2State
*s
= bs
->opaque
;
4219 int current_version
= s
->qcow_version
;
4222 /* This is qcow2_downgrade(), not qcow2_upgrade() */
4223 assert(target_version
< current_version
);
4225 /* There are no other versions (now) that you can downgrade to */
4226 assert(target_version
== 2);
4228 if (s
->refcount_order
!= 4) {
4229 error_setg(errp
, "compat=0.10 requires refcount_bits=16");
4233 /* clear incompatible features */
4234 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
4235 ret
= qcow2_mark_clean(bs
);
4237 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
4242 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
4243 * the first place; if that happens nonetheless, returning -ENOTSUP is the
4244 * best thing to do anyway */
4246 if (s
->incompatible_features
) {
4247 error_setg(errp
, "Cannot downgrade an image with incompatible features "
4248 "%#" PRIx64
" set", s
->incompatible_features
);
4252 /* since we can ignore compatible features, we can set them to 0 as well */
4253 s
->compatible_features
= 0;
4254 /* if lazy refcounts have been used, they have already been fixed through
4255 * clearing the dirty flag */
4257 /* clearing autoclear features is trivial */
4258 s
->autoclear_features
= 0;
4260 ret
= qcow2_expand_zero_clusters(bs
, status_cb
, cb_opaque
);
4262 error_setg_errno(errp
, -ret
, "Failed to turn zero into data clusters");
4266 s
->qcow_version
= target_version
;
4267 ret
= qcow2_update_header(bs
);
4269 s
->qcow_version
= current_version
;
4270 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4276 typedef enum Qcow2AmendOperation
{
4277 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
4278 * statically initialized to so that the helper CB can discern the first
4279 * invocation from an operation change */
4280 QCOW2_NO_OPERATION
= 0,
4282 QCOW2_CHANGING_REFCOUNT_ORDER
,
4284 } Qcow2AmendOperation
;
4286 typedef struct Qcow2AmendHelperCBInfo
{
4287 /* The code coordinating the amend operations should only modify
4288 * these four fields; the rest will be managed by the CB */
4289 BlockDriverAmendStatusCB
*original_status_cb
;
4290 void *original_cb_opaque
;
4292 Qcow2AmendOperation current_operation
;
4294 /* Total number of operations to perform (only set once) */
4295 int total_operations
;
4297 /* The following fields are managed by the CB */
4299 /* Number of operations completed */
4300 int operations_completed
;
4302 /* Cumulative offset of all completed operations */
4303 int64_t offset_completed
;
4305 Qcow2AmendOperation last_operation
;
4306 int64_t last_work_size
;
4307 } Qcow2AmendHelperCBInfo
;
4309 static void qcow2_amend_helper_cb(BlockDriverState
*bs
,
4310 int64_t operation_offset
,
4311 int64_t operation_work_size
, void *opaque
)
4313 Qcow2AmendHelperCBInfo
*info
= opaque
;
4314 int64_t current_work_size
;
4315 int64_t projected_work_size
;
4317 if (info
->current_operation
!= info
->last_operation
) {
4318 if (info
->last_operation
!= QCOW2_NO_OPERATION
) {
4319 info
->offset_completed
+= info
->last_work_size
;
4320 info
->operations_completed
++;
4323 info
->last_operation
= info
->current_operation
;
4326 assert(info
->total_operations
> 0);
4327 assert(info
->operations_completed
< info
->total_operations
);
4329 info
->last_work_size
= operation_work_size
;
4331 current_work_size
= info
->offset_completed
+ operation_work_size
;
4333 /* current_work_size is the total work size for (operations_completed + 1)
4334 * operations (which includes this one), so multiply it by the number of
4335 * operations not covered and divide it by the number of operations
4336 * covered to get a projection for the operations not covered */
4337 projected_work_size
= current_work_size
* (info
->total_operations
-
4338 info
->operations_completed
- 1)
4339 / (info
->operations_completed
+ 1);
4341 info
->original_status_cb(bs
, info
->offset_completed
+ operation_offset
,
4342 current_work_size
+ projected_work_size
,
4343 info
->original_cb_opaque
);
4346 static int qcow2_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
4347 BlockDriverAmendStatusCB
*status_cb
,
4351 BDRVQcow2State
*s
= bs
->opaque
;
4352 int old_version
= s
->qcow_version
, new_version
= old_version
;
4353 uint64_t new_size
= 0;
4354 const char *backing_file
= NULL
, *backing_format
= NULL
;
4355 bool lazy_refcounts
= s
->use_lazy_refcounts
;
4356 const char *compat
= NULL
;
4357 uint64_t cluster_size
= s
->cluster_size
;
4360 int refcount_bits
= s
->refcount_bits
;
4362 QemuOptDesc
*desc
= opts
->list
->desc
;
4363 Qcow2AmendHelperCBInfo helper_cb_info
;
4365 while (desc
&& desc
->name
) {
4366 if (!qemu_opt_find(opts
, desc
->name
)) {
4367 /* only change explicitly defined options */
4372 if (!strcmp(desc
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
4373 compat
= qemu_opt_get(opts
, BLOCK_OPT_COMPAT_LEVEL
);
4375 /* preserve default */
4376 } else if (!strcmp(compat
, "0.10")) {
4378 } else if (!strcmp(compat
, "1.1")) {
4381 error_setg(errp
, "Unknown compatibility level %s", compat
);
4384 } else if (!strcmp(desc
->name
, BLOCK_OPT_PREALLOC
)) {
4385 error_setg(errp
, "Cannot change preallocation mode");
4387 } else if (!strcmp(desc
->name
, BLOCK_OPT_SIZE
)) {
4388 new_size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
4389 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FILE
)) {
4390 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
4391 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FMT
)) {
4392 backing_format
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
4393 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT
)) {
4394 encrypt
= qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
,
4397 if (encrypt
!= !!s
->crypto
) {
4399 "Changing the encryption flag is not supported");
4402 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT_FORMAT
)) {
4403 encformat
= qcow2_crypt_method_from_format(
4404 qemu_opt_get(opts
, BLOCK_OPT_ENCRYPT_FORMAT
));
4406 if (encformat
!= s
->crypt_method_header
) {
4408 "Changing the encryption format is not supported");
4411 } else if (g_str_has_prefix(desc
->name
, "encrypt.")) {
4413 "Changing the encryption parameters is not supported");
4415 } else if (!strcmp(desc
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
4416 cluster_size
= qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
,
4418 if (cluster_size
!= s
->cluster_size
) {
4419 error_setg(errp
, "Changing the cluster size is not supported");
4422 } else if (!strcmp(desc
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
4423 lazy_refcounts
= qemu_opt_get_bool(opts
, BLOCK_OPT_LAZY_REFCOUNTS
,
4425 } else if (!strcmp(desc
->name
, BLOCK_OPT_REFCOUNT_BITS
)) {
4426 refcount_bits
= qemu_opt_get_number(opts
, BLOCK_OPT_REFCOUNT_BITS
,
4429 if (refcount_bits
<= 0 || refcount_bits
> 64 ||
4430 !is_power_of_2(refcount_bits
))
4432 error_setg(errp
, "Refcount width must be a power of two and "
4433 "may not exceed 64 bits");
4437 /* if this point is reached, this probably means a new option was
4438 * added without having it covered here */
4445 helper_cb_info
= (Qcow2AmendHelperCBInfo
){
4446 .original_status_cb
= status_cb
,
4447 .original_cb_opaque
= cb_opaque
,
4448 .total_operations
= (new_version
< old_version
)
4449 + (s
->refcount_bits
!= refcount_bits
)
4452 /* Upgrade first (some features may require compat=1.1) */
4453 if (new_version
> old_version
) {
4454 s
->qcow_version
= new_version
;
4455 ret
= qcow2_update_header(bs
);
4457 s
->qcow_version
= old_version
;
4458 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4463 if (s
->refcount_bits
!= refcount_bits
) {
4464 int refcount_order
= ctz32(refcount_bits
);
4466 if (new_version
< 3 && refcount_bits
!= 16) {
4467 error_setg(errp
, "Refcount widths other than 16 bits require "
4468 "compatibility level 1.1 or above (use compat=1.1 or "
4473 helper_cb_info
.current_operation
= QCOW2_CHANGING_REFCOUNT_ORDER
;
4474 ret
= qcow2_change_refcount_order(bs
, refcount_order
,
4475 &qcow2_amend_helper_cb
,
4476 &helper_cb_info
, errp
);
4482 if (backing_file
|| backing_format
) {
4483 ret
= qcow2_change_backing_file(bs
,
4484 backing_file
?: s
->image_backing_file
,
4485 backing_format
?: s
->image_backing_format
);
4487 error_setg_errno(errp
, -ret
, "Failed to change the backing file");
4492 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
4493 if (lazy_refcounts
) {
4494 if (new_version
< 3) {
4495 error_setg(errp
, "Lazy refcounts only supported with "
4496 "compatibility level 1.1 and above (use compat=1.1 "
4500 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
4501 ret
= qcow2_update_header(bs
);
4503 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
4504 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4507 s
->use_lazy_refcounts
= true;
4509 /* make image clean first */
4510 ret
= qcow2_mark_clean(bs
);
4512 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
4515 /* now disallow lazy refcounts */
4516 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
4517 ret
= qcow2_update_header(bs
);
4519 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
4520 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4523 s
->use_lazy_refcounts
= false;
4528 BlockBackend
*blk
= blk_new(BLK_PERM_RESIZE
, BLK_PERM_ALL
);
4529 ret
= blk_insert_bs(blk
, bs
, errp
);
4535 ret
= blk_truncate(blk
, new_size
, PREALLOC_MODE_OFF
, errp
);
4542 /* Downgrade last (so unsupported features can be removed before) */
4543 if (new_version
< old_version
) {
4544 helper_cb_info
.current_operation
= QCOW2_DOWNGRADING
;
4545 ret
= qcow2_downgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
4546 &helper_cb_info
, errp
);
4556 * If offset or size are negative, respectively, they will not be included in
4557 * the BLOCK_IMAGE_CORRUPTED event emitted.
4558 * fatal will be ignored for read-only BDS; corruptions found there will always
4559 * be considered non-fatal.
4561 void qcow2_signal_corruption(BlockDriverState
*bs
, bool fatal
, int64_t offset
,
4562 int64_t size
, const char *message_format
, ...)
4564 BDRVQcow2State
*s
= bs
->opaque
;
4565 const char *node_name
;
4569 fatal
= fatal
&& bdrv_is_writable(bs
);
4571 if (s
->signaled_corruption
&&
4572 (!fatal
|| (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
)))
4577 va_start(ap
, message_format
);
4578 message
= g_strdup_vprintf(message_format
, ap
);
4582 fprintf(stderr
, "qcow2: Marking image as corrupt: %s; further "
4583 "corruption events will be suppressed\n", message
);
4585 fprintf(stderr
, "qcow2: Image is corrupt: %s; further non-fatal "
4586 "corruption events will be suppressed\n", message
);
4589 node_name
= bdrv_get_node_name(bs
);
4590 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs
),
4591 *node_name
!= '\0', node_name
,
4592 message
, offset
>= 0, offset
,
4594 fatal
, &error_abort
);
4598 qcow2_mark_corrupt(bs
);
4599 bs
->drv
= NULL
; /* make BDS unusable */
4602 s
->signaled_corruption
= true;
4605 static QemuOptsList qcow2_create_opts
= {
4606 .name
= "qcow2-create-opts",
4607 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_create_opts
.head
),
4610 .name
= BLOCK_OPT_SIZE
,
4611 .type
= QEMU_OPT_SIZE
,
4612 .help
= "Virtual disk size"
4615 .name
= BLOCK_OPT_COMPAT_LEVEL
,
4616 .type
= QEMU_OPT_STRING
,
4617 .help
= "Compatibility level (0.10 or 1.1)"
4620 .name
= BLOCK_OPT_BACKING_FILE
,
4621 .type
= QEMU_OPT_STRING
,
4622 .help
= "File name of a base image"
4625 .name
= BLOCK_OPT_BACKING_FMT
,
4626 .type
= QEMU_OPT_STRING
,
4627 .help
= "Image format of the base image"
4630 .name
= BLOCK_OPT_ENCRYPT
,
4631 .type
= QEMU_OPT_BOOL
,
4632 .help
= "Encrypt the image with format 'aes'. (Deprecated "
4633 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT
"=aes)",
4636 .name
= BLOCK_OPT_ENCRYPT_FORMAT
,
4637 .type
= QEMU_OPT_STRING
,
4638 .help
= "Encrypt the image, format choices: 'aes', 'luks'",
4640 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
4641 "ID of secret providing qcow AES key or LUKS passphrase"),
4642 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."),
4643 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."),
4644 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."),
4645 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."),
4646 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."),
4647 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
4649 .name
= BLOCK_OPT_CLUSTER_SIZE
,
4650 .type
= QEMU_OPT_SIZE
,
4651 .help
= "qcow2 cluster size",
4652 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
)
4655 .name
= BLOCK_OPT_PREALLOC
,
4656 .type
= QEMU_OPT_STRING
,
4657 .help
= "Preallocation mode (allowed values: off, metadata, "
4661 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
4662 .type
= QEMU_OPT_BOOL
,
4663 .help
= "Postpone refcount updates",
4664 .def_value_str
= "off"
4667 .name
= BLOCK_OPT_REFCOUNT_BITS
,
4668 .type
= QEMU_OPT_NUMBER
,
4669 .help
= "Width of a reference count entry in bits",
4670 .def_value_str
= "16"
4672 { /* end of list */ }
4676 BlockDriver bdrv_qcow2
= {
4677 .format_name
= "qcow2",
4678 .instance_size
= sizeof(BDRVQcow2State
),
4679 .bdrv_probe
= qcow2_probe
,
4680 .bdrv_open
= qcow2_open
,
4681 .bdrv_close
= qcow2_close
,
4682 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
4683 .bdrv_reopen_commit
= qcow2_reopen_commit
,
4684 .bdrv_reopen_abort
= qcow2_reopen_abort
,
4685 .bdrv_join_options
= qcow2_join_options
,
4686 .bdrv_child_perm
= bdrv_format_default_perms
,
4687 .bdrv_co_create_opts
= qcow2_co_create_opts
,
4688 .bdrv_co_create
= qcow2_co_create
,
4689 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
4690 .bdrv_co_block_status
= qcow2_co_block_status
,
4692 .bdrv_co_preadv
= qcow2_co_preadv
,
4693 .bdrv_co_pwritev
= qcow2_co_pwritev
,
4694 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
4696 .bdrv_co_pwrite_zeroes
= qcow2_co_pwrite_zeroes
,
4697 .bdrv_co_pdiscard
= qcow2_co_pdiscard
,
4698 .bdrv_co_copy_range_from
= qcow2_co_copy_range_from
,
4699 .bdrv_co_copy_range_to
= qcow2_co_copy_range_to
,
4700 .bdrv_truncate
= qcow2_truncate
,
4701 .bdrv_co_pwritev_compressed
= qcow2_co_pwritev_compressed
,
4702 .bdrv_make_empty
= qcow2_make_empty
,
4704 .bdrv_snapshot_create
= qcow2_snapshot_create
,
4705 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
4706 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
4707 .bdrv_snapshot_list
= qcow2_snapshot_list
,
4708 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
4709 .bdrv_measure
= qcow2_measure
,
4710 .bdrv_get_info
= qcow2_get_info
,
4711 .bdrv_get_specific_info
= qcow2_get_specific_info
,
4713 .bdrv_save_vmstate
= qcow2_save_vmstate
,
4714 .bdrv_load_vmstate
= qcow2_load_vmstate
,
4716 .supports_backing
= true,
4717 .bdrv_change_backing_file
= qcow2_change_backing_file
,
4719 .bdrv_refresh_limits
= qcow2_refresh_limits
,
4720 .bdrv_co_invalidate_cache
= qcow2_co_invalidate_cache
,
4721 .bdrv_inactivate
= qcow2_inactivate
,
4723 .create_opts
= &qcow2_create_opts
,
4724 .bdrv_co_check
= qcow2_co_check
,
4725 .bdrv_amend_options
= qcow2_amend_options
,
4727 .bdrv_detach_aio_context
= qcow2_detach_aio_context
,
4728 .bdrv_attach_aio_context
= qcow2_attach_aio_context
,
4730 .bdrv_reopen_bitmaps_rw
= qcow2_reopen_bitmaps_rw
,
4731 .bdrv_can_store_new_dirty_bitmap
= qcow2_can_store_new_dirty_bitmap
,
4732 .bdrv_remove_persistent_dirty_bitmap
= qcow2_remove_persistent_dirty_bitmap
,
4735 static void bdrv_qcow2_init(void)
4737 bdrv_register(&bdrv_qcow2
);
4740 block_init(bdrv_qcow2_init
);