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.
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
)
84 BDRVQcowState
*s
= bs
->opaque
;
90 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset
, end_offset
);
92 offset
= start_offset
;
93 while (offset
< end_offset
) {
97 if (offset
> s
->cluster_size
)
98 printf("qcow2_read_extension: suspicious offset %lu\n", offset
);
100 printf("attempting to read extended header in offset %lu\n", offset
);
103 if (bdrv_pread(bs
->file
, offset
, &ext
, sizeof(ext
)) != sizeof(ext
)) {
104 fprintf(stderr
, "qcow2_read_extension: ERROR: "
105 "pread fail from offset %" PRIu64
"\n",
109 be32_to_cpus(&ext
.magic
);
110 be32_to_cpus(&ext
.len
);
111 offset
+= sizeof(ext
);
113 printf("ext.magic = 0x%x\n", ext
.magic
);
115 if (ext
.len
> end_offset
- offset
) {
116 error_report("Header extension too large");
121 case QCOW2_EXT_MAGIC_END
:
124 case QCOW2_EXT_MAGIC_BACKING_FORMAT
:
125 if (ext
.len
>= sizeof(bs
->backing_format
)) {
126 fprintf(stderr
, "ERROR: ext_backing_format: len=%u too large"
128 ext
.len
, sizeof(bs
->backing_format
));
131 if (bdrv_pread(bs
->file
, offset
, bs
->backing_format
,
134 bs
->backing_format
[ext
.len
] = '\0';
136 printf("Qcow2: Got format extension %s\n", bs
->backing_format
);
140 case QCOW2_EXT_MAGIC_FEATURE_TABLE
:
141 if (p_feature_table
!= NULL
) {
142 void* feature_table
= g_malloc0(ext
.len
+ 2 * sizeof(Qcow2Feature
));
143 ret
= bdrv_pread(bs
->file
, offset
, feature_table
, ext
.len
);
148 *p_feature_table
= feature_table
;
153 /* unknown magic - save it in case we need to rewrite the header */
155 Qcow2UnknownHeaderExtension
*uext
;
157 uext
= g_malloc0(sizeof(*uext
) + ext
.len
);
158 uext
->magic
= ext
.magic
;
160 QLIST_INSERT_HEAD(&s
->unknown_header_ext
, uext
, next
);
162 ret
= bdrv_pread(bs
->file
, offset
, uext
->data
, uext
->len
);
170 offset
+= ((ext
.len
+ 7) & ~7);
176 static void cleanup_unknown_header_ext(BlockDriverState
*bs
)
178 BDRVQcowState
*s
= bs
->opaque
;
179 Qcow2UnknownHeaderExtension
*uext
, *next
;
181 QLIST_FOREACH_SAFE(uext
, &s
->unknown_header_ext
, next
, next
) {
182 QLIST_REMOVE(uext
, next
);
187 static void GCC_FMT_ATTR(2, 3) report_unsupported(BlockDriverState
*bs
,
188 const char *fmt
, ...)
194 vsnprintf(msg
, sizeof(msg
), fmt
, ap
);
197 qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE
,
198 bs
->device_name
, "qcow2", msg
);
201 static void report_unsupported_feature(BlockDriverState
*bs
,
202 Qcow2Feature
*table
, uint64_t mask
)
204 while (table
&& table
->name
[0] != '\0') {
205 if (table
->type
== QCOW2_FEAT_TYPE_INCOMPATIBLE
) {
206 if (mask
& (1 << table
->bit
)) {
207 report_unsupported(bs
, "%.46s",table
->name
);
208 mask
&= ~(1 << table
->bit
);
215 report_unsupported(bs
, "Unknown incompatible feature: %" PRIx64
, mask
);
220 * Sets the dirty bit and flushes afterwards if necessary.
222 * The incompatible_features bit is only set if the image file header was
223 * updated successfully. Therefore it is not required to check the return
224 * value of this function.
226 int qcow2_mark_dirty(BlockDriverState
*bs
)
228 BDRVQcowState
*s
= bs
->opaque
;
232 assert(s
->qcow_version
>= 3);
234 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
235 return 0; /* already dirty */
238 val
= cpu_to_be64(s
->incompatible_features
| QCOW2_INCOMPAT_DIRTY
);
239 ret
= bdrv_pwrite(bs
->file
, offsetof(QCowHeader
, incompatible_features
),
244 ret
= bdrv_flush(bs
->file
);
249 /* Only treat image as dirty if the header was updated successfully */
250 s
->incompatible_features
|= QCOW2_INCOMPAT_DIRTY
;
255 * Clears the dirty bit and flushes before if necessary. Only call this
256 * function when there are no pending requests, it does not guard against
257 * concurrent requests dirtying the image.
259 static int qcow2_mark_clean(BlockDriverState
*bs
)
261 BDRVQcowState
*s
= bs
->opaque
;
263 if (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
) {
264 int ret
= bdrv_flush(bs
);
269 s
->incompatible_features
&= ~QCOW2_INCOMPAT_DIRTY
;
270 return qcow2_update_header(bs
);
276 * Marks the image as corrupt.
278 int qcow2_mark_corrupt(BlockDriverState
*bs
)
280 BDRVQcowState
*s
= bs
->opaque
;
282 s
->incompatible_features
|= QCOW2_INCOMPAT_CORRUPT
;
283 return qcow2_update_header(bs
);
287 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
288 * before if necessary.
290 int qcow2_mark_consistent(BlockDriverState
*bs
)
292 BDRVQcowState
*s
= bs
->opaque
;
294 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
295 int ret
= bdrv_flush(bs
);
300 s
->incompatible_features
&= ~QCOW2_INCOMPAT_CORRUPT
;
301 return qcow2_update_header(bs
);
306 static int qcow2_check(BlockDriverState
*bs
, BdrvCheckResult
*result
,
309 int ret
= qcow2_check_refcounts(bs
, result
, fix
);
314 if (fix
&& result
->check_errors
== 0 && result
->corruptions
== 0) {
315 ret
= qcow2_mark_clean(bs
);
319 return qcow2_mark_consistent(bs
);
324 static QemuOptsList qcow2_runtime_opts
= {
326 .head
= QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts
.head
),
329 .name
= QCOW2_OPT_LAZY_REFCOUNTS
,
330 .type
= QEMU_OPT_BOOL
,
331 .help
= "Postpone refcount updates",
334 .name
= QCOW2_OPT_DISCARD_REQUEST
,
335 .type
= QEMU_OPT_BOOL
,
336 .help
= "Pass guest discard requests to the layer below",
339 .name
= QCOW2_OPT_DISCARD_SNAPSHOT
,
340 .type
= QEMU_OPT_BOOL
,
341 .help
= "Generate discard requests when snapshot related space "
345 .name
= QCOW2_OPT_DISCARD_OTHER
,
346 .type
= QEMU_OPT_BOOL
,
347 .help
= "Generate discard requests when other clusters are freed",
349 { /* end of list */ }
353 static int qcow2_open(BlockDriverState
*bs
, QDict
*options
, int flags
)
355 BDRVQcowState
*s
= bs
->opaque
;
359 Error
*local_err
= NULL
;
361 uint64_t l1_vm_state_index
;
363 ret
= bdrv_pread(bs
->file
, 0, &header
, sizeof(header
));
367 be32_to_cpus(&header
.magic
);
368 be32_to_cpus(&header
.version
);
369 be64_to_cpus(&header
.backing_file_offset
);
370 be32_to_cpus(&header
.backing_file_size
);
371 be64_to_cpus(&header
.size
);
372 be32_to_cpus(&header
.cluster_bits
);
373 be32_to_cpus(&header
.crypt_method
);
374 be64_to_cpus(&header
.l1_table_offset
);
375 be32_to_cpus(&header
.l1_size
);
376 be64_to_cpus(&header
.refcount_table_offset
);
377 be32_to_cpus(&header
.refcount_table_clusters
);
378 be64_to_cpus(&header
.snapshots_offset
);
379 be32_to_cpus(&header
.nb_snapshots
);
381 if (header
.magic
!= QCOW_MAGIC
) {
385 if (header
.version
< 2 || header
.version
> 3) {
386 report_unsupported(bs
, "QCOW version %d", header
.version
);
391 s
->qcow_version
= header
.version
;
393 /* Initialise version 3 header fields */
394 if (header
.version
== 2) {
395 header
.incompatible_features
= 0;
396 header
.compatible_features
= 0;
397 header
.autoclear_features
= 0;
398 header
.refcount_order
= 4;
399 header
.header_length
= 72;
401 be64_to_cpus(&header
.incompatible_features
);
402 be64_to_cpus(&header
.compatible_features
);
403 be64_to_cpus(&header
.autoclear_features
);
404 be32_to_cpus(&header
.refcount_order
);
405 be32_to_cpus(&header
.header_length
);
408 if (header
.header_length
> sizeof(header
)) {
409 s
->unknown_header_fields_size
= header
.header_length
- sizeof(header
);
410 s
->unknown_header_fields
= g_malloc(s
->unknown_header_fields_size
);
411 ret
= bdrv_pread(bs
->file
, sizeof(header
), s
->unknown_header_fields
,
412 s
->unknown_header_fields_size
);
418 if (header
.backing_file_offset
) {
419 ext_end
= header
.backing_file_offset
;
421 ext_end
= 1 << header
.cluster_bits
;
424 /* Handle feature bits */
425 s
->incompatible_features
= header
.incompatible_features
;
426 s
->compatible_features
= header
.compatible_features
;
427 s
->autoclear_features
= header
.autoclear_features
;
429 if (s
->incompatible_features
& ~QCOW2_INCOMPAT_MASK
) {
430 void *feature_table
= NULL
;
431 qcow2_read_extensions(bs
, header
.header_length
, ext_end
,
433 report_unsupported_feature(bs
, feature_table
,
434 s
->incompatible_features
&
435 ~QCOW2_INCOMPAT_MASK
);
440 if (s
->incompatible_features
& QCOW2_INCOMPAT_CORRUPT
) {
441 /* Corrupt images may not be written to unless they are being repaired
443 if ((flags
& BDRV_O_RDWR
) && !(flags
& BDRV_O_CHECK
)) {
444 error_report("qcow2: Image is corrupt; cannot be opened "
451 /* Check support for various header values */
452 if (header
.refcount_order
!= 4) {
453 report_unsupported(bs
, "%d bit reference counts",
454 1 << header
.refcount_order
);
458 s
->refcount_order
= header
.refcount_order
;
460 if (header
.cluster_bits
< MIN_CLUSTER_BITS
||
461 header
.cluster_bits
> MAX_CLUSTER_BITS
) {
465 if (header
.crypt_method
> QCOW_CRYPT_AES
) {
469 s
->crypt_method_header
= header
.crypt_method
;
470 if (s
->crypt_method_header
) {
473 s
->cluster_bits
= header
.cluster_bits
;
474 s
->cluster_size
= 1 << s
->cluster_bits
;
475 s
->cluster_sectors
= 1 << (s
->cluster_bits
- 9);
476 s
->l2_bits
= s
->cluster_bits
- 3; /* L2 is always one cluster */
477 s
->l2_size
= 1 << s
->l2_bits
;
478 bs
->total_sectors
= header
.size
/ 512;
479 s
->csize_shift
= (62 - (s
->cluster_bits
- 8));
480 s
->csize_mask
= (1 << (s
->cluster_bits
- 8)) - 1;
481 s
->cluster_offset_mask
= (1LL << s
->csize_shift
) - 1;
482 s
->refcount_table_offset
= header
.refcount_table_offset
;
483 s
->refcount_table_size
=
484 header
.refcount_table_clusters
<< (s
->cluster_bits
- 3);
486 s
->snapshots_offset
= header
.snapshots_offset
;
487 s
->nb_snapshots
= header
.nb_snapshots
;
489 /* read the level 1 table */
490 s
->l1_size
= header
.l1_size
;
492 l1_vm_state_index
= size_to_l1(s
, header
.size
);
493 if (l1_vm_state_index
> INT_MAX
) {
497 s
->l1_vm_state_index
= l1_vm_state_index
;
499 /* the L1 table must contain at least enough entries to put
501 if (s
->l1_size
< s
->l1_vm_state_index
) {
505 s
->l1_table_offset
= header
.l1_table_offset
;
506 if (s
->l1_size
> 0) {
507 s
->l1_table
= g_malloc0(
508 align_offset(s
->l1_size
* sizeof(uint64_t), 512));
509 ret
= bdrv_pread(bs
->file
, s
->l1_table_offset
, s
->l1_table
,
510 s
->l1_size
* sizeof(uint64_t));
514 for(i
= 0;i
< s
->l1_size
; i
++) {
515 be64_to_cpus(&s
->l1_table
[i
]);
519 /* alloc L2 table/refcount block cache */
520 s
->l2_table_cache
= qcow2_cache_create(bs
, L2_CACHE_SIZE
);
521 s
->refcount_block_cache
= qcow2_cache_create(bs
, REFCOUNT_CACHE_SIZE
);
523 s
->cluster_cache
= g_malloc(s
->cluster_size
);
524 /* one more sector for decompressed data alignment */
525 s
->cluster_data
= qemu_blockalign(bs
, QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
527 s
->cluster_cache_offset
= -1;
530 ret
= qcow2_refcount_init(bs
);
535 QLIST_INIT(&s
->cluster_allocs
);
536 QTAILQ_INIT(&s
->discards
);
538 /* read qcow2 extensions */
539 if (qcow2_read_extensions(bs
, header
.header_length
, ext_end
, NULL
)) {
544 /* read the backing file name */
545 if (header
.backing_file_offset
!= 0) {
546 len
= header
.backing_file_size
;
550 ret
= bdrv_pread(bs
->file
, header
.backing_file_offset
,
551 bs
->backing_file
, len
);
555 bs
->backing_file
[len
] = '\0';
558 ret
= qcow2_read_snapshots(bs
);
563 /* Clear unknown autoclear feature bits */
564 if (!bs
->read_only
&& s
->autoclear_features
!= 0) {
565 s
->autoclear_features
= 0;
566 ret
= qcow2_update_header(bs
);
572 /* Initialise locks */
573 qemu_co_mutex_init(&s
->lock
);
575 /* Repair image if dirty */
576 if (!(flags
& BDRV_O_CHECK
) && !bs
->read_only
&&
577 (s
->incompatible_features
& QCOW2_INCOMPAT_DIRTY
)) {
578 BdrvCheckResult result
= {0};
580 ret
= qcow2_check(bs
, &result
, BDRV_FIX_ERRORS
);
586 /* Enable lazy_refcounts according to image and command line options */
587 opts
= qemu_opts_create_nofail(&qcow2_runtime_opts
);
588 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
589 if (error_is_set(&local_err
)) {
590 qerror_report_err(local_err
);
591 error_free(local_err
);
596 s
->use_lazy_refcounts
= qemu_opt_get_bool(opts
, QCOW2_OPT_LAZY_REFCOUNTS
,
597 (s
->compatible_features
& QCOW2_COMPAT_LAZY_REFCOUNTS
));
599 s
->discard_passthrough
[QCOW2_DISCARD_NEVER
] = false;
600 s
->discard_passthrough
[QCOW2_DISCARD_ALWAYS
] = true;
601 s
->discard_passthrough
[QCOW2_DISCARD_REQUEST
] =
602 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_REQUEST
,
603 flags
& BDRV_O_UNMAP
);
604 s
->discard_passthrough
[QCOW2_DISCARD_SNAPSHOT
] =
605 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_SNAPSHOT
, true);
606 s
->discard_passthrough
[QCOW2_DISCARD_OTHER
] =
607 qemu_opt_get_bool(opts
, QCOW2_OPT_DISCARD_OTHER
, false);
611 if (s
->use_lazy_refcounts
&& s
->qcow_version
< 3) {
612 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Lazy refcounts require "
613 "a qcow2 image with at least qemu 1.1 compatibility level");
620 BdrvCheckResult result
= {0};
621 qcow2_check_refcounts(bs
, &result
, 0);
627 g_free(s
->unknown_header_fields
);
628 cleanup_unknown_header_ext(bs
);
629 qcow2_free_snapshots(bs
);
630 qcow2_refcount_close(bs
);
632 /* else pre-write overlap checks in cache_destroy may crash */
634 if (s
->l2_table_cache
) {
635 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
637 g_free(s
->cluster_cache
);
638 qemu_vfree(s
->cluster_data
);
642 static int qcow2_set_key(BlockDriverState
*bs
, const char *key
)
644 BDRVQcowState
*s
= bs
->opaque
;
648 memset(keybuf
, 0, 16);
652 /* XXX: we could compress the chars to 7 bits to increase
654 for(i
= 0;i
< len
;i
++) {
657 s
->crypt_method
= s
->crypt_method_header
;
659 if (AES_set_encrypt_key(keybuf
, 128, &s
->aes_encrypt_key
) != 0)
661 if (AES_set_decrypt_key(keybuf
, 128, &s
->aes_decrypt_key
) != 0)
671 AES_encrypt(in
, tmp
, &s
->aes_encrypt_key
);
672 AES_decrypt(tmp
, out
, &s
->aes_decrypt_key
);
673 for(i
= 0; i
< 16; i
++)
674 printf(" %02x", tmp
[i
]);
676 for(i
= 0; i
< 16; i
++)
677 printf(" %02x", out
[i
]);
684 /* We have nothing to do for QCOW2 reopen, stubs just return
686 static int qcow2_reopen_prepare(BDRVReopenState
*state
,
687 BlockReopenQueue
*queue
, Error
**errp
)
692 static int64_t coroutine_fn
qcow2_co_get_block_status(BlockDriverState
*bs
,
693 int64_t sector_num
, int nb_sectors
, int *pnum
)
695 BDRVQcowState
*s
= bs
->opaque
;
696 uint64_t cluster_offset
;
697 int index_in_cluster
, ret
;
701 qemu_co_mutex_lock(&s
->lock
);
702 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9, pnum
, &cluster_offset
);
703 qemu_co_mutex_unlock(&s
->lock
);
708 if (cluster_offset
!= 0 && ret
!= QCOW2_CLUSTER_COMPRESSED
&&
710 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
711 cluster_offset
|= (index_in_cluster
<< BDRV_SECTOR_BITS
);
712 status
|= BDRV_BLOCK_OFFSET_VALID
| cluster_offset
;
714 if (ret
== QCOW2_CLUSTER_ZERO
) {
715 status
|= BDRV_BLOCK_ZERO
;
716 } else if (ret
!= QCOW2_CLUSTER_UNALLOCATED
) {
717 status
|= BDRV_BLOCK_DATA
;
722 /* handle reading after the end of the backing file */
723 int qcow2_backing_read1(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
724 int64_t sector_num
, int nb_sectors
)
727 if ((sector_num
+ nb_sectors
) <= bs
->total_sectors
)
729 if (sector_num
>= bs
->total_sectors
)
732 n1
= bs
->total_sectors
- sector_num
;
734 qemu_iovec_memset(qiov
, 512 * n1
, 0, 512 * (nb_sectors
- n1
));
739 static coroutine_fn
int qcow2_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
740 int remaining_sectors
, QEMUIOVector
*qiov
)
742 BDRVQcowState
*s
= bs
->opaque
;
743 int index_in_cluster
, n1
;
745 int cur_nr_sectors
; /* number of sectors in current iteration */
746 uint64_t cluster_offset
= 0;
747 uint64_t bytes_done
= 0;
748 QEMUIOVector hd_qiov
;
749 uint8_t *cluster_data
= NULL
;
751 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
753 qemu_co_mutex_lock(&s
->lock
);
755 while (remaining_sectors
!= 0) {
757 /* prepare next request */
758 cur_nr_sectors
= remaining_sectors
;
759 if (s
->crypt_method
) {
760 cur_nr_sectors
= MIN(cur_nr_sectors
,
761 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
);
764 ret
= qcow2_get_cluster_offset(bs
, sector_num
<< 9,
765 &cur_nr_sectors
, &cluster_offset
);
770 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
772 qemu_iovec_reset(&hd_qiov
);
773 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
,
774 cur_nr_sectors
* 512);
777 case QCOW2_CLUSTER_UNALLOCATED
:
779 if (bs
->backing_hd
) {
780 /* read from the base image */
781 n1
= qcow2_backing_read1(bs
->backing_hd
, &hd_qiov
,
782 sector_num
, cur_nr_sectors
);
784 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_BACKING_AIO
);
785 qemu_co_mutex_unlock(&s
->lock
);
786 ret
= bdrv_co_readv(bs
->backing_hd
, sector_num
,
788 qemu_co_mutex_lock(&s
->lock
);
794 /* Note: in this case, no need to wait */
795 qemu_iovec_memset(&hd_qiov
, 0, 0, 512 * cur_nr_sectors
);
799 case QCOW2_CLUSTER_ZERO
:
800 qemu_iovec_memset(&hd_qiov
, 0, 0, 512 * cur_nr_sectors
);
803 case QCOW2_CLUSTER_COMPRESSED
:
804 /* add AIO support for compressed blocks ? */
805 ret
= qcow2_decompress_cluster(bs
, cluster_offset
);
810 qemu_iovec_from_buf(&hd_qiov
, 0,
811 s
->cluster_cache
+ index_in_cluster
* 512,
812 512 * cur_nr_sectors
);
815 case QCOW2_CLUSTER_NORMAL
:
816 if ((cluster_offset
& 511) != 0) {
821 if (s
->crypt_method
) {
823 * For encrypted images, read everything into a temporary
824 * contiguous buffer on which the AES functions can work.
828 qemu_blockalign(bs
, QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
831 assert(cur_nr_sectors
<=
832 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
);
833 qemu_iovec_reset(&hd_qiov
);
834 qemu_iovec_add(&hd_qiov
, cluster_data
,
835 512 * cur_nr_sectors
);
838 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_AIO
);
839 qemu_co_mutex_unlock(&s
->lock
);
840 ret
= bdrv_co_readv(bs
->file
,
841 (cluster_offset
>> 9) + index_in_cluster
,
842 cur_nr_sectors
, &hd_qiov
);
843 qemu_co_mutex_lock(&s
->lock
);
847 if (s
->crypt_method
) {
848 qcow2_encrypt_sectors(s
, sector_num
, cluster_data
,
849 cluster_data
, cur_nr_sectors
, 0, &s
->aes_decrypt_key
);
850 qemu_iovec_from_buf(qiov
, bytes_done
,
851 cluster_data
, 512 * cur_nr_sectors
);
856 g_assert_not_reached();
861 remaining_sectors
-= cur_nr_sectors
;
862 sector_num
+= cur_nr_sectors
;
863 bytes_done
+= cur_nr_sectors
* 512;
868 qemu_co_mutex_unlock(&s
->lock
);
870 qemu_iovec_destroy(&hd_qiov
);
871 qemu_vfree(cluster_data
);
876 static coroutine_fn
int qcow2_co_writev(BlockDriverState
*bs
,
878 int remaining_sectors
,
881 BDRVQcowState
*s
= bs
->opaque
;
882 int index_in_cluster
;
885 int cur_nr_sectors
; /* number of sectors in current iteration */
886 uint64_t cluster_offset
;
887 QEMUIOVector hd_qiov
;
888 uint64_t bytes_done
= 0;
889 uint8_t *cluster_data
= NULL
;
890 QCowL2Meta
*l2meta
= NULL
;
892 trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num
,
895 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
897 s
->cluster_cache_offset
= -1; /* disable compressed cache */
899 qemu_co_mutex_lock(&s
->lock
);
901 while (remaining_sectors
!= 0) {
905 trace_qcow2_writev_start_part(qemu_coroutine_self());
906 index_in_cluster
= sector_num
& (s
->cluster_sectors
- 1);
907 n_end
= index_in_cluster
+ remaining_sectors
;
908 if (s
->crypt_method
&&
909 n_end
> QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
) {
910 n_end
= QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_sectors
;
913 ret
= qcow2_alloc_cluster_offset(bs
, sector_num
<< 9,
914 index_in_cluster
, n_end
, &cur_nr_sectors
, &cluster_offset
, &l2meta
);
919 assert((cluster_offset
& 511) == 0);
921 qemu_iovec_reset(&hd_qiov
);
922 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
,
923 cur_nr_sectors
* 512);
925 if (s
->crypt_method
) {
927 cluster_data
= qemu_blockalign(bs
, QCOW_MAX_CRYPT_CLUSTERS
*
931 assert(hd_qiov
.size
<=
932 QCOW_MAX_CRYPT_CLUSTERS
* s
->cluster_size
);
933 qemu_iovec_to_buf(&hd_qiov
, 0, cluster_data
, hd_qiov
.size
);
935 qcow2_encrypt_sectors(s
, sector_num
, cluster_data
,
936 cluster_data
, cur_nr_sectors
, 1, &s
->aes_encrypt_key
);
938 qemu_iovec_reset(&hd_qiov
);
939 qemu_iovec_add(&hd_qiov
, cluster_data
,
940 cur_nr_sectors
* 512);
943 ret
= qcow2_pre_write_overlap_check(bs
, QCOW2_OL_DEFAULT
,
944 cluster_offset
+ index_in_cluster
* BDRV_SECTOR_SIZE
,
945 cur_nr_sectors
* BDRV_SECTOR_SIZE
);
950 qemu_co_mutex_unlock(&s
->lock
);
951 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_AIO
);
952 trace_qcow2_writev_data(qemu_coroutine_self(),
953 (cluster_offset
>> 9) + index_in_cluster
);
954 ret
= bdrv_co_writev(bs
->file
,
955 (cluster_offset
>> 9) + index_in_cluster
,
956 cur_nr_sectors
, &hd_qiov
);
957 qemu_co_mutex_lock(&s
->lock
);
962 while (l2meta
!= NULL
) {
965 ret
= qcow2_alloc_cluster_link_l2(bs
, l2meta
);
970 /* Take the request off the list of running requests */
971 if (l2meta
->nb_clusters
!= 0) {
972 QLIST_REMOVE(l2meta
, next_in_flight
);
975 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
982 remaining_sectors
-= cur_nr_sectors
;
983 sector_num
+= cur_nr_sectors
;
984 bytes_done
+= cur_nr_sectors
* 512;
985 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors
);
990 qemu_co_mutex_unlock(&s
->lock
);
992 while (l2meta
!= NULL
) {
995 if (l2meta
->nb_clusters
!= 0) {
996 QLIST_REMOVE(l2meta
, next_in_flight
);
998 qemu_co_queue_restart_all(&l2meta
->dependent_requests
);
1000 next
= l2meta
->next
;
1005 qemu_iovec_destroy(&hd_qiov
);
1006 qemu_vfree(cluster_data
);
1007 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret
);
1012 static void qcow2_close(BlockDriverState
*bs
)
1014 BDRVQcowState
*s
= bs
->opaque
;
1015 g_free(s
->l1_table
);
1016 /* else pre-write overlap checks in cache_destroy may crash */
1019 qcow2_cache_flush(bs
, s
->l2_table_cache
);
1020 qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1022 qcow2_mark_clean(bs
);
1024 qcow2_cache_destroy(bs
, s
->l2_table_cache
);
1025 qcow2_cache_destroy(bs
, s
->refcount_block_cache
);
1027 g_free(s
->unknown_header_fields
);
1028 cleanup_unknown_header_ext(bs
);
1030 g_free(s
->cluster_cache
);
1031 qemu_vfree(s
->cluster_data
);
1032 qcow2_refcount_close(bs
);
1033 qcow2_free_snapshots(bs
);
1036 static void qcow2_invalidate_cache(BlockDriverState
*bs
)
1038 BDRVQcowState
*s
= bs
->opaque
;
1039 int flags
= s
->flags
;
1040 AES_KEY aes_encrypt_key
;
1041 AES_KEY aes_decrypt_key
;
1042 uint32_t crypt_method
= 0;
1046 * Backing files are read-only which makes all of their metadata immutable,
1047 * that means we don't have to worry about reopening them here.
1050 if (s
->crypt_method
) {
1051 crypt_method
= s
->crypt_method
;
1052 memcpy(&aes_encrypt_key
, &s
->aes_encrypt_key
, sizeof(aes_encrypt_key
));
1053 memcpy(&aes_decrypt_key
, &s
->aes_decrypt_key
, sizeof(aes_decrypt_key
));
1058 options
= qdict_new();
1059 qdict_put(options
, QCOW2_OPT_LAZY_REFCOUNTS
,
1060 qbool_from_int(s
->use_lazy_refcounts
));
1062 memset(s
, 0, sizeof(BDRVQcowState
));
1063 qcow2_open(bs
, options
, flags
);
1068 s
->crypt_method
= crypt_method
;
1069 memcpy(&s
->aes_encrypt_key
, &aes_encrypt_key
, sizeof(aes_encrypt_key
));
1070 memcpy(&s
->aes_decrypt_key
, &aes_decrypt_key
, sizeof(aes_decrypt_key
));
1074 static size_t header_ext_add(char *buf
, uint32_t magic
, const void *s
,
1075 size_t len
, size_t buflen
)
1077 QCowExtension
*ext_backing_fmt
= (QCowExtension
*) buf
;
1078 size_t ext_len
= sizeof(QCowExtension
) + ((len
+ 7) & ~7);
1080 if (buflen
< ext_len
) {
1084 *ext_backing_fmt
= (QCowExtension
) {
1085 .magic
= cpu_to_be32(magic
),
1086 .len
= cpu_to_be32(len
),
1088 memcpy(buf
+ sizeof(QCowExtension
), s
, len
);
1094 * Updates the qcow2 header, including the variable length parts of it, i.e.
1095 * the backing file name and all extensions. qcow2 was not designed to allow
1096 * such changes, so if we run out of space (we can only use the first cluster)
1097 * this function may fail.
1099 * Returns 0 on success, -errno in error cases.
1101 int qcow2_update_header(BlockDriverState
*bs
)
1103 BDRVQcowState
*s
= bs
->opaque
;
1106 size_t buflen
= s
->cluster_size
;
1108 uint64_t total_size
;
1109 uint32_t refcount_table_clusters
;
1110 size_t header_length
;
1111 Qcow2UnknownHeaderExtension
*uext
;
1113 buf
= qemu_blockalign(bs
, buflen
);
1115 /* Header structure */
1116 header
= (QCowHeader
*) buf
;
1118 if (buflen
< sizeof(*header
)) {
1123 header_length
= sizeof(*header
) + s
->unknown_header_fields_size
;
1124 total_size
= bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1125 refcount_table_clusters
= s
->refcount_table_size
>> (s
->cluster_bits
- 3);
1127 *header
= (QCowHeader
) {
1128 /* Version 2 fields */
1129 .magic
= cpu_to_be32(QCOW_MAGIC
),
1130 .version
= cpu_to_be32(s
->qcow_version
),
1131 .backing_file_offset
= 0,
1132 .backing_file_size
= 0,
1133 .cluster_bits
= cpu_to_be32(s
->cluster_bits
),
1134 .size
= cpu_to_be64(total_size
),
1135 .crypt_method
= cpu_to_be32(s
->crypt_method_header
),
1136 .l1_size
= cpu_to_be32(s
->l1_size
),
1137 .l1_table_offset
= cpu_to_be64(s
->l1_table_offset
),
1138 .refcount_table_offset
= cpu_to_be64(s
->refcount_table_offset
),
1139 .refcount_table_clusters
= cpu_to_be32(refcount_table_clusters
),
1140 .nb_snapshots
= cpu_to_be32(s
->nb_snapshots
),
1141 .snapshots_offset
= cpu_to_be64(s
->snapshots_offset
),
1143 /* Version 3 fields */
1144 .incompatible_features
= cpu_to_be64(s
->incompatible_features
),
1145 .compatible_features
= cpu_to_be64(s
->compatible_features
),
1146 .autoclear_features
= cpu_to_be64(s
->autoclear_features
),
1147 .refcount_order
= cpu_to_be32(s
->refcount_order
),
1148 .header_length
= cpu_to_be32(header_length
),
1151 /* For older versions, write a shorter header */
1152 switch (s
->qcow_version
) {
1154 ret
= offsetof(QCowHeader
, incompatible_features
);
1157 ret
= sizeof(*header
);
1166 memset(buf
, 0, buflen
);
1168 /* Preserve any unknown field in the header */
1169 if (s
->unknown_header_fields_size
) {
1170 if (buflen
< s
->unknown_header_fields_size
) {
1175 memcpy(buf
, s
->unknown_header_fields
, s
->unknown_header_fields_size
);
1176 buf
+= s
->unknown_header_fields_size
;
1177 buflen
-= s
->unknown_header_fields_size
;
1180 /* Backing file format header extension */
1181 if (*bs
->backing_format
) {
1182 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_BACKING_FORMAT
,
1183 bs
->backing_format
, strlen(bs
->backing_format
),
1194 Qcow2Feature features
[] = {
1196 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1197 .bit
= QCOW2_INCOMPAT_DIRTY_BITNR
,
1198 .name
= "dirty bit",
1201 .type
= QCOW2_FEAT_TYPE_INCOMPATIBLE
,
1202 .bit
= QCOW2_INCOMPAT_CORRUPT_BITNR
,
1203 .name
= "corrupt bit",
1206 .type
= QCOW2_FEAT_TYPE_COMPATIBLE
,
1207 .bit
= QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR
,
1208 .name
= "lazy refcounts",
1212 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_FEATURE_TABLE
,
1213 features
, sizeof(features
), buflen
);
1220 /* Keep unknown header extensions */
1221 QLIST_FOREACH(uext
, &s
->unknown_header_ext
, next
) {
1222 ret
= header_ext_add(buf
, uext
->magic
, uext
->data
, uext
->len
, buflen
);
1231 /* End of header extensions */
1232 ret
= header_ext_add(buf
, QCOW2_EXT_MAGIC_END
, NULL
, 0, buflen
);
1240 /* Backing file name */
1241 if (*bs
->backing_file
) {
1242 size_t backing_file_len
= strlen(bs
->backing_file
);
1244 if (buflen
< backing_file_len
) {
1249 /* Using strncpy is ok here, since buf is not NUL-terminated. */
1250 strncpy(buf
, bs
->backing_file
, buflen
);
1252 header
->backing_file_offset
= cpu_to_be64(buf
- ((char*) header
));
1253 header
->backing_file_size
= cpu_to_be32(backing_file_len
);
1256 /* Write the new header */
1257 ret
= bdrv_pwrite(bs
->file
, 0, header
, s
->cluster_size
);
1268 static int qcow2_change_backing_file(BlockDriverState
*bs
,
1269 const char *backing_file
, const char *backing_fmt
)
1271 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1272 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1274 return qcow2_update_header(bs
);
1277 static int preallocate(BlockDriverState
*bs
)
1279 uint64_t nb_sectors
;
1281 uint64_t host_offset
= 0;
1286 nb_sectors
= bdrv_getlength(bs
) >> 9;
1289 while (nb_sectors
) {
1290 num
= MIN(nb_sectors
, INT_MAX
>> 9);
1291 ret
= qcow2_alloc_cluster_offset(bs
, offset
, 0, num
, &num
,
1292 &host_offset
, &meta
);
1297 ret
= qcow2_alloc_cluster_link_l2(bs
, meta
);
1299 qcow2_free_any_clusters(bs
, meta
->alloc_offset
, meta
->nb_clusters
,
1300 QCOW2_DISCARD_NEVER
);
1304 /* There are no dependent requests, but we need to remove our request
1305 * from the list of in-flight requests */
1307 QLIST_REMOVE(meta
, next_in_flight
);
1310 /* TODO Preallocate data if requested */
1317 * It is expected that the image file is large enough to actually contain
1318 * all of the allocated clusters (otherwise we get failing reads after
1319 * EOF). Extend the image to the last allocated sector.
1321 if (host_offset
!= 0) {
1323 memset(buf
, 0, 512);
1324 ret
= bdrv_write(bs
->file
, (host_offset
>> 9) + num
- 1, buf
, 1);
1333 static int qcow2_create2(const char *filename
, int64_t total_size
,
1334 const char *backing_file
, const char *backing_format
,
1335 int flags
, size_t cluster_size
, int prealloc
,
1336 QEMUOptionParameter
*options
, int version
)
1338 /* Calculate cluster_bits */
1340 cluster_bits
= ffs(cluster_size
) - 1;
1341 if (cluster_bits
< MIN_CLUSTER_BITS
|| cluster_bits
> MAX_CLUSTER_BITS
||
1342 (1 << cluster_bits
) != cluster_size
)
1345 "Cluster size must be a power of two between %d and %dk",
1346 1 << MIN_CLUSTER_BITS
, 1 << (MAX_CLUSTER_BITS
- 10));
1351 * Open the image file and write a minimal qcow2 header.
1353 * We keep things simple and start with a zero-sized image. We also
1354 * do without refcount blocks or a L1 table for now. We'll fix the
1355 * inconsistency later.
1357 * We do need a refcount table because growing the refcount table means
1358 * allocating two new refcount blocks - the seconds of which would be at
1359 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
1360 * size for any qcow2 image.
1362 BlockDriverState
* bs
;
1364 uint8_t* refcount_table
;
1367 ret
= bdrv_create_file(filename
, options
);
1372 ret
= bdrv_file_open(&bs
, filename
, NULL
, BDRV_O_RDWR
);
1377 /* Write the header */
1378 memset(&header
, 0, sizeof(header
));
1379 header
.magic
= cpu_to_be32(QCOW_MAGIC
);
1380 header
.version
= cpu_to_be32(version
);
1381 header
.cluster_bits
= cpu_to_be32(cluster_bits
);
1382 header
.size
= cpu_to_be64(0);
1383 header
.l1_table_offset
= cpu_to_be64(0);
1384 header
.l1_size
= cpu_to_be32(0);
1385 header
.refcount_table_offset
= cpu_to_be64(cluster_size
);
1386 header
.refcount_table_clusters
= cpu_to_be32(1);
1387 header
.refcount_order
= cpu_to_be32(3 + REFCOUNT_SHIFT
);
1388 header
.header_length
= cpu_to_be32(sizeof(header
));
1390 if (flags
& BLOCK_FLAG_ENCRYPT
) {
1391 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_AES
);
1393 header
.crypt_method
= cpu_to_be32(QCOW_CRYPT_NONE
);
1396 if (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
) {
1397 header
.compatible_features
|=
1398 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS
);
1401 ret
= bdrv_pwrite(bs
, 0, &header
, sizeof(header
));
1406 /* Write an empty refcount table */
1407 refcount_table
= g_malloc0(cluster_size
);
1408 ret
= bdrv_pwrite(bs
, cluster_size
, refcount_table
, cluster_size
);
1409 g_free(refcount_table
);
1418 * And now open the image and make it consistent first (i.e. increase the
1419 * refcount of the cluster that is occupied by the header and the refcount
1422 BlockDriver
* drv
= bdrv_find_format("qcow2");
1423 assert(drv
!= NULL
);
1424 ret
= bdrv_open(bs
, filename
, NULL
,
1425 BDRV_O_RDWR
| BDRV_O_CACHE_WB
| BDRV_O_NO_FLUSH
, drv
);
1430 ret
= qcow2_alloc_clusters(bs
, 2 * cluster_size
);
1434 } else if (ret
!= 0) {
1435 error_report("Huh, first cluster in empty image is already in use?");
1439 /* Okay, now that we have a valid image, let's give it the right size */
1440 ret
= bdrv_truncate(bs
, total_size
* BDRV_SECTOR_SIZE
);
1445 /* Want a backing file? There you go.*/
1447 ret
= bdrv_change_backing_file(bs
, backing_file
, backing_format
);
1453 /* And if we're supposed to preallocate metadata, do that now */
1455 BDRVQcowState
*s
= bs
->opaque
;
1456 qemu_co_mutex_lock(&s
->lock
);
1457 ret
= preallocate(bs
);
1458 qemu_co_mutex_unlock(&s
->lock
);
1470 static int qcow2_create(const char *filename
, QEMUOptionParameter
*options
)
1472 const char *backing_file
= NULL
;
1473 const char *backing_fmt
= NULL
;
1474 uint64_t sectors
= 0;
1476 size_t cluster_size
= DEFAULT_CLUSTER_SIZE
;
1480 /* Read out options */
1481 while (options
&& options
->name
) {
1482 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
1483 sectors
= options
->value
.n
/ 512;
1484 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
1485 backing_file
= options
->value
.s
;
1486 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FMT
)) {
1487 backing_fmt
= options
->value
.s
;
1488 } else if (!strcmp(options
->name
, BLOCK_OPT_ENCRYPT
)) {
1489 flags
|= options
->value
.n
? BLOCK_FLAG_ENCRYPT
: 0;
1490 } else if (!strcmp(options
->name
, BLOCK_OPT_CLUSTER_SIZE
)) {
1491 if (options
->value
.n
) {
1492 cluster_size
= options
->value
.n
;
1494 } else if (!strcmp(options
->name
, BLOCK_OPT_PREALLOC
)) {
1495 if (!options
->value
.s
|| !strcmp(options
->value
.s
, "off")) {
1497 } else if (!strcmp(options
->value
.s
, "metadata")) {
1500 fprintf(stderr
, "Invalid preallocation mode: '%s'\n",
1504 } else if (!strcmp(options
->name
, BLOCK_OPT_COMPAT_LEVEL
)) {
1505 if (!options
->value
.s
) {
1506 /* keep the default */
1507 } else if (!strcmp(options
->value
.s
, "0.10")) {
1509 } else if (!strcmp(options
->value
.s
, "1.1")) {
1512 fprintf(stderr
, "Invalid compatibility level: '%s'\n",
1516 } else if (!strcmp(options
->name
, BLOCK_OPT_LAZY_REFCOUNTS
)) {
1517 flags
|= options
->value
.n
? BLOCK_FLAG_LAZY_REFCOUNTS
: 0;
1522 if (backing_file
&& prealloc
) {
1523 fprintf(stderr
, "Backing file and preallocation cannot be used at "
1528 if (version
< 3 && (flags
& BLOCK_FLAG_LAZY_REFCOUNTS
)) {
1529 fprintf(stderr
, "Lazy refcounts only supported with compatibility "
1530 "level 1.1 and above (use compat=1.1 or greater)\n");
1534 return qcow2_create2(filename
, sectors
, backing_file
, backing_fmt
, flags
,
1535 cluster_size
, prealloc
, options
, version
);
1538 static int qcow2_make_empty(BlockDriverState
*bs
)
1541 /* XXX: not correct */
1542 BDRVQcowState
*s
= bs
->opaque
;
1543 uint32_t l1_length
= s
->l1_size
* sizeof(uint64_t);
1546 memset(s
->l1_table
, 0, l1_length
);
1547 if (bdrv_pwrite(bs
->file
, s
->l1_table_offset
, s
->l1_table
, l1_length
) < 0)
1549 ret
= bdrv_truncate(bs
->file
, s
->l1_table_offset
+ l1_length
);
1558 static coroutine_fn
int qcow2_co_write_zeroes(BlockDriverState
*bs
,
1559 int64_t sector_num
, int nb_sectors
)
1562 BDRVQcowState
*s
= bs
->opaque
;
1564 /* Emulate misaligned zero writes */
1565 if (sector_num
% s
->cluster_sectors
|| nb_sectors
% s
->cluster_sectors
) {
1569 /* Whatever is left can use real zero clusters */
1570 qemu_co_mutex_lock(&s
->lock
);
1571 ret
= qcow2_zero_clusters(bs
, sector_num
<< BDRV_SECTOR_BITS
,
1573 qemu_co_mutex_unlock(&s
->lock
);
1578 static coroutine_fn
int qcow2_co_discard(BlockDriverState
*bs
,
1579 int64_t sector_num
, int nb_sectors
)
1582 BDRVQcowState
*s
= bs
->opaque
;
1584 qemu_co_mutex_lock(&s
->lock
);
1585 ret
= qcow2_discard_clusters(bs
, sector_num
<< BDRV_SECTOR_BITS
,
1586 nb_sectors
, QCOW2_DISCARD_REQUEST
);
1587 qemu_co_mutex_unlock(&s
->lock
);
1591 static int qcow2_truncate(BlockDriverState
*bs
, int64_t offset
)
1593 BDRVQcowState
*s
= bs
->opaque
;
1594 int64_t new_l1_size
;
1598 error_report("The new size must be a multiple of 512");
1602 /* cannot proceed if image has snapshots */
1603 if (s
->nb_snapshots
) {
1604 error_report("Can't resize an image which has snapshots");
1608 /* shrinking is currently not supported */
1609 if (offset
< bs
->total_sectors
* 512) {
1610 error_report("qcow2 doesn't support shrinking images yet");
1614 new_l1_size
= size_to_l1(s
, offset
);
1615 ret
= qcow2_grow_l1_table(bs
, new_l1_size
, true);
1620 /* write updated header.size */
1621 offset
= cpu_to_be64(offset
);
1622 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, size
),
1623 &offset
, sizeof(uint64_t));
1628 s
->l1_vm_state_index
= new_l1_size
;
1632 /* XXX: put compressed sectors first, then all the cluster aligned
1633 tables to avoid losing bytes in alignment */
1634 static int qcow2_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
1635 const uint8_t *buf
, int nb_sectors
)
1637 BDRVQcowState
*s
= bs
->opaque
;
1641 uint64_t cluster_offset
;
1643 if (nb_sectors
== 0) {
1644 /* align end of file to a sector boundary to ease reading with
1645 sector based I/Os */
1646 cluster_offset
= bdrv_getlength(bs
->file
);
1647 cluster_offset
= (cluster_offset
+ 511) & ~511;
1648 bdrv_truncate(bs
->file
, cluster_offset
);
1652 if (nb_sectors
!= s
->cluster_sectors
) {
1655 /* Zero-pad last write if image size is not cluster aligned */
1656 if (sector_num
+ nb_sectors
== bs
->total_sectors
&&
1657 nb_sectors
< s
->cluster_sectors
) {
1658 uint8_t *pad_buf
= qemu_blockalign(bs
, s
->cluster_size
);
1659 memset(pad_buf
, 0, s
->cluster_size
);
1660 memcpy(pad_buf
, buf
, nb_sectors
* BDRV_SECTOR_SIZE
);
1661 ret
= qcow2_write_compressed(bs
, sector_num
,
1662 pad_buf
, s
->cluster_sectors
);
1663 qemu_vfree(pad_buf
);
1668 out_buf
= g_malloc(s
->cluster_size
+ (s
->cluster_size
/ 1000) + 128);
1670 /* best compression, small window, no zlib header */
1671 memset(&strm
, 0, sizeof(strm
));
1672 ret
= deflateInit2(&strm
, Z_DEFAULT_COMPRESSION
,
1674 9, Z_DEFAULT_STRATEGY
);
1680 strm
.avail_in
= s
->cluster_size
;
1681 strm
.next_in
= (uint8_t *)buf
;
1682 strm
.avail_out
= s
->cluster_size
;
1683 strm
.next_out
= out_buf
;
1685 ret
= deflate(&strm
, Z_FINISH
);
1686 if (ret
!= Z_STREAM_END
&& ret
!= Z_OK
) {
1691 out_len
= strm
.next_out
- out_buf
;
1695 if (ret
!= Z_STREAM_END
|| out_len
>= s
->cluster_size
) {
1696 /* could not compress: write normal cluster */
1698 ret
= qcow2_pre_write_overlap_check(bs
, QCOW2_OL_DEFAULT
,
1699 sector_num
* BDRV_SECTOR_SIZE
,
1700 s
->cluster_sectors
* BDRV_SECTOR_SIZE
);
1705 ret
= bdrv_write(bs
, sector_num
, buf
, s
->cluster_sectors
);
1710 cluster_offset
= qcow2_alloc_compressed_cluster_offset(bs
,
1711 sector_num
<< 9, out_len
);
1712 if (!cluster_offset
) {
1716 cluster_offset
&= s
->cluster_offset_mask
;
1718 ret
= qcow2_pre_write_overlap_check(bs
, QCOW2_OL_DEFAULT
,
1719 cluster_offset
, out_len
);
1724 BLKDBG_EVENT(bs
->file
, BLKDBG_WRITE_COMPRESSED
);
1725 ret
= bdrv_pwrite(bs
->file
, cluster_offset
, out_buf
, out_len
);
1737 static coroutine_fn
int qcow2_co_flush_to_os(BlockDriverState
*bs
)
1739 BDRVQcowState
*s
= bs
->opaque
;
1742 qemu_co_mutex_lock(&s
->lock
);
1743 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
1745 qemu_co_mutex_unlock(&s
->lock
);
1749 if (qcow2_need_accurate_refcounts(s
)) {
1750 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
1752 qemu_co_mutex_unlock(&s
->lock
);
1756 qemu_co_mutex_unlock(&s
->lock
);
1761 static int qcow2_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
1763 BDRVQcowState
*s
= bs
->opaque
;
1764 bdi
->cluster_size
= s
->cluster_size
;
1765 bdi
->vm_state_offset
= qcow2_vm_state_offset(s
);
1770 static void dump_refcounts(BlockDriverState
*bs
)
1772 BDRVQcowState
*s
= bs
->opaque
;
1773 int64_t nb_clusters
, k
, k1
, size
;
1776 size
= bdrv_getlength(bs
->file
);
1777 nb_clusters
= size_to_clusters(s
, size
);
1778 for(k
= 0; k
< nb_clusters
;) {
1780 refcount
= get_refcount(bs
, k
);
1782 while (k
< nb_clusters
&& get_refcount(bs
, k
) == refcount
)
1784 printf("%" PRId64
": refcount=%d nb=%" PRId64
"\n", k
, refcount
,
1790 static int qcow2_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
1793 BDRVQcowState
*s
= bs
->opaque
;
1794 int growable
= bs
->growable
;
1797 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_SAVE
);
1799 ret
= bdrv_pwritev(bs
, qcow2_vm_state_offset(s
) + pos
, qiov
);
1800 bs
->growable
= growable
;
1805 static int qcow2_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
1806 int64_t pos
, int size
)
1808 BDRVQcowState
*s
= bs
->opaque
;
1809 int growable
= bs
->growable
;
1810 bool zero_beyond_eof
= bs
->zero_beyond_eof
;
1813 BLKDBG_EVENT(bs
->file
, BLKDBG_VMSTATE_LOAD
);
1815 bs
->zero_beyond_eof
= false;
1816 ret
= bdrv_pread(bs
, qcow2_vm_state_offset(s
) + pos
, buf
, size
);
1817 bs
->growable
= growable
;
1818 bs
->zero_beyond_eof
= zero_beyond_eof
;
1823 static QEMUOptionParameter qcow2_create_options
[] = {
1825 .name
= BLOCK_OPT_SIZE
,
1827 .help
= "Virtual disk size"
1830 .name
= BLOCK_OPT_COMPAT_LEVEL
,
1832 .help
= "Compatibility level (0.10 or 1.1)"
1835 .name
= BLOCK_OPT_BACKING_FILE
,
1837 .help
= "File name of a base image"
1840 .name
= BLOCK_OPT_BACKING_FMT
,
1842 .help
= "Image format of the base image"
1845 .name
= BLOCK_OPT_ENCRYPT
,
1847 .help
= "Encrypt the image"
1850 .name
= BLOCK_OPT_CLUSTER_SIZE
,
1852 .help
= "qcow2 cluster size",
1853 .value
= { .n
= DEFAULT_CLUSTER_SIZE
},
1856 .name
= BLOCK_OPT_PREALLOC
,
1858 .help
= "Preallocation mode (allowed values: off, metadata)"
1861 .name
= BLOCK_OPT_LAZY_REFCOUNTS
,
1863 .help
= "Postpone refcount updates",
1868 static BlockDriver bdrv_qcow2
= {
1869 .format_name
= "qcow2",
1870 .instance_size
= sizeof(BDRVQcowState
),
1871 .bdrv_probe
= qcow2_probe
,
1872 .bdrv_open
= qcow2_open
,
1873 .bdrv_close
= qcow2_close
,
1874 .bdrv_reopen_prepare
= qcow2_reopen_prepare
,
1875 .bdrv_create
= qcow2_create
,
1876 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
1877 .bdrv_co_get_block_status
= qcow2_co_get_block_status
,
1878 .bdrv_set_key
= qcow2_set_key
,
1879 .bdrv_make_empty
= qcow2_make_empty
,
1881 .bdrv_co_readv
= qcow2_co_readv
,
1882 .bdrv_co_writev
= qcow2_co_writev
,
1883 .bdrv_co_flush_to_os
= qcow2_co_flush_to_os
,
1885 .bdrv_co_write_zeroes
= qcow2_co_write_zeroes
,
1886 .bdrv_co_discard
= qcow2_co_discard
,
1887 .bdrv_truncate
= qcow2_truncate
,
1888 .bdrv_write_compressed
= qcow2_write_compressed
,
1890 .bdrv_snapshot_create
= qcow2_snapshot_create
,
1891 .bdrv_snapshot_goto
= qcow2_snapshot_goto
,
1892 .bdrv_snapshot_delete
= qcow2_snapshot_delete
,
1893 .bdrv_snapshot_list
= qcow2_snapshot_list
,
1894 .bdrv_snapshot_load_tmp
= qcow2_snapshot_load_tmp
,
1895 .bdrv_get_info
= qcow2_get_info
,
1897 .bdrv_save_vmstate
= qcow2_save_vmstate
,
1898 .bdrv_load_vmstate
= qcow2_load_vmstate
,
1900 .bdrv_change_backing_file
= qcow2_change_backing_file
,
1902 .bdrv_invalidate_cache
= qcow2_invalidate_cache
,
1904 .create_options
= qcow2_create_options
,
1905 .bdrv_check
= qcow2_check
,
1908 static void bdrv_qcow2_init(void)
1910 bdrv_register(&bdrv_qcow2
);
1913 block_init(bdrv_qcow2_init
);