2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
27 #include "block/qdict.h"
28 #include "sysemu/block-backend.h"
29 #include "qemu/main-loop.h"
30 #include "qemu/module.h"
32 #include "qemu/error-report.h"
33 #include "qapi/error.h"
34 #include "qapi/qapi-events-block-core.h"
35 #include "qapi/qmp/qdict.h"
36 #include "qapi/qmp/qstring.h"
38 #include "qemu/option_int.h"
39 #include "qemu/cutils.h"
40 #include "qemu/bswap.h"
41 #include "qapi/qobject-input-visitor.h"
42 #include "qapi/qapi-visit-block-core.h"
44 #include "block/aio_task.h"
47 Differences with QCOW:
49 - Support for multiple incremental snapshots.
50 - Memory management by reference counts.
51 - Clusters which have a reference count of one have the bit
52 QCOW_OFLAG_COPIED to optimize write performance.
53 - Size of compressed clusters is stored in sectors to reduce bit usage
54 in the cluster offsets.
55 - Support for storing additional data (such as the VM state) in the
57 - If a backing store is used, the cluster size is not constrained
58 (could be backported to QCOW).
59 - L2 tables have always a size of one cluster.
66 } QEMU_PACKED QCowExtension
;
68 #define QCOW2_EXT_MAGIC_END 0
69 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
70 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
71 #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
72 #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875
73 #define QCOW2_EXT_MAGIC_DATA_FILE 0x44415441
75 static int coroutine_fn
76 qcow2_co_preadv_compressed(BlockDriverState
*bs
,
77 uint64_t file_cluster_offset
,
83 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
85 const QCowHeader
*cow_header
= (const void *)buf
;
87 if (buf_size
>= sizeof(QCowHeader
) &&
88 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
89 be32_to_cpu(cow_header
->version
) >= 2)
96 static ssize_t
qcow2_crypto_hdr_read_func(QCryptoBlock
*block
, size_t offset
,
97 uint8_t *buf
, size_t buflen
,
98 void *opaque
, Error
**errp
)
100 BlockDriverState
*bs
= opaque
;
101 BDRVQcow2State
*s
= bs
->opaque
;
104 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
105 error_setg(errp
, "Request for data outside of extension header");
109 ret
= bdrv_pread(bs
->file
,
110 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
112 error_setg_errno(errp
, -ret
, "Could not read encryption header");
119 static ssize_t
qcow2_crypto_hdr_init_func(QCryptoBlock
*block
, size_t headerlen
,
120 void *opaque
, Error
**errp
)
122 BlockDriverState
*bs
= opaque
;
123 BDRVQcow2State
*s
= bs
->opaque
;
127 ret
= qcow2_alloc_clusters(bs
, headerlen
);
129 error_setg_errno(errp
, -ret
,
130 "Cannot allocate cluster for LUKS header size %zu",
135 s
->crypto_header
.length
= headerlen
;
136 s
->crypto_header
.offset
= ret
;
138 /* Zero fill remaining space in cluster so it has predictable
139 * content in case of future spec changes */
140 clusterlen
= size_to_clusters(s
, headerlen
) * s
->cluster_size
;
141 assert(qcow2_pre_write_overlap_check(bs
, 0, ret
, clusterlen
, false) == 0);
142 ret
= bdrv_pwrite_zeroes(bs
->file
,
144 clusterlen
- headerlen
, 0);
146 error_setg_errno(errp
, -ret
, "Could not zero fill encryption header");
154 static ssize_t
qcow2_crypto_hdr_write_func(QCryptoBlock
*block
, size_t offset
,
155 const uint8_t *buf
, size_t buflen
,
156 void *opaque
, Error
**errp
)
158 BlockDriverState
*bs
= opaque
;
159 BDRVQcow2State
*s
= bs
->opaque
;
162 if ((offset
+ buflen
) > s
->crypto_header
.length
) {
163 error_setg(errp
, "Request for data outside of extension header");
167 ret
= bdrv_pwrite(bs
->file
,
168 s
->crypto_header
.offset
+ offset
, buf
, buflen
);
170 error_setg_errno(errp
, -ret
, "Could not read encryption header");
178 * read qcow2 extension and fill bs
179 * start reading from start_offset
180 * finish reading upon magic of value 0 or when end_offset reached
181 * unknown magic is skipped (future extension this version knows nothing about)
182 * return 0 upon success, non-0 otherwise
184 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
185 uint64_t end_offset
, void **p_feature_table
,
186 int flags
, bool *need_update_header
,
189 BDRVQcow2State
*s
= bs
->opaque
;
193 Qcow2BitmapHeaderExt bitmaps_ext
;
195 if (need_update_header
!= NULL
) {
196 *need_update_header
= false;
200 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
202 offset
= start_offset
;
203 while (offset
< end_offset
) {
207 if (offset
> s
->cluster_size
)
208 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
210 printf("attempting to read extended header in offset %lu\n", offset
);
213 ret
= bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
));
215 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
216 "pread fail from offset %" PRIu64
, offset
);
219 ext
.magic
= be32_to_cpu(ext
.magic
);
220 ext
.len
= be32_to_cpu(ext
.len
);
221 offset
+= sizeof(ext
);
223 printf("ext.magic = 0x%x\n", ext
.magic
);
225 if (offset
> end_offset
|| ext
.len
> end_offset
- offset
) {
226 error_setg(errp
, "Header extension too large");
231 case QCOW2_EXT_MAGIC_END
:
234 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
235 if (ext
.len
>= sizeof(bs
->backing_format
)) {
236 error_setg(errp
, "ERROR: ext_backing_format: len=%" PRIu32
237 " too large (>=%zu)", ext
.len
,
238 sizeof(bs
->backing_format
));
241 ret
= bdrv_pread(bs
->file
, offset
, bs
->backing_format
, ext
.len
);
243 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
244 "Could not read format name");
247 bs
->backing_format
[ext
.len
] = '\0';
248 s
->image_backing_format
= g_strdup(bs
->backing_format
);
250 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
254 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
255 if (p_feature_table
!= NULL
) {
256 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
257 ret
= bdrv_pread(bs
->file
, offset
, feature_table
, ext
.len
);
259 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
260 "Could not read table");
264 *p_feature_table
= feature_table
;
268 case QCOW2_EXT_MAGIC_CRYPTO_HEADER
: {
269 unsigned int cflags
= 0;
270 if (s
->crypt_method_header
!= QCOW_CRYPT_LUKS
) {
271 error_setg(errp
, "CRYPTO header extension only "
272 "expected with LUKS encryption method");
275 if (ext
.len
!= sizeof(Qcow2CryptoHeaderExtension
)) {
276 error_setg(errp
, "CRYPTO header extension size %u, "
277 "but expected size %zu", ext
.len
,
278 sizeof(Qcow2CryptoHeaderExtension
));
282 ret
= bdrv_pread(bs
->file
, offset
, &s
->crypto_header
, ext
.len
);
284 error_setg_errno(errp
, -ret
,
285 "Unable to read CRYPTO header extension");
288 s
->crypto_header
.offset
= be64_to_cpu(s
->crypto_header
.offset
);
289 s
->crypto_header
.length
= be64_to_cpu(s
->crypto_header
.length
);
291 if ((s
->crypto_header
.offset
% s
->cluster_size
) != 0) {
292 error_setg(errp
, "Encryption header offset '%" PRIu64
"' is "
293 "not a multiple of cluster size '%u'",
294 s
->crypto_header
.offset
, s
->cluster_size
);
298 if (flags
& BDRV_O_NO_IO
) {
299 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
301 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
302 qcow2_crypto_hdr_read_func
,
303 bs
, cflags
, QCOW2_MAX_THREADS
, errp
);
309 case QCOW2_EXT_MAGIC_BITMAPS
:
310 if (ext
.len
!= sizeof(bitmaps_ext
)) {
311 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
312 "Invalid extension length");
316 if (!(s
->autoclear_features
& QCOW2_AUTOCLEAR_BITMAPS
)) {
317 if (s
->qcow_version
< 3) {
318 /* Let's be a bit more specific */
319 warn_report("This qcow2 v2 image contains bitmaps, but "
320 "they may have been modified by a program "
321 "without persistent bitmap support; so now "
322 "they must all be considered inconsistent");
324 warn_report("a program lacking bitmap support "
325 "modified this file, so all bitmaps are now "
326 "considered inconsistent");
328 error_printf("Some clusters may be leaked, "
329 "run 'qemu-img check -r' on the image "
331 if (need_update_header
!= NULL
) {
332 /* Updating is needed to drop invalid bitmap extension. */
333 *need_update_header
= true;
338 ret
= bdrv_pread(bs
->file
, offset
, &bitmaps_ext
, ext
.len
);
340 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
341 "Could not read ext header");
345 if (bitmaps_ext
.reserved32
!= 0) {
346 error_setg_errno(errp
, -ret
, "bitmaps_ext: "
347 "Reserved field is not zero");
351 bitmaps_ext
.nb_bitmaps
= be32_to_cpu(bitmaps_ext
.nb_bitmaps
);
352 bitmaps_ext
.bitmap_directory_size
=
353 be64_to_cpu(bitmaps_ext
.bitmap_directory_size
);
354 bitmaps_ext
.bitmap_directory_offset
=
355 be64_to_cpu(bitmaps_ext
.bitmap_directory_offset
);
357 if (bitmaps_ext
.nb_bitmaps
> QCOW2_MAX_BITMAPS
) {
359 "bitmaps_ext: Image has %" PRIu32
" bitmaps, "
360 "exceeding the QEMU supported maximum of %d",
361 bitmaps_ext
.nb_bitmaps
, QCOW2_MAX_BITMAPS
);
365 if (bitmaps_ext
.nb_bitmaps
== 0) {
366 error_setg(errp
, "found bitmaps extension with zero bitmaps");
370 if (bitmaps_ext
.bitmap_directory_offset
& (s
->cluster_size
- 1)) {
371 error_setg(errp
, "bitmaps_ext: "
372 "invalid bitmap directory offset");
376 if (bitmaps_ext
.bitmap_directory_size
>
377 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
) {
378 error_setg(errp
, "bitmaps_ext: "
379 "bitmap directory size (%" PRIu64
") exceeds "
380 "the maximum supported size (%d)",
381 bitmaps_ext
.bitmap_directory_size
,
382 QCOW2_MAX_BITMAP_DIRECTORY_SIZE
);
386 s
->nb_bitmaps
= bitmaps_ext
.nb_bitmaps
;
387 s
->bitmap_directory_offset
=
388 bitmaps_ext
.bitmap_directory_offset
;
389 s
->bitmap_directory_size
=
390 bitmaps_ext
.bitmap_directory_size
;
393 printf("Qcow2: Got bitmaps extension: "
394 "offset=%" PRIu64
" nb_bitmaps=%" PRIu32
"\n",
395 s
->bitmap_directory_offset
, s
->nb_bitmaps
);
399 case QCOW2_EXT_MAGIC_DATA_FILE
:
401 s
->image_data_file
= g_malloc0(ext
.len
+ 1);
402 ret
= bdrv_pread(bs
->file
, offset
, s
->image_data_file
, ext
.len
);
404 error_setg_errno(errp
, -ret
,
405 "ERROR: Could not read data file name");
409 printf("Qcow2: Got external data file %s\n", s
->image_data_file
);
415 /* unknown magic - save it in case we need to rewrite the header */
416 /* If you add a new feature, make sure to also update the fast
417 * path of qcow2_make_empty() to deal with it. */
419 Qcow2UnknownHeaderExtension
*uext
;
421 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
422 uext
->magic
= ext
.magic
;
424 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
426 ret
= bdrv_pread(bs
->file
, offset
, uext
->data
, uext
->len
);
428 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
429 "Could not read data");
436 offset
+= ((ext
.len
+ 7) & ~7);
442 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
444 BDRVQcow2State
*s
= bs
->opaque
;
445 Qcow2UnknownHeaderExtension
*uext
, *next
;
447 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
448 QLIST_REMOVE(uext
, next
);
453 static void report_unsupported_feature(Error
**errp
, Qcow2Feature
*table
,
456 char *features
= g_strdup("");
459 while (table
&& table
->name
[0] != '\0') {
460 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
461 if (mask
& (1ULL << table
->bit
)) {
463 features
= g_strdup_printf("%s%s%.46s", old
, *old
? ", " : "",
466 mask
&= ~(1ULL << table
->bit
);
474 features
= g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64
,
475 old
, *old
? ", " : "", mask
);
479 error_setg(errp
, "Unsupported qcow2 feature(s): %s", features
);
484 * Sets the dirty bit and flushes afterwards if necessary.
486 * The incompatible_features bit is only set if the image file header was
487 * updated successfully. Therefore it is not required to check the return
488 * value of this function.
490 int qcow2_mark_dirty(BlockDriverState
*bs
)
492 BDRVQcow2State
*s
= bs
->opaque
;
496 assert(s
->qcow_version
>= 3);
498 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
499 return 0; /* already dirty */
502 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
503 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, incompatible_features
),
508 ret
= bdrv_flush(bs
->file
->bs
);
513 /* Only treat image as dirty if the header was updated successfully */
514 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
519 * Clears the dirty bit and flushes before if necessary. Only call this
520 * function when there are no pending requests, it does not guard against
521 * concurrent requests dirtying the image.
523 static int qcow2_mark_clean(BlockDriverState
*bs
)
525 BDRVQcow2State
*s
= bs
->opaque
;
527 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
530 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
532 ret
= qcow2_flush_caches(bs
);
537 return qcow2_update_header(bs
);
543 * Marks the image as corrupt.
545 int qcow2_mark_corrupt(BlockDriverState
*bs
)
547 BDRVQcow2State
*s
= bs
->opaque
;
549 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
550 return qcow2_update_header(bs
);
554 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
555 * before if necessary.
557 int qcow2_mark_consistent(BlockDriverState
*bs
)
559 BDRVQcow2State
*s
= bs
->opaque
;
561 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
562 int ret
= qcow2_flush_caches(bs
);
567 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
568 return qcow2_update_header(bs
);
573 static int coroutine_fn
qcow2_co_check_locked(BlockDriverState
*bs
,
574 BdrvCheckResult
*result
,
577 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
582 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
583 ret
= qcow2_mark_clean(bs
);
587 return qcow2_mark_consistent(bs
);
592 static int coroutine_fn
qcow2_co_check(BlockDriverState
*bs
,
593 BdrvCheckResult
*result
,
596 BDRVQcow2State
*s
= bs
->opaque
;
599 qemu_co_mutex_lock(&s
->lock
);
600 ret
= qcow2_co_check_locked(bs
, result
, fix
);
601 qemu_co_mutex_unlock(&s
->lock
);
605 int qcow2_validate_table(BlockDriverState
*bs
, uint64_t offset
,
606 uint64_t entries
, size_t entry_len
,
607 int64_t max_size_bytes
, const char *table_name
,
610 BDRVQcow2State
*s
= bs
->opaque
;
612 if (entries
> max_size_bytes
/ entry_len
) {
613 error_setg(errp
, "%s too large", table_name
);
617 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
618 * because values will be passed to qemu functions taking int64_t. */
619 if ((INT64_MAX
- entries
* entry_len
< offset
) ||
620 (offset_into_cluster(s
, offset
) != 0)) {
621 error_setg(errp
, "%s offset invalid", table_name
);
628 static const char *const mutable_opts
[] = {
629 QCOW2_OPT_LAZY_REFCOUNTS
,
630 QCOW2_OPT_DISCARD_REQUEST
,
631 QCOW2_OPT_DISCARD_SNAPSHOT
,
632 QCOW2_OPT_DISCARD_OTHER
,
634 QCOW2_OPT_OVERLAP_TEMPLATE
,
635 QCOW2_OPT_OVERLAP_MAIN_HEADER
,
636 QCOW2_OPT_OVERLAP_ACTIVE_L1
,
637 QCOW2_OPT_OVERLAP_ACTIVE_L2
,
638 QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
639 QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
640 QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
641 QCOW2_OPT_OVERLAP_INACTIVE_L1
,
642 QCOW2_OPT_OVERLAP_INACTIVE_L2
,
643 QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
644 QCOW2_OPT_CACHE_SIZE
,
645 QCOW2_OPT_L2_CACHE_SIZE
,
646 QCOW2_OPT_L2_CACHE_ENTRY_SIZE
,
647 QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
648 QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
652 static QemuOptsList qcow2_runtime_opts
= {
654 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
657 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
658 .type
= QEMU_OPT_BOOL
,
659 .help
= "Postpone refcount updates",
662 .name
= QCOW2_OPT_DISCARD_REQUEST
,
663 .type
= QEMU_OPT_BOOL
,
664 .help
= "Pass guest discard requests to the layer below",
667 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
668 .type
= QEMU_OPT_BOOL
,
669 .help
= "Generate discard requests when snapshot related space "
673 .name
= QCOW2_OPT_DISCARD_OTHER
,
674 .type
= QEMU_OPT_BOOL
,
675 .help
= "Generate discard requests when other clusters are freed",
678 .name
= QCOW2_OPT_OVERLAP
,
679 .type
= QEMU_OPT_STRING
,
680 .help
= "Selects which overlap checks to perform from a range of "
681 "templates (none, constant, cached, all)",
684 .name
= QCOW2_OPT_OVERLAP_TEMPLATE
,
685 .type
= QEMU_OPT_STRING
,
686 .help
= "Selects which overlap checks to perform from a range of "
687 "templates (none, constant, cached, all)",
690 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
691 .type
= QEMU_OPT_BOOL
,
692 .help
= "Check for unintended writes into the main qcow2 header",
695 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
696 .type
= QEMU_OPT_BOOL
,
697 .help
= "Check for unintended writes into the active L1 table",
700 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
701 .type
= QEMU_OPT_BOOL
,
702 .help
= "Check for unintended writes into an active L2 table",
705 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
706 .type
= QEMU_OPT_BOOL
,
707 .help
= "Check for unintended writes into the refcount table",
710 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
711 .type
= QEMU_OPT_BOOL
,
712 .help
= "Check for unintended writes into a refcount block",
715 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
716 .type
= QEMU_OPT_BOOL
,
717 .help
= "Check for unintended writes into the snapshot table",
720 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
721 .type
= QEMU_OPT_BOOL
,
722 .help
= "Check for unintended writes into an inactive L1 table",
725 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
726 .type
= QEMU_OPT_BOOL
,
727 .help
= "Check for unintended writes into an inactive L2 table",
730 .name
= QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
731 .type
= QEMU_OPT_BOOL
,
732 .help
= "Check for unintended writes into the bitmap directory",
735 .name
= QCOW2_OPT_CACHE_SIZE
,
736 .type
= QEMU_OPT_SIZE
,
737 .help
= "Maximum combined metadata (L2 tables and refcount blocks) "
741 .name
= QCOW2_OPT_L2_CACHE_SIZE
,
742 .type
= QEMU_OPT_SIZE
,
743 .help
= "Maximum L2 table cache size",
746 .name
= QCOW2_OPT_L2_CACHE_ENTRY_SIZE
,
747 .type
= QEMU_OPT_SIZE
,
748 .help
= "Size of each entry in the L2 cache",
751 .name
= QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
752 .type
= QEMU_OPT_SIZE
,
753 .help
= "Maximum refcount block cache size",
756 .name
= QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
757 .type
= QEMU_OPT_NUMBER
,
758 .help
= "Clean unused cache entries after this time (in seconds)",
760 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
761 "ID of secret providing qcow2 AES key or LUKS passphrase"),
762 { /* end of list */ }
766 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
767 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
768 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
769 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
770 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
771 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
772 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
773 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
774 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
775 [QCOW2_OL_BITMAP_DIRECTORY_BITNR
] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY
,
778 static void cache_clean_timer_cb(void *opaque
)
780 BlockDriverState
*bs
= opaque
;
781 BDRVQcow2State
*s
= bs
->opaque
;
782 qcow2_cache_clean_unused(s
->l2_table_cache
);
783 qcow2_cache_clean_unused(s
->refcount_block_cache
);
784 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
785 (int64_t) s
->cache_clean_interval
* 1000);
788 static void cache_clean_timer_init(BlockDriverState
*bs
, AioContext
*context
)
790 BDRVQcow2State
*s
= bs
->opaque
;
791 if (s
->cache_clean_interval
> 0) {
792 s
->cache_clean_timer
= aio_timer_new(context
, QEMU_CLOCK_VIRTUAL
,
793 SCALE_MS
, cache_clean_timer_cb
,
795 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
796 (int64_t) s
->cache_clean_interval
* 1000);
800 static void cache_clean_timer_del(BlockDriverState
*bs
)
802 BDRVQcow2State
*s
= bs
->opaque
;
803 if (s
->cache_clean_timer
) {
804 timer_del(s
->cache_clean_timer
);
805 timer_free(s
->cache_clean_timer
);
806 s
->cache_clean_timer
= NULL
;
810 static void qcow2_detach_aio_context(BlockDriverState
*bs
)
812 cache_clean_timer_del(bs
);
815 static void qcow2_attach_aio_context(BlockDriverState
*bs
,
816 AioContext
*new_context
)
818 cache_clean_timer_init(bs
, new_context
);
821 static void read_cache_sizes(BlockDriverState
*bs
, QemuOpts
*opts
,
822 uint64_t *l2_cache_size
,
823 uint64_t *l2_cache_entry_size
,
824 uint64_t *refcount_cache_size
, Error
**errp
)
826 BDRVQcow2State
*s
= bs
->opaque
;
827 uint64_t combined_cache_size
, l2_cache_max_setting
;
828 bool l2_cache_size_set
, refcount_cache_size_set
, combined_cache_size_set
;
829 bool l2_cache_entry_size_set
;
830 int min_refcount_cache
= MIN_REFCOUNT_CACHE_SIZE
* s
->cluster_size
;
831 uint64_t virtual_disk_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
832 uint64_t max_l2_entries
= DIV_ROUND_UP(virtual_disk_size
, s
->cluster_size
);
833 /* An L2 table is always one cluster in size so the max cache size
834 * should be a multiple of the cluster size. */
835 uint64_t max_l2_cache
= ROUND_UP(max_l2_entries
* sizeof(uint64_t),
838 combined_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_CACHE_SIZE
);
839 l2_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_SIZE
);
840 refcount_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
841 l2_cache_entry_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_ENTRY_SIZE
);
843 combined_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_CACHE_SIZE
, 0);
844 l2_cache_max_setting
= qemu_opt_get_size(opts
, QCOW2_OPT_L2_CACHE_SIZE
,
845 DEFAULT_L2_CACHE_MAX_SIZE
);
846 *refcount_cache_size
= qemu_opt_get_size(opts
,
847 QCOW2_OPT_REFCOUNT_CACHE_SIZE
, 0);
849 *l2_cache_entry_size
= qemu_opt_get_size(
850 opts
, QCOW2_OPT_L2_CACHE_ENTRY_SIZE
, s
->cluster_size
);
852 *l2_cache_size
= MIN(max_l2_cache
, l2_cache_max_setting
);
854 if (combined_cache_size_set
) {
855 if (l2_cache_size_set
&& refcount_cache_size_set
) {
856 error_setg(errp
, QCOW2_OPT_CACHE_SIZE
", " QCOW2_OPT_L2_CACHE_SIZE
857 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not be set "
860 } else if (l2_cache_size_set
&&
861 (l2_cache_max_setting
> combined_cache_size
)) {
862 error_setg(errp
, QCOW2_OPT_L2_CACHE_SIZE
" may not exceed "
863 QCOW2_OPT_CACHE_SIZE
);
865 } else if (*refcount_cache_size
> combined_cache_size
) {
866 error_setg(errp
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not exceed "
867 QCOW2_OPT_CACHE_SIZE
);
871 if (l2_cache_size_set
) {
872 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
873 } else if (refcount_cache_size_set
) {
874 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
876 /* Assign as much memory as possible to the L2 cache, and
877 * use the remainder for the refcount cache */
878 if (combined_cache_size
>= max_l2_cache
+ min_refcount_cache
) {
879 *l2_cache_size
= max_l2_cache
;
880 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
882 *refcount_cache_size
=
883 MIN(combined_cache_size
, min_refcount_cache
);
884 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
890 * If the L2 cache is not enough to cover the whole disk then
891 * default to 4KB entries. Smaller entries reduce the cost of
892 * loads and evictions and increase I/O performance.
894 if (*l2_cache_size
< max_l2_cache
&& !l2_cache_entry_size_set
) {
895 *l2_cache_entry_size
= MIN(s
->cluster_size
, 4096);
898 /* l2_cache_size and refcount_cache_size are ensured to have at least
899 * their minimum values in qcow2_update_options_prepare() */
901 if (*l2_cache_entry_size
< (1 << MIN_CLUSTER_BITS
) ||
902 *l2_cache_entry_size
> s
->cluster_size
||
903 !is_power_of_2(*l2_cache_entry_size
)) {
904 error_setg(errp
, "L2 cache entry size must be a power of two "
905 "between %d and the cluster size (%d)",
906 1 << MIN_CLUSTER_BITS
, s
->cluster_size
);
911 typedef struct Qcow2ReopenState
{
912 Qcow2Cache
*l2_table_cache
;
913 Qcow2Cache
*refcount_block_cache
;
914 int l2_slice_size
; /* Number of entries in a slice of the L2 table */
915 bool use_lazy_refcounts
;
917 bool discard_passthrough
[QCOW2_DISCARD_MAX
];
918 uint64_t cache_clean_interval
;
919 QCryptoBlockOpenOptions
*crypto_opts
; /* Disk encryption runtime options */
922 static int qcow2_update_options_prepare(BlockDriverState
*bs
,
924 QDict
*options
, int flags
,
927 BDRVQcow2State
*s
= bs
->opaque
;
928 QemuOpts
*opts
= NULL
;
929 const char *opt_overlap_check
, *opt_overlap_check_template
;
930 int overlap_check_template
= 0;
931 uint64_t l2_cache_size
, l2_cache_entry_size
, refcount_cache_size
;
933 const char *encryptfmt
;
934 QDict
*encryptopts
= NULL
;
935 Error
*local_err
= NULL
;
938 qdict_extract_subqdict(options
, &encryptopts
, "encrypt.");
939 encryptfmt
= qdict_get_try_str(encryptopts
, "format");
941 opts
= qemu_opts_create(&qcow2_runtime_opts
, NULL
, 0, &error_abort
);
942 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
944 error_propagate(errp
, local_err
);
949 /* get L2 table/refcount block cache size from command line options */
950 read_cache_sizes(bs
, opts
, &l2_cache_size
, &l2_cache_entry_size
,
951 &refcount_cache_size
, &local_err
);
953 error_propagate(errp
, local_err
);
958 l2_cache_size
/= l2_cache_entry_size
;
959 if (l2_cache_size
< MIN_L2_CACHE_SIZE
) {
960 l2_cache_size
= MIN_L2_CACHE_SIZE
;
962 if (l2_cache_size
> INT_MAX
) {
963 error_setg(errp
, "L2 cache size too big");
968 refcount_cache_size
/= s
->cluster_size
;
969 if (refcount_cache_size
< MIN_REFCOUNT_CACHE_SIZE
) {
970 refcount_cache_size
= MIN_REFCOUNT_CACHE_SIZE
;
972 if (refcount_cache_size
> INT_MAX
) {
973 error_setg(errp
, "Refcount cache size too big");
978 /* alloc new L2 table/refcount block cache, flush old one */
979 if (s
->l2_table_cache
) {
980 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
982 error_setg_errno(errp
, -ret
, "Failed to flush the L2 table cache");
987 if (s
->refcount_block_cache
) {
988 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
990 error_setg_errno(errp
, -ret
,
991 "Failed to flush the refcount block cache");
996 r
->l2_slice_size
= l2_cache_entry_size
/ sizeof(uint64_t);
997 r
->l2_table_cache
= qcow2_cache_create(bs
, l2_cache_size
,
998 l2_cache_entry_size
);
999 r
->refcount_block_cache
= qcow2_cache_create(bs
, refcount_cache_size
,
1001 if (r
->l2_table_cache
== NULL
|| r
->refcount_block_cache
== NULL
) {
1002 error_setg(errp
, "Could not allocate metadata caches");
1007 /* New interval for cache cleanup timer */
1008 r
->cache_clean_interval
=
1009 qemu_opt_get_number(opts
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
1010 DEFAULT_CACHE_CLEAN_INTERVAL
);
1011 #ifndef CONFIG_LINUX
1012 if (r
->cache_clean_interval
!= 0) {
1013 error_setg(errp
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
1014 " not supported on this host");
1019 if (r
->cache_clean_interval
> UINT_MAX
) {
1020 error_setg(errp
, "Cache clean interval too big");
1025 /* lazy-refcounts; flush if going from enabled to disabled */
1026 r
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
1027 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
1028 if (r
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
1029 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
1030 "qemu 1.1 compatibility level");
1035 if (s
->use_lazy_refcounts
&& !r
->use_lazy_refcounts
) {
1036 ret
= qcow2_mark_clean(bs
);
1038 error_setg_errno(errp
, -ret
, "Failed to disable lazy refcounts");
1043 /* Overlap check options */
1044 opt_overlap_check
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP
);
1045 opt_overlap_check_template
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1046 if (opt_overlap_check_template
&& opt_overlap_check
&&
1047 strcmp(opt_overlap_check_template
, opt_overlap_check
))
1049 error_setg(errp
, "Conflicting values for qcow2 options '"
1050 QCOW2_OPT_OVERLAP
"' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
1051 "' ('%s')", opt_overlap_check
, opt_overlap_check_template
);
1055 if (!opt_overlap_check
) {
1056 opt_overlap_check
= opt_overlap_check_template
?: "cached";
1059 if (!strcmp(opt_overlap_check
, "none")) {
1060 overlap_check_template
= 0;
1061 } else if (!strcmp(opt_overlap_check
, "constant")) {
1062 overlap_check_template
= QCOW2_OL_CONSTANT
;
1063 } else if (!strcmp(opt_overlap_check
, "cached")) {
1064 overlap_check_template
= QCOW2_OL_CACHED
;
1065 } else if (!strcmp(opt_overlap_check
, "all")) {
1066 overlap_check_template
= QCOW2_OL_ALL
;
1068 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
1069 "'overlap-check'. Allowed are any of the following: "
1070 "none, constant, cached, all", opt_overlap_check
);
1075 r
->overlap_check
= 0;
1076 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
1077 /* overlap-check defines a template bitmask, but every flag may be
1078 * overwritten through the associated boolean option */
1080 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
1081 overlap_check_template
& (1 << i
)) << i
;
1084 r
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
1085 r
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
1086 r
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
1087 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
1088 flags
& BDRV_O_UNMAP
);
1089 r
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
1090 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
1091 r
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
1092 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
1094 switch (s
->crypt_method_header
) {
1095 case QCOW_CRYPT_NONE
:
1097 error_setg(errp
, "No encryption in image header, but options "
1098 "specified format '%s'", encryptfmt
);
1104 case QCOW_CRYPT_AES
:
1105 if (encryptfmt
&& !g_str_equal(encryptfmt
, "aes")) {
1107 "Header reported 'aes' encryption format but "
1108 "options specify '%s'", encryptfmt
);
1112 qdict_put_str(encryptopts
, "format", "qcow");
1113 r
->crypto_opts
= block_crypto_open_opts_init(encryptopts
, errp
);
1116 case QCOW_CRYPT_LUKS
:
1117 if (encryptfmt
&& !g_str_equal(encryptfmt
, "luks")) {
1119 "Header reported 'luks' encryption format but "
1120 "options specify '%s'", encryptfmt
);
1124 qdict_put_str(encryptopts
, "format", "luks");
1125 r
->crypto_opts
= block_crypto_open_opts_init(encryptopts
, errp
);
1129 error_setg(errp
, "Unsupported encryption method %d",
1130 s
->crypt_method_header
);
1133 if (s
->crypt_method_header
!= QCOW_CRYPT_NONE
&& !r
->crypto_opts
) {
1140 qobject_unref(encryptopts
);
1141 qemu_opts_del(opts
);
1146 static void qcow2_update_options_commit(BlockDriverState
*bs
,
1147 Qcow2ReopenState
*r
)
1149 BDRVQcow2State
*s
= bs
->opaque
;
1152 if (s
->l2_table_cache
) {
1153 qcow2_cache_destroy(s
->l2_table_cache
);
1155 if (s
->refcount_block_cache
) {
1156 qcow2_cache_destroy(s
->refcount_block_cache
);
1158 s
->l2_table_cache
= r
->l2_table_cache
;
1159 s
->refcount_block_cache
= r
->refcount_block_cache
;
1160 s
->l2_slice_size
= r
->l2_slice_size
;
1162 s
->overlap_check
= r
->overlap_check
;
1163 s
->use_lazy_refcounts
= r
->use_lazy_refcounts
;
1165 for (i
= 0; i
< QCOW2_DISCARD_MAX
; i
++) {
1166 s
->discard_passthrough
[i
] = r
->discard_passthrough
[i
];
1169 if (s
->cache_clean_interval
!= r
->cache_clean_interval
) {
1170 cache_clean_timer_del(bs
);
1171 s
->cache_clean_interval
= r
->cache_clean_interval
;
1172 cache_clean_timer_init(bs
, bdrv_get_aio_context(bs
));
1175 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1176 s
->crypto_opts
= r
->crypto_opts
;
1179 static void qcow2_update_options_abort(BlockDriverState
*bs
,
1180 Qcow2ReopenState
*r
)
1182 if (r
->l2_table_cache
) {
1183 qcow2_cache_destroy(r
->l2_table_cache
);
1185 if (r
->refcount_block_cache
) {
1186 qcow2_cache_destroy(r
->refcount_block_cache
);
1188 qapi_free_QCryptoBlockOpenOptions(r
->crypto_opts
);
1191 static int qcow2_update_options(BlockDriverState
*bs
, QDict
*options
,
1192 int flags
, Error
**errp
)
1194 Qcow2ReopenState r
= {};
1197 ret
= qcow2_update_options_prepare(bs
, &r
, options
, flags
, errp
);
1199 qcow2_update_options_commit(bs
, &r
);
1201 qcow2_update_options_abort(bs
, &r
);
1207 /* Called with s->lock held. */
1208 static int coroutine_fn
qcow2_do_open(BlockDriverState
*bs
, QDict
*options
,
1209 int flags
, Error
**errp
)
1211 BDRVQcow2State
*s
= bs
->opaque
;
1212 unsigned int len
, i
;
1215 Error
*local_err
= NULL
;
1217 uint64_t l1_vm_state_index
;
1218 bool update_header
= false;
1220 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
1222 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
1225 header
.magic
= be32_to_cpu(header
.magic
);
1226 header
.version
= be32_to_cpu(header
.version
);
1227 header
.backing_file_offset
= be64_to_cpu(header
.backing_file_offset
);
1228 header
.backing_file_size
= be32_to_cpu(header
.backing_file_size
);
1229 header
.size
= be64_to_cpu(header
.size
);
1230 header
.cluster_bits
= be32_to_cpu(header
.cluster_bits
);
1231 header
.crypt_method
= be32_to_cpu(header
.crypt_method
);
1232 header
.l1_table_offset
= be64_to_cpu(header
.l1_table_offset
);
1233 header
.l1_size
= be32_to_cpu(header
.l1_size
);
1234 header
.refcount_table_offset
= be64_to_cpu(header
.refcount_table_offset
);
1235 header
.refcount_table_clusters
=
1236 be32_to_cpu(header
.refcount_table_clusters
);
1237 header
.snapshots_offset
= be64_to_cpu(header
.snapshots_offset
);
1238 header
.nb_snapshots
= be32_to_cpu(header
.nb_snapshots
);
1240 if (header
.magic
!= QCOW_MAGIC
) {
1241 error_setg(errp
, "Image is not in qcow2 format");
1245 if (header
.version
< 2 || header
.version
> 3) {
1246 error_setg(errp
, "Unsupported qcow2 version %" PRIu32
, header
.version
);
1251 s
->qcow_version
= header
.version
;
1253 /* Initialise cluster size */
1254 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
1255 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
1256 error_setg(errp
, "Unsupported cluster size: 2^%" PRIu32
,
1257 header
.cluster_bits
);
1262 s
->cluster_bits
= header
.cluster_bits
;
1263 s
->cluster_size
= 1 << s
->cluster_bits
;
1265 /* Initialise version 3 header fields */
1266 if (header
.version
== 2) {
1267 header
.incompatible_features
= 0;
1268 header
.compatible_features
= 0;
1269 header
.autoclear_features
= 0;
1270 header
.refcount_order
= 4;
1271 header
.header_length
= 72;
1273 header
.incompatible_features
=
1274 be64_to_cpu(header
.incompatible_features
);
1275 header
.compatible_features
= be64_to_cpu(header
.compatible_features
);
1276 header
.autoclear_features
= be64_to_cpu(header
.autoclear_features
);
1277 header
.refcount_order
= be32_to_cpu(header
.refcount_order
);
1278 header
.header_length
= be32_to_cpu(header
.header_length
);
1280 if (header
.header_length
< 104) {
1281 error_setg(errp
, "qcow2 header too short");
1287 if (header
.header_length
> s
->cluster_size
) {
1288 error_setg(errp
, "qcow2 header exceeds cluster size");
1293 if (header
.header_length
> sizeof(header
)) {
1294 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
1295 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
1296 ret
= bdrv_pread(bs
->file
, sizeof(header
), s
->unknown_header_fields
,
1297 s
->unknown_header_fields_size
);
1299 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
1305 if (header
.backing_file_offset
> s
->cluster_size
) {
1306 error_setg(errp
, "Invalid backing file offset");
1311 if (header
.backing_file_offset
) {
1312 ext_end
= header
.backing_file_offset
;
1314 ext_end
= 1 << header
.cluster_bits
;
1317 /* Handle feature bits */
1318 s
->incompatible_features
= header
.incompatible_features
;
1319 s
->compatible_features
= header
.compatible_features
;
1320 s
->autoclear_features
= header
.autoclear_features
;
1322 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
1323 void *feature_table
= NULL
;
1324 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
1325 &feature_table
, flags
, NULL
, NULL
);
1326 report_unsupported_feature(errp
, feature_table
,
1327 s
->incompatible_features
&
1328 ~QCOW2_INCOMPAT_MASK
);
1330 g_free(feature_table
);
1334 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
1335 /* Corrupt images may not be written to unless they are being repaired
1337 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
1338 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
1345 /* Check support for various header values */
1346 if (header
.refcount_order
> 6) {
1347 error_setg(errp
, "Reference count entry width too large; may not "
1352 s
->refcount_order
= header
.refcount_order
;
1353 s
->refcount_bits
= 1 << s
->refcount_order
;
1354 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
1355 s
->refcount_max
+= s
->refcount_max
- 1;
1357 s
->crypt_method_header
= header
.crypt_method
;
1358 if (s
->crypt_method_header
) {
1359 if (bdrv_uses_whitelist() &&
1360 s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1362 "Use of AES-CBC encrypted qcow2 images is no longer "
1363 "supported in system emulators");
1364 error_append_hint(errp
,
1365 "You can use 'qemu-img convert' to convert your "
1366 "image to an alternative supported format, such "
1367 "as unencrypted qcow2, or raw with the LUKS "
1368 "format instead.\n");
1373 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1374 s
->crypt_physical_offset
= false;
1376 /* Assuming LUKS and any future crypt methods we
1377 * add will all use physical offsets, due to the
1378 * fact that the alternative is insecure... */
1379 s
->crypt_physical_offset
= true;
1382 bs
->encrypted
= true;
1385 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
1386 s
->l2_size
= 1 << s
->l2_bits
;
1387 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1388 s
->refcount_block_bits
= s
->cluster_bits
- (s
->refcount_order
- 3);
1389 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
1390 bs
->total_sectors
= header
.size
/ BDRV_SECTOR_SIZE
;
1391 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
1392 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
1393 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
1395 s
->refcount_table_offset
= header
.refcount_table_offset
;
1396 s
->refcount_table_size
=
1397 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
1399 if (header
.refcount_table_clusters
== 0 && !(flags
& BDRV_O_CHECK
)) {
1400 error_setg(errp
, "Image does not contain a reference count table");
1405 ret
= qcow2_validate_table(bs
, s
->refcount_table_offset
,
1406 header
.refcount_table_clusters
,
1407 s
->cluster_size
, QCOW_MAX_REFTABLE_SIZE
,
1408 "Reference count table", errp
);
1413 /* The total size in bytes of the snapshot table is checked in
1414 * qcow2_read_snapshots() because the size of each snapshot is
1415 * variable and we don't know it yet.
1416 * Here we only check the offset and number of snapshots. */
1417 ret
= qcow2_validate_table(bs
, header
.snapshots_offset
,
1418 header
.nb_snapshots
,
1419 sizeof(QCowSnapshotHeader
),
1420 sizeof(QCowSnapshotHeader
) * QCOW_MAX_SNAPSHOTS
,
1421 "Snapshot table", errp
);
1426 /* read the level 1 table */
1427 ret
= qcow2_validate_table(bs
, header
.l1_table_offset
,
1428 header
.l1_size
, sizeof(uint64_t),
1429 QCOW_MAX_L1_SIZE
, "Active L1 table", errp
);
1433 s
->l1_size
= header
.l1_size
;
1434 s
->l1_table_offset
= header
.l1_table_offset
;
1436 l1_vm_state_index
= size_to_l1(s
, header
.size
);
1437 if (l1_vm_state_index
> INT_MAX
) {
1438 error_setg(errp
, "Image is too big");
1442 s
->l1_vm_state_index
= l1_vm_state_index
;
1444 /* the L1 table must contain at least enough entries to put
1445 header.size bytes */
1446 if (s
->l1_size
< s
->l1_vm_state_index
) {
1447 error_setg(errp
, "L1 table is too small");
1452 if (s
->l1_size
> 0) {
1453 s
->l1_table
= qemu_try_blockalign(bs
->file
->bs
,
1454 ROUND_UP(s
->l1_size
* sizeof(uint64_t), 512));
1455 if (s
->l1_table
== NULL
) {
1456 error_setg(errp
, "Could not allocate L1 table");
1460 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
1461 s
->l1_size
* sizeof(uint64_t));
1463 error_setg_errno(errp
, -ret
, "Could not read L1 table");
1466 for(i
= 0;i
< s
->l1_size
; i
++) {
1467 s
->l1_table
[i
] = be64_to_cpu(s
->l1_table
[i
]);
1471 /* Parse driver-specific options */
1472 ret
= qcow2_update_options(bs
, options
, flags
, errp
);
1479 ret
= qcow2_refcount_init(bs
);
1481 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
1485 QLIST_INIT(&s
->cluster_allocs
);
1486 QTAILQ_INIT(&s
->discards
);
1488 /* read qcow2 extensions */
1489 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
1490 flags
, &update_header
, &local_err
)) {
1491 error_propagate(errp
, local_err
);
1496 /* Open external data file */
1497 s
->data_file
= bdrv_open_child(NULL
, options
, "data-file", bs
, &child_file
,
1500 error_propagate(errp
, local_err
);
1505 if (s
->incompatible_features
& QCOW2_INCOMPAT_DATA_FILE
) {
1506 if (!s
->data_file
&& s
->image_data_file
) {
1507 s
->data_file
= bdrv_open_child(s
->image_data_file
, options
,
1508 "data-file", bs
, &child_file
,
1510 if (!s
->data_file
) {
1515 if (!s
->data_file
) {
1516 error_setg(errp
, "'data-file' is required for this image");
1522 error_setg(errp
, "'data-file' can only be set for images with an "
1523 "external data file");
1528 s
->data_file
= bs
->file
;
1530 if (data_file_is_raw(bs
)) {
1531 error_setg(errp
, "data-file-raw requires a data file");
1537 /* qcow2_read_extension may have set up the crypto context
1538 * if the crypt method needs a header region, some methods
1539 * don't need header extensions, so must check here
1541 if (s
->crypt_method_header
&& !s
->crypto
) {
1542 if (s
->crypt_method_header
== QCOW_CRYPT_AES
) {
1543 unsigned int cflags
= 0;
1544 if (flags
& BDRV_O_NO_IO
) {
1545 cflags
|= QCRYPTO_BLOCK_OPEN_NO_IO
;
1547 s
->crypto
= qcrypto_block_open(s
->crypto_opts
, "encrypt.",
1549 QCOW2_MAX_THREADS
, errp
);
1554 } else if (!(flags
& BDRV_O_NO_IO
)) {
1555 error_setg(errp
, "Missing CRYPTO header for crypt method %d",
1556 s
->crypt_method_header
);
1562 /* read the backing file name */
1563 if (header
.backing_file_offset
!= 0) {
1564 len
= header
.backing_file_size
;
1565 if (len
> MIN(1023, s
->cluster_size
- header
.backing_file_offset
) ||
1566 len
>= sizeof(bs
->backing_file
)) {
1567 error_setg(errp
, "Backing file name too long");
1571 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
1572 bs
->auto_backing_file
, len
);
1574 error_setg_errno(errp
, -ret
, "Could not read backing file name");
1577 bs
->auto_backing_file
[len
] = '\0';
1578 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
),
1579 bs
->auto_backing_file
);
1580 s
->image_backing_file
= g_strdup(bs
->auto_backing_file
);
1583 /* Internal snapshots */
1584 s
->snapshots_offset
= header
.snapshots_offset
;
1585 s
->nb_snapshots
= header
.nb_snapshots
;
1587 ret
= qcow2_read_snapshots(bs
);
1589 error_setg_errno(errp
, -ret
, "Could not read snapshots");
1593 /* Clear unknown autoclear feature bits */
1594 update_header
|= s
->autoclear_features
& ~QCOW2_AUTOCLEAR_MASK
;
1596 update_header
&& !bs
->read_only
&& !(flags
& BDRV_O_INACTIVE
);
1597 if (update_header
) {
1598 s
->autoclear_features
&= QCOW2_AUTOCLEAR_MASK
;
1601 /* == Handle persistent dirty bitmaps ==
1603 * We want load dirty bitmaps in three cases:
1605 * 1. Normal open of the disk in active mode, not related to invalidation
1608 * 2. Invalidation of the target vm after pre-copy phase of migration, if
1609 * bitmaps are _not_ migrating through migration channel, i.e.
1610 * 'dirty-bitmaps' capability is disabled.
1612 * 3. Invalidation of source vm after failed or canceled migration.
1613 * This is a very interesting case. There are two possible types of
1616 * A. Stored on inactivation and removed. They should be loaded from the
1619 * B. Not stored: not-persistent bitmaps and bitmaps, migrated through
1620 * the migration channel (with dirty-bitmaps capability).
1622 * On the other hand, there are two possible sub-cases:
1624 * 3.1 disk was changed by somebody else while were inactive. In this
1625 * case all in-RAM dirty bitmaps (both persistent and not) are
1626 * definitely invalid. And we don't have any method to determine
1629 * Simple and safe thing is to just drop all the bitmaps of type B on
1630 * inactivation. But in this case we lose bitmaps in valid 4.2 case.
1632 * On the other hand, resuming source vm, if disk was already changed
1633 * is a bad thing anyway: not only bitmaps, the whole vm state is
1634 * out of sync with disk.
1636 * This means, that user or management tool, who for some reason
1637 * decided to resume source vm, after disk was already changed by
1638 * target vm, should at least drop all dirty bitmaps by hand.
1640 * So, we can ignore this case for now, but TODO: "generation"
1641 * extension for qcow2, to determine, that image was changed after
1642 * last inactivation. And if it is changed, we will drop (or at least
1643 * mark as 'invalid' all the bitmaps of type B, both persistent
1646 * 3.2 disk was _not_ changed while were inactive. Bitmaps may be saved
1647 * to disk ('dirty-bitmaps' capability disabled), or not saved
1648 * ('dirty-bitmaps' capability enabled), but we don't need to care
1649 * of: let's load bitmaps as always: stored bitmaps will be loaded,
1650 * and not stored has flag IN_USE=1 in the image and will be skipped
1653 * One remaining possible case when we don't want load bitmaps:
1655 * 4. Open disk in inactive mode in target vm (bitmaps are migrating or
1656 * will be loaded on invalidation, no needs try loading them before)
1659 if (!(bdrv_get_flags(bs
) & BDRV_O_INACTIVE
)) {
1660 /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
1661 bool header_updated
= qcow2_load_dirty_bitmaps(bs
, &local_err
);
1663 update_header
= update_header
&& !header_updated
;
1665 if (local_err
!= NULL
) {
1666 error_propagate(errp
, local_err
);
1671 if (update_header
) {
1672 ret
= qcow2_update_header(bs
);
1674 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
1679 bs
->supported_zero_flags
= header
.version
>= 3 ? BDRV_REQ_MAY_UNMAP
: 0;
1681 /* Repair image if dirty */
1682 if (!(flags
& (BDRV_O_CHECK
| BDRV_O_INACTIVE
)) && !bs
->read_only
&&
1683 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
1684 BdrvCheckResult result
= {0};
1686 ret
= qcow2_co_check_locked(bs
, &result
,
1687 BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1688 if (ret
< 0 || result
.check_errors
) {
1692 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
1699 BdrvCheckResult result
= {0};
1700 qcow2_check_refcounts(bs
, &result
, 0);
1704 qemu_co_queue_init(&s
->thread_task_queue
);
1709 g_free(s
->image_data_file
);
1710 if (has_data_file(bs
)) {
1711 bdrv_unref_child(bs
, s
->data_file
);
1713 g_free(s
->unknown_header_fields
);
1714 cleanup_unknown_header_ext(bs
);
1715 qcow2_free_snapshots(bs
);
1716 qcow2_refcount_close(bs
);
1717 qemu_vfree(s
->l1_table
);
1718 /* else pre-write overlap checks in cache_destroy may crash */
1720 cache_clean_timer_del(bs
);
1721 if (s
->l2_table_cache
) {
1722 qcow2_cache_destroy(s
->l2_table_cache
);
1724 if (s
->refcount_block_cache
) {
1725 qcow2_cache_destroy(s
->refcount_block_cache
);
1727 qcrypto_block_free(s
->crypto
);
1728 qapi_free_QCryptoBlockOpenOptions(s
->crypto_opts
);
1732 typedef struct QCow2OpenCo
{
1733 BlockDriverState
*bs
;
1740 static void coroutine_fn
qcow2_open_entry(void *opaque
)
1742 QCow2OpenCo
*qoc
= opaque
;
1743 BDRVQcow2State
*s
= qoc
->bs
->opaque
;
1745 qemu_co_mutex_lock(&s
->lock
);
1746 qoc
->ret
= qcow2_do_open(qoc
->bs
, qoc
->options
, qoc
->flags
, qoc
->errp
);
1747 qemu_co_mutex_unlock(&s
->lock
);
1750 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1753 BDRVQcow2State
*s
= bs
->opaque
;
1762 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
1768 /* Initialise locks */
1769 qemu_co_mutex_init(&s
->lock
);
1771 if (qemu_in_coroutine()) {
1772 /* From bdrv_co_create. */
1773 qcow2_open_entry(&qoc
);
1775 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
1776 qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry
, &qoc
));
1777 BDRV_POLL_WHILE(bs
, qoc
.ret
== -EINPROGRESS
);
1782 static void qcow2_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
1784 BDRVQcow2State
*s
= bs
->opaque
;
1786 if (bs
->encrypted
) {
1787 /* Encryption works on a sector granularity */
1788 bs
->bl
.request_alignment
= qcrypto_block_get_sector_size(s
->crypto
);
1790 bs
->bl
.pwrite_zeroes_alignment
= s
->cluster_size
;
1791 bs
->bl
.pdiscard_alignment
= s
->cluster_size
;
1794 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
1795 BlockReopenQueue
*queue
, Error
**errp
)
1797 Qcow2ReopenState
*r
;
1800 r
= g_new0(Qcow2ReopenState
, 1);
1803 ret
= qcow2_update_options_prepare(state
->bs
, r
, state
->options
,
1804 state
->flags
, errp
);
1809 /* We need to write out any unwritten data if we reopen read-only. */
1810 if ((state
->flags
& BDRV_O_RDWR
) == 0) {
1811 ret
= qcow2_reopen_bitmaps_ro(state
->bs
, errp
);
1816 ret
= bdrv_flush(state
->bs
);
1821 ret
= qcow2_mark_clean(state
->bs
);
1830 qcow2_update_options_abort(state
->bs
, r
);
1835 static void qcow2_reopen_commit(BDRVReopenState
*state
)
1837 qcow2_update_options_commit(state
->bs
, state
->opaque
);
1838 if (state
->flags
& BDRV_O_RDWR
) {
1839 Error
*local_err
= NULL
;
1841 if (qcow2_reopen_bitmaps_rw(state
->bs
, &local_err
) < 0) {
1843 * This is not fatal, bitmaps just left read-only, so all following
1844 * writes will fail. User can remove read-only bitmaps to unblock
1845 * writes or retry reopen.
1847 error_reportf_err(local_err
,
1848 "%s: Failed to make dirty bitmaps writable: ",
1849 bdrv_get_node_name(state
->bs
));
1852 g_free(state
->opaque
);
1855 static void qcow2_reopen_abort(BDRVReopenState
*state
)
1857 qcow2_update_options_abort(state
->bs
, state
->opaque
);
1858 g_free(state
->opaque
);
1861 static void qcow2_join_options(QDict
*options
, QDict
*old_options
)
1863 bool has_new_overlap_template
=
1864 qdict_haskey(options
, QCOW2_OPT_OVERLAP
) ||
1865 qdict_haskey(options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1866 bool has_new_total_cache_size
=
1867 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
);
1868 bool has_all_cache_options
;
1870 /* New overlap template overrides all old overlap options */
1871 if (has_new_overlap_template
) {
1872 qdict_del(old_options
, QCOW2_OPT_OVERLAP
);
1873 qdict_del(old_options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1874 qdict_del(old_options
, QCOW2_OPT_OVERLAP_MAIN_HEADER
);
1875 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L1
);
1876 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L2
);
1877 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
);
1878 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
);
1879 qdict_del(old_options
, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
);
1880 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L1
);
1881 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L2
);
1884 /* New total cache size overrides all old options */
1885 if (qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
)) {
1886 qdict_del(old_options
, QCOW2_OPT_L2_CACHE_SIZE
);
1887 qdict_del(old_options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1890 qdict_join(options
, old_options
, false);
1893 * If after merging all cache size options are set, an old total size is
1894 * overwritten. Do keep all options, however, if all three are new. The
1895 * resulting error message is what we want to happen.
1897 has_all_cache_options
=
1898 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
) ||
1899 qdict_haskey(options
, QCOW2_OPT_L2_CACHE_SIZE
) ||
1900 qdict_haskey(options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1902 if (has_all_cache_options
&& !has_new_total_cache_size
) {
1903 qdict_del(options
, QCOW2_OPT_CACHE_SIZE
);
1907 static int coroutine_fn
qcow2_co_block_status(BlockDriverState
*bs
,
1909 int64_t offset
, int64_t count
,
1910 int64_t *pnum
, int64_t *map
,
1911 BlockDriverState
**file
)
1913 BDRVQcow2State
*s
= bs
->opaque
;
1914 uint64_t cluster_offset
;
1915 int index_in_cluster
, ret
;
1919 qemu_co_mutex_lock(&s
->lock
);
1921 if (!s
->metadata_preallocation_checked
) {
1922 ret
= qcow2_detect_metadata_preallocation(bs
);
1923 s
->metadata_preallocation
= (ret
== 1);
1924 s
->metadata_preallocation_checked
= true;
1927 bytes
= MIN(INT_MAX
, count
);
1928 ret
= qcow2_get_cluster_offset(bs
, offset
, &bytes
, &cluster_offset
);
1929 qemu_co_mutex_unlock(&s
->lock
);
1936 if ((ret
== QCOW2_CLUSTER_NORMAL
|| ret
== QCOW2_CLUSTER_ZERO_ALLOC
) &&
1938 index_in_cluster
= offset
& (s
->cluster_size
- 1);
1939 *map
= cluster_offset
| index_in_cluster
;
1940 *file
= s
->data_file
->bs
;
1941 status
|= BDRV_BLOCK_OFFSET_VALID
;
1943 if (ret
== QCOW2_CLUSTER_ZERO_PLAIN
|| ret
== QCOW2_CLUSTER_ZERO_ALLOC
) {
1944 status
|= BDRV_BLOCK_ZERO
;
1945 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
1946 status
|= BDRV_BLOCK_DATA
;
1948 if (s
->metadata_preallocation
&& (status
& BDRV_BLOCK_DATA
) &&
1949 (status
& BDRV_BLOCK_OFFSET_VALID
))
1951 status
|= BDRV_BLOCK_RECURSE
;
1956 static coroutine_fn
int qcow2_handle_l2meta(BlockDriverState
*bs
,
1957 QCowL2Meta
**pl2meta
,
1961 QCowL2Meta
*l2meta
= *pl2meta
;
1963 while (l2meta
!= NULL
) {
1967 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
1972 qcow2_alloc_cluster_abort(bs
, l2meta
);
1975 /* Take the request off the list of running requests */
1976 if (l2meta
->nb_clusters
!= 0) {
1977 QLIST_REMOVE(l2meta
, next_in_flight
);
1980 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1982 next
= l2meta
->next
;
1991 static coroutine_fn
int
1992 qcow2_co_preadv_encrypted(BlockDriverState
*bs
,
1993 uint64_t file_cluster_offset
,
1997 uint64_t qiov_offset
)
2000 BDRVQcow2State
*s
= bs
->opaque
;
2003 assert(bs
->encrypted
&& s
->crypto
);
2004 assert(bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2007 * For encrypted images, read everything into a temporary
2008 * contiguous buffer on which the AES functions can work.
2009 * Also, decryption in a separate buffer is better as it
2010 * prevents the guest from learning information about the
2011 * encrypted nature of the virtual disk.
2014 buf
= qemu_try_blockalign(s
->data_file
->bs
, bytes
);
2019 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
2020 ret
= bdrv_co_pread(s
->data_file
,
2021 file_cluster_offset
+ offset_into_cluster(s
, offset
),
2027 assert(QEMU_IS_ALIGNED(offset
, BDRV_SECTOR_SIZE
));
2028 assert(QEMU_IS_ALIGNED(bytes
, BDRV_SECTOR_SIZE
));
2029 if (qcow2_co_decrypt(bs
,
2030 file_cluster_offset
+ offset_into_cluster(s
, offset
),
2031 offset
, buf
, bytes
) < 0)
2036 qemu_iovec_from_buf(qiov
, qiov_offset
, buf
, bytes
);
2044 typedef struct Qcow2AioTask
{
2047 BlockDriverState
*bs
;
2048 QCow2ClusterType cluster_type
; /* only for read */
2049 uint64_t file_cluster_offset
;
2053 uint64_t qiov_offset
;
2054 QCowL2Meta
*l2meta
; /* only for write */
2057 static coroutine_fn
int qcow2_co_preadv_task_entry(AioTask
*task
);
2058 static coroutine_fn
int qcow2_add_task(BlockDriverState
*bs
,
2061 QCow2ClusterType cluster_type
,
2062 uint64_t file_cluster_offset
,
2069 Qcow2AioTask local_task
;
2070 Qcow2AioTask
*task
= pool
? g_new(Qcow2AioTask
, 1) : &local_task
;
2072 *task
= (Qcow2AioTask
) {
2075 .cluster_type
= cluster_type
,
2077 .file_cluster_offset
= file_cluster_offset
,
2080 .qiov_offset
= qiov_offset
,
2084 trace_qcow2_add_task(qemu_coroutine_self(), bs
, pool
,
2085 func
== qcow2_co_preadv_task_entry
? "read" : "write",
2086 cluster_type
, file_cluster_offset
, offset
, bytes
,
2090 return func(&task
->task
);
2093 aio_task_pool_start_task(pool
, &task
->task
);
2098 static coroutine_fn
int qcow2_co_preadv_task(BlockDriverState
*bs
,
2099 QCow2ClusterType cluster_type
,
2100 uint64_t file_cluster_offset
,
2101 uint64_t offset
, uint64_t bytes
,
2105 BDRVQcow2State
*s
= bs
->opaque
;
2106 int offset_in_cluster
= offset_into_cluster(s
, offset
);
2108 switch (cluster_type
) {
2109 case QCOW2_CLUSTER_ZERO_PLAIN
:
2110 case QCOW2_CLUSTER_ZERO_ALLOC
:
2111 /* Both zero types are handled in qcow2_co_preadv_part */
2112 g_assert_not_reached();
2114 case QCOW2_CLUSTER_UNALLOCATED
:
2115 assert(bs
->backing
); /* otherwise handled in qcow2_co_preadv_part */
2117 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
2118 return bdrv_co_preadv_part(bs
->backing
, offset
, bytes
,
2119 qiov
, qiov_offset
, 0);
2121 case QCOW2_CLUSTER_COMPRESSED
:
2122 return qcow2_co_preadv_compressed(bs
, file_cluster_offset
,
2123 offset
, bytes
, qiov
, qiov_offset
);
2125 case QCOW2_CLUSTER_NORMAL
:
2126 if ((file_cluster_offset
& 511) != 0) {
2130 if (bs
->encrypted
) {
2131 return qcow2_co_preadv_encrypted(bs
, file_cluster_offset
,
2132 offset
, bytes
, qiov
, qiov_offset
);
2135 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
2136 return bdrv_co_preadv_part(s
->data_file
,
2137 file_cluster_offset
+ offset_in_cluster
,
2138 bytes
, qiov
, qiov_offset
, 0);
2141 g_assert_not_reached();
2144 g_assert_not_reached();
2147 static coroutine_fn
int qcow2_co_preadv_task_entry(AioTask
*task
)
2149 Qcow2AioTask
*t
= container_of(task
, Qcow2AioTask
, task
);
2153 return qcow2_co_preadv_task(t
->bs
, t
->cluster_type
, t
->file_cluster_offset
,
2154 t
->offset
, t
->bytes
, t
->qiov
, t
->qiov_offset
);
2157 static coroutine_fn
int qcow2_co_preadv_part(BlockDriverState
*bs
,
2158 uint64_t offset
, uint64_t bytes
,
2160 size_t qiov_offset
, int flags
)
2162 BDRVQcow2State
*s
= bs
->opaque
;
2164 unsigned int cur_bytes
; /* number of bytes in current iteration */
2165 uint64_t cluster_offset
= 0;
2166 AioTaskPool
*aio
= NULL
;
2168 while (bytes
!= 0 && aio_task_pool_status(aio
) == 0) {
2169 /* prepare next request */
2170 cur_bytes
= MIN(bytes
, INT_MAX
);
2172 cur_bytes
= MIN(cur_bytes
,
2173 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2176 qemu_co_mutex_lock(&s
->lock
);
2177 ret
= qcow2_get_cluster_offset(bs
, offset
, &cur_bytes
, &cluster_offset
);
2178 qemu_co_mutex_unlock(&s
->lock
);
2183 if (ret
== QCOW2_CLUSTER_ZERO_PLAIN
||
2184 ret
== QCOW2_CLUSTER_ZERO_ALLOC
||
2185 (ret
== QCOW2_CLUSTER_UNALLOCATED
&& !bs
->backing
))
2187 qemu_iovec_memset(qiov
, qiov_offset
, 0, cur_bytes
);
2189 if (!aio
&& cur_bytes
!= bytes
) {
2190 aio
= aio_task_pool_new(QCOW2_MAX_WORKERS
);
2192 ret
= qcow2_add_task(bs
, aio
, qcow2_co_preadv_task_entry
, ret
,
2193 cluster_offset
, offset
, cur_bytes
,
2194 qiov
, qiov_offset
, NULL
);
2201 offset
+= cur_bytes
;
2202 qiov_offset
+= cur_bytes
;
2207 aio_task_pool_wait_all(aio
);
2209 ret
= aio_task_pool_status(aio
);
2217 /* Check if it's possible to merge a write request with the writing of
2218 * the data from the COW regions */
2219 static bool merge_cow(uint64_t offset
, unsigned bytes
,
2220 QEMUIOVector
*qiov
, size_t qiov_offset
,
2225 for (m
= l2meta
; m
!= NULL
; m
= m
->next
) {
2226 /* If both COW regions are empty then there's nothing to merge */
2227 if (m
->cow_start
.nb_bytes
== 0 && m
->cow_end
.nb_bytes
== 0) {
2231 /* If COW regions are handled already, skip this too */
2236 /* The data (middle) region must be immediately after the
2238 if (l2meta_cow_start(m
) + m
->cow_start
.nb_bytes
!= offset
) {
2242 /* The end region must be immediately after the data (middle)
2244 if (m
->offset
+ m
->cow_end
.offset
!= offset
+ bytes
) {
2248 /* Make sure that adding both COW regions to the QEMUIOVector
2249 * does not exceed IOV_MAX */
2250 if (qemu_iovec_subvec_niov(qiov
, qiov_offset
, bytes
) > IOV_MAX
- 2) {
2254 m
->data_qiov
= qiov
;
2255 m
->data_qiov_offset
= qiov_offset
;
2262 static bool is_unallocated(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
2266 (!bdrv_is_allocated_above(bs
, NULL
, false, offset
, bytes
, &nr
) &&
2270 static bool is_zero_cow(BlockDriverState
*bs
, QCowL2Meta
*m
)
2273 * This check is designed for optimization shortcut so it must be
2275 * Instead of is_zero(), use is_unallocated() as it is faster (but not
2276 * as accurate and can result in false negatives).
2278 return is_unallocated(bs
, m
->offset
+ m
->cow_start
.offset
,
2279 m
->cow_start
.nb_bytes
) &&
2280 is_unallocated(bs
, m
->offset
+ m
->cow_end
.offset
,
2281 m
->cow_end
.nb_bytes
);
2284 static int handle_alloc_space(BlockDriverState
*bs
, QCowL2Meta
*l2meta
)
2286 BDRVQcow2State
*s
= bs
->opaque
;
2289 if (!(s
->data_file
->bs
->supported_zero_flags
& BDRV_REQ_NO_FALLBACK
)) {
2293 if (bs
->encrypted
) {
2297 for (m
= l2meta
; m
!= NULL
; m
= m
->next
) {
2300 if (!m
->cow_start
.nb_bytes
&& !m
->cow_end
.nb_bytes
) {
2304 if (!is_zero_cow(bs
, m
)) {
2309 * instead of writing zero COW buffers,
2310 * efficiently zero out the whole clusters
2313 ret
= qcow2_pre_write_overlap_check(bs
, 0, m
->alloc_offset
,
2314 m
->nb_clusters
* s
->cluster_size
,
2320 BLKDBG_EVENT(bs
->file
, BLKDBG_CLUSTER_ALLOC_SPACE
);
2321 ret
= bdrv_co_pwrite_zeroes(s
->data_file
, m
->alloc_offset
,
2322 m
->nb_clusters
* s
->cluster_size
,
2323 BDRV_REQ_NO_FALLBACK
);
2325 if (ret
!= -ENOTSUP
&& ret
!= -EAGAIN
) {
2331 trace_qcow2_skip_cow(qemu_coroutine_self(), m
->offset
, m
->nb_clusters
);
2338 * qcow2_co_pwritev_task
2339 * Called with s->lock unlocked
2340 * l2meta - if not NULL, qcow2_co_pwritev_task() will consume it. Caller must
2341 * not use it somehow after qcow2_co_pwritev_task() call
2343 static coroutine_fn
int qcow2_co_pwritev_task(BlockDriverState
*bs
,
2344 uint64_t file_cluster_offset
,
2345 uint64_t offset
, uint64_t bytes
,
2347 uint64_t qiov_offset
,
2351 BDRVQcow2State
*s
= bs
->opaque
;
2352 void *crypt_buf
= NULL
;
2353 int offset_in_cluster
= offset_into_cluster(s
, offset
);
2354 QEMUIOVector encrypted_qiov
;
2356 if (bs
->encrypted
) {
2358 assert(bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
2359 crypt_buf
= qemu_try_blockalign(bs
->file
->bs
, bytes
);
2360 if (crypt_buf
== NULL
) {
2364 qemu_iovec_to_buf(qiov
, qiov_offset
, crypt_buf
, bytes
);
2366 if (qcow2_co_encrypt(bs
, file_cluster_offset
+ offset_in_cluster
,
2367 offset
, crypt_buf
, bytes
) < 0)
2373 qemu_iovec_init_buf(&encrypted_qiov
, crypt_buf
, bytes
);
2374 qiov
= &encrypted_qiov
;
2378 /* Try to efficiently initialize the physical space with zeroes */
2379 ret
= handle_alloc_space(bs
, l2meta
);
2385 * If we need to do COW, check if it's possible to merge the
2386 * writing of the guest data together with that of the COW regions.
2387 * If it's not possible (or not necessary) then write the
2390 if (!merge_cow(offset
, bytes
, qiov
, qiov_offset
, l2meta
)) {
2391 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
2392 trace_qcow2_writev_data(qemu_coroutine_self(),
2393 file_cluster_offset
+ offset_in_cluster
);
2394 ret
= bdrv_co_pwritev_part(s
->data_file
,
2395 file_cluster_offset
+ offset_in_cluster
,
2396 bytes
, qiov
, qiov_offset
, 0);
2402 qemu_co_mutex_lock(&s
->lock
);
2404 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
2408 qemu_co_mutex_lock(&s
->lock
);
2411 qcow2_handle_l2meta(bs
, &l2meta
, false);
2412 qemu_co_mutex_unlock(&s
->lock
);
2414 qemu_vfree(crypt_buf
);
2419 static coroutine_fn
int qcow2_co_pwritev_task_entry(AioTask
*task
)
2421 Qcow2AioTask
*t
= container_of(task
, Qcow2AioTask
, task
);
2423 assert(!t
->cluster_type
);
2425 return qcow2_co_pwritev_task(t
->bs
, t
->file_cluster_offset
,
2426 t
->offset
, t
->bytes
, t
->qiov
, t
->qiov_offset
,
2430 static coroutine_fn
int qcow2_co_pwritev_part(
2431 BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
2432 QEMUIOVector
*qiov
, size_t qiov_offset
, int flags
)
2434 BDRVQcow2State
*s
= bs
->opaque
;
2435 int offset_in_cluster
;
2437 unsigned int cur_bytes
; /* number of sectors in current iteration */
2438 uint64_t cluster_offset
;
2439 QCowL2Meta
*l2meta
= NULL
;
2440 AioTaskPool
*aio
= NULL
;
2442 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset
, bytes
);
2444 while (bytes
!= 0 && aio_task_pool_status(aio
) == 0) {
2448 trace_qcow2_writev_start_part(qemu_coroutine_self());
2449 offset_in_cluster
= offset_into_cluster(s
, offset
);
2450 cur_bytes
= MIN(bytes
, INT_MAX
);
2451 if (bs
->encrypted
) {
2452 cur_bytes
= MIN(cur_bytes
,
2453 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
2454 - offset_in_cluster
);
2457 qemu_co_mutex_lock(&s
->lock
);
2459 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2460 &cluster_offset
, &l2meta
);
2465 assert((cluster_offset
& 511) == 0);
2467 ret
= qcow2_pre_write_overlap_check(bs
, 0,
2468 cluster_offset
+ offset_in_cluster
,
2474 qemu_co_mutex_unlock(&s
->lock
);
2476 if (!aio
&& cur_bytes
!= bytes
) {
2477 aio
= aio_task_pool_new(QCOW2_MAX_WORKERS
);
2479 ret
= qcow2_add_task(bs
, aio
, qcow2_co_pwritev_task_entry
, 0,
2480 cluster_offset
, offset
, cur_bytes
,
2481 qiov
, qiov_offset
, l2meta
);
2482 l2meta
= NULL
; /* l2meta is consumed by qcow2_co_pwritev_task() */
2488 offset
+= cur_bytes
;
2489 qiov_offset
+= cur_bytes
;
2490 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes
);
2494 qemu_co_mutex_lock(&s
->lock
);
2497 qcow2_handle_l2meta(bs
, &l2meta
, false);
2499 qemu_co_mutex_unlock(&s
->lock
);
2503 aio_task_pool_wait_all(aio
);
2505 ret
= aio_task_pool_status(aio
);
2510 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
2515 static int qcow2_inactivate(BlockDriverState
*bs
)
2517 BDRVQcow2State
*s
= bs
->opaque
;
2518 int ret
, result
= 0;
2519 Error
*local_err
= NULL
;
2521 qcow2_store_persistent_dirty_bitmaps(bs
, true, &local_err
);
2522 if (local_err
!= NULL
) {
2524 error_reportf_err(local_err
, "Lost persistent bitmaps during "
2525 "inactivation of node '%s': ",
2526 bdrv_get_device_or_node_name(bs
));
2529 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
2532 error_report("Failed to flush the L2 table cache: %s",
2536 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
2539 error_report("Failed to flush the refcount block cache: %s",
2544 qcow2_mark_clean(bs
);
2550 static void qcow2_close(BlockDriverState
*bs
)
2552 BDRVQcow2State
*s
= bs
->opaque
;
2553 qemu_vfree(s
->l1_table
);
2554 /* else pre-write overlap checks in cache_destroy may crash */
2557 if (!(s
->flags
& BDRV_O_INACTIVE
)) {
2558 qcow2_inactivate(bs
);
2561 cache_clean_timer_del(bs
);
2562 qcow2_cache_destroy(s
->l2_table_cache
);
2563 qcow2_cache_destroy(s
->refcount_block_cache
);
2565 qcrypto_block_free(s
->crypto
);
2568 g_free(s
->unknown_header_fields
);
2569 cleanup_unknown_header_ext(bs
);
2571 g_free(s
->image_data_file
);
2572 g_free(s
->image_backing_file
);
2573 g_free(s
->image_backing_format
);
2575 if (has_data_file(bs
)) {
2576 bdrv_unref_child(bs
, s
->data_file
);
2579 qcow2_refcount_close(bs
);
2580 qcow2_free_snapshots(bs
);
2583 static void coroutine_fn
qcow2_co_invalidate_cache(BlockDriverState
*bs
,
2586 BDRVQcow2State
*s
= bs
->opaque
;
2587 int flags
= s
->flags
;
2588 QCryptoBlock
*crypto
= NULL
;
2590 Error
*local_err
= NULL
;
2594 * Backing files are read-only which makes all of their metadata immutable,
2595 * that means we don't have to worry about reopening them here.
2603 memset(s
, 0, sizeof(BDRVQcow2State
));
2604 options
= qdict_clone_shallow(bs
->options
);
2606 flags
&= ~BDRV_O_INACTIVE
;
2607 qemu_co_mutex_lock(&s
->lock
);
2608 ret
= qcow2_do_open(bs
, options
, flags
, &local_err
);
2609 qemu_co_mutex_unlock(&s
->lock
);
2610 qobject_unref(options
);
2612 error_propagate_prepend(errp
, local_err
,
2613 "Could not reopen qcow2 layer: ");
2616 } else if (ret
< 0) {
2617 error_setg_errno(errp
, -ret
, "Could not reopen qcow2 layer");
2625 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
2626 size_t len
, size_t buflen
)
2628 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
2629 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
2631 if (buflen
< ext_len
) {
2635 *ext_backing_fmt
= (QCowExtension
) {
2636 .magic
= cpu_to_be32(magic
),
2637 .len
= cpu_to_be32(len
),
2641 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
2648 * Updates the qcow2 header, including the variable length parts of it, i.e.
2649 * the backing file name and all extensions. qcow2 was not designed to allow
2650 * such changes, so if we run out of space (we can only use the first cluster)
2651 * this function may fail.
2653 * Returns 0 on success, -errno in error cases.
2655 int qcow2_update_header(BlockDriverState
*bs
)
2657 BDRVQcow2State
*s
= bs
->opaque
;
2660 size_t buflen
= s
->cluster_size
;
2662 uint64_t total_size
;
2663 uint32_t refcount_table_clusters
;
2664 size_t header_length
;
2665 Qcow2UnknownHeaderExtension
*uext
;
2667 buf
= qemu_blockalign(bs
, buflen
);
2669 /* Header structure */
2670 header
= (QCowHeader
*) buf
;
2672 if (buflen
< sizeof(*header
)) {
2677 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
2678 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2679 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
2681 *header
= (QCowHeader
) {
2682 /* Version 2 fields */
2683 .magic
= cpu_to_be32(QCOW_MAGIC
),
2684 .version
= cpu_to_be32(s
->qcow_version
),
2685 .backing_file_offset
= 0,
2686 .backing_file_size
= 0,
2687 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
2688 .size
= cpu_to_be64(total_size
),
2689 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
2690 .l1_size
= cpu_to_be32(s
->l1_size
),
2691 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
2692 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
2693 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
2694 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
2695 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
2697 /* Version 3 fields */
2698 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
2699 .compatible_features
= cpu_to_be64(s
->compatible_features
),
2700 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
2701 .refcount_order
= cpu_to_be32(s
->refcount_order
),
2702 .header_length
= cpu_to_be32(header_length
),
2705 /* For older versions, write a shorter header */
2706 switch (s
->qcow_version
) {
2708 ret
= offsetof(QCowHeader
, incompatible_features
);
2711 ret
= sizeof(*header
);
2720 memset(buf
, 0, buflen
);
2722 /* Preserve any unknown field in the header */
2723 if (s
->unknown_header_fields_size
) {
2724 if (buflen
< s
->unknown_header_fields_size
) {
2729 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
2730 buf
+= s
->unknown_header_fields_size
;
2731 buflen
-= s
->unknown_header_fields_size
;
2734 /* Backing file format header extension */
2735 if (s
->image_backing_format
) {
2736 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
2737 s
->image_backing_format
,
2738 strlen(s
->image_backing_format
),
2748 /* External data file header extension */
2749 if (has_data_file(bs
) && s
->image_data_file
) {
2750 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_DATA_FILE
,
2751 s
->image_data_file
, strlen(s
->image_data_file
),
2761 /* Full disk encryption header pointer extension */
2762 if (s
->crypto_header
.offset
!= 0) {
2763 s
->crypto_header
.offset
= cpu_to_be64(s
->crypto_header
.offset
);
2764 s
->crypto_header
.length
= cpu_to_be64(s
->crypto_header
.length
);
2765 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_CRYPTO_HEADER
,
2766 &s
->crypto_header
, sizeof(s
->crypto_header
),
2768 s
->crypto_header
.offset
= be64_to_cpu(s
->crypto_header
.offset
);
2769 s
->crypto_header
.length
= be64_to_cpu(s
->crypto_header
.length
);
2778 if (s
->qcow_version
>= 3) {
2779 Qcow2Feature features
[] = {
2781 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2782 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
2783 .name
= "dirty bit",
2786 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2787 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
2788 .name
= "corrupt bit",
2791 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
2792 .bit
= QCOW2_INCOMPAT_DATA_FILE_BITNR
,
2793 .name
= "external data file",
2796 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
2797 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
2798 .name
= "lazy refcounts",
2802 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
2803 features
, sizeof(features
), buflen
);
2811 /* Bitmap extension */
2812 if (s
->nb_bitmaps
> 0) {
2813 Qcow2BitmapHeaderExt bitmaps_header
= {
2814 .nb_bitmaps
= cpu_to_be32(s
->nb_bitmaps
),
2815 .bitmap_directory_size
=
2816 cpu_to_be64(s
->bitmap_directory_size
),
2817 .bitmap_directory_offset
=
2818 cpu_to_be64(s
->bitmap_directory_offset
)
2820 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BITMAPS
,
2821 &bitmaps_header
, sizeof(bitmaps_header
),
2830 /* Keep unknown header extensions */
2831 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
2832 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
2841 /* End of header extensions */
2842 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
2850 /* Backing file name */
2851 if (s
->image_backing_file
) {
2852 size_t backing_file_len
= strlen(s
->image_backing_file
);
2854 if (buflen
< backing_file_len
) {
2859 /* Using strncpy is ok here, since buf is not NUL-terminated. */
2860 strncpy(buf
, s
->image_backing_file
, buflen
);
2862 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
2863 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
2866 /* Write the new header */
2867 ret
= bdrv_pwrite(bs
->file
, 0, header
, s
->cluster_size
);
2878 static int qcow2_change_backing_file(BlockDriverState
*bs
,
2879 const char *backing_file
, const char *backing_fmt
)
2881 BDRVQcow2State
*s
= bs
->opaque
;
2883 /* Adding a backing file means that the external data file alone won't be
2884 * enough to make sense of the content */
2885 if (backing_file
&& data_file_is_raw(bs
)) {
2889 if (backing_file
&& strlen(backing_file
) > 1023) {
2893 pstrcpy(bs
->auto_backing_file
, sizeof(bs
->auto_backing_file
),
2894 backing_file
?: "");
2895 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2896 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2898 g_free(s
->image_backing_file
);
2899 g_free(s
->image_backing_format
);
2901 s
->image_backing_file
= backing_file
? g_strdup(bs
->backing_file
) : NULL
;
2902 s
->image_backing_format
= backing_fmt
? g_strdup(bs
->backing_format
) : NULL
;
2904 return qcow2_update_header(bs
);
2907 static int qcow2_crypt_method_from_format(const char *encryptfmt
)
2909 if (g_str_equal(encryptfmt
, "luks")) {
2910 return QCOW_CRYPT_LUKS
;
2911 } else if (g_str_equal(encryptfmt
, "aes")) {
2912 return QCOW_CRYPT_AES
;
2918 static int qcow2_set_up_encryption(BlockDriverState
*bs
,
2919 QCryptoBlockCreateOptions
*cryptoopts
,
2922 BDRVQcow2State
*s
= bs
->opaque
;
2923 QCryptoBlock
*crypto
= NULL
;
2926 switch (cryptoopts
->format
) {
2927 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
2928 fmt
= QCOW_CRYPT_LUKS
;
2930 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
2931 fmt
= QCOW_CRYPT_AES
;
2934 error_setg(errp
, "Crypto format not supported in qcow2");
2938 s
->crypt_method_header
= fmt
;
2940 crypto
= qcrypto_block_create(cryptoopts
, "encrypt.",
2941 qcow2_crypto_hdr_init_func
,
2942 qcow2_crypto_hdr_write_func
,
2948 ret
= qcow2_update_header(bs
);
2950 error_setg_errno(errp
, -ret
, "Could not write encryption header");
2956 qcrypto_block_free(crypto
);
2961 * Preallocates metadata structures for data clusters between @offset (in the
2962 * guest disk) and @new_length (which is thus generally the new guest disk
2965 * Returns: 0 on success, -errno on failure.
2967 static int coroutine_fn
preallocate_co(BlockDriverState
*bs
, uint64_t offset
,
2968 uint64_t new_length
, PreallocMode mode
,
2971 BDRVQcow2State
*s
= bs
->opaque
;
2973 uint64_t host_offset
= 0;
2974 int64_t file_length
;
2975 unsigned int cur_bytes
;
2979 assert(offset
<= new_length
);
2980 bytes
= new_length
- offset
;
2983 cur_bytes
= MIN(bytes
, QEMU_ALIGN_DOWN(INT_MAX
, s
->cluster_size
));
2984 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2985 &host_offset
, &meta
);
2987 error_setg_errno(errp
, -ret
, "Allocating clusters failed");
2992 QCowL2Meta
*next
= meta
->next
;
2994 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
2996 error_setg_errno(errp
, -ret
, "Mapping clusters failed");
2997 qcow2_free_any_clusters(bs
, meta
->alloc_offset
,
2998 meta
->nb_clusters
, QCOW2_DISCARD_NEVER
);
3002 /* There are no dependent requests, but we need to remove our
3003 * request from the list of in-flight requests */
3004 QLIST_REMOVE(meta
, next_in_flight
);
3010 /* TODO Preallocate data if requested */
3013 offset
+= cur_bytes
;
3017 * It is expected that the image file is large enough to actually contain
3018 * all of the allocated clusters (otherwise we get failing reads after
3019 * EOF). Extend the image to the last allocated sector.
3021 file_length
= bdrv_getlength(s
->data_file
->bs
);
3022 if (file_length
< 0) {
3023 error_setg_errno(errp
, -file_length
, "Could not get file size");
3027 if (host_offset
+ cur_bytes
> file_length
) {
3028 if (mode
== PREALLOC_MODE_METADATA
) {
3029 mode
= PREALLOC_MODE_OFF
;
3031 ret
= bdrv_co_truncate(s
->data_file
, host_offset
+ cur_bytes
, mode
,
3041 /* qcow2_refcount_metadata_size:
3042 * @clusters: number of clusters to refcount (including data and L1/L2 tables)
3043 * @cluster_size: size of a cluster, in bytes
3044 * @refcount_order: refcount bits power-of-2 exponent
3045 * @generous_increase: allow for the refcount table to be 1.5x as large as it
3048 * Returns: Number of bytes required for refcount blocks and table metadata.
3050 int64_t qcow2_refcount_metadata_size(int64_t clusters
, size_t cluster_size
,
3051 int refcount_order
, bool generous_increase
,
3052 uint64_t *refblock_count
)
3055 * Every host cluster is reference-counted, including metadata (even
3056 * refcount metadata is recursively included).
3058 * An accurate formula for the size of refcount metadata size is difficult
3059 * to derive. An easier method of calculation is finding the fixed point
3060 * where no further refcount blocks or table clusters are required to
3061 * reference count every cluster.
3063 int64_t blocks_per_table_cluster
= cluster_size
/ sizeof(uint64_t);
3064 int64_t refcounts_per_block
= cluster_size
* 8 / (1 << refcount_order
);
3065 int64_t table
= 0; /* number of refcount table clusters */
3066 int64_t blocks
= 0; /* number of refcount block clusters */
3072 blocks
= DIV_ROUND_UP(clusters
+ table
+ blocks
, refcounts_per_block
);
3073 table
= DIV_ROUND_UP(blocks
, blocks_per_table_cluster
);
3074 n
= clusters
+ blocks
+ table
;
3076 if (n
== last
&& generous_increase
) {
3077 clusters
+= DIV_ROUND_UP(table
, 2);
3078 n
= 0; /* force another loop */
3079 generous_increase
= false;
3081 } while (n
!= last
);
3083 if (refblock_count
) {
3084 *refblock_count
= blocks
;
3087 return (blocks
+ table
) * cluster_size
;
3091 * qcow2_calc_prealloc_size:
3092 * @total_size: virtual disk size in bytes
3093 * @cluster_size: cluster size in bytes
3094 * @refcount_order: refcount bits power-of-2 exponent
3096 * Returns: Total number of bytes required for the fully allocated image
3097 * (including metadata).
3099 static int64_t qcow2_calc_prealloc_size(int64_t total_size
,
3100 size_t cluster_size
,
3103 int64_t meta_size
= 0;
3104 uint64_t nl1e
, nl2e
;
3105 int64_t aligned_total_size
= ROUND_UP(total_size
, cluster_size
);
3107 /* header: 1 cluster */
3108 meta_size
+= cluster_size
;
3110 /* total size of L2 tables */
3111 nl2e
= aligned_total_size
/ cluster_size
;
3112 nl2e
= ROUND_UP(nl2e
, cluster_size
/ sizeof(uint64_t));
3113 meta_size
+= nl2e
* sizeof(uint64_t);
3115 /* total size of L1 tables */
3116 nl1e
= nl2e
* sizeof(uint64_t) / cluster_size
;
3117 nl1e
= ROUND_UP(nl1e
, cluster_size
/ sizeof(uint64_t));
3118 meta_size
+= nl1e
* sizeof(uint64_t);
3120 /* total size of refcount table and blocks */
3121 meta_size
+= qcow2_refcount_metadata_size(
3122 (meta_size
+ aligned_total_size
) / cluster_size
,
3123 cluster_size
, refcount_order
, false, NULL
);
3125 return meta_size
+ aligned_total_size
;
3128 static bool validate_cluster_size(size_t cluster_size
, Error
**errp
)
3130 int cluster_bits
= ctz32(cluster_size
);
3131 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
3132 (1 << cluster_bits
) != cluster_size
)
3134 error_setg(errp
, "Cluster size must be a power of two between %d and "
3135 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
3141 static size_t qcow2_opt_get_cluster_size_del(QemuOpts
*opts
, Error
**errp
)
3143 size_t cluster_size
;
3145 cluster_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
3146 DEFAULT_CLUSTER_SIZE
);
3147 if (!validate_cluster_size(cluster_size
, errp
)) {
3150 return cluster_size
;
3153 static int qcow2_opt_get_version_del(QemuOpts
*opts
, Error
**errp
)
3158 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_COMPAT_LEVEL
);
3160 ret
= 3; /* default */
3161 } else if (!strcmp(buf
, "0.10")) {
3163 } else if (!strcmp(buf
, "1.1")) {
3166 error_setg(errp
, "Invalid compatibility level: '%s'", buf
);
3173 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts
*opts
, int version
,
3176 uint64_t refcount_bits
;
3178 refcount_bits
= qemu_opt_get_number_del(opts
, BLOCK_OPT_REFCOUNT_BITS
, 16);
3179 if (refcount_bits
> 64 || !is_power_of_2(refcount_bits
)) {
3180 error_setg(errp
, "Refcount width must be a power of two and may not "
3185 if (version
< 3 && refcount_bits
!= 16) {
3186 error_setg(errp
, "Different refcount widths than 16 bits require "
3187 "compatibility level 1.1 or above (use compat=1.1 or "
3192 return refcount_bits
;
3195 static int coroutine_fn
3196 qcow2_co_create(BlockdevCreateOptions
*create_options
, Error
**errp
)
3198 BlockdevCreateOptionsQcow2
*qcow2_opts
;
3202 * Open the image file and write a minimal qcow2 header.
3204 * We keep things simple and start with a zero-sized image. We also
3205 * do without refcount blocks or a L1 table for now. We'll fix the
3206 * inconsistency later.
3208 * We do need a refcount table because growing the refcount table means
3209 * allocating two new refcount blocks - the seconds of which would be at
3210 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
3211 * size for any qcow2 image.
3213 BlockBackend
*blk
= NULL
;
3214 BlockDriverState
*bs
= NULL
;
3215 BlockDriverState
*data_bs
= NULL
;
3217 size_t cluster_size
;
3220 uint64_t* refcount_table
;
3221 Error
*local_err
= NULL
;
3224 assert(create_options
->driver
== BLOCKDEV_DRIVER_QCOW2
);
3225 qcow2_opts
= &create_options
->u
.qcow2
;
3227 bs
= bdrv_open_blockdev_ref(qcow2_opts
->file
, errp
);
3232 /* Validate options and set default values */
3233 if (!QEMU_IS_ALIGNED(qcow2_opts
->size
, BDRV_SECTOR_SIZE
)) {
3234 error_setg(errp
, "Image size must be a multiple of 512 bytes");
3239 if (qcow2_opts
->has_version
) {
3240 switch (qcow2_opts
->version
) {
3241 case BLOCKDEV_QCOW2_VERSION_V2
:
3244 case BLOCKDEV_QCOW2_VERSION_V3
:
3248 g_assert_not_reached();
3254 if (qcow2_opts
->has_cluster_size
) {
3255 cluster_size
= qcow2_opts
->cluster_size
;
3257 cluster_size
= DEFAULT_CLUSTER_SIZE
;
3260 if (!validate_cluster_size(cluster_size
, errp
)) {
3265 if (!qcow2_opts
->has_preallocation
) {
3266 qcow2_opts
->preallocation
= PREALLOC_MODE_OFF
;
3268 if (qcow2_opts
->has_backing_file
&&
3269 qcow2_opts
->preallocation
!= PREALLOC_MODE_OFF
)
3271 error_setg(errp
, "Backing file and preallocation cannot be used at "
3276 if (qcow2_opts
->has_backing_fmt
&& !qcow2_opts
->has_backing_file
) {
3277 error_setg(errp
, "Backing format cannot be used without backing file");
3282 if (!qcow2_opts
->has_lazy_refcounts
) {
3283 qcow2_opts
->lazy_refcounts
= false;
3285 if (version
< 3 && qcow2_opts
->lazy_refcounts
) {
3286 error_setg(errp
, "Lazy refcounts only supported with compatibility "
3287 "level 1.1 and above (use version=v3 or greater)");
3292 if (!qcow2_opts
->has_refcount_bits
) {
3293 qcow2_opts
->refcount_bits
= 16;
3295 if (qcow2_opts
->refcount_bits
> 64 ||
3296 !is_power_of_2(qcow2_opts
->refcount_bits
))
3298 error_setg(errp
, "Refcount width must be a power of two and may not "
3303 if (version
< 3 && qcow2_opts
->refcount_bits
!= 16) {
3304 error_setg(errp
, "Different refcount widths than 16 bits require "
3305 "compatibility level 1.1 or above (use version=v3 or "
3310 refcount_order
= ctz32(qcow2_opts
->refcount_bits
);
3312 if (qcow2_opts
->data_file_raw
&& !qcow2_opts
->data_file
) {
3313 error_setg(errp
, "data-file-raw requires data-file");
3317 if (qcow2_opts
->data_file_raw
&& qcow2_opts
->has_backing_file
) {
3318 error_setg(errp
, "Backing file and data-file-raw cannot be used at "
3324 if (qcow2_opts
->data_file
) {
3326 error_setg(errp
, "External data files are only supported with "
3327 "compatibility level 1.1 and above (use version=v3 or "
3332 data_bs
= bdrv_open_blockdev_ref(qcow2_opts
->data_file
, errp
);
3333 if (data_bs
== NULL
) {
3339 /* Create BlockBackend to write to the image */
3340 blk
= blk_new(bdrv_get_aio_context(bs
),
3341 BLK_PERM_WRITE
| BLK_PERM_RESIZE
, BLK_PERM_ALL
);
3342 ret
= blk_insert_bs(blk
, bs
, errp
);
3346 blk_set_allow_write_beyond_eof(blk
, true);
3348 /* Clear the protocol layer and preallocate it if necessary */
3349 ret
= blk_truncate(blk
, 0, PREALLOC_MODE_OFF
, errp
);
3354 /* Write the header */
3355 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS
) < sizeof(*header
));
3356 header
= g_malloc0(cluster_size
);
3357 *header
= (QCowHeader
) {
3358 .magic
= cpu_to_be32(QCOW_MAGIC
),
3359 .version
= cpu_to_be32(version
),
3360 .cluster_bits
= cpu_to_be32(ctz32(cluster_size
)),
3361 .size
= cpu_to_be64(0),
3362 .l1_table_offset
= cpu_to_be64(0),
3363 .l1_size
= cpu_to_be32(0),
3364 .refcount_table_offset
= cpu_to_be64(cluster_size
),
3365 .refcount_table_clusters
= cpu_to_be32(1),
3366 .refcount_order
= cpu_to_be32(refcount_order
),
3367 .header_length
= cpu_to_be32(sizeof(*header
)),
3370 /* We'll update this to correct value later */
3371 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
3373 if (qcow2_opts
->lazy_refcounts
) {
3374 header
->compatible_features
|=
3375 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
3378 header
->incompatible_features
|=
3379 cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE
);
3381 if (qcow2_opts
->data_file_raw
) {
3382 header
->autoclear_features
|=
3383 cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW
);
3386 ret
= blk_pwrite(blk
, 0, header
, cluster_size
, 0);
3389 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
3393 /* Write a refcount table with one refcount block */
3394 refcount_table
= g_malloc0(2 * cluster_size
);
3395 refcount_table
[0] = cpu_to_be64(2 * cluster_size
);
3396 ret
= blk_pwrite(blk
, cluster_size
, refcount_table
, 2 * cluster_size
, 0);
3397 g_free(refcount_table
);
3400 error_setg_errno(errp
, -ret
, "Could not write refcount table");
3408 * And now open the image and make it consistent first (i.e. increase the
3409 * refcount of the cluster that is occupied by the header and the refcount
3412 options
= qdict_new();
3413 qdict_put_str(options
, "driver", "qcow2");
3414 qdict_put_str(options
, "file", bs
->node_name
);
3416 qdict_put_str(options
, "data-file", data_bs
->node_name
);
3418 blk
= blk_new_open(NULL
, NULL
, options
,
3419 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_NO_FLUSH
,
3422 error_propagate(errp
, local_err
);
3427 ret
= qcow2_alloc_clusters(blk_bs(blk
), 3 * cluster_size
);
3429 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
3430 "header and refcount table");
3433 } else if (ret
!= 0) {
3434 error_report("Huh, first cluster in empty image is already in use?");
3438 /* Set the external data file if necessary */
3440 BDRVQcow2State
*s
= blk_bs(blk
)->opaque
;
3441 s
->image_data_file
= g_strdup(data_bs
->filename
);
3444 /* Create a full header (including things like feature table) */
3445 ret
= qcow2_update_header(blk_bs(blk
));
3447 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
3451 /* Okay, now that we have a valid image, let's give it the right size */
3452 ret
= blk_truncate(blk
, qcow2_opts
->size
, qcow2_opts
->preallocation
, errp
);
3454 error_prepend(errp
, "Could not resize image: ");
3458 /* Want a backing file? There you go.*/
3459 if (qcow2_opts
->has_backing_file
) {
3460 const char *backing_format
= NULL
;
3462 if (qcow2_opts
->has_backing_fmt
) {
3463 backing_format
= BlockdevDriver_str(qcow2_opts
->backing_fmt
);
3466 ret
= bdrv_change_backing_file(blk_bs(blk
), qcow2_opts
->backing_file
,
3469 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
3470 "with format '%s'", qcow2_opts
->backing_file
,
3476 /* Want encryption? There you go. */
3477 if (qcow2_opts
->has_encrypt
) {
3478 ret
= qcow2_set_up_encryption(blk_bs(blk
), qcow2_opts
->encrypt
, errp
);
3487 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
3488 * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
3489 * have to setup decryption context. We're not doing any I/O on the top
3490 * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
3493 options
= qdict_new();
3494 qdict_put_str(options
, "driver", "qcow2");
3495 qdict_put_str(options
, "file", bs
->node_name
);
3497 qdict_put_str(options
, "data-file", data_bs
->node_name
);
3499 blk
= blk_new_open(NULL
, NULL
, options
,
3500 BDRV_O_RDWR
| BDRV_O_NO_BACKING
| BDRV_O_NO_IO
,
3503 error_propagate(errp
, local_err
);
3512 bdrv_unref(data_bs
);
3516 static int coroutine_fn
qcow2_co_create_opts(const char *filename
, QemuOpts
*opts
,
3519 BlockdevCreateOptions
*create_options
= NULL
;
3522 BlockDriverState
*bs
= NULL
;
3523 BlockDriverState
*data_bs
= NULL
;
3524 Error
*local_err
= NULL
;
3528 /* Only the keyval visitor supports the dotted syntax needed for
3529 * encryption, so go through a QDict before getting a QAPI type. Ignore
3530 * options meant for the protocol layer so that the visitor doesn't
3532 qdict
= qemu_opts_to_qdict_filtered(opts
, NULL
, bdrv_qcow2
.create_opts
,
3535 /* Handle encryption options */
3536 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT
);
3537 if (val
&& !strcmp(val
, "on")) {
3538 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT
, "qcow");
3539 } else if (val
&& !strcmp(val
, "off")) {
3540 qdict_del(qdict
, BLOCK_OPT_ENCRYPT
);
3543 val
= qdict_get_try_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
);
3544 if (val
&& !strcmp(val
, "aes")) {
3545 qdict_put_str(qdict
, BLOCK_OPT_ENCRYPT_FORMAT
, "qcow");
3548 /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into
3549 * version=v2/v3 below. */
3550 val
= qdict_get_try_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
);
3551 if (val
&& !strcmp(val
, "0.10")) {
3552 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v2");
3553 } else if (val
&& !strcmp(val
, "1.1")) {
3554 qdict_put_str(qdict
, BLOCK_OPT_COMPAT_LEVEL
, "v3");
3557 /* Change legacy command line options into QMP ones */
3558 static const QDictRenames opt_renames
[] = {
3559 { BLOCK_OPT_BACKING_FILE
, "backing-file" },
3560 { BLOCK_OPT_BACKING_FMT
, "backing-fmt" },
3561 { BLOCK_OPT_CLUSTER_SIZE
, "cluster-size" },
3562 { BLOCK_OPT_LAZY_REFCOUNTS
, "lazy-refcounts" },
3563 { BLOCK_OPT_REFCOUNT_BITS
, "refcount-bits" },
3564 { BLOCK_OPT_ENCRYPT
, BLOCK_OPT_ENCRYPT_FORMAT
},
3565 { BLOCK_OPT_COMPAT_LEVEL
, "version" },
3566 { BLOCK_OPT_DATA_FILE_RAW
, "data-file-raw" },
3570 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
3575 /* Create and open the file (protocol layer) */
3576 ret
= bdrv_create_file(filename
, opts
, errp
);
3581 bs
= bdrv_open(filename
, NULL
, NULL
,
3582 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
, errp
);
3588 /* Create and open an external data file (protocol layer) */
3589 val
= qdict_get_try_str(qdict
, BLOCK_OPT_DATA_FILE
);
3591 ret
= bdrv_create_file(val
, opts
, errp
);
3596 data_bs
= bdrv_open(val
, NULL
, NULL
,
3597 BDRV_O_RDWR
| BDRV_O_RESIZE
| BDRV_O_PROTOCOL
,
3599 if (data_bs
== NULL
) {
3604 qdict_del(qdict
, BLOCK_OPT_DATA_FILE
);
3605 qdict_put_str(qdict
, "data-file", data_bs
->node_name
);
3608 /* Set 'driver' and 'node' options */
3609 qdict_put_str(qdict
, "driver", "qcow2");
3610 qdict_put_str(qdict
, "file", bs
->node_name
);
3612 /* Now get the QAPI type BlockdevCreateOptions */
3613 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
3619 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, &local_err
);
3623 error_propagate(errp
, local_err
);
3628 /* Silently round up size */
3629 create_options
->u
.qcow2
.size
= ROUND_UP(create_options
->u
.qcow2
.size
,
3632 /* Create the qcow2 image (format layer) */
3633 ret
= qcow2_co_create(create_options
, errp
);
3640 qobject_unref(qdict
);
3642 bdrv_unref(data_bs
);
3643 qapi_free_BlockdevCreateOptions(create_options
);
3648 static bool is_zero(BlockDriverState
*bs
, int64_t offset
, int64_t bytes
)
3653 /* Clamp to image length, before checking status of underlying sectors */
3654 if (offset
+ bytes
> bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3655 bytes
= bs
->total_sectors
* BDRV_SECTOR_SIZE
- offset
;
3661 res
= bdrv_block_status_above(bs
, NULL
, offset
, bytes
, &nr
, NULL
, NULL
);
3662 return res
>= 0 && (res
& BDRV_BLOCK_ZERO
) && nr
== bytes
;
3665 static coroutine_fn
int qcow2_co_pwrite_zeroes(BlockDriverState
*bs
,
3666 int64_t offset
, int bytes
, BdrvRequestFlags flags
)
3669 BDRVQcow2State
*s
= bs
->opaque
;
3671 uint32_t head
= offset
% s
->cluster_size
;
3672 uint32_t tail
= (offset
+ bytes
) % s
->cluster_size
;
3674 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset
, bytes
);
3675 if (offset
+ bytes
== bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3683 assert(head
+ bytes
<= s
->cluster_size
);
3685 /* check whether remainder of cluster already reads as zero */
3686 if (!(is_zero(bs
, offset
- head
, head
) &&
3687 is_zero(bs
, offset
+ bytes
,
3688 tail
? s
->cluster_size
- tail
: 0))) {
3692 qemu_co_mutex_lock(&s
->lock
);
3693 /* We can have new write after previous check */
3694 offset
= QEMU_ALIGN_DOWN(offset
, s
->cluster_size
);
3695 bytes
= s
->cluster_size
;
3696 nr
= s
->cluster_size
;
3697 ret
= qcow2_get_cluster_offset(bs
, offset
, &nr
, &off
);
3698 if (ret
!= QCOW2_CLUSTER_UNALLOCATED
&&
3699 ret
!= QCOW2_CLUSTER_ZERO_PLAIN
&&
3700 ret
!= QCOW2_CLUSTER_ZERO_ALLOC
) {
3701 qemu_co_mutex_unlock(&s
->lock
);
3705 qemu_co_mutex_lock(&s
->lock
);
3708 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset
, bytes
);
3710 /* Whatever is left can use real zero clusters */
3711 ret
= qcow2_cluster_zeroize(bs
, offset
, bytes
, flags
);
3712 qemu_co_mutex_unlock(&s
->lock
);
3717 static coroutine_fn
int qcow2_co_pdiscard(BlockDriverState
*bs
,
3718 int64_t offset
, int bytes
)
3721 BDRVQcow2State
*s
= bs
->opaque
;
3723 if (!QEMU_IS_ALIGNED(offset
| bytes
, s
->cluster_size
)) {
3724 assert(bytes
< s
->cluster_size
);
3725 /* Ignore partial clusters, except for the special case of the
3726 * complete partial cluster at the end of an unaligned file */
3727 if (!QEMU_IS_ALIGNED(offset
, s
->cluster_size
) ||
3728 offset
+ bytes
!= bs
->total_sectors
* BDRV_SECTOR_SIZE
) {
3733 qemu_co_mutex_lock(&s
->lock
);
3734 ret
= qcow2_cluster_discard(bs
, offset
, bytes
, QCOW2_DISCARD_REQUEST
,
3736 qemu_co_mutex_unlock(&s
->lock
);
3740 static int coroutine_fn
3741 qcow2_co_copy_range_from(BlockDriverState
*bs
,
3742 BdrvChild
*src
, uint64_t src_offset
,
3743 BdrvChild
*dst
, uint64_t dst_offset
,
3744 uint64_t bytes
, BdrvRequestFlags read_flags
,
3745 BdrvRequestFlags write_flags
)
3747 BDRVQcow2State
*s
= bs
->opaque
;
3749 unsigned int cur_bytes
; /* number of bytes in current iteration */
3750 BdrvChild
*child
= NULL
;
3751 BdrvRequestFlags cur_write_flags
;
3753 assert(!bs
->encrypted
);
3754 qemu_co_mutex_lock(&s
->lock
);
3756 while (bytes
!= 0) {
3757 uint64_t copy_offset
= 0;
3758 /* prepare next request */
3759 cur_bytes
= MIN(bytes
, INT_MAX
);
3760 cur_write_flags
= write_flags
;
3762 ret
= qcow2_get_cluster_offset(bs
, src_offset
, &cur_bytes
, ©_offset
);
3768 case QCOW2_CLUSTER_UNALLOCATED
:
3769 if (bs
->backing
&& bs
->backing
->bs
) {
3770 int64_t backing_length
= bdrv_getlength(bs
->backing
->bs
);
3771 if (src_offset
>= backing_length
) {
3772 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
3774 child
= bs
->backing
;
3775 cur_bytes
= MIN(cur_bytes
, backing_length
- src_offset
);
3776 copy_offset
= src_offset
;
3779 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
3783 case QCOW2_CLUSTER_ZERO_PLAIN
:
3784 case QCOW2_CLUSTER_ZERO_ALLOC
:
3785 cur_write_flags
|= BDRV_REQ_ZERO_WRITE
;
3788 case QCOW2_CLUSTER_COMPRESSED
:
3792 case QCOW2_CLUSTER_NORMAL
:
3793 child
= s
->data_file
;
3794 copy_offset
+= offset_into_cluster(s
, src_offset
);
3795 if ((copy_offset
& 511) != 0) {
3804 qemu_co_mutex_unlock(&s
->lock
);
3805 ret
= bdrv_co_copy_range_from(child
,
3808 cur_bytes
, read_flags
, cur_write_flags
);
3809 qemu_co_mutex_lock(&s
->lock
);
3815 src_offset
+= cur_bytes
;
3816 dst_offset
+= cur_bytes
;
3821 qemu_co_mutex_unlock(&s
->lock
);
3825 static int coroutine_fn
3826 qcow2_co_copy_range_to(BlockDriverState
*bs
,
3827 BdrvChild
*src
, uint64_t src_offset
,
3828 BdrvChild
*dst
, uint64_t dst_offset
,
3829 uint64_t bytes
, BdrvRequestFlags read_flags
,
3830 BdrvRequestFlags write_flags
)
3832 BDRVQcow2State
*s
= bs
->opaque
;
3833 int offset_in_cluster
;
3835 unsigned int cur_bytes
; /* number of sectors in current iteration */
3836 uint64_t cluster_offset
;
3837 QCowL2Meta
*l2meta
= NULL
;
3839 assert(!bs
->encrypted
);
3841 qemu_co_mutex_lock(&s
->lock
);
3843 while (bytes
!= 0) {
3847 offset_in_cluster
= offset_into_cluster(s
, dst_offset
);
3848 cur_bytes
= MIN(bytes
, INT_MAX
);
3851 * If src->bs == dst->bs, we could simply copy by incrementing
3852 * the refcnt, without copying user data.
3853 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
3854 ret
= qcow2_alloc_cluster_offset(bs
, dst_offset
, &cur_bytes
,
3855 &cluster_offset
, &l2meta
);
3860 assert((cluster_offset
& 511) == 0);
3862 ret
= qcow2_pre_write_overlap_check(bs
, 0,
3863 cluster_offset
+ offset_in_cluster
, cur_bytes
, true);
3868 qemu_co_mutex_unlock(&s
->lock
);
3869 ret
= bdrv_co_copy_range_to(src
, src_offset
,
3871 cluster_offset
+ offset_in_cluster
,
3872 cur_bytes
, read_flags
, write_flags
);
3873 qemu_co_mutex_lock(&s
->lock
);
3878 ret
= qcow2_handle_l2meta(bs
, &l2meta
, true);
3884 src_offset
+= cur_bytes
;
3885 dst_offset
+= cur_bytes
;
3890 qcow2_handle_l2meta(bs
, &l2meta
, false);
3892 qemu_co_mutex_unlock(&s
->lock
);
3894 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
3899 static int coroutine_fn
qcow2_co_truncate(BlockDriverState
*bs
, int64_t offset
,
3900 PreallocMode prealloc
, Error
**errp
)
3902 BDRVQcow2State
*s
= bs
->opaque
;
3903 uint64_t old_length
;
3904 int64_t new_l1_size
;
3908 if (prealloc
!= PREALLOC_MODE_OFF
&& prealloc
!= PREALLOC_MODE_METADATA
&&
3909 prealloc
!= PREALLOC_MODE_FALLOC
&& prealloc
!= PREALLOC_MODE_FULL
)
3911 error_setg(errp
, "Unsupported preallocation mode '%s'",
3912 PreallocMode_str(prealloc
));
3917 error_setg(errp
, "The new size must be a multiple of 512");
3921 qemu_co_mutex_lock(&s
->lock
);
3923 /* cannot proceed if image has snapshots */
3924 if (s
->nb_snapshots
) {
3925 error_setg(errp
, "Can't resize an image which has snapshots");
3930 /* cannot proceed if image has bitmaps */
3931 if (qcow2_truncate_bitmaps_check(bs
, errp
)) {
3936 old_length
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3937 new_l1_size
= size_to_l1(s
, offset
);
3939 if (offset
< old_length
) {
3940 int64_t last_cluster
, old_file_size
;
3941 if (prealloc
!= PREALLOC_MODE_OFF
) {
3943 "Preallocation can't be used for shrinking an image");
3948 ret
= qcow2_cluster_discard(bs
, ROUND_UP(offset
, s
->cluster_size
),
3949 old_length
- ROUND_UP(offset
,
3951 QCOW2_DISCARD_ALWAYS
, true);
3953 error_setg_errno(errp
, -ret
, "Failed to discard cropped clusters");
3957 ret
= qcow2_shrink_l1_table(bs
, new_l1_size
);
3959 error_setg_errno(errp
, -ret
,
3960 "Failed to reduce the number of L2 tables");
3964 ret
= qcow2_shrink_reftable(bs
);
3966 error_setg_errno(errp
, -ret
,
3967 "Failed to discard unused refblocks");
3971 old_file_size
= bdrv_getlength(bs
->file
->bs
);
3972 if (old_file_size
< 0) {
3973 error_setg_errno(errp
, -old_file_size
,
3974 "Failed to inquire current file length");
3975 ret
= old_file_size
;
3978 last_cluster
= qcow2_get_last_cluster(bs
, old_file_size
);
3979 if (last_cluster
< 0) {
3980 error_setg_errno(errp
, -last_cluster
,
3981 "Failed to find the last cluster");
3985 if ((last_cluster
+ 1) * s
->cluster_size
< old_file_size
) {
3986 Error
*local_err
= NULL
;
3988 bdrv_co_truncate(bs
->file
, (last_cluster
+ 1) * s
->cluster_size
,
3989 PREALLOC_MODE_OFF
, &local_err
);
3991 warn_reportf_err(local_err
,
3992 "Failed to truncate the tail of the image: ");
3996 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
3998 error_setg_errno(errp
, -ret
, "Failed to grow the L1 table");
4004 case PREALLOC_MODE_OFF
:
4005 if (has_data_file(bs
)) {
4006 ret
= bdrv_co_truncate(s
->data_file
, offset
, prealloc
, errp
);
4013 case PREALLOC_MODE_METADATA
:
4014 ret
= preallocate_co(bs
, old_length
, offset
, prealloc
, errp
);
4020 case PREALLOC_MODE_FALLOC
:
4021 case PREALLOC_MODE_FULL
:
4023 int64_t allocation_start
, host_offset
, guest_offset
;
4024 int64_t clusters_allocated
;
4025 int64_t old_file_size
, new_file_size
;
4026 uint64_t nb_new_data_clusters
, nb_new_l2_tables
;
4028 /* With a data file, preallocation means just allocating the metadata
4029 * and forwarding the truncate request to the data file */
4030 if (has_data_file(bs
)) {
4031 ret
= preallocate_co(bs
, old_length
, offset
, prealloc
, errp
);
4038 old_file_size
= bdrv_getlength(bs
->file
->bs
);
4039 if (old_file_size
< 0) {
4040 error_setg_errno(errp
, -old_file_size
,
4041 "Failed to inquire current file length");
4042 ret
= old_file_size
;
4045 old_file_size
= ROUND_UP(old_file_size
, s
->cluster_size
);
4047 nb_new_data_clusters
= DIV_ROUND_UP(offset
- old_length
,
4050 /* This is an overestimation; we will not actually allocate space for
4051 * these in the file but just make sure the new refcount structures are
4052 * able to cover them so we will not have to allocate new refblocks
4053 * while entering the data blocks in the potentially new L2 tables.
4054 * (We do not actually care where the L2 tables are placed. Maybe they
4055 * are already allocated or they can be placed somewhere before
4056 * @old_file_size. It does not matter because they will be fully
4057 * allocated automatically, so they do not need to be covered by the
4058 * preallocation. All that matters is that we will not have to allocate
4059 * new refcount structures for them.) */
4060 nb_new_l2_tables
= DIV_ROUND_UP(nb_new_data_clusters
,
4061 s
->cluster_size
/ sizeof(uint64_t));
4062 /* The cluster range may not be aligned to L2 boundaries, so add one L2
4063 * table for a potential head/tail */
4066 allocation_start
= qcow2_refcount_area(bs
, old_file_size
,
4067 nb_new_data_clusters
+
4070 if (allocation_start
< 0) {
4071 error_setg_errno(errp
, -allocation_start
,
4072 "Failed to resize refcount structures");
4073 ret
= allocation_start
;
4077 clusters_allocated
= qcow2_alloc_clusters_at(bs
, allocation_start
,
4078 nb_new_data_clusters
);
4079 if (clusters_allocated
< 0) {
4080 error_setg_errno(errp
, -clusters_allocated
,
4081 "Failed to allocate data clusters");
4082 ret
= clusters_allocated
;
4086 assert(clusters_allocated
== nb_new_data_clusters
);
4088 /* Allocate the data area */
4089 new_file_size
= allocation_start
+
4090 nb_new_data_clusters
* s
->cluster_size
;
4091 ret
= bdrv_co_truncate(bs
->file
, new_file_size
, prealloc
, errp
);
4093 error_prepend(errp
, "Failed to resize underlying file: ");
4094 qcow2_free_clusters(bs
, allocation_start
,
4095 nb_new_data_clusters
* s
->cluster_size
,
4096 QCOW2_DISCARD_OTHER
);
4100 /* Create the necessary L2 entries */
4101 host_offset
= allocation_start
;
4102 guest_offset
= old_length
;
4103 while (nb_new_data_clusters
) {
4104 int64_t nb_clusters
= MIN(
4105 nb_new_data_clusters
,
4106 s
->l2_slice_size
- offset_to_l2_slice_index(s
, guest_offset
));
4107 QCowL2Meta allocation
= {
4108 .offset
= guest_offset
,
4109 .alloc_offset
= host_offset
,
4110 .nb_clusters
= nb_clusters
,
4112 qemu_co_queue_init(&allocation
.dependent_requests
);
4114 ret
= qcow2_alloc_cluster_link_l2(bs
, &allocation
);
4116 error_setg_errno(errp
, -ret
, "Failed to update L2 tables");
4117 qcow2_free_clusters(bs
, host_offset
,
4118 nb_new_data_clusters
* s
->cluster_size
,
4119 QCOW2_DISCARD_OTHER
);
4123 guest_offset
+= nb_clusters
* s
->cluster_size
;
4124 host_offset
+= nb_clusters
* s
->cluster_size
;
4125 nb_new_data_clusters
-= nb_clusters
;
4131 g_assert_not_reached();
4134 if (prealloc
!= PREALLOC_MODE_OFF
) {
4135 /* Flush metadata before actually changing the image size */
4136 ret
= qcow2_write_caches(bs
);
4138 error_setg_errno(errp
, -ret
,
4139 "Failed to flush the preallocated area to disk");
4144 bs
->total_sectors
= offset
/ BDRV_SECTOR_SIZE
;
4146 /* write updated header.size */
4147 offset
= cpu_to_be64(offset
);
4148 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
4149 &offset
, sizeof(uint64_t));
4151 error_setg_errno(errp
, -ret
, "Failed to update the image size");
4155 s
->l1_vm_state_index
= new_l1_size
;
4157 /* Update cache sizes */
4158 options
= qdict_clone_shallow(bs
->options
);
4159 ret
= qcow2_update_options(bs
, options
, s
->flags
, errp
);
4160 qobject_unref(options
);
4166 qemu_co_mutex_unlock(&s
->lock
);
4170 /* XXX: put compressed sectors first, then all the cluster aligned
4171 tables to avoid losing bytes in alignment */
4172 static coroutine_fn
int
4173 qcow2_co_pwritev_compressed_part(BlockDriverState
*bs
,
4174 uint64_t offset
, uint64_t bytes
,
4175 QEMUIOVector
*qiov
, size_t qiov_offset
)
4177 BDRVQcow2State
*s
= bs
->opaque
;
4180 uint8_t *buf
, *out_buf
;
4181 uint64_t cluster_offset
;
4183 if (has_data_file(bs
)) {
4188 /* align end of file to a sector boundary to ease reading with
4189 sector based I/Os */
4190 int64_t len
= bdrv_getlength(bs
->file
->bs
);
4194 return bdrv_co_truncate(bs
->file
, len
, PREALLOC_MODE_OFF
, NULL
);
4197 if (offset_into_cluster(s
, offset
)) {
4201 buf
= qemu_blockalign(bs
, s
->cluster_size
);
4202 if (bytes
!= s
->cluster_size
) {
4203 if (bytes
> s
->cluster_size
||
4204 offset
+ bytes
!= bs
->total_sectors
<< BDRV_SECTOR_BITS
)
4209 /* Zero-pad last write if image size is not cluster aligned */
4210 memset(buf
+ bytes
, 0, s
->cluster_size
- bytes
);
4212 qemu_iovec_to_buf(qiov
, qiov_offset
, buf
, bytes
);
4214 out_buf
= g_malloc(s
->cluster_size
);
4216 out_len
= qcow2_co_compress(bs
, out_buf
, s
->cluster_size
- 1,
4217 buf
, s
->cluster_size
);
4218 if (out_len
== -ENOMEM
) {
4219 /* could not compress: write normal cluster */
4220 ret
= qcow2_co_pwritev_part(bs
, offset
, bytes
, qiov
, qiov_offset
, 0);
4225 } else if (out_len
< 0) {
4230 qemu_co_mutex_lock(&s
->lock
);
4231 ret
= qcow2_alloc_compressed_cluster_offset(bs
, offset
, out_len
,
4234 qemu_co_mutex_unlock(&s
->lock
);
4238 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
, true);
4239 qemu_co_mutex_unlock(&s
->lock
);
4244 BLKDBG_EVENT(s
->data_file
, BLKDBG_WRITE_COMPRESSED
);
4245 ret
= bdrv_co_pwrite(s
->data_file
, cluster_offset
, out_len
, out_buf
, 0);
4257 static int coroutine_fn
4258 qcow2_co_preadv_compressed(BlockDriverState
*bs
,
4259 uint64_t file_cluster_offset
,
4265 BDRVQcow2State
*s
= bs
->opaque
;
4266 int ret
= 0, csize
, nb_csectors
;
4268 uint8_t *buf
, *out_buf
;
4269 int offset_in_cluster
= offset_into_cluster(s
, offset
);
4271 coffset
= file_cluster_offset
& s
->cluster_offset_mask
;
4272 nb_csectors
= ((file_cluster_offset
>> s
->csize_shift
) & s
->csize_mask
) + 1;
4273 csize
= nb_csectors
* QCOW2_COMPRESSED_SECTOR_SIZE
-
4274 (coffset
& ~QCOW2_COMPRESSED_SECTOR_MASK
);
4276 buf
= g_try_malloc(csize
);
4281 out_buf
= qemu_blockalign(bs
, s
->cluster_size
);
4283 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_COMPRESSED
);
4284 ret
= bdrv_co_pread(bs
->file
, coffset
, csize
, buf
, 0);
4289 if (qcow2_co_decompress(bs
, out_buf
, s
->cluster_size
, buf
, csize
) < 0) {
4294 qemu_iovec_from_buf(qiov
, qiov_offset
, out_buf
+ offset_in_cluster
, bytes
);
4297 qemu_vfree(out_buf
);
4303 static int make_completely_empty(BlockDriverState
*bs
)
4305 BDRVQcow2State
*s
= bs
->opaque
;
4306 Error
*local_err
= NULL
;
4307 int ret
, l1_clusters
;
4309 uint64_t *new_reftable
= NULL
;
4310 uint64_t rt_entry
, l1_size2
;
4313 uint64_t reftable_offset
;
4314 uint32_t reftable_clusters
;
4315 } QEMU_PACKED l1_ofs_rt_ofs_cls
;
4317 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
4322 ret
= qcow2_cache_empty(bs
, s
->refcount_block_cache
);
4327 /* Refcounts will be broken utterly */
4328 ret
= qcow2_mark_dirty(bs
);
4333 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
4335 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
4336 l1_size2
= (uint64_t)s
->l1_size
* sizeof(uint64_t);
4338 /* After this call, neither the in-memory nor the on-disk refcount
4339 * information accurately describe the actual references */
4341 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->l1_table_offset
,
4342 l1_clusters
* s
->cluster_size
, 0);
4344 goto fail_broken_refcounts
;
4346 memset(s
->l1_table
, 0, l1_size2
);
4348 BLKDBG_EVENT(bs
->file
, BLKDBG_EMPTY_IMAGE_PREPARE
);
4350 /* Overwrite enough clusters at the beginning of the sectors to place
4351 * the refcount table, a refcount block and the L1 table in; this may
4352 * overwrite parts of the existing refcount and L1 table, which is not
4353 * an issue because the dirty flag is set, complete data loss is in fact
4354 * desired and partial data loss is consequently fine as well */
4355 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->cluster_size
,
4356 (2 + l1_clusters
) * s
->cluster_size
, 0);
4357 /* This call (even if it failed overall) may have overwritten on-disk
4358 * refcount structures; in that case, the in-memory refcount information
4359 * will probably differ from the on-disk information which makes the BDS
4362 goto fail_broken_refcounts
;
4365 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
4366 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_UPDATE
);
4368 /* "Create" an empty reftable (one cluster) directly after the image
4369 * header and an empty L1 table three clusters after the image header;
4370 * the cluster between those two will be used as the first refblock */
4371 l1_ofs_rt_ofs_cls
.l1_offset
= cpu_to_be64(3 * s
->cluster_size
);
4372 l1_ofs_rt_ofs_cls
.reftable_offset
= cpu_to_be64(s
->cluster_size
);
4373 l1_ofs_rt_ofs_cls
.reftable_clusters
= cpu_to_be32(1);
4374 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, l1_table_offset
),
4375 &l1_ofs_rt_ofs_cls
, sizeof(l1_ofs_rt_ofs_cls
));
4377 goto fail_broken_refcounts
;
4380 s
->l1_table_offset
= 3 * s
->cluster_size
;
4382 new_reftable
= g_try_new0(uint64_t, s
->cluster_size
/ sizeof(uint64_t));
4383 if (!new_reftable
) {
4385 goto fail_broken_refcounts
;
4388 s
->refcount_table_offset
= s
->cluster_size
;
4389 s
->refcount_table_size
= s
->cluster_size
/ sizeof(uint64_t);
4390 s
->max_refcount_table_index
= 0;
4392 g_free(s
->refcount_table
);
4393 s
->refcount_table
= new_reftable
;
4394 new_reftable
= NULL
;
4396 /* Now the in-memory refcount information again corresponds to the on-disk
4397 * information (reftable is empty and no refblocks (the refblock cache is
4398 * empty)); however, this means some clusters (e.g. the image header) are
4399 * referenced, but not refcounted, but the normal qcow2 code assumes that
4400 * the in-memory information is always correct */
4402 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
4404 /* Enter the first refblock into the reftable */
4405 rt_entry
= cpu_to_be64(2 * s
->cluster_size
);
4406 ret
= bdrv_pwrite_sync(bs
->file
, s
->cluster_size
,
4407 &rt_entry
, sizeof(rt_entry
));
4409 goto fail_broken_refcounts
;
4411 s
->refcount_table
[0] = 2 * s
->cluster_size
;
4413 s
->free_cluster_index
= 0;
4414 assert(3 + l1_clusters
<= s
->refcount_block_size
);
4415 offset
= qcow2_alloc_clusters(bs
, 3 * s
->cluster_size
+ l1_size2
);
4418 goto fail_broken_refcounts
;
4419 } else if (offset
> 0) {
4420 error_report("First cluster in emptied image is in use");
4424 /* Now finally the in-memory information corresponds to the on-disk
4425 * structures and is correct */
4426 ret
= qcow2_mark_clean(bs
);
4431 ret
= bdrv_truncate(bs
->file
, (3 + l1_clusters
) * s
->cluster_size
,
4432 PREALLOC_MODE_OFF
, &local_err
);
4434 error_report_err(local_err
);
4440 fail_broken_refcounts
:
4441 /* The BDS is unusable at this point. If we wanted to make it usable, we
4442 * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
4443 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
4444 * again. However, because the functions which could have caused this error
4445 * path to be taken are used by those functions as well, it's very likely
4446 * that that sequence will fail as well. Therefore, just eject the BDS. */
4450 g_free(new_reftable
);
4454 static int qcow2_make_empty(BlockDriverState
*bs
)
4456 BDRVQcow2State
*s
= bs
->opaque
;
4457 uint64_t offset
, end_offset
;
4458 int step
= QEMU_ALIGN_DOWN(INT_MAX
, s
->cluster_size
);
4459 int l1_clusters
, ret
= 0;
4461 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
4463 if (s
->qcow_version
>= 3 && !s
->snapshots
&& !s
->nb_bitmaps
&&
4464 3 + l1_clusters
<= s
->refcount_block_size
&&
4465 s
->crypt_method_header
!= QCOW_CRYPT_LUKS
&&
4466 !has_data_file(bs
)) {
4467 /* The following function only works for qcow2 v3 images (it
4468 * requires the dirty flag) and only as long as there are no
4469 * features that reserve extra clusters (such as snapshots,
4470 * LUKS header, or persistent bitmaps), because it completely
4471 * empties the image. Furthermore, the L1 table and three
4472 * additional clusters (image header, refcount table, one
4473 * refcount block) have to fit inside one refcount block. It
4474 * only resets the image file, i.e. does not work with an
4475 * external data file. */
4476 return make_completely_empty(bs
);
4479 /* This fallback code simply discards every active cluster; this is slow,
4480 * but works in all cases */
4481 end_offset
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
4482 for (offset
= 0; offset
< end_offset
; offset
+= step
) {
4483 /* As this function is generally used after committing an external
4484 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
4485 * default action for this kind of discard is to pass the discard,
4486 * which will ideally result in an actually smaller image file, as
4487 * is probably desired. */
4488 ret
= qcow2_cluster_discard(bs
, offset
, MIN(step
, end_offset
- offset
),
4489 QCOW2_DISCARD_SNAPSHOT
, true);
4498 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
4500 BDRVQcow2State
*s
= bs
->opaque
;
4503 qemu_co_mutex_lock(&s
->lock
);
4504 ret
= qcow2_write_caches(bs
);
4505 qemu_co_mutex_unlock(&s
->lock
);
4510 static ssize_t
qcow2_measure_crypto_hdr_init_func(QCryptoBlock
*block
,
4511 size_t headerlen
, void *opaque
, Error
**errp
)
4513 size_t *headerlenp
= opaque
;
4515 /* Stash away the payload size */
4516 *headerlenp
= headerlen
;
4520 static ssize_t
qcow2_measure_crypto_hdr_write_func(QCryptoBlock
*block
,
4521 size_t offset
, const uint8_t *buf
, size_t buflen
,
4522 void *opaque
, Error
**errp
)
4524 /* Discard the bytes, we're not actually writing to an image */
4528 /* Determine the number of bytes for the LUKS payload */
4529 static bool qcow2_measure_luks_headerlen(QemuOpts
*opts
, size_t *len
,
4533 QDict
*cryptoopts_qdict
;
4534 QCryptoBlockCreateOptions
*cryptoopts
;
4535 QCryptoBlock
*crypto
;
4537 /* Extract "encrypt." options into a qdict */
4538 opts_qdict
= qemu_opts_to_qdict(opts
, NULL
);
4539 qdict_extract_subqdict(opts_qdict
, &cryptoopts_qdict
, "encrypt.");
4540 qobject_unref(opts_qdict
);
4542 /* Build QCryptoBlockCreateOptions object from qdict */
4543 qdict_put_str(cryptoopts_qdict
, "format", "luks");
4544 cryptoopts
= block_crypto_create_opts_init(cryptoopts_qdict
, errp
);
4545 qobject_unref(cryptoopts_qdict
);
4550 /* Fake LUKS creation in order to determine the payload size */
4551 crypto
= qcrypto_block_create(cryptoopts
, "encrypt.",
4552 qcow2_measure_crypto_hdr_init_func
,
4553 qcow2_measure_crypto_hdr_write_func
,
4555 qapi_free_QCryptoBlockCreateOptions(cryptoopts
);
4560 qcrypto_block_free(crypto
);
4564 static BlockMeasureInfo
*qcow2_measure(QemuOpts
*opts
, BlockDriverState
*in_bs
,
4567 Error
*local_err
= NULL
;
4568 BlockMeasureInfo
*info
;
4569 uint64_t required
= 0; /* bytes that contribute to required size */
4570 uint64_t virtual_size
; /* disk size as seen by guest */
4571 uint64_t refcount_bits
;
4573 uint64_t luks_payload_size
= 0;
4574 size_t cluster_size
;
4577 PreallocMode prealloc
;
4578 bool has_backing_file
;
4581 /* Parse image creation options */
4582 cluster_size
= qcow2_opt_get_cluster_size_del(opts
, &local_err
);
4587 version
= qcow2_opt_get_version_del(opts
, &local_err
);
4592 refcount_bits
= qcow2_opt_get_refcount_bits_del(opts
, version
, &local_err
);
4597 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
4598 prealloc
= qapi_enum_parse(&PreallocMode_lookup
, optstr
,
4599 PREALLOC_MODE_OFF
, &local_err
);
4605 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
4606 has_backing_file
= !!optstr
;
4609 optstr
= qemu_opt_get_del(opts
, BLOCK_OPT_ENCRYPT_FORMAT
);
4610 has_luks
= optstr
&& strcmp(optstr
, "luks") == 0;
4616 if (!qcow2_measure_luks_headerlen(opts
, &headerlen
, &local_err
)) {
4620 luks_payload_size
= ROUND_UP(headerlen
, cluster_size
);
4623 virtual_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0);
4624 virtual_size
= ROUND_UP(virtual_size
, cluster_size
);
4626 /* Check that virtual disk size is valid */
4627 l2_tables
= DIV_ROUND_UP(virtual_size
/ cluster_size
,
4628 cluster_size
/ sizeof(uint64_t));
4629 if (l2_tables
* sizeof(uint64_t) > QCOW_MAX_L1_SIZE
) {
4630 error_setg(&local_err
, "The image size is too large "
4631 "(try using a larger cluster size)");
4635 /* Account for input image */
4637 int64_t ssize
= bdrv_getlength(in_bs
);
4639 error_setg_errno(&local_err
, -ssize
,
4640 "Unable to get image virtual_size");
4644 virtual_size
= ROUND_UP(ssize
, cluster_size
);
4646 if (has_backing_file
) {
4647 /* We don't how much of the backing chain is shared by the input
4648 * image and the new image file. In the worst case the new image's
4649 * backing file has nothing in common with the input image. Be
4650 * conservative and assume all clusters need to be written.
4652 required
= virtual_size
;
4657 for (offset
= 0; offset
< ssize
; offset
+= pnum
) {
4660 ret
= bdrv_block_status_above(in_bs
, NULL
, offset
,
4661 ssize
- offset
, &pnum
, NULL
,
4664 error_setg_errno(&local_err
, -ret
,
4665 "Unable to get block status");
4669 if (ret
& BDRV_BLOCK_ZERO
) {
4670 /* Skip zero regions (safe with no backing file) */
4671 } else if ((ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) ==
4672 (BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
)) {
4673 /* Extend pnum to end of cluster for next iteration */
4674 pnum
= ROUND_UP(offset
+ pnum
, cluster_size
) - offset
;
4676 /* Count clusters we've seen */
4677 required
+= offset
% cluster_size
+ pnum
;
4683 /* Take into account preallocation. Nothing special is needed for
4684 * PREALLOC_MODE_METADATA since metadata is always counted.
4686 if (prealloc
== PREALLOC_MODE_FULL
|| prealloc
== PREALLOC_MODE_FALLOC
) {
4687 required
= virtual_size
;
4690 info
= g_new(BlockMeasureInfo
, 1);
4691 info
->fully_allocated
=
4692 qcow2_calc_prealloc_size(virtual_size
, cluster_size
,
4693 ctz32(refcount_bits
)) + luks_payload_size
;
4695 /* Remove data clusters that are not required. This overestimates the
4696 * required size because metadata needed for the fully allocated file is
4699 info
->required
= info
->fully_allocated
- virtual_size
+ required
;
4703 error_propagate(errp
, local_err
);
4707 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4709 BDRVQcow2State
*s
= bs
->opaque
;
4710 bdi
->unallocated_blocks_are_zero
= true;
4711 bdi
->cluster_size
= s
->cluster_size
;
4712 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
4716 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
,
4719 BDRVQcow2State
*s
= bs
->opaque
;
4720 ImageInfoSpecific
*spec_info
;
4721 QCryptoBlockInfo
*encrypt_info
= NULL
;
4722 Error
*local_err
= NULL
;
4724 if (s
->crypto
!= NULL
) {
4725 encrypt_info
= qcrypto_block_get_info(s
->crypto
, &local_err
);
4727 error_propagate(errp
, local_err
);
4732 spec_info
= g_new(ImageInfoSpecific
, 1);
4733 *spec_info
= (ImageInfoSpecific
){
4734 .type
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
4735 .u
.qcow2
.data
= g_new0(ImageInfoSpecificQCow2
, 1),
4737 if (s
->qcow_version
== 2) {
4738 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
4739 .compat
= g_strdup("0.10"),
4740 .refcount_bits
= s
->refcount_bits
,
4742 } else if (s
->qcow_version
== 3) {
4743 Qcow2BitmapInfoList
*bitmaps
;
4744 bitmaps
= qcow2_get_bitmap_info_list(bs
, &local_err
);
4746 error_propagate(errp
, local_err
);
4747 qapi_free_ImageInfoSpecific(spec_info
);
4750 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
4751 .compat
= g_strdup("1.1"),
4752 .lazy_refcounts
= s
->compatible_features
&
4753 QCOW2_COMPAT_LAZY_REFCOUNTS
,
4754 .has_lazy_refcounts
= true,
4755 .corrupt
= s
->incompatible_features
&
4756 QCOW2_INCOMPAT_CORRUPT
,
4757 .has_corrupt
= true,
4758 .refcount_bits
= s
->refcount_bits
,
4759 .has_bitmaps
= !!bitmaps
,
4761 .has_data_file
= !!s
->image_data_file
,
4762 .data_file
= g_strdup(s
->image_data_file
),
4763 .has_data_file_raw
= has_data_file(bs
),
4764 .data_file_raw
= data_file_is_raw(bs
),
4767 /* if this assertion fails, this probably means a new version was
4768 * added without having it covered here */
4773 ImageInfoSpecificQCow2Encryption
*qencrypt
=
4774 g_new(ImageInfoSpecificQCow2Encryption
, 1);
4775 switch (encrypt_info
->format
) {
4776 case Q_CRYPTO_BLOCK_FORMAT_QCOW
:
4777 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES
;
4779 case Q_CRYPTO_BLOCK_FORMAT_LUKS
:
4780 qencrypt
->format
= BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS
;
4781 qencrypt
->u
.luks
= encrypt_info
->u
.luks
;
4786 /* Since we did shallow copy above, erase any pointers
4787 * in the original info */
4788 memset(&encrypt_info
->u
, 0, sizeof(encrypt_info
->u
));
4789 qapi_free_QCryptoBlockInfo(encrypt_info
);
4791 spec_info
->u
.qcow2
.data
->has_encrypt
= true;
4792 spec_info
->u
.qcow2
.data
->encrypt
= qencrypt
;
4798 static int qcow2_has_zero_init(BlockDriverState
*bs
)
4800 BDRVQcow2State
*s
= bs
->opaque
;
4803 if (qemu_in_coroutine()) {
4804 qemu_co_mutex_lock(&s
->lock
);
4807 * Check preallocation status: Preallocated images have all L2
4808 * tables allocated, nonpreallocated images have none. It is
4809 * therefore enough to check the first one.
4811 preallocated
= s
->l1_size
> 0 && s
->l1_table
[0] != 0;
4812 if (qemu_in_coroutine()) {
4813 qemu_co_mutex_unlock(&s
->lock
);
4816 if (!preallocated
) {
4818 } else if (bs
->encrypted
) {
4821 return bdrv_has_zero_init(s
->data_file
->bs
);
4825 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
4828 BDRVQcow2State
*s
= bs
->opaque
;
4830 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
4831 return bs
->drv
->bdrv_co_pwritev_part(bs
, qcow2_vm_state_offset(s
) + pos
,
4832 qiov
->size
, qiov
, 0, 0);
4835 static int qcow2_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
4838 BDRVQcow2State
*s
= bs
->opaque
;
4840 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
4841 return bs
->drv
->bdrv_co_preadv_part(bs
, qcow2_vm_state_offset(s
) + pos
,
4842 qiov
->size
, qiov
, 0, 0);
4846 * Downgrades an image's version. To achieve this, any incompatible features
4847 * have to be removed.
4849 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
,
4850 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
,
4853 BDRVQcow2State
*s
= bs
->opaque
;
4854 int current_version
= s
->qcow_version
;
4857 /* This is qcow2_downgrade(), not qcow2_upgrade() */
4858 assert(target_version
< current_version
);
4860 /* There are no other versions (now) that you can downgrade to */
4861 assert(target_version
== 2);
4863 if (s
->refcount_order
!= 4) {
4864 error_setg(errp
, "compat=0.10 requires refcount_bits=16");
4868 if (has_data_file(bs
)) {
4869 error_setg(errp
, "Cannot downgrade an image with a data file");
4873 /* clear incompatible features */
4874 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
4875 ret
= qcow2_mark_clean(bs
);
4877 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
4882 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
4883 * the first place; if that happens nonetheless, returning -ENOTSUP is the
4884 * best thing to do anyway */
4886 if (s
->incompatible_features
) {
4887 error_setg(errp
, "Cannot downgrade an image with incompatible features "
4888 "%#" PRIx64
" set", s
->incompatible_features
);
4892 /* since we can ignore compatible features, we can set them to 0 as well */
4893 s
->compatible_features
= 0;
4894 /* if lazy refcounts have been used, they have already been fixed through
4895 * clearing the dirty flag */
4897 /* clearing autoclear features is trivial */
4898 s
->autoclear_features
= 0;
4900 ret
= qcow2_expand_zero_clusters(bs
, status_cb
, cb_opaque
);
4902 error_setg_errno(errp
, -ret
, "Failed to turn zero into data clusters");
4906 s
->qcow_version
= target_version
;
4907 ret
= qcow2_update_header(bs
);
4909 s
->qcow_version
= current_version
;
4910 error_setg_errno(errp
, -ret
, "Failed to update the image header");
4916 typedef enum Qcow2AmendOperation
{
4917 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
4918 * statically initialized to so that the helper CB can discern the first
4919 * invocation from an operation change */
4920 QCOW2_NO_OPERATION
= 0,
4922 QCOW2_CHANGING_REFCOUNT_ORDER
,
4924 } Qcow2AmendOperation
;
4926 typedef struct Qcow2AmendHelperCBInfo
{
4927 /* The code coordinating the amend operations should only modify
4928 * these four fields; the rest will be managed by the CB */
4929 BlockDriverAmendStatusCB
*original_status_cb
;
4930 void *original_cb_opaque
;
4932 Qcow2AmendOperation current_operation
;
4934 /* Total number of operations to perform (only set once) */
4935 int total_operations
;
4937 /* The following fields are managed by the CB */
4939 /* Number of operations completed */
4940 int operations_completed
;
4942 /* Cumulative offset of all completed operations */
4943 int64_t offset_completed
;
4945 Qcow2AmendOperation last_operation
;
4946 int64_t last_work_size
;
4947 } Qcow2AmendHelperCBInfo
;
4949 static void qcow2_amend_helper_cb(BlockDriverState
*bs
,
4950 int64_t operation_offset
,
4951 int64_t operation_work_size
, void *opaque
)
4953 Qcow2AmendHelperCBInfo
*info
= opaque
;
4954 int64_t current_work_size
;
4955 int64_t projected_work_size
;
4957 if (info
->current_operation
!= info
->last_operation
) {
4958 if (info
->last_operation
!= QCOW2_NO_OPERATION
) {
4959 info
->offset_completed
+= info
->last_work_size
;
4960 info
->operations_completed
++;
4963 info
->last_operation
= info
->current_operation
;
4966 assert(info
->total_operations
> 0);
4967 assert(info
->operations_completed
< info
->total_operations
);
4969 info
->last_work_size
= operation_work_size
;
4971 current_work_size
= info
->offset_completed
+ operation_work_size
;
4973 /* current_work_size is the total work size for (operations_completed + 1)
4974 * operations (which includes this one), so multiply it by the number of
4975 * operations not covered and divide it by the number of operations
4976 * covered to get a projection for the operations not covered */
4977 projected_work_size
= current_work_size
* (info
->total_operations
-
4978 info
->operations_completed
- 1)
4979 / (info
->operations_completed
+ 1);
4981 info
->original_status_cb(bs
, info
->offset_completed
+ operation_offset
,
4982 current_work_size
+ projected_work_size
,
4983 info
->original_cb_opaque
);
4986 static int qcow2_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
4987 BlockDriverAmendStatusCB
*status_cb
,
4991 BDRVQcow2State
*s
= bs
->opaque
;
4992 int old_version
= s
->qcow_version
, new_version
= old_version
;
4993 uint64_t new_size
= 0;
4994 const char *backing_file
= NULL
, *backing_format
= NULL
, *data_file
= NULL
;
4995 bool lazy_refcounts
= s
->use_lazy_refcounts
;
4996 bool data_file_raw
= data_file_is_raw(bs
);
4997 const char *compat
= NULL
;
4998 uint64_t cluster_size
= s
->cluster_size
;
5001 int refcount_bits
= s
->refcount_bits
;
5003 QemuOptDesc
*desc
= opts
->list
->desc
;
5004 Qcow2AmendHelperCBInfo helper_cb_info
;
5006 while (desc
&& desc
->name
) {
5007 if (!qemu_opt_find(opts
, desc
->name
)) {
5008 /* only change explicitly defined options */
5013 if (!strcmp(desc
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
5014 compat
= qemu_opt_get(opts
, BLOCK_OPT_COMPAT_LEVEL
);
5016 /* preserve default */
5017 } else if (!strcmp(compat
, "0.10") || !strcmp(compat
, "v2")) {
5019 } else if (!strcmp(compat
, "1.1") || !strcmp(compat
, "v3")) {
5022 error_setg(errp
, "Unknown compatibility level %s", compat
);
5025 } else if (!strcmp(desc
->name
, BLOCK_OPT_PREALLOC
)) {
5026 error_setg(errp
, "Cannot change preallocation mode");
5028 } else if (!strcmp(desc
->name
, BLOCK_OPT_SIZE
)) {
5029 new_size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
5030 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FILE
)) {
5031 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
5032 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FMT
)) {
5033 backing_format
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
5034 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT
)) {
5035 encrypt
= qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
,
5038 if (encrypt
!= !!s
->crypto
) {
5040 "Changing the encryption flag is not supported");
5043 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT_FORMAT
)) {
5044 encformat
= qcow2_crypt_method_from_format(
5045 qemu_opt_get(opts
, BLOCK_OPT_ENCRYPT_FORMAT
));
5047 if (encformat
!= s
->crypt_method_header
) {
5049 "Changing the encryption format is not supported");
5052 } else if (g_str_has_prefix(desc
->name
, "encrypt.")) {
5054 "Changing the encryption parameters is not supported");
5056 } else if (!strcmp(desc
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
5057 cluster_size
= qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
,
5059 if (cluster_size
!= s
->cluster_size
) {
5060 error_setg(errp
, "Changing the cluster size is not supported");
5063 } else if (!strcmp(desc
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
5064 lazy_refcounts
= qemu_opt_get_bool(opts
, BLOCK_OPT_LAZY_REFCOUNTS
,
5066 } else if (!strcmp(desc
->name
, BLOCK_OPT_REFCOUNT_BITS
)) {
5067 refcount_bits
= qemu_opt_get_number(opts
, BLOCK_OPT_REFCOUNT_BITS
,
5070 if (refcount_bits
<= 0 || refcount_bits
> 64 ||
5071 !is_power_of_2(refcount_bits
))
5073 error_setg(errp
, "Refcount width must be a power of two and "
5074 "may not exceed 64 bits");
5077 } else if (!strcmp(desc
->name
, BLOCK_OPT_DATA_FILE
)) {
5078 data_file
= qemu_opt_get(opts
, BLOCK_OPT_DATA_FILE
);
5079 if (data_file
&& !has_data_file(bs
)) {
5080 error_setg(errp
, "data-file can only be set for images that "
5081 "use an external data file");
5084 } else if (!strcmp(desc
->name
, BLOCK_OPT_DATA_FILE_RAW
)) {
5085 data_file_raw
= qemu_opt_get_bool(opts
, BLOCK_OPT_DATA_FILE_RAW
,
5087 if (data_file_raw
&& !data_file_is_raw(bs
)) {
5088 error_setg(errp
, "data-file-raw cannot be set on existing "
5093 /* if this point is reached, this probably means a new option was
5094 * added without having it covered here */
5101 helper_cb_info
= (Qcow2AmendHelperCBInfo
){
5102 .original_status_cb
= status_cb
,
5103 .original_cb_opaque
= cb_opaque
,
5104 .total_operations
= (new_version
< old_version
)
5105 + (s
->refcount_bits
!= refcount_bits
)
5108 /* Upgrade first (some features may require compat=1.1) */
5109 if (new_version
> old_version
) {
5110 s
->qcow_version
= new_version
;
5111 ret
= qcow2_update_header(bs
);
5113 s
->qcow_version
= old_version
;
5114 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5119 if (s
->refcount_bits
!= refcount_bits
) {
5120 int refcount_order
= ctz32(refcount_bits
);
5122 if (new_version
< 3 && refcount_bits
!= 16) {
5123 error_setg(errp
, "Refcount widths other than 16 bits require "
5124 "compatibility level 1.1 or above (use compat=1.1 or "
5129 helper_cb_info
.current_operation
= QCOW2_CHANGING_REFCOUNT_ORDER
;
5130 ret
= qcow2_change_refcount_order(bs
, refcount_order
,
5131 &qcow2_amend_helper_cb
,
5132 &helper_cb_info
, errp
);
5138 /* data-file-raw blocks backing files, so clear it first if requested */
5139 if (data_file_raw
) {
5140 s
->autoclear_features
|= QCOW2_AUTOCLEAR_DATA_FILE_RAW
;
5142 s
->autoclear_features
&= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW
;
5146 g_free(s
->image_data_file
);
5147 s
->image_data_file
= *data_file
? g_strdup(data_file
) : NULL
;
5150 ret
= qcow2_update_header(bs
);
5152 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5156 if (backing_file
|| backing_format
) {
5157 ret
= qcow2_change_backing_file(bs
,
5158 backing_file
?: s
->image_backing_file
,
5159 backing_format
?: s
->image_backing_format
);
5161 error_setg_errno(errp
, -ret
, "Failed to change the backing file");
5166 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
5167 if (lazy_refcounts
) {
5168 if (new_version
< 3) {
5169 error_setg(errp
, "Lazy refcounts only supported with "
5170 "compatibility level 1.1 and above (use compat=1.1 "
5174 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
5175 ret
= qcow2_update_header(bs
);
5177 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
5178 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5181 s
->use_lazy_refcounts
= true;
5183 /* make image clean first */
5184 ret
= qcow2_mark_clean(bs
);
5186 error_setg_errno(errp
, -ret
, "Failed to make the image clean");
5189 /* now disallow lazy refcounts */
5190 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
5191 ret
= qcow2_update_header(bs
);
5193 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
5194 error_setg_errno(errp
, -ret
, "Failed to update the image header");
5197 s
->use_lazy_refcounts
= false;
5202 BlockBackend
*blk
= blk_new(bdrv_get_aio_context(bs
),
5203 BLK_PERM_RESIZE
, BLK_PERM_ALL
);
5204 ret
= blk_insert_bs(blk
, bs
, errp
);
5210 ret
= blk_truncate(blk
, new_size
, PREALLOC_MODE_OFF
, errp
);
5217 /* Downgrade last (so unsupported features can be removed before) */
5218 if (new_version
< old_version
) {
5219 helper_cb_info
.current_operation
= QCOW2_DOWNGRADING
;
5220 ret
= qcow2_downgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
5221 &helper_cb_info
, errp
);
5231 * If offset or size are negative, respectively, they will not be included in
5232 * the BLOCK_IMAGE_CORRUPTED event emitted.
5233 * fatal will be ignored for read-only BDS; corruptions found there will always
5234 * be considered non-fatal.
5236 void qcow2_signal_corruption(BlockDriverState
*bs
, bool fatal
, int64_t offset
,
5237 int64_t size
, const char *message_format
, ...)
5239 BDRVQcow2State
*s
= bs
->opaque
;
5240 const char *node_name
;
5244 fatal
= fatal
&& bdrv_is_writable(bs
);
5246 if (s
->signaled_corruption
&&
5247 (!fatal
|| (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
)))
5252 va_start(ap
, message_format
);
5253 message
= g_strdup_vprintf(message_format
, ap
);
5257 fprintf(stderr
, "qcow2: Marking image as corrupt: %s; further "
5258 "corruption events will be suppressed\n", message
);
5260 fprintf(stderr
, "qcow2: Image is corrupt: %s; further non-fatal "
5261 "corruption events will be suppressed\n", message
);
5264 node_name
= bdrv_get_node_name(bs
);
5265 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs
),
5266 *node_name
!= '\0', node_name
,
5267 message
, offset
>= 0, offset
,
5273 qcow2_mark_corrupt(bs
);
5274 bs
->drv
= NULL
; /* make BDS unusable */
5277 s
->signaled_corruption
= true;
5280 static QemuOptsList qcow2_create_opts
= {
5281 .name
= "qcow2-create-opts",
5282 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_create_opts
.head
),
5285 .name
= BLOCK_OPT_SIZE
,
5286 .type
= QEMU_OPT_SIZE
,
5287 .help
= "Virtual disk size"
5290 .name
= BLOCK_OPT_COMPAT_LEVEL
,
5291 .type
= QEMU_OPT_STRING
,
5292 .help
= "Compatibility level (v2 [0.10] or v3 [1.1])"
5295 .name
= BLOCK_OPT_BACKING_FILE
,
5296 .type
= QEMU_OPT_STRING
,
5297 .help
= "File name of a base image"
5300 .name
= BLOCK_OPT_BACKING_FMT
,
5301 .type
= QEMU_OPT_STRING
,
5302 .help
= "Image format of the base image"
5305 .name
= BLOCK_OPT_DATA_FILE
,
5306 .type
= QEMU_OPT_STRING
,
5307 .help
= "File name of an external data file"
5310 .name
= BLOCK_OPT_DATA_FILE_RAW
,
5311 .type
= QEMU_OPT_BOOL
,
5312 .help
= "The external data file must stay valid as a raw image"
5315 .name
= BLOCK_OPT_ENCRYPT
,
5316 .type
= QEMU_OPT_BOOL
,
5317 .help
= "Encrypt the image with format 'aes'. (Deprecated "
5318 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT
"=aes)",
5321 .name
= BLOCK_OPT_ENCRYPT_FORMAT
,
5322 .type
= QEMU_OPT_STRING
,
5323 .help
= "Encrypt the image, format choices: 'aes', 'luks'",
5325 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
5326 "ID of secret providing qcow AES key or LUKS passphrase"),
5327 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."),
5328 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."),
5329 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."),
5330 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."),
5331 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."),
5332 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
5334 .name
= BLOCK_OPT_CLUSTER_SIZE
,
5335 .type
= QEMU_OPT_SIZE
,
5336 .help
= "qcow2 cluster size",
5337 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
)
5340 .name
= BLOCK_OPT_PREALLOC
,
5341 .type
= QEMU_OPT_STRING
,
5342 .help
= "Preallocation mode (allowed values: off, metadata, "
5346 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
5347 .type
= QEMU_OPT_BOOL
,
5348 .help
= "Postpone refcount updates",
5349 .def_value_str
= "off"
5352 .name
= BLOCK_OPT_REFCOUNT_BITS
,
5353 .type
= QEMU_OPT_NUMBER
,
5354 .help
= "Width of a reference count entry in bits",
5355 .def_value_str
= "16"
5357 { /* end of list */ }
5361 static const char *const qcow2_strong_runtime_opts
[] = {
5362 "encrypt." BLOCK_CRYPTO_OPT_QCOW_KEY_SECRET
,
5367 BlockDriver bdrv_qcow2
= {
5368 .format_name
= "qcow2",
5369 .instance_size
= sizeof(BDRVQcow2State
),
5370 .bdrv_probe
= qcow2_probe
,
5371 .bdrv_open
= qcow2_open
,
5372 .bdrv_close
= qcow2_close
,
5373 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
5374 .bdrv_reopen_commit
= qcow2_reopen_commit
,
5375 .bdrv_reopen_abort
= qcow2_reopen_abort
,
5376 .bdrv_join_options
= qcow2_join_options
,
5377 .bdrv_child_perm
= bdrv_format_default_perms
,
5378 .bdrv_co_create_opts
= qcow2_co_create_opts
,
5379 .bdrv_co_create
= qcow2_co_create
,
5380 .bdrv_has_zero_init
= qcow2_has_zero_init
,
5381 .bdrv_has_zero_init_truncate
= bdrv_has_zero_init_1
,
5382 .bdrv_co_block_status
= qcow2_co_block_status
,
5384 .bdrv_co_preadv_part
= qcow2_co_preadv_part
,
5385 .bdrv_co_pwritev_part
= qcow2_co_pwritev_part
,
5386 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
5388 .bdrv_co_pwrite_zeroes
= qcow2_co_pwrite_zeroes
,
5389 .bdrv_co_pdiscard
= qcow2_co_pdiscard
,
5390 .bdrv_co_copy_range_from
= qcow2_co_copy_range_from
,
5391 .bdrv_co_copy_range_to
= qcow2_co_copy_range_to
,
5392 .bdrv_co_truncate
= qcow2_co_truncate
,
5393 .bdrv_co_pwritev_compressed_part
= qcow2_co_pwritev_compressed_part
,
5394 .bdrv_make_empty
= qcow2_make_empty
,
5396 .bdrv_snapshot_create
= qcow2_snapshot_create
,
5397 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
5398 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
5399 .bdrv_snapshot_list
= qcow2_snapshot_list
,
5400 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
5401 .bdrv_measure
= qcow2_measure
,
5402 .bdrv_get_info
= qcow2_get_info
,
5403 .bdrv_get_specific_info
= qcow2_get_specific_info
,
5405 .bdrv_save_vmstate
= qcow2_save_vmstate
,
5406 .bdrv_load_vmstate
= qcow2_load_vmstate
,
5408 .supports_backing
= true,
5409 .bdrv_change_backing_file
= qcow2_change_backing_file
,
5411 .bdrv_refresh_limits
= qcow2_refresh_limits
,
5412 .bdrv_co_invalidate_cache
= qcow2_co_invalidate_cache
,
5413 .bdrv_inactivate
= qcow2_inactivate
,
5415 .create_opts
= &qcow2_create_opts
,
5416 .strong_runtime_opts
= qcow2_strong_runtime_opts
,
5417 .mutable_opts
= mutable_opts
,
5418 .bdrv_co_check
= qcow2_co_check
,
5419 .bdrv_amend_options
= qcow2_amend_options
,
5421 .bdrv_detach_aio_context
= qcow2_detach_aio_context
,
5422 .bdrv_attach_aio_context
= qcow2_attach_aio_context
,
5424 .bdrv_co_can_store_new_dirty_bitmap
= qcow2_co_can_store_new_dirty_bitmap
,
5425 .bdrv_co_remove_persistent_dirty_bitmap
=
5426 qcow2_co_remove_persistent_dirty_bitmap
,
5429 static void bdrv_qcow2_init(void)
5431 bdrv_register(&bdrv_qcow2
);
5434 block_init(bdrv_qcow2_init
);