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-common.h"
25 #include "block/block_int.h"
26 #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"
36 Differences with QCOW:
38 - Support for multiple incremental snapshots.
39 - Memory management by reference counts.
40 - Clusters which have a reference count of one have the bit
41 QCOW_OFLAG_COPIED to optimize write performance.
42 - Size of compressed clusters is stored in sectors to reduce bit usage
43 in the cluster offsets.
44 - Support for storing additional data (such as the VM state) in the
46 - If a backing store is used, the cluster size is not constrained
47 (could be backported to QCOW).
48 - L2 tables have always a size of one cluster.
55 } QEMU_PACKED QCowExtension
;
57 #define QCOW2_EXT_MAGIC_END 0
58 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
59 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
61 static int qcow2_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
63 const QCowHeader
*cow_header
= (const void *)buf
;
65 if (buf_size
>= sizeof(QCowHeader
) &&
66 be32_to_cpu(cow_header
->magic
) == QCOW_MAGIC
&&
67 be32_to_cpu(cow_header
->version
) >= 2)
75 * read qcow2 extension and fill bs
76 * start reading from start_offset
77 * finish reading upon magic of value 0 or when end_offset reached
78 * unknown magic is skipped (future extension this version knows nothing about)
79 * return 0 upon success, non-0 otherwise
81 static int qcow2_read_extensions(BlockDriverState
*bs
, uint64_t start_offset
,
82 uint64_t end_offset
, void **p_feature_table
,
85 BDRVQcowState
*s
= bs
->opaque
;
91 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
93 offset
= start_offset
;
94 while (offset
< end_offset
) {
98 if (offset
> s
->cluster_size
)
99 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
101 printf("attempting to read extended header in offset %lu\n", offset
);
104 ret
= bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
));
106 error_setg_errno(errp
, -ret
, "qcow2_read_extension: ERROR: "
107 "pread fail from offset %" PRIu64
, offset
);
110 be32_to_cpus(&ext
.magic
);
111 be32_to_cpus(&ext
.len
);
112 offset
+= sizeof(ext
);
114 printf("ext.magic = 0x%x\n", ext
.magic
);
116 if (ext
.len
> end_offset
- offset
) {
117 error_setg(errp
, "Header extension too large");
122 case QCOW2_EXT_MAGIC_END
:
125 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
126 if (ext
.len
>= sizeof(bs
->backing_format
)) {
127 error_setg(errp
, "ERROR: ext_backing_format: len=%u too large"
128 " (>=%zu)", ext
.len
, sizeof(bs
->backing_format
));
131 ret
= bdrv_pread(bs
->file
, offset
, bs
->backing_format
, ext
.len
);
133 error_setg_errno(errp
, -ret
, "ERROR: ext_backing_format: "
134 "Could not read format name");
137 bs
->backing_format
[ext
.len
] = '\0';
139 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
143 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
144 if (p_feature_table
!= NULL
) {
145 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
146 ret
= bdrv_pread(bs
->file
, offset
, feature_table
, ext
.len
);
148 error_setg_errno(errp
, -ret
, "ERROR: ext_feature_table: "
149 "Could not read table");
153 *p_feature_table
= feature_table
;
158 /* unknown magic - save it in case we need to rewrite the header */
160 Qcow2UnknownHeaderExtension
*uext
;
162 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
163 uext
->magic
= ext
.magic
;
165 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
167 ret
= bdrv_pread(bs
->file
, offset
, uext
->data
, uext
->len
);
169 error_setg_errno(errp
, -ret
, "ERROR: unknown extension: "
170 "Could not read data");
177 offset
+= ((ext
.len
+ 7) & ~7);
183 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
185 BDRVQcowState
*s
= bs
->opaque
;
186 Qcow2UnknownHeaderExtension
*uext
, *next
;
188 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
189 QLIST_REMOVE(uext
, next
);
194 static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState
*bs
,
195 Error
**errp
, const char *fmt
, ...)
201 vsnprintf(msg
, sizeof(msg
), fmt
, ap
);
204 error_set(errp
, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE
, bs
->device_name
, "qcow2",
208 static void report_unsupported_feature(BlockDriverState
*bs
,
209 Error
**errp
, Qcow2Feature
*table
, uint64_t mask
)
211 while (table
&& table
->name
[0] != '\0') {
212 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
213 if (mask
& (1 << table
->bit
)) {
214 report_unsupported(bs
, errp
, "%.46s", table
->name
);
215 mask
&= ~(1 << table
->bit
);
222 report_unsupported(bs
, errp
, "Unknown incompatible feature: %" PRIx64
,
228 * Sets the dirty bit and flushes afterwards if necessary.
230 * The incompatible_features bit is only set if the image file header was
231 * updated successfully. Therefore it is not required to check the return
232 * value of this function.
234 int qcow2_mark_dirty(BlockDriverState
*bs
)
236 BDRVQcowState
*s
= bs
->opaque
;
240 assert(s
->qcow_version
>= 3);
242 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
243 return 0; /* already dirty */
246 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
247 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, incompatible_features
),
252 ret
= bdrv_flush(bs
->file
);
257 /* Only treat image as dirty if the header was updated successfully */
258 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
263 * Clears the dirty bit and flushes before if necessary. Only call this
264 * function when there are no pending requests, it does not guard against
265 * concurrent requests dirtying the image.
267 static int qcow2_mark_clean(BlockDriverState
*bs
)
269 BDRVQcowState
*s
= bs
->opaque
;
271 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
272 int ret
= bdrv_flush(bs
);
277 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
278 return qcow2_update_header(bs
);
284 * Marks the image as corrupt.
286 int qcow2_mark_corrupt(BlockDriverState
*bs
)
288 BDRVQcowState
*s
= bs
->opaque
;
290 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
291 return qcow2_update_header(bs
);
295 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
296 * before if necessary.
298 int qcow2_mark_consistent(BlockDriverState
*bs
)
300 BDRVQcowState
*s
= bs
->opaque
;
302 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
303 int ret
= bdrv_flush(bs
);
308 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
309 return qcow2_update_header(bs
);
314 static int qcow2_check(BlockDriverState
*bs
, BdrvCheckResult
*result
,
317 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
322 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
323 ret
= qcow2_mark_clean(bs
);
327 return qcow2_mark_consistent(bs
);
332 static QemuOptsList qcow2_runtime_opts
= {
334 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
337 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
338 .type
= QEMU_OPT_BOOL
,
339 .help
= "Postpone refcount updates",
342 .name
= QCOW2_OPT_DISCARD_REQUEST
,
343 .type
= QEMU_OPT_BOOL
,
344 .help
= "Pass guest discard requests to the layer below",
347 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
348 .type
= QEMU_OPT_BOOL
,
349 .help
= "Generate discard requests when snapshot related space "
353 .name
= QCOW2_OPT_DISCARD_OTHER
,
354 .type
= QEMU_OPT_BOOL
,
355 .help
= "Generate discard requests when other clusters are freed",
358 .name
= QCOW2_OPT_OVERLAP
,
359 .type
= QEMU_OPT_STRING
,
360 .help
= "Selects which overlap checks to perform from a range of "
361 "templates (none, constant, cached, all)",
364 .name
= QCOW2_OPT_OVERLAP_MAIN_HEADER
,
365 .type
= QEMU_OPT_BOOL
,
366 .help
= "Check for unintended writes into the main qcow2 header",
369 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L1
,
370 .type
= QEMU_OPT_BOOL
,
371 .help
= "Check for unintended writes into the active L1 table",
374 .name
= QCOW2_OPT_OVERLAP_ACTIVE_L2
,
375 .type
= QEMU_OPT_BOOL
,
376 .help
= "Check for unintended writes into an active L2 table",
379 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
380 .type
= QEMU_OPT_BOOL
,
381 .help
= "Check for unintended writes into the refcount table",
384 .name
= QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
385 .type
= QEMU_OPT_BOOL
,
386 .help
= "Check for unintended writes into a refcount block",
389 .name
= QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
390 .type
= QEMU_OPT_BOOL
,
391 .help
= "Check for unintended writes into the snapshot table",
394 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L1
,
395 .type
= QEMU_OPT_BOOL
,
396 .help
= "Check for unintended writes into an inactive L1 table",
399 .name
= QCOW2_OPT_OVERLAP_INACTIVE_L2
,
400 .type
= QEMU_OPT_BOOL
,
401 .help
= "Check for unintended writes into an inactive L2 table",
403 { /* end of list */ }
407 static const char *overlap_bool_option_names
[QCOW2_OL_MAX_BITNR
] = {
408 [QCOW2_OL_MAIN_HEADER_BITNR
] = QCOW2_OPT_OVERLAP_MAIN_HEADER
,
409 [QCOW2_OL_ACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L1
,
410 [QCOW2_OL_ACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_ACTIVE_L2
,
411 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE
,
412 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK
,
413 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE
,
414 [QCOW2_OL_INACTIVE_L1_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L1
,
415 [QCOW2_OL_INACTIVE_L2_BITNR
] = QCOW2_OPT_OVERLAP_INACTIVE_L2
,
418 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
421 BDRVQcowState
*s
= bs
->opaque
;
425 Error
*local_err
= NULL
;
427 uint64_t l1_vm_state_index
;
428 const char *opt_overlap_check
;
429 int overlap_check_template
= 0;
431 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
433 error_setg_errno(errp
, -ret
, "Could not read qcow2 header");
436 be32_to_cpus(&header
.magic
);
437 be32_to_cpus(&header
.version
);
438 be64_to_cpus(&header
.backing_file_offset
);
439 be32_to_cpus(&header
.backing_file_size
);
440 be64_to_cpus(&header
.size
);
441 be32_to_cpus(&header
.cluster_bits
);
442 be32_to_cpus(&header
.crypt_method
);
443 be64_to_cpus(&header
.l1_table_offset
);
444 be32_to_cpus(&header
.l1_size
);
445 be64_to_cpus(&header
.refcount_table_offset
);
446 be32_to_cpus(&header
.refcount_table_clusters
);
447 be64_to_cpus(&header
.snapshots_offset
);
448 be32_to_cpus(&header
.nb_snapshots
);
450 if (header
.magic
!= QCOW_MAGIC
) {
451 error_setg(errp
, "Image is not in qcow2 format");
455 if (header
.version
< 2 || header
.version
> 3) {
456 report_unsupported(bs
, errp
, "QCOW version %d", header
.version
);
461 s
->qcow_version
= header
.version
;
463 /* Initialise version 3 header fields */
464 if (header
.version
== 2) {
465 header
.incompatible_features
= 0;
466 header
.compatible_features
= 0;
467 header
.autoclear_features
= 0;
468 header
.refcount_order
= 4;
469 header
.header_length
= 72;
471 be64_to_cpus(&header
.incompatible_features
);
472 be64_to_cpus(&header
.compatible_features
);
473 be64_to_cpus(&header
.autoclear_features
);
474 be32_to_cpus(&header
.refcount_order
);
475 be32_to_cpus(&header
.header_length
);
478 if (header
.header_length
> sizeof(header
)) {
479 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
480 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
481 ret
= bdrv_pread(bs
->file
, sizeof(header
), s
->unknown_header_fields
,
482 s
->unknown_header_fields_size
);
484 error_setg_errno(errp
, -ret
, "Could not read unknown qcow2 header "
490 if (header
.backing_file_offset
) {
491 ext_end
= header
.backing_file_offset
;
493 ext_end
= 1 << header
.cluster_bits
;
496 /* Handle feature bits */
497 s
->incompatible_features
= header
.incompatible_features
;
498 s
->compatible_features
= header
.compatible_features
;
499 s
->autoclear_features
= header
.autoclear_features
;
501 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
502 void *feature_table
= NULL
;
503 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
504 &feature_table
, NULL
);
505 report_unsupported_feature(bs
, errp
, feature_table
,
506 s
->incompatible_features
&
507 ~QCOW2_INCOMPAT_MASK
);
512 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
513 /* Corrupt images may not be written to unless they are being repaired
515 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
516 error_setg(errp
, "qcow2: Image is corrupt; cannot be opened "
523 /* Check support for various header values */
524 if (header
.refcount_order
!= 4) {
525 report_unsupported(bs
, errp
, "%d bit reference counts",
526 1 << header
.refcount_order
);
530 s
->refcount_order
= header
.refcount_order
;
532 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
533 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
534 error_setg(errp
, "Unsupported cluster size: 2^%i", header
.cluster_bits
);
538 if (header
.crypt_method
> QCOW_CRYPT_AES
) {
539 error_setg(errp
, "Unsupported encryption method: %i",
540 header
.crypt_method
);
544 s
->crypt_method_header
= header
.crypt_method
;
545 if (s
->crypt_method_header
) {
548 s
->cluster_bits
= header
.cluster_bits
;
549 s
->cluster_size
= 1 << s
->cluster_bits
;
550 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
551 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
552 s
->l2_size
= 1 << s
->l2_bits
;
553 bs
->total_sectors
= header
.size
/ 512;
554 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
555 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
556 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
557 s
->refcount_table_offset
= header
.refcount_table_offset
;
558 s
->refcount_table_size
=
559 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
561 s
->snapshots_offset
= header
.snapshots_offset
;
562 s
->nb_snapshots
= header
.nb_snapshots
;
564 /* read the level 1 table */
565 s
->l1_size
= header
.l1_size
;
567 l1_vm_state_index
= size_to_l1(s
, header
.size
);
568 if (l1_vm_state_index
> INT_MAX
) {
569 error_setg(errp
, "Image is too big");
573 s
->l1_vm_state_index
= l1_vm_state_index
;
575 /* the L1 table must contain at least enough entries to put
577 if (s
->l1_size
< s
->l1_vm_state_index
) {
578 error_setg(errp
, "L1 table is too small");
582 s
->l1_table_offset
= header
.l1_table_offset
;
583 if (s
->l1_size
> 0) {
584 s
->l1_table
= g_malloc0(
585 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
586 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
587 s
->l1_size
* sizeof(uint64_t));
589 error_setg_errno(errp
, -ret
, "Could not read L1 table");
592 for(i
= 0;i
< s
->l1_size
; i
++) {
593 be64_to_cpus(&s
->l1_table
[i
]);
597 /* alloc L2 table/refcount block cache */
598 s
->l2_table_cache
= qcow2_cache_create(bs
, L2_CACHE_SIZE
);
599 s
->refcount_block_cache
= qcow2_cache_create(bs
, REFCOUNT_CACHE_SIZE
);
601 s
->cluster_cache
= g_malloc(s
->cluster_size
);
602 /* one more sector for decompressed data alignment */
603 s
->cluster_data
= qemu_blockalign(bs
, QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
605 s
->cluster_cache_offset
= -1;
608 ret
= qcow2_refcount_init(bs
);
610 error_setg_errno(errp
, -ret
, "Could not initialize refcount handling");
614 QLIST_INIT(&s
->cluster_allocs
);
615 QTAILQ_INIT(&s
->discards
);
617 /* read qcow2 extensions */
618 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
,
620 error_propagate(errp
, local_err
);
625 /* read the backing file name */
626 if (header
.backing_file_offset
!= 0) {
627 len
= header
.backing_file_size
;
631 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
632 bs
->backing_file
, len
);
634 error_setg_errno(errp
, -ret
, "Could not read backing file name");
637 bs
->backing_file
[len
] = '\0';
640 ret
= qcow2_read_snapshots(bs
);
642 error_setg_errno(errp
, -ret
, "Could not read snapshots");
646 /* Clear unknown autoclear feature bits */
647 if (!bs
->read_only
&& s
->autoclear_features
!= 0) {
648 s
->autoclear_features
= 0;
649 ret
= qcow2_update_header(bs
);
651 error_setg_errno(errp
, -ret
, "Could not update qcow2 header");
656 /* Initialise locks */
657 qemu_co_mutex_init(&s
->lock
);
659 /* Repair image if dirty */
660 if (!(flags
& BDRV_O_CHECK
) && !bs
->read_only
&&
661 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
662 BdrvCheckResult result
= {0};
664 ret
= qcow2_check(bs
, &result
, BDRV_FIX_ERRORS
);
666 error_setg_errno(errp
, -ret
, "Could not repair dirty image");
671 /* Enable lazy_refcounts according to image and command line options */
672 opts
= qemu_opts_create_nofail(&qcow2_runtime_opts
);
673 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
674 if (error_is_set(&local_err
)) {
675 error_propagate(errp
, local_err
);
680 s
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
681 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
683 s
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
684 s
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
685 s
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
686 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
687 flags
& BDRV_O_UNMAP
);
688 s
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
689 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
690 s
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
691 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
693 opt_overlap_check
= qemu_opt_get(opts
, "overlap-check") ?: "cached";
694 if (!strcmp(opt_overlap_check
, "none")) {
695 overlap_check_template
= 0;
696 } else if (!strcmp(opt_overlap_check
, "constant")) {
697 overlap_check_template
= QCOW2_OL_CONSTANT
;
698 } else if (!strcmp(opt_overlap_check
, "cached")) {
699 overlap_check_template
= QCOW2_OL_CACHED
;
700 } else if (!strcmp(opt_overlap_check
, "all")) {
701 overlap_check_template
= QCOW2_OL_ALL
;
703 error_setg(errp
, "Unsupported value '%s' for qcow2 option "
704 "'overlap-check'. Allowed are either of the following: "
705 "none, constant, cached, all", opt_overlap_check
);
711 s
->overlap_check
= 0;
712 for (i
= 0; i
< QCOW2_OL_MAX_BITNR
; i
++) {
713 /* overlap-check defines a template bitmask, but every flag may be
714 * overwritten through the associated boolean option */
716 qemu_opt_get_bool(opts
, overlap_bool_option_names
[i
],
717 overlap_check_template
& (1 << i
)) << i
;
722 if (s
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
723 error_setg(errp
, "Lazy refcounts require a qcow2 image with at least "
724 "qemu 1.1 compatibility level");
731 BdrvCheckResult result
= {0};
732 qcow2_check_refcounts(bs
, &result
, 0);
738 g_free(s
->unknown_header_fields
);
739 cleanup_unknown_header_ext(bs
);
740 qcow2_free_snapshots(bs
);
741 qcow2_refcount_close(bs
);
743 /* else pre-write overlap checks in cache_destroy may crash */
745 if (s
->l2_table_cache
) {
746 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
748 g_free(s
->cluster_cache
);
749 qemu_vfree(s
->cluster_data
);
753 static int qcow2_set_key(BlockDriverState
*bs
, const char *key
)
755 BDRVQcowState
*s
= bs
->opaque
;
759 memset(keybuf
, 0, 16);
763 /* XXX: we could compress the chars to 7 bits to increase
765 for(i
= 0;i
< len
;i
++) {
768 s
->crypt_method
= s
->crypt_method_header
;
770 if (AES_set_encrypt_key(keybuf
, 128, &s
->aes_encrypt_key
) != 0)
772 if (AES_set_decrypt_key(keybuf
, 128, &s
->aes_decrypt_key
) != 0)
782 AES_encrypt(in
, tmp
, &s
->aes_encrypt_key
);
783 AES_decrypt(tmp
, out
, &s
->aes_decrypt_key
);
784 for(i
= 0; i
< 16; i
++)
785 printf(" %02x", tmp
[i
]);
787 for(i
= 0; i
< 16; i
++)
788 printf(" %02x", out
[i
]);
795 /* We have nothing to do for QCOW2 reopen, stubs just return
797 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
798 BlockReopenQueue
*queue
, Error
**errp
)
803 static int64_t coroutine_fn
qcow2_co_get_block_status(BlockDriverState
*bs
,
804 int64_t sector_num
, int nb_sectors
, int *pnum
)
806 BDRVQcowState
*s
= bs
->opaque
;
807 uint64_t cluster_offset
;
808 int index_in_cluster
, ret
;
812 qemu_co_mutex_lock(&s
->lock
);
813 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9, pnum
, &cluster_offset
);
814 qemu_co_mutex_unlock(&s
->lock
);
819 if (cluster_offset
!= 0 && ret
!= QCOW2_CLUSTER_COMPRESSED
&&
821 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
822 cluster_offset
|= (index_in_cluster
<< BDRV_SECTOR_BITS
);
823 status
|= BDRV_BLOCK_OFFSET_VALID
| cluster_offset
;
825 if (ret
== QCOW2_CLUSTER_ZERO
) {
826 status
|= BDRV_BLOCK_ZERO
;
827 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
828 status
|= BDRV_BLOCK_DATA
;
833 /* handle reading after the end of the backing file */
834 int qcow2_backing_read1(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
835 int64_t sector_num
, int nb_sectors
)
838 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
840 if (sector_num
>= bs
->total_sectors
)
843 n1
= bs
->total_sectors
- sector_num
;
845 qemu_iovec_memset(qiov
, 512 * n1
, 0, 512 * (nb_sectors
- n1
));
850 static coroutine_fn
int qcow2_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
851 int remaining_sectors
, QEMUIOVector
*qiov
)
853 BDRVQcowState
*s
= bs
->opaque
;
854 int index_in_cluster
, n1
;
856 int cur_nr_sectors
; /* number of sectors in current iteration */
857 uint64_t cluster_offset
= 0;
858 uint64_t bytes_done
= 0;
859 QEMUIOVector hd_qiov
;
860 uint8_t *cluster_data
= NULL
;
862 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
864 qemu_co_mutex_lock(&s
->lock
);
866 while (remaining_sectors
!= 0) {
868 /* prepare next request */
869 cur_nr_sectors
= remaining_sectors
;
870 if (s
->crypt_method
) {
871 cur_nr_sectors
= MIN(cur_nr_sectors
,
872 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
);
875 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9,
876 &cur_nr_sectors
, &cluster_offset
);
881 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
883 qemu_iovec_reset(&hd_qiov
);
884 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
,
885 cur_nr_sectors
* 512);
888 case QCOW2_CLUSTER_UNALLOCATED
:
890 if (bs
->backing_hd
) {
891 /* read from the base image */
892 n1
= qcow2_backing_read1(bs
->backing_hd
, &hd_qiov
,
893 sector_num
, cur_nr_sectors
);
895 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
896 qemu_co_mutex_unlock(&s
->lock
);
897 ret
= bdrv_co_readv(bs
->backing_hd
, sector_num
,
899 qemu_co_mutex_lock(&s
->lock
);
905 /* Note: in this case, no need to wait */
906 qemu_iovec_memset(&hd_qiov
, 0, 0, 512 * cur_nr_sectors
);
910 case QCOW2_CLUSTER_ZERO
:
911 qemu_iovec_memset(&hd_qiov
, 0, 0, 512 * cur_nr_sectors
);
914 case QCOW2_CLUSTER_COMPRESSED
:
915 /* add AIO support for compressed blocks ? */
916 ret
= qcow2_decompress_cluster(bs
, cluster_offset
);
921 qemu_iovec_from_buf(&hd_qiov
, 0,
922 s
->cluster_cache
+ index_in_cluster
* 512,
923 512 * cur_nr_sectors
);
926 case QCOW2_CLUSTER_NORMAL
:
927 if ((cluster_offset
& 511) != 0) {
932 if (s
->crypt_method
) {
934 * For encrypted images, read everything into a temporary
935 * contiguous buffer on which the AES functions can work.
939 qemu_blockalign(bs
, QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
942 assert(cur_nr_sectors
<=
943 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
);
944 qemu_iovec_reset(&hd_qiov
);
945 qemu_iovec_add(&hd_qiov
, cluster_data
,
946 512 * cur_nr_sectors
);
949 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
950 qemu_co_mutex_unlock(&s
->lock
);
951 ret
= bdrv_co_readv(bs
->file
,
952 (cluster_offset
>> 9) + index_in_cluster
,
953 cur_nr_sectors
, &hd_qiov
);
954 qemu_co_mutex_lock(&s
->lock
);
958 if (s
->crypt_method
) {
959 qcow2_encrypt_sectors(s
, sector_num
, cluster_data
,
960 cluster_data
, cur_nr_sectors
, 0, &s
->aes_decrypt_key
);
961 qemu_iovec_from_buf(qiov
, bytes_done
,
962 cluster_data
, 512 * cur_nr_sectors
);
967 g_assert_not_reached();
972 remaining_sectors
-= cur_nr_sectors
;
973 sector_num
+= cur_nr_sectors
;
974 bytes_done
+= cur_nr_sectors
* 512;
979 qemu_co_mutex_unlock(&s
->lock
);
981 qemu_iovec_destroy(&hd_qiov
);
982 qemu_vfree(cluster_data
);
987 static coroutine_fn
int qcow2_co_writev(BlockDriverState
*bs
,
989 int remaining_sectors
,
992 BDRVQcowState
*s
= bs
->opaque
;
993 int index_in_cluster
;
996 int cur_nr_sectors
; /* number of sectors in current iteration */
997 uint64_t cluster_offset
;
998 QEMUIOVector hd_qiov
;
999 uint64_t bytes_done
= 0;
1000 uint8_t *cluster_data
= NULL
;
1001 QCowL2Meta
*l2meta
= NULL
;
1003 trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num
,
1006 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
1008 s
->cluster_cache_offset
= -1; /* disable compressed cache */
1010 qemu_co_mutex_lock(&s
->lock
);
1012 while (remaining_sectors
!= 0) {
1016 trace_qcow2_writev_start_part(qemu_coroutine_self());
1017 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
1018 n_end
= index_in_cluster
+ remaining_sectors
;
1019 if (s
->crypt_method
&&
1020 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
) {
1021 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
1024 ret
= qcow2_alloc_cluster_offset(bs
, sector_num
<< 9,
1025 index_in_cluster
, n_end
, &cur_nr_sectors
, &cluster_offset
, &l2meta
);
1030 assert((cluster_offset
& 511) == 0);
1032 qemu_iovec_reset(&hd_qiov
);
1033 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
,
1034 cur_nr_sectors
* 512);
1036 if (s
->crypt_method
) {
1037 if (!cluster_data
) {
1038 cluster_data
= qemu_blockalign(bs
, QCOW_MAX_CRYPT_CLUSTERS
*
1042 assert(hd_qiov
.size
<=
1043 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
1044 qemu_iovec_to_buf(&hd_qiov
, 0, cluster_data
, hd_qiov
.size
);
1046 qcow2_encrypt_sectors(s
, sector_num
, cluster_data
,
1047 cluster_data
, cur_nr_sectors
, 1, &s
->aes_encrypt_key
);
1049 qemu_iovec_reset(&hd_qiov
);
1050 qemu_iovec_add(&hd_qiov
, cluster_data
,
1051 cur_nr_sectors
* 512);
1054 ret
= qcow2_pre_write_overlap_check(bs
, 0,
1055 cluster_offset
+ index_in_cluster
* BDRV_SECTOR_SIZE
,
1056 cur_nr_sectors
* BDRV_SECTOR_SIZE
);
1061 qemu_co_mutex_unlock(&s
->lock
);
1062 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
1063 trace_qcow2_writev_data(qemu_coroutine_self(),
1064 (cluster_offset
>> 9) + index_in_cluster
);
1065 ret
= bdrv_co_writev(bs
->file
,
1066 (cluster_offset
>> 9) + index_in_cluster
,
1067 cur_nr_sectors
, &hd_qiov
);
1068 qemu_co_mutex_lock(&s
->lock
);
1073 while (l2meta
!= NULL
) {
1076 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
1081 /* Take the request off the list of running requests */
1082 if (l2meta
->nb_clusters
!= 0) {
1083 QLIST_REMOVE(l2meta
, next_in_flight
);
1086 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1088 next
= l2meta
->next
;
1093 remaining_sectors
-= cur_nr_sectors
;
1094 sector_num
+= cur_nr_sectors
;
1095 bytes_done
+= cur_nr_sectors
* 512;
1096 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors
);
1101 qemu_co_mutex_unlock(&s
->lock
);
1103 while (l2meta
!= NULL
) {
1106 if (l2meta
->nb_clusters
!= 0) {
1107 QLIST_REMOVE(l2meta
, next_in_flight
);
1109 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1111 next
= l2meta
->next
;
1116 qemu_iovec_destroy(&hd_qiov
);
1117 qemu_vfree(cluster_data
);
1118 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
1123 static void qcow2_close(BlockDriverState
*bs
)
1125 BDRVQcowState
*s
= bs
->opaque
;
1126 g_free(s
->l1_table
);
1127 /* else pre-write overlap checks in cache_destroy may crash */
1130 qcow2_cache_flush(bs
, s
->l2_table_cache
);
1131 qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1133 qcow2_mark_clean(bs
);
1135 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1136 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1138 g_free(s
->unknown_header_fields
);
1139 cleanup_unknown_header_ext(bs
);
1141 g_free(s
->cluster_cache
);
1142 qemu_vfree(s
->cluster_data
);
1143 qcow2_refcount_close(bs
);
1144 qcow2_free_snapshots(bs
);
1147 static void qcow2_invalidate_cache(BlockDriverState
*bs
)
1149 BDRVQcowState
*s
= bs
->opaque
;
1150 int flags
= s
->flags
;
1151 AES_KEY aes_encrypt_key
;
1152 AES_KEY aes_decrypt_key
;
1153 uint32_t crypt_method
= 0;
1157 * Backing files are read-only which makes all of their metadata immutable,
1158 * that means we don't have to worry about reopening them here.
1161 if (s
->crypt_method
) {
1162 crypt_method
= s
->crypt_method
;
1163 memcpy(&aes_encrypt_key
, &s
->aes_encrypt_key
, sizeof(aes_encrypt_key
));
1164 memcpy(&aes_decrypt_key
, &s
->aes_decrypt_key
, sizeof(aes_decrypt_key
));
1169 options
= qdict_new();
1170 qdict_put(options
, QCOW2_OPT_LAZY_REFCOUNTS
,
1171 qbool_from_int(s
->use_lazy_refcounts
));
1173 memset(s
, 0, sizeof(BDRVQcowState
));
1174 qcow2_open(bs
, options
, flags
, NULL
);
1179 s
->crypt_method
= crypt_method
;
1180 memcpy(&s
->aes_encrypt_key
, &aes_encrypt_key
, sizeof(aes_encrypt_key
));
1181 memcpy(&s
->aes_decrypt_key
, &aes_decrypt_key
, sizeof(aes_decrypt_key
));
1185 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
1186 size_t len
, size_t buflen
)
1188 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
1189 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
1191 if (buflen
< ext_len
) {
1195 *ext_backing_fmt
= (QCowExtension
) {
1196 .magic
= cpu_to_be32(magic
),
1197 .len
= cpu_to_be32(len
),
1199 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
1205 * Updates the qcow2 header, including the variable length parts of it, i.e.
1206 * the backing file name and all extensions. qcow2 was not designed to allow
1207 * such changes, so if we run out of space (we can only use the first cluster)
1208 * this function may fail.
1210 * Returns 0 on success, -errno in error cases.
1212 int qcow2_update_header(BlockDriverState
*bs
)
1214 BDRVQcowState
*s
= bs
->opaque
;
1217 size_t buflen
= s
->cluster_size
;
1219 uint64_t total_size
;
1220 uint32_t refcount_table_clusters
;
1221 size_t header_length
;
1222 Qcow2UnknownHeaderExtension
*uext
;
1224 buf
= qemu_blockalign(bs
, buflen
);
1226 /* Header structure */
1227 header
= (QCowHeader
*) buf
;
1229 if (buflen
< sizeof(*header
)) {
1234 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
1235 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1236 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
1238 *header
= (QCowHeader
) {
1239 /* Version 2 fields */
1240 .magic
= cpu_to_be32(QCOW_MAGIC
),
1241 .version
= cpu_to_be32(s
->qcow_version
),
1242 .backing_file_offset
= 0,
1243 .backing_file_size
= 0,
1244 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
1245 .size
= cpu_to_be64(total_size
),
1246 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
1247 .l1_size
= cpu_to_be32(s
->l1_size
),
1248 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
1249 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
1250 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
1251 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
1252 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
1254 /* Version 3 fields */
1255 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
1256 .compatible_features
= cpu_to_be64(s
->compatible_features
),
1257 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
1258 .refcount_order
= cpu_to_be32(s
->refcount_order
),
1259 .header_length
= cpu_to_be32(header_length
),
1262 /* For older versions, write a shorter header */
1263 switch (s
->qcow_version
) {
1265 ret
= offsetof(QCowHeader
, incompatible_features
);
1268 ret
= sizeof(*header
);
1277 memset(buf
, 0, buflen
);
1279 /* Preserve any unknown field in the header */
1280 if (s
->unknown_header_fields_size
) {
1281 if (buflen
< s
->unknown_header_fields_size
) {
1286 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
1287 buf
+= s
->unknown_header_fields_size
;
1288 buflen
-= s
->unknown_header_fields_size
;
1291 /* Backing file format header extension */
1292 if (*bs
->backing_format
) {
1293 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
1294 bs
->backing_format
, strlen(bs
->backing_format
),
1305 Qcow2Feature features
[] = {
1307 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1308 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
1309 .name
= "dirty bit",
1312 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1313 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
1314 .name
= "corrupt bit",
1317 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
1318 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
1319 .name
= "lazy refcounts",
1323 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
1324 features
, sizeof(features
), buflen
);
1331 /* Keep unknown header extensions */
1332 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
1333 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
1342 /* End of header extensions */
1343 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
1351 /* Backing file name */
1352 if (*bs
->backing_file
) {
1353 size_t backing_file_len
= strlen(bs
->backing_file
);
1355 if (buflen
< backing_file_len
) {
1360 /* Using strncpy is ok here, since buf is not NUL-terminated. */
1361 strncpy(buf
, bs
->backing_file
, buflen
);
1363 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
1364 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
1367 /* Write the new header */
1368 ret
= bdrv_pwrite(bs
->file
, 0, header
, s
->cluster_size
);
1379 static int qcow2_change_backing_file(BlockDriverState
*bs
,
1380 const char *backing_file
, const char *backing_fmt
)
1382 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1383 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1385 return qcow2_update_header(bs
);
1388 static int preallocate(BlockDriverState
*bs
)
1390 uint64_t nb_sectors
;
1392 uint64_t host_offset
= 0;
1397 nb_sectors
= bdrv_getlength(bs
) >> 9;
1400 while (nb_sectors
) {
1401 num
= MIN(nb_sectors
, INT_MAX
>> 9);
1402 ret
= qcow2_alloc_cluster_offset(bs
, offset
, 0, num
, &num
,
1403 &host_offset
, &meta
);
1408 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
1410 qcow2_free_any_clusters(bs
, meta
->alloc_offset
, meta
->nb_clusters
,
1411 QCOW2_DISCARD_NEVER
);
1415 /* There are no dependent requests, but we need to remove our request
1416 * from the list of in-flight requests */
1418 QLIST_REMOVE(meta
, next_in_flight
);
1421 /* TODO Preallocate data if requested */
1428 * It is expected that the image file is large enough to actually contain
1429 * all of the allocated clusters (otherwise we get failing reads after
1430 * EOF). Extend the image to the last allocated sector.
1432 if (host_offset
!= 0) {
1434 memset(buf
, 0, 512);
1435 ret
= bdrv_write(bs
->file
, (host_offset
>> 9) + num
- 1, buf
, 1);
1444 static int qcow2_create2(const char *filename
, int64_t total_size
,
1445 const char *backing_file
, const char *backing_format
,
1446 int flags
, size_t cluster_size
, int prealloc
,
1447 QEMUOptionParameter
*options
, int version
,
1450 /* Calculate cluster_bits */
1452 cluster_bits
= ffs(cluster_size
) - 1;
1453 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
1454 (1 << cluster_bits
) != cluster_size
)
1456 error_setg(errp
, "Cluster size must be a power of two between %d and "
1457 "%dk", 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
1462 * Open the image file and write a minimal qcow2 header.
1464 * We keep things simple and start with a zero-sized image. We also
1465 * do without refcount blocks or a L1 table for now. We'll fix the
1466 * inconsistency later.
1468 * We do need a refcount table because growing the refcount table means
1469 * allocating two new refcount blocks - the seconds of which would be at
1470 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
1471 * size for any qcow2 image.
1473 BlockDriverState
* bs
;
1475 uint8_t* refcount_table
;
1476 Error
*local_err
= NULL
;
1479 ret
= bdrv_create_file(filename
, options
, &local_err
);
1481 error_propagate(errp
, local_err
);
1485 ret
= bdrv_file_open(&bs
, filename
, NULL
, BDRV_O_RDWR
, &local_err
);
1487 error_propagate(errp
, local_err
);
1491 /* Write the header */
1492 memset(&header
, 0, sizeof(header
));
1493 header
.magic
= cpu_to_be32(QCOW_MAGIC
);
1494 header
.version
= cpu_to_be32(version
);
1495 header
.cluster_bits
= cpu_to_be32(cluster_bits
);
1496 header
.size
= cpu_to_be64(0);
1497 header
.l1_table_offset
= cpu_to_be64(0);
1498 header
.l1_size
= cpu_to_be32(0);
1499 header
.refcount_table_offset
= cpu_to_be64(cluster_size
);
1500 header
.refcount_table_clusters
= cpu_to_be32(1);
1501 header
.refcount_order
= cpu_to_be32(3 + REFCOUNT_SHIFT
);
1502 header
.header_length
= cpu_to_be32(sizeof(header
));
1504 if (flags
& BLOCK_FLAG_ENCRYPT
) {
1505 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
1507 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
1510 if (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
) {
1511 header
.compatible_features
|=
1512 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
1515 ret
= bdrv_pwrite(bs
, 0, &header
, sizeof(header
));
1517 error_setg_errno(errp
, -ret
, "Could not write qcow2 header");
1521 /* Write an empty refcount table */
1522 refcount_table
= g_malloc0(cluster_size
);
1523 ret
= bdrv_pwrite(bs
, cluster_size
, refcount_table
, cluster_size
);
1524 g_free(refcount_table
);
1527 error_setg_errno(errp
, -ret
, "Could not write refcount table");
1534 * And now open the image and make it consistent first (i.e. increase the
1535 * refcount of the cluster that is occupied by the header and the refcount
1538 BlockDriver
* drv
= bdrv_find_format("qcow2");
1539 assert(drv
!= NULL
);
1540 ret
= bdrv_open(bs
, filename
, NULL
,
1541 BDRV_O_RDWR
| BDRV_O_CACHE_WB
| BDRV_O_NO_FLUSH
, drv
, &local_err
);
1543 error_propagate(errp
, local_err
);
1547 ret
= qcow2_alloc_clusters(bs
, 2 * cluster_size
);
1549 error_setg_errno(errp
, -ret
, "Could not allocate clusters for qcow2 "
1550 "header and refcount table");
1553 } else if (ret
!= 0) {
1554 error_report("Huh, first cluster in empty image is already in use?");
1558 /* Okay, now that we have a valid image, let's give it the right size */
1559 ret
= bdrv_truncate(bs
, total_size
* BDRV_SECTOR_SIZE
);
1561 error_setg_errno(errp
, -ret
, "Could not resize image");
1565 /* Want a backing file? There you go.*/
1567 ret
= bdrv_change_backing_file(bs
, backing_file
, backing_format
);
1569 error_setg_errno(errp
, -ret
, "Could not assign backing file '%s' "
1570 "with format '%s'", backing_file
, backing_format
);
1575 /* And if we're supposed to preallocate metadata, do that now */
1577 BDRVQcowState
*s
= bs
->opaque
;
1578 qemu_co_mutex_lock(&s
->lock
);
1579 ret
= preallocate(bs
);
1580 qemu_co_mutex_unlock(&s
->lock
);
1582 error_setg_errno(errp
, -ret
, "Could not preallocate metadata");
1593 static int qcow2_create(const char *filename
, QEMUOptionParameter
*options
,
1596 const char *backing_file
= NULL
;
1597 const char *backing_fmt
= NULL
;
1598 uint64_t sectors
= 0;
1600 size_t cluster_size
= DEFAULT_CLUSTER_SIZE
;
1603 Error
*local_err
= NULL
;
1606 /* Read out options */
1607 while (options
&& options
->name
) {
1608 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
1609 sectors
= options
->value
.n
/ 512;
1610 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
1611 backing_file
= options
->value
.s
;
1612 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FMT
)) {
1613 backing_fmt
= options
->value
.s
;
1614 } else if (!strcmp(options
->name
, BLOCK_OPT_ENCRYPT
)) {
1615 flags
|= options
->value
.n
? BLOCK_FLAG_ENCRYPT
: 0;
1616 } else if (!strcmp(options
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
1617 if (options
->value
.n
) {
1618 cluster_size
= options
->value
.n
;
1620 } else if (!strcmp(options
->name
, BLOCK_OPT_PREALLOC
)) {
1621 if (!options
->value
.s
|| !strcmp(options
->value
.s
, "off")) {
1623 } else if (!strcmp(options
->value
.s
, "metadata")) {
1626 error_setg(errp
, "Invalid preallocation mode: '%s'",
1630 } else if (!strcmp(options
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
1631 if (!options
->value
.s
) {
1632 /* keep the default */
1633 } else if (!strcmp(options
->value
.s
, "0.10")) {
1635 } else if (!strcmp(options
->value
.s
, "1.1")) {
1638 error_setg(errp
, "Invalid compatibility level: '%s'",
1642 } else if (!strcmp(options
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
1643 flags
|= options
->value
.n
? BLOCK_FLAG_LAZY_REFCOUNTS
: 0;
1648 if (backing_file
&& prealloc
) {
1649 error_setg(errp
, "Backing file and preallocation cannot be used at "
1654 if (version
< 3 && (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
)) {
1655 error_setg(errp
, "Lazy refcounts only supported with compatibility "
1656 "level 1.1 and above (use compat=1.1 or greater)");
1660 ret
= qcow2_create2(filename
, sectors
, backing_file
, backing_fmt
, flags
,
1661 cluster_size
, prealloc
, options
, version
, &local_err
);
1662 if (error_is_set(&local_err
)) {
1663 error_propagate(errp
, local_err
);
1668 static int qcow2_make_empty(BlockDriverState
*bs
)
1671 /* XXX: not correct */
1672 BDRVQcowState
*s
= bs
->opaque
;
1673 uint32_t l1_length
= s
->l1_size
* sizeof(uint64_t);
1676 memset(s
->l1_table
, 0, l1_length
);
1677 if (bdrv_pwrite(bs
->file
, s
->l1_table_offset
, s
->l1_table
, l1_length
) < 0)
1679 ret
= bdrv_truncate(bs
->file
, s
->l1_table_offset
+ l1_length
);
1688 static coroutine_fn
int qcow2_co_write_zeroes(BlockDriverState
*bs
,
1689 int64_t sector_num
, int nb_sectors
)
1692 BDRVQcowState
*s
= bs
->opaque
;
1694 /* Emulate misaligned zero writes */
1695 if (sector_num
% s
->cluster_sectors
|| nb_sectors
% s
->cluster_sectors
) {
1699 /* Whatever is left can use real zero clusters */
1700 qemu_co_mutex_lock(&s
->lock
);
1701 ret
= qcow2_zero_clusters(bs
, sector_num
<< BDRV_SECTOR_BITS
,
1703 qemu_co_mutex_unlock(&s
->lock
);
1708 static coroutine_fn
int qcow2_co_discard(BlockDriverState
*bs
,
1709 int64_t sector_num
, int nb_sectors
)
1712 BDRVQcowState
*s
= bs
->opaque
;
1714 qemu_co_mutex_lock(&s
->lock
);
1715 ret
= qcow2_discard_clusters(bs
, sector_num
<< BDRV_SECTOR_BITS
,
1716 nb_sectors
, QCOW2_DISCARD_REQUEST
);
1717 qemu_co_mutex_unlock(&s
->lock
);
1721 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
)
1723 BDRVQcowState
*s
= bs
->opaque
;
1724 int64_t new_l1_size
;
1728 error_report("The new size must be a multiple of 512");
1732 /* cannot proceed if image has snapshots */
1733 if (s
->nb_snapshots
) {
1734 error_report("Can't resize an image which has snapshots");
1738 /* shrinking is currently not supported */
1739 if (offset
< bs
->total_sectors
* 512) {
1740 error_report("qcow2 doesn't support shrinking images yet");
1744 new_l1_size
= size_to_l1(s
, offset
);
1745 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
1750 /* write updated header.size */
1751 offset
= cpu_to_be64(offset
);
1752 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
1753 &offset
, sizeof(uint64_t));
1758 s
->l1_vm_state_index
= new_l1_size
;
1762 /* XXX: put compressed sectors first, then all the cluster aligned
1763 tables to avoid losing bytes in alignment */
1764 static int qcow2_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
1765 const uint8_t *buf
, int nb_sectors
)
1767 BDRVQcowState
*s
= bs
->opaque
;
1771 uint64_t cluster_offset
;
1773 if (nb_sectors
== 0) {
1774 /* align end of file to a sector boundary to ease reading with
1775 sector based I/Os */
1776 cluster_offset
= bdrv_getlength(bs
->file
);
1777 cluster_offset
= (cluster_offset
+ 511) & ~511;
1778 bdrv_truncate(bs
->file
, cluster_offset
);
1782 if (nb_sectors
!= s
->cluster_sectors
) {
1785 /* Zero-pad last write if image size is not cluster aligned */
1786 if (sector_num
+ nb_sectors
== bs
->total_sectors
&&
1787 nb_sectors
< s
->cluster_sectors
) {
1788 uint8_t *pad_buf
= qemu_blockalign(bs
, s
->cluster_size
);
1789 memset(pad_buf
, 0, s
->cluster_size
);
1790 memcpy(pad_buf
, buf
, nb_sectors
* BDRV_SECTOR_SIZE
);
1791 ret
= qcow2_write_compressed(bs
, sector_num
,
1792 pad_buf
, s
->cluster_sectors
);
1793 qemu_vfree(pad_buf
);
1798 out_buf
= g_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
1800 /* best compression, small window, no zlib header */
1801 memset(&strm
, 0, sizeof(strm
));
1802 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
1804 9, Z_DEFAULT_STRATEGY
);
1810 strm
.avail_in
= s
->cluster_size
;
1811 strm
.next_in
= (uint8_t *)buf
;
1812 strm
.avail_out
= s
->cluster_size
;
1813 strm
.next_out
= out_buf
;
1815 ret
= deflate(&strm
, Z_FINISH
);
1816 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
1821 out_len
= strm
.next_out
- out_buf
;
1825 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
1826 /* could not compress: write normal cluster */
1827 ret
= bdrv_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
1832 cluster_offset
= qcow2_alloc_compressed_cluster_offset(bs
,
1833 sector_num
<< 9, out_len
);
1834 if (!cluster_offset
) {
1838 cluster_offset
&= s
->cluster_offset_mask
;
1840 ret
= qcow2_pre_write_overlap_check(bs
, 0, cluster_offset
, out_len
);
1845 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
1846 ret
= bdrv_pwrite(bs
->file
, cluster_offset
, out_buf
, out_len
);
1858 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
1860 BDRVQcowState
*s
= bs
->opaque
;
1863 qemu_co_mutex_lock(&s
->lock
);
1864 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1866 qemu_co_mutex_unlock(&s
->lock
);
1870 if (qcow2_need_accurate_refcounts(s
)) {
1871 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1873 qemu_co_mutex_unlock(&s
->lock
);
1877 qemu_co_mutex_unlock(&s
->lock
);
1882 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1884 BDRVQcowState
*s
= bs
->opaque
;
1885 bdi
->cluster_size
= s
->cluster_size
;
1886 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
1890 static ImageInfoSpecific
*qcow2_get_specific_info(BlockDriverState
*bs
)
1892 BDRVQcowState
*s
= bs
->opaque
;
1893 ImageInfoSpecific
*spec_info
= g_new(ImageInfoSpecific
, 1);
1895 *spec_info
= (ImageInfoSpecific
){
1896 .kind
= IMAGE_INFO_SPECIFIC_KIND_QCOW2
,
1898 .qcow2
= g_new(ImageInfoSpecificQCow2
, 1),
1901 if (s
->qcow_version
== 2) {
1902 *spec_info
->qcow2
= (ImageInfoSpecificQCow2
){
1903 .compat
= g_strdup("0.10"),
1905 } else if (s
->qcow_version
== 3) {
1906 *spec_info
->qcow2
= (ImageInfoSpecificQCow2
){
1907 .compat
= g_strdup("1.1"),
1908 .lazy_refcounts
= s
->compatible_features
&
1909 QCOW2_COMPAT_LAZY_REFCOUNTS
,
1910 .has_lazy_refcounts
= true,
1918 static void dump_refcounts(BlockDriverState
*bs
)
1920 BDRVQcowState
*s
= bs
->opaque
;
1921 int64_t nb_clusters
, k
, k1
, size
;
1924 size
= bdrv_getlength(bs
->file
);
1925 nb_clusters
= size_to_clusters(s
, size
);
1926 for(k
= 0; k
< nb_clusters
;) {
1928 refcount
= get_refcount(bs
, k
);
1930 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
1932 printf("%" PRId64
": refcount=%d nb=%" PRId64
"\n", k
, refcount
,
1938 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
1941 BDRVQcowState
*s
= bs
->opaque
;
1942 int64_t total_sectors
= bs
->total_sectors
;
1943 int growable
= bs
->growable
;
1944 bool zero_beyond_eof
= bs
->zero_beyond_eof
;
1947 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
1949 bs
->zero_beyond_eof
= false;
1950 ret
= bdrv_pwritev(bs
, qcow2_vm_state_offset(s
) + pos
, qiov
);
1951 bs
->growable
= growable
;
1952 bs
->zero_beyond_eof
= zero_beyond_eof
;
1954 /* bdrv_co_do_writev will have increased the total_sectors value to include
1955 * the VM state - the VM state is however not an actual part of the block
1956 * device, therefore, we need to restore the old value. */
1957 bs
->total_sectors
= total_sectors
;
1962 static int qcow2_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
1963 int64_t pos
, int size
)
1965 BDRVQcowState
*s
= bs
->opaque
;
1966 int growable
= bs
->growable
;
1967 bool zero_beyond_eof
= bs
->zero_beyond_eof
;
1970 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
1972 bs
->zero_beyond_eof
= false;
1973 ret
= bdrv_pread(bs
, qcow2_vm_state_offset(s
) + pos
, buf
, size
);
1974 bs
->growable
= growable
;
1975 bs
->zero_beyond_eof
= zero_beyond_eof
;
1981 * Downgrades an image's version. To achieve this, any incompatible features
1982 * have to be removed.
1984 static int qcow2_downgrade(BlockDriverState
*bs
, int target_version
)
1986 BDRVQcowState
*s
= bs
->opaque
;
1987 int current_version
= s
->qcow_version
;
1990 if (target_version
== current_version
) {
1992 } else if (target_version
> current_version
) {
1994 } else if (target_version
!= 2) {
1998 if (s
->refcount_order
!= 4) {
1999 /* we would have to convert the image to a refcount_order == 4 image
2000 * here; however, since qemu (at the time of writing this) does not
2001 * support anything different than 4 anyway, there is no point in doing
2002 * so right now; however, we should error out (if qemu supports this in
2003 * the future and this code has not been adapted) */
2004 error_report("qcow2_downgrade: Image refcount orders other than 4 are "
2005 "currently not supported.");
2009 /* clear incompatible features */
2010 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
2011 ret
= qcow2_mark_clean(bs
);
2017 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
2018 * the first place; if that happens nonetheless, returning -ENOTSUP is the
2019 * best thing to do anyway */
2021 if (s
->incompatible_features
) {
2025 /* since we can ignore compatible features, we can set them to 0 as well */
2026 s
->compatible_features
= 0;
2027 /* if lazy refcounts have been used, they have already been fixed through
2028 * clearing the dirty flag */
2030 /* clearing autoclear features is trivial */
2031 s
->autoclear_features
= 0;
2033 ret
= qcow2_expand_zero_clusters(bs
);
2038 s
->qcow_version
= target_version
;
2039 ret
= qcow2_update_header(bs
);
2041 s
->qcow_version
= current_version
;
2047 static int qcow2_amend_options(BlockDriverState
*bs
,
2048 QEMUOptionParameter
*options
)
2050 BDRVQcowState
*s
= bs
->opaque
;
2051 int old_version
= s
->qcow_version
, new_version
= old_version
;
2052 uint64_t new_size
= 0;
2053 const char *backing_file
= NULL
, *backing_format
= NULL
;
2054 bool lazy_refcounts
= s
->use_lazy_refcounts
;
2058 for (i
= 0; options
[i
].name
; i
++)
2060 if (!options
[i
].assigned
) {
2061 /* only change explicitly defined options */
2065 if (!strcmp(options
[i
].name
, "compat")) {
2066 if (!options
[i
].value
.s
) {
2067 /* preserve default */
2068 } else if (!strcmp(options
[i
].value
.s
, "0.10")) {
2070 } else if (!strcmp(options
[i
].value
.s
, "1.1")) {
2073 fprintf(stderr
, "Unknown compatibility level %s.\n",
2074 options
[i
].value
.s
);
2077 } else if (!strcmp(options
[i
].name
, "preallocation")) {
2078 fprintf(stderr
, "Cannot change preallocation mode.\n");
2080 } else if (!strcmp(options
[i
].name
, "size")) {
2081 new_size
= options
[i
].value
.n
;
2082 } else if (!strcmp(options
[i
].name
, "backing_file")) {
2083 backing_file
= options
[i
].value
.s
;
2084 } else if (!strcmp(options
[i
].name
, "backing_fmt")) {
2085 backing_format
= options
[i
].value
.s
;
2086 } else if (!strcmp(options
[i
].name
, "encryption")) {
2087 if ((options
[i
].value
.n
!= !!s
->crypt_method
)) {
2088 fprintf(stderr
, "Changing the encryption flag is not "
2092 } else if (!strcmp(options
[i
].name
, "cluster_size")) {
2093 if (options
[i
].value
.n
!= s
->cluster_size
) {
2094 fprintf(stderr
, "Changing the cluster size is not "
2098 } else if (!strcmp(options
[i
].name
, "lazy_refcounts")) {
2099 lazy_refcounts
= options
[i
].value
.n
;
2101 /* if this assertion fails, this probably means a new option was
2102 * added without having it covered here */
2107 if (new_version
!= old_version
) {
2108 if (new_version
> old_version
) {
2110 s
->qcow_version
= new_version
;
2111 ret
= qcow2_update_header(bs
);
2113 s
->qcow_version
= old_version
;
2117 ret
= qcow2_downgrade(bs
, new_version
);
2124 if (backing_file
|| backing_format
) {
2125 ret
= qcow2_change_backing_file(bs
, backing_file
?: bs
->backing_file
,
2126 backing_format
?: bs
->backing_format
);
2132 if (s
->use_lazy_refcounts
!= lazy_refcounts
) {
2133 if (lazy_refcounts
) {
2134 if (s
->qcow_version
< 3) {
2135 fprintf(stderr
, "Lazy refcounts only supported with compatibility "
2136 "level 1.1 and above (use compat=1.1 or greater)\n");
2139 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
2140 ret
= qcow2_update_header(bs
);
2142 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
2145 s
->use_lazy_refcounts
= true;
2147 /* make image clean first */
2148 ret
= qcow2_mark_clean(bs
);
2152 /* now disallow lazy refcounts */
2153 s
->compatible_features
&= ~QCOW2_COMPAT_LAZY_REFCOUNTS
;
2154 ret
= qcow2_update_header(bs
);
2156 s
->compatible_features
|= QCOW2_COMPAT_LAZY_REFCOUNTS
;
2159 s
->use_lazy_refcounts
= false;
2164 ret
= bdrv_truncate(bs
, new_size
);
2173 static QEMUOptionParameter qcow2_create_options
[] = {
2175 .name
= BLOCK_OPT_SIZE
,
2177 .help
= "Virtual disk size"
2180 .name
= BLOCK_OPT_COMPAT_LEVEL
,
2182 .help
= "Compatibility level (0.10 or 1.1)"
2185 .name
= BLOCK_OPT_BACKING_FILE
,
2187 .help
= "File name of a base image"
2190 .name
= BLOCK_OPT_BACKING_FMT
,
2192 .help
= "Image format of the base image"
2195 .name
= BLOCK_OPT_ENCRYPT
,
2197 .help
= "Encrypt the image"
2200 .name
= BLOCK_OPT_CLUSTER_SIZE
,
2202 .help
= "qcow2 cluster size",
2203 .value
= { .n
= DEFAULT_CLUSTER_SIZE
},
2206 .name
= BLOCK_OPT_PREALLOC
,
2208 .help
= "Preallocation mode (allowed values: off, metadata)"
2211 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
2213 .help
= "Postpone refcount updates",
2218 static BlockDriver bdrv_qcow2
= {
2219 .format_name
= "qcow2",
2220 .instance_size
= sizeof(BDRVQcowState
),
2221 .bdrv_probe
= qcow2_probe
,
2222 .bdrv_open
= qcow2_open
,
2223 .bdrv_close
= qcow2_close
,
2224 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
2225 .bdrv_create
= qcow2_create
,
2226 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
2227 .bdrv_co_get_block_status
= qcow2_co_get_block_status
,
2228 .bdrv_set_key
= qcow2_set_key
,
2229 .bdrv_make_empty
= qcow2_make_empty
,
2231 .bdrv_co_readv
= qcow2_co_readv
,
2232 .bdrv_co_writev
= qcow2_co_writev
,
2233 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
2235 .bdrv_co_write_zeroes
= qcow2_co_write_zeroes
,
2236 .bdrv_co_discard
= qcow2_co_discard
,
2237 .bdrv_truncate
= qcow2_truncate
,
2238 .bdrv_write_compressed
= qcow2_write_compressed
,
2240 .bdrv_snapshot_create
= qcow2_snapshot_create
,
2241 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
2242 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
2243 .bdrv_snapshot_list
= qcow2_snapshot_list
,
2244 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
2245 .bdrv_get_info
= qcow2_get_info
,
2246 .bdrv_get_specific_info
= qcow2_get_specific_info
,
2248 .bdrv_save_vmstate
= qcow2_save_vmstate
,
2249 .bdrv_load_vmstate
= qcow2_load_vmstate
,
2251 .bdrv_change_backing_file
= qcow2_change_backing_file
,
2253 .bdrv_invalidate_cache
= qcow2_invalidate_cache
,
2255 .create_options
= qcow2_create_options
,
2256 .bdrv_check
= qcow2_check
,
2257 .bdrv_amend_options
= qcow2_amend_options
,
2260 static void bdrv_qcow2_init(void)
2262 bdrv_register(&bdrv_qcow2
);
2265 block_init(bdrv_qcow2_init
);