2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qemu-common.h"
26 #include "block/block_int.h"
27 #include "qemu/module.h"
29 #include "block/qcow2.h"
30 #include "qemu/error-report.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qbool.h"
33 #include "qapi/util.h"
34 #include "qapi/qmp/types.h"
35 #include "qapi-event.h"
37 #include "qemu/option_int.h"
40 Differences with QCOW:
42 - Support for multiple incremental snapshots.
43 - Memory management by reference counts.
44 - Clusters which have a reference count of one have the bit
45 QCOW_OFLAG_COPIED to optimize write performance.
46 - Size of compressed clusters is stored in sectors to reduce bit usage
47 in the cluster offsets.
48 - Support for storing additional data (such as the VM state) in the
50 - If a backing store is used, the cluster size is not constrained
51 (could be backported to QCOW).
52 - L2 tables have always a size of one cluster.
59 } QEMU_PACKED QCowExtension
;
61 #define QCOW2_EXT_MAGIC_END 0
62 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
63 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
65 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
67 const QCowHeader
*cow_header
= (const void *)buf
;
69 if (buf_size
>= sizeof(QCowHeader
) &&
70 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
71 be32_to_cpu(cow_header
->version
) >= 2)
79 * read qcow2 extension and fill bs
80 * start reading from start_offset
81 * finish reading upon magic of value 0 or when end_offset reached
82 * unknown magic is skipped (future extension this version knows nothing about)
83 * return 0 upon success, non-0 otherwise
85 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
86 uint64_t end_offset
, void **p_feature_table
,
89 BDRVQcow2State
*s
= bs
->opaque
;
95 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
97 offset
= start_offset
;
98 while (offset
< end_offset
) {
102 if (offset
> s
->cluster_size
)
103 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
105 printf("attempting to read extended header in offset %lu\n", offset
);
108 ret
= bdrv_pread(bs
->file
->bs
, offset
, &ext
, sizeof(ext
));
110 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
111 "pread fail from offset %" PRIu64
, offset
);
114 be32_to_cpus(&ext
.magic
);
115 be32_to_cpus(&ext
.len
);
116 offset
+= sizeof(ext
);
118 printf("ext.magic = 0x%x\n", ext
.magic
);
120 if (offset
> end_offset
|| ext
.len
> end_offset
- offset
) {
121 error_setg(errp
, "Header extension too large");
126 case QCOW2_EXT_MAGIC_END
:
129 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
130 if (ext
.len
>= sizeof(bs
->backing_format
)) {
131 error_setg(errp
, "ERROR: ext_backing_format: len=%" PRIu32
132 " too large (>=%zu)", ext
.len
,
133 sizeof(bs
->backing_format
));
136 ret
= bdrv_pread(bs
->file
->bs
, offset
, bs
->backing_format
, ext
.len
);
138 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
139 "Could not read format name");
142 bs
->backing_format
[ext
.len
] = '\0';
143 s
->image_backing_format
= g_strdup(bs
->backing_format
);
145 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
149 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
150 if (p_feature_table
!= NULL
) {
151 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
152 ret
= bdrv_pread(bs
->file
->bs
, offset
, feature_table
, ext
.len
);
154 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
155 "Could not read table");
159 *p_feature_table
= feature_table
;
164 /* unknown magic - save it in case we need to rewrite the header */
166 Qcow2UnknownHeaderExtension
*uext
;
168 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
169 uext
->magic
= ext
.magic
;
171 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
173 ret
= bdrv_pread(bs
->file
->bs
, offset
, uext
->data
, uext
->len
);
175 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
176 "Could not read data");
183 offset
+= ((ext
.len
+ 7) & ~7);
189 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
191 BDRVQcow2State
*s
= bs
->opaque
;
192 Qcow2UnknownHeaderExtension
*uext
, *next
;
194 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
195 QLIST_REMOVE(uext
, next
);
200 static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState
*bs
,
201 Error
**errp
, const char *fmt
, ...)
207 vsnprintf(msg
, sizeof(msg
), fmt
, ap
);
210 error_setg(errp
, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE
,
211 bdrv_get_device_or_node_name(bs
), "qcow2", msg
);
214 static void report_unsupported_feature(BlockDriverState
*bs
,
215 Error
**errp
, Qcow2Feature
*table
, uint64_t mask
)
217 char *features
= g_strdup("");
220 while (table
&& table
->name
[0] != '\0') {
221 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
222 if (mask
& (1ULL << table
->bit
)) {
224 features
= g_strdup_printf("%s%s%.46s", old
, *old
? ", " : "",
227 mask
&= ~(1ULL << table
->bit
);
235 features
= g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64
,
236 old
, *old
? ", " : "", mask
);
240 report_unsupported(bs
, errp
, "%s", features
);
245 * Sets the dirty bit and flushes afterwards if necessary.
247 * The incompatible_features bit is only set if the image file header was
248 * updated successfully. Therefore it is not required to check the return
249 * value of this function.
251 int qcow2_mark_dirty(BlockDriverState
*bs
)
253 BDRVQcow2State
*s
= bs
->opaque
;
257 assert(s
->qcow_version
>= 3);
259 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
260 return 0; /* already dirty */
263 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
264 ret
= bdrv_pwrite(bs
->file
->bs
, offsetof(QCowHeader
, incompatible_features
),
269 ret
= bdrv_flush(bs
->file
->bs
);
274 /* Only treat image as dirty if the header was updated successfully */
275 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
280 * Clears the dirty bit and flushes before if necessary. Only call this
281 * function when there are no pending requests, it does not guard against
282 * concurrent requests dirtying the image.
284 static int qcow2_mark_clean(BlockDriverState
*bs
)
286 BDRVQcow2State
*s
= bs
->opaque
;
288 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
291 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
293 ret
= bdrv_flush(bs
);
298 return qcow2_update_header(bs
);
304 * Marks the image as corrupt.
306 int qcow2_mark_corrupt(BlockDriverState
*bs
)
308 BDRVQcow2State
*s
= bs
->opaque
;
310 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
311 return qcow2_update_header(bs
);
315 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
316 * before if necessary.
318 int qcow2_mark_consistent(BlockDriverState
*bs
)
320 BDRVQcow2State
*s
= bs
->opaque
;
322 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
323 int ret
= bdrv_flush(bs
);
328 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
329 return qcow2_update_header(bs
);
334 static int qcow2_check(BlockDriverState
*bs
, BdrvCheckResult
*result
,
337 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
342 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
343 ret
= qcow2_mark_clean(bs
);
347 return qcow2_mark_consistent(bs
);
352 static int validate_table_offset(BlockDriverState
*bs
, uint64_t offset
,
353 uint64_t entries
, size_t entry_len
)
355 BDRVQcow2State
*s
= bs
->opaque
;
358 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
359 * because values will be passed to qemu functions taking int64_t. */
360 if (entries
> INT64_MAX
/ entry_len
) {
364 size
= entries
* entry_len
;
366 if (INT64_MAX
- size
< offset
) {
370 /* Tables must be cluster aligned */
371 if (offset
& (s
->cluster_size
- 1)) {
378 static QemuOptsList qcow2_runtime_opts
= {
380 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
383 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
384 .type
= QEMU_OPT_BOOL
,
385 .help
= "Postpone refcount updates",
388 .name
= QCOW2_OPT_DISCARD_REQUEST
,
389 .type
= QEMU_OPT_BOOL
,
390 .help
= "Pass guest discard requests to the layer below",
393 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
394 .type
= QEMU_OPT_BOOL
,
395 .help
= "Generate discard requests when snapshot related space "
399 .name
= QCOW2_OPT_DISCARD_OTHER
,
400 .type
= QEMU_OPT_BOOL
,
401 .help
= "Generate discard requests when other clusters are freed",
404 .name
= QCOW2_OPT_OVERLAP
,
405 .type
= QEMU_OPT_STRING
,
406 .help
= "Selects which overlap checks to perform from a range of "
407 "templates (none, constant, cached, all)",
410 .name
= QCOW2_OPT_OVERLAP_TEMPLATE
,
411 .type
= QEMU_OPT_STRING
,
412 .help
= "Selects which overlap checks to perform from a range of "
413 "templates (none, constant, cached, all)",
416 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
417 .type
= QEMU_OPT_BOOL
,
418 .help
= "Check for unintended writes into the main qcow2 header",
421 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
422 .type
= QEMU_OPT_BOOL
,
423 .help
= "Check for unintended writes into the active L1 table",
426 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
427 .type
= QEMU_OPT_BOOL
,
428 .help
= "Check for unintended writes into an active L2 table",
431 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
432 .type
= QEMU_OPT_BOOL
,
433 .help
= "Check for unintended writes into the refcount table",
436 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
437 .type
= QEMU_OPT_BOOL
,
438 .help
= "Check for unintended writes into a refcount block",
441 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
442 .type
= QEMU_OPT_BOOL
,
443 .help
= "Check for unintended writes into the snapshot table",
446 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
447 .type
= QEMU_OPT_BOOL
,
448 .help
= "Check for unintended writes into an inactive L1 table",
451 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
452 .type
= QEMU_OPT_BOOL
,
453 .help
= "Check for unintended writes into an inactive L2 table",
456 .name
= QCOW2_OPT_CACHE_SIZE
,
457 .type
= QEMU_OPT_SIZE
,
458 .help
= "Maximum combined metadata (L2 tables and refcount blocks) "
462 .name
= QCOW2_OPT_L2_CACHE_SIZE
,
463 .type
= QEMU_OPT_SIZE
,
464 .help
= "Maximum L2 table cache size",
467 .name
= QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
468 .type
= QEMU_OPT_SIZE
,
469 .help
= "Maximum refcount block cache size",
472 .name
= QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
473 .type
= QEMU_OPT_NUMBER
,
474 .help
= "Clean unused cache entries after this time (in seconds)",
476 { /* end of list */ }
480 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
481 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
482 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
483 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
484 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
485 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
486 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
487 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
488 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
491 static void cache_clean_timer_cb(void *opaque
)
493 BlockDriverState
*bs
= opaque
;
494 BDRVQcow2State
*s
= bs
->opaque
;
495 qcow2_cache_clean_unused(bs
, s
->l2_table_cache
);
496 qcow2_cache_clean_unused(bs
, s
->refcount_block_cache
);
497 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
498 (int64_t) s
->cache_clean_interval
* 1000);
501 static void cache_clean_timer_init(BlockDriverState
*bs
, AioContext
*context
)
503 BDRVQcow2State
*s
= bs
->opaque
;
504 if (s
->cache_clean_interval
> 0) {
505 s
->cache_clean_timer
= aio_timer_new(context
, QEMU_CLOCK_VIRTUAL
,
506 SCALE_MS
, cache_clean_timer_cb
,
508 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
509 (int64_t) s
->cache_clean_interval
* 1000);
513 static void cache_clean_timer_del(BlockDriverState
*bs
)
515 BDRVQcow2State
*s
= bs
->opaque
;
516 if (s
->cache_clean_timer
) {
517 timer_del(s
->cache_clean_timer
);
518 timer_free(s
->cache_clean_timer
);
519 s
->cache_clean_timer
= NULL
;
523 static void qcow2_detach_aio_context(BlockDriverState
*bs
)
525 cache_clean_timer_del(bs
);
528 static void qcow2_attach_aio_context(BlockDriverState
*bs
,
529 AioContext
*new_context
)
531 cache_clean_timer_init(bs
, new_context
);
534 static void read_cache_sizes(BlockDriverState
*bs
, QemuOpts
*opts
,
535 uint64_t *l2_cache_size
,
536 uint64_t *refcount_cache_size
, Error
**errp
)
538 BDRVQcow2State
*s
= bs
->opaque
;
539 uint64_t combined_cache_size
;
540 bool l2_cache_size_set
, refcount_cache_size_set
, combined_cache_size_set
;
542 combined_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_CACHE_SIZE
);
543 l2_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_SIZE
);
544 refcount_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
546 combined_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_CACHE_SIZE
, 0);
547 *l2_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_L2_CACHE_SIZE
, 0);
548 *refcount_cache_size
= qemu_opt_get_size(opts
,
549 QCOW2_OPT_REFCOUNT_CACHE_SIZE
, 0);
551 if (combined_cache_size_set
) {
552 if (l2_cache_size_set
&& refcount_cache_size_set
) {
553 error_setg(errp
, QCOW2_OPT_CACHE_SIZE
", " QCOW2_OPT_L2_CACHE_SIZE
554 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not be set "
557 } else if (*l2_cache_size
> combined_cache_size
) {
558 error_setg(errp
, QCOW2_OPT_L2_CACHE_SIZE
" may not exceed "
559 QCOW2_OPT_CACHE_SIZE
);
561 } else if (*refcount_cache_size
> combined_cache_size
) {
562 error_setg(errp
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not exceed "
563 QCOW2_OPT_CACHE_SIZE
);
567 if (l2_cache_size_set
) {
568 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
569 } else if (refcount_cache_size_set
) {
570 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
572 *refcount_cache_size
= combined_cache_size
573 / (DEFAULT_L2_REFCOUNT_SIZE_RATIO
+ 1);
574 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
577 if (!l2_cache_size_set
&& !refcount_cache_size_set
) {
578 *l2_cache_size
= MAX(DEFAULT_L2_CACHE_BYTE_SIZE
,
579 (uint64_t)DEFAULT_L2_CACHE_CLUSTERS
581 *refcount_cache_size
= *l2_cache_size
582 / DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
583 } else if (!l2_cache_size_set
) {
584 *l2_cache_size
= *refcount_cache_size
585 * DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
586 } else if (!refcount_cache_size_set
) {
587 *refcount_cache_size
= *l2_cache_size
588 / DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
593 typedef struct Qcow2ReopenState
{
594 Qcow2Cache
*l2_table_cache
;
595 Qcow2Cache
*refcount_block_cache
;
596 bool use_lazy_refcounts
;
598 bool discard_passthrough
[QCOW2_DISCARD_MAX
];
599 uint64_t cache_clean_interval
;
602 static int qcow2_update_options_prepare(BlockDriverState
*bs
,
604 QDict
*options
, int flags
,
607 BDRVQcow2State
*s
= bs
->opaque
;
608 QemuOpts
*opts
= NULL
;
609 const char *opt_overlap_check
, *opt_overlap_check_template
;
610 int overlap_check_template
= 0;
611 uint64_t l2_cache_size
, refcount_cache_size
;
613 Error
*local_err
= NULL
;
616 opts
= qemu_opts_create(&qcow2_runtime_opts
, NULL
, 0, &error_abort
);
617 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
619 error_propagate(errp
, local_err
);
624 /* get L2 table/refcount block cache size from command line options */
625 read_cache_sizes(bs
, opts
, &l2_cache_size
, &refcount_cache_size
,
628 error_propagate(errp
, local_err
);
633 l2_cache_size
/= s
->cluster_size
;
634 if (l2_cache_size
< MIN_L2_CACHE_SIZE
) {
635 l2_cache_size
= MIN_L2_CACHE_SIZE
;
637 if (l2_cache_size
> INT_MAX
) {
638 error_setg(errp
, "L2 cache size too big");
643 refcount_cache_size
/= s
->cluster_size
;
644 if (refcount_cache_size
< MIN_REFCOUNT_CACHE_SIZE
) {
645 refcount_cache_size
= MIN_REFCOUNT_CACHE_SIZE
;
647 if (refcount_cache_size
> INT_MAX
) {
648 error_setg(errp
, "Refcount cache size too big");
653 /* alloc new L2 table/refcount block cache, flush old one */
654 if (s
->l2_table_cache
) {
655 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
657 error_setg_errno(errp
, -ret
, "Failed to flush the L2 table cache");
662 if (s
->refcount_block_cache
) {
663 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
665 error_setg_errno(errp
, -ret
,
666 "Failed to flush the refcount block cache");
671 r
->l2_table_cache
= qcow2_cache_create(bs
, l2_cache_size
);
672 r
->refcount_block_cache
= qcow2_cache_create(bs
, refcount_cache_size
);
673 if (r
->l2_table_cache
== NULL
|| r
->refcount_block_cache
== NULL
) {
674 error_setg(errp
, "Could not allocate metadata caches");
679 /* New interval for cache cleanup timer */
680 r
->cache_clean_interval
=
681 qemu_opt_get_number(opts
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
682 s
->cache_clean_interval
);
683 if (r
->cache_clean_interval
> UINT_MAX
) {
684 error_setg(errp
, "Cache clean interval too big");
689 /* lazy-refcounts; flush if going from enabled to disabled */
690 r
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
691 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
692 if (r
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
693 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
694 "qemu 1.1 compatibility level");
699 if (s
->use_lazy_refcounts
&& !r
->use_lazy_refcounts
) {
700 ret
= qcow2_mark_clean(bs
);
702 error_setg_errno(errp
, -ret
, "Failed to disable lazy refcounts");
707 /* Overlap check options */
708 opt_overlap_check
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP
);
709 opt_overlap_check_template
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP_TEMPLATE
);
710 if (opt_overlap_check_template
&& opt_overlap_check
&&
711 strcmp(opt_overlap_check_template
, opt_overlap_check
))
713 error_setg(errp
, "Conflicting values for qcow2 options '"
714 QCOW2_OPT_OVERLAP
"' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
715 "' ('%s')", opt_overlap_check
, opt_overlap_check_template
);
719 if (!opt_overlap_check
) {
720 opt_overlap_check
= opt_overlap_check_template
?: "cached";
723 if (!strcmp(opt_overlap_check
, "none")) {
724 overlap_check_template
= 0;
725 } else if (!strcmp(opt_overlap_check
, "constant")) {
726 overlap_check_template
= QCOW2_OL_CONSTANT
;
727 } else if (!strcmp(opt_overlap_check
, "cached")) {
728 overlap_check_template
= QCOW2_OL_CACHED
;
729 } else if (!strcmp(opt_overlap_check
, "all")) {
730 overlap_check_template
= QCOW2_OL_ALL
;
732 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
733 "'overlap-check'. Allowed are any of the following: "
734 "none, constant, cached, all", opt_overlap_check
);
739 r
->overlap_check
= 0;
740 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
741 /* overlap-check defines a template bitmask, but every flag may be
742 * overwritten through the associated boolean option */
744 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
745 overlap_check_template
& (1 << i
)) << i
;
748 r
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
749 r
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
750 r
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
751 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
752 flags
& BDRV_O_UNMAP
);
753 r
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
754 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
755 r
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
756 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
765 static void qcow2_update_options_commit(BlockDriverState
*bs
,
768 BDRVQcow2State
*s
= bs
->opaque
;
771 if (s
->l2_table_cache
) {
772 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
774 if (s
->refcount_block_cache
) {
775 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
777 s
->l2_table_cache
= r
->l2_table_cache
;
778 s
->refcount_block_cache
= r
->refcount_block_cache
;
780 s
->overlap_check
= r
->overlap_check
;
781 s
->use_lazy_refcounts
= r
->use_lazy_refcounts
;
783 for (i
= 0; i
< QCOW2_DISCARD_MAX
; i
++) {
784 s
->discard_passthrough
[i
] = r
->discard_passthrough
[i
];
787 if (s
->cache_clean_interval
!= r
->cache_clean_interval
) {
788 cache_clean_timer_del(bs
);
789 s
->cache_clean_interval
= r
->cache_clean_interval
;
790 cache_clean_timer_init(bs
, bdrv_get_aio_context(bs
));
794 static void qcow2_update_options_abort(BlockDriverState
*bs
,
797 if (r
->l2_table_cache
) {
798 qcow2_cache_destroy(bs
, r
->l2_table_cache
);
800 if (r
->refcount_block_cache
) {
801 qcow2_cache_destroy(bs
, r
->refcount_block_cache
);
805 static int qcow2_update_options(BlockDriverState
*bs
, QDict
*options
,
806 int flags
, Error
**errp
)
808 Qcow2ReopenState r
= {};
811 ret
= qcow2_update_options_prepare(bs
, &r
, options
, flags
, errp
);
813 qcow2_update_options_commit(bs
, &r
);
815 qcow2_update_options_abort(bs
, &r
);
821 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
824 BDRVQcow2State
*s
= bs
->opaque
;
828 Error
*local_err
= NULL
;
830 uint64_t l1_vm_state_index
;
832 ret
= bdrv_pread(bs
->file
->bs
, 0, &header
, sizeof(header
));
834 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
837 be32_to_cpus(&header
.magic
);
838 be32_to_cpus(&header
.version
);
839 be64_to_cpus(&header
.backing_file_offset
);
840 be32_to_cpus(&header
.backing_file_size
);
841 be64_to_cpus(&header
.size
);
842 be32_to_cpus(&header
.cluster_bits
);
843 be32_to_cpus(&header
.crypt_method
);
844 be64_to_cpus(&header
.l1_table_offset
);
845 be32_to_cpus(&header
.l1_size
);
846 be64_to_cpus(&header
.refcount_table_offset
);
847 be32_to_cpus(&header
.refcount_table_clusters
);
848 be64_to_cpus(&header
.snapshots_offset
);
849 be32_to_cpus(&header
.nb_snapshots
);
851 if (header
.magic
!= QCOW_MAGIC
) {
852 error_setg(errp
, "Image is not in qcow2 format");
856 if (header
.version
< 2 || header
.version
> 3) {
857 report_unsupported(bs
, errp
, "QCOW version %" PRIu32
, header
.version
);
862 s
->qcow_version
= header
.version
;
864 /* Initialise cluster size */
865 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
866 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
867 error_setg(errp
, "Unsupported cluster size: 2^%" PRIu32
,
868 header
.cluster_bits
);
873 s
->cluster_bits
= header
.cluster_bits
;
874 s
->cluster_size
= 1 << s
->cluster_bits
;
875 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
877 /* Initialise version 3 header fields */
878 if (header
.version
== 2) {
879 header
.incompatible_features
= 0;
880 header
.compatible_features
= 0;
881 header
.autoclear_features
= 0;
882 header
.refcount_order
= 4;
883 header
.header_length
= 72;
885 be64_to_cpus(&header
.incompatible_features
);
886 be64_to_cpus(&header
.compatible_features
);
887 be64_to_cpus(&header
.autoclear_features
);
888 be32_to_cpus(&header
.refcount_order
);
889 be32_to_cpus(&header
.header_length
);
891 if (header
.header_length
< 104) {
892 error_setg(errp
, "qcow2 header too short");
898 if (header
.header_length
> s
->cluster_size
) {
899 error_setg(errp
, "qcow2 header exceeds cluster size");
904 if (header
.header_length
> sizeof(header
)) {
905 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
906 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
907 ret
= bdrv_pread(bs
->file
->bs
, sizeof(header
), s
->unknown_header_fields
,
908 s
->unknown_header_fields_size
);
910 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
916 if (header
.backing_file_offset
> s
->cluster_size
) {
917 error_setg(errp
, "Invalid backing file offset");
922 if (header
.backing_file_offset
) {
923 ext_end
= header
.backing_file_offset
;
925 ext_end
= 1 << header
.cluster_bits
;
928 /* Handle feature bits */
929 s
->incompatible_features
= header
.incompatible_features
;
930 s
->compatible_features
= header
.compatible_features
;
931 s
->autoclear_features
= header
.autoclear_features
;
933 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
934 void *feature_table
= NULL
;
935 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
936 &feature_table
, NULL
);
937 report_unsupported_feature(bs
, errp
, feature_table
,
938 s
->incompatible_features
&
939 ~QCOW2_INCOMPAT_MASK
);
941 g_free(feature_table
);
945 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
946 /* Corrupt images may not be written to unless they are being repaired
948 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
949 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
956 /* Check support for various header values */
957 if (header
.refcount_order
> 6) {
958 error_setg(errp
, "Reference count entry width too large; may not "
963 s
->refcount_order
= header
.refcount_order
;
964 s
->refcount_bits
= 1 << s
->refcount_order
;
965 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
966 s
->refcount_max
+= s
->refcount_max
- 1;
968 if (header
.crypt_method
> QCOW_CRYPT_AES
) {
969 error_setg(errp
, "Unsupported encryption method: %" PRIu32
,
970 header
.crypt_method
);
974 if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128
)) {
975 error_setg(errp
, "AES cipher not available");
979 s
->crypt_method_header
= header
.crypt_method
;
980 if (s
->crypt_method_header
) {
984 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
985 s
->l2_size
= 1 << s
->l2_bits
;
986 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
987 s
->refcount_block_bits
= s
->cluster_bits
- (s
->refcount_order
- 3);
988 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
989 bs
->total_sectors
= header
.size
/ 512;
990 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
991 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
992 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
994 s
->refcount_table_offset
= header
.refcount_table_offset
;
995 s
->refcount_table_size
=
996 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
998 if (header
.refcount_table_clusters
> qcow2_max_refcount_clusters(s
)) {
999 error_setg(errp
, "Reference count table too large");
1004 ret
= validate_table_offset(bs
, s
->refcount_table_offset
,
1005 s
->refcount_table_size
, sizeof(uint64_t));
1007 error_setg(errp
, "Invalid reference count table offset");
1011 /* Snapshot table offset/length */
1012 if (header
.nb_snapshots
> QCOW_MAX_SNAPSHOTS
) {
1013 error_setg(errp
, "Too many snapshots");
1018 ret
= validate_table_offset(bs
, header
.snapshots_offset
,
1019 header
.nb_snapshots
,
1020 sizeof(QCowSnapshotHeader
));
1022 error_setg(errp
, "Invalid snapshot table offset");
1026 /* read the level 1 table */
1027 if (header
.l1_size
> QCOW_MAX_L1_SIZE
/ sizeof(uint64_t)) {
1028 error_setg(errp
, "Active L1 table too large");
1032 s
->l1_size
= header
.l1_size
;
1034 l1_vm_state_index
= size_to_l1(s
, header
.size
);
1035 if (l1_vm_state_index
> INT_MAX
) {
1036 error_setg(errp
, "Image is too big");
1040 s
->l1_vm_state_index
= l1_vm_state_index
;
1042 /* the L1 table must contain at least enough entries to put
1043 header.size bytes */
1044 if (s
->l1_size
< s
->l1_vm_state_index
) {
1045 error_setg(errp
, "L1 table is too small");
1050 ret
= validate_table_offset(bs
, header
.l1_table_offset
,
1051 header
.l1_size
, sizeof(uint64_t));
1053 error_setg(errp
, "Invalid L1 table offset");
1056 s
->l1_table_offset
= header
.l1_table_offset
;
1059 if (s
->l1_size
> 0) {
1060 s
->l1_table
= qemu_try_blockalign(bs
->file
->bs
,
1061 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
1062 if (s
->l1_table
== NULL
) {
1063 error_setg(errp
, "Could not allocate L1 table");
1067 ret
= bdrv_pread(bs
->file
->bs
, s
->l1_table_offset
, s
->l1_table
,
1068 s
->l1_size
* sizeof(uint64_t));
1070 error_setg_errno(errp
, -ret
, "Could not read L1 table");
1073 for(i
= 0;i
< s
->l1_size
; i
++) {
1074 be64_to_cpus(&s
->l1_table
[i
]);
1078 /* Parse driver-specific options */
1079 ret
= qcow2_update_options(bs
, options
, flags
, errp
);
1084 s
->cluster_cache
= g_malloc(s
->cluster_size
);
1085 /* one more sector for decompressed data alignment */
1086 s
->cluster_data
= qemu_try_blockalign(bs
->file
->bs
, QCOW_MAX_CRYPT_CLUSTERS
1087 * s
->cluster_size
+ 512);
1088 if (s
->cluster_data
== NULL
) {
1089 error_setg(errp
, "Could not allocate temporary cluster buffer");
1094 s
->cluster_cache_offset
= -1;
1097 ret
= qcow2_refcount_init(bs
);
1099 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
1103 QLIST_INIT(&s
->cluster_allocs
);
1104 QTAILQ_INIT(&s
->discards
);
1106 /* read qcow2 extensions */
1107 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
1109 error_propagate(errp
, local_err
);
1114 /* read the backing file name */
1115 if (header
.backing_file_offset
!= 0) {
1116 len
= header
.backing_file_size
;
1117 if (len
> MIN(1023, s
->cluster_size
- header
.backing_file_offset
) ||
1118 len
>= sizeof(bs
->backing_file
)) {
1119 error_setg(errp
, "Backing file name too long");
1123 ret
= bdrv_pread(bs
->file
->bs
, header
.backing_file_offset
,
1124 bs
->backing_file
, len
);
1126 error_setg_errno(errp
, -ret
, "Could not read backing file name");
1129 bs
->backing_file
[len
] = '\0';
1130 s
->image_backing_file
= g_strdup(bs
->backing_file
);
1133 /* Internal snapshots */
1134 s
->snapshots_offset
= header
.snapshots_offset
;
1135 s
->nb_snapshots
= header
.nb_snapshots
;
1137 ret
= qcow2_read_snapshots(bs
);
1139 error_setg_errno(errp
, -ret
, "Could not read snapshots");
1143 /* Clear unknown autoclear feature bits */
1144 if (!bs
->read_only
&& !(flags
& BDRV_O_INCOMING
) && s
->autoclear_features
) {
1145 s
->autoclear_features
= 0;
1146 ret
= qcow2_update_header(bs
);
1148 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
1153 /* Initialise locks */
1154 qemu_co_mutex_init(&s
->lock
);
1156 /* Repair image if dirty */
1157 if (!(flags
& (BDRV_O_CHECK
| BDRV_O_INCOMING
)) && !bs
->read_only
&&
1158 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
1159 BdrvCheckResult result
= {0};
1161 ret
= qcow2_check(bs
, &result
, BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1163 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
1170 BdrvCheckResult result
= {0};
1171 qcow2_check_refcounts(bs
, &result
, 0);
1177 g_free(s
->unknown_header_fields
);
1178 cleanup_unknown_header_ext(bs
);
1179 qcow2_free_snapshots(bs
);
1180 qcow2_refcount_close(bs
);
1181 qemu_vfree(s
->l1_table
);
1182 /* else pre-write overlap checks in cache_destroy may crash */
1184 cache_clean_timer_del(bs
);
1185 if (s
->l2_table_cache
) {
1186 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1188 if (s
->refcount_block_cache
) {
1189 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1191 g_free(s
->cluster_cache
);
1192 qemu_vfree(s
->cluster_data
);
1196 static void qcow2_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
1198 BDRVQcow2State
*s
= bs
->opaque
;
1200 bs
->bl
.write_zeroes_alignment
= s
->cluster_sectors
;
1203 static int qcow2_set_key(BlockDriverState
*bs
, const char *key
)
1205 BDRVQcow2State
*s
= bs
->opaque
;
1210 memset(keybuf
, 0, 16);
1214 /* XXX: we could compress the chars to 7 bits to increase
1216 for(i
= 0;i
< len
;i
++) {
1219 assert(bs
->encrypted
);
1221 qcrypto_cipher_free(s
->cipher
);
1222 s
->cipher
= qcrypto_cipher_new(
1223 QCRYPTO_CIPHER_ALG_AES_128
,
1224 QCRYPTO_CIPHER_MODE_CBC
,
1225 keybuf
, G_N_ELEMENTS(keybuf
),
1229 /* XXX would be nice if errors in this method could
1230 * be properly propagate to the caller. Would need
1231 * the bdrv_set_key() API signature to be fixed. */
1238 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
1239 BlockReopenQueue
*queue
, Error
**errp
)
1241 Qcow2ReopenState
*r
;
1244 r
= g_new0(Qcow2ReopenState
, 1);
1247 ret
= qcow2_update_options_prepare(state
->bs
, r
, state
->options
,
1248 state
->flags
, errp
);
1253 /* We need to write out any unwritten data if we reopen read-only. */
1254 if ((state
->flags
& BDRV_O_RDWR
) == 0) {
1255 ret
= bdrv_flush(state
->bs
);
1260 ret
= qcow2_mark_clean(state
->bs
);
1269 qcow2_update_options_abort(state
->bs
, r
);
1274 static void qcow2_reopen_commit(BDRVReopenState
*state
)
1276 qcow2_update_options_commit(state
->bs
, state
->opaque
);
1277 g_free(state
->opaque
);
1280 static void qcow2_reopen_abort(BDRVReopenState
*state
)
1282 qcow2_update_options_abort(state
->bs
, state
->opaque
);
1283 g_free(state
->opaque
);
1286 static void qcow2_join_options(QDict
*options
, QDict
*old_options
)
1288 bool has_new_overlap_template
=
1289 qdict_haskey(options
, QCOW2_OPT_OVERLAP
) ||
1290 qdict_haskey(options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1291 bool has_new_total_cache_size
=
1292 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
);
1293 bool has_all_cache_options
;
1295 /* New overlap template overrides all old overlap options */
1296 if (has_new_overlap_template
) {
1297 qdict_del(old_options
, QCOW2_OPT_OVERLAP
);
1298 qdict_del(old_options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1299 qdict_del(old_options
, QCOW2_OPT_OVERLAP_MAIN_HEADER
);
1300 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L1
);
1301 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L2
);
1302 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
);
1303 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
);
1304 qdict_del(old_options
, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
);
1305 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L1
);
1306 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L2
);
1309 /* New total cache size overrides all old options */
1310 if (qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
)) {
1311 qdict_del(old_options
, QCOW2_OPT_L2_CACHE_SIZE
);
1312 qdict_del(old_options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1315 qdict_join(options
, old_options
, false);
1318 * If after merging all cache size options are set, an old total size is
1319 * overwritten. Do keep all options, however, if all three are new. The
1320 * resulting error message is what we want to happen.
1322 has_all_cache_options
=
1323 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
) ||
1324 qdict_haskey(options
, QCOW2_OPT_L2_CACHE_SIZE
) ||
1325 qdict_haskey(options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1327 if (has_all_cache_options
&& !has_new_total_cache_size
) {
1328 qdict_del(options
, QCOW2_OPT_CACHE_SIZE
);
1332 static int64_t coroutine_fn
qcow2_co_get_block_status(BlockDriverState
*bs
,
1333 int64_t sector_num
, int nb_sectors
, int *pnum
)
1335 BDRVQcow2State
*s
= bs
->opaque
;
1336 uint64_t cluster_offset
;
1337 int index_in_cluster
, ret
;
1341 qemu_co_mutex_lock(&s
->lock
);
1342 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9, pnum
, &cluster_offset
);
1343 qemu_co_mutex_unlock(&s
->lock
);
1348 if (cluster_offset
!= 0 && ret
!= QCOW2_CLUSTER_COMPRESSED
&&
1350 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1351 cluster_offset
|= (index_in_cluster
<< BDRV_SECTOR_BITS
);
1352 status
|= BDRV_BLOCK_OFFSET_VALID
| cluster_offset
;
1354 if (ret
== QCOW2_CLUSTER_ZERO
) {
1355 status
|= BDRV_BLOCK_ZERO
;
1356 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
1357 status
|= BDRV_BLOCK_DATA
;
1362 /* handle reading after the end of the backing file */
1363 int qcow2_backing_read1(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
1364 int64_t sector_num
, int nb_sectors
)
1367 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
1369 if (sector_num
>= bs
->total_sectors
)
1372 n1
= bs
->total_sectors
- sector_num
;
1374 qemu_iovec_memset(qiov
, 512 * n1
, 0, 512 * (nb_sectors
- n1
));
1379 static coroutine_fn
int qcow2_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
1380 int remaining_sectors
, QEMUIOVector
*qiov
)
1382 BDRVQcow2State
*s
= bs
->opaque
;
1383 int index_in_cluster
, n1
;
1385 int cur_nr_sectors
; /* number of sectors in current iteration */
1386 uint64_t cluster_offset
= 0;
1387 uint64_t bytes_done
= 0;
1388 QEMUIOVector hd_qiov
;
1389 uint8_t *cluster_data
= NULL
;
1391 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1393 qemu_co_mutex_lock(&s
->lock
);
1395 while (remaining_sectors
!= 0) {
1397 /* prepare next request */
1398 cur_nr_sectors
= remaining_sectors
;
1400 cur_nr_sectors
= MIN(cur_nr_sectors
,
1401 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
);
1404 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9,
1405 &cur_nr_sectors
, &cluster_offset
);
1410 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1412 qemu_iovec_reset(&hd_qiov
);
1413 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
,
1414 cur_nr_sectors
* 512);
1417 case QCOW2_CLUSTER_UNALLOCATED
:
1420 /* read from the base image */
1421 n1
= qcow2_backing_read1(bs
->backing
->bs
, &hd_qiov
,
1422 sector_num
, cur_nr_sectors
);
1424 QEMUIOVector local_qiov
;
1426 qemu_iovec_init(&local_qiov
, hd_qiov
.niov
);
1427 qemu_iovec_concat(&local_qiov
, &hd_qiov
, 0,
1428 n1
* BDRV_SECTOR_SIZE
);
1430 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
1431 qemu_co_mutex_unlock(&s
->lock
);
1432 ret
= bdrv_co_readv(bs
->backing
->bs
, sector_num
,
1434 qemu_co_mutex_lock(&s
->lock
);
1436 qemu_iovec_destroy(&local_qiov
);
1443 /* Note: in this case, no need to wait */
1444 qemu_iovec_memset(&hd_qiov
, 0, 0, 512 * cur_nr_sectors
);
1448 case QCOW2_CLUSTER_ZERO
:
1449 qemu_iovec_memset(&hd_qiov
, 0, 0, 512 * cur_nr_sectors
);
1452 case QCOW2_CLUSTER_COMPRESSED
:
1453 /* add AIO support for compressed blocks ? */
1454 ret
= qcow2_decompress_cluster(bs
, cluster_offset
);
1459 qemu_iovec_from_buf(&hd_qiov
, 0,
1460 s
->cluster_cache
+ index_in_cluster
* 512,
1461 512 * cur_nr_sectors
);
1464 case QCOW2_CLUSTER_NORMAL
:
1465 if ((cluster_offset
& 511) != 0) {
1470 if (bs
->encrypted
) {
1474 * For encrypted images, read everything into a temporary
1475 * contiguous buffer on which the AES functions can work.
1477 if (!cluster_data
) {
1479 qemu_try_blockalign(bs
->file
->bs
,
1480 QCOW_MAX_CRYPT_CLUSTERS
1482 if (cluster_data
== NULL
) {
1488 assert(cur_nr_sectors
<=
1489 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
);
1490 qemu_iovec_reset(&hd_qiov
);
1491 qemu_iovec_add(&hd_qiov
, cluster_data
,
1492 512 * cur_nr_sectors
);
1495 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
1496 qemu_co_mutex_unlock(&s
->lock
);
1497 ret
= bdrv_co_readv(bs
->file
->bs
,
1498 (cluster_offset
>> 9) + index_in_cluster
,
1499 cur_nr_sectors
, &hd_qiov
);
1500 qemu_co_mutex_lock(&s
->lock
);
1504 if (bs
->encrypted
) {
1507 if (qcow2_encrypt_sectors(s
, sector_num
, cluster_data
,
1508 cluster_data
, cur_nr_sectors
, false,
1514 qemu_iovec_from_buf(qiov
, bytes_done
,
1515 cluster_data
, 512 * cur_nr_sectors
);
1520 g_assert_not_reached();
1525 remaining_sectors
-= cur_nr_sectors
;
1526 sector_num
+= cur_nr_sectors
;
1527 bytes_done
+= cur_nr_sectors
* 512;
1532 qemu_co_mutex_unlock(&s
->lock
);
1534 qemu_iovec_destroy(&hd_qiov
);
1535 qemu_vfree(cluster_data
);
1540 static coroutine_fn
int qcow2_co_writev(BlockDriverState
*bs
,
1542 int remaining_sectors
,
1545 BDRVQcow2State
*s
= bs
->opaque
;
1546 int index_in_cluster
;
1548 int cur_nr_sectors
; /* number of sectors in current iteration */
1549 uint64_t cluster_offset
;
1550 QEMUIOVector hd_qiov
;
1551 uint64_t bytes_done
= 0;
1552 uint8_t *cluster_data
= NULL
;
1553 QCowL2Meta
*l2meta
= NULL
;
1555 trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num
,
1558 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1560 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1562 qemu_co_mutex_lock(&s
->lock
);
1564 while (remaining_sectors
!= 0) {
1568 trace_qcow2_writev_start_part(qemu_coroutine_self());
1569 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1570 cur_nr_sectors
= remaining_sectors
;
1571 if (bs
->encrypted
&&
1573 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
- index_in_cluster
) {
1575 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
- index_in_cluster
;
1578 ret
= qcow2_alloc_cluster_offset(bs
, sector_num
<< 9,
1579 &cur_nr_sectors
, &cluster_offset
, &l2meta
);
1584 assert((cluster_offset
& 511) == 0);
1586 qemu_iovec_reset(&hd_qiov
);
1587 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
,
1588 cur_nr_sectors
* 512);
1590 if (bs
->encrypted
) {
1593 if (!cluster_data
) {
1594 cluster_data
= qemu_try_blockalign(bs
->file
->bs
,
1595 QCOW_MAX_CRYPT_CLUSTERS
1597 if (cluster_data
== NULL
) {
1603 assert(hd_qiov
.size
<=
1604 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1605 qemu_iovec_to_buf(&hd_qiov
, 0, cluster_data
, hd_qiov
.size
);
1607 if (qcow2_encrypt_sectors(s
, sector_num
, cluster_data
,
1608 cluster_data
, cur_nr_sectors
,
1615 qemu_iovec_reset(&hd_qiov
);
1616 qemu_iovec_add(&hd_qiov
, cluster_data
,
1617 cur_nr_sectors
* 512);
1620 ret
= qcow2_pre_write_overlap_check(bs
, 0,
1621 cluster_offset
+ index_in_cluster
* BDRV_SECTOR_SIZE
,
1622 cur_nr_sectors
* BDRV_SECTOR_SIZE
);
1627 qemu_co_mutex_unlock(&s
->lock
);
1628 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
1629 trace_qcow2_writev_data(qemu_coroutine_self(),
1630 (cluster_offset
>> 9) + index_in_cluster
);
1631 ret
= bdrv_co_writev(bs
->file
->bs
,
1632 (cluster_offset
>> 9) + index_in_cluster
,
1633 cur_nr_sectors
, &hd_qiov
);
1634 qemu_co_mutex_lock(&s
->lock
);
1639 while (l2meta
!= NULL
) {
1642 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
1647 /* Take the request off the list of running requests */
1648 if (l2meta
->nb_clusters
!= 0) {
1649 QLIST_REMOVE(l2meta
, next_in_flight
);
1652 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1654 next
= l2meta
->next
;
1659 remaining_sectors
-= cur_nr_sectors
;
1660 sector_num
+= cur_nr_sectors
;
1661 bytes_done
+= cur_nr_sectors
* 512;
1662 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors
);
1667 qemu_co_mutex_unlock(&s
->lock
);
1669 while (l2meta
!= NULL
) {
1672 if (l2meta
->nb_clusters
!= 0) {
1673 QLIST_REMOVE(l2meta
, next_in_flight
);
1675 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1677 next
= l2meta
->next
;
1682 qemu_iovec_destroy(&hd_qiov
);
1683 qemu_vfree(cluster_data
);
1684 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
1689 static void qcow2_close(BlockDriverState
*bs
)
1691 BDRVQcow2State
*s
= bs
->opaque
;
1692 qemu_vfree(s
->l1_table
);
1693 /* else pre-write overlap checks in cache_destroy may crash */
1696 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
1699 ret1
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1700 ret2
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1703 error_report("Failed to flush the L2 table cache: %s",
1707 error_report("Failed to flush the refcount block cache: %s",
1711 if (!ret1
&& !ret2
) {
1712 qcow2_mark_clean(bs
);
1716 cache_clean_timer_del(bs
);
1717 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1718 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1720 qcrypto_cipher_free(s
->cipher
);
1723 g_free(s
->unknown_header_fields
);
1724 cleanup_unknown_header_ext(bs
);
1726 g_free(s
->image_backing_file
);
1727 g_free(s
->image_backing_format
);
1729 g_free(s
->cluster_cache
);
1730 qemu_vfree(s
->cluster_data
);
1731 qcow2_refcount_close(bs
);
1732 qcow2_free_snapshots(bs
);
1735 static void qcow2_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
1737 BDRVQcow2State
*s
= bs
->opaque
;
1738 int flags
= s
->flags
;
1739 QCryptoCipher
*cipher
= NULL
;
1741 Error
*local_err
= NULL
;
1745 * Backing files are read-only which makes all of their metadata immutable,
1746 * that means we don't have to worry about reopening them here.
1754 bdrv_invalidate_cache(bs
->file
->bs
, &local_err
);
1756 error_propagate(errp
, local_err
);
1760 memset(s
, 0, sizeof(BDRVQcow2State
));
1761 options
= qdict_clone_shallow(bs
->options
);
1763 ret
= qcow2_open(bs
, options
, flags
, &local_err
);
1766 error_propagate(errp
, local_err
);
1767 error_prepend(errp
, "Could not reopen qcow2 layer: ");
1769 } else if (ret
< 0) {
1770 error_setg_errno(errp
, -ret
, "Could not reopen qcow2 layer");
1777 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
1778 size_t len
, size_t buflen
)
1780 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
1781 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
1783 if (buflen
< ext_len
) {
1787 *ext_backing_fmt
= (QCowExtension
) {
1788 .magic
= cpu_to_be32(magic
),
1789 .len
= cpu_to_be32(len
),
1791 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
1797 * Updates the qcow2 header, including the variable length parts of it, i.e.
1798 * the backing file name and all extensions. qcow2 was not designed to allow
1799 * such changes, so if we run out of space (we can only use the first cluster)
1800 * this function may fail.
1802 * Returns 0 on success, -errno in error cases.
1804 int qcow2_update_header(BlockDriverState
*bs
)
1806 BDRVQcow2State
*s
= bs
->opaque
;
1809 size_t buflen
= s
->cluster_size
;
1811 uint64_t total_size
;
1812 uint32_t refcount_table_clusters
;
1813 size_t header_length
;
1814 Qcow2UnknownHeaderExtension
*uext
;
1816 buf
= qemu_blockalign(bs
, buflen
);
1818 /* Header structure */
1819 header
= (QCowHeader
*) buf
;
1821 if (buflen
< sizeof(*header
)) {
1826 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
1827 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1828 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
1830 *header
= (QCowHeader
) {
1831 /* Version 2 fields */
1832 .magic
= cpu_to_be32(QCOW_MAGIC
),
1833 .version
= cpu_to_be32(s
->qcow_version
),
1834 .backing_file_offset
= 0,
1835 .backing_file_size
= 0,
1836 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
1837 .size
= cpu_to_be64(total_size
),
1838 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
1839 .l1_size
= cpu_to_be32(s
->l1_size
),
1840 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
1841 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
1842 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
1843 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
1844 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
1846 /* Version 3 fields */
1847 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
1848 .compatible_features
= cpu_to_be64(s
->compatible_features
),
1849 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
1850 .refcount_order
= cpu_to_be32(s
->refcount_order
),
1851 .header_length
= cpu_to_be32(header_length
),
1854 /* For older versions, write a shorter header */
1855 switch (s
->qcow_version
) {
1857 ret
= offsetof(QCowHeader
, incompatible_features
);
1860 ret
= sizeof(*header
);
1869 memset(buf
, 0, buflen
);
1871 /* Preserve any unknown field in the header */
1872 if (s
->unknown_header_fields_size
) {
1873 if (buflen
< s
->unknown_header_fields_size
) {
1878 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
1879 buf
+= s
->unknown_header_fields_size
;
1880 buflen
-= s
->unknown_header_fields_size
;
1883 /* Backing file format header extension */
1884 if (s
->image_backing_format
) {
1885 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
1886 s
->image_backing_format
,
1887 strlen(s
->image_backing_format
),
1898 Qcow2Feature features
[] = {
1900 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1901 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
1902 .name
= "dirty bit",
1905 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1906 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
1907 .name
= "corrupt bit",
1910 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
1911 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
1912 .name
= "lazy refcounts",
1916 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
1917 features
, sizeof(features
), buflen
);
1924 /* Keep unknown header extensions */
1925 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
1926 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
1935 /* End of header extensions */
1936 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
1944 /* Backing file name */
1945 if (s
->image_backing_file
) {
1946 size_t backing_file_len
= strlen(s
->image_backing_file
);
1948 if (buflen
< backing_file_len
) {
1953 /* Using strncpy is ok here, since buf is not NUL-terminated. */
1954 strncpy(buf
, s
->image_backing_file
, buflen
);
1956 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
1957 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
1960 /* Write the new header */
1961 ret
= bdrv_pwrite(bs
->file
->bs
, 0, header
, s
->cluster_size
);
1972 static int qcow2_change_backing_file(BlockDriverState
*bs
,
1973 const char *backing_file
, const char *backing_fmt
)
1975 BDRVQcow2State
*s
= bs
->opaque
;
1977 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1978 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1980 g_free(s
->image_backing_file
);
1981 g_free(s
->image_backing_format
);
1983 s
->image_backing_file
= backing_file
? g_strdup(bs
->backing_file
) : NULL
;
1984 s
->image_backing_format
= backing_fmt
? g_strdup(bs
->backing_format
) : NULL
;
1986 return qcow2_update_header(bs
);
1989 static int preallocate(BlockDriverState
*bs
)
1991 uint64_t nb_sectors
;
1993 uint64_t host_offset
= 0;
1998 nb_sectors
= bdrv_nb_sectors(bs
);
2001 while (nb_sectors
) {
2002 num
= MIN(nb_sectors
, INT_MAX
>> BDRV_SECTOR_BITS
);
2003 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &num
,
2004 &host_offset
, &meta
);
2010 QCowL2Meta
*next
= meta
->next
;
2012 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
2014 qcow2_free_any_clusters(bs
, meta
->alloc_offset
,
2015 meta
->nb_clusters
, QCOW2_DISCARD_NEVER
);
2019 /* There are no dependent requests, but we need to remove our
2020 * request from the list of in-flight requests */
2021 QLIST_REMOVE(meta
, next_in_flight
);
2027 /* TODO Preallocate data if requested */
2030 offset
+= num
<< BDRV_SECTOR_BITS
;
2034 * It is expected that the image file is large enough to actually contain
2035 * all of the allocated clusters (otherwise we get failing reads after
2036 * EOF). Extend the image to the last allocated sector.
2038 if (host_offset
!= 0) {
2039 uint8_t buf
[BDRV_SECTOR_SIZE
];
2040 memset(buf
, 0, BDRV_SECTOR_SIZE
);
2041 ret
= bdrv_write(bs
->file
->bs
,
2042 (host_offset
>> BDRV_SECTOR_BITS
) + num
- 1,
2052 static int qcow2_create2(const char *filename
, int64_t total_size
,
2053 const char *backing_file
, const char *backing_format
,
2054 int flags
, size_t cluster_size
, PreallocMode prealloc
,
2055 QemuOpts
*opts
, int version
, int refcount_order
,
2061 /* Calculate cluster_bits */
2062 cluster_bits
= ctz32(cluster_size
);
2063 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
2064 (1 << cluster_bits
) != cluster_size
)
2066 error_setg(errp
, "Cluster size must be a power of two between %d and "
2067 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
2072 * Open the image file and write a minimal qcow2 header.
2074 * We keep things simple and start with a zero-sized image. We also
2075 * do without refcount blocks or a L1 table for now. We'll fix the
2076 * inconsistency later.
2078 * We do need a refcount table because growing the refcount table means
2079 * allocating two new refcount blocks - the seconds of which would be at
2080 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
2081 * size for any qcow2 image.
2083 BlockDriverState
* bs
;
2085 uint64_t* refcount_table
;
2086 Error
*local_err
= NULL
;
2089 if (prealloc
== PREALLOC_MODE_FULL
|| prealloc
== PREALLOC_MODE_FALLOC
) {
2090 /* Note: The following calculation does not need to be exact; if it is a
2091 * bit off, either some bytes will be "leaked" (which is fine) or we
2092 * will need to increase the file size by some bytes (which is fine,
2093 * too, as long as the bulk is allocated here). Therefore, using
2094 * floating point arithmetic is fine. */
2095 int64_t meta_size
= 0;
2096 uint64_t nreftablee
, nrefblocke
, nl1e
, nl2e
;
2097 int64_t aligned_total_size
= align_offset(total_size
, cluster_size
);
2098 int refblock_bits
, refblock_size
;
2099 /* refcount entry size in bytes */
2100 double rces
= (1 << refcount_order
) / 8.;
2102 /* see qcow2_open() */
2103 refblock_bits
= cluster_bits
- (refcount_order
- 3);
2104 refblock_size
= 1 << refblock_bits
;
2106 /* header: 1 cluster */
2107 meta_size
+= cluster_size
;
2109 /* total size of L2 tables */
2110 nl2e
= aligned_total_size
/ cluster_size
;
2111 nl2e
= align_offset(nl2e
, cluster_size
/ sizeof(uint64_t));
2112 meta_size
+= nl2e
* sizeof(uint64_t);
2114 /* total size of L1 tables */
2115 nl1e
= nl2e
* sizeof(uint64_t) / cluster_size
;
2116 nl1e
= align_offset(nl1e
, cluster_size
/ sizeof(uint64_t));
2117 meta_size
+= nl1e
* sizeof(uint64_t);
2119 /* total size of refcount blocks
2121 * note: every host cluster is reference-counted, including metadata
2122 * (even refcount blocks are recursively included).
2124 * a = total_size (this is the guest disk size)
2125 * m = meta size not including refcount blocks and refcount tables
2127 * y1 = number of refcount blocks entries
2128 * y2 = meta size including everything
2129 * rces = refcount entry size in bytes
2132 * y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m
2134 * y1 = (a + m) / (c - rces - rces * sizeof(u64) / c)
2136 nrefblocke
= (aligned_total_size
+ meta_size
+ cluster_size
)
2137 / (cluster_size
- rces
- rces
* sizeof(uint64_t)
2139 meta_size
+= DIV_ROUND_UP(nrefblocke
, refblock_size
) * cluster_size
;
2141 /* total size of refcount tables */
2142 nreftablee
= nrefblocke
/ refblock_size
;
2143 nreftablee
= align_offset(nreftablee
, cluster_size
/ sizeof(uint64_t));
2144 meta_size
+= nreftablee
* sizeof(uint64_t);
2146 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
,
2147 aligned_total_size
+ meta_size
, &error_abort
);
2148 qemu_opt_set(opts
, BLOCK_OPT_PREALLOC
, PreallocMode_lookup
[prealloc
],
2152 ret
= bdrv_create_file(filename
, opts
, &local_err
);
2154 error_propagate(errp
, local_err
);
2159 ret
= bdrv_open(&bs
, filename
, NULL
, NULL
, BDRV_O_RDWR
| BDRV_O_PROTOCOL
,
2162 error_propagate(errp
, local_err
);
2166 /* Write the header */
2167 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS
) < sizeof(*header
));
2168 header
= g_malloc0(cluster_size
);
2169 *header
= (QCowHeader
) {
2170 .magic
= cpu_to_be32(QCOW_MAGIC
),
2171 .version
= cpu_to_be32(version
),
2172 .cluster_bits
= cpu_to_be32(cluster_bits
),
2173 .size
= cpu_to_be64(0),
2174 .l1_table_offset
= cpu_to_be64(0),
2175 .l1_size
= cpu_to_be32(0),
2176 .refcount_table_offset
= cpu_to_be64(cluster_size
),
2177 .refcount_table_clusters
= cpu_to_be32(1),
2178 .refcount_order
= cpu_to_be32(refcount_order
),
2179 .header_length
= cpu_to_be32(sizeof(*header
)),
2182 if (flags
& BLOCK_FLAG_ENCRYPT
) {
2183 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
2185 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
2188 if (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
) {
2189 header
->compatible_features
|=
2190 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
2193 ret
= bdrv_pwrite(bs
, 0, header
, cluster_size
);
2196 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
2200 /* Write a refcount table with one refcount block */
2201 refcount_table
= g_malloc0(2 * cluster_size
);
2202 refcount_table
[0] = cpu_to_be64(2 * cluster_size
);
2203 ret
= bdrv_pwrite(bs
, cluster_size
, refcount_table
, 2 * cluster_size
);
2204 g_free(refcount_table
);
2207 error_setg_errno(errp
, -ret
, "Could not write refcount table");
2215 * And now open the image and make it consistent first (i.e. increase the
2216 * refcount of the cluster that is occupied by the header and the refcount
2219 options
= qdict_new();
2220 qdict_put(options
, "driver", qstring_from_str("qcow2"));
2221 ret
= bdrv_open(&bs
, filename
, NULL
, options
,
2222 BDRV_O_RDWR
| BDRV_O_CACHE_WB
| BDRV_O_NO_FLUSH
,
2225 error_propagate(errp
, local_err
);
2229 ret
= qcow2_alloc_clusters(bs
, 3 * cluster_size
);
2231 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
2232 "header and refcount table");
2235 } else if (ret
!= 0) {
2236 error_report("Huh, first cluster in empty image is already in use?");
2240 /* Okay, now that we have a valid image, let's give it the right size */
2241 ret
= bdrv_truncate(bs
, total_size
);
2243 error_setg_errno(errp
, -ret
, "Could not resize image");
2247 /* Want a backing file? There you go.*/
2249 ret
= bdrv_change_backing_file(bs
, backing_file
, backing_format
);
2251 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
2252 "with format '%s'", backing_file
, backing_format
);
2257 /* And if we're supposed to preallocate metadata, do that now */
2258 if (prealloc
!= PREALLOC_MODE_OFF
) {
2259 BDRVQcow2State
*s
= bs
->opaque
;
2260 qemu_co_mutex_lock(&s
->lock
);
2261 ret
= preallocate(bs
);
2262 qemu_co_mutex_unlock(&s
->lock
);
2264 error_setg_errno(errp
, -ret
, "Could not preallocate metadata");
2272 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
2273 options
= qdict_new();
2274 qdict_put(options
, "driver", qstring_from_str("qcow2"));
2275 ret
= bdrv_open(&bs
, filename
, NULL
, options
,
2276 BDRV_O_RDWR
| BDRV_O_CACHE_WB
| BDRV_O_NO_BACKING
,
2279 error_propagate(errp
, local_err
);
2291 static int qcow2_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
2293 char *backing_file
= NULL
;
2294 char *backing_fmt
= NULL
;
2298 size_t cluster_size
= DEFAULT_CLUSTER_SIZE
;
2299 PreallocMode prealloc
;
2301 uint64_t refcount_bits
= 16;
2303 Error
*local_err
= NULL
;
2306 /* Read out options */
2307 size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
2309 backing_file
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
2310 backing_fmt
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FMT
);
2311 if (qemu_opt_get_bool_del(opts
, BLOCK_OPT_ENCRYPT
, false)) {
2312 flags
|= BLOCK_FLAG_ENCRYPT
;
2314 cluster_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
2315 DEFAULT_CLUSTER_SIZE
);
2316 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
2317 prealloc
= qapi_enum_parse(PreallocMode_lookup
, buf
,
2318 PREALLOC_MODE__MAX
, PREALLOC_MODE_OFF
,
2321 error_propagate(errp
, local_err
);
2326 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_COMPAT_LEVEL
);
2328 /* keep the default */
2329 } else if (!strcmp(buf
, "0.10")) {
2331 } else if (!strcmp(buf
, "1.1")) {
2334 error_setg(errp
, "Invalid compatibility level: '%s'", buf
);
2339 if (qemu_opt_get_bool_del(opts
, BLOCK_OPT_LAZY_REFCOUNTS
, false)) {
2340 flags
|= BLOCK_FLAG_LAZY_REFCOUNTS
;
2343 if (backing_file
&& prealloc
!= PREALLOC_MODE_OFF
) {
2344 error_setg(errp
, "Backing file and preallocation cannot be used at "
2350 if (version
< 3 && (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
)) {
2351 error_setg(errp
, "Lazy refcounts only supported with compatibility "
2352 "level 1.1 and above (use compat=1.1 or greater)");
2357 refcount_bits
= qemu_opt_get_number_del(opts
, BLOCK_OPT_REFCOUNT_BITS
,
2359 if (refcount_bits
> 64 || !is_power_of_2(refcount_bits
)) {
2360 error_setg(errp
, "Refcount width must be a power of two and may not "
2366 if (version
< 3 && refcount_bits
!= 16) {
2367 error_setg(errp
, "Different refcount widths than 16 bits require "
2368 "compatibility level 1.1 or above (use compat=1.1 or "
2374 refcount_order
= ctz32(refcount_bits
);
2376 ret
= qcow2_create2(filename
, size
, backing_file
, backing_fmt
, flags
,
2377 cluster_size
, prealloc
, opts
, version
, refcount_order
,
2380 error_propagate(errp
, local_err
);
2384 g_free(backing_file
);
2385 g_free(backing_fmt
);
2390 static coroutine_fn
int qcow2_co_write_zeroes(BlockDriverState
*bs
,
2391 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
2394 BDRVQcow2State
*s
= bs
->opaque
;
2396 /* Emulate misaligned zero writes */
2397 if (sector_num
% s
->cluster_sectors
|| nb_sectors
% s
->cluster_sectors
) {
2401 /* Whatever is left can use real zero clusters */
2402 qemu_co_mutex_lock(&s
->lock
);
2403 ret
= qcow2_zero_clusters(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2405 qemu_co_mutex_unlock(&s
->lock
);
2410 static coroutine_fn
int qcow2_co_discard(BlockDriverState
*bs
,
2411 int64_t sector_num
, int nb_sectors
)
2414 BDRVQcow2State
*s
= bs
->opaque
;
2416 qemu_co_mutex_lock(&s
->lock
);
2417 ret
= qcow2_discard_clusters(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2418 nb_sectors
, QCOW2_DISCARD_REQUEST
, false);
2419 qemu_co_mutex_unlock(&s
->lock
);
2423 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
)
2425 BDRVQcow2State
*s
= bs
->opaque
;
2426 int64_t new_l1_size
;
2430 error_report("The new size must be a multiple of 512");
2434 /* cannot proceed if image has snapshots */
2435 if (s
->nb_snapshots
) {
2436 error_report("Can't resize an image which has snapshots");
2440 /* shrinking is currently not supported */
2441 if (offset
< bs
->total_sectors
* 512) {
2442 error_report("qcow2 doesn't support shrinking images yet");
2446 new_l1_size
= size_to_l1(s
, offset
);
2447 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
2452 /* write updated header.size */
2453 offset
= cpu_to_be64(offset
);
2454 ret
= bdrv_pwrite_sync(bs
->file
->bs
, offsetof(QCowHeader
, size
),
2455 &offset
, sizeof(uint64_t));
2460 s
->l1_vm_state_index
= new_l1_size
;
2464 /* XXX: put compressed sectors first, then all the cluster aligned
2465 tables to avoid losing bytes in alignment */
2466 static int qcow2_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2467 const uint8_t *buf
, int nb_sectors
)
2469 BDRVQcow2State
*s
= bs
->opaque
;
2473 uint64_t cluster_offset
;
2475 if (nb_sectors
== 0) {
2476 /* align end of file to a sector boundary to ease reading with
2477 sector based I/Os */
2478 cluster_offset
= bdrv_getlength(bs
->file
->bs
);
2479 return bdrv_truncate(bs
->file
->bs
, cluster_offset
);
2482 if (nb_sectors
!= s
->cluster_sectors
) {
2485 /* Zero-pad last write if image size is not cluster aligned */
2486 if (sector_num
+ nb_sectors
== bs
->total_sectors
&&
2487 nb_sectors
< s
->cluster_sectors
) {
2488 uint8_t *pad_buf
= qemu_blockalign(bs
, s
->cluster_size
);
2489 memset(pad_buf
, 0, s
->cluster_size
);
2490 memcpy(pad_buf
, buf
, nb_sectors
* BDRV_SECTOR_SIZE
);
2491 ret
= qcow2_write_compressed(bs
, sector_num
,
2492 pad_buf
, s
->cluster_sectors
);
2493 qemu_vfree(pad_buf
);
2498 out_buf
= g_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
2500 /* best compression, small window, no zlib header */
2501 memset(&strm
, 0, sizeof(strm
));
2502 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
2504 9, Z_DEFAULT_STRATEGY
);
2510 strm
.avail_in
= s
->cluster_size
;
2511 strm
.next_in
= (uint8_t *)buf
;
2512 strm
.avail_out
= s
->cluster_size
;
2513 strm
.next_out
= out_buf
;
2515 ret
= deflate(&strm
, Z_FINISH
);
2516 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
2521 out_len
= strm
.next_out
- out_buf
;
2525 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
2526 /* could not compress: write normal cluster */
2527 ret
= bdrv_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
2532 cluster_offset
= qcow2_alloc_compressed_cluster_offset(bs
,
2533 sector_num
<< 9, out_len
);
2534 if (!cluster_offset
) {
2538 cluster_offset
&= s
->cluster_offset_mask
;
2540 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
);
2545 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
2546 ret
= bdrv_pwrite(bs
->file
->bs
, cluster_offset
, out_buf
, out_len
);
2558 static int make_completely_empty(BlockDriverState
*bs
)
2560 BDRVQcow2State
*s
= bs
->opaque
;
2561 int ret
, l1_clusters
;
2563 uint64_t *new_reftable
= NULL
;
2564 uint64_t rt_entry
, l1_size2
;
2567 uint64_t reftable_offset
;
2568 uint32_t reftable_clusters
;
2569 } QEMU_PACKED l1_ofs_rt_ofs_cls
;
2571 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
2576 ret
= qcow2_cache_empty(bs
, s
->refcount_block_cache
);
2581 /* Refcounts will be broken utterly */
2582 ret
= qcow2_mark_dirty(bs
);
2587 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
2589 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
2590 l1_size2
= (uint64_t)s
->l1_size
* sizeof(uint64_t);
2592 /* After this call, neither the in-memory nor the on-disk refcount
2593 * information accurately describe the actual references */
2595 ret
= bdrv_write_zeroes(bs
->file
->bs
, s
->l1_table_offset
/ BDRV_SECTOR_SIZE
,
2596 l1_clusters
* s
->cluster_sectors
, 0);
2598 goto fail_broken_refcounts
;
2600 memset(s
->l1_table
, 0, l1_size2
);
2602 BLKDBG_EVENT(bs
->file
, BLKDBG_EMPTY_IMAGE_PREPARE
);
2604 /* Overwrite enough clusters at the beginning of the sectors to place
2605 * the refcount table, a refcount block and the L1 table in; this may
2606 * overwrite parts of the existing refcount and L1 table, which is not
2607 * an issue because the dirty flag is set, complete data loss is in fact
2608 * desired and partial data loss is consequently fine as well */
2609 ret
= bdrv_write_zeroes(bs
->file
->bs
, s
->cluster_size
/ BDRV_SECTOR_SIZE
,
2610 (2 + l1_clusters
) * s
->cluster_size
/
2611 BDRV_SECTOR_SIZE
, 0);
2612 /* This call (even if it failed overall) may have overwritten on-disk
2613 * refcount structures; in that case, the in-memory refcount information
2614 * will probably differ from the on-disk information which makes the BDS
2617 goto fail_broken_refcounts
;
2620 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
2621 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_UPDATE
);
2623 /* "Create" an empty reftable (one cluster) directly after the image
2624 * header and an empty L1 table three clusters after the image header;
2625 * the cluster between those two will be used as the first refblock */
2626 cpu_to_be64w(&l1_ofs_rt_ofs_cls
.l1_offset
, 3 * s
->cluster_size
);
2627 cpu_to_be64w(&l1_ofs_rt_ofs_cls
.reftable_offset
, s
->cluster_size
);
2628 cpu_to_be32w(&l1_ofs_rt_ofs_cls
.reftable_clusters
, 1);
2629 ret
= bdrv_pwrite_sync(bs
->file
->bs
, offsetof(QCowHeader
, l1_table_offset
),
2630 &l1_ofs_rt_ofs_cls
, sizeof(l1_ofs_rt_ofs_cls
));
2632 goto fail_broken_refcounts
;
2635 s
->l1_table_offset
= 3 * s
->cluster_size
;
2637 new_reftable
= g_try_new0(uint64_t, s
->cluster_size
/ sizeof(uint64_t));
2638 if (!new_reftable
) {
2640 goto fail_broken_refcounts
;
2643 s
->refcount_table_offset
= s
->cluster_size
;
2644 s
->refcount_table_size
= s
->cluster_size
/ sizeof(uint64_t);
2646 g_free(s
->refcount_table
);
2647 s
->refcount_table
= new_reftable
;
2648 new_reftable
= NULL
;
2650 /* Now the in-memory refcount information again corresponds to the on-disk
2651 * information (reftable is empty and no refblocks (the refblock cache is
2652 * empty)); however, this means some clusters (e.g. the image header) are
2653 * referenced, but not refcounted, but the normal qcow2 code assumes that
2654 * the in-memory information is always correct */
2656 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
2658 /* Enter the first refblock into the reftable */
2659 rt_entry
= cpu_to_be64(2 * s
->cluster_size
);
2660 ret
= bdrv_pwrite_sync(bs
->file
->bs
, s
->cluster_size
,
2661 &rt_entry
, sizeof(rt_entry
));
2663 goto fail_broken_refcounts
;
2665 s
->refcount_table
[0] = 2 * s
->cluster_size
;
2667 s
->free_cluster_index
= 0;
2668 assert(3 + l1_clusters
<= s
->refcount_block_size
);
2669 offset
= qcow2_alloc_clusters(bs
, 3 * s
->cluster_size
+ l1_size2
);
2672 goto fail_broken_refcounts
;
2673 } else if (offset
> 0) {
2674 error_report("First cluster in emptied image is in use");
2678 /* Now finally the in-memory information corresponds to the on-disk
2679 * structures and is correct */
2680 ret
= qcow2_mark_clean(bs
);
2685 ret
= bdrv_truncate(bs
->file
->bs
, (3 + l1_clusters
) * s
->cluster_size
);
2692 fail_broken_refcounts
:
2693 /* The BDS is unusable at this point. If we wanted to make it usable, we
2694 * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
2695 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
2696 * again. However, because the functions which could have caused this error
2697 * path to be taken are used by those functions as well, it's very likely
2698 * that that sequence will fail as well. Therefore, just eject the BDS. */
2702 g_free(new_reftable
);
2706 static int qcow2_make_empty(BlockDriverState
*bs
)
2708 BDRVQcow2State
*s
= bs
->opaque
;
2709 uint64_t start_sector
;
2710 int sector_step
= INT_MAX
/ BDRV_SECTOR_SIZE
;
2711 int l1_clusters
, ret
= 0;
2713 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
2715 if (s
->qcow_version
>= 3 && !s
->snapshots
&&
2716 3 + l1_clusters
<= s
->refcount_block_size
) {
2717 /* The following function only works for qcow2 v3 images (it requires
2718 * the dirty flag) and only as long as there are no snapshots (because
2719 * it completely empties the image). Furthermore, the L1 table and three
2720 * additional clusters (image header, refcount table, one refcount
2721 * block) have to fit inside one refcount block. */
2722 return make_completely_empty(bs
);
2725 /* This fallback code simply discards every active cluster; this is slow,
2726 * but works in all cases */
2727 for (start_sector
= 0; start_sector
< bs
->total_sectors
;
2728 start_sector
+= sector_step
)
2730 /* As this function is generally used after committing an external
2731 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
2732 * default action for this kind of discard is to pass the discard,
2733 * which will ideally result in an actually smaller image file, as
2734 * is probably desired. */
2735 ret
= qcow2_discard_clusters(bs
, start_sector
* BDRV_SECTOR_SIZE
,
2737 bs
->total_sectors
- start_sector
),
2738 QCOW2_DISCARD_SNAPSHOT
, true);
2747 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
2749 BDRVQcow2State
*s
= bs
->opaque
;
2752 qemu_co_mutex_lock(&s
->lock
);
2753 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
2755 qemu_co_mutex_unlock(&s
->lock
);
2759 if (qcow2_need_accurate_refcounts(s
)) {
2760 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
2762 qemu_co_mutex_unlock(&s
->lock
);
2766 qemu_co_mutex_unlock(&s
->lock
);
2771 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2773 BDRVQcow2State
*s
= bs
->opaque
;
2774 bdi
->unallocated_blocks_are_zero
= true;
2775 bdi
->can_write_zeroes_with_unmap
= (s
->qcow_version
>= 3);
2776 bdi
->cluster_size
= s
->cluster_size
;
2777 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
2781 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
)
2783 BDRVQcow2State
*s
= bs
->opaque
;
2784 ImageInfoSpecific
*spec_info
= g_new(ImageInfoSpecific
, 1);
2786 *spec_info
= (ImageInfoSpecific
){
2787 .type
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
2788 .u
.qcow2
= g_new(ImageInfoSpecificQCow2
, 1),
2790 if (s
->qcow_version
== 2) {
2791 *spec_info
->u
.qcow2
= (ImageInfoSpecificQCow2
){
2792 .compat
= g_strdup("0.10"),
2793 .refcount_bits
= s
->refcount_bits
,
2795 } else if (s
->qcow_version
== 3) {
2796 *spec_info
->u
.qcow2
= (ImageInfoSpecificQCow2
){
2797 .compat
= g_strdup("1.1"),
2798 .lazy_refcounts
= s
->compatible_features
&
2799 QCOW2_COMPAT_LAZY_REFCOUNTS
,
2800 .has_lazy_refcounts
= true,
2801 .corrupt
= s
->incompatible_features
&
2802 QCOW2_INCOMPAT_CORRUPT
,
2803 .has_corrupt
= true,
2804 .refcount_bits
= s
->refcount_bits
,
2807 /* if this assertion fails, this probably means a new version was
2808 * added without having it covered here */
2816 static void dump_refcounts(BlockDriverState
*bs
)
2818 BDRVQcow2State
*s
= bs
->opaque
;
2819 int64_t nb_clusters
, k
, k1
, size
;
2822 size
= bdrv_getlength(bs
->file
->bs
);
2823 nb_clusters
= size_to_clusters(s
, size
);
2824 for(k
= 0; k
< nb_clusters
;) {
2826 refcount
= get_refcount(bs
, k
);
2828 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
2830 printf("%" PRId64
": refcount=%d nb=%" PRId64
"\n", k
, refcount
,
2836 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
2839 BDRVQcow2State
*s
= bs
->opaque
;
2840 int64_t total_sectors
= bs
->total_sectors
;
2841 bool zero_beyond_eof
= bs
->zero_beyond_eof
;
2844 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
2845 bs
->zero_beyond_eof
= false;
2846 ret
= bdrv_pwritev(bs
, qcow2_vm_state_offset(s
) + pos
, qiov
);
2847 bs
->zero_beyond_eof
= zero_beyond_eof
;
2849 /* bdrv_co_do_writev will have increased the total_sectors value to include
2850 * the VM state - the VM state is however not an actual part of the block
2851 * device, therefore, we need to restore the old value. */
2852 bs
->total_sectors
= total_sectors
;
2857 static int qcow2_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
2858 int64_t pos
, int size
)
2860 BDRVQcow2State
*s
= bs
->opaque
;
2861 bool zero_beyond_eof
= bs
->zero_beyond_eof
;
2864 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
2865 bs
->zero_beyond_eof
= false;
2866 ret
= bdrv_pread(bs
, qcow2_vm_state_offset(s
) + pos
, buf
, size
);
2867 bs
->zero_beyond_eof
= zero_beyond_eof
;
2873 * Downgrades an image's version. To achieve this, any incompatible features
2874 * have to be removed.
2876 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
,
2877 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
)
2879 BDRVQcow2State
*s
= bs
->opaque
;
2880 int current_version
= s
->qcow_version
;
2883 if (target_version
== current_version
) {
2885 } else if (target_version
> current_version
) {
2887 } else if (target_version
!= 2) {
2891 if (s
->refcount_order
!= 4) {
2892 error_report("compat=0.10 requires refcount_bits=16");
2896 /* clear incompatible features */
2897 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
2898 ret
= qcow2_mark_clean(bs
);
2904 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
2905 * the first place; if that happens nonetheless, returning -ENOTSUP is the
2906 * best thing to do anyway */
2908 if (s
->incompatible_features
) {
2912 /* since we can ignore compatible features, we can set them to 0 as well */
2913 s
->compatible_features
= 0;
2914 /* if lazy refcounts have been used, they have already been fixed through
2915 * clearing the dirty flag */
2917 /* clearing autoclear features is trivial */
2918 s
->autoclear_features
= 0;
2920 ret
= qcow2_expand_zero_clusters(bs
, status_cb
, cb_opaque
);
2925 s
->qcow_version
= target_version
;
2926 ret
= qcow2_update_header(bs
);
2928 s
->qcow_version
= current_version
;
2934 typedef enum Qcow2AmendOperation
{
2935 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
2936 * statically initialized to so that the helper CB can discern the first
2937 * invocation from an operation change */
2938 QCOW2_NO_OPERATION
= 0,
2940 QCOW2_CHANGING_REFCOUNT_ORDER
,
2942 } Qcow2AmendOperation
;
2944 typedef struct Qcow2AmendHelperCBInfo
{
2945 /* The code coordinating the amend operations should only modify
2946 * these four fields; the rest will be managed by the CB */
2947 BlockDriverAmendStatusCB
*original_status_cb
;
2948 void *original_cb_opaque
;
2950 Qcow2AmendOperation current_operation
;
2952 /* Total number of operations to perform (only set once) */
2953 int total_operations
;
2955 /* The following fields are managed by the CB */
2957 /* Number of operations completed */
2958 int operations_completed
;
2960 /* Cumulative offset of all completed operations */
2961 int64_t offset_completed
;
2963 Qcow2AmendOperation last_operation
;
2964 int64_t last_work_size
;
2965 } Qcow2AmendHelperCBInfo
;
2967 static void qcow2_amend_helper_cb(BlockDriverState
*bs
,
2968 int64_t operation_offset
,
2969 int64_t operation_work_size
, void *opaque
)
2971 Qcow2AmendHelperCBInfo
*info
= opaque
;
2972 int64_t current_work_size
;
2973 int64_t projected_work_size
;
2975 if (info
->current_operation
!= info
->last_operation
) {
2976 if (info
->last_operation
!= QCOW2_NO_OPERATION
) {
2977 info
->offset_completed
+= info
->last_work_size
;
2978 info
->operations_completed
++;
2981 info
->last_operation
= info
->current_operation
;
2984 assert(info
->total_operations
> 0);
2985 assert(info
->operations_completed
< info
->total_operations
);
2987 info
->last_work_size
= operation_work_size
;
2989 current_work_size
= info
->offset_completed
+ operation_work_size
;
2991 /* current_work_size is the total work size for (operations_completed + 1)
2992 * operations (which includes this one), so multiply it by the number of
2993 * operations not covered and divide it by the number of operations
2994 * covered to get a projection for the operations not covered */
2995 projected_work_size
= current_work_size
* (info
->total_operations
-
2996 info
->operations_completed
- 1)
2997 / (info
->operations_completed
+ 1);
2999 info
->original_status_cb(bs
, info
->offset_completed
+ operation_offset
,
3000 current_work_size
+ projected_work_size
,
3001 info
->original_cb_opaque
);
3004 static int qcow2_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3005 BlockDriverAmendStatusCB
*status_cb
,
3008 BDRVQcow2State
*s
= bs
->opaque
;
3009 int old_version
= s
->qcow_version
, new_version
= old_version
;
3010 uint64_t new_size
= 0;
3011 const char *backing_file
= NULL
, *backing_format
= NULL
;
3012 bool lazy_refcounts
= s
->use_lazy_refcounts
;
3013 const char *compat
= NULL
;
3014 uint64_t cluster_size
= s
->cluster_size
;
3016 int refcount_bits
= s
->refcount_bits
;
3018 QemuOptDesc
*desc
= opts
->list
->desc
;
3019 Qcow2AmendHelperCBInfo helper_cb_info
;
3021 while (desc
&& desc
->name
) {
3022 if (!qemu_opt_find(opts
, desc
->name
)) {
3023 /* only change explicitly defined options */
3028 if (!strcmp(desc
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
3029 compat
= qemu_opt_get(opts
, BLOCK_OPT_COMPAT_LEVEL
);
3031 /* preserve default */
3032 } else if (!strcmp(compat
, "0.10")) {
3034 } else if (!strcmp(compat
, "1.1")) {
3037 error_report("Unknown compatibility level %s", compat
);
3040 } else if (!strcmp(desc
->name
, BLOCK_OPT_PREALLOC
)) {
3041 error_report("Cannot change preallocation mode");
3043 } else if (!strcmp(desc
->name
, BLOCK_OPT_SIZE
)) {
3044 new_size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3045 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FILE
)) {
3046 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3047 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FMT
)) {
3048 backing_format
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3049 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT
)) {
3050 encrypt
= qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
,
3053 if (encrypt
!= !!s
->cipher
) {
3054 error_report("Changing the encryption flag is not supported");
3057 } else if (!strcmp(desc
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
3058 cluster_size
= qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
,
3060 if (cluster_size
!= s
->cluster_size
) {
3061 error_report("Changing the cluster size is not supported");
3064 } else if (!strcmp(desc
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
3065 lazy_refcounts
= qemu_opt_get_bool(opts
, BLOCK_OPT_LAZY_REFCOUNTS
,
3067 } else if (!strcmp(desc
->name
, BLOCK_OPT_REFCOUNT_BITS
)) {
3068 refcount_bits
= qemu_opt_get_number(opts
, BLOCK_OPT_REFCOUNT_BITS
,
3071 if (refcount_bits
<= 0 || refcount_bits
> 64 ||
3072 !is_power_of_2(refcount_bits
))
3074 error_report("Refcount width must be a power of two and may "
3075 "not exceed 64 bits");
3079 /* if this point is reached, this probably means a new option was
3080 * added without having it covered here */
3087 helper_cb_info
= (Qcow2AmendHelperCBInfo
){
3088 .original_status_cb
= status_cb
,
3089 .original_cb_opaque
= cb_opaque
,
3090 .total_operations
= (new_version
< old_version
)
3091 + (s
->refcount_bits
!= refcount_bits
)
3094 /* Upgrade first (some features may require compat=1.1) */
3095 if (new_version
> old_version
) {
3096 s
->qcow_version
= new_version
;
3097 ret
= qcow2_update_header(bs
);
3099 s
->qcow_version
= old_version
;
3104 if (s
->refcount_bits
!= refcount_bits
) {
3105 int refcount_order
= ctz32(refcount_bits
);
3106 Error
*local_error
= NULL
;
3108 if (new_version
< 3 && refcount_bits
!= 16) {
3109 error_report("Different refcount widths than 16 bits require "
3110 "compatibility level 1.1 or above (use compat=1.1 or "
3115 helper_cb_info
.current_operation
= QCOW2_CHANGING_REFCOUNT_ORDER
;
3116 ret
= qcow2_change_refcount_order(bs
, refcount_order
,
3117 &qcow2_amend_helper_cb
,
3118 &helper_cb_info
, &local_error
);
3120 error_report_err(local_error
);
3125 if (backing_file
|| backing_format
) {
3126 ret
= qcow2_change_backing_file(bs
,
3127 backing_file
?: s
->image_backing_file
,
3128 backing_format
?: s
->image_backing_format
);
3134 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
3135 if (lazy_refcounts
) {
3136 if (new_version
< 3) {
3137 error_report("Lazy refcounts only supported with compatibility "
3138 "level 1.1 and above (use compat=1.1 or greater)");
3141 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
3142 ret
= qcow2_update_header(bs
);
3144 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
3147 s
->use_lazy_refcounts
= true;
3149 /* make image clean first */
3150 ret
= qcow2_mark_clean(bs
);
3154 /* now disallow lazy refcounts */
3155 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
3156 ret
= qcow2_update_header(bs
);
3158 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
3161 s
->use_lazy_refcounts
= false;
3166 ret
= bdrv_truncate(bs
, new_size
);
3172 /* Downgrade last (so unsupported features can be removed before) */
3173 if (new_version
< old_version
) {
3174 helper_cb_info
.current_operation
= QCOW2_DOWNGRADING
;
3175 ret
= qcow2_downgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
3186 * If offset or size are negative, respectively, they will not be included in
3187 * the BLOCK_IMAGE_CORRUPTED event emitted.
3188 * fatal will be ignored for read-only BDS; corruptions found there will always
3189 * be considered non-fatal.
3191 void qcow2_signal_corruption(BlockDriverState
*bs
, bool fatal
, int64_t offset
,
3192 int64_t size
, const char *message_format
, ...)
3194 BDRVQcow2State
*s
= bs
->opaque
;
3195 const char *node_name
;
3199 fatal
= fatal
&& !bs
->read_only
;
3201 if (s
->signaled_corruption
&&
3202 (!fatal
|| (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
)))
3207 va_start(ap
, message_format
);
3208 message
= g_strdup_vprintf(message_format
, ap
);
3212 fprintf(stderr
, "qcow2: Marking image as corrupt: %s; further "
3213 "corruption events will be suppressed\n", message
);
3215 fprintf(stderr
, "qcow2: Image is corrupt: %s; further non-fatal "
3216 "corruption events will be suppressed\n", message
);
3219 node_name
= bdrv_get_node_name(bs
);
3220 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs
),
3221 *node_name
!= '\0', node_name
,
3222 message
, offset
>= 0, offset
,
3224 fatal
, &error_abort
);
3228 qcow2_mark_corrupt(bs
);
3229 bs
->drv
= NULL
; /* make BDS unusable */
3232 s
->signaled_corruption
= true;
3235 static QemuOptsList qcow2_create_opts
= {
3236 .name
= "qcow2-create-opts",
3237 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_create_opts
.head
),
3240 .name
= BLOCK_OPT_SIZE
,
3241 .type
= QEMU_OPT_SIZE
,
3242 .help
= "Virtual disk size"
3245 .name
= BLOCK_OPT_COMPAT_LEVEL
,
3246 .type
= QEMU_OPT_STRING
,
3247 .help
= "Compatibility level (0.10 or 1.1)"
3250 .name
= BLOCK_OPT_BACKING_FILE
,
3251 .type
= QEMU_OPT_STRING
,
3252 .help
= "File name of a base image"
3255 .name
= BLOCK_OPT_BACKING_FMT
,
3256 .type
= QEMU_OPT_STRING
,
3257 .help
= "Image format of the base image"
3260 .name
= BLOCK_OPT_ENCRYPT
,
3261 .type
= QEMU_OPT_BOOL
,
3262 .help
= "Encrypt the image",
3263 .def_value_str
= "off"
3266 .name
= BLOCK_OPT_CLUSTER_SIZE
,
3267 .type
= QEMU_OPT_SIZE
,
3268 .help
= "qcow2 cluster size",
3269 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
)
3272 .name
= BLOCK_OPT_PREALLOC
,
3273 .type
= QEMU_OPT_STRING
,
3274 .help
= "Preallocation mode (allowed values: off, metadata, "
3278 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
3279 .type
= QEMU_OPT_BOOL
,
3280 .help
= "Postpone refcount updates",
3281 .def_value_str
= "off"
3284 .name
= BLOCK_OPT_REFCOUNT_BITS
,
3285 .type
= QEMU_OPT_NUMBER
,
3286 .help
= "Width of a reference count entry in bits",
3287 .def_value_str
= "16"
3289 { /* end of list */ }
3293 BlockDriver bdrv_qcow2
= {
3294 .format_name
= "qcow2",
3295 .instance_size
= sizeof(BDRVQcow2State
),
3296 .bdrv_probe
= qcow2_probe
,
3297 .bdrv_open
= qcow2_open
,
3298 .bdrv_close
= qcow2_close
,
3299 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
3300 .bdrv_reopen_commit
= qcow2_reopen_commit
,
3301 .bdrv_reopen_abort
= qcow2_reopen_abort
,
3302 .bdrv_join_options
= qcow2_join_options
,
3303 .bdrv_create
= qcow2_create
,
3304 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
3305 .bdrv_co_get_block_status
= qcow2_co_get_block_status
,
3306 .bdrv_set_key
= qcow2_set_key
,
3308 .bdrv_co_readv
= qcow2_co_readv
,
3309 .bdrv_co_writev
= qcow2_co_writev
,
3310 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
3312 .bdrv_co_write_zeroes
= qcow2_co_write_zeroes
,
3313 .bdrv_co_discard
= qcow2_co_discard
,
3314 .bdrv_truncate
= qcow2_truncate
,
3315 .bdrv_write_compressed
= qcow2_write_compressed
,
3316 .bdrv_make_empty
= qcow2_make_empty
,
3318 .bdrv_snapshot_create
= qcow2_snapshot_create
,
3319 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
3320 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
3321 .bdrv_snapshot_list
= qcow2_snapshot_list
,
3322 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
3323 .bdrv_get_info
= qcow2_get_info
,
3324 .bdrv_get_specific_info
= qcow2_get_specific_info
,
3326 .bdrv_save_vmstate
= qcow2_save_vmstate
,
3327 .bdrv_load_vmstate
= qcow2_load_vmstate
,
3329 .supports_backing
= true,
3330 .bdrv_change_backing_file
= qcow2_change_backing_file
,
3332 .bdrv_refresh_limits
= qcow2_refresh_limits
,
3333 .bdrv_invalidate_cache
= qcow2_invalidate_cache
,
3335 .create_opts
= &qcow2_create_opts
,
3336 .bdrv_check
= qcow2_check
,
3337 .bdrv_amend_options
= qcow2_amend_options
,
3339 .bdrv_detach_aio_context
= qcow2_detach_aio_context
,
3340 .bdrv_attach_aio_context
= qcow2_attach_aio_context
,
3343 static void bdrv_qcow2_init(void)
3345 bdrv_register(&bdrv_qcow2
);
3348 block_init(bdrv_qcow2_init
);