2 * Block driver for the QCOW version 2 format
4 * Copyright (c) 2004-2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
28 #include "qapi/error.h"
29 #include "qemu-common.h"
30 #include "block/block_int.h"
31 #include "block/qcow2.h"
32 #include "qemu/bswap.h"
35 int qcow2_grow_l1_table(BlockDriverState
*bs
, uint64_t min_size
,
38 BDRVQcow2State
*s
= bs
->opaque
;
39 int new_l1_size2
, ret
, i
;
40 uint64_t *new_l1_table
;
41 int64_t old_l1_table_offset
, old_l1_size
;
42 int64_t new_l1_table_offset
, new_l1_size
;
45 if (min_size
<= s
->l1_size
)
48 /* Do a sanity check on min_size before trying to calculate new_l1_size
49 * (this prevents overflows during the while loop for the calculation of
51 if (min_size
> INT_MAX
/ sizeof(uint64_t)) {
56 new_l1_size
= min_size
;
58 /* Bump size up to reduce the number of times we have to grow */
59 new_l1_size
= s
->l1_size
;
60 if (new_l1_size
== 0) {
63 while (min_size
> new_l1_size
) {
64 new_l1_size
= (new_l1_size
* 3 + 1) / 2;
68 QEMU_BUILD_BUG_ON(QCOW_MAX_L1_SIZE
> INT_MAX
);
69 if (new_l1_size
> QCOW_MAX_L1_SIZE
/ sizeof(uint64_t)) {
74 fprintf(stderr
, "grow l1_table from %d to %" PRId64
"\n",
75 s
->l1_size
, new_l1_size
);
78 new_l1_size2
= sizeof(uint64_t) * new_l1_size
;
79 new_l1_table
= qemu_try_blockalign(bs
->file
->bs
,
80 align_offset(new_l1_size2
, 512));
81 if (new_l1_table
== NULL
) {
84 memset(new_l1_table
, 0, align_offset(new_l1_size2
, 512));
86 memcpy(new_l1_table
, s
->l1_table
, s
->l1_size
* sizeof(uint64_t));
88 /* write new table (align to cluster) */
89 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_GROW_ALLOC_TABLE
);
90 new_l1_table_offset
= qcow2_alloc_clusters(bs
, new_l1_size2
);
91 if (new_l1_table_offset
< 0) {
92 qemu_vfree(new_l1_table
);
93 return new_l1_table_offset
;
96 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
101 /* the L1 position has not yet been updated, so these clusters must
102 * indeed be completely free */
103 ret
= qcow2_pre_write_overlap_check(bs
, 0, new_l1_table_offset
,
109 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_GROW_WRITE_TABLE
);
110 for(i
= 0; i
< s
->l1_size
; i
++)
111 new_l1_table
[i
] = cpu_to_be64(new_l1_table
[i
]);
112 ret
= bdrv_pwrite_sync(bs
->file
, new_l1_table_offset
,
113 new_l1_table
, new_l1_size2
);
116 for(i
= 0; i
< s
->l1_size
; i
++)
117 new_l1_table
[i
] = be64_to_cpu(new_l1_table
[i
]);
120 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_GROW_ACTIVATE_TABLE
);
121 stl_be_p(data
, new_l1_size
);
122 stq_be_p(data
+ 4, new_l1_table_offset
);
123 ret
= bdrv_pwrite_sync(bs
->file
, offsetof(QCowHeader
, l1_size
),
128 qemu_vfree(s
->l1_table
);
129 old_l1_table_offset
= s
->l1_table_offset
;
130 s
->l1_table_offset
= new_l1_table_offset
;
131 s
->l1_table
= new_l1_table
;
132 old_l1_size
= s
->l1_size
;
133 s
->l1_size
= new_l1_size
;
134 qcow2_free_clusters(bs
, old_l1_table_offset
, old_l1_size
* sizeof(uint64_t),
135 QCOW2_DISCARD_OTHER
);
138 qemu_vfree(new_l1_table
);
139 qcow2_free_clusters(bs
, new_l1_table_offset
, new_l1_size2
,
140 QCOW2_DISCARD_OTHER
);
147 * Loads a L2 table into memory. If the table is in the cache, the cache
148 * is used; otherwise the L2 table is loaded from the image file.
150 * Returns a pointer to the L2 table on success, or NULL if the read from
151 * the image file failed.
154 static int l2_load(BlockDriverState
*bs
, uint64_t l2_offset
,
157 BDRVQcow2State
*s
= bs
->opaque
;
159 return qcow2_cache_get(bs
, s
->l2_table_cache
, l2_offset
,
164 * Writes one sector of the L1 table to the disk (can't update single entries
165 * and we really don't want bdrv_pread to perform a read-modify-write)
167 #define L1_ENTRIES_PER_SECTOR (512 / 8)
168 int qcow2_write_l1_entry(BlockDriverState
*bs
, int l1_index
)
170 BDRVQcow2State
*s
= bs
->opaque
;
171 uint64_t buf
[L1_ENTRIES_PER_SECTOR
] = { 0 };
175 l1_start_index
= l1_index
& ~(L1_ENTRIES_PER_SECTOR
- 1);
176 for (i
= 0; i
< L1_ENTRIES_PER_SECTOR
&& l1_start_index
+ i
< s
->l1_size
;
179 buf
[i
] = cpu_to_be64(s
->l1_table
[l1_start_index
+ i
]);
182 ret
= qcow2_pre_write_overlap_check(bs
, QCOW2_OL_ACTIVE_L1
,
183 s
->l1_table_offset
+ 8 * l1_start_index
, sizeof(buf
));
188 BLKDBG_EVENT(bs
->file
, BLKDBG_L1_UPDATE
);
189 ret
= bdrv_pwrite_sync(bs
->file
,
190 s
->l1_table_offset
+ 8 * l1_start_index
,
202 * Allocate a new l2 entry in the file. If l1_index points to an already
203 * used entry in the L2 table (i.e. we are doing a copy on write for the L2
204 * table) copy the contents of the old L2 table into the newly allocated one.
205 * Otherwise the new table is initialized with zeros.
209 static int l2_allocate(BlockDriverState
*bs
, int l1_index
, uint64_t **table
)
211 BDRVQcow2State
*s
= bs
->opaque
;
212 uint64_t old_l2_offset
;
213 uint64_t *l2_table
= NULL
;
217 old_l2_offset
= s
->l1_table
[l1_index
];
219 trace_qcow2_l2_allocate(bs
, l1_index
);
221 /* allocate a new l2 entry */
223 l2_offset
= qcow2_alloc_clusters(bs
, s
->l2_size
* sizeof(uint64_t));
229 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
234 /* allocate a new entry in the l2 cache */
236 trace_qcow2_l2_allocate_get_empty(bs
, l1_index
);
237 ret
= qcow2_cache_get_empty(bs
, s
->l2_table_cache
, l2_offset
, (void**) table
);
244 if ((old_l2_offset
& L1E_OFFSET_MASK
) == 0) {
245 /* if there was no old l2 table, clear the new table */
246 memset(l2_table
, 0, s
->l2_size
* sizeof(uint64_t));
250 /* if there was an old l2 table, read it from the disk */
251 BLKDBG_EVENT(bs
->file
, BLKDBG_L2_ALLOC_COW_READ
);
252 ret
= qcow2_cache_get(bs
, s
->l2_table_cache
,
253 old_l2_offset
& L1E_OFFSET_MASK
,
254 (void**) &old_table
);
259 memcpy(l2_table
, old_table
, s
->cluster_size
);
261 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &old_table
);
264 /* write the l2 table to the file */
265 BLKDBG_EVENT(bs
->file
, BLKDBG_L2_ALLOC_WRITE
);
267 trace_qcow2_l2_allocate_write_l2(bs
, l1_index
);
268 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
, l2_table
);
269 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
274 /* update the L1 entry */
275 trace_qcow2_l2_allocate_write_l1(bs
, l1_index
);
276 s
->l1_table
[l1_index
] = l2_offset
| QCOW_OFLAG_COPIED
;
277 ret
= qcow2_write_l1_entry(bs
, l1_index
);
283 trace_qcow2_l2_allocate_done(bs
, l1_index
, 0);
287 trace_qcow2_l2_allocate_done(bs
, l1_index
, ret
);
288 if (l2_table
!= NULL
) {
289 qcow2_cache_put(bs
, s
->l2_table_cache
, (void**) table
);
291 s
->l1_table
[l1_index
] = old_l2_offset
;
293 qcow2_free_clusters(bs
, l2_offset
, s
->l2_size
* sizeof(uint64_t),
294 QCOW2_DISCARD_ALWAYS
);
300 * Checks how many clusters in a given L2 table are contiguous in the image
301 * file. As soon as one of the flags in the bitmask stop_flags changes compared
302 * to the first cluster, the search is stopped and the cluster is not counted
303 * as contiguous. (This allows it, for example, to stop at the first compressed
304 * cluster which may require a different handling)
306 static int count_contiguous_clusters(int nb_clusters
, int cluster_size
,
307 uint64_t *l2_table
, uint64_t stop_flags
)
310 uint64_t mask
= stop_flags
| L2E_OFFSET_MASK
| QCOW_OFLAG_COMPRESSED
;
311 uint64_t first_entry
= be64_to_cpu(l2_table
[0]);
312 uint64_t offset
= first_entry
& mask
;
317 assert(qcow2_get_cluster_type(first_entry
) == QCOW2_CLUSTER_NORMAL
);
319 for (i
= 0; i
< nb_clusters
; i
++) {
320 uint64_t l2_entry
= be64_to_cpu(l2_table
[i
]) & mask
;
321 if (offset
+ (uint64_t) i
* cluster_size
!= l2_entry
) {
329 static int count_contiguous_clusters_by_type(int nb_clusters
,
335 for (i
= 0; i
< nb_clusters
; i
++) {
336 int type
= qcow2_get_cluster_type(be64_to_cpu(l2_table
[i
]));
338 if (type
!= wanted_type
) {
346 /* The crypt function is compatible with the linux cryptoloop
347 algorithm for < 4 GB images. NOTE: out_buf == in_buf is
349 int qcow2_encrypt_sectors(BDRVQcow2State
*s
, int64_t sector_num
,
350 uint8_t *out_buf
, const uint8_t *in_buf
,
351 int nb_sectors
, bool enc
,
361 for(i
= 0; i
< nb_sectors
; i
++) {
362 ivec
.ll
[0] = cpu_to_le64(sector_num
);
364 if (qcrypto_cipher_setiv(s
->cipher
,
365 ivec
.b
, G_N_ELEMENTS(ivec
.b
),
370 ret
= qcrypto_cipher_encrypt(s
->cipher
,
376 ret
= qcrypto_cipher_decrypt(s
->cipher
,
392 static int coroutine_fn
do_perform_cow(BlockDriverState
*bs
,
393 uint64_t src_cluster_offset
,
394 uint64_t cluster_offset
,
395 int offset_in_cluster
,
398 BDRVQcow2State
*s
= bs
->opaque
;
404 iov
.iov_base
= qemu_try_blockalign(bs
, iov
.iov_len
);
405 if (iov
.iov_base
== NULL
) {
409 qemu_iovec_init_external(&qiov
, &iov
, 1);
411 BLKDBG_EVENT(bs
->file
, BLKDBG_COW_READ
);
418 /* Call .bdrv_co_readv() directly instead of using the public block-layer
419 * interface. This avoids double I/O throttling and request tracking,
420 * which can lead to deadlock when block layer copy-on-read is enabled.
422 ret
= bs
->drv
->bdrv_co_preadv(bs
, src_cluster_offset
+ offset_in_cluster
,
430 int64_t sector
= (cluster_offset
+ offset_in_cluster
)
433 assert((offset_in_cluster
& ~BDRV_SECTOR_MASK
) == 0);
434 assert((bytes
& ~BDRV_SECTOR_MASK
) == 0);
435 if (qcow2_encrypt_sectors(s
, sector
, iov
.iov_base
, iov
.iov_base
,
436 bytes
>> BDRV_SECTOR_BITS
, true, &err
) < 0) {
443 ret
= qcow2_pre_write_overlap_check(bs
, 0,
444 cluster_offset
+ offset_in_cluster
, bytes
);
449 BLKDBG_EVENT(bs
->file
, BLKDBG_COW_WRITE
);
450 ret
= bdrv_co_pwritev(bs
->file
, cluster_offset
+ offset_in_cluster
,
458 qemu_vfree(iov
.iov_base
);
466 * For a given offset of the virtual disk, find the cluster type and offset in
467 * the qcow2 file. The offset is stored in *cluster_offset.
469 * On entry, *bytes is the maximum number of contiguous bytes starting at
470 * offset that we are interested in.
472 * On exit, *bytes is the number of bytes starting at offset that have the same
473 * cluster type and (if applicable) are stored contiguously in the image file.
474 * Compressed clusters are always returned one by one.
476 * Returns the cluster type (QCOW2_CLUSTER_*) on success, -errno in error
479 int qcow2_get_cluster_offset(BlockDriverState
*bs
, uint64_t offset
,
480 unsigned int *bytes
, uint64_t *cluster_offset
)
482 BDRVQcow2State
*s
= bs
->opaque
;
483 unsigned int l2_index
;
484 uint64_t l1_index
, l2_offset
, *l2_table
;
486 unsigned int offset_in_cluster
, nb_clusters
;
487 uint64_t bytes_available
, bytes_needed
;
490 offset_in_cluster
= offset_into_cluster(s
, offset
);
491 bytes_needed
= (uint64_t) *bytes
+ offset_in_cluster
;
493 l1_bits
= s
->l2_bits
+ s
->cluster_bits
;
495 /* compute how many bytes there are between the start of the cluster
496 * containing offset and the end of the l1 entry */
497 bytes_available
= (1ULL << l1_bits
) - (offset
& ((1ULL << l1_bits
) - 1))
500 if (bytes_needed
> bytes_available
) {
501 bytes_needed
= bytes_available
;
503 assert(bytes_needed
<= INT_MAX
);
507 /* seek to the l2 offset in the l1 table */
509 l1_index
= offset
>> l1_bits
;
510 if (l1_index
>= s
->l1_size
) {
511 ret
= QCOW2_CLUSTER_UNALLOCATED
;
515 l2_offset
= s
->l1_table
[l1_index
] & L1E_OFFSET_MASK
;
517 ret
= QCOW2_CLUSTER_UNALLOCATED
;
521 if (offset_into_cluster(s
, l2_offset
)) {
522 qcow2_signal_corruption(bs
, true, -1, -1, "L2 table offset %#" PRIx64
523 " unaligned (L1 index: %#" PRIx64
")",
524 l2_offset
, l1_index
);
528 /* load the l2 table in memory */
530 ret
= l2_load(bs
, l2_offset
, &l2_table
);
535 /* find the cluster offset for the given disk offset */
537 l2_index
= (offset
>> s
->cluster_bits
) & (s
->l2_size
- 1);
538 *cluster_offset
= be64_to_cpu(l2_table
[l2_index
]);
540 /* nb_needed <= INT_MAX, thus nb_clusters <= INT_MAX, too */
541 nb_clusters
= size_to_clusters(s
, bytes_needed
);
543 ret
= qcow2_get_cluster_type(*cluster_offset
);
545 case QCOW2_CLUSTER_COMPRESSED
:
546 /* Compressed clusters can only be processed one by one */
548 *cluster_offset
&= L2E_COMPRESSED_OFFSET_SIZE_MASK
;
550 case QCOW2_CLUSTER_ZERO
:
551 if (s
->qcow_version
< 3) {
552 qcow2_signal_corruption(bs
, true, -1, -1, "Zero cluster entry found"
553 " in pre-v3 image (L2 offset: %#" PRIx64
554 ", L2 index: %#x)", l2_offset
, l2_index
);
558 c
= count_contiguous_clusters_by_type(nb_clusters
, &l2_table
[l2_index
],
562 case QCOW2_CLUSTER_UNALLOCATED
:
563 /* how many empty clusters ? */
564 c
= count_contiguous_clusters_by_type(nb_clusters
, &l2_table
[l2_index
],
565 QCOW2_CLUSTER_UNALLOCATED
);
568 case QCOW2_CLUSTER_NORMAL
:
569 /* how many allocated clusters ? */
570 c
= count_contiguous_clusters(nb_clusters
, s
->cluster_size
,
571 &l2_table
[l2_index
], QCOW_OFLAG_ZERO
);
572 *cluster_offset
&= L2E_OFFSET_MASK
;
573 if (offset_into_cluster(s
, *cluster_offset
)) {
574 qcow2_signal_corruption(bs
, true, -1, -1, "Data cluster offset %#"
575 PRIx64
" unaligned (L2 offset: %#" PRIx64
576 ", L2 index: %#x)", *cluster_offset
,
577 l2_offset
, l2_index
);
586 qcow2_cache_put(bs
, s
->l2_table_cache
, (void**) &l2_table
);
588 bytes_available
= (c
* s
->cluster_size
);
591 if (bytes_available
> bytes_needed
) {
592 bytes_available
= bytes_needed
;
595 *bytes
= bytes_available
- offset_in_cluster
;
600 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **)&l2_table
);
607 * for a given disk offset, load (and allocate if needed)
610 * the l2 table offset in the qcow2 file and the cluster index
611 * in the l2 table are given to the caller.
613 * Returns 0 on success, -errno in failure case
615 static int get_cluster_table(BlockDriverState
*bs
, uint64_t offset
,
616 uint64_t **new_l2_table
,
619 BDRVQcow2State
*s
= bs
->opaque
;
620 unsigned int l2_index
;
621 uint64_t l1_index
, l2_offset
;
622 uint64_t *l2_table
= NULL
;
625 /* seek to the l2 offset in the l1 table */
627 l1_index
= offset
>> (s
->l2_bits
+ s
->cluster_bits
);
628 if (l1_index
>= s
->l1_size
) {
629 ret
= qcow2_grow_l1_table(bs
, l1_index
+ 1, false);
635 assert(l1_index
< s
->l1_size
);
636 l2_offset
= s
->l1_table
[l1_index
] & L1E_OFFSET_MASK
;
637 if (offset_into_cluster(s
, l2_offset
)) {
638 qcow2_signal_corruption(bs
, true, -1, -1, "L2 table offset %#" PRIx64
639 " unaligned (L1 index: %#" PRIx64
")",
640 l2_offset
, l1_index
);
644 /* seek the l2 table of the given l2 offset */
646 if (s
->l1_table
[l1_index
] & QCOW_OFLAG_COPIED
) {
647 /* load the l2 table in memory */
648 ret
= l2_load(bs
, l2_offset
, &l2_table
);
653 /* First allocate a new L2 table (and do COW if needed) */
654 ret
= l2_allocate(bs
, l1_index
, &l2_table
);
659 /* Then decrease the refcount of the old table */
661 qcow2_free_clusters(bs
, l2_offset
, s
->l2_size
* sizeof(uint64_t),
662 QCOW2_DISCARD_OTHER
);
666 /* find the cluster offset for the given disk offset */
668 l2_index
= (offset
>> s
->cluster_bits
) & (s
->l2_size
- 1);
670 *new_l2_table
= l2_table
;
671 *new_l2_index
= l2_index
;
677 * alloc_compressed_cluster_offset
679 * For a given offset of the disk image, return cluster offset in
682 * If the offset is not found, allocate a new compressed cluster.
684 * Return the cluster offset if successful,
685 * Return 0, otherwise.
689 uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState
*bs
,
693 BDRVQcow2State
*s
= bs
->opaque
;
696 int64_t cluster_offset
;
699 ret
= get_cluster_table(bs
, offset
, &l2_table
, &l2_index
);
704 /* Compression can't overwrite anything. Fail if the cluster was already
706 cluster_offset
= be64_to_cpu(l2_table
[l2_index
]);
707 if (cluster_offset
& L2E_OFFSET_MASK
) {
708 qcow2_cache_put(bs
, s
->l2_table_cache
, (void**) &l2_table
);
712 cluster_offset
= qcow2_alloc_bytes(bs
, compressed_size
);
713 if (cluster_offset
< 0) {
714 qcow2_cache_put(bs
, s
->l2_table_cache
, (void**) &l2_table
);
718 nb_csectors
= ((cluster_offset
+ compressed_size
- 1) >> 9) -
719 (cluster_offset
>> 9);
721 cluster_offset
|= QCOW_OFLAG_COMPRESSED
|
722 ((uint64_t)nb_csectors
<< s
->csize_shift
);
724 /* update L2 table */
726 /* compressed clusters never have the copied flag */
728 BLKDBG_EVENT(bs
->file
, BLKDBG_L2_UPDATE_COMPRESSED
);
729 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
, l2_table
);
730 l2_table
[l2_index
] = cpu_to_be64(cluster_offset
);
731 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
733 return cluster_offset
;
736 static int perform_cow(BlockDriverState
*bs
, QCowL2Meta
*m
, Qcow2COWRegion
*r
)
738 BDRVQcow2State
*s
= bs
->opaque
;
741 if (r
->nb_bytes
== 0) {
745 qemu_co_mutex_unlock(&s
->lock
);
746 ret
= do_perform_cow(bs
, m
->offset
, m
->alloc_offset
, r
->offset
, r
->nb_bytes
);
747 qemu_co_mutex_lock(&s
->lock
);
754 * Before we update the L2 table to actually point to the new cluster, we
755 * need to be sure that the refcounts have been increased and COW was
758 qcow2_cache_depends_on_flush(s
->l2_table_cache
);
763 int qcow2_alloc_cluster_link_l2(BlockDriverState
*bs
, QCowL2Meta
*m
)
765 BDRVQcow2State
*s
= bs
->opaque
;
766 int i
, j
= 0, l2_index
, ret
;
767 uint64_t *old_cluster
, *l2_table
;
768 uint64_t cluster_offset
= m
->alloc_offset
;
770 trace_qcow2_cluster_link_l2(qemu_coroutine_self(), m
->nb_clusters
);
771 assert(m
->nb_clusters
> 0);
773 old_cluster
= g_try_new(uint64_t, m
->nb_clusters
);
774 if (old_cluster
== NULL
) {
779 /* copy content of unmodified sectors */
780 ret
= perform_cow(bs
, m
, &m
->cow_start
);
785 ret
= perform_cow(bs
, m
, &m
->cow_end
);
790 /* Update L2 table. */
791 if (s
->use_lazy_refcounts
) {
792 qcow2_mark_dirty(bs
);
794 if (qcow2_need_accurate_refcounts(s
)) {
795 qcow2_cache_set_dependency(bs
, s
->l2_table_cache
,
796 s
->refcount_block_cache
);
799 ret
= get_cluster_table(bs
, m
->offset
, &l2_table
, &l2_index
);
803 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
, l2_table
);
805 assert(l2_index
+ m
->nb_clusters
<= s
->l2_size
);
806 for (i
= 0; i
< m
->nb_clusters
; i
++) {
807 /* if two concurrent writes happen to the same unallocated cluster
808 * each write allocates separate cluster and writes data concurrently.
809 * The first one to complete updates l2 table with pointer to its
810 * cluster the second one has to do RMW (which is done above by
811 * perform_cow()), update l2 table with its cluster pointer and free
812 * old cluster. This is what this loop does */
813 if (l2_table
[l2_index
+ i
] != 0) {
814 old_cluster
[j
++] = l2_table
[l2_index
+ i
];
817 l2_table
[l2_index
+ i
] = cpu_to_be64((cluster_offset
+
818 (i
<< s
->cluster_bits
)) | QCOW_OFLAG_COPIED
);
822 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
825 * If this was a COW, we need to decrease the refcount of the old cluster.
827 * Don't discard clusters that reach a refcount of 0 (e.g. compressed
828 * clusters), the next write will reuse them anyway.
831 for (i
= 0; i
< j
; i
++) {
832 qcow2_free_any_clusters(bs
, be64_to_cpu(old_cluster
[i
]), 1,
833 QCOW2_DISCARD_NEVER
);
844 * Returns the number of contiguous clusters that can be used for an allocating
845 * write, but require COW to be performed (this includes yet unallocated space,
846 * which must copy from the backing file)
848 static int count_cow_clusters(BDRVQcow2State
*s
, int nb_clusters
,
849 uint64_t *l2_table
, int l2_index
)
853 for (i
= 0; i
< nb_clusters
; i
++) {
854 uint64_t l2_entry
= be64_to_cpu(l2_table
[l2_index
+ i
]);
855 int cluster_type
= qcow2_get_cluster_type(l2_entry
);
857 switch(cluster_type
) {
858 case QCOW2_CLUSTER_NORMAL
:
859 if (l2_entry
& QCOW_OFLAG_COPIED
) {
863 case QCOW2_CLUSTER_UNALLOCATED
:
864 case QCOW2_CLUSTER_COMPRESSED
:
865 case QCOW2_CLUSTER_ZERO
:
873 assert(i
<= nb_clusters
);
878 * Check if there already is an AIO write request in flight which allocates
879 * the same cluster. In this case we need to wait until the previous
880 * request has completed and updated the L2 table accordingly.
883 * 0 if there was no dependency. *cur_bytes indicates the number of
884 * bytes from guest_offset that can be read before the next
885 * dependency must be processed (or the request is complete)
887 * -EAGAIN if we had to wait for another request, previously gathered
888 * information on cluster allocation may be invalid now. The caller
889 * must start over anyway, so consider *cur_bytes undefined.
891 static int handle_dependencies(BlockDriverState
*bs
, uint64_t guest_offset
,
892 uint64_t *cur_bytes
, QCowL2Meta
**m
)
894 BDRVQcow2State
*s
= bs
->opaque
;
895 QCowL2Meta
*old_alloc
;
896 uint64_t bytes
= *cur_bytes
;
898 QLIST_FOREACH(old_alloc
, &s
->cluster_allocs
, next_in_flight
) {
900 uint64_t start
= guest_offset
;
901 uint64_t end
= start
+ bytes
;
902 uint64_t old_start
= l2meta_cow_start(old_alloc
);
903 uint64_t old_end
= l2meta_cow_end(old_alloc
);
905 if (end
<= old_start
|| start
>= old_end
) {
906 /* No intersection */
908 if (start
< old_start
) {
909 /* Stop at the start of a running allocation */
910 bytes
= old_start
- start
;
915 /* Stop if already an l2meta exists. After yielding, it wouldn't
916 * be valid any more, so we'd have to clean up the old L2Metas
917 * and deal with requests depending on them before starting to
918 * gather new ones. Not worth the trouble. */
919 if (bytes
== 0 && *m
) {
925 /* Wait for the dependency to complete. We need to recheck
926 * the free/allocated clusters when we continue. */
927 qemu_co_mutex_unlock(&s
->lock
);
928 qemu_co_queue_wait(&old_alloc
->dependent_requests
);
929 qemu_co_mutex_lock(&s
->lock
);
935 /* Make sure that existing clusters and new allocations are only used up to
936 * the next dependency if we shortened the request above */
943 * Checks how many already allocated clusters that don't require a copy on
944 * write there are at the given guest_offset (up to *bytes). If
945 * *host_offset is not zero, only physically contiguous clusters beginning at
946 * this host offset are counted.
948 * Note that guest_offset may not be cluster aligned. In this case, the
949 * returned *host_offset points to exact byte referenced by guest_offset and
950 * therefore isn't cluster aligned as well.
953 * 0: if no allocated clusters are available at the given offset.
954 * *bytes is normally unchanged. It is set to 0 if the cluster
955 * is allocated and doesn't need COW, but doesn't have the right
958 * 1: if allocated clusters that don't require a COW are available at
959 * the requested offset. *bytes may have decreased and describes
960 * the length of the area that can be written to.
962 * -errno: in error cases
964 static int handle_copied(BlockDriverState
*bs
, uint64_t guest_offset
,
965 uint64_t *host_offset
, uint64_t *bytes
, QCowL2Meta
**m
)
967 BDRVQcow2State
*s
= bs
->opaque
;
969 uint64_t cluster_offset
;
971 uint64_t nb_clusters
;
972 unsigned int keep_clusters
;
975 trace_qcow2_handle_copied(qemu_coroutine_self(), guest_offset
, *host_offset
,
978 assert(*host_offset
== 0 || offset_into_cluster(s
, guest_offset
)
979 == offset_into_cluster(s
, *host_offset
));
982 * Calculate the number of clusters to look for. We stop at L2 table
983 * boundaries to keep things simple.
986 size_to_clusters(s
, offset_into_cluster(s
, guest_offset
) + *bytes
);
988 l2_index
= offset_to_l2_index(s
, guest_offset
);
989 nb_clusters
= MIN(nb_clusters
, s
->l2_size
- l2_index
);
990 assert(nb_clusters
<= INT_MAX
);
992 /* Find L2 entry for the first involved cluster */
993 ret
= get_cluster_table(bs
, guest_offset
, &l2_table
, &l2_index
);
998 cluster_offset
= be64_to_cpu(l2_table
[l2_index
]);
1000 /* Check how many clusters are already allocated and don't need COW */
1001 if (qcow2_get_cluster_type(cluster_offset
) == QCOW2_CLUSTER_NORMAL
1002 && (cluster_offset
& QCOW_OFLAG_COPIED
))
1004 /* If a specific host_offset is required, check it */
1005 bool offset_matches
=
1006 (cluster_offset
& L2E_OFFSET_MASK
) == *host_offset
;
1008 if (offset_into_cluster(s
, cluster_offset
& L2E_OFFSET_MASK
)) {
1009 qcow2_signal_corruption(bs
, true, -1, -1, "Data cluster offset "
1010 "%#llx unaligned (guest offset: %#" PRIx64
1011 ")", cluster_offset
& L2E_OFFSET_MASK
,
1017 if (*host_offset
!= 0 && !offset_matches
) {
1023 /* We keep all QCOW_OFLAG_COPIED clusters */
1025 count_contiguous_clusters(nb_clusters
, s
->cluster_size
,
1026 &l2_table
[l2_index
],
1027 QCOW_OFLAG_COPIED
| QCOW_OFLAG_ZERO
);
1028 assert(keep_clusters
<= nb_clusters
);
1030 *bytes
= MIN(*bytes
,
1031 keep_clusters
* s
->cluster_size
1032 - offset_into_cluster(s
, guest_offset
));
1041 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1043 /* Only return a host offset if we actually made progress. Otherwise we
1044 * would make requirements for handle_alloc() that it can't fulfill */
1046 *host_offset
= (cluster_offset
& L2E_OFFSET_MASK
)
1047 + offset_into_cluster(s
, guest_offset
);
1054 * Allocates new clusters for the given guest_offset.
1056 * At most *nb_clusters are allocated, and on return *nb_clusters is updated to
1057 * contain the number of clusters that have been allocated and are contiguous
1058 * in the image file.
1060 * If *host_offset is non-zero, it specifies the offset in the image file at
1061 * which the new clusters must start. *nb_clusters can be 0 on return in this
1062 * case if the cluster at host_offset is already in use. If *host_offset is
1063 * zero, the clusters can be allocated anywhere in the image file.
1065 * *host_offset is updated to contain the offset into the image file at which
1066 * the first allocated cluster starts.
1068 * Return 0 on success and -errno in error cases. -EAGAIN means that the
1069 * function has been waiting for another request and the allocation must be
1070 * restarted, but the whole request should not be failed.
1072 static int do_alloc_cluster_offset(BlockDriverState
*bs
, uint64_t guest_offset
,
1073 uint64_t *host_offset
, uint64_t *nb_clusters
)
1075 BDRVQcow2State
*s
= bs
->opaque
;
1077 trace_qcow2_do_alloc_clusters_offset(qemu_coroutine_self(), guest_offset
,
1078 *host_offset
, *nb_clusters
);
1080 /* Allocate new clusters */
1081 trace_qcow2_cluster_alloc_phys(qemu_coroutine_self());
1082 if (*host_offset
== 0) {
1083 int64_t cluster_offset
=
1084 qcow2_alloc_clusters(bs
, *nb_clusters
* s
->cluster_size
);
1085 if (cluster_offset
< 0) {
1086 return cluster_offset
;
1088 *host_offset
= cluster_offset
;
1091 int64_t ret
= qcow2_alloc_clusters_at(bs
, *host_offset
, *nb_clusters
);
1101 * Allocates new clusters for an area that either is yet unallocated or needs a
1102 * copy on write. If *host_offset is non-zero, clusters are only allocated if
1103 * the new allocation can match the specified host offset.
1105 * Note that guest_offset may not be cluster aligned. In this case, the
1106 * returned *host_offset points to exact byte referenced by guest_offset and
1107 * therefore isn't cluster aligned as well.
1110 * 0: if no clusters could be allocated. *bytes is set to 0,
1111 * *host_offset is left unchanged.
1113 * 1: if new clusters were allocated. *bytes may be decreased if the
1114 * new allocation doesn't cover all of the requested area.
1115 * *host_offset is updated to contain the host offset of the first
1116 * newly allocated cluster.
1118 * -errno: in error cases
1120 static int handle_alloc(BlockDriverState
*bs
, uint64_t guest_offset
,
1121 uint64_t *host_offset
, uint64_t *bytes
, QCowL2Meta
**m
)
1123 BDRVQcow2State
*s
= bs
->opaque
;
1127 uint64_t nb_clusters
;
1130 uint64_t alloc_cluster_offset
;
1132 trace_qcow2_handle_alloc(qemu_coroutine_self(), guest_offset
, *host_offset
,
1137 * Calculate the number of clusters to look for. We stop at L2 table
1138 * boundaries to keep things simple.
1141 size_to_clusters(s
, offset_into_cluster(s
, guest_offset
) + *bytes
);
1143 l2_index
= offset_to_l2_index(s
, guest_offset
);
1144 nb_clusters
= MIN(nb_clusters
, s
->l2_size
- l2_index
);
1145 assert(nb_clusters
<= INT_MAX
);
1147 /* Find L2 entry for the first involved cluster */
1148 ret
= get_cluster_table(bs
, guest_offset
, &l2_table
, &l2_index
);
1153 entry
= be64_to_cpu(l2_table
[l2_index
]);
1155 /* For the moment, overwrite compressed clusters one by one */
1156 if (entry
& QCOW_OFLAG_COMPRESSED
) {
1159 nb_clusters
= count_cow_clusters(s
, nb_clusters
, l2_table
, l2_index
);
1162 /* This function is only called when there were no non-COW clusters, so if
1163 * we can't find any unallocated or COW clusters either, something is
1164 * wrong with our code. */
1165 assert(nb_clusters
> 0);
1167 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1169 /* Allocate, if necessary at a given offset in the image file */
1170 alloc_cluster_offset
= start_of_cluster(s
, *host_offset
);
1171 ret
= do_alloc_cluster_offset(bs
, guest_offset
, &alloc_cluster_offset
,
1177 /* Can't extend contiguous allocation */
1178 if (nb_clusters
== 0) {
1183 /* !*host_offset would overwrite the image header and is reserved for "no
1184 * host offset preferred". If 0 was a valid host offset, it'd trigger the
1185 * following overlap check; do that now to avoid having an invalid value in
1187 if (!alloc_cluster_offset
) {
1188 ret
= qcow2_pre_write_overlap_check(bs
, 0, alloc_cluster_offset
,
1189 nb_clusters
* s
->cluster_size
);
1195 * Save info needed for meta data update.
1197 * requested_bytes: Number of bytes from the start of the first
1198 * newly allocated cluster to the end of the (possibly shortened
1199 * before) write request.
1201 * avail_bytes: Number of bytes from the start of the first
1202 * newly allocated to the end of the last newly allocated cluster.
1204 * nb_bytes: The number of bytes from the start of the first
1205 * newly allocated cluster to the end of the area that the write
1206 * request actually writes to (excluding COW at the end)
1208 uint64_t requested_bytes
= *bytes
+ offset_into_cluster(s
, guest_offset
);
1209 int avail_bytes
= MIN(INT_MAX
, nb_clusters
<< s
->cluster_bits
);
1210 int nb_bytes
= MIN(requested_bytes
, avail_bytes
);
1211 QCowL2Meta
*old_m
= *m
;
1213 *m
= g_malloc0(sizeof(**m
));
1215 **m
= (QCowL2Meta
) {
1218 .alloc_offset
= alloc_cluster_offset
,
1219 .offset
= start_of_cluster(s
, guest_offset
),
1220 .nb_clusters
= nb_clusters
,
1224 .nb_bytes
= offset_into_cluster(s
, guest_offset
),
1228 .nb_bytes
= avail_bytes
- nb_bytes
,
1231 qemu_co_queue_init(&(*m
)->dependent_requests
);
1232 QLIST_INSERT_HEAD(&s
->cluster_allocs
, *m
, next_in_flight
);
1234 *host_offset
= alloc_cluster_offset
+ offset_into_cluster(s
, guest_offset
);
1235 *bytes
= MIN(*bytes
, nb_bytes
- offset_into_cluster(s
, guest_offset
));
1236 assert(*bytes
!= 0);
1241 if (*m
&& (*m
)->nb_clusters
> 0) {
1242 QLIST_REMOVE(*m
, next_in_flight
);
1248 * alloc_cluster_offset
1250 * For a given offset on the virtual disk, find the cluster offset in qcow2
1251 * file. If the offset is not found, allocate a new cluster.
1253 * If the cluster was already allocated, m->nb_clusters is set to 0 and
1254 * other fields in m are meaningless.
1256 * If the cluster is newly allocated, m->nb_clusters is set to the number of
1257 * contiguous clusters that have been allocated. In this case, the other
1258 * fields of m are valid and contain information about the first allocated
1261 * If the request conflicts with another write request in flight, the coroutine
1262 * is queued and will be reentered when the dependency has completed.
1264 * Return 0 on success and -errno in error cases
1266 int qcow2_alloc_cluster_offset(BlockDriverState
*bs
, uint64_t offset
,
1267 unsigned int *bytes
, uint64_t *host_offset
,
1270 BDRVQcow2State
*s
= bs
->opaque
;
1271 uint64_t start
, remaining
;
1272 uint64_t cluster_offset
;
1276 trace_qcow2_alloc_clusters_offset(qemu_coroutine_self(), offset
, *bytes
);
1288 if (!*host_offset
) {
1289 *host_offset
= start_of_cluster(s
, cluster_offset
);
1292 assert(remaining
>= cur_bytes
);
1295 remaining
-= cur_bytes
;
1296 cluster_offset
+= cur_bytes
;
1298 if (remaining
== 0) {
1302 cur_bytes
= remaining
;
1305 * Now start gathering as many contiguous clusters as possible:
1307 * 1. Check for overlaps with in-flight allocations
1309 * a) Overlap not in the first cluster -> shorten this request and
1310 * let the caller handle the rest in its next loop iteration.
1312 * b) Real overlaps of two requests. Yield and restart the search
1313 * for contiguous clusters (the situation could have changed
1314 * while we were sleeping)
1316 * c) TODO: Request starts in the same cluster as the in-flight
1317 * allocation ends. Shorten the COW of the in-fight allocation,
1318 * set cluster_offset to write to the same cluster and set up
1319 * the right synchronisation between the in-flight request and
1322 ret
= handle_dependencies(bs
, start
, &cur_bytes
, m
);
1323 if (ret
== -EAGAIN
) {
1324 /* Currently handle_dependencies() doesn't yield if we already had
1325 * an allocation. If it did, we would have to clean up the L2Meta
1326 * structs before starting over. */
1329 } else if (ret
< 0) {
1331 } else if (cur_bytes
== 0) {
1334 /* handle_dependencies() may have decreased cur_bytes (shortened
1335 * the allocations below) so that the next dependency is processed
1336 * correctly during the next loop iteration. */
1340 * 2. Count contiguous COPIED clusters.
1342 ret
= handle_copied(bs
, start
, &cluster_offset
, &cur_bytes
, m
);
1347 } else if (cur_bytes
== 0) {
1352 * 3. If the request still hasn't completed, allocate new clusters,
1353 * considering any cluster_offset of steps 1c or 2.
1355 ret
= handle_alloc(bs
, start
, &cluster_offset
, &cur_bytes
, m
);
1361 assert(cur_bytes
== 0);
1366 *bytes
-= remaining
;
1368 assert(*host_offset
!= 0);
1373 static int decompress_buffer(uint8_t *out_buf
, int out_buf_size
,
1374 const uint8_t *buf
, int buf_size
)
1376 z_stream strm1
, *strm
= &strm1
;
1379 memset(strm
, 0, sizeof(*strm
));
1381 strm
->next_in
= (uint8_t *)buf
;
1382 strm
->avail_in
= buf_size
;
1383 strm
->next_out
= out_buf
;
1384 strm
->avail_out
= out_buf_size
;
1386 ret
= inflateInit2(strm
, -12);
1389 ret
= inflate(strm
, Z_FINISH
);
1390 out_len
= strm
->next_out
- out_buf
;
1391 if ((ret
!= Z_STREAM_END
&& ret
!= Z_BUF_ERROR
) ||
1392 out_len
!= out_buf_size
) {
1400 int qcow2_decompress_cluster(BlockDriverState
*bs
, uint64_t cluster_offset
)
1402 BDRVQcow2State
*s
= bs
->opaque
;
1403 int ret
, csize
, nb_csectors
, sector_offset
;
1406 coffset
= cluster_offset
& s
->cluster_offset_mask
;
1407 if (s
->cluster_cache_offset
!= coffset
) {
1408 nb_csectors
= ((cluster_offset
>> s
->csize_shift
) & s
->csize_mask
) + 1;
1409 sector_offset
= coffset
& 511;
1410 csize
= nb_csectors
* 512 - sector_offset
;
1411 BLKDBG_EVENT(bs
->file
, BLKDBG_READ_COMPRESSED
);
1412 ret
= bdrv_read(bs
->file
, coffset
>> 9, s
->cluster_data
,
1417 if (decompress_buffer(s
->cluster_cache
, s
->cluster_size
,
1418 s
->cluster_data
+ sector_offset
, csize
) < 0) {
1421 s
->cluster_cache_offset
= coffset
;
1427 * This discards as many clusters of nb_clusters as possible at once (i.e.
1428 * all clusters in the same L2 table) and returns the number of discarded
1431 static int discard_single_l2(BlockDriverState
*bs
, uint64_t offset
,
1432 uint64_t nb_clusters
, enum qcow2_discard_type type
,
1435 BDRVQcow2State
*s
= bs
->opaque
;
1441 ret
= get_cluster_table(bs
, offset
, &l2_table
, &l2_index
);
1446 /* Limit nb_clusters to one L2 table */
1447 nb_clusters
= MIN(nb_clusters
, s
->l2_size
- l2_index
);
1448 assert(nb_clusters
<= INT_MAX
);
1450 for (i
= 0; i
< nb_clusters
; i
++) {
1451 uint64_t old_l2_entry
;
1453 old_l2_entry
= be64_to_cpu(l2_table
[l2_index
+ i
]);
1456 * If full_discard is false, make sure that a discarded area reads back
1457 * as zeroes for v3 images (we cannot do it for v2 without actually
1458 * writing a zero-filled buffer). We can skip the operation if the
1459 * cluster is already marked as zero, or if it's unallocated and we
1460 * don't have a backing file.
1462 * TODO We might want to use bdrv_get_block_status(bs) here, but we're
1463 * holding s->lock, so that doesn't work today.
1465 * If full_discard is true, the sector should not read back as zeroes,
1466 * but rather fall through to the backing file.
1468 switch (qcow2_get_cluster_type(old_l2_entry
)) {
1469 case QCOW2_CLUSTER_UNALLOCATED
:
1470 if (full_discard
|| !bs
->backing
) {
1475 case QCOW2_CLUSTER_ZERO
:
1476 if (!full_discard
) {
1481 case QCOW2_CLUSTER_NORMAL
:
1482 case QCOW2_CLUSTER_COMPRESSED
:
1489 /* First remove L2 entries */
1490 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
, l2_table
);
1491 if (!full_discard
&& s
->qcow_version
>= 3) {
1492 l2_table
[l2_index
+ i
] = cpu_to_be64(QCOW_OFLAG_ZERO
);
1494 l2_table
[l2_index
+ i
] = cpu_to_be64(0);
1497 /* Then decrease the refcount */
1498 qcow2_free_any_clusters(bs
, old_l2_entry
, 1, type
);
1501 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1506 int qcow2_discard_clusters(BlockDriverState
*bs
, uint64_t offset
,
1507 int nb_sectors
, enum qcow2_discard_type type
, bool full_discard
)
1509 BDRVQcow2State
*s
= bs
->opaque
;
1510 uint64_t end_offset
;
1511 uint64_t nb_clusters
;
1514 end_offset
= offset
+ (nb_sectors
<< BDRV_SECTOR_BITS
);
1516 /* Round start up and end down */
1517 offset
= align_offset(offset
, s
->cluster_size
);
1518 end_offset
= start_of_cluster(s
, end_offset
);
1520 if (offset
> end_offset
) {
1524 nb_clusters
= size_to_clusters(s
, end_offset
- offset
);
1526 s
->cache_discards
= true;
1528 /* Each L2 table is handled by its own loop iteration */
1529 while (nb_clusters
> 0) {
1530 ret
= discard_single_l2(bs
, offset
, nb_clusters
, type
, full_discard
);
1536 offset
+= (ret
* s
->cluster_size
);
1541 s
->cache_discards
= false;
1542 qcow2_process_discards(bs
, ret
);
1548 * This zeroes as many clusters of nb_clusters as possible at once (i.e.
1549 * all clusters in the same L2 table) and returns the number of zeroed
1552 static int zero_single_l2(BlockDriverState
*bs
, uint64_t offset
,
1553 uint64_t nb_clusters
)
1555 BDRVQcow2State
*s
= bs
->opaque
;
1561 ret
= get_cluster_table(bs
, offset
, &l2_table
, &l2_index
);
1566 /* Limit nb_clusters to one L2 table */
1567 nb_clusters
= MIN(nb_clusters
, s
->l2_size
- l2_index
);
1568 assert(nb_clusters
<= INT_MAX
);
1570 for (i
= 0; i
< nb_clusters
; i
++) {
1571 uint64_t old_offset
;
1573 old_offset
= be64_to_cpu(l2_table
[l2_index
+ i
]);
1575 /* Update L2 entries */
1576 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
, l2_table
);
1577 if (old_offset
& QCOW_OFLAG_COMPRESSED
) {
1578 l2_table
[l2_index
+ i
] = cpu_to_be64(QCOW_OFLAG_ZERO
);
1579 qcow2_free_any_clusters(bs
, old_offset
, 1, QCOW2_DISCARD_REQUEST
);
1581 l2_table
[l2_index
+ i
] |= cpu_to_be64(QCOW_OFLAG_ZERO
);
1585 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1590 int qcow2_zero_clusters(BlockDriverState
*bs
, uint64_t offset
, int nb_sectors
)
1592 BDRVQcow2State
*s
= bs
->opaque
;
1593 uint64_t nb_clusters
;
1596 /* The zero flag is only supported by version 3 and newer */
1597 if (s
->qcow_version
< 3) {
1601 /* Each L2 table is handled by its own loop iteration */
1602 nb_clusters
= size_to_clusters(s
, nb_sectors
<< BDRV_SECTOR_BITS
);
1604 s
->cache_discards
= true;
1606 while (nb_clusters
> 0) {
1607 ret
= zero_single_l2(bs
, offset
, nb_clusters
);
1613 offset
+= (ret
* s
->cluster_size
);
1618 s
->cache_discards
= false;
1619 qcow2_process_discards(bs
, ret
);
1625 * Expands all zero clusters in a specific L1 table (or deallocates them, for
1626 * non-backed non-pre-allocated zero clusters).
1628 * l1_entries and *visited_l1_entries are used to keep track of progress for
1629 * status_cb(). l1_entries contains the total number of L1 entries and
1630 * *visited_l1_entries counts all visited L1 entries.
1632 static int expand_zero_clusters_in_l1(BlockDriverState
*bs
, uint64_t *l1_table
,
1633 int l1_size
, int64_t *visited_l1_entries
,
1635 BlockDriverAmendStatusCB
*status_cb
,
1638 BDRVQcow2State
*s
= bs
->opaque
;
1639 bool is_active_l1
= (l1_table
== s
->l1_table
);
1640 uint64_t *l2_table
= NULL
;
1644 if (!is_active_l1
) {
1645 /* inactive L2 tables require a buffer to be stored in when loading
1647 l2_table
= qemu_try_blockalign(bs
->file
->bs
, s
->cluster_size
);
1648 if (l2_table
== NULL
) {
1653 for (i
= 0; i
< l1_size
; i
++) {
1654 uint64_t l2_offset
= l1_table
[i
] & L1E_OFFSET_MASK
;
1655 bool l2_dirty
= false;
1656 uint64_t l2_refcount
;
1660 (*visited_l1_entries
)++;
1662 status_cb(bs
, *visited_l1_entries
, l1_entries
, cb_opaque
);
1667 if (offset_into_cluster(s
, l2_offset
)) {
1668 qcow2_signal_corruption(bs
, true, -1, -1, "L2 table offset %#"
1669 PRIx64
" unaligned (L1 index: %#x)",
1676 /* get active L2 tables from cache */
1677 ret
= qcow2_cache_get(bs
, s
->l2_table_cache
, l2_offset
,
1678 (void **)&l2_table
);
1680 /* load inactive L2 tables from disk */
1681 ret
= bdrv_read(bs
->file
, l2_offset
/ BDRV_SECTOR_SIZE
,
1682 (void *)l2_table
, s
->cluster_sectors
);
1688 ret
= qcow2_get_refcount(bs
, l2_offset
>> s
->cluster_bits
,
1694 for (j
= 0; j
< s
->l2_size
; j
++) {
1695 uint64_t l2_entry
= be64_to_cpu(l2_table
[j
]);
1696 int64_t offset
= l2_entry
& L2E_OFFSET_MASK
;
1697 int cluster_type
= qcow2_get_cluster_type(l2_entry
);
1698 bool preallocated
= offset
!= 0;
1700 if (cluster_type
!= QCOW2_CLUSTER_ZERO
) {
1704 if (!preallocated
) {
1706 /* not backed; therefore we can simply deallocate the
1713 offset
= qcow2_alloc_clusters(bs
, s
->cluster_size
);
1719 if (l2_refcount
> 1) {
1720 /* For shared L2 tables, set the refcount accordingly (it is
1721 * already 1 and needs to be l2_refcount) */
1722 ret
= qcow2_update_cluster_refcount(bs
,
1723 offset
>> s
->cluster_bits
,
1724 refcount_diff(1, l2_refcount
), false,
1725 QCOW2_DISCARD_OTHER
);
1727 qcow2_free_clusters(bs
, offset
, s
->cluster_size
,
1728 QCOW2_DISCARD_OTHER
);
1734 if (offset_into_cluster(s
, offset
)) {
1735 qcow2_signal_corruption(bs
, true, -1, -1, "Data cluster offset "
1736 "%#" PRIx64
" unaligned (L2 offset: %#"
1737 PRIx64
", L2 index: %#x)", offset
,
1739 if (!preallocated
) {
1740 qcow2_free_clusters(bs
, offset
, s
->cluster_size
,
1741 QCOW2_DISCARD_ALWAYS
);
1747 ret
= qcow2_pre_write_overlap_check(bs
, 0, offset
, s
->cluster_size
);
1749 if (!preallocated
) {
1750 qcow2_free_clusters(bs
, offset
, s
->cluster_size
,
1751 QCOW2_DISCARD_ALWAYS
);
1756 ret
= bdrv_pwrite_zeroes(bs
->file
, offset
, s
->cluster_size
, 0);
1758 if (!preallocated
) {
1759 qcow2_free_clusters(bs
, offset
, s
->cluster_size
,
1760 QCOW2_DISCARD_ALWAYS
);
1765 if (l2_refcount
== 1) {
1766 l2_table
[j
] = cpu_to_be64(offset
| QCOW_OFLAG_COPIED
);
1768 l2_table
[j
] = cpu_to_be64(offset
);
1775 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
, l2_table
);
1776 qcow2_cache_depends_on_flush(s
->l2_table_cache
);
1778 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1781 ret
= qcow2_pre_write_overlap_check(bs
,
1782 QCOW2_OL_INACTIVE_L2
| QCOW2_OL_ACTIVE_L2
, l2_offset
,
1788 ret
= bdrv_write(bs
->file
, l2_offset
/ BDRV_SECTOR_SIZE
,
1789 (void *)l2_table
, s
->cluster_sectors
);
1796 (*visited_l1_entries
)++;
1798 status_cb(bs
, *visited_l1_entries
, l1_entries
, cb_opaque
);
1806 if (!is_active_l1
) {
1807 qemu_vfree(l2_table
);
1809 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1816 * For backed images, expands all zero clusters on the image. For non-backed
1817 * images, deallocates all non-pre-allocated zero clusters (and claims the
1818 * allocation for pre-allocated ones). This is important for downgrading to a
1819 * qcow2 version which doesn't yet support metadata zero clusters.
1821 int qcow2_expand_zero_clusters(BlockDriverState
*bs
,
1822 BlockDriverAmendStatusCB
*status_cb
,
1825 BDRVQcow2State
*s
= bs
->opaque
;
1826 uint64_t *l1_table
= NULL
;
1827 int64_t l1_entries
= 0, visited_l1_entries
= 0;
1832 l1_entries
= s
->l1_size
;
1833 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
1834 l1_entries
+= s
->snapshots
[i
].l1_size
;
1838 ret
= expand_zero_clusters_in_l1(bs
, s
->l1_table
, s
->l1_size
,
1839 &visited_l1_entries
, l1_entries
,
1840 status_cb
, cb_opaque
);
1845 /* Inactive L1 tables may point to active L2 tables - therefore it is
1846 * necessary to flush the L2 table cache before trying to access the L2
1847 * tables pointed to by inactive L1 entries (else we might try to expand
1848 * zero clusters that have already been expanded); furthermore, it is also
1849 * necessary to empty the L2 table cache, since it may contain tables which
1850 * are now going to be modified directly on disk, bypassing the cache.
1851 * qcow2_cache_empty() does both for us. */
1852 ret
= qcow2_cache_empty(bs
, s
->l2_table_cache
);
1857 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
1858 int l1_sectors
= DIV_ROUND_UP(s
->snapshots
[i
].l1_size
*
1859 sizeof(uint64_t), BDRV_SECTOR_SIZE
);
1861 l1_table
= g_realloc(l1_table
, l1_sectors
* BDRV_SECTOR_SIZE
);
1863 ret
= bdrv_read(bs
->file
,
1864 s
->snapshots
[i
].l1_table_offset
/ BDRV_SECTOR_SIZE
,
1865 (void *)l1_table
, l1_sectors
);
1870 for (j
= 0; j
< s
->snapshots
[i
].l1_size
; j
++) {
1871 be64_to_cpus(&l1_table
[j
]);
1874 ret
= expand_zero_clusters_in_l1(bs
, l1_table
, s
->snapshots
[i
].l1_size
,
1875 &visited_l1_entries
, l1_entries
,
1876 status_cb
, cb_opaque
);