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"
26 #include "qapi/error.h"
27 #include "qemu-common.h"
28 #include "block/block_int.h"
29 #include "block/qcow2.h"
30 #include "qemu/range.h"
31 #include "qemu/bswap.h"
32 #include "qemu/cutils.h"
34 static int64_t alloc_clusters_noref(BlockDriverState
*bs
, uint64_t size
);
35 static int QEMU_WARN_UNUSED_RESULT
update_refcount(BlockDriverState
*bs
,
36 int64_t offset
, int64_t length
, uint64_t addend
,
37 bool decrease
, enum qcow2_discard_type type
);
39 static uint64_t get_refcount_ro0(const void *refcount_array
, uint64_t index
);
40 static uint64_t get_refcount_ro1(const void *refcount_array
, uint64_t index
);
41 static uint64_t get_refcount_ro2(const void *refcount_array
, uint64_t index
);
42 static uint64_t get_refcount_ro3(const void *refcount_array
, uint64_t index
);
43 static uint64_t get_refcount_ro4(const void *refcount_array
, uint64_t index
);
44 static uint64_t get_refcount_ro5(const void *refcount_array
, uint64_t index
);
45 static uint64_t get_refcount_ro6(const void *refcount_array
, uint64_t index
);
47 static void set_refcount_ro0(void *refcount_array
, uint64_t index
,
49 static void set_refcount_ro1(void *refcount_array
, uint64_t index
,
51 static void set_refcount_ro2(void *refcount_array
, uint64_t index
,
53 static void set_refcount_ro3(void *refcount_array
, uint64_t index
,
55 static void set_refcount_ro4(void *refcount_array
, uint64_t index
,
57 static void set_refcount_ro5(void *refcount_array
, uint64_t index
,
59 static void set_refcount_ro6(void *refcount_array
, uint64_t index
,
63 static Qcow2GetRefcountFunc
*const get_refcount_funcs
[] = {
73 static Qcow2SetRefcountFunc
*const set_refcount_funcs
[] = {
84 /*********************************************************/
85 /* refcount handling */
87 static void update_max_refcount_table_index(BDRVQcow2State
*s
)
89 unsigned i
= s
->refcount_table_size
- 1;
90 while (i
> 0 && (s
->refcount_table
[i
] & REFT_OFFSET_MASK
) == 0) {
93 /* Set s->max_refcount_table_index to the index of the last used entry */
94 s
->max_refcount_table_index
= i
;
97 int qcow2_refcount_init(BlockDriverState
*bs
)
99 BDRVQcow2State
*s
= bs
->opaque
;
100 unsigned int refcount_table_size2
, i
;
103 assert(s
->refcount_order
>= 0 && s
->refcount_order
<= 6);
105 s
->get_refcount
= get_refcount_funcs
[s
->refcount_order
];
106 s
->set_refcount
= set_refcount_funcs
[s
->refcount_order
];
108 assert(s
->refcount_table_size
<= INT_MAX
/ sizeof(uint64_t));
109 refcount_table_size2
= s
->refcount_table_size
* sizeof(uint64_t);
110 s
->refcount_table
= g_try_malloc(refcount_table_size2
);
112 if (s
->refcount_table_size
> 0) {
113 if (s
->refcount_table
== NULL
) {
117 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_LOAD
);
118 ret
= bdrv_pread(bs
->file
, s
->refcount_table_offset
,
119 s
->refcount_table
, refcount_table_size2
);
123 for(i
= 0; i
< s
->refcount_table_size
; i
++)
124 be64_to_cpus(&s
->refcount_table
[i
]);
125 update_max_refcount_table_index(s
);
132 void qcow2_refcount_close(BlockDriverState
*bs
)
134 BDRVQcow2State
*s
= bs
->opaque
;
135 g_free(s
->refcount_table
);
139 static uint64_t get_refcount_ro0(const void *refcount_array
, uint64_t index
)
141 return (((const uint8_t *)refcount_array
)[index
/ 8] >> (index
% 8)) & 0x1;
144 static void set_refcount_ro0(void *refcount_array
, uint64_t index
,
147 assert(!(value
>> 1));
148 ((uint8_t *)refcount_array
)[index
/ 8] &= ~(0x1 << (index
% 8));
149 ((uint8_t *)refcount_array
)[index
/ 8] |= value
<< (index
% 8);
152 static uint64_t get_refcount_ro1(const void *refcount_array
, uint64_t index
)
154 return (((const uint8_t *)refcount_array
)[index
/ 4] >> (2 * (index
% 4)))
158 static void set_refcount_ro1(void *refcount_array
, uint64_t index
,
161 assert(!(value
>> 2));
162 ((uint8_t *)refcount_array
)[index
/ 4] &= ~(0x3 << (2 * (index
% 4)));
163 ((uint8_t *)refcount_array
)[index
/ 4] |= value
<< (2 * (index
% 4));
166 static uint64_t get_refcount_ro2(const void *refcount_array
, uint64_t index
)
168 return (((const uint8_t *)refcount_array
)[index
/ 2] >> (4 * (index
% 2)))
172 static void set_refcount_ro2(void *refcount_array
, uint64_t index
,
175 assert(!(value
>> 4));
176 ((uint8_t *)refcount_array
)[index
/ 2] &= ~(0xf << (4 * (index
% 2)));
177 ((uint8_t *)refcount_array
)[index
/ 2] |= value
<< (4 * (index
% 2));
180 static uint64_t get_refcount_ro3(const void *refcount_array
, uint64_t index
)
182 return ((const uint8_t *)refcount_array
)[index
];
185 static void set_refcount_ro3(void *refcount_array
, uint64_t index
,
188 assert(!(value
>> 8));
189 ((uint8_t *)refcount_array
)[index
] = value
;
192 static uint64_t get_refcount_ro4(const void *refcount_array
, uint64_t index
)
194 return be16_to_cpu(((const uint16_t *)refcount_array
)[index
]);
197 static void set_refcount_ro4(void *refcount_array
, uint64_t index
,
200 assert(!(value
>> 16));
201 ((uint16_t *)refcount_array
)[index
] = cpu_to_be16(value
);
204 static uint64_t get_refcount_ro5(const void *refcount_array
, uint64_t index
)
206 return be32_to_cpu(((const uint32_t *)refcount_array
)[index
]);
209 static void set_refcount_ro5(void *refcount_array
, uint64_t index
,
212 assert(!(value
>> 32));
213 ((uint32_t *)refcount_array
)[index
] = cpu_to_be32(value
);
216 static uint64_t get_refcount_ro6(const void *refcount_array
, uint64_t index
)
218 return be64_to_cpu(((const uint64_t *)refcount_array
)[index
]);
221 static void set_refcount_ro6(void *refcount_array
, uint64_t index
,
224 ((uint64_t *)refcount_array
)[index
] = cpu_to_be64(value
);
228 static int load_refcount_block(BlockDriverState
*bs
,
229 int64_t refcount_block_offset
,
230 void **refcount_block
)
232 BDRVQcow2State
*s
= bs
->opaque
;
234 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_LOAD
);
235 return qcow2_cache_get(bs
, s
->refcount_block_cache
, refcount_block_offset
,
240 * Retrieves the refcount of the cluster given by its index and stores it in
241 * *refcount. Returns 0 on success and -errno on failure.
243 int qcow2_get_refcount(BlockDriverState
*bs
, int64_t cluster_index
,
246 BDRVQcow2State
*s
= bs
->opaque
;
247 uint64_t refcount_table_index
, block_index
;
248 int64_t refcount_block_offset
;
250 void *refcount_block
;
252 refcount_table_index
= cluster_index
>> s
->refcount_block_bits
;
253 if (refcount_table_index
>= s
->refcount_table_size
) {
257 refcount_block_offset
=
258 s
->refcount_table
[refcount_table_index
] & REFT_OFFSET_MASK
;
259 if (!refcount_block_offset
) {
264 if (offset_into_cluster(s
, refcount_block_offset
)) {
265 qcow2_signal_corruption(bs
, true, -1, -1, "Refblock offset %#" PRIx64
266 " unaligned (reftable index: %#" PRIx64
")",
267 refcount_block_offset
, refcount_table_index
);
271 ret
= qcow2_cache_get(bs
, s
->refcount_block_cache
, refcount_block_offset
,
277 block_index
= cluster_index
& (s
->refcount_block_size
- 1);
278 *refcount
= s
->get_refcount(refcount_block
, block_index
);
280 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refcount_block
);
285 /* Checks if two offsets are described by the same refcount block */
286 static int in_same_refcount_block(BDRVQcow2State
*s
, uint64_t offset_a
,
289 uint64_t block_a
= offset_a
>> (s
->cluster_bits
+ s
->refcount_block_bits
);
290 uint64_t block_b
= offset_b
>> (s
->cluster_bits
+ s
->refcount_block_bits
);
292 return (block_a
== block_b
);
296 * Loads a refcount block. If it doesn't exist yet, it is allocated first
297 * (including growing the refcount table if needed).
299 * Returns 0 on success or -errno in error case
301 static int alloc_refcount_block(BlockDriverState
*bs
,
302 int64_t cluster_index
, void **refcount_block
)
304 BDRVQcow2State
*s
= bs
->opaque
;
305 unsigned int refcount_table_index
;
308 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
310 /* Find the refcount block for the given cluster */
311 refcount_table_index
= cluster_index
>> s
->refcount_block_bits
;
313 if (refcount_table_index
< s
->refcount_table_size
) {
315 uint64_t refcount_block_offset
=
316 s
->refcount_table
[refcount_table_index
] & REFT_OFFSET_MASK
;
318 /* If it's already there, we're done */
319 if (refcount_block_offset
) {
320 if (offset_into_cluster(s
, refcount_block_offset
)) {
321 qcow2_signal_corruption(bs
, true, -1, -1, "Refblock offset %#"
322 PRIx64
" unaligned (reftable index: "
323 "%#x)", refcount_block_offset
,
324 refcount_table_index
);
328 return load_refcount_block(bs
, refcount_block_offset
,
334 * If we came here, we need to allocate something. Something is at least
335 * a cluster for the new refcount block. It may also include a new refcount
336 * table if the old refcount table is too small.
338 * Note that allocating clusters here needs some special care:
340 * - We can't use the normal qcow2_alloc_clusters(), it would try to
341 * increase the refcount and very likely we would end up with an endless
342 * recursion. Instead we must place the refcount blocks in a way that
343 * they can describe them themselves.
345 * - We need to consider that at this point we are inside update_refcounts
346 * and potentially doing an initial refcount increase. This means that
347 * some clusters have already been allocated by the caller, but their
348 * refcount isn't accurate yet. If we allocate clusters for metadata, we
349 * need to return -EAGAIN to signal the caller that it needs to restart
350 * the search for free clusters.
352 * - alloc_clusters_noref and qcow2_free_clusters may load a different
353 * refcount block into the cache
356 *refcount_block
= NULL
;
358 /* We write to the refcount table, so we might depend on L2 tables */
359 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
364 /* Allocate the refcount block itself and mark it as used */
365 int64_t new_block
= alloc_clusters_noref(bs
, s
->cluster_size
);
370 /* If we're allocating the block at offset 0 then something is wrong */
371 if (new_block
== 0) {
372 qcow2_signal_corruption(bs
, true, -1, -1, "Preventing invalid "
373 "allocation of refcount block at offset 0");
378 fprintf(stderr
, "qcow2: Allocate refcount block %d for %" PRIx64
380 refcount_table_index
, cluster_index
<< s
->cluster_bits
, new_block
);
383 if (in_same_refcount_block(s
, new_block
, cluster_index
<< s
->cluster_bits
)) {
384 /* Zero the new refcount block before updating it */
385 ret
= qcow2_cache_get_empty(bs
, s
->refcount_block_cache
, new_block
,
391 memset(*refcount_block
, 0, s
->cluster_size
);
393 /* The block describes itself, need to update the cache */
394 int block_index
= (new_block
>> s
->cluster_bits
) &
395 (s
->refcount_block_size
- 1);
396 s
->set_refcount(*refcount_block
, block_index
, 1);
398 /* Described somewhere else. This can recurse at most twice before we
399 * arrive at a block that describes itself. */
400 ret
= update_refcount(bs
, new_block
, s
->cluster_size
, 1, false,
401 QCOW2_DISCARD_NEVER
);
406 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
411 /* Initialize the new refcount block only after updating its refcount,
412 * update_refcount uses the refcount cache itself */
413 ret
= qcow2_cache_get_empty(bs
, s
->refcount_block_cache
, new_block
,
419 memset(*refcount_block
, 0, s
->cluster_size
);
422 /* Now the new refcount block needs to be written to disk */
423 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_WRITE
);
424 qcow2_cache_entry_mark_dirty(bs
, s
->refcount_block_cache
, *refcount_block
);
425 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
430 /* If the refcount table is big enough, just hook the block up there */
431 if (refcount_table_index
< s
->refcount_table_size
) {
432 uint64_t data64
= cpu_to_be64(new_block
);
433 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_HOOKUP
);
434 ret
= bdrv_pwrite_sync(bs
->file
,
435 s
->refcount_table_offset
+ refcount_table_index
* sizeof(uint64_t),
436 &data64
, sizeof(data64
));
441 s
->refcount_table
[refcount_table_index
] = new_block
;
442 /* If there's a hole in s->refcount_table then it can happen
443 * that refcount_table_index < s->max_refcount_table_index */
444 s
->max_refcount_table_index
=
445 MAX(s
->max_refcount_table_index
, refcount_table_index
);
447 /* The new refcount block may be where the caller intended to put its
448 * data, so let it restart the search. */
452 qcow2_cache_put(bs
, s
->refcount_block_cache
, refcount_block
);
455 * If we come here, we need to grow the refcount table. Again, a new
456 * refcount table needs some space and we can't simply allocate to avoid
459 * Therefore let's grab new refcount blocks at the end of the image, which
460 * will describe themselves and the new refcount table. This way we can
461 * reference them only in the new table and do the switch to the new
462 * refcount table at once without producing an inconsistent state in
465 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_GROW
);
467 /* Calculate the number of refcount blocks needed so far; this will be the
468 * basis for calculating the index of the first cluster used for the
469 * self-describing refcount structures which we are about to create.
471 * Because we reached this point, there cannot be any refcount entries for
472 * cluster_index or higher indices yet. However, because new_block has been
473 * allocated to describe that cluster (and it will assume this role later
474 * on), we cannot use that index; also, new_block may actually have a higher
475 * cluster index than cluster_index, so it needs to be taken into account
476 * here (and 1 needs to be added to its value because that cluster is used).
478 uint64_t blocks_used
= DIV_ROUND_UP(MAX(cluster_index
+ 1,
479 (new_block
>> s
->cluster_bits
) + 1),
480 s
->refcount_block_size
);
482 /* Create the new refcount table and blocks */
483 uint64_t meta_offset
= (blocks_used
* s
->refcount_block_size
) *
486 ret
= qcow2_refcount_area(bs
, meta_offset
, 0, false,
487 refcount_table_index
, new_block
);
492 ret
= load_refcount_block(bs
, new_block
, refcount_block
);
497 /* If we were trying to do the initial refcount update for some cluster
498 * allocation, we might have used the same clusters to store newly
499 * allocated metadata. Make the caller search some new space. */
503 if (*refcount_block
!= NULL
) {
504 qcow2_cache_put(bs
, s
->refcount_block_cache
, refcount_block
);
510 * Starting at @start_offset, this function creates new self-covering refcount
511 * structures: A new refcount table and refcount blocks which cover all of
512 * themselves, and a number of @additional_clusters beyond their end.
513 * @start_offset must be at the end of the image file, that is, there must be
514 * only empty space beyond it.
515 * If @exact_size is false, the refcount table will have 50 % more entries than
516 * necessary so it will not need to grow again soon.
517 * If @new_refblock_offset is not zero, it contains the offset of a refcount
518 * block that should be entered into the new refcount table at index
519 * @new_refblock_index.
521 * Returns: The offset after the new refcount structures (i.e. where the
522 * @additional_clusters may be placed) on success, -errno on error.
524 int64_t qcow2_refcount_area(BlockDriverState
*bs
, uint64_t start_offset
,
525 uint64_t additional_clusters
, bool exact_size
,
526 int new_refblock_index
,
527 uint64_t new_refblock_offset
)
529 BDRVQcow2State
*s
= bs
->opaque
;
530 uint64_t total_refblock_count_u64
, additional_refblock_count
;
531 int total_refblock_count
, table_size
, area_reftable_index
, table_clusters
;
533 uint64_t table_offset
, block_offset
, end_offset
;
537 assert(!(start_offset
% s
->cluster_size
));
539 qcow2_refcount_metadata_size(start_offset
/ s
->cluster_size
+
541 s
->cluster_size
, s
->refcount_order
,
542 !exact_size
, &total_refblock_count_u64
);
543 if (total_refblock_count_u64
> QCOW_MAX_REFTABLE_SIZE
) {
546 total_refblock_count
= total_refblock_count_u64
;
548 /* Index in the refcount table of the first refcount block to cover the area
549 * of refcount structures we are about to create; we know that
550 * @total_refblock_count can cover @start_offset, so this will definitely
551 * fit into an int. */
552 area_reftable_index
= (start_offset
/ s
->cluster_size
) /
553 s
->refcount_block_size
;
556 table_size
= total_refblock_count
;
558 table_size
= total_refblock_count
+
559 DIV_ROUND_UP(total_refblock_count
, 2);
561 /* The qcow2 file can only store the reftable size in number of clusters */
562 table_size
= ROUND_UP(table_size
, s
->cluster_size
/ sizeof(uint64_t));
563 table_clusters
= (table_size
* sizeof(uint64_t)) / s
->cluster_size
;
565 if (table_size
> QCOW_MAX_REFTABLE_SIZE
) {
569 new_table
= g_try_new0(uint64_t, table_size
);
571 assert(table_size
> 0);
572 if (new_table
== NULL
) {
577 /* Fill the new refcount table */
578 if (table_size
> s
->max_refcount_table_index
) {
579 /* We're actually growing the reftable */
580 memcpy(new_table
, s
->refcount_table
,
581 (s
->max_refcount_table_index
+ 1) * sizeof(uint64_t));
583 /* Improbable case: We're shrinking the reftable. However, the caller
584 * has assured us that there is only empty space beyond @start_offset,
585 * so we can simply drop all of the refblocks that won't fit into the
587 memcpy(new_table
, s
->refcount_table
, table_size
* sizeof(uint64_t));
590 if (new_refblock_offset
) {
591 assert(new_refblock_index
< total_refblock_count
);
592 new_table
[new_refblock_index
] = new_refblock_offset
;
595 /* Count how many new refblocks we have to create */
596 additional_refblock_count
= 0;
597 for (i
= area_reftable_index
; i
< total_refblock_count
; i
++) {
599 additional_refblock_count
++;
603 table_offset
= start_offset
+ additional_refblock_count
* s
->cluster_size
;
604 end_offset
= table_offset
+ table_clusters
* s
->cluster_size
;
606 /* Fill the refcount blocks, and create new ones, if necessary */
607 block_offset
= start_offset
;
608 for (i
= area_reftable_index
; i
< total_refblock_count
; i
++) {
610 uint64_t first_offset_covered
;
612 /* Reuse an existing refblock if possible, create a new one otherwise */
614 ret
= qcow2_cache_get(bs
, s
->refcount_block_cache
, new_table
[i
],
620 ret
= qcow2_cache_get_empty(bs
, s
->refcount_block_cache
,
621 block_offset
, &refblock_data
);
625 memset(refblock_data
, 0, s
->cluster_size
);
626 qcow2_cache_entry_mark_dirty(bs
, s
->refcount_block_cache
,
629 new_table
[i
] = block_offset
;
630 block_offset
+= s
->cluster_size
;
633 /* First host offset covered by this refblock */
634 first_offset_covered
= (uint64_t)i
* s
->refcount_block_size
*
636 if (first_offset_covered
< end_offset
) {
639 /* Set the refcount of all of the new refcount structures to 1 */
641 if (first_offset_covered
< start_offset
) {
642 assert(i
== area_reftable_index
);
643 j
= (start_offset
- first_offset_covered
) / s
->cluster_size
;
644 assert(j
< s
->refcount_block_size
);
649 end_index
= MIN((end_offset
- first_offset_covered
) /
651 s
->refcount_block_size
);
653 for (; j
< end_index
; j
++) {
654 /* The caller guaranteed us this space would be empty */
655 assert(s
->get_refcount(refblock_data
, j
) == 0);
656 s
->set_refcount(refblock_data
, j
, 1);
659 qcow2_cache_entry_mark_dirty(bs
, s
->refcount_block_cache
,
663 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock_data
);
666 assert(block_offset
== table_offset
);
668 /* Write refcount blocks to disk */
669 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS
);
670 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
675 /* Write refcount table to disk */
676 for (i
= 0; i
< total_refblock_count
; i
++) {
677 cpu_to_be64s(&new_table
[i
]);
680 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE
);
681 ret
= bdrv_pwrite_sync(bs
->file
, table_offset
, new_table
,
682 table_size
* sizeof(uint64_t));
687 for (i
= 0; i
< total_refblock_count
; i
++) {
688 be64_to_cpus(&new_table
[i
]);
691 /* Hook up the new refcount table in the qcow2 header */
696 data
.d64
= cpu_to_be64(table_offset
);
697 data
.d32
= cpu_to_be32(table_clusters
);
698 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE
);
699 ret
= bdrv_pwrite_sync(bs
->file
,
700 offsetof(QCowHeader
, refcount_table_offset
),
701 &data
, sizeof(data
));
706 /* And switch it in memory */
707 uint64_t old_table_offset
= s
->refcount_table_offset
;
708 uint64_t old_table_size
= s
->refcount_table_size
;
710 g_free(s
->refcount_table
);
711 s
->refcount_table
= new_table
;
712 s
->refcount_table_size
= table_size
;
713 s
->refcount_table_offset
= table_offset
;
714 update_max_refcount_table_index(s
);
716 /* Free old table. */
717 qcow2_free_clusters(bs
, old_table_offset
, old_table_size
* sizeof(uint64_t),
718 QCOW2_DISCARD_OTHER
);
727 void qcow2_process_discards(BlockDriverState
*bs
, int ret
)
729 BDRVQcow2State
*s
= bs
->opaque
;
730 Qcow2DiscardRegion
*d
, *next
;
732 QTAILQ_FOREACH_SAFE(d
, &s
->discards
, next
, next
) {
733 QTAILQ_REMOVE(&s
->discards
, d
, next
);
735 /* Discard is optional, ignore the return value */
737 bdrv_pdiscard(bs
->file
->bs
, d
->offset
, d
->bytes
);
744 static void update_refcount_discard(BlockDriverState
*bs
,
745 uint64_t offset
, uint64_t length
)
747 BDRVQcow2State
*s
= bs
->opaque
;
748 Qcow2DiscardRegion
*d
, *p
, *next
;
750 QTAILQ_FOREACH(d
, &s
->discards
, next
) {
751 uint64_t new_start
= MIN(offset
, d
->offset
);
752 uint64_t new_end
= MAX(offset
+ length
, d
->offset
+ d
->bytes
);
754 if (new_end
- new_start
<= length
+ d
->bytes
) {
755 /* There can't be any overlap, areas ending up here have no
756 * references any more and therefore shouldn't get freed another
758 assert(d
->bytes
+ length
== new_end
- new_start
);
759 d
->offset
= new_start
;
760 d
->bytes
= new_end
- new_start
;
765 d
= g_malloc(sizeof(*d
));
766 *d
= (Qcow2DiscardRegion
) {
771 QTAILQ_INSERT_TAIL(&s
->discards
, d
, next
);
774 /* Merge discard requests if they are adjacent now */
775 QTAILQ_FOREACH_SAFE(p
, &s
->discards
, next
, next
) {
777 || p
->offset
> d
->offset
+ d
->bytes
778 || d
->offset
> p
->offset
+ p
->bytes
)
783 /* Still no overlap possible */
784 assert(p
->offset
== d
->offset
+ d
->bytes
785 || d
->offset
== p
->offset
+ p
->bytes
);
787 QTAILQ_REMOVE(&s
->discards
, p
, next
);
788 d
->offset
= MIN(d
->offset
, p
->offset
);
789 d
->bytes
+= p
->bytes
;
794 /* XXX: cache several refcount block clusters ? */
795 /* @addend is the absolute value of the addend; if @decrease is set, @addend
796 * will be subtracted from the current refcount, otherwise it will be added */
797 static int QEMU_WARN_UNUSED_RESULT
update_refcount(BlockDriverState
*bs
,
802 enum qcow2_discard_type type
)
804 BDRVQcow2State
*s
= bs
->opaque
;
805 int64_t start
, last
, cluster_offset
;
806 void *refcount_block
= NULL
;
807 int64_t old_table_index
= -1;
811 fprintf(stderr
, "update_refcount: offset=%" PRId64
" size=%" PRId64
812 " addend=%s%" PRIu64
"\n", offset
, length
, decrease
? "-" : "",
817 } else if (length
== 0) {
822 qcow2_cache_set_dependency(bs
, s
->refcount_block_cache
,
826 start
= start_of_cluster(s
, offset
);
827 last
= start_of_cluster(s
, offset
+ length
- 1);
828 for(cluster_offset
= start
; cluster_offset
<= last
;
829 cluster_offset
+= s
->cluster_size
)
833 int64_t cluster_index
= cluster_offset
>> s
->cluster_bits
;
834 int64_t table_index
= cluster_index
>> s
->refcount_block_bits
;
836 /* Load the refcount block and allocate it if needed */
837 if (table_index
!= old_table_index
) {
838 if (refcount_block
) {
839 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refcount_block
);
841 ret
= alloc_refcount_block(bs
, cluster_index
, &refcount_block
);
846 old_table_index
= table_index
;
848 qcow2_cache_entry_mark_dirty(bs
, s
->refcount_block_cache
,
851 /* we can update the count and save it */
852 block_index
= cluster_index
& (s
->refcount_block_size
- 1);
854 refcount
= s
->get_refcount(refcount_block
, block_index
);
855 if (decrease
? (refcount
- addend
> refcount
)
856 : (refcount
+ addend
< refcount
||
857 refcount
+ addend
> s
->refcount_max
))
867 if (refcount
== 0 && cluster_index
< s
->free_cluster_index
) {
868 s
->free_cluster_index
= cluster_index
;
870 s
->set_refcount(refcount_block
, block_index
, refcount
);
875 table
= qcow2_cache_is_table_offset(bs
, s
->refcount_block_cache
,
878 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refcount_block
);
879 qcow2_cache_discard(bs
, s
->refcount_block_cache
, table
);
882 table
= qcow2_cache_is_table_offset(bs
, s
->l2_table_cache
, offset
);
884 qcow2_cache_discard(bs
, s
->l2_table_cache
, table
);
887 if (s
->discard_passthrough
[type
]) {
888 update_refcount_discard(bs
, cluster_offset
, s
->cluster_size
);
895 if (!s
->cache_discards
) {
896 qcow2_process_discards(bs
, ret
);
899 /* Write last changed block to disk */
900 if (refcount_block
) {
901 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refcount_block
);
905 * Try do undo any updates if an error is returned (This may succeed in
906 * some cases like ENOSPC for allocating a new refcount block)
910 dummy
= update_refcount(bs
, offset
, cluster_offset
- offset
, addend
,
911 !decrease
, QCOW2_DISCARD_NEVER
);
919 * Increases or decreases the refcount of a given cluster.
921 * @addend is the absolute value of the addend; if @decrease is set, @addend
922 * will be subtracted from the current refcount, otherwise it will be added.
924 * On success 0 is returned; on failure -errno is returned.
926 int qcow2_update_cluster_refcount(BlockDriverState
*bs
,
927 int64_t cluster_index
,
928 uint64_t addend
, bool decrease
,
929 enum qcow2_discard_type type
)
931 BDRVQcow2State
*s
= bs
->opaque
;
934 ret
= update_refcount(bs
, cluster_index
<< s
->cluster_bits
, 1, addend
,
945 /*********************************************************/
946 /* cluster allocation functions */
950 /* return < 0 if error */
951 static int64_t alloc_clusters_noref(BlockDriverState
*bs
, uint64_t size
)
953 BDRVQcow2State
*s
= bs
->opaque
;
954 uint64_t i
, nb_clusters
, refcount
;
957 /* We can't allocate clusters if they may still be queued for discard. */
958 if (s
->cache_discards
) {
959 qcow2_process_discards(bs
, 0);
962 nb_clusters
= size_to_clusters(s
, size
);
964 for(i
= 0; i
< nb_clusters
; i
++) {
965 uint64_t next_cluster_index
= s
->free_cluster_index
++;
966 ret
= qcow2_get_refcount(bs
, next_cluster_index
, &refcount
);
970 } else if (refcount
!= 0) {
975 /* Make sure that all offsets in the "allocated" range are representable
977 if (s
->free_cluster_index
> 0 &&
978 s
->free_cluster_index
- 1 > (INT64_MAX
>> s
->cluster_bits
))
984 fprintf(stderr
, "alloc_clusters: size=%" PRId64
" -> %" PRId64
"\n",
986 (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
);
988 return (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
;
991 int64_t qcow2_alloc_clusters(BlockDriverState
*bs
, uint64_t size
)
996 BLKDBG_EVENT(bs
->file
, BLKDBG_CLUSTER_ALLOC
);
998 offset
= alloc_clusters_noref(bs
, size
);
1003 ret
= update_refcount(bs
, offset
, size
, 1, false, QCOW2_DISCARD_NEVER
);
1004 } while (ret
== -EAGAIN
);
1013 int64_t qcow2_alloc_clusters_at(BlockDriverState
*bs
, uint64_t offset
,
1014 int64_t nb_clusters
)
1016 BDRVQcow2State
*s
= bs
->opaque
;
1017 uint64_t cluster_index
, refcount
;
1021 assert(nb_clusters
>= 0);
1022 if (nb_clusters
== 0) {
1027 /* Check how many clusters there are free */
1028 cluster_index
= offset
>> s
->cluster_bits
;
1029 for(i
= 0; i
< nb_clusters
; i
++) {
1030 ret
= qcow2_get_refcount(bs
, cluster_index
++, &refcount
);
1033 } else if (refcount
!= 0) {
1038 /* And then allocate them */
1039 ret
= update_refcount(bs
, offset
, i
<< s
->cluster_bits
, 1, false,
1040 QCOW2_DISCARD_NEVER
);
1041 } while (ret
== -EAGAIN
);
1050 /* only used to allocate compressed sectors. We try to allocate
1051 contiguous sectors. size must be <= cluster_size */
1052 int64_t qcow2_alloc_bytes(BlockDriverState
*bs
, int size
)
1054 BDRVQcow2State
*s
= bs
->opaque
;
1056 size_t free_in_cluster
;
1059 BLKDBG_EVENT(bs
->file
, BLKDBG_CLUSTER_ALLOC_BYTES
);
1060 assert(size
> 0 && size
<= s
->cluster_size
);
1061 assert(!s
->free_byte_offset
|| offset_into_cluster(s
, s
->free_byte_offset
));
1063 offset
= s
->free_byte_offset
;
1067 ret
= qcow2_get_refcount(bs
, offset
>> s
->cluster_bits
, &refcount
);
1072 if (refcount
== s
->refcount_max
) {
1077 free_in_cluster
= s
->cluster_size
- offset_into_cluster(s
, offset
);
1079 if (!offset
|| free_in_cluster
< size
) {
1080 int64_t new_cluster
= alloc_clusters_noref(bs
, s
->cluster_size
);
1081 if (new_cluster
< 0) {
1085 if (!offset
|| ROUND_UP(offset
, s
->cluster_size
) != new_cluster
) {
1086 offset
= new_cluster
;
1087 free_in_cluster
= s
->cluster_size
;
1089 free_in_cluster
+= s
->cluster_size
;
1094 ret
= update_refcount(bs
, offset
, size
, 1, false, QCOW2_DISCARD_NEVER
);
1098 } while (ret
== -EAGAIN
);
1103 /* The cluster refcount was incremented; refcount blocks must be flushed
1104 * before the caller's L2 table updates. */
1105 qcow2_cache_set_dependency(bs
, s
->l2_table_cache
, s
->refcount_block_cache
);
1107 s
->free_byte_offset
= offset
+ size
;
1108 if (!offset_into_cluster(s
, s
->free_byte_offset
)) {
1109 s
->free_byte_offset
= 0;
1115 void qcow2_free_clusters(BlockDriverState
*bs
,
1116 int64_t offset
, int64_t size
,
1117 enum qcow2_discard_type type
)
1121 BLKDBG_EVENT(bs
->file
, BLKDBG_CLUSTER_FREE
);
1122 ret
= update_refcount(bs
, offset
, size
, 1, true, type
);
1124 fprintf(stderr
, "qcow2_free_clusters failed: %s\n", strerror(-ret
));
1125 /* TODO Remember the clusters to free them later and avoid leaking */
1130 * Free a cluster using its L2 entry (handles clusters of all types, e.g.
1131 * normal cluster, compressed cluster, etc.)
1133 void qcow2_free_any_clusters(BlockDriverState
*bs
, uint64_t l2_entry
,
1134 int nb_clusters
, enum qcow2_discard_type type
)
1136 BDRVQcow2State
*s
= bs
->opaque
;
1138 switch (qcow2_get_cluster_type(l2_entry
)) {
1139 case QCOW2_CLUSTER_COMPRESSED
:
1142 nb_csectors
= ((l2_entry
>> s
->csize_shift
) &
1144 qcow2_free_clusters(bs
,
1145 (l2_entry
& s
->cluster_offset_mask
) & ~511,
1146 nb_csectors
* 512, type
);
1149 case QCOW2_CLUSTER_NORMAL
:
1150 case QCOW2_CLUSTER_ZERO_ALLOC
:
1151 if (offset_into_cluster(s
, l2_entry
& L2E_OFFSET_MASK
)) {
1152 qcow2_signal_corruption(bs
, false, -1, -1,
1153 "Cannot free unaligned cluster %#llx",
1154 l2_entry
& L2E_OFFSET_MASK
);
1156 qcow2_free_clusters(bs
, l2_entry
& L2E_OFFSET_MASK
,
1157 nb_clusters
<< s
->cluster_bits
, type
);
1160 case QCOW2_CLUSTER_ZERO_PLAIN
:
1161 case QCOW2_CLUSTER_UNALLOCATED
:
1170 /*********************************************************/
1171 /* snapshots and image creation */
1175 /* update the refcounts of snapshots and the copied flag */
1176 int qcow2_update_snapshot_refcount(BlockDriverState
*bs
,
1177 int64_t l1_table_offset
, int l1_size
, int addend
)
1179 BDRVQcow2State
*s
= bs
->opaque
;
1180 uint64_t *l1_table
, *l2_table
, l2_offset
, entry
, l1_size2
, refcount
;
1181 bool l1_allocated
= false;
1182 int64_t old_entry
, old_l2_offset
;
1183 int i
, j
, l1_modified
= 0, nb_csectors
;
1186 assert(addend
>= -1 && addend
<= 1);
1190 l1_size2
= l1_size
* sizeof(uint64_t);
1192 s
->cache_discards
= true;
1194 /* WARNING: qcow2_snapshot_goto relies on this function not using the
1195 * l1_table_offset when it is the current s->l1_table_offset! Be careful
1196 * when changing this! */
1197 if (l1_table_offset
!= s
->l1_table_offset
) {
1198 l1_table
= g_try_malloc0(align_offset(l1_size2
, 512));
1199 if (l1_size2
&& l1_table
== NULL
) {
1203 l1_allocated
= true;
1205 ret
= bdrv_pread(bs
->file
, l1_table_offset
, l1_table
, l1_size2
);
1210 for (i
= 0; i
< l1_size
; i
++) {
1211 be64_to_cpus(&l1_table
[i
]);
1214 assert(l1_size
== s
->l1_size
);
1215 l1_table
= s
->l1_table
;
1216 l1_allocated
= false;
1219 for (i
= 0; i
< l1_size
; i
++) {
1220 l2_offset
= l1_table
[i
];
1222 old_l2_offset
= l2_offset
;
1223 l2_offset
&= L1E_OFFSET_MASK
;
1225 if (offset_into_cluster(s
, l2_offset
)) {
1226 qcow2_signal_corruption(bs
, true, -1, -1, "L2 table offset %#"
1227 PRIx64
" unaligned (L1 index: %#x)",
1233 ret
= qcow2_cache_get(bs
, s
->l2_table_cache
, l2_offset
,
1234 (void**) &l2_table
);
1239 for (j
= 0; j
< s
->l2_size
; j
++) {
1240 uint64_t cluster_index
;
1243 entry
= be64_to_cpu(l2_table
[j
]);
1245 entry
&= ~QCOW_OFLAG_COPIED
;
1246 offset
= entry
& L2E_OFFSET_MASK
;
1248 switch (qcow2_get_cluster_type(entry
)) {
1249 case QCOW2_CLUSTER_COMPRESSED
:
1250 nb_csectors
= ((entry
>> s
->csize_shift
) &
1253 ret
= update_refcount(bs
,
1254 (entry
& s
->cluster_offset_mask
) & ~511,
1255 nb_csectors
* 512, abs(addend
), addend
< 0,
1256 QCOW2_DISCARD_SNAPSHOT
);
1261 /* compressed clusters are never modified */
1265 case QCOW2_CLUSTER_NORMAL
:
1266 case QCOW2_CLUSTER_ZERO_ALLOC
:
1267 if (offset_into_cluster(s
, offset
)) {
1268 qcow2_signal_corruption(bs
, true, -1, -1, "Cluster "
1269 "allocation offset %#" PRIx64
1270 " unaligned (L2 offset: %#"
1271 PRIx64
", L2 index: %#x)",
1272 offset
, l2_offset
, j
);
1277 cluster_index
= offset
>> s
->cluster_bits
;
1278 assert(cluster_index
);
1280 ret
= qcow2_update_cluster_refcount(bs
,
1281 cluster_index
, abs(addend
), addend
< 0,
1282 QCOW2_DISCARD_SNAPSHOT
);
1288 ret
= qcow2_get_refcount(bs
, cluster_index
, &refcount
);
1294 case QCOW2_CLUSTER_ZERO_PLAIN
:
1295 case QCOW2_CLUSTER_UNALLOCATED
:
1303 if (refcount
== 1) {
1304 entry
|= QCOW_OFLAG_COPIED
;
1306 if (entry
!= old_entry
) {
1308 qcow2_cache_set_dependency(bs
, s
->l2_table_cache
,
1309 s
->refcount_block_cache
);
1311 l2_table
[j
] = cpu_to_be64(entry
);
1312 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
,
1317 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1320 ret
= qcow2_update_cluster_refcount(bs
, l2_offset
>>
1322 abs(addend
), addend
< 0,
1323 QCOW2_DISCARD_SNAPSHOT
);
1328 ret
= qcow2_get_refcount(bs
, l2_offset
>> s
->cluster_bits
,
1332 } else if (refcount
== 1) {
1333 l2_offset
|= QCOW_OFLAG_COPIED
;
1335 if (l2_offset
!= old_l2_offset
) {
1336 l1_table
[i
] = l2_offset
;
1342 ret
= bdrv_flush(bs
);
1345 qcow2_cache_put(bs
, s
->l2_table_cache
, (void**) &l2_table
);
1348 s
->cache_discards
= false;
1349 qcow2_process_discards(bs
, ret
);
1351 /* Update L1 only if it isn't deleted anyway (addend = -1) */
1352 if (ret
== 0 && addend
>= 0 && l1_modified
) {
1353 for (i
= 0; i
< l1_size
; i
++) {
1354 cpu_to_be64s(&l1_table
[i
]);
1357 ret
= bdrv_pwrite_sync(bs
->file
, l1_table_offset
,
1358 l1_table
, l1_size2
);
1360 for (i
= 0; i
< l1_size
; i
++) {
1361 be64_to_cpus(&l1_table
[i
]);
1372 /*********************************************************/
1373 /* refcount checking functions */
1376 static uint64_t refcount_array_byte_size(BDRVQcow2State
*s
, uint64_t entries
)
1378 /* This assertion holds because there is no way we can address more than
1379 * 2^(64 - 9) clusters at once (with cluster size 512 = 2^9, and because
1380 * offsets have to be representable in bytes); due to every cluster
1381 * corresponding to one refcount entry, we are well below that limit */
1382 assert(entries
< (UINT64_C(1) << (64 - 9)));
1384 /* Thanks to the assertion this will not overflow, because
1385 * s->refcount_order < 7.
1386 * (note: x << s->refcount_order == x * s->refcount_bits) */
1387 return DIV_ROUND_UP(entries
<< s
->refcount_order
, 8);
1391 * Reallocates *array so that it can hold new_size entries. *size must contain
1392 * the current number of entries in *array. If the reallocation fails, *array
1393 * and *size will not be modified and -errno will be returned. If the
1394 * reallocation is successful, *array will be set to the new buffer, *size
1395 * will be set to new_size and 0 will be returned. The size of the reallocated
1396 * refcount array buffer will be aligned to a cluster boundary, and the newly
1397 * allocated area will be zeroed.
1399 static int realloc_refcount_array(BDRVQcow2State
*s
, void **array
,
1400 int64_t *size
, int64_t new_size
)
1402 int64_t old_byte_size
, new_byte_size
;
1405 /* Round to clusters so the array can be directly written to disk */
1406 old_byte_size
= size_to_clusters(s
, refcount_array_byte_size(s
, *size
))
1408 new_byte_size
= size_to_clusters(s
, refcount_array_byte_size(s
, new_size
))
1411 if (new_byte_size
== old_byte_size
) {
1416 assert(new_byte_size
> 0);
1418 if (new_byte_size
> SIZE_MAX
) {
1422 new_ptr
= g_try_realloc(*array
, new_byte_size
);
1427 if (new_byte_size
> old_byte_size
) {
1428 memset((char *)new_ptr
+ old_byte_size
, 0,
1429 new_byte_size
- old_byte_size
);
1439 * Increases the refcount for a range of clusters in a given refcount table.
1440 * This is used to construct a temporary refcount table out of L1 and L2 tables
1441 * which can be compared to the refcount table saved in the image.
1443 * Modifies the number of errors in res.
1445 int qcow2_inc_refcounts_imrt(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1446 void **refcount_table
,
1447 int64_t *refcount_table_size
,
1448 int64_t offset
, int64_t size
)
1450 BDRVQcow2State
*s
= bs
->opaque
;
1451 uint64_t start
, last
, cluster_offset
, k
, refcount
;
1458 start
= start_of_cluster(s
, offset
);
1459 last
= start_of_cluster(s
, offset
+ size
- 1);
1460 for(cluster_offset
= start
; cluster_offset
<= last
;
1461 cluster_offset
+= s
->cluster_size
) {
1462 k
= cluster_offset
>> s
->cluster_bits
;
1463 if (k
>= *refcount_table_size
) {
1464 ret
= realloc_refcount_array(s
, refcount_table
,
1465 refcount_table_size
, k
+ 1);
1467 res
->check_errors
++;
1472 refcount
= s
->get_refcount(*refcount_table
, k
);
1473 if (refcount
== s
->refcount_max
) {
1474 fprintf(stderr
, "ERROR: overflow cluster offset=0x%" PRIx64
1475 "\n", cluster_offset
);
1476 fprintf(stderr
, "Use qemu-img amend to increase the refcount entry "
1477 "width or qemu-img convert to create a clean copy if the "
1478 "image cannot be opened for writing\n");
1482 s
->set_refcount(*refcount_table
, k
, refcount
+ 1);
1488 /* Flags for check_refcounts_l1() and check_refcounts_l2() */
1490 CHECK_FRAG_INFO
= 0x2, /* update BlockFragInfo counters */
1494 * Increases the refcount in the given refcount table for the all clusters
1495 * referenced in the L2 table. While doing so, performs some checks on L2
1498 * Returns the number of errors found by the checks or -errno if an internal
1501 static int check_refcounts_l2(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1502 void **refcount_table
,
1503 int64_t *refcount_table_size
, int64_t l2_offset
,
1506 BDRVQcow2State
*s
= bs
->opaque
;
1507 uint64_t *l2_table
, l2_entry
;
1508 uint64_t next_contiguous_offset
= 0;
1509 int i
, l2_size
, nb_csectors
, ret
;
1511 /* Read L2 table from disk */
1512 l2_size
= s
->l2_size
* sizeof(uint64_t);
1513 l2_table
= g_malloc(l2_size
);
1515 ret
= bdrv_pread(bs
->file
, l2_offset
, l2_table
, l2_size
);
1517 fprintf(stderr
, "ERROR: I/O error in check_refcounts_l2\n");
1518 res
->check_errors
++;
1522 /* Do the actual checks */
1523 for(i
= 0; i
< s
->l2_size
; i
++) {
1524 l2_entry
= be64_to_cpu(l2_table
[i
]);
1526 switch (qcow2_get_cluster_type(l2_entry
)) {
1527 case QCOW2_CLUSTER_COMPRESSED
:
1528 /* Compressed clusters don't have QCOW_OFLAG_COPIED */
1529 if (l2_entry
& QCOW_OFLAG_COPIED
) {
1530 fprintf(stderr
, "ERROR: cluster %" PRId64
": "
1531 "copied flag must never be set for compressed "
1532 "clusters\n", l2_entry
>> s
->cluster_bits
);
1533 l2_entry
&= ~QCOW_OFLAG_COPIED
;
1537 /* Mark cluster as used */
1538 nb_csectors
= ((l2_entry
>> s
->csize_shift
) &
1540 l2_entry
&= s
->cluster_offset_mask
;
1541 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
1542 refcount_table
, refcount_table_size
,
1543 l2_entry
& ~511, nb_csectors
* 512);
1548 if (flags
& CHECK_FRAG_INFO
) {
1549 res
->bfi
.allocated_clusters
++;
1550 res
->bfi
.compressed_clusters
++;
1552 /* Compressed clusters are fragmented by nature. Since they
1553 * take up sub-sector space but we only have sector granularity
1554 * I/O we need to re-read the same sectors even for adjacent
1555 * compressed clusters.
1557 res
->bfi
.fragmented_clusters
++;
1561 case QCOW2_CLUSTER_ZERO_ALLOC
:
1562 case QCOW2_CLUSTER_NORMAL
:
1564 uint64_t offset
= l2_entry
& L2E_OFFSET_MASK
;
1566 if (flags
& CHECK_FRAG_INFO
) {
1567 res
->bfi
.allocated_clusters
++;
1568 if (next_contiguous_offset
&&
1569 offset
!= next_contiguous_offset
) {
1570 res
->bfi
.fragmented_clusters
++;
1572 next_contiguous_offset
= offset
+ s
->cluster_size
;
1575 /* Mark cluster as used */
1576 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
1577 refcount_table
, refcount_table_size
,
1578 offset
, s
->cluster_size
);
1583 /* Correct offsets are cluster aligned */
1584 if (offset_into_cluster(s
, offset
)) {
1585 fprintf(stderr
, "ERROR offset=%" PRIx64
": Cluster is not "
1586 "properly aligned; L2 entry corrupted.\n", offset
);
1592 case QCOW2_CLUSTER_ZERO_PLAIN
:
1593 case QCOW2_CLUSTER_UNALLOCATED
:
1610 * Increases the refcount for the L1 table, its L2 tables and all referenced
1611 * clusters in the given refcount table. While doing so, performs some checks
1612 * on L1 and L2 entries.
1614 * Returns the number of errors found by the checks or -errno if an internal
1617 static int check_refcounts_l1(BlockDriverState
*bs
,
1618 BdrvCheckResult
*res
,
1619 void **refcount_table
,
1620 int64_t *refcount_table_size
,
1621 int64_t l1_table_offset
, int l1_size
,
1624 BDRVQcow2State
*s
= bs
->opaque
;
1625 uint64_t *l1_table
= NULL
, l2_offset
, l1_size2
;
1628 l1_size2
= l1_size
* sizeof(uint64_t);
1630 /* Mark L1 table as used */
1631 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, refcount_table_size
,
1632 l1_table_offset
, l1_size2
);
1637 /* Read L1 table entries from disk */
1639 l1_table
= g_try_malloc(l1_size2
);
1640 if (l1_table
== NULL
) {
1642 res
->check_errors
++;
1645 ret
= bdrv_pread(bs
->file
, l1_table_offset
, l1_table
, l1_size2
);
1647 fprintf(stderr
, "ERROR: I/O error in check_refcounts_l1\n");
1648 res
->check_errors
++;
1651 for(i
= 0;i
< l1_size
; i
++)
1652 be64_to_cpus(&l1_table
[i
]);
1655 /* Do the actual checks */
1656 for(i
= 0; i
< l1_size
; i
++) {
1657 l2_offset
= l1_table
[i
];
1659 /* Mark L2 table as used */
1660 l2_offset
&= L1E_OFFSET_MASK
;
1661 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
1662 refcount_table
, refcount_table_size
,
1663 l2_offset
, s
->cluster_size
);
1668 /* L2 tables are cluster aligned */
1669 if (offset_into_cluster(s
, l2_offset
)) {
1670 fprintf(stderr
, "ERROR l2_offset=%" PRIx64
": Table is not "
1671 "cluster aligned; L1 entry corrupted\n", l2_offset
);
1675 /* Process and check L2 entries */
1676 ret
= check_refcounts_l2(bs
, res
, refcount_table
,
1677 refcount_table_size
, l2_offset
, flags
);
1692 * Checks the OFLAG_COPIED flag for all L1 and L2 entries.
1694 * This function does not print an error message nor does it increment
1695 * check_errors if qcow2_get_refcount fails (this is because such an error will
1696 * have been already detected and sufficiently signaled by the calling function
1697 * (qcow2_check_refcounts) by the time this function is called).
1699 static int check_oflag_copied(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1702 BDRVQcow2State
*s
= bs
->opaque
;
1703 uint64_t *l2_table
= qemu_blockalign(bs
, s
->cluster_size
);
1708 for (i
= 0; i
< s
->l1_size
; i
++) {
1709 uint64_t l1_entry
= s
->l1_table
[i
];
1710 uint64_t l2_offset
= l1_entry
& L1E_OFFSET_MASK
;
1711 bool l2_dirty
= false;
1717 ret
= qcow2_get_refcount(bs
, l2_offset
>> s
->cluster_bits
,
1720 /* don't print message nor increment check_errors */
1723 if ((refcount
== 1) != ((l1_entry
& QCOW_OFLAG_COPIED
) != 0)) {
1724 fprintf(stderr
, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
1725 "l1_entry=%" PRIx64
" refcount=%" PRIu64
"\n",
1726 fix
& BDRV_FIX_ERRORS
? "Repairing" :
1728 i
, l1_entry
, refcount
);
1729 if (fix
& BDRV_FIX_ERRORS
) {
1730 s
->l1_table
[i
] = refcount
== 1
1731 ? l1_entry
| QCOW_OFLAG_COPIED
1732 : l1_entry
& ~QCOW_OFLAG_COPIED
;
1733 ret
= qcow2_write_l1_entry(bs
, i
);
1735 res
->check_errors
++;
1738 res
->corruptions_fixed
++;
1744 ret
= bdrv_pread(bs
->file
, l2_offset
, l2_table
,
1745 s
->l2_size
* sizeof(uint64_t));
1747 fprintf(stderr
, "ERROR: Could not read L2 table: %s\n",
1749 res
->check_errors
++;
1753 for (j
= 0; j
< s
->l2_size
; j
++) {
1754 uint64_t l2_entry
= be64_to_cpu(l2_table
[j
]);
1755 uint64_t data_offset
= l2_entry
& L2E_OFFSET_MASK
;
1756 QCow2ClusterType cluster_type
= qcow2_get_cluster_type(l2_entry
);
1758 if (cluster_type
== QCOW2_CLUSTER_NORMAL
||
1759 cluster_type
== QCOW2_CLUSTER_ZERO_ALLOC
) {
1760 ret
= qcow2_get_refcount(bs
,
1761 data_offset
>> s
->cluster_bits
,
1764 /* don't print message nor increment check_errors */
1767 if ((refcount
== 1) != ((l2_entry
& QCOW_OFLAG_COPIED
) != 0)) {
1768 fprintf(stderr
, "%s OFLAG_COPIED data cluster: "
1769 "l2_entry=%" PRIx64
" refcount=%" PRIu64
"\n",
1770 fix
& BDRV_FIX_ERRORS
? "Repairing" :
1772 l2_entry
, refcount
);
1773 if (fix
& BDRV_FIX_ERRORS
) {
1774 l2_table
[j
] = cpu_to_be64(refcount
== 1
1775 ? l2_entry
| QCOW_OFLAG_COPIED
1776 : l2_entry
& ~QCOW_OFLAG_COPIED
);
1778 res
->corruptions_fixed
++;
1787 ret
= qcow2_pre_write_overlap_check(bs
, QCOW2_OL_ACTIVE_L2
,
1788 l2_offset
, s
->cluster_size
);
1790 fprintf(stderr
, "ERROR: Could not write L2 table; metadata "
1791 "overlap check failed: %s\n", strerror(-ret
));
1792 res
->check_errors
++;
1796 ret
= bdrv_pwrite(bs
->file
, l2_offset
, l2_table
,
1799 fprintf(stderr
, "ERROR: Could not write L2 table: %s\n",
1801 res
->check_errors
++;
1810 qemu_vfree(l2_table
);
1815 * Checks consistency of refblocks and accounts for each refblock in
1818 static int check_refblocks(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1819 BdrvCheckMode fix
, bool *rebuild
,
1820 void **refcount_table
, int64_t *nb_clusters
)
1822 BDRVQcow2State
*s
= bs
->opaque
;
1826 for(i
= 0; i
< s
->refcount_table_size
; i
++) {
1827 uint64_t offset
, cluster
;
1828 offset
= s
->refcount_table
[i
];
1829 cluster
= offset
>> s
->cluster_bits
;
1831 /* Refcount blocks are cluster aligned */
1832 if (offset_into_cluster(s
, offset
)) {
1833 fprintf(stderr
, "ERROR refcount block %" PRId64
" is not "
1834 "cluster aligned; refcount table entry corrupted\n", i
);
1840 if (cluster
>= *nb_clusters
) {
1841 fprintf(stderr
, "%s refcount block %" PRId64
" is outside image\n",
1842 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR", i
);
1844 if (fix
& BDRV_FIX_ERRORS
) {
1845 int64_t new_nb_clusters
;
1846 Error
*local_err
= NULL
;
1848 if (offset
> INT64_MAX
- s
->cluster_size
) {
1853 ret
= bdrv_truncate(bs
->file
, offset
+ s
->cluster_size
,
1854 PREALLOC_MODE_OFF
, &local_err
);
1856 error_report_err(local_err
);
1859 size
= bdrv_getlength(bs
->file
->bs
);
1865 new_nb_clusters
= size_to_clusters(s
, size
);
1866 assert(new_nb_clusters
>= *nb_clusters
);
1868 ret
= realloc_refcount_array(s
, refcount_table
,
1869 nb_clusters
, new_nb_clusters
);
1871 res
->check_errors
++;
1875 if (cluster
>= *nb_clusters
) {
1880 res
->corruptions_fixed
++;
1881 ret
= qcow2_inc_refcounts_imrt(bs
, res
,
1882 refcount_table
, nb_clusters
,
1883 offset
, s
->cluster_size
);
1887 /* No need to check whether the refcount is now greater than 1:
1888 * This area was just allocated and zeroed, so it can only be
1889 * exactly 1 after qcow2_inc_refcounts_imrt() */
1895 fprintf(stderr
, "ERROR could not resize image: %s\n",
1904 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, nb_clusters
,
1905 offset
, s
->cluster_size
);
1909 if (s
->get_refcount(*refcount_table
, cluster
) != 1) {
1910 fprintf(stderr
, "ERROR refcount block %" PRId64
1911 " refcount=%" PRIu64
"\n", i
,
1912 s
->get_refcount(*refcount_table
, cluster
));
1923 * Calculates an in-memory refcount table.
1925 static int calculate_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1926 BdrvCheckMode fix
, bool *rebuild
,
1927 void **refcount_table
, int64_t *nb_clusters
)
1929 BDRVQcow2State
*s
= bs
->opaque
;
1934 if (!*refcount_table
) {
1935 int64_t old_size
= 0;
1936 ret
= realloc_refcount_array(s
, refcount_table
,
1937 &old_size
, *nb_clusters
);
1939 res
->check_errors
++;
1945 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, nb_clusters
,
1946 0, s
->cluster_size
);
1951 /* current L1 table */
1952 ret
= check_refcounts_l1(bs
, res
, refcount_table
, nb_clusters
,
1953 s
->l1_table_offset
, s
->l1_size
, CHECK_FRAG_INFO
);
1959 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
1960 sn
= s
->snapshots
+ i
;
1961 ret
= check_refcounts_l1(bs
, res
, refcount_table
, nb_clusters
,
1962 sn
->l1_table_offset
, sn
->l1_size
, 0);
1967 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, nb_clusters
,
1968 s
->snapshots_offset
, s
->snapshots_size
);
1974 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, nb_clusters
,
1975 s
->refcount_table_offset
,
1976 s
->refcount_table_size
* sizeof(uint64_t));
1982 if (s
->crypto_header
.length
) {
1983 ret
= qcow2_inc_refcounts_imrt(bs
, res
, refcount_table
, nb_clusters
,
1984 s
->crypto_header
.offset
,
1985 s
->crypto_header
.length
);
1992 ret
= qcow2_check_bitmaps_refcounts(bs
, res
, refcount_table
, nb_clusters
);
1997 return check_refblocks(bs
, res
, fix
, rebuild
, refcount_table
, nb_clusters
);
2001 * Compares the actual reference count for each cluster in the image against the
2002 * refcount as reported by the refcount structures on-disk.
2004 static void compare_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
2005 BdrvCheckMode fix
, bool *rebuild
,
2006 int64_t *highest_cluster
,
2007 void *refcount_table
, int64_t nb_clusters
)
2009 BDRVQcow2State
*s
= bs
->opaque
;
2011 uint64_t refcount1
, refcount2
;
2014 for (i
= 0, *highest_cluster
= 0; i
< nb_clusters
; i
++) {
2015 ret
= qcow2_get_refcount(bs
, i
, &refcount1
);
2017 fprintf(stderr
, "Can't get refcount for cluster %" PRId64
": %s\n",
2019 res
->check_errors
++;
2023 refcount2
= s
->get_refcount(refcount_table
, i
);
2025 if (refcount1
> 0 || refcount2
> 0) {
2026 *highest_cluster
= i
;
2029 if (refcount1
!= refcount2
) {
2030 /* Check if we're allowed to fix the mismatch */
2031 int *num_fixed
= NULL
;
2032 if (refcount1
== 0) {
2034 } else if (refcount1
> refcount2
&& (fix
& BDRV_FIX_LEAKS
)) {
2035 num_fixed
= &res
->leaks_fixed
;
2036 } else if (refcount1
< refcount2
&& (fix
& BDRV_FIX_ERRORS
)) {
2037 num_fixed
= &res
->corruptions_fixed
;
2040 fprintf(stderr
, "%s cluster %" PRId64
" refcount=%" PRIu64
2041 " reference=%" PRIu64
"\n",
2042 num_fixed
!= NULL
? "Repairing" :
2043 refcount1
< refcount2
? "ERROR" :
2045 i
, refcount1
, refcount2
);
2048 ret
= update_refcount(bs
, i
<< s
->cluster_bits
, 1,
2049 refcount_diff(refcount1
, refcount2
),
2050 refcount1
> refcount2
,
2051 QCOW2_DISCARD_ALWAYS
);
2058 /* And if we couldn't, print an error */
2059 if (refcount1
< refcount2
) {
2069 * Allocates clusters using an in-memory refcount table (IMRT) in contrast to
2070 * the on-disk refcount structures.
2072 * On input, *first_free_cluster tells where to start looking, and need not
2073 * actually be a free cluster; the returned offset will not be before that
2074 * cluster. On output, *first_free_cluster points to the first gap found, even
2075 * if that gap was too small to be used as the returned offset.
2077 * Note that *first_free_cluster is a cluster index whereas the return value is
2080 static int64_t alloc_clusters_imrt(BlockDriverState
*bs
,
2082 void **refcount_table
,
2083 int64_t *imrt_nb_clusters
,
2084 int64_t *first_free_cluster
)
2086 BDRVQcow2State
*s
= bs
->opaque
;
2087 int64_t cluster
= *first_free_cluster
, i
;
2088 bool first_gap
= true;
2089 int contiguous_free_clusters
;
2092 /* Starting at *first_free_cluster, find a range of at least cluster_count
2093 * continuously free clusters */
2094 for (contiguous_free_clusters
= 0;
2095 cluster
< *imrt_nb_clusters
&&
2096 contiguous_free_clusters
< cluster_count
;
2099 if (!s
->get_refcount(*refcount_table
, cluster
)) {
2100 contiguous_free_clusters
++;
2102 /* If this is the first free cluster found, update
2103 * *first_free_cluster accordingly */
2104 *first_free_cluster
= cluster
;
2107 } else if (contiguous_free_clusters
) {
2108 contiguous_free_clusters
= 0;
2112 /* If contiguous_free_clusters is greater than zero, it contains the number
2113 * of continuously free clusters until the current cluster; the first free
2114 * cluster in the current "gap" is therefore
2115 * cluster - contiguous_free_clusters */
2117 /* If no such range could be found, grow the in-memory refcount table
2118 * accordingly to append free clusters at the end of the image */
2119 if (contiguous_free_clusters
< cluster_count
) {
2120 /* contiguous_free_clusters clusters are already empty at the image end;
2121 * we need cluster_count clusters; therefore, we have to allocate
2122 * cluster_count - contiguous_free_clusters new clusters at the end of
2123 * the image (which is the current value of cluster; note that cluster
2124 * may exceed old_imrt_nb_clusters if *first_free_cluster pointed beyond
2126 ret
= realloc_refcount_array(s
, refcount_table
, imrt_nb_clusters
,
2127 cluster
+ cluster_count
2128 - contiguous_free_clusters
);
2134 /* Go back to the first free cluster */
2135 cluster
-= contiguous_free_clusters
;
2136 for (i
= 0; i
< cluster_count
; i
++) {
2137 s
->set_refcount(*refcount_table
, cluster
+ i
, 1);
2140 return cluster
<< s
->cluster_bits
;
2144 * Creates a new refcount structure based solely on the in-memory information
2145 * given through *refcount_table. All necessary allocations will be reflected
2148 * On success, the old refcount structure is leaked (it will be covered by the
2149 * new refcount structure).
2151 static int rebuild_refcount_structure(BlockDriverState
*bs
,
2152 BdrvCheckResult
*res
,
2153 void **refcount_table
,
2154 int64_t *nb_clusters
)
2156 BDRVQcow2State
*s
= bs
->opaque
;
2157 int64_t first_free_cluster
= 0, reftable_offset
= -1, cluster
= 0;
2158 int64_t refblock_offset
, refblock_start
, refblock_index
;
2159 uint32_t reftable_size
= 0;
2160 uint64_t *on_disk_reftable
= NULL
;
2161 void *on_disk_refblock
;
2164 uint64_t reftable_offset
;
2165 uint32_t reftable_clusters
;
2166 } QEMU_PACKED reftable_offset_and_clusters
;
2168 qcow2_cache_empty(bs
, s
->refcount_block_cache
);
2171 for (; cluster
< *nb_clusters
; cluster
++) {
2172 if (!s
->get_refcount(*refcount_table
, cluster
)) {
2176 refblock_index
= cluster
>> s
->refcount_block_bits
;
2177 refblock_start
= refblock_index
<< s
->refcount_block_bits
;
2179 /* Don't allocate a cluster in a refblock already written to disk */
2180 if (first_free_cluster
< refblock_start
) {
2181 first_free_cluster
= refblock_start
;
2183 refblock_offset
= alloc_clusters_imrt(bs
, 1, refcount_table
,
2184 nb_clusters
, &first_free_cluster
);
2185 if (refblock_offset
< 0) {
2186 fprintf(stderr
, "ERROR allocating refblock: %s\n",
2187 strerror(-refblock_offset
));
2188 res
->check_errors
++;
2189 ret
= refblock_offset
;
2193 if (reftable_size
<= refblock_index
) {
2194 uint32_t old_reftable_size
= reftable_size
;
2195 uint64_t *new_on_disk_reftable
;
2197 reftable_size
= ROUND_UP((refblock_index
+ 1) * sizeof(uint64_t),
2198 s
->cluster_size
) / sizeof(uint64_t);
2199 new_on_disk_reftable
= g_try_realloc(on_disk_reftable
,
2202 if (!new_on_disk_reftable
) {
2203 res
->check_errors
++;
2207 on_disk_reftable
= new_on_disk_reftable
;
2209 memset(on_disk_reftable
+ old_reftable_size
, 0,
2210 (reftable_size
- old_reftable_size
) * sizeof(uint64_t));
2212 /* The offset we have for the reftable is now no longer valid;
2213 * this will leak that range, but we can easily fix that by running
2214 * a leak-fixing check after this rebuild operation */
2215 reftable_offset
= -1;
2217 assert(on_disk_reftable
);
2219 on_disk_reftable
[refblock_index
] = refblock_offset
;
2221 /* If this is apparently the last refblock (for now), try to squeeze the
2223 if (refblock_index
== (*nb_clusters
- 1) >> s
->refcount_block_bits
&&
2224 reftable_offset
< 0)
2226 uint64_t reftable_clusters
= size_to_clusters(s
, reftable_size
*
2228 reftable_offset
= alloc_clusters_imrt(bs
, reftable_clusters
,
2229 refcount_table
, nb_clusters
,
2230 &first_free_cluster
);
2231 if (reftable_offset
< 0) {
2232 fprintf(stderr
, "ERROR allocating reftable: %s\n",
2233 strerror(-reftable_offset
));
2234 res
->check_errors
++;
2235 ret
= reftable_offset
;
2240 ret
= qcow2_pre_write_overlap_check(bs
, 0, refblock_offset
,
2243 fprintf(stderr
, "ERROR writing refblock: %s\n", strerror(-ret
));
2247 /* The size of *refcount_table is always cluster-aligned, therefore the
2248 * write operation will not overflow */
2249 on_disk_refblock
= (void *)((char *) *refcount_table
+
2250 refblock_index
* s
->cluster_size
);
2252 ret
= bdrv_write(bs
->file
, refblock_offset
/ BDRV_SECTOR_SIZE
,
2253 on_disk_refblock
, s
->cluster_sectors
);
2255 fprintf(stderr
, "ERROR writing refblock: %s\n", strerror(-ret
));
2259 /* Go to the end of this refblock */
2260 cluster
= refblock_start
+ s
->refcount_block_size
- 1;
2263 if (reftable_offset
< 0) {
2264 uint64_t post_refblock_start
, reftable_clusters
;
2266 post_refblock_start
= ROUND_UP(*nb_clusters
, s
->refcount_block_size
);
2267 reftable_clusters
= size_to_clusters(s
,
2268 reftable_size
* sizeof(uint64_t));
2269 /* Not pretty but simple */
2270 if (first_free_cluster
< post_refblock_start
) {
2271 first_free_cluster
= post_refblock_start
;
2273 reftable_offset
= alloc_clusters_imrt(bs
, reftable_clusters
,
2274 refcount_table
, nb_clusters
,
2275 &first_free_cluster
);
2276 if (reftable_offset
< 0) {
2277 fprintf(stderr
, "ERROR allocating reftable: %s\n",
2278 strerror(-reftable_offset
));
2279 res
->check_errors
++;
2280 ret
= reftable_offset
;
2284 goto write_refblocks
;
2287 for (refblock_index
= 0; refblock_index
< reftable_size
; refblock_index
++) {
2288 cpu_to_be64s(&on_disk_reftable
[refblock_index
]);
2291 ret
= qcow2_pre_write_overlap_check(bs
, 0, reftable_offset
,
2292 reftable_size
* sizeof(uint64_t));
2294 fprintf(stderr
, "ERROR writing reftable: %s\n", strerror(-ret
));
2298 assert(reftable_size
< INT_MAX
/ sizeof(uint64_t));
2299 ret
= bdrv_pwrite(bs
->file
, reftable_offset
, on_disk_reftable
,
2300 reftable_size
* sizeof(uint64_t));
2302 fprintf(stderr
, "ERROR writing reftable: %s\n", strerror(-ret
));
2306 /* Enter new reftable into the image header */
2307 reftable_offset_and_clusters
.reftable_offset
= cpu_to_be64(reftable_offset
);
2308 reftable_offset_and_clusters
.reftable_clusters
=
2309 cpu_to_be32(size_to_clusters(s
, reftable_size
* sizeof(uint64_t)));
2310 ret
= bdrv_pwrite_sync(bs
->file
,
2311 offsetof(QCowHeader
, refcount_table_offset
),
2312 &reftable_offset_and_clusters
,
2313 sizeof(reftable_offset_and_clusters
));
2315 fprintf(stderr
, "ERROR setting reftable: %s\n", strerror(-ret
));
2319 for (refblock_index
= 0; refblock_index
< reftable_size
; refblock_index
++) {
2320 be64_to_cpus(&on_disk_reftable
[refblock_index
]);
2322 s
->refcount_table
= on_disk_reftable
;
2323 s
->refcount_table_offset
= reftable_offset
;
2324 s
->refcount_table_size
= reftable_size
;
2325 update_max_refcount_table_index(s
);
2330 g_free(on_disk_reftable
);
2335 * Checks an image for refcount consistency.
2337 * Returns 0 if no errors are found, the number of errors in case the image is
2338 * detected as corrupted, and -errno when an internal error occurred.
2340 int qcow2_check_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
2343 BDRVQcow2State
*s
= bs
->opaque
;
2344 BdrvCheckResult pre_compare_res
;
2345 int64_t size
, highest_cluster
, nb_clusters
;
2346 void *refcount_table
= NULL
;
2347 bool rebuild
= false;
2350 size
= bdrv_getlength(bs
->file
->bs
);
2352 res
->check_errors
++;
2356 nb_clusters
= size_to_clusters(s
, size
);
2357 if (nb_clusters
> INT_MAX
) {
2358 res
->check_errors
++;
2362 res
->bfi
.total_clusters
=
2363 size_to_clusters(s
, bs
->total_sectors
* BDRV_SECTOR_SIZE
);
2365 ret
= calculate_refcounts(bs
, res
, fix
, &rebuild
, &refcount_table
,
2371 /* In case we don't need to rebuild the refcount structure (but want to fix
2372 * something), this function is immediately called again, in which case the
2373 * result should be ignored */
2374 pre_compare_res
= *res
;
2375 compare_refcounts(bs
, res
, 0, &rebuild
, &highest_cluster
, refcount_table
,
2378 if (rebuild
&& (fix
& BDRV_FIX_ERRORS
)) {
2379 BdrvCheckResult old_res
= *res
;
2380 int fresh_leaks
= 0;
2382 fprintf(stderr
, "Rebuilding refcount structure\n");
2383 ret
= rebuild_refcount_structure(bs
, res
, &refcount_table
,
2389 res
->corruptions
= 0;
2392 /* Because the old reftable has been exchanged for a new one the
2393 * references have to be recalculated */
2395 memset(refcount_table
, 0, refcount_array_byte_size(s
, nb_clusters
));
2396 ret
= calculate_refcounts(bs
, res
, 0, &rebuild
, &refcount_table
,
2402 if (fix
& BDRV_FIX_LEAKS
) {
2403 /* The old refcount structures are now leaked, fix it; the result
2404 * can be ignored, aside from leaks which were introduced by
2405 * rebuild_refcount_structure() that could not be fixed */
2406 BdrvCheckResult saved_res
= *res
;
2407 *res
= (BdrvCheckResult
){ 0 };
2409 compare_refcounts(bs
, res
, BDRV_FIX_LEAKS
, &rebuild
,
2410 &highest_cluster
, refcount_table
, nb_clusters
);
2412 fprintf(stderr
, "ERROR rebuilt refcount structure is still "
2416 /* Any leaks accounted for here were introduced by
2417 * rebuild_refcount_structure() because that function has created a
2418 * new refcount structure from scratch */
2419 fresh_leaks
= res
->leaks
;
2423 if (res
->corruptions
< old_res
.corruptions
) {
2424 res
->corruptions_fixed
+= old_res
.corruptions
- res
->corruptions
;
2426 if (res
->leaks
< old_res
.leaks
) {
2427 res
->leaks_fixed
+= old_res
.leaks
- res
->leaks
;
2429 res
->leaks
+= fresh_leaks
;
2432 fprintf(stderr
, "ERROR need to rebuild refcount structures\n");
2433 res
->check_errors
++;
2438 if (res
->leaks
|| res
->corruptions
) {
2439 *res
= pre_compare_res
;
2440 compare_refcounts(bs
, res
, fix
, &rebuild
, &highest_cluster
,
2441 refcount_table
, nb_clusters
);
2445 /* check OFLAG_COPIED */
2446 ret
= check_oflag_copied(bs
, res
, fix
);
2451 res
->image_end_offset
= (highest_cluster
+ 1) * s
->cluster_size
;
2455 g_free(refcount_table
);
2460 #define overlaps_with(ofs, sz) \
2461 ranges_overlap(offset, size, ofs, sz)
2464 * Checks if the given offset into the image file is actually free to use by
2465 * looking for overlaps with important metadata sections (L1/L2 tables etc.),
2466 * i.e. a sanity check without relying on the refcount tables.
2468 * The ign parameter specifies what checks not to perform (being a bitmask of
2469 * QCow2MetadataOverlap values), i.e., what sections to ignore.
2472 * - 0 if writing to this offset will not affect the mentioned metadata
2473 * - a positive QCow2MetadataOverlap value indicating one overlapping section
2474 * - a negative value (-errno) indicating an error while performing a check,
2475 * e.g. when bdrv_read failed on QCOW2_OL_INACTIVE_L2
2477 int qcow2_check_metadata_overlap(BlockDriverState
*bs
, int ign
, int64_t offset
,
2480 BDRVQcow2State
*s
= bs
->opaque
;
2481 int chk
= s
->overlap_check
& ~ign
;
2488 if (chk
& QCOW2_OL_MAIN_HEADER
) {
2489 if (offset
< s
->cluster_size
) {
2490 return QCOW2_OL_MAIN_HEADER
;
2494 /* align range to test to cluster boundaries */
2495 size
= align_offset(offset_into_cluster(s
, offset
) + size
, s
->cluster_size
);
2496 offset
= start_of_cluster(s
, offset
);
2498 if ((chk
& QCOW2_OL_ACTIVE_L1
) && s
->l1_size
) {
2499 if (overlaps_with(s
->l1_table_offset
, s
->l1_size
* sizeof(uint64_t))) {
2500 return QCOW2_OL_ACTIVE_L1
;
2504 if ((chk
& QCOW2_OL_REFCOUNT_TABLE
) && s
->refcount_table_size
) {
2505 if (overlaps_with(s
->refcount_table_offset
,
2506 s
->refcount_table_size
* sizeof(uint64_t))) {
2507 return QCOW2_OL_REFCOUNT_TABLE
;
2511 if ((chk
& QCOW2_OL_SNAPSHOT_TABLE
) && s
->snapshots_size
) {
2512 if (overlaps_with(s
->snapshots_offset
, s
->snapshots_size
)) {
2513 return QCOW2_OL_SNAPSHOT_TABLE
;
2517 if ((chk
& QCOW2_OL_INACTIVE_L1
) && s
->snapshots
) {
2518 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
2519 if (s
->snapshots
[i
].l1_size
&&
2520 overlaps_with(s
->snapshots
[i
].l1_table_offset
,
2521 s
->snapshots
[i
].l1_size
* sizeof(uint64_t))) {
2522 return QCOW2_OL_INACTIVE_L1
;
2527 if ((chk
& QCOW2_OL_ACTIVE_L2
) && s
->l1_table
) {
2528 for (i
= 0; i
< s
->l1_size
; i
++) {
2529 if ((s
->l1_table
[i
] & L1E_OFFSET_MASK
) &&
2530 overlaps_with(s
->l1_table
[i
] & L1E_OFFSET_MASK
,
2532 return QCOW2_OL_ACTIVE_L2
;
2537 if ((chk
& QCOW2_OL_REFCOUNT_BLOCK
) && s
->refcount_table
) {
2538 unsigned last_entry
= s
->max_refcount_table_index
;
2539 assert(last_entry
< s
->refcount_table_size
);
2540 assert(last_entry
+ 1 == s
->refcount_table_size
||
2541 (s
->refcount_table
[last_entry
+ 1] & REFT_OFFSET_MASK
) == 0);
2542 for (i
= 0; i
<= last_entry
; i
++) {
2543 if ((s
->refcount_table
[i
] & REFT_OFFSET_MASK
) &&
2544 overlaps_with(s
->refcount_table
[i
] & REFT_OFFSET_MASK
,
2546 return QCOW2_OL_REFCOUNT_BLOCK
;
2551 if ((chk
& QCOW2_OL_INACTIVE_L2
) && s
->snapshots
) {
2552 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
2553 uint64_t l1_ofs
= s
->snapshots
[i
].l1_table_offset
;
2554 uint32_t l1_sz
= s
->snapshots
[i
].l1_size
;
2555 uint64_t l1_sz2
= l1_sz
* sizeof(uint64_t);
2556 uint64_t *l1
= g_try_malloc(l1_sz2
);
2559 if (l1_sz2
&& l1
== NULL
) {
2563 ret
= bdrv_pread(bs
->file
, l1_ofs
, l1
, l1_sz2
);
2569 for (j
= 0; j
< l1_sz
; j
++) {
2570 uint64_t l2_ofs
= be64_to_cpu(l1
[j
]) & L1E_OFFSET_MASK
;
2571 if (l2_ofs
&& overlaps_with(l2_ofs
, s
->cluster_size
)) {
2573 return QCOW2_OL_INACTIVE_L2
;
2584 static const char *metadata_ol_names
[] = {
2585 [QCOW2_OL_MAIN_HEADER_BITNR
] = "qcow2_header",
2586 [QCOW2_OL_ACTIVE_L1_BITNR
] = "active L1 table",
2587 [QCOW2_OL_ACTIVE_L2_BITNR
] = "active L2 table",
2588 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = "refcount table",
2589 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = "refcount block",
2590 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = "snapshot table",
2591 [QCOW2_OL_INACTIVE_L1_BITNR
] = "inactive L1 table",
2592 [QCOW2_OL_INACTIVE_L2_BITNR
] = "inactive L2 table",
2596 * First performs a check for metadata overlaps (through
2597 * qcow2_check_metadata_overlap); if that fails with a negative value (error
2598 * while performing a check), that value is returned. If an impending overlap
2599 * is detected, the BDS will be made unusable, the qcow2 file marked corrupt
2600 * and -EIO returned.
2602 * Returns 0 if there were neither overlaps nor errors while checking for
2603 * overlaps; or a negative value (-errno) on error.
2605 int qcow2_pre_write_overlap_check(BlockDriverState
*bs
, int ign
, int64_t offset
,
2608 int ret
= qcow2_check_metadata_overlap(bs
, ign
, offset
, size
);
2612 } else if (ret
> 0) {
2613 int metadata_ol_bitnr
= ctz32(ret
);
2614 assert(metadata_ol_bitnr
< QCOW2_OL_MAX_BITNR
);
2616 qcow2_signal_corruption(bs
, true, offset
, size
, "Preventing invalid "
2617 "write on metadata (overlaps with %s)",
2618 metadata_ol_names
[metadata_ol_bitnr
]);
2625 /* A pointer to a function of this type is given to walk_over_reftable(). That
2626 * function will create refblocks and pass them to a RefblockFinishOp once they
2627 * are completed (@refblock). @refblock_empty is set if the refblock is
2630 * Along with the refblock, a corresponding reftable entry is passed, in the
2631 * reftable @reftable (which may be reallocated) at @reftable_index.
2633 * @allocated should be set to true if a new cluster has been allocated.
2635 typedef int (RefblockFinishOp
)(BlockDriverState
*bs
, uint64_t **reftable
,
2636 uint64_t reftable_index
, uint64_t *reftable_size
,
2637 void *refblock
, bool refblock_empty
,
2638 bool *allocated
, Error
**errp
);
2641 * This "operation" for walk_over_reftable() allocates the refblock on disk (if
2642 * it is not empty) and inserts its offset into the new reftable. The size of
2643 * this new reftable is increased as required.
2645 static int alloc_refblock(BlockDriverState
*bs
, uint64_t **reftable
,
2646 uint64_t reftable_index
, uint64_t *reftable_size
,
2647 void *refblock
, bool refblock_empty
, bool *allocated
,
2650 BDRVQcow2State
*s
= bs
->opaque
;
2653 if (!refblock_empty
&& reftable_index
>= *reftable_size
) {
2654 uint64_t *new_reftable
;
2655 uint64_t new_reftable_size
;
2657 new_reftable_size
= ROUND_UP(reftable_index
+ 1,
2658 s
->cluster_size
/ sizeof(uint64_t));
2659 if (new_reftable_size
> QCOW_MAX_REFTABLE_SIZE
/ sizeof(uint64_t)) {
2661 "This operation would make the refcount table grow "
2662 "beyond the maximum size supported by QEMU, aborting");
2666 new_reftable
= g_try_realloc(*reftable
, new_reftable_size
*
2668 if (!new_reftable
) {
2669 error_setg(errp
, "Failed to increase reftable buffer size");
2673 memset(new_reftable
+ *reftable_size
, 0,
2674 (new_reftable_size
- *reftable_size
) * sizeof(uint64_t));
2676 *reftable
= new_reftable
;
2677 *reftable_size
= new_reftable_size
;
2680 if (!refblock_empty
&& !(*reftable
)[reftable_index
]) {
2681 offset
= qcow2_alloc_clusters(bs
, s
->cluster_size
);
2683 error_setg_errno(errp
, -offset
, "Failed to allocate refblock");
2686 (*reftable
)[reftable_index
] = offset
;
2694 * This "operation" for walk_over_reftable() writes the refblock to disk at the
2695 * offset specified by the new reftable's entry. It does not modify the new
2696 * reftable or change any refcounts.
2698 static int flush_refblock(BlockDriverState
*bs
, uint64_t **reftable
,
2699 uint64_t reftable_index
, uint64_t *reftable_size
,
2700 void *refblock
, bool refblock_empty
, bool *allocated
,
2703 BDRVQcow2State
*s
= bs
->opaque
;
2707 if (reftable_index
< *reftable_size
&& (*reftable
)[reftable_index
]) {
2708 offset
= (*reftable
)[reftable_index
];
2710 ret
= qcow2_pre_write_overlap_check(bs
, 0, offset
, s
->cluster_size
);
2712 error_setg_errno(errp
, -ret
, "Overlap check failed");
2716 ret
= bdrv_pwrite(bs
->file
, offset
, refblock
, s
->cluster_size
);
2718 error_setg_errno(errp
, -ret
, "Failed to write refblock");
2722 assert(refblock_empty
);
2729 * This function walks over the existing reftable and every referenced refblock;
2730 * if @new_set_refcount is non-NULL, it is called for every refcount entry to
2731 * create an equal new entry in the passed @new_refblock. Once that
2732 * @new_refblock is completely filled, @operation will be called.
2734 * @status_cb and @cb_opaque are used for the amend operation's status callback.
2735 * @index is the index of the walk_over_reftable() calls and @total is the total
2736 * number of walk_over_reftable() calls per amend operation. Both are used for
2737 * calculating the parameters for the status callback.
2739 * @allocated is set to true if a new cluster has been allocated.
2741 static int walk_over_reftable(BlockDriverState
*bs
, uint64_t **new_reftable
,
2742 uint64_t *new_reftable_index
,
2743 uint64_t *new_reftable_size
,
2744 void *new_refblock
, int new_refblock_size
,
2745 int new_refcount_bits
,
2746 RefblockFinishOp
*operation
, bool *allocated
,
2747 Qcow2SetRefcountFunc
*new_set_refcount
,
2748 BlockDriverAmendStatusCB
*status_cb
,
2749 void *cb_opaque
, int index
, int total
,
2752 BDRVQcow2State
*s
= bs
->opaque
;
2753 uint64_t reftable_index
;
2754 bool new_refblock_empty
= true;
2756 int new_refblock_index
= 0;
2759 for (reftable_index
= 0; reftable_index
< s
->refcount_table_size
;
2762 uint64_t refblock_offset
= s
->refcount_table
[reftable_index
]
2765 status_cb(bs
, (uint64_t)index
* s
->refcount_table_size
+ reftable_index
,
2766 (uint64_t)total
* s
->refcount_table_size
, cb_opaque
);
2768 if (refblock_offset
) {
2771 if (offset_into_cluster(s
, refblock_offset
)) {
2772 qcow2_signal_corruption(bs
, true, -1, -1, "Refblock offset %#"
2773 PRIx64
" unaligned (reftable index: %#"
2774 PRIx64
")", refblock_offset
,
2777 "Image is corrupt (unaligned refblock offset)");
2781 ret
= qcow2_cache_get(bs
, s
->refcount_block_cache
, refblock_offset
,
2784 error_setg_errno(errp
, -ret
, "Failed to retrieve refblock");
2788 for (refblock_index
= 0; refblock_index
< s
->refcount_block_size
;
2793 if (new_refblock_index
>= new_refblock_size
) {
2794 /* new_refblock is now complete */
2795 ret
= operation(bs
, new_reftable
, *new_reftable_index
,
2796 new_reftable_size
, new_refblock
,
2797 new_refblock_empty
, allocated
, errp
);
2799 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
2803 (*new_reftable_index
)++;
2804 new_refblock_index
= 0;
2805 new_refblock_empty
= true;
2808 refcount
= s
->get_refcount(refblock
, refblock_index
);
2809 if (new_refcount_bits
< 64 && refcount
>> new_refcount_bits
) {
2812 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
2814 offset
= ((reftable_index
<< s
->refcount_block_bits
)
2815 + refblock_index
) << s
->cluster_bits
;
2817 error_setg(errp
, "Cannot decrease refcount entry width to "
2818 "%i bits: Cluster at offset %#" PRIx64
" has a "
2819 "refcount of %" PRIu64
, new_refcount_bits
,
2824 if (new_set_refcount
) {
2825 new_set_refcount(new_refblock
, new_refblock_index
++,
2828 new_refblock_index
++;
2830 new_refblock_empty
= new_refblock_empty
&& refcount
== 0;
2833 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
2835 /* No refblock means every refcount is 0 */
2836 for (refblock_index
= 0; refblock_index
< s
->refcount_block_size
;
2839 if (new_refblock_index
>= new_refblock_size
) {
2840 /* new_refblock is now complete */
2841 ret
= operation(bs
, new_reftable
, *new_reftable_index
,
2842 new_reftable_size
, new_refblock
,
2843 new_refblock_empty
, allocated
, errp
);
2848 (*new_reftable_index
)++;
2849 new_refblock_index
= 0;
2850 new_refblock_empty
= true;
2853 if (new_set_refcount
) {
2854 new_set_refcount(new_refblock
, new_refblock_index
++, 0);
2856 new_refblock_index
++;
2862 if (new_refblock_index
> 0) {
2863 /* Complete the potentially existing partially filled final refblock */
2864 if (new_set_refcount
) {
2865 for (; new_refblock_index
< new_refblock_size
;
2866 new_refblock_index
++)
2868 new_set_refcount(new_refblock
, new_refblock_index
, 0);
2872 ret
= operation(bs
, new_reftable
, *new_reftable_index
,
2873 new_reftable_size
, new_refblock
, new_refblock_empty
,
2879 (*new_reftable_index
)++;
2882 status_cb(bs
, (uint64_t)(index
+ 1) * s
->refcount_table_size
,
2883 (uint64_t)total
* s
->refcount_table_size
, cb_opaque
);
2888 int qcow2_change_refcount_order(BlockDriverState
*bs
, int refcount_order
,
2889 BlockDriverAmendStatusCB
*status_cb
,
2890 void *cb_opaque
, Error
**errp
)
2892 BDRVQcow2State
*s
= bs
->opaque
;
2893 Qcow2GetRefcountFunc
*new_get_refcount
;
2894 Qcow2SetRefcountFunc
*new_set_refcount
;
2895 void *new_refblock
= qemu_blockalign(bs
->file
->bs
, s
->cluster_size
);
2896 uint64_t *new_reftable
= NULL
, new_reftable_size
= 0;
2897 uint64_t *old_reftable
, old_reftable_size
, old_reftable_offset
;
2898 uint64_t new_reftable_index
= 0;
2900 int64_t new_reftable_offset
= 0, allocated_reftable_size
= 0;
2901 int new_refblock_size
, new_refcount_bits
= 1 << refcount_order
;
2902 int old_refcount_order
;
2905 bool new_allocation
;
2907 assert(s
->qcow_version
>= 3);
2908 assert(refcount_order
>= 0 && refcount_order
<= 6);
2910 /* see qcow2_open() */
2911 new_refblock_size
= 1 << (s
->cluster_bits
- (refcount_order
- 3));
2913 new_get_refcount
= get_refcount_funcs
[refcount_order
];
2914 new_set_refcount
= set_refcount_funcs
[refcount_order
];
2920 new_allocation
= false;
2922 /* At least we have to do this walk and the one which writes the
2923 * refblocks; also, at least we have to do this loop here at least
2924 * twice (normally), first to do the allocations, and second to
2925 * determine that everything is correctly allocated, this then makes
2926 * three walks in total */
2927 total_walks
= MAX(walk_index
+ 2, 3);
2929 /* First, allocate the structures so they are present in the refcount
2931 ret
= walk_over_reftable(bs
, &new_reftable
, &new_reftable_index
,
2932 &new_reftable_size
, NULL
, new_refblock_size
,
2933 new_refcount_bits
, &alloc_refblock
,
2934 &new_allocation
, NULL
, status_cb
, cb_opaque
,
2935 walk_index
++, total_walks
, errp
);
2940 new_reftable_index
= 0;
2942 if (new_allocation
) {
2943 if (new_reftable_offset
) {
2944 qcow2_free_clusters(bs
, new_reftable_offset
,
2945 allocated_reftable_size
* sizeof(uint64_t),
2946 QCOW2_DISCARD_NEVER
);
2949 new_reftable_offset
= qcow2_alloc_clusters(bs
, new_reftable_size
*
2951 if (new_reftable_offset
< 0) {
2952 error_setg_errno(errp
, -new_reftable_offset
,
2953 "Failed to allocate the new reftable");
2954 ret
= new_reftable_offset
;
2957 allocated_reftable_size
= new_reftable_size
;
2959 } while (new_allocation
);
2961 /* Second, write the new refblocks */
2962 ret
= walk_over_reftable(bs
, &new_reftable
, &new_reftable_index
,
2963 &new_reftable_size
, new_refblock
,
2964 new_refblock_size
, new_refcount_bits
,
2965 &flush_refblock
, &new_allocation
, new_set_refcount
,
2966 status_cb
, cb_opaque
, walk_index
, walk_index
+ 1,
2971 assert(!new_allocation
);
2974 /* Write the new reftable */
2975 ret
= qcow2_pre_write_overlap_check(bs
, 0, new_reftable_offset
,
2976 new_reftable_size
* sizeof(uint64_t));
2978 error_setg_errno(errp
, -ret
, "Overlap check failed");
2982 for (i
= 0; i
< new_reftable_size
; i
++) {
2983 cpu_to_be64s(&new_reftable
[i
]);
2986 ret
= bdrv_pwrite(bs
->file
, new_reftable_offset
, new_reftable
,
2987 new_reftable_size
* sizeof(uint64_t));
2989 for (i
= 0; i
< new_reftable_size
; i
++) {
2990 be64_to_cpus(&new_reftable
[i
]);
2994 error_setg_errno(errp
, -ret
, "Failed to write the new reftable");
2999 /* Empty the refcount cache */
3000 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
3002 error_setg_errno(errp
, -ret
, "Failed to flush the refblock cache");
3006 /* Update the image header to point to the new reftable; this only updates
3007 * the fields which are relevant to qcow2_update_header(); other fields
3008 * such as s->refcount_table or s->refcount_bits stay stale for now
3009 * (because we have to restore everything if qcow2_update_header() fails) */
3010 old_refcount_order
= s
->refcount_order
;
3011 old_reftable_size
= s
->refcount_table_size
;
3012 old_reftable_offset
= s
->refcount_table_offset
;
3014 s
->refcount_order
= refcount_order
;
3015 s
->refcount_table_size
= new_reftable_size
;
3016 s
->refcount_table_offset
= new_reftable_offset
;
3018 ret
= qcow2_update_header(bs
);
3020 s
->refcount_order
= old_refcount_order
;
3021 s
->refcount_table_size
= old_reftable_size
;
3022 s
->refcount_table_offset
= old_reftable_offset
;
3023 error_setg_errno(errp
, -ret
, "Failed to update the qcow2 header");
3027 /* Now update the rest of the in-memory information */
3028 old_reftable
= s
->refcount_table
;
3029 s
->refcount_table
= new_reftable
;
3030 update_max_refcount_table_index(s
);
3032 s
->refcount_bits
= 1 << refcount_order
;
3033 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
3034 s
->refcount_max
+= s
->refcount_max
- 1;
3036 s
->refcount_block_bits
= s
->cluster_bits
- (refcount_order
- 3);
3037 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
3039 s
->get_refcount
= new_get_refcount
;
3040 s
->set_refcount
= new_set_refcount
;
3042 /* For cleaning up all old refblocks and the old reftable below the "done"
3044 new_reftable
= old_reftable
;
3045 new_reftable_size
= old_reftable_size
;
3046 new_reftable_offset
= old_reftable_offset
;
3050 /* On success, new_reftable actually points to the old reftable (and
3051 * new_reftable_size is the old reftable's size); but that is just
3053 for (i
= 0; i
< new_reftable_size
; i
++) {
3054 uint64_t offset
= new_reftable
[i
] & REFT_OFFSET_MASK
;
3056 qcow2_free_clusters(bs
, offset
, s
->cluster_size
,
3057 QCOW2_DISCARD_OTHER
);
3060 g_free(new_reftable
);
3062 if (new_reftable_offset
> 0) {
3063 qcow2_free_clusters(bs
, new_reftable_offset
,
3064 new_reftable_size
* sizeof(uint64_t),
3065 QCOW2_DISCARD_OTHER
);
3069 qemu_vfree(new_refblock
);
3073 static int qcow2_discard_refcount_block(BlockDriverState
*bs
,
3074 uint64_t discard_block_offs
)
3076 BDRVQcow2State
*s
= bs
->opaque
;
3077 uint64_t refblock_offs
= get_refblock_offset(s
, discard_block_offs
);
3078 uint64_t cluster_index
= discard_block_offs
>> s
->cluster_bits
;
3079 uint32_t block_index
= cluster_index
& (s
->refcount_block_size
- 1);
3083 assert(discard_block_offs
!= 0);
3085 ret
= qcow2_cache_get(bs
, s
->refcount_block_cache
, refblock_offs
,
3091 if (s
->get_refcount(refblock
, block_index
) != 1) {
3092 qcow2_signal_corruption(bs
, true, -1, -1, "Invalid refcount:"
3093 " refblock offset %#" PRIx64
3094 ", reftable index %u"
3095 ", block offset %#" PRIx64
3096 ", refcount %#" PRIx64
,
3098 offset_to_reftable_index(s
, discard_block_offs
),
3100 s
->get_refcount(refblock
, block_index
));
3101 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
3104 s
->set_refcount(refblock
, block_index
, 0);
3106 qcow2_cache_entry_mark_dirty(bs
, s
->refcount_block_cache
, refblock
);
3108 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
3110 if (cluster_index
< s
->free_cluster_index
) {
3111 s
->free_cluster_index
= cluster_index
;
3114 refblock
= qcow2_cache_is_table_offset(bs
, s
->refcount_block_cache
,
3115 discard_block_offs
);
3117 /* discard refblock from the cache if refblock is cached */
3118 qcow2_cache_discard(bs
, s
->refcount_block_cache
, refblock
);
3120 update_refcount_discard(bs
, discard_block_offs
, s
->cluster_size
);
3125 int qcow2_shrink_reftable(BlockDriverState
*bs
)
3127 BDRVQcow2State
*s
= bs
->opaque
;
3128 uint64_t *reftable_tmp
=
3129 g_malloc(s
->refcount_table_size
* sizeof(uint64_t));
3132 for (i
= 0; i
< s
->refcount_table_size
; i
++) {
3133 int64_t refblock_offs
= s
->refcount_table
[i
] & REFT_OFFSET_MASK
;
3137 if (refblock_offs
== 0) {
3138 reftable_tmp
[i
] = 0;
3141 ret
= qcow2_cache_get(bs
, s
->refcount_block_cache
, refblock_offs
,
3147 /* the refblock has own reference */
3148 if (i
== offset_to_reftable_index(s
, refblock_offs
)) {
3149 uint64_t block_index
= (refblock_offs
>> s
->cluster_bits
) &
3150 (s
->refcount_block_size
- 1);
3151 uint64_t refcount
= s
->get_refcount(refblock
, block_index
);
3153 s
->set_refcount(refblock
, block_index
, 0);
3155 unused_block
= buffer_is_zero(refblock
, s
->cluster_size
);
3157 s
->set_refcount(refblock
, block_index
, refcount
);
3159 unused_block
= buffer_is_zero(refblock
, s
->cluster_size
);
3161 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
3163 reftable_tmp
[i
] = unused_block
? 0 : cpu_to_be64(s
->refcount_table
[i
]);
3166 ret
= bdrv_pwrite_sync(bs
->file
, s
->refcount_table_offset
, reftable_tmp
,
3167 s
->refcount_table_size
* sizeof(uint64_t));
3169 * If the write in the reftable failed the image may contain a partially
3170 * overwritten reftable. In this case it would be better to clear the
3171 * reftable in memory to avoid possible image corruption.
3173 for (i
= 0; i
< s
->refcount_table_size
; i
++) {
3174 if (s
->refcount_table
[i
] && !reftable_tmp
[i
]) {
3176 ret
= qcow2_discard_refcount_block(bs
, s
->refcount_table
[i
] &
3179 s
->refcount_table
[i
] = 0;
3183 if (!s
->cache_discards
) {
3184 qcow2_process_discards(bs
, ret
);
3188 g_free(reftable_tmp
);
3192 int64_t qcow2_get_last_cluster(BlockDriverState
*bs
, int64_t size
)
3194 BDRVQcow2State
*s
= bs
->opaque
;
3197 for (i
= size_to_clusters(s
, size
) - 1; i
>= 0; i
--) {
3199 int ret
= qcow2_get_refcount(bs
, i
, &refcount
);
3201 fprintf(stderr
, "Can't get refcount for cluster %" PRId64
": %s\n",
3209 qcow2_signal_corruption(bs
, true, -1, -1,
3210 "There are no references in the refcount table.");