2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "block/block_int.h"
26 #include "sysemu/block-backend.h"
27 #include "qemu/module.h"
29 #include "block/qcow2.h"
30 #include "qemu/error-report.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qbool.h"
33 #include "qapi/util.h"
34 #include "qapi/qmp/types.h"
35 #include "qapi-event.h"
37 #include "qemu/option_int.h"
38 #include "qemu/cutils.h"
39 #include "qemu/bswap.h"
42 Differences with QCOW:
44 - Support for multiple incremental snapshots.
45 - Memory management by reference counts.
46 - Clusters which have a reference count of one have the bit
47 QCOW_OFLAG_COPIED to optimize write performance.
48 - Size of compressed clusters is stored in sectors to reduce bit usage
49 in the cluster offsets.
50 - Support for storing additional data (such as the VM state) in the
52 - If a backing store is used, the cluster size is not constrained
53 (could be backported to QCOW).
54 - L2 tables have always a size of one cluster.
61 } QEMU_PACKED QCowExtension
;
63 #define QCOW2_EXT_MAGIC_END 0
64 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
65 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
67 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
69 const QCowHeader
*cow_header
= (const void *)buf
;
71 if (buf_size
>= sizeof(QCowHeader
) &&
72 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
73 be32_to_cpu(cow_header
->version
) >= 2)
81 * read qcow2 extension and fill bs
82 * start reading from start_offset
83 * finish reading upon magic of value 0 or when end_offset reached
84 * unknown magic is skipped (future extension this version knows nothing about)
85 * return 0 upon success, non-0 otherwise
87 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
88 uint64_t end_offset
, void **p_feature_table
,
91 BDRVQcow2State
*s
= bs
->opaque
;
97 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
99 offset
= start_offset
;
100 while (offset
< end_offset
) {
104 if (offset
> s
->cluster_size
)
105 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
107 printf("attempting to read extended header in offset %lu\n", offset
);
110 ret
= bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
));
112 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
113 "pread fail from offset %" PRIu64
, offset
);
116 be32_to_cpus(&ext
.magic
);
117 be32_to_cpus(&ext
.len
);
118 offset
+= sizeof(ext
);
120 printf("ext.magic = 0x%x\n", ext
.magic
);
122 if (offset
> end_offset
|| ext
.len
> end_offset
- offset
) {
123 error_setg(errp
, "Header extension too large");
128 case QCOW2_EXT_MAGIC_END
:
131 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
132 if (ext
.len
>= sizeof(bs
->backing_format
)) {
133 error_setg(errp
, "ERROR: ext_backing_format: len=%" PRIu32
134 " too large (>=%zu)", ext
.len
,
135 sizeof(bs
->backing_format
));
138 ret
= bdrv_pread(bs
->file
, offset
, bs
->backing_format
, ext
.len
);
140 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
141 "Could not read format name");
144 bs
->backing_format
[ext
.len
] = '\0';
145 s
->image_backing_format
= g_strdup(bs
->backing_format
);
147 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
151 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
152 if (p_feature_table
!= NULL
) {
153 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
154 ret
= bdrv_pread(bs
->file
, offset
, feature_table
, ext
.len
);
156 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
157 "Could not read table");
161 *p_feature_table
= feature_table
;
166 /* unknown magic - save it in case we need to rewrite the header */
168 Qcow2UnknownHeaderExtension
*uext
;
170 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
171 uext
->magic
= ext
.magic
;
173 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
175 ret
= bdrv_pread(bs
->file
, offset
, uext
->data
, uext
->len
);
177 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
178 "Could not read data");
185 offset
+= ((ext
.len
+ 7) & ~7);
191 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
193 BDRVQcow2State
*s
= bs
->opaque
;
194 Qcow2UnknownHeaderExtension
*uext
, *next
;
196 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
197 QLIST_REMOVE(uext
, next
);
202 static void report_unsupported_feature(Error
**errp
, Qcow2Feature
*table
,
205 char *features
= g_strdup("");
208 while (table
&& table
->name
[0] != '\0') {
209 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
210 if (mask
& (1ULL << table
->bit
)) {
212 features
= g_strdup_printf("%s%s%.46s", old
, *old
? ", " : "",
215 mask
&= ~(1ULL << table
->bit
);
223 features
= g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64
,
224 old
, *old
? ", " : "", mask
);
228 error_setg(errp
, "Unsupported qcow2 feature(s): %s", features
);
233 * Sets the dirty bit and flushes afterwards if necessary.
235 * The incompatible_features bit is only set if the image file header was
236 * updated successfully. Therefore it is not required to check the return
237 * value of this function.
239 int qcow2_mark_dirty(BlockDriverState
*bs
)
241 BDRVQcow2State
*s
= bs
->opaque
;
245 assert(s
->qcow_version
>= 3);
247 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
248 return 0; /* already dirty */
251 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
252 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, incompatible_features
),
257 ret
= bdrv_flush(bs
->file
->bs
);
262 /* Only treat image as dirty if the header was updated successfully */
263 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
268 * Clears the dirty bit and flushes before if necessary. Only call this
269 * function when there are no pending requests, it does not guard against
270 * concurrent requests dirtying the image.
272 static int qcow2_mark_clean(BlockDriverState
*bs
)
274 BDRVQcow2State
*s
= bs
->opaque
;
276 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
279 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
281 ret
= bdrv_flush(bs
);
286 return qcow2_update_header(bs
);
292 * Marks the image as corrupt.
294 int qcow2_mark_corrupt(BlockDriverState
*bs
)
296 BDRVQcow2State
*s
= bs
->opaque
;
298 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
299 return qcow2_update_header(bs
);
303 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
304 * before if necessary.
306 int qcow2_mark_consistent(BlockDriverState
*bs
)
308 BDRVQcow2State
*s
= bs
->opaque
;
310 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
311 int ret
= bdrv_flush(bs
);
316 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
317 return qcow2_update_header(bs
);
322 static int qcow2_check(BlockDriverState
*bs
, BdrvCheckResult
*result
,
325 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
330 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
331 ret
= qcow2_mark_clean(bs
);
335 return qcow2_mark_consistent(bs
);
340 static int validate_table_offset(BlockDriverState
*bs
, uint64_t offset
,
341 uint64_t entries
, size_t entry_len
)
343 BDRVQcow2State
*s
= bs
->opaque
;
346 /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
347 * because values will be passed to qemu functions taking int64_t. */
348 if (entries
> INT64_MAX
/ entry_len
) {
352 size
= entries
* entry_len
;
354 if (INT64_MAX
- size
< offset
) {
358 /* Tables must be cluster aligned */
359 if (offset
& (s
->cluster_size
- 1)) {
366 static QemuOptsList qcow2_runtime_opts
= {
368 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
371 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
372 .type
= QEMU_OPT_BOOL
,
373 .help
= "Postpone refcount updates",
376 .name
= QCOW2_OPT_DISCARD_REQUEST
,
377 .type
= QEMU_OPT_BOOL
,
378 .help
= "Pass guest discard requests to the layer below",
381 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
382 .type
= QEMU_OPT_BOOL
,
383 .help
= "Generate discard requests when snapshot related space "
387 .name
= QCOW2_OPT_DISCARD_OTHER
,
388 .type
= QEMU_OPT_BOOL
,
389 .help
= "Generate discard requests when other clusters are freed",
392 .name
= QCOW2_OPT_OVERLAP
,
393 .type
= QEMU_OPT_STRING
,
394 .help
= "Selects which overlap checks to perform from a range of "
395 "templates (none, constant, cached, all)",
398 .name
= QCOW2_OPT_OVERLAP_TEMPLATE
,
399 .type
= QEMU_OPT_STRING
,
400 .help
= "Selects which overlap checks to perform from a range of "
401 "templates (none, constant, cached, all)",
404 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
405 .type
= QEMU_OPT_BOOL
,
406 .help
= "Check for unintended writes into the main qcow2 header",
409 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
410 .type
= QEMU_OPT_BOOL
,
411 .help
= "Check for unintended writes into the active L1 table",
414 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
415 .type
= QEMU_OPT_BOOL
,
416 .help
= "Check for unintended writes into an active L2 table",
419 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
420 .type
= QEMU_OPT_BOOL
,
421 .help
= "Check for unintended writes into the refcount table",
424 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
425 .type
= QEMU_OPT_BOOL
,
426 .help
= "Check for unintended writes into a refcount block",
429 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
430 .type
= QEMU_OPT_BOOL
,
431 .help
= "Check for unintended writes into the snapshot table",
434 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
435 .type
= QEMU_OPT_BOOL
,
436 .help
= "Check for unintended writes into an inactive L1 table",
439 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
440 .type
= QEMU_OPT_BOOL
,
441 .help
= "Check for unintended writes into an inactive L2 table",
444 .name
= QCOW2_OPT_CACHE_SIZE
,
445 .type
= QEMU_OPT_SIZE
,
446 .help
= "Maximum combined metadata (L2 tables and refcount blocks) "
450 .name
= QCOW2_OPT_L2_CACHE_SIZE
,
451 .type
= QEMU_OPT_SIZE
,
452 .help
= "Maximum L2 table cache size",
455 .name
= QCOW2_OPT_REFCOUNT_CACHE_SIZE
,
456 .type
= QEMU_OPT_SIZE
,
457 .help
= "Maximum refcount block cache size",
460 .name
= QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
461 .type
= QEMU_OPT_NUMBER
,
462 .help
= "Clean unused cache entries after this time (in seconds)",
464 { /* end of list */ }
468 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
469 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
470 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
471 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
472 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
473 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
474 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
475 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
476 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
479 static void cache_clean_timer_cb(void *opaque
)
481 BlockDriverState
*bs
= opaque
;
482 BDRVQcow2State
*s
= bs
->opaque
;
483 qcow2_cache_clean_unused(bs
, s
->l2_table_cache
);
484 qcow2_cache_clean_unused(bs
, s
->refcount_block_cache
);
485 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
486 (int64_t) s
->cache_clean_interval
* 1000);
489 static void cache_clean_timer_init(BlockDriverState
*bs
, AioContext
*context
)
491 BDRVQcow2State
*s
= bs
->opaque
;
492 if (s
->cache_clean_interval
> 0) {
493 s
->cache_clean_timer
= aio_timer_new(context
, QEMU_CLOCK_VIRTUAL
,
494 SCALE_MS
, cache_clean_timer_cb
,
496 timer_mod(s
->cache_clean_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
497 (int64_t) s
->cache_clean_interval
* 1000);
501 static void cache_clean_timer_del(BlockDriverState
*bs
)
503 BDRVQcow2State
*s
= bs
->opaque
;
504 if (s
->cache_clean_timer
) {
505 timer_del(s
->cache_clean_timer
);
506 timer_free(s
->cache_clean_timer
);
507 s
->cache_clean_timer
= NULL
;
511 static void qcow2_detach_aio_context(BlockDriverState
*bs
)
513 cache_clean_timer_del(bs
);
516 static void qcow2_attach_aio_context(BlockDriverState
*bs
,
517 AioContext
*new_context
)
519 cache_clean_timer_init(bs
, new_context
);
522 static void read_cache_sizes(BlockDriverState
*bs
, QemuOpts
*opts
,
523 uint64_t *l2_cache_size
,
524 uint64_t *refcount_cache_size
, Error
**errp
)
526 BDRVQcow2State
*s
= bs
->opaque
;
527 uint64_t combined_cache_size
;
528 bool l2_cache_size_set
, refcount_cache_size_set
, combined_cache_size_set
;
530 combined_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_CACHE_SIZE
);
531 l2_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_L2_CACHE_SIZE
);
532 refcount_cache_size_set
= qemu_opt_get(opts
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
534 combined_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_CACHE_SIZE
, 0);
535 *l2_cache_size
= qemu_opt_get_size(opts
, QCOW2_OPT_L2_CACHE_SIZE
, 0);
536 *refcount_cache_size
= qemu_opt_get_size(opts
,
537 QCOW2_OPT_REFCOUNT_CACHE_SIZE
, 0);
539 if (combined_cache_size_set
) {
540 if (l2_cache_size_set
&& refcount_cache_size_set
) {
541 error_setg(errp
, QCOW2_OPT_CACHE_SIZE
", " QCOW2_OPT_L2_CACHE_SIZE
542 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not be set "
545 } else if (*l2_cache_size
> combined_cache_size
) {
546 error_setg(errp
, QCOW2_OPT_L2_CACHE_SIZE
" may not exceed "
547 QCOW2_OPT_CACHE_SIZE
);
549 } else if (*refcount_cache_size
> combined_cache_size
) {
550 error_setg(errp
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
" may not exceed "
551 QCOW2_OPT_CACHE_SIZE
);
555 if (l2_cache_size_set
) {
556 *refcount_cache_size
= combined_cache_size
- *l2_cache_size
;
557 } else if (refcount_cache_size_set
) {
558 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
560 *refcount_cache_size
= combined_cache_size
561 / (DEFAULT_L2_REFCOUNT_SIZE_RATIO
+ 1);
562 *l2_cache_size
= combined_cache_size
- *refcount_cache_size
;
565 if (!l2_cache_size_set
&& !refcount_cache_size_set
) {
566 *l2_cache_size
= MAX(DEFAULT_L2_CACHE_BYTE_SIZE
,
567 (uint64_t)DEFAULT_L2_CACHE_CLUSTERS
569 *refcount_cache_size
= *l2_cache_size
570 / DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
571 } else if (!l2_cache_size_set
) {
572 *l2_cache_size
= *refcount_cache_size
573 * DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
574 } else if (!refcount_cache_size_set
) {
575 *refcount_cache_size
= *l2_cache_size
576 / DEFAULT_L2_REFCOUNT_SIZE_RATIO
;
581 typedef struct Qcow2ReopenState
{
582 Qcow2Cache
*l2_table_cache
;
583 Qcow2Cache
*refcount_block_cache
;
584 bool use_lazy_refcounts
;
586 bool discard_passthrough
[QCOW2_DISCARD_MAX
];
587 uint64_t cache_clean_interval
;
590 static int qcow2_update_options_prepare(BlockDriverState
*bs
,
592 QDict
*options
, int flags
,
595 BDRVQcow2State
*s
= bs
->opaque
;
596 QemuOpts
*opts
= NULL
;
597 const char *opt_overlap_check
, *opt_overlap_check_template
;
598 int overlap_check_template
= 0;
599 uint64_t l2_cache_size
, refcount_cache_size
;
601 Error
*local_err
= NULL
;
604 opts
= qemu_opts_create(&qcow2_runtime_opts
, NULL
, 0, &error_abort
);
605 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
607 error_propagate(errp
, local_err
);
612 /* get L2 table/refcount block cache size from command line options */
613 read_cache_sizes(bs
, opts
, &l2_cache_size
, &refcount_cache_size
,
616 error_propagate(errp
, local_err
);
621 l2_cache_size
/= s
->cluster_size
;
622 if (l2_cache_size
< MIN_L2_CACHE_SIZE
) {
623 l2_cache_size
= MIN_L2_CACHE_SIZE
;
625 if (l2_cache_size
> INT_MAX
) {
626 error_setg(errp
, "L2 cache size too big");
631 refcount_cache_size
/= s
->cluster_size
;
632 if (refcount_cache_size
< MIN_REFCOUNT_CACHE_SIZE
) {
633 refcount_cache_size
= MIN_REFCOUNT_CACHE_SIZE
;
635 if (refcount_cache_size
> INT_MAX
) {
636 error_setg(errp
, "Refcount cache size too big");
641 /* alloc new L2 table/refcount block cache, flush old one */
642 if (s
->l2_table_cache
) {
643 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
645 error_setg_errno(errp
, -ret
, "Failed to flush the L2 table cache");
650 if (s
->refcount_block_cache
) {
651 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
653 error_setg_errno(errp
, -ret
,
654 "Failed to flush the refcount block cache");
659 r
->l2_table_cache
= qcow2_cache_create(bs
, l2_cache_size
);
660 r
->refcount_block_cache
= qcow2_cache_create(bs
, refcount_cache_size
);
661 if (r
->l2_table_cache
== NULL
|| r
->refcount_block_cache
== NULL
) {
662 error_setg(errp
, "Could not allocate metadata caches");
667 /* New interval for cache cleanup timer */
668 r
->cache_clean_interval
=
669 qemu_opt_get_number(opts
, QCOW2_OPT_CACHE_CLEAN_INTERVAL
,
670 s
->cache_clean_interval
);
671 if (r
->cache_clean_interval
> UINT_MAX
) {
672 error_setg(errp
, "Cache clean interval too big");
677 /* lazy-refcounts; flush if going from enabled to disabled */
678 r
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
679 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
680 if (r
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
681 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
682 "qemu 1.1 compatibility level");
687 if (s
->use_lazy_refcounts
&& !r
->use_lazy_refcounts
) {
688 ret
= qcow2_mark_clean(bs
);
690 error_setg_errno(errp
, -ret
, "Failed to disable lazy refcounts");
695 /* Overlap check options */
696 opt_overlap_check
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP
);
697 opt_overlap_check_template
= qemu_opt_get(opts
, QCOW2_OPT_OVERLAP_TEMPLATE
);
698 if (opt_overlap_check_template
&& opt_overlap_check
&&
699 strcmp(opt_overlap_check_template
, opt_overlap_check
))
701 error_setg(errp
, "Conflicting values for qcow2 options '"
702 QCOW2_OPT_OVERLAP
"' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
703 "' ('%s')", opt_overlap_check
, opt_overlap_check_template
);
707 if (!opt_overlap_check
) {
708 opt_overlap_check
= opt_overlap_check_template
?: "cached";
711 if (!strcmp(opt_overlap_check
, "none")) {
712 overlap_check_template
= 0;
713 } else if (!strcmp(opt_overlap_check
, "constant")) {
714 overlap_check_template
= QCOW2_OL_CONSTANT
;
715 } else if (!strcmp(opt_overlap_check
, "cached")) {
716 overlap_check_template
= QCOW2_OL_CACHED
;
717 } else if (!strcmp(opt_overlap_check
, "all")) {
718 overlap_check_template
= QCOW2_OL_ALL
;
720 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
721 "'overlap-check'. Allowed are any of the following: "
722 "none, constant, cached, all", opt_overlap_check
);
727 r
->overlap_check
= 0;
728 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
729 /* overlap-check defines a template bitmask, but every flag may be
730 * overwritten through the associated boolean option */
732 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
733 overlap_check_template
& (1 << i
)) << i
;
736 r
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
737 r
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
738 r
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
739 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
740 flags
& BDRV_O_UNMAP
);
741 r
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
742 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
743 r
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
744 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
753 static void qcow2_update_options_commit(BlockDriverState
*bs
,
756 BDRVQcow2State
*s
= bs
->opaque
;
759 if (s
->l2_table_cache
) {
760 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
762 if (s
->refcount_block_cache
) {
763 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
765 s
->l2_table_cache
= r
->l2_table_cache
;
766 s
->refcount_block_cache
= r
->refcount_block_cache
;
768 s
->overlap_check
= r
->overlap_check
;
769 s
->use_lazy_refcounts
= r
->use_lazy_refcounts
;
771 for (i
= 0; i
< QCOW2_DISCARD_MAX
; i
++) {
772 s
->discard_passthrough
[i
] = r
->discard_passthrough
[i
];
775 if (s
->cache_clean_interval
!= r
->cache_clean_interval
) {
776 cache_clean_timer_del(bs
);
777 s
->cache_clean_interval
= r
->cache_clean_interval
;
778 cache_clean_timer_init(bs
, bdrv_get_aio_context(bs
));
782 static void qcow2_update_options_abort(BlockDriverState
*bs
,
785 if (r
->l2_table_cache
) {
786 qcow2_cache_destroy(bs
, r
->l2_table_cache
);
788 if (r
->refcount_block_cache
) {
789 qcow2_cache_destroy(bs
, r
->refcount_block_cache
);
793 static int qcow2_update_options(BlockDriverState
*bs
, QDict
*options
,
794 int flags
, Error
**errp
)
796 Qcow2ReopenState r
= {};
799 ret
= qcow2_update_options_prepare(bs
, &r
, options
, flags
, errp
);
801 qcow2_update_options_commit(bs
, &r
);
803 qcow2_update_options_abort(bs
, &r
);
809 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
812 BDRVQcow2State
*s
= bs
->opaque
;
816 Error
*local_err
= NULL
;
818 uint64_t l1_vm_state_index
;
820 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
822 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
825 be32_to_cpus(&header
.magic
);
826 be32_to_cpus(&header
.version
);
827 be64_to_cpus(&header
.backing_file_offset
);
828 be32_to_cpus(&header
.backing_file_size
);
829 be64_to_cpus(&header
.size
);
830 be32_to_cpus(&header
.cluster_bits
);
831 be32_to_cpus(&header
.crypt_method
);
832 be64_to_cpus(&header
.l1_table_offset
);
833 be32_to_cpus(&header
.l1_size
);
834 be64_to_cpus(&header
.refcount_table_offset
);
835 be32_to_cpus(&header
.refcount_table_clusters
);
836 be64_to_cpus(&header
.snapshots_offset
);
837 be32_to_cpus(&header
.nb_snapshots
);
839 if (header
.magic
!= QCOW_MAGIC
) {
840 error_setg(errp
, "Image is not in qcow2 format");
844 if (header
.version
< 2 || header
.version
> 3) {
845 error_setg(errp
, "Unsupported qcow2 version %" PRIu32
, header
.version
);
850 s
->qcow_version
= header
.version
;
852 /* Initialise cluster size */
853 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
854 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
855 error_setg(errp
, "Unsupported cluster size: 2^%" PRIu32
,
856 header
.cluster_bits
);
861 s
->cluster_bits
= header
.cluster_bits
;
862 s
->cluster_size
= 1 << s
->cluster_bits
;
863 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
865 /* Initialise version 3 header fields */
866 if (header
.version
== 2) {
867 header
.incompatible_features
= 0;
868 header
.compatible_features
= 0;
869 header
.autoclear_features
= 0;
870 header
.refcount_order
= 4;
871 header
.header_length
= 72;
873 be64_to_cpus(&header
.incompatible_features
);
874 be64_to_cpus(&header
.compatible_features
);
875 be64_to_cpus(&header
.autoclear_features
);
876 be32_to_cpus(&header
.refcount_order
);
877 be32_to_cpus(&header
.header_length
);
879 if (header
.header_length
< 104) {
880 error_setg(errp
, "qcow2 header too short");
886 if (header
.header_length
> s
->cluster_size
) {
887 error_setg(errp
, "qcow2 header exceeds cluster size");
892 if (header
.header_length
> sizeof(header
)) {
893 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
894 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
895 ret
= bdrv_pread(bs
->file
, sizeof(header
), s
->unknown_header_fields
,
896 s
->unknown_header_fields_size
);
898 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
904 if (header
.backing_file_offset
> s
->cluster_size
) {
905 error_setg(errp
, "Invalid backing file offset");
910 if (header
.backing_file_offset
) {
911 ext_end
= header
.backing_file_offset
;
913 ext_end
= 1 << header
.cluster_bits
;
916 /* Handle feature bits */
917 s
->incompatible_features
= header
.incompatible_features
;
918 s
->compatible_features
= header
.compatible_features
;
919 s
->autoclear_features
= header
.autoclear_features
;
921 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
922 void *feature_table
= NULL
;
923 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
924 &feature_table
, NULL
);
925 report_unsupported_feature(errp
, feature_table
,
926 s
->incompatible_features
&
927 ~QCOW2_INCOMPAT_MASK
);
929 g_free(feature_table
);
933 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
934 /* Corrupt images may not be written to unless they are being repaired
936 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
937 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
944 /* Check support for various header values */
945 if (header
.refcount_order
> 6) {
946 error_setg(errp
, "Reference count entry width too large; may not "
951 s
->refcount_order
= header
.refcount_order
;
952 s
->refcount_bits
= 1 << s
->refcount_order
;
953 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
954 s
->refcount_max
+= s
->refcount_max
- 1;
956 if (header
.crypt_method
> QCOW_CRYPT_AES
) {
957 error_setg(errp
, "Unsupported encryption method: %" PRIu32
,
958 header
.crypt_method
);
962 if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128
)) {
963 error_setg(errp
, "AES cipher not available");
967 s
->crypt_method_header
= header
.crypt_method
;
968 if (s
->crypt_method_header
) {
969 if (bdrv_uses_whitelist() &&
970 s
->crypt_method_header
== QCOW_CRYPT_AES
) {
972 "Use of AES-CBC encrypted qcow2 images is no longer "
973 "supported in system emulators");
974 error_append_hint(errp
,
975 "You can use 'qemu-img convert' to convert your "
976 "image to an alternative supported format, such "
977 "as unencrypted qcow2, or raw with the LUKS "
978 "format instead.\n");
983 bs
->encrypted
= true;
986 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
987 s
->l2_size
= 1 << s
->l2_bits
;
988 /* 2^(s->refcount_order - 3) is the refcount width in bytes */
989 s
->refcount_block_bits
= s
->cluster_bits
- (s
->refcount_order
- 3);
990 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
991 bs
->total_sectors
= header
.size
/ 512;
992 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
993 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
994 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
996 s
->refcount_table_offset
= header
.refcount_table_offset
;
997 s
->refcount_table_size
=
998 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
1000 if (header
.refcount_table_clusters
> qcow2_max_refcount_clusters(s
)) {
1001 error_setg(errp
, "Reference count table too large");
1006 ret
= validate_table_offset(bs
, s
->refcount_table_offset
,
1007 s
->refcount_table_size
, sizeof(uint64_t));
1009 error_setg(errp
, "Invalid reference count table offset");
1013 /* Snapshot table offset/length */
1014 if (header
.nb_snapshots
> QCOW_MAX_SNAPSHOTS
) {
1015 error_setg(errp
, "Too many snapshots");
1020 ret
= validate_table_offset(bs
, header
.snapshots_offset
,
1021 header
.nb_snapshots
,
1022 sizeof(QCowSnapshotHeader
));
1024 error_setg(errp
, "Invalid snapshot table offset");
1028 /* read the level 1 table */
1029 if (header
.l1_size
> QCOW_MAX_L1_SIZE
/ sizeof(uint64_t)) {
1030 error_setg(errp
, "Active L1 table too large");
1034 s
->l1_size
= header
.l1_size
;
1036 l1_vm_state_index
= size_to_l1(s
, header
.size
);
1037 if (l1_vm_state_index
> INT_MAX
) {
1038 error_setg(errp
, "Image is too big");
1042 s
->l1_vm_state_index
= l1_vm_state_index
;
1044 /* the L1 table must contain at least enough entries to put
1045 header.size bytes */
1046 if (s
->l1_size
< s
->l1_vm_state_index
) {
1047 error_setg(errp
, "L1 table is too small");
1052 ret
= validate_table_offset(bs
, header
.l1_table_offset
,
1053 header
.l1_size
, sizeof(uint64_t));
1055 error_setg(errp
, "Invalid L1 table offset");
1058 s
->l1_table_offset
= header
.l1_table_offset
;
1061 if (s
->l1_size
> 0) {
1062 s
->l1_table
= qemu_try_blockalign(bs
->file
->bs
,
1063 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
1064 if (s
->l1_table
== NULL
) {
1065 error_setg(errp
, "Could not allocate L1 table");
1069 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
1070 s
->l1_size
* sizeof(uint64_t));
1072 error_setg_errno(errp
, -ret
, "Could not read L1 table");
1075 for(i
= 0;i
< s
->l1_size
; i
++) {
1076 be64_to_cpus(&s
->l1_table
[i
]);
1080 /* Parse driver-specific options */
1081 ret
= qcow2_update_options(bs
, options
, flags
, errp
);
1086 s
->cluster_cache
= g_malloc(s
->cluster_size
);
1087 /* one more sector for decompressed data alignment */
1088 s
->cluster_data
= qemu_try_blockalign(bs
->file
->bs
, QCOW_MAX_CRYPT_CLUSTERS
1089 * s
->cluster_size
+ 512);
1090 if (s
->cluster_data
== NULL
) {
1091 error_setg(errp
, "Could not allocate temporary cluster buffer");
1096 s
->cluster_cache_offset
= -1;
1099 ret
= qcow2_refcount_init(bs
);
1101 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
1105 QLIST_INIT(&s
->cluster_allocs
);
1106 QTAILQ_INIT(&s
->discards
);
1108 /* read qcow2 extensions */
1109 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
1111 error_propagate(errp
, local_err
);
1116 /* read the backing file name */
1117 if (header
.backing_file_offset
!= 0) {
1118 len
= header
.backing_file_size
;
1119 if (len
> MIN(1023, s
->cluster_size
- header
.backing_file_offset
) ||
1120 len
>= sizeof(bs
->backing_file
)) {
1121 error_setg(errp
, "Backing file name too long");
1125 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
1126 bs
->backing_file
, len
);
1128 error_setg_errno(errp
, -ret
, "Could not read backing file name");
1131 bs
->backing_file
[len
] = '\0';
1132 s
->image_backing_file
= g_strdup(bs
->backing_file
);
1135 /* Internal snapshots */
1136 s
->snapshots_offset
= header
.snapshots_offset
;
1137 s
->nb_snapshots
= header
.nb_snapshots
;
1139 ret
= qcow2_read_snapshots(bs
);
1141 error_setg_errno(errp
, -ret
, "Could not read snapshots");
1145 /* Clear unknown autoclear feature bits */
1146 if (!bs
->read_only
&& !(flags
& BDRV_O_INACTIVE
) && s
->autoclear_features
) {
1147 s
->autoclear_features
= 0;
1148 ret
= qcow2_update_header(bs
);
1150 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
1155 /* Initialise locks */
1156 qemu_co_mutex_init(&s
->lock
);
1158 /* Repair image if dirty */
1159 if (!(flags
& (BDRV_O_CHECK
| BDRV_O_INACTIVE
)) && !bs
->read_only
&&
1160 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
1161 BdrvCheckResult result
= {0};
1163 ret
= qcow2_check(bs
, &result
, BDRV_FIX_ERRORS
| BDRV_FIX_LEAKS
);
1165 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
1172 BdrvCheckResult result
= {0};
1173 qcow2_check_refcounts(bs
, &result
, 0);
1179 g_free(s
->unknown_header_fields
);
1180 cleanup_unknown_header_ext(bs
);
1181 qcow2_free_snapshots(bs
);
1182 qcow2_refcount_close(bs
);
1183 qemu_vfree(s
->l1_table
);
1184 /* else pre-write overlap checks in cache_destroy may crash */
1186 cache_clean_timer_del(bs
);
1187 if (s
->l2_table_cache
) {
1188 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1190 if (s
->refcount_block_cache
) {
1191 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1193 g_free(s
->cluster_cache
);
1194 qemu_vfree(s
->cluster_data
);
1198 static void qcow2_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
1200 BDRVQcow2State
*s
= bs
->opaque
;
1202 if (bs
->encrypted
) {
1203 /* Encryption works on a sector granularity */
1204 bs
->bl
.request_alignment
= BDRV_SECTOR_SIZE
;
1206 bs
->bl
.pwrite_zeroes_alignment
= s
->cluster_size
;
1207 bs
->bl
.pdiscard_alignment
= s
->cluster_size
;
1210 static int qcow2_set_key(BlockDriverState
*bs
, const char *key
)
1212 BDRVQcow2State
*s
= bs
->opaque
;
1217 memset(keybuf
, 0, 16);
1221 /* XXX: we could compress the chars to 7 bits to increase
1223 for(i
= 0;i
< len
;i
++) {
1226 assert(bs
->encrypted
);
1228 qcrypto_cipher_free(s
->cipher
);
1229 s
->cipher
= qcrypto_cipher_new(
1230 QCRYPTO_CIPHER_ALG_AES_128
,
1231 QCRYPTO_CIPHER_MODE_CBC
,
1232 keybuf
, G_N_ELEMENTS(keybuf
),
1236 /* XXX would be nice if errors in this method could
1237 * be properly propagate to the caller. Would need
1238 * the bdrv_set_key() API signature to be fixed. */
1245 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
1246 BlockReopenQueue
*queue
, Error
**errp
)
1248 Qcow2ReopenState
*r
;
1251 r
= g_new0(Qcow2ReopenState
, 1);
1254 ret
= qcow2_update_options_prepare(state
->bs
, r
, state
->options
,
1255 state
->flags
, errp
);
1260 /* We need to write out any unwritten data if we reopen read-only. */
1261 if ((state
->flags
& BDRV_O_RDWR
) == 0) {
1262 ret
= bdrv_flush(state
->bs
);
1267 ret
= qcow2_mark_clean(state
->bs
);
1276 qcow2_update_options_abort(state
->bs
, r
);
1281 static void qcow2_reopen_commit(BDRVReopenState
*state
)
1283 qcow2_update_options_commit(state
->bs
, state
->opaque
);
1284 g_free(state
->opaque
);
1287 static void qcow2_reopen_abort(BDRVReopenState
*state
)
1289 qcow2_update_options_abort(state
->bs
, state
->opaque
);
1290 g_free(state
->opaque
);
1293 static void qcow2_join_options(QDict
*options
, QDict
*old_options
)
1295 bool has_new_overlap_template
=
1296 qdict_haskey(options
, QCOW2_OPT_OVERLAP
) ||
1297 qdict_haskey(options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1298 bool has_new_total_cache_size
=
1299 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
);
1300 bool has_all_cache_options
;
1302 /* New overlap template overrides all old overlap options */
1303 if (has_new_overlap_template
) {
1304 qdict_del(old_options
, QCOW2_OPT_OVERLAP
);
1305 qdict_del(old_options
, QCOW2_OPT_OVERLAP_TEMPLATE
);
1306 qdict_del(old_options
, QCOW2_OPT_OVERLAP_MAIN_HEADER
);
1307 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L1
);
1308 qdict_del(old_options
, QCOW2_OPT_OVERLAP_ACTIVE_L2
);
1309 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
);
1310 qdict_del(old_options
, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
);
1311 qdict_del(old_options
, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
);
1312 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L1
);
1313 qdict_del(old_options
, QCOW2_OPT_OVERLAP_INACTIVE_L2
);
1316 /* New total cache size overrides all old options */
1317 if (qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
)) {
1318 qdict_del(old_options
, QCOW2_OPT_L2_CACHE_SIZE
);
1319 qdict_del(old_options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1322 qdict_join(options
, old_options
, false);
1325 * If after merging all cache size options are set, an old total size is
1326 * overwritten. Do keep all options, however, if all three are new. The
1327 * resulting error message is what we want to happen.
1329 has_all_cache_options
=
1330 qdict_haskey(options
, QCOW2_OPT_CACHE_SIZE
) ||
1331 qdict_haskey(options
, QCOW2_OPT_L2_CACHE_SIZE
) ||
1332 qdict_haskey(options
, QCOW2_OPT_REFCOUNT_CACHE_SIZE
);
1334 if (has_all_cache_options
&& !has_new_total_cache_size
) {
1335 qdict_del(options
, QCOW2_OPT_CACHE_SIZE
);
1339 static int64_t coroutine_fn
qcow2_co_get_block_status(BlockDriverState
*bs
,
1340 int64_t sector_num
, int nb_sectors
, int *pnum
, BlockDriverState
**file
)
1342 BDRVQcow2State
*s
= bs
->opaque
;
1343 uint64_t cluster_offset
;
1344 int index_in_cluster
, ret
;
1348 bytes
= MIN(INT_MAX
, nb_sectors
* BDRV_SECTOR_SIZE
);
1349 qemu_co_mutex_lock(&s
->lock
);
1350 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9, &bytes
,
1352 qemu_co_mutex_unlock(&s
->lock
);
1357 *pnum
= bytes
>> BDRV_SECTOR_BITS
;
1359 if (cluster_offset
!= 0 && ret
!= QCOW2_CLUSTER_COMPRESSED
&&
1361 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1362 cluster_offset
|= (index_in_cluster
<< BDRV_SECTOR_BITS
);
1363 *file
= bs
->file
->bs
;
1364 status
|= BDRV_BLOCK_OFFSET_VALID
| cluster_offset
;
1366 if (ret
== QCOW2_CLUSTER_ZERO
) {
1367 status
|= BDRV_BLOCK_ZERO
;
1368 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
1369 status
|= BDRV_BLOCK_DATA
;
1374 /* handle reading after the end of the backing file */
1375 int qcow2_backing_read1(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
1376 int64_t offset
, int bytes
)
1378 uint64_t bs_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1381 if ((offset
+ bytes
) <= bs_size
) {
1385 if (offset
>= bs_size
) {
1388 n1
= bs_size
- offset
;
1391 qemu_iovec_memset(qiov
, n1
, 0, bytes
- n1
);
1396 static coroutine_fn
int qcow2_co_preadv(BlockDriverState
*bs
, uint64_t offset
,
1397 uint64_t bytes
, QEMUIOVector
*qiov
,
1400 BDRVQcow2State
*s
= bs
->opaque
;
1401 int offset_in_cluster
, n1
;
1403 unsigned int cur_bytes
; /* number of bytes in current iteration */
1404 uint64_t cluster_offset
= 0;
1405 uint64_t bytes_done
= 0;
1406 QEMUIOVector hd_qiov
;
1407 uint8_t *cluster_data
= NULL
;
1409 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1411 qemu_co_mutex_lock(&s
->lock
);
1413 while (bytes
!= 0) {
1415 /* prepare next request */
1416 cur_bytes
= MIN(bytes
, INT_MAX
);
1418 cur_bytes
= MIN(cur_bytes
,
1419 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1422 ret
= qcow2_get_cluster_offset(bs
, offset
, &cur_bytes
, &cluster_offset
);
1427 offset_in_cluster
= offset_into_cluster(s
, offset
);
1429 qemu_iovec_reset(&hd_qiov
);
1430 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
1433 case QCOW2_CLUSTER_UNALLOCATED
:
1436 /* read from the base image */
1437 n1
= qcow2_backing_read1(bs
->backing
->bs
, &hd_qiov
,
1440 QEMUIOVector local_qiov
;
1442 qemu_iovec_init(&local_qiov
, hd_qiov
.niov
);
1443 qemu_iovec_concat(&local_qiov
, &hd_qiov
, 0, n1
);
1445 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
1446 qemu_co_mutex_unlock(&s
->lock
);
1447 ret
= bdrv_co_preadv(bs
->backing
, offset
, n1
,
1449 qemu_co_mutex_lock(&s
->lock
);
1451 qemu_iovec_destroy(&local_qiov
);
1458 /* Note: in this case, no need to wait */
1459 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1463 case QCOW2_CLUSTER_ZERO
:
1464 qemu_iovec_memset(&hd_qiov
, 0, 0, cur_bytes
);
1467 case QCOW2_CLUSTER_COMPRESSED
:
1468 /* add AIO support for compressed blocks ? */
1469 ret
= qcow2_decompress_cluster(bs
, cluster_offset
);
1474 qemu_iovec_from_buf(&hd_qiov
, 0,
1475 s
->cluster_cache
+ offset_in_cluster
,
1479 case QCOW2_CLUSTER_NORMAL
:
1480 if ((cluster_offset
& 511) != 0) {
1485 if (bs
->encrypted
) {
1489 * For encrypted images, read everything into a temporary
1490 * contiguous buffer on which the AES functions can work.
1492 if (!cluster_data
) {
1494 qemu_try_blockalign(bs
->file
->bs
,
1495 QCOW_MAX_CRYPT_CLUSTERS
1497 if (cluster_data
== NULL
) {
1503 assert(cur_bytes
<= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1504 qemu_iovec_reset(&hd_qiov
);
1505 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
1508 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
1509 qemu_co_mutex_unlock(&s
->lock
);
1510 ret
= bdrv_co_preadv(bs
->file
,
1511 cluster_offset
+ offset_in_cluster
,
1512 cur_bytes
, &hd_qiov
, 0);
1513 qemu_co_mutex_lock(&s
->lock
);
1517 if (bs
->encrypted
) {
1519 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1520 assert((cur_bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
1522 if (qcow2_encrypt_sectors(s
, offset
>> BDRV_SECTOR_BITS
,
1523 cluster_data
, cluster_data
,
1524 cur_bytes
>> BDRV_SECTOR_BITS
,
1530 qemu_iovec_from_buf(qiov
, bytes_done
, cluster_data
, cur_bytes
);
1535 g_assert_not_reached();
1541 offset
+= cur_bytes
;
1542 bytes_done
+= cur_bytes
;
1547 qemu_co_mutex_unlock(&s
->lock
);
1549 qemu_iovec_destroy(&hd_qiov
);
1550 qemu_vfree(cluster_data
);
1555 static coroutine_fn
int qcow2_co_pwritev(BlockDriverState
*bs
, uint64_t offset
,
1556 uint64_t bytes
, QEMUIOVector
*qiov
,
1559 BDRVQcow2State
*s
= bs
->opaque
;
1560 int offset_in_cluster
;
1562 unsigned int cur_bytes
; /* number of sectors in current iteration */
1563 uint64_t cluster_offset
;
1564 QEMUIOVector hd_qiov
;
1565 uint64_t bytes_done
= 0;
1566 uint8_t *cluster_data
= NULL
;
1567 QCowL2Meta
*l2meta
= NULL
;
1569 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset
, bytes
);
1571 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1573 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1575 qemu_co_mutex_lock(&s
->lock
);
1577 while (bytes
!= 0) {
1581 trace_qcow2_writev_start_part(qemu_coroutine_self());
1582 offset_in_cluster
= offset_into_cluster(s
, offset
);
1583 cur_bytes
= MIN(bytes
, INT_MAX
);
1584 if (bs
->encrypted
) {
1585 cur_bytes
= MIN(cur_bytes
,
1586 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
1587 - offset_in_cluster
);
1590 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
1591 &cluster_offset
, &l2meta
);
1596 assert((cluster_offset
& 511) == 0);
1598 qemu_iovec_reset(&hd_qiov
);
1599 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, cur_bytes
);
1601 if (bs
->encrypted
) {
1604 if (!cluster_data
) {
1605 cluster_data
= qemu_try_blockalign(bs
->file
->bs
,
1606 QCOW_MAX_CRYPT_CLUSTERS
1608 if (cluster_data
== NULL
) {
1614 assert(hd_qiov
.size
<=
1615 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1616 qemu_iovec_to_buf(&hd_qiov
, 0, cluster_data
, hd_qiov
.size
);
1618 if (qcow2_encrypt_sectors(s
, offset
>> BDRV_SECTOR_BITS
,
1619 cluster_data
, cluster_data
,
1620 cur_bytes
>>BDRV_SECTOR_BITS
,
1627 qemu_iovec_reset(&hd_qiov
);
1628 qemu_iovec_add(&hd_qiov
, cluster_data
, cur_bytes
);
1631 ret
= qcow2_pre_write_overlap_check(bs
, 0,
1632 cluster_offset
+ offset_in_cluster
, cur_bytes
);
1637 qemu_co_mutex_unlock(&s
->lock
);
1638 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
1639 trace_qcow2_writev_data(qemu_coroutine_self(),
1640 cluster_offset
+ offset_in_cluster
);
1641 ret
= bdrv_co_pwritev(bs
->file
,
1642 cluster_offset
+ offset_in_cluster
,
1643 cur_bytes
, &hd_qiov
, 0);
1644 qemu_co_mutex_lock(&s
->lock
);
1649 while (l2meta
!= NULL
) {
1652 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
1657 /* Take the request off the list of running requests */
1658 if (l2meta
->nb_clusters
!= 0) {
1659 QLIST_REMOVE(l2meta
, next_in_flight
);
1662 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1664 next
= l2meta
->next
;
1670 offset
+= cur_bytes
;
1671 bytes_done
+= cur_bytes
;
1672 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes
);
1677 qemu_co_mutex_unlock(&s
->lock
);
1679 while (l2meta
!= NULL
) {
1682 if (l2meta
->nb_clusters
!= 0) {
1683 QLIST_REMOVE(l2meta
, next_in_flight
);
1685 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1687 next
= l2meta
->next
;
1692 qemu_iovec_destroy(&hd_qiov
);
1693 qemu_vfree(cluster_data
);
1694 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
1699 static int qcow2_inactivate(BlockDriverState
*bs
)
1701 BDRVQcow2State
*s
= bs
->opaque
;
1702 int ret
, result
= 0;
1704 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1707 error_report("Failed to flush the L2 table cache: %s",
1711 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1714 error_report("Failed to flush the refcount block cache: %s",
1719 qcow2_mark_clean(bs
);
1725 static void qcow2_close(BlockDriverState
*bs
)
1727 BDRVQcow2State
*s
= bs
->opaque
;
1728 qemu_vfree(s
->l1_table
);
1729 /* else pre-write overlap checks in cache_destroy may crash */
1732 if (!(s
->flags
& BDRV_O_INACTIVE
)) {
1733 qcow2_inactivate(bs
);
1736 cache_clean_timer_del(bs
);
1737 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1738 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1740 qcrypto_cipher_free(s
->cipher
);
1743 g_free(s
->unknown_header_fields
);
1744 cleanup_unknown_header_ext(bs
);
1746 g_free(s
->image_backing_file
);
1747 g_free(s
->image_backing_format
);
1749 g_free(s
->cluster_cache
);
1750 qemu_vfree(s
->cluster_data
);
1751 qcow2_refcount_close(bs
);
1752 qcow2_free_snapshots(bs
);
1755 static void qcow2_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
1757 BDRVQcow2State
*s
= bs
->opaque
;
1758 int flags
= s
->flags
;
1759 QCryptoCipher
*cipher
= NULL
;
1761 Error
*local_err
= NULL
;
1765 * Backing files are read-only which makes all of their metadata immutable,
1766 * that means we don't have to worry about reopening them here.
1774 memset(s
, 0, sizeof(BDRVQcow2State
));
1775 options
= qdict_clone_shallow(bs
->options
);
1777 flags
&= ~BDRV_O_INACTIVE
;
1778 ret
= qcow2_open(bs
, options
, flags
, &local_err
);
1781 error_propagate(errp
, local_err
);
1782 error_prepend(errp
, "Could not reopen qcow2 layer: ");
1785 } else if (ret
< 0) {
1786 error_setg_errno(errp
, -ret
, "Could not reopen qcow2 layer");
1794 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
1795 size_t len
, size_t buflen
)
1797 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
1798 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
1800 if (buflen
< ext_len
) {
1804 *ext_backing_fmt
= (QCowExtension
) {
1805 .magic
= cpu_to_be32(magic
),
1806 .len
= cpu_to_be32(len
),
1808 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
1814 * Updates the qcow2 header, including the variable length parts of it, i.e.
1815 * the backing file name and all extensions. qcow2 was not designed to allow
1816 * such changes, so if we run out of space (we can only use the first cluster)
1817 * this function may fail.
1819 * Returns 0 on success, -errno in error cases.
1821 int qcow2_update_header(BlockDriverState
*bs
)
1823 BDRVQcow2State
*s
= bs
->opaque
;
1826 size_t buflen
= s
->cluster_size
;
1828 uint64_t total_size
;
1829 uint32_t refcount_table_clusters
;
1830 size_t header_length
;
1831 Qcow2UnknownHeaderExtension
*uext
;
1833 buf
= qemu_blockalign(bs
, buflen
);
1835 /* Header structure */
1836 header
= (QCowHeader
*) buf
;
1838 if (buflen
< sizeof(*header
)) {
1843 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
1844 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1845 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
1847 *header
= (QCowHeader
) {
1848 /* Version 2 fields */
1849 .magic
= cpu_to_be32(QCOW_MAGIC
),
1850 .version
= cpu_to_be32(s
->qcow_version
),
1851 .backing_file_offset
= 0,
1852 .backing_file_size
= 0,
1853 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
1854 .size
= cpu_to_be64(total_size
),
1855 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
1856 .l1_size
= cpu_to_be32(s
->l1_size
),
1857 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
1858 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
1859 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
1860 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
1861 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
1863 /* Version 3 fields */
1864 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
1865 .compatible_features
= cpu_to_be64(s
->compatible_features
),
1866 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
1867 .refcount_order
= cpu_to_be32(s
->refcount_order
),
1868 .header_length
= cpu_to_be32(header_length
),
1871 /* For older versions, write a shorter header */
1872 switch (s
->qcow_version
) {
1874 ret
= offsetof(QCowHeader
, incompatible_features
);
1877 ret
= sizeof(*header
);
1886 memset(buf
, 0, buflen
);
1888 /* Preserve any unknown field in the header */
1889 if (s
->unknown_header_fields_size
) {
1890 if (buflen
< s
->unknown_header_fields_size
) {
1895 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
1896 buf
+= s
->unknown_header_fields_size
;
1897 buflen
-= s
->unknown_header_fields_size
;
1900 /* Backing file format header extension */
1901 if (s
->image_backing_format
) {
1902 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
1903 s
->image_backing_format
,
1904 strlen(s
->image_backing_format
),
1915 if (s
->qcow_version
>= 3) {
1916 Qcow2Feature features
[] = {
1918 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1919 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
1920 .name
= "dirty bit",
1923 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1924 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
1925 .name
= "corrupt bit",
1928 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
1929 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
1930 .name
= "lazy refcounts",
1934 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
1935 features
, sizeof(features
), buflen
);
1943 /* Keep unknown header extensions */
1944 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
1945 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
1954 /* End of header extensions */
1955 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
1963 /* Backing file name */
1964 if (s
->image_backing_file
) {
1965 size_t backing_file_len
= strlen(s
->image_backing_file
);
1967 if (buflen
< backing_file_len
) {
1972 /* Using strncpy is ok here, since buf is not NUL-terminated. */
1973 strncpy(buf
, s
->image_backing_file
, buflen
);
1975 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
1976 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
1979 /* Write the new header */
1980 ret
= bdrv_pwrite(bs
->file
, 0, header
, s
->cluster_size
);
1991 static int qcow2_change_backing_file(BlockDriverState
*bs
,
1992 const char *backing_file
, const char *backing_fmt
)
1994 BDRVQcow2State
*s
= bs
->opaque
;
1996 if (backing_file
&& strlen(backing_file
) > 1023) {
2000 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2001 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2003 g_free(s
->image_backing_file
);
2004 g_free(s
->image_backing_format
);
2006 s
->image_backing_file
= backing_file
? g_strdup(bs
->backing_file
) : NULL
;
2007 s
->image_backing_format
= backing_fmt
? g_strdup(bs
->backing_format
) : NULL
;
2009 return qcow2_update_header(bs
);
2012 static int preallocate(BlockDriverState
*bs
)
2016 uint64_t host_offset
= 0;
2017 unsigned int cur_bytes
;
2021 bytes
= bdrv_getlength(bs
);
2025 cur_bytes
= MIN(bytes
, INT_MAX
);
2026 ret
= qcow2_alloc_cluster_offset(bs
, offset
, &cur_bytes
,
2027 &host_offset
, &meta
);
2033 QCowL2Meta
*next
= meta
->next
;
2035 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
2037 qcow2_free_any_clusters(bs
, meta
->alloc_offset
,
2038 meta
->nb_clusters
, QCOW2_DISCARD_NEVER
);
2042 /* There are no dependent requests, but we need to remove our
2043 * request from the list of in-flight requests */
2044 QLIST_REMOVE(meta
, next_in_flight
);
2050 /* TODO Preallocate data if requested */
2053 offset
+= cur_bytes
;
2057 * It is expected that the image file is large enough to actually contain
2058 * all of the allocated clusters (otherwise we get failing reads after
2059 * EOF). Extend the image to the last allocated sector.
2061 if (host_offset
!= 0) {
2063 ret
= bdrv_pwrite(bs
->file
, (host_offset
+ cur_bytes
) - 1,
2073 static int qcow2_create2(const char *filename
, int64_t total_size
,
2074 const char *backing_file
, const char *backing_format
,
2075 int flags
, size_t cluster_size
, PreallocMode prealloc
,
2076 QemuOpts
*opts
, int version
, int refcount_order
,
2082 /* Calculate cluster_bits */
2083 cluster_bits
= ctz32(cluster_size
);
2084 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
2085 (1 << cluster_bits
) != cluster_size
)
2087 error_setg(errp
, "Cluster size must be a power of two between %d and "
2088 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
2093 * Open the image file and write a minimal qcow2 header.
2095 * We keep things simple and start with a zero-sized image. We also
2096 * do without refcount blocks or a L1 table for now. We'll fix the
2097 * inconsistency later.
2099 * We do need a refcount table because growing the refcount table means
2100 * allocating two new refcount blocks - the seconds of which would be at
2101 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
2102 * size for any qcow2 image.
2106 uint64_t* refcount_table
;
2107 Error
*local_err
= NULL
;
2110 if (prealloc
== PREALLOC_MODE_FULL
|| prealloc
== PREALLOC_MODE_FALLOC
) {
2111 /* Note: The following calculation does not need to be exact; if it is a
2112 * bit off, either some bytes will be "leaked" (which is fine) or we
2113 * will need to increase the file size by some bytes (which is fine,
2114 * too, as long as the bulk is allocated here). Therefore, using
2115 * floating point arithmetic is fine. */
2116 int64_t meta_size
= 0;
2117 uint64_t nreftablee
, nrefblocke
, nl1e
, nl2e
;
2118 int64_t aligned_total_size
= align_offset(total_size
, cluster_size
);
2119 int refblock_bits
, refblock_size
;
2120 /* refcount entry size in bytes */
2121 double rces
= (1 << refcount_order
) / 8.;
2123 /* see qcow2_open() */
2124 refblock_bits
= cluster_bits
- (refcount_order
- 3);
2125 refblock_size
= 1 << refblock_bits
;
2127 /* header: 1 cluster */
2128 meta_size
+= cluster_size
;
2130 /* total size of L2 tables */
2131 nl2e
= aligned_total_size
/ cluster_size
;
2132 nl2e
= align_offset(nl2e
, cluster_size
/ sizeof(uint64_t));
2133 meta_size
+= nl2e
* sizeof(uint64_t);
2135 /* total size of L1 tables */
2136 nl1e
= nl2e
* sizeof(uint64_t) / cluster_size
;
2137 nl1e
= align_offset(nl1e
, cluster_size
/ sizeof(uint64_t));
2138 meta_size
+= nl1e
* sizeof(uint64_t);
2140 /* total size of refcount blocks
2142 * note: every host cluster is reference-counted, including metadata
2143 * (even refcount blocks are recursively included).
2145 * a = total_size (this is the guest disk size)
2146 * m = meta size not including refcount blocks and refcount tables
2148 * y1 = number of refcount blocks entries
2149 * y2 = meta size including everything
2150 * rces = refcount entry size in bytes
2153 * y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m
2155 * y1 = (a + m) / (c - rces - rces * sizeof(u64) / c)
2157 nrefblocke
= (aligned_total_size
+ meta_size
+ cluster_size
)
2158 / (cluster_size
- rces
- rces
* sizeof(uint64_t)
2160 meta_size
+= DIV_ROUND_UP(nrefblocke
, refblock_size
) * cluster_size
;
2162 /* total size of refcount tables */
2163 nreftablee
= nrefblocke
/ refblock_size
;
2164 nreftablee
= align_offset(nreftablee
, cluster_size
/ sizeof(uint64_t));
2165 meta_size
+= nreftablee
* sizeof(uint64_t);
2167 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
,
2168 aligned_total_size
+ meta_size
, &error_abort
);
2169 qemu_opt_set(opts
, BLOCK_OPT_PREALLOC
, PreallocMode_lookup
[prealloc
],
2173 ret
= bdrv_create_file(filename
, opts
, &local_err
);
2175 error_propagate(errp
, local_err
);
2179 blk
= blk_new_open(filename
, NULL
, NULL
,
2180 BDRV_O_RDWR
| BDRV_O_PROTOCOL
, &local_err
);
2182 error_propagate(errp
, local_err
);
2186 blk_set_allow_write_beyond_eof(blk
, true);
2188 /* Write the header */
2189 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS
) < sizeof(*header
));
2190 header
= g_malloc0(cluster_size
);
2191 *header
= (QCowHeader
) {
2192 .magic
= cpu_to_be32(QCOW_MAGIC
),
2193 .version
= cpu_to_be32(version
),
2194 .cluster_bits
= cpu_to_be32(cluster_bits
),
2195 .size
= cpu_to_be64(0),
2196 .l1_table_offset
= cpu_to_be64(0),
2197 .l1_size
= cpu_to_be32(0),
2198 .refcount_table_offset
= cpu_to_be64(cluster_size
),
2199 .refcount_table_clusters
= cpu_to_be32(1),
2200 .refcount_order
= cpu_to_be32(refcount_order
),
2201 .header_length
= cpu_to_be32(sizeof(*header
)),
2204 if (flags
& BLOCK_FLAG_ENCRYPT
) {
2205 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
2207 header
->crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
2210 if (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
) {
2211 header
->compatible_features
|=
2212 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
2215 ret
= blk_pwrite(blk
, 0, header
, cluster_size
, 0);
2218 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
2222 /* Write a refcount table with one refcount block */
2223 refcount_table
= g_malloc0(2 * cluster_size
);
2224 refcount_table
[0] = cpu_to_be64(2 * cluster_size
);
2225 ret
= blk_pwrite(blk
, cluster_size
, refcount_table
, 2 * cluster_size
, 0);
2226 g_free(refcount_table
);
2229 error_setg_errno(errp
, -ret
, "Could not write refcount table");
2237 * And now open the image and make it consistent first (i.e. increase the
2238 * refcount of the cluster that is occupied by the header and the refcount
2241 options
= qdict_new();
2242 qdict_put(options
, "driver", qstring_from_str("qcow2"));
2243 blk
= blk_new_open(filename
, NULL
, options
,
2244 BDRV_O_RDWR
| BDRV_O_NO_FLUSH
, &local_err
);
2246 error_propagate(errp
, local_err
);
2251 ret
= qcow2_alloc_clusters(blk_bs(blk
), 3 * cluster_size
);
2253 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
2254 "header and refcount table");
2257 } else if (ret
!= 0) {
2258 error_report("Huh, first cluster in empty image is already in use?");
2262 /* Create a full header (including things like feature table) */
2263 ret
= qcow2_update_header(blk_bs(blk
));
2265 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
2269 /* Okay, now that we have a valid image, let's give it the right size */
2270 ret
= blk_truncate(blk
, total_size
);
2272 error_setg_errno(errp
, -ret
, "Could not resize image");
2276 /* Want a backing file? There you go.*/
2278 ret
= bdrv_change_backing_file(blk_bs(blk
), backing_file
, backing_format
);
2280 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
2281 "with format '%s'", backing_file
, backing_format
);
2286 /* And if we're supposed to preallocate metadata, do that now */
2287 if (prealloc
!= PREALLOC_MODE_OFF
) {
2288 BDRVQcow2State
*s
= blk_bs(blk
)->opaque
;
2289 qemu_co_mutex_lock(&s
->lock
);
2290 ret
= preallocate(blk_bs(blk
));
2291 qemu_co_mutex_unlock(&s
->lock
);
2293 error_setg_errno(errp
, -ret
, "Could not preallocate metadata");
2301 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
2302 options
= qdict_new();
2303 qdict_put(options
, "driver", qstring_from_str("qcow2"));
2304 blk
= blk_new_open(filename
, NULL
, options
,
2305 BDRV_O_RDWR
| BDRV_O_NO_BACKING
, &local_err
);
2307 error_propagate(errp
, local_err
);
2320 static int qcow2_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
2322 char *backing_file
= NULL
;
2323 char *backing_fmt
= NULL
;
2327 size_t cluster_size
= DEFAULT_CLUSTER_SIZE
;
2328 PreallocMode prealloc
;
2330 uint64_t refcount_bits
= 16;
2332 Error
*local_err
= NULL
;
2335 /* Read out options */
2336 size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
2338 backing_file
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
2339 backing_fmt
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FMT
);
2340 if (qemu_opt_get_bool_del(opts
, BLOCK_OPT_ENCRYPT
, false)) {
2341 flags
|= BLOCK_FLAG_ENCRYPT
;
2343 cluster_size
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
,
2344 DEFAULT_CLUSTER_SIZE
);
2345 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
2346 prealloc
= qapi_enum_parse(PreallocMode_lookup
, buf
,
2347 PREALLOC_MODE__MAX
, PREALLOC_MODE_OFF
,
2350 error_propagate(errp
, local_err
);
2355 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_COMPAT_LEVEL
);
2357 /* keep the default */
2358 } else if (!strcmp(buf
, "0.10")) {
2360 } else if (!strcmp(buf
, "1.1")) {
2363 error_setg(errp
, "Invalid compatibility level: '%s'", buf
);
2368 if (qemu_opt_get_bool_del(opts
, BLOCK_OPT_LAZY_REFCOUNTS
, false)) {
2369 flags
|= BLOCK_FLAG_LAZY_REFCOUNTS
;
2372 if (backing_file
&& prealloc
!= PREALLOC_MODE_OFF
) {
2373 error_setg(errp
, "Backing file and preallocation cannot be used at "
2379 if (version
< 3 && (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
)) {
2380 error_setg(errp
, "Lazy refcounts only supported with compatibility "
2381 "level 1.1 and above (use compat=1.1 or greater)");
2386 refcount_bits
= qemu_opt_get_number_del(opts
, BLOCK_OPT_REFCOUNT_BITS
,
2388 if (refcount_bits
> 64 || !is_power_of_2(refcount_bits
)) {
2389 error_setg(errp
, "Refcount width must be a power of two and may not "
2395 if (version
< 3 && refcount_bits
!= 16) {
2396 error_setg(errp
, "Different refcount widths than 16 bits require "
2397 "compatibility level 1.1 or above (use compat=1.1 or "
2403 refcount_order
= ctz32(refcount_bits
);
2405 ret
= qcow2_create2(filename
, size
, backing_file
, backing_fmt
, flags
,
2406 cluster_size
, prealloc
, opts
, version
, refcount_order
,
2408 error_propagate(errp
, local_err
);
2411 g_free(backing_file
);
2412 g_free(backing_fmt
);
2418 static bool is_zero_sectors(BlockDriverState
*bs
, int64_t start
,
2422 BlockDriverState
*file
;
2428 res
= bdrv_get_block_status_above(bs
, NULL
, start
, count
,
2430 return res
>= 0 && (res
& BDRV_BLOCK_ZERO
) && nr
== count
;
2433 static coroutine_fn
int qcow2_co_pwrite_zeroes(BlockDriverState
*bs
,
2434 int64_t offset
, int count
, BdrvRequestFlags flags
)
2437 BDRVQcow2State
*s
= bs
->opaque
;
2439 uint32_t head
= offset
% s
->cluster_size
;
2440 uint32_t tail
= (offset
+ count
) % s
->cluster_size
;
2442 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset
, count
);
2445 int64_t cl_start
= (offset
- head
) >> BDRV_SECTOR_BITS
;
2449 assert(head
+ count
<= s
->cluster_size
);
2451 /* check whether remainder of cluster already reads as zero */
2452 if (!(is_zero_sectors(bs
, cl_start
,
2453 DIV_ROUND_UP(head
, BDRV_SECTOR_SIZE
)) &&
2454 is_zero_sectors(bs
, (offset
+ count
) >> BDRV_SECTOR_BITS
,
2455 DIV_ROUND_UP(-tail
& (s
->cluster_size
- 1),
2456 BDRV_SECTOR_SIZE
)))) {
2460 qemu_co_mutex_lock(&s
->lock
);
2461 /* We can have new write after previous check */
2462 offset
= cl_start
<< BDRV_SECTOR_BITS
;
2463 count
= s
->cluster_size
;
2464 nr
= s
->cluster_size
;
2465 ret
= qcow2_get_cluster_offset(bs
, offset
, &nr
, &off
);
2466 if (ret
!= QCOW2_CLUSTER_UNALLOCATED
&& ret
!= QCOW2_CLUSTER_ZERO
) {
2467 qemu_co_mutex_unlock(&s
->lock
);
2471 qemu_co_mutex_lock(&s
->lock
);
2474 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset
, count
);
2476 /* Whatever is left can use real zero clusters */
2477 ret
= qcow2_zero_clusters(bs
, offset
, count
>> BDRV_SECTOR_BITS
);
2478 qemu_co_mutex_unlock(&s
->lock
);
2483 static coroutine_fn
int qcow2_co_pdiscard(BlockDriverState
*bs
,
2484 int64_t offset
, int count
)
2487 BDRVQcow2State
*s
= bs
->opaque
;
2489 if (!QEMU_IS_ALIGNED(offset
| count
, s
->cluster_size
)) {
2490 assert(count
< s
->cluster_size
);
2494 qemu_co_mutex_lock(&s
->lock
);
2495 ret
= qcow2_discard_clusters(bs
, offset
, count
>> BDRV_SECTOR_BITS
,
2496 QCOW2_DISCARD_REQUEST
, false);
2497 qemu_co_mutex_unlock(&s
->lock
);
2501 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
)
2503 BDRVQcow2State
*s
= bs
->opaque
;
2504 int64_t new_l1_size
;
2508 error_report("The new size must be a multiple of 512");
2512 /* cannot proceed if image has snapshots */
2513 if (s
->nb_snapshots
) {
2514 error_report("Can't resize an image which has snapshots");
2518 /* shrinking is currently not supported */
2519 if (offset
< bs
->total_sectors
* 512) {
2520 error_report("qcow2 doesn't support shrinking images yet");
2524 new_l1_size
= size_to_l1(s
, offset
);
2525 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
2530 /* write updated header.size */
2531 offset
= cpu_to_be64(offset
);
2532 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
2533 &offset
, sizeof(uint64_t));
2538 s
->l1_vm_state_index
= new_l1_size
;
2542 typedef struct Qcow2WriteCo
{
2543 BlockDriverState
*bs
;
2550 static void qcow2_write_co_entry(void *opaque
)
2552 Qcow2WriteCo
*co
= opaque
;
2554 uint64_t offset
= co
->sector_num
* BDRV_SECTOR_SIZE
;
2555 uint64_t bytes
= co
->nb_sectors
* BDRV_SECTOR_SIZE
;
2557 struct iovec iov
= (struct iovec
) {
2558 .iov_base
= (uint8_t*) co
->buf
,
2561 qemu_iovec_init_external(&qiov
, &iov
, 1);
2563 co
->ret
= qcow2_co_pwritev(co
->bs
, offset
, bytes
, &qiov
, 0);
2566 /* Wrapper for non-coroutine contexts */
2567 static int qcow2_write(BlockDriverState
*bs
, int64_t sector_num
,
2568 const uint8_t *buf
, int nb_sectors
)
2571 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2572 Qcow2WriteCo data
= {
2574 .sector_num
= sector_num
,
2576 .nb_sectors
= nb_sectors
,
2577 .ret
= -EINPROGRESS
,
2579 co
= qemu_coroutine_create(qcow2_write_co_entry
, &data
);
2580 qemu_coroutine_enter(co
);
2581 while (data
.ret
== -EINPROGRESS
) {
2582 aio_poll(aio_context
, true);
2587 /* XXX: put compressed sectors first, then all the cluster aligned
2588 tables to avoid losing bytes in alignment */
2589 static int qcow2_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2590 const uint8_t *buf
, int nb_sectors
)
2592 BDRVQcow2State
*s
= bs
->opaque
;
2596 uint64_t cluster_offset
;
2598 if (nb_sectors
== 0) {
2599 /* align end of file to a sector boundary to ease reading with
2600 sector based I/Os */
2601 cluster_offset
= bdrv_getlength(bs
->file
->bs
);
2602 return bdrv_truncate(bs
->file
->bs
, cluster_offset
);
2605 if (nb_sectors
!= s
->cluster_sectors
) {
2608 /* Zero-pad last write if image size is not cluster aligned */
2609 if (sector_num
+ nb_sectors
== bs
->total_sectors
&&
2610 nb_sectors
< s
->cluster_sectors
) {
2611 uint8_t *pad_buf
= qemu_blockalign(bs
, s
->cluster_size
);
2612 memset(pad_buf
, 0, s
->cluster_size
);
2613 memcpy(pad_buf
, buf
, nb_sectors
* BDRV_SECTOR_SIZE
);
2614 ret
= qcow2_write_compressed(bs
, sector_num
,
2615 pad_buf
, s
->cluster_sectors
);
2616 qemu_vfree(pad_buf
);
2621 out_buf
= g_malloc(s
->cluster_size
);
2623 /* best compression, small window, no zlib header */
2624 memset(&strm
, 0, sizeof(strm
));
2625 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
2627 9, Z_DEFAULT_STRATEGY
);
2633 strm
.avail_in
= s
->cluster_size
;
2634 strm
.next_in
= (uint8_t *)buf
;
2635 strm
.avail_out
= s
->cluster_size
;
2636 strm
.next_out
= out_buf
;
2638 ret
= deflate(&strm
, Z_FINISH
);
2639 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
2644 out_len
= strm
.next_out
- out_buf
;
2648 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
2649 /* could not compress: write normal cluster */
2650 ret
= qcow2_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
2655 cluster_offset
= qcow2_alloc_compressed_cluster_offset(bs
,
2656 sector_num
<< 9, out_len
);
2657 if (!cluster_offset
) {
2661 cluster_offset
&= s
->cluster_offset_mask
;
2663 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
);
2668 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
2669 ret
= bdrv_pwrite(bs
->file
, cluster_offset
, out_buf
, out_len
);
2681 static int make_completely_empty(BlockDriverState
*bs
)
2683 BDRVQcow2State
*s
= bs
->opaque
;
2684 int ret
, l1_clusters
;
2686 uint64_t *new_reftable
= NULL
;
2687 uint64_t rt_entry
, l1_size2
;
2690 uint64_t reftable_offset
;
2691 uint32_t reftable_clusters
;
2692 } QEMU_PACKED l1_ofs_rt_ofs_cls
;
2694 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
2699 ret
= qcow2_cache_empty(bs
, s
->refcount_block_cache
);
2704 /* Refcounts will be broken utterly */
2705 ret
= qcow2_mark_dirty(bs
);
2710 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
2712 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
2713 l1_size2
= (uint64_t)s
->l1_size
* sizeof(uint64_t);
2715 /* After this call, neither the in-memory nor the on-disk refcount
2716 * information accurately describe the actual references */
2718 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->l1_table_offset
,
2719 l1_clusters
* s
->cluster_size
, 0);
2721 goto fail_broken_refcounts
;
2723 memset(s
->l1_table
, 0, l1_size2
);
2725 BLKDBG_EVENT(bs
->file
, BLKDBG_EMPTY_IMAGE_PREPARE
);
2727 /* Overwrite enough clusters at the beginning of the sectors to place
2728 * the refcount table, a refcount block and the L1 table in; this may
2729 * overwrite parts of the existing refcount and L1 table, which is not
2730 * an issue because the dirty flag is set, complete data loss is in fact
2731 * desired and partial data loss is consequently fine as well */
2732 ret
= bdrv_pwrite_zeroes(bs
->file
, s
->cluster_size
,
2733 (2 + l1_clusters
) * s
->cluster_size
, 0);
2734 /* This call (even if it failed overall) may have overwritten on-disk
2735 * refcount structures; in that case, the in-memory refcount information
2736 * will probably differ from the on-disk information which makes the BDS
2739 goto fail_broken_refcounts
;
2742 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
2743 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_UPDATE
);
2745 /* "Create" an empty reftable (one cluster) directly after the image
2746 * header and an empty L1 table three clusters after the image header;
2747 * the cluster between those two will be used as the first refblock */
2748 l1_ofs_rt_ofs_cls
.l1_offset
= cpu_to_be64(3 * s
->cluster_size
);
2749 l1_ofs_rt_ofs_cls
.reftable_offset
= cpu_to_be64(s
->cluster_size
);
2750 l1_ofs_rt_ofs_cls
.reftable_clusters
= cpu_to_be32(1);
2751 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, l1_table_offset
),
2752 &l1_ofs_rt_ofs_cls
, sizeof(l1_ofs_rt_ofs_cls
));
2754 goto fail_broken_refcounts
;
2757 s
->l1_table_offset
= 3 * s
->cluster_size
;
2759 new_reftable
= g_try_new0(uint64_t, s
->cluster_size
/ sizeof(uint64_t));
2760 if (!new_reftable
) {
2762 goto fail_broken_refcounts
;
2765 s
->refcount_table_offset
= s
->cluster_size
;
2766 s
->refcount_table_size
= s
->cluster_size
/ sizeof(uint64_t);
2768 g_free(s
->refcount_table
);
2769 s
->refcount_table
= new_reftable
;
2770 new_reftable
= NULL
;
2772 /* Now the in-memory refcount information again corresponds to the on-disk
2773 * information (reftable is empty and no refblocks (the refblock cache is
2774 * empty)); however, this means some clusters (e.g. the image header) are
2775 * referenced, but not refcounted, but the normal qcow2 code assumes that
2776 * the in-memory information is always correct */
2778 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
2780 /* Enter the first refblock into the reftable */
2781 rt_entry
= cpu_to_be64(2 * s
->cluster_size
);
2782 ret
= bdrv_pwrite_sync(bs
->file
, s
->cluster_size
,
2783 &rt_entry
, sizeof(rt_entry
));
2785 goto fail_broken_refcounts
;
2787 s
->refcount_table
[0] = 2 * s
->cluster_size
;
2789 s
->free_cluster_index
= 0;
2790 assert(3 + l1_clusters
<= s
->refcount_block_size
);
2791 offset
= qcow2_alloc_clusters(bs
, 3 * s
->cluster_size
+ l1_size2
);
2794 goto fail_broken_refcounts
;
2795 } else if (offset
> 0) {
2796 error_report("First cluster in emptied image is in use");
2800 /* Now finally the in-memory information corresponds to the on-disk
2801 * structures and is correct */
2802 ret
= qcow2_mark_clean(bs
);
2807 ret
= bdrv_truncate(bs
->file
->bs
, (3 + l1_clusters
) * s
->cluster_size
);
2814 fail_broken_refcounts
:
2815 /* The BDS is unusable at this point. If we wanted to make it usable, we
2816 * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
2817 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
2818 * again. However, because the functions which could have caused this error
2819 * path to be taken are used by those functions as well, it's very likely
2820 * that that sequence will fail as well. Therefore, just eject the BDS. */
2824 g_free(new_reftable
);
2828 static int qcow2_make_empty(BlockDriverState
*bs
)
2830 BDRVQcow2State
*s
= bs
->opaque
;
2831 uint64_t start_sector
;
2832 int sector_step
= INT_MAX
/ BDRV_SECTOR_SIZE
;
2833 int l1_clusters
, ret
= 0;
2835 l1_clusters
= DIV_ROUND_UP(s
->l1_size
, s
->cluster_size
/ sizeof(uint64_t));
2837 if (s
->qcow_version
>= 3 && !s
->snapshots
&&
2838 3 + l1_clusters
<= s
->refcount_block_size
) {
2839 /* The following function only works for qcow2 v3 images (it requires
2840 * the dirty flag) and only as long as there are no snapshots (because
2841 * it completely empties the image). Furthermore, the L1 table and three
2842 * additional clusters (image header, refcount table, one refcount
2843 * block) have to fit inside one refcount block. */
2844 return make_completely_empty(bs
);
2847 /* This fallback code simply discards every active cluster; this is slow,
2848 * but works in all cases */
2849 for (start_sector
= 0; start_sector
< bs
->total_sectors
;
2850 start_sector
+= sector_step
)
2852 /* As this function is generally used after committing an external
2853 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
2854 * default action for this kind of discard is to pass the discard,
2855 * which will ideally result in an actually smaller image file, as
2856 * is probably desired. */
2857 ret
= qcow2_discard_clusters(bs
, start_sector
* BDRV_SECTOR_SIZE
,
2859 bs
->total_sectors
- start_sector
),
2860 QCOW2_DISCARD_SNAPSHOT
, true);
2869 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
2871 BDRVQcow2State
*s
= bs
->opaque
;
2874 qemu_co_mutex_lock(&s
->lock
);
2875 ret
= qcow2_cache_write(bs
, s
->l2_table_cache
);
2877 qemu_co_mutex_unlock(&s
->lock
);
2881 if (qcow2_need_accurate_refcounts(s
)) {
2882 ret
= qcow2_cache_write(bs
, s
->refcount_block_cache
);
2884 qemu_co_mutex_unlock(&s
->lock
);
2888 qemu_co_mutex_unlock(&s
->lock
);
2893 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2895 BDRVQcow2State
*s
= bs
->opaque
;
2896 bdi
->unallocated_blocks_are_zero
= true;
2897 bdi
->can_write_zeroes_with_unmap
= (s
->qcow_version
>= 3);
2898 bdi
->cluster_size
= s
->cluster_size
;
2899 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
2903 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
)
2905 BDRVQcow2State
*s
= bs
->opaque
;
2906 ImageInfoSpecific
*spec_info
= g_new(ImageInfoSpecific
, 1);
2908 *spec_info
= (ImageInfoSpecific
){
2909 .type
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
2910 .u
.qcow2
.data
= g_new(ImageInfoSpecificQCow2
, 1),
2912 if (s
->qcow_version
== 2) {
2913 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
2914 .compat
= g_strdup("0.10"),
2915 .refcount_bits
= s
->refcount_bits
,
2917 } else if (s
->qcow_version
== 3) {
2918 *spec_info
->u
.qcow2
.data
= (ImageInfoSpecificQCow2
){
2919 .compat
= g_strdup("1.1"),
2920 .lazy_refcounts
= s
->compatible_features
&
2921 QCOW2_COMPAT_LAZY_REFCOUNTS
,
2922 .has_lazy_refcounts
= true,
2923 .corrupt
= s
->incompatible_features
&
2924 QCOW2_INCOMPAT_CORRUPT
,
2925 .has_corrupt
= true,
2926 .refcount_bits
= s
->refcount_bits
,
2929 /* if this assertion fails, this probably means a new version was
2930 * added without having it covered here */
2938 static void dump_refcounts(BlockDriverState
*bs
)
2940 BDRVQcow2State
*s
= bs
->opaque
;
2941 int64_t nb_clusters
, k
, k1
, size
;
2944 size
= bdrv_getlength(bs
->file
->bs
);
2945 nb_clusters
= size_to_clusters(s
, size
);
2946 for(k
= 0; k
< nb_clusters
;) {
2948 refcount
= get_refcount(bs
, k
);
2950 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
2952 printf("%" PRId64
": refcount=%d nb=%" PRId64
"\n", k
, refcount
,
2958 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
2961 BDRVQcow2State
*s
= bs
->opaque
;
2963 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
2964 return bs
->drv
->bdrv_co_pwritev(bs
, qcow2_vm_state_offset(s
) + pos
,
2965 qiov
->size
, qiov
, 0);
2968 static int qcow2_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
2971 BDRVQcow2State
*s
= bs
->opaque
;
2973 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
2974 return bs
->drv
->bdrv_co_preadv(bs
, qcow2_vm_state_offset(s
) + pos
,
2975 qiov
->size
, qiov
, 0);
2979 * Downgrades an image's version. To achieve this, any incompatible features
2980 * have to be removed.
2982 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
,
2983 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
)
2985 BDRVQcow2State
*s
= bs
->opaque
;
2986 int current_version
= s
->qcow_version
;
2989 if (target_version
== current_version
) {
2991 } else if (target_version
> current_version
) {
2993 } else if (target_version
!= 2) {
2997 if (s
->refcount_order
!= 4) {
2998 error_report("compat=0.10 requires refcount_bits=16");
3002 /* clear incompatible features */
3003 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
3004 ret
= qcow2_mark_clean(bs
);
3010 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
3011 * the first place; if that happens nonetheless, returning -ENOTSUP is the
3012 * best thing to do anyway */
3014 if (s
->incompatible_features
) {
3018 /* since we can ignore compatible features, we can set them to 0 as well */
3019 s
->compatible_features
= 0;
3020 /* if lazy refcounts have been used, they have already been fixed through
3021 * clearing the dirty flag */
3023 /* clearing autoclear features is trivial */
3024 s
->autoclear_features
= 0;
3026 ret
= qcow2_expand_zero_clusters(bs
, status_cb
, cb_opaque
);
3031 s
->qcow_version
= target_version
;
3032 ret
= qcow2_update_header(bs
);
3034 s
->qcow_version
= current_version
;
3040 typedef enum Qcow2AmendOperation
{
3041 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
3042 * statically initialized to so that the helper CB can discern the first
3043 * invocation from an operation change */
3044 QCOW2_NO_OPERATION
= 0,
3046 QCOW2_CHANGING_REFCOUNT_ORDER
,
3048 } Qcow2AmendOperation
;
3050 typedef struct Qcow2AmendHelperCBInfo
{
3051 /* The code coordinating the amend operations should only modify
3052 * these four fields; the rest will be managed by the CB */
3053 BlockDriverAmendStatusCB
*original_status_cb
;
3054 void *original_cb_opaque
;
3056 Qcow2AmendOperation current_operation
;
3058 /* Total number of operations to perform (only set once) */
3059 int total_operations
;
3061 /* The following fields are managed by the CB */
3063 /* Number of operations completed */
3064 int operations_completed
;
3066 /* Cumulative offset of all completed operations */
3067 int64_t offset_completed
;
3069 Qcow2AmendOperation last_operation
;
3070 int64_t last_work_size
;
3071 } Qcow2AmendHelperCBInfo
;
3073 static void qcow2_amend_helper_cb(BlockDriverState
*bs
,
3074 int64_t operation_offset
,
3075 int64_t operation_work_size
, void *opaque
)
3077 Qcow2AmendHelperCBInfo
*info
= opaque
;
3078 int64_t current_work_size
;
3079 int64_t projected_work_size
;
3081 if (info
->current_operation
!= info
->last_operation
) {
3082 if (info
->last_operation
!= QCOW2_NO_OPERATION
) {
3083 info
->offset_completed
+= info
->last_work_size
;
3084 info
->operations_completed
++;
3087 info
->last_operation
= info
->current_operation
;
3090 assert(info
->total_operations
> 0);
3091 assert(info
->operations_completed
< info
->total_operations
);
3093 info
->last_work_size
= operation_work_size
;
3095 current_work_size
= info
->offset_completed
+ operation_work_size
;
3097 /* current_work_size is the total work size for (operations_completed + 1)
3098 * operations (which includes this one), so multiply it by the number of
3099 * operations not covered and divide it by the number of operations
3100 * covered to get a projection for the operations not covered */
3101 projected_work_size
= current_work_size
* (info
->total_operations
-
3102 info
->operations_completed
- 1)
3103 / (info
->operations_completed
+ 1);
3105 info
->original_status_cb(bs
, info
->offset_completed
+ operation_offset
,
3106 current_work_size
+ projected_work_size
,
3107 info
->original_cb_opaque
);
3110 static int qcow2_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3111 BlockDriverAmendStatusCB
*status_cb
,
3114 BDRVQcow2State
*s
= bs
->opaque
;
3115 int old_version
= s
->qcow_version
, new_version
= old_version
;
3116 uint64_t new_size
= 0;
3117 const char *backing_file
= NULL
, *backing_format
= NULL
;
3118 bool lazy_refcounts
= s
->use_lazy_refcounts
;
3119 const char *compat
= NULL
;
3120 uint64_t cluster_size
= s
->cluster_size
;
3122 int refcount_bits
= s
->refcount_bits
;
3124 QemuOptDesc
*desc
= opts
->list
->desc
;
3125 Qcow2AmendHelperCBInfo helper_cb_info
;
3127 while (desc
&& desc
->name
) {
3128 if (!qemu_opt_find(opts
, desc
->name
)) {
3129 /* only change explicitly defined options */
3134 if (!strcmp(desc
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
3135 compat
= qemu_opt_get(opts
, BLOCK_OPT_COMPAT_LEVEL
);
3137 /* preserve default */
3138 } else if (!strcmp(compat
, "0.10")) {
3140 } else if (!strcmp(compat
, "1.1")) {
3143 error_report("Unknown compatibility level %s", compat
);
3146 } else if (!strcmp(desc
->name
, BLOCK_OPT_PREALLOC
)) {
3147 error_report("Cannot change preallocation mode");
3149 } else if (!strcmp(desc
->name
, BLOCK_OPT_SIZE
)) {
3150 new_size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3151 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FILE
)) {
3152 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3153 } else if (!strcmp(desc
->name
, BLOCK_OPT_BACKING_FMT
)) {
3154 backing_format
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3155 } else if (!strcmp(desc
->name
, BLOCK_OPT_ENCRYPT
)) {
3156 encrypt
= qemu_opt_get_bool(opts
, BLOCK_OPT_ENCRYPT
,
3159 if (encrypt
!= !!s
->cipher
) {
3160 error_report("Changing the encryption flag is not supported");
3163 } else if (!strcmp(desc
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
3164 cluster_size
= qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
,
3166 if (cluster_size
!= s
->cluster_size
) {
3167 error_report("Changing the cluster size is not supported");
3170 } else if (!strcmp(desc
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
3171 lazy_refcounts
= qemu_opt_get_bool(opts
, BLOCK_OPT_LAZY_REFCOUNTS
,
3173 } else if (!strcmp(desc
->name
, BLOCK_OPT_REFCOUNT_BITS
)) {
3174 refcount_bits
= qemu_opt_get_number(opts
, BLOCK_OPT_REFCOUNT_BITS
,
3177 if (refcount_bits
<= 0 || refcount_bits
> 64 ||
3178 !is_power_of_2(refcount_bits
))
3180 error_report("Refcount width must be a power of two and may "
3181 "not exceed 64 bits");
3185 /* if this point is reached, this probably means a new option was
3186 * added without having it covered here */
3193 helper_cb_info
= (Qcow2AmendHelperCBInfo
){
3194 .original_status_cb
= status_cb
,
3195 .original_cb_opaque
= cb_opaque
,
3196 .total_operations
= (new_version
< old_version
)
3197 + (s
->refcount_bits
!= refcount_bits
)
3200 /* Upgrade first (some features may require compat=1.1) */
3201 if (new_version
> old_version
) {
3202 s
->qcow_version
= new_version
;
3203 ret
= qcow2_update_header(bs
);
3205 s
->qcow_version
= old_version
;
3210 if (s
->refcount_bits
!= refcount_bits
) {
3211 int refcount_order
= ctz32(refcount_bits
);
3212 Error
*local_error
= NULL
;
3214 if (new_version
< 3 && refcount_bits
!= 16) {
3215 error_report("Different refcount widths than 16 bits require "
3216 "compatibility level 1.1 or above (use compat=1.1 or "
3221 helper_cb_info
.current_operation
= QCOW2_CHANGING_REFCOUNT_ORDER
;
3222 ret
= qcow2_change_refcount_order(bs
, refcount_order
,
3223 &qcow2_amend_helper_cb
,
3224 &helper_cb_info
, &local_error
);
3226 error_report_err(local_error
);
3231 if (backing_file
|| backing_format
) {
3232 ret
= qcow2_change_backing_file(bs
,
3233 backing_file
?: s
->image_backing_file
,
3234 backing_format
?: s
->image_backing_format
);
3240 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
3241 if (lazy_refcounts
) {
3242 if (new_version
< 3) {
3243 error_report("Lazy refcounts only supported with compatibility "
3244 "level 1.1 and above (use compat=1.1 or greater)");
3247 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
3248 ret
= qcow2_update_header(bs
);
3250 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
3253 s
->use_lazy_refcounts
= true;
3255 /* make image clean first */
3256 ret
= qcow2_mark_clean(bs
);
3260 /* now disallow lazy refcounts */
3261 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
3262 ret
= qcow2_update_header(bs
);
3264 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
3267 s
->use_lazy_refcounts
= false;
3272 ret
= bdrv_truncate(bs
, new_size
);
3278 /* Downgrade last (so unsupported features can be removed before) */
3279 if (new_version
< old_version
) {
3280 helper_cb_info
.current_operation
= QCOW2_DOWNGRADING
;
3281 ret
= qcow2_downgrade(bs
, new_version
, &qcow2_amend_helper_cb
,
3292 * If offset or size are negative, respectively, they will not be included in
3293 * the BLOCK_IMAGE_CORRUPTED event emitted.
3294 * fatal will be ignored for read-only BDS; corruptions found there will always
3295 * be considered non-fatal.
3297 void qcow2_signal_corruption(BlockDriverState
*bs
, bool fatal
, int64_t offset
,
3298 int64_t size
, const char *message_format
, ...)
3300 BDRVQcow2State
*s
= bs
->opaque
;
3301 const char *node_name
;
3305 fatal
= fatal
&& !bs
->read_only
;
3307 if (s
->signaled_corruption
&&
3308 (!fatal
|| (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
)))
3313 va_start(ap
, message_format
);
3314 message
= g_strdup_vprintf(message_format
, ap
);
3318 fprintf(stderr
, "qcow2: Marking image as corrupt: %s; further "
3319 "corruption events will be suppressed\n", message
);
3321 fprintf(stderr
, "qcow2: Image is corrupt: %s; further non-fatal "
3322 "corruption events will be suppressed\n", message
);
3325 node_name
= bdrv_get_node_name(bs
);
3326 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs
),
3327 *node_name
!= '\0', node_name
,
3328 message
, offset
>= 0, offset
,
3330 fatal
, &error_abort
);
3334 qcow2_mark_corrupt(bs
);
3335 bs
->drv
= NULL
; /* make BDS unusable */
3338 s
->signaled_corruption
= true;
3341 static QemuOptsList qcow2_create_opts
= {
3342 .name
= "qcow2-create-opts",
3343 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_create_opts
.head
),
3346 .name
= BLOCK_OPT_SIZE
,
3347 .type
= QEMU_OPT_SIZE
,
3348 .help
= "Virtual disk size"
3351 .name
= BLOCK_OPT_COMPAT_LEVEL
,
3352 .type
= QEMU_OPT_STRING
,
3353 .help
= "Compatibility level (0.10 or 1.1)"
3356 .name
= BLOCK_OPT_BACKING_FILE
,
3357 .type
= QEMU_OPT_STRING
,
3358 .help
= "File name of a base image"
3361 .name
= BLOCK_OPT_BACKING_FMT
,
3362 .type
= QEMU_OPT_STRING
,
3363 .help
= "Image format of the base image"
3366 .name
= BLOCK_OPT_ENCRYPT
,
3367 .type
= QEMU_OPT_BOOL
,
3368 .help
= "Encrypt the image",
3369 .def_value_str
= "off"
3372 .name
= BLOCK_OPT_CLUSTER_SIZE
,
3373 .type
= QEMU_OPT_SIZE
,
3374 .help
= "qcow2 cluster size",
3375 .def_value_str
= stringify(DEFAULT_CLUSTER_SIZE
)
3378 .name
= BLOCK_OPT_PREALLOC
,
3379 .type
= QEMU_OPT_STRING
,
3380 .help
= "Preallocation mode (allowed values: off, metadata, "
3384 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
3385 .type
= QEMU_OPT_BOOL
,
3386 .help
= "Postpone refcount updates",
3387 .def_value_str
= "off"
3390 .name
= BLOCK_OPT_REFCOUNT_BITS
,
3391 .type
= QEMU_OPT_NUMBER
,
3392 .help
= "Width of a reference count entry in bits",
3393 .def_value_str
= "16"
3395 { /* end of list */ }
3399 BlockDriver bdrv_qcow2
= {
3400 .format_name
= "qcow2",
3401 .instance_size
= sizeof(BDRVQcow2State
),
3402 .bdrv_probe
= qcow2_probe
,
3403 .bdrv_open
= qcow2_open
,
3404 .bdrv_close
= qcow2_close
,
3405 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
3406 .bdrv_reopen_commit
= qcow2_reopen_commit
,
3407 .bdrv_reopen_abort
= qcow2_reopen_abort
,
3408 .bdrv_join_options
= qcow2_join_options
,
3409 .bdrv_create
= qcow2_create
,
3410 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
3411 .bdrv_co_get_block_status
= qcow2_co_get_block_status
,
3412 .bdrv_set_key
= qcow2_set_key
,
3414 .bdrv_co_preadv
= qcow2_co_preadv
,
3415 .bdrv_co_pwritev
= qcow2_co_pwritev
,
3416 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
3418 .bdrv_co_pwrite_zeroes
= qcow2_co_pwrite_zeroes
,
3419 .bdrv_co_pdiscard
= qcow2_co_pdiscard
,
3420 .bdrv_truncate
= qcow2_truncate
,
3421 .bdrv_write_compressed
= qcow2_write_compressed
,
3422 .bdrv_make_empty
= qcow2_make_empty
,
3424 .bdrv_snapshot_create
= qcow2_snapshot_create
,
3425 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
3426 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
3427 .bdrv_snapshot_list
= qcow2_snapshot_list
,
3428 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
3429 .bdrv_get_info
= qcow2_get_info
,
3430 .bdrv_get_specific_info
= qcow2_get_specific_info
,
3432 .bdrv_save_vmstate
= qcow2_save_vmstate
,
3433 .bdrv_load_vmstate
= qcow2_load_vmstate
,
3435 .supports_backing
= true,
3436 .bdrv_change_backing_file
= qcow2_change_backing_file
,
3438 .bdrv_refresh_limits
= qcow2_refresh_limits
,
3439 .bdrv_invalidate_cache
= qcow2_invalidate_cache
,
3440 .bdrv_inactivate
= qcow2_inactivate
,
3442 .create_opts
= &qcow2_create_opts
,
3443 .bdrv_check
= qcow2_check
,
3444 .bdrv_amend_options
= qcow2_amend_options
,
3446 .bdrv_detach_aio_context
= qcow2_detach_aio_context
,
3447 .bdrv_attach_aio_context
= qcow2_attach_aio_context
,
3450 static void bdrv_qcow2_init(void)
3452 bdrv_register(&bdrv_qcow2
);
3455 block_init(bdrv_qcow2_init
);