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"
33 static int64_t alloc_clusters_noref(BlockDriverState
*bs
, uint64_t size
);
34 static int QEMU_WARN_UNUSED_RESULT
update_refcount(BlockDriverState
*bs
,
35 int64_t offset
, int64_t length
, uint64_t addend
,
36 bool decrease
, enum qcow2_discard_type type
);
38 static uint64_t get_refcount_ro0(const void *refcount_array
, uint64_t index
);
39 static uint64_t get_refcount_ro1(const void *refcount_array
, uint64_t index
);
40 static uint64_t get_refcount_ro2(const void *refcount_array
, uint64_t index
);
41 static uint64_t get_refcount_ro3(const void *refcount_array
, uint64_t index
);
42 static uint64_t get_refcount_ro4(const void *refcount_array
, uint64_t index
);
43 static uint64_t get_refcount_ro5(const void *refcount_array
, uint64_t index
);
44 static uint64_t get_refcount_ro6(const void *refcount_array
, uint64_t index
);
46 static void set_refcount_ro0(void *refcount_array
, uint64_t index
,
48 static void set_refcount_ro1(void *refcount_array
, uint64_t index
,
50 static void set_refcount_ro2(void *refcount_array
, uint64_t index
,
52 static void set_refcount_ro3(void *refcount_array
, uint64_t index
,
54 static void set_refcount_ro4(void *refcount_array
, uint64_t index
,
56 static void set_refcount_ro5(void *refcount_array
, uint64_t index
,
58 static void set_refcount_ro6(void *refcount_array
, uint64_t index
,
62 static Qcow2GetRefcountFunc
*const get_refcount_funcs
[] = {
72 static Qcow2SetRefcountFunc
*const set_refcount_funcs
[] = {
83 /*********************************************************/
84 /* refcount handling */
86 static void update_max_refcount_table_index(BDRVQcow2State
*s
)
88 unsigned i
= s
->refcount_table_size
- 1;
89 while (i
> 0 && (s
->refcount_table
[i
] & REFT_OFFSET_MASK
) == 0) {
92 /* Set s->max_refcount_table_index to the index of the last used entry */
93 s
->max_refcount_table_index
= i
;
96 int qcow2_refcount_init(BlockDriverState
*bs
)
98 BDRVQcow2State
*s
= bs
->opaque
;
99 unsigned int refcount_table_size2
, i
;
102 assert(s
->refcount_order
>= 0 && s
->refcount_order
<= 6);
104 s
->get_refcount
= get_refcount_funcs
[s
->refcount_order
];
105 s
->set_refcount
= set_refcount_funcs
[s
->refcount_order
];
107 assert(s
->refcount_table_size
<= INT_MAX
/ sizeof(uint64_t));
108 refcount_table_size2
= s
->refcount_table_size
* sizeof(uint64_t);
109 s
->refcount_table
= g_try_malloc(refcount_table_size2
);
111 if (s
->refcount_table_size
> 0) {
112 if (s
->refcount_table
== NULL
) {
116 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_LOAD
);
117 ret
= bdrv_pread(bs
->file
, s
->refcount_table_offset
,
118 s
->refcount_table
, refcount_table_size2
);
122 for(i
= 0; i
< s
->refcount_table_size
; i
++)
123 be64_to_cpus(&s
->refcount_table
[i
]);
124 update_max_refcount_table_index(s
);
131 void qcow2_refcount_close(BlockDriverState
*bs
)
133 BDRVQcow2State
*s
= bs
->opaque
;
134 g_free(s
->refcount_table
);
138 static uint64_t get_refcount_ro0(const void *refcount_array
, uint64_t index
)
140 return (((const uint8_t *)refcount_array
)[index
/ 8] >> (index
% 8)) & 0x1;
143 static void set_refcount_ro0(void *refcount_array
, uint64_t index
,
146 assert(!(value
>> 1));
147 ((uint8_t *)refcount_array
)[index
/ 8] &= ~(0x1 << (index
% 8));
148 ((uint8_t *)refcount_array
)[index
/ 8] |= value
<< (index
% 8);
151 static uint64_t get_refcount_ro1(const void *refcount_array
, uint64_t index
)
153 return (((const uint8_t *)refcount_array
)[index
/ 4] >> (2 * (index
% 4)))
157 static void set_refcount_ro1(void *refcount_array
, uint64_t index
,
160 assert(!(value
>> 2));
161 ((uint8_t *)refcount_array
)[index
/ 4] &= ~(0x3 << (2 * (index
% 4)));
162 ((uint8_t *)refcount_array
)[index
/ 4] |= value
<< (2 * (index
% 4));
165 static uint64_t get_refcount_ro2(const void *refcount_array
, uint64_t index
)
167 return (((const uint8_t *)refcount_array
)[index
/ 2] >> (4 * (index
% 2)))
171 static void set_refcount_ro2(void *refcount_array
, uint64_t index
,
174 assert(!(value
>> 4));
175 ((uint8_t *)refcount_array
)[index
/ 2] &= ~(0xf << (4 * (index
% 2)));
176 ((uint8_t *)refcount_array
)[index
/ 2] |= value
<< (4 * (index
% 2));
179 static uint64_t get_refcount_ro3(const void *refcount_array
, uint64_t index
)
181 return ((const uint8_t *)refcount_array
)[index
];
184 static void set_refcount_ro3(void *refcount_array
, uint64_t index
,
187 assert(!(value
>> 8));
188 ((uint8_t *)refcount_array
)[index
] = value
;
191 static uint64_t get_refcount_ro4(const void *refcount_array
, uint64_t index
)
193 return be16_to_cpu(((const uint16_t *)refcount_array
)[index
]);
196 static void set_refcount_ro4(void *refcount_array
, uint64_t index
,
199 assert(!(value
>> 16));
200 ((uint16_t *)refcount_array
)[index
] = cpu_to_be16(value
);
203 static uint64_t get_refcount_ro5(const void *refcount_array
, uint64_t index
)
205 return be32_to_cpu(((const uint32_t *)refcount_array
)[index
]);
208 static void set_refcount_ro5(void *refcount_array
, uint64_t index
,
211 assert(!(value
>> 32));
212 ((uint32_t *)refcount_array
)[index
] = cpu_to_be32(value
);
215 static uint64_t get_refcount_ro6(const void *refcount_array
, uint64_t index
)
217 return be64_to_cpu(((const uint64_t *)refcount_array
)[index
]);
220 static void set_refcount_ro6(void *refcount_array
, uint64_t index
,
223 ((uint64_t *)refcount_array
)[index
] = cpu_to_be64(value
);
227 static int load_refcount_block(BlockDriverState
*bs
,
228 int64_t refcount_block_offset
,
229 void **refcount_block
)
231 BDRVQcow2State
*s
= bs
->opaque
;
233 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_LOAD
);
234 return qcow2_cache_get(bs
, s
->refcount_block_cache
, refcount_block_offset
,
239 * Retrieves the refcount of the cluster given by its index and stores it in
240 * *refcount. Returns 0 on success and -errno on failure.
242 int qcow2_get_refcount(BlockDriverState
*bs
, int64_t cluster_index
,
245 BDRVQcow2State
*s
= bs
->opaque
;
246 uint64_t refcount_table_index
, block_index
;
247 int64_t refcount_block_offset
;
249 void *refcount_block
;
251 refcount_table_index
= cluster_index
>> s
->refcount_block_bits
;
252 if (refcount_table_index
>= s
->refcount_table_size
) {
256 refcount_block_offset
=
257 s
->refcount_table
[refcount_table_index
] & REFT_OFFSET_MASK
;
258 if (!refcount_block_offset
) {
263 if (offset_into_cluster(s
, refcount_block_offset
)) {
264 qcow2_signal_corruption(bs
, true, -1, -1, "Refblock offset %#" PRIx64
265 " unaligned (reftable index: %#" PRIx64
")",
266 refcount_block_offset
, refcount_table_index
);
270 ret
= qcow2_cache_get(bs
, s
->refcount_block_cache
, refcount_block_offset
,
276 block_index
= cluster_index
& (s
->refcount_block_size
- 1);
277 *refcount
= s
->get_refcount(refcount_block
, block_index
);
279 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refcount_block
);
285 * Rounds the refcount table size up to avoid growing the table for each single
286 * refcount block that is allocated.
288 static unsigned int next_refcount_table_size(BDRVQcow2State
*s
,
289 unsigned int min_size
)
291 unsigned int min_clusters
= (min_size
>> (s
->cluster_bits
- 3)) + 1;
292 unsigned int refcount_table_clusters
=
293 MAX(1, s
->refcount_table_size
>> (s
->cluster_bits
- 3));
295 while (min_clusters
> refcount_table_clusters
) {
296 refcount_table_clusters
= (refcount_table_clusters
* 3 + 1) / 2;
299 return refcount_table_clusters
<< (s
->cluster_bits
- 3);
303 /* Checks if two offsets are described by the same refcount block */
304 static int in_same_refcount_block(BDRVQcow2State
*s
, uint64_t offset_a
,
307 uint64_t block_a
= offset_a
>> (s
->cluster_bits
+ s
->refcount_block_bits
);
308 uint64_t block_b
= offset_b
>> (s
->cluster_bits
+ s
->refcount_block_bits
);
310 return (block_a
== block_b
);
314 * Loads a refcount block. If it doesn't exist yet, it is allocated first
315 * (including growing the refcount table if needed).
317 * Returns 0 on success or -errno in error case
319 static int alloc_refcount_block(BlockDriverState
*bs
,
320 int64_t cluster_index
, void **refcount_block
)
322 BDRVQcow2State
*s
= bs
->opaque
;
323 unsigned int refcount_table_index
;
326 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC
);
328 /* Find the refcount block for the given cluster */
329 refcount_table_index
= cluster_index
>> s
->refcount_block_bits
;
331 if (refcount_table_index
< s
->refcount_table_size
) {
333 uint64_t refcount_block_offset
=
334 s
->refcount_table
[refcount_table_index
] & REFT_OFFSET_MASK
;
336 /* If it's already there, we're done */
337 if (refcount_block_offset
) {
338 if (offset_into_cluster(s
, refcount_block_offset
)) {
339 qcow2_signal_corruption(bs
, true, -1, -1, "Refblock offset %#"
340 PRIx64
" unaligned (reftable index: "
341 "%#x)", refcount_block_offset
,
342 refcount_table_index
);
346 return load_refcount_block(bs
, refcount_block_offset
,
352 * If we came here, we need to allocate something. Something is at least
353 * a cluster for the new refcount block. It may also include a new refcount
354 * table if the old refcount table is too small.
356 * Note that allocating clusters here needs some special care:
358 * - We can't use the normal qcow2_alloc_clusters(), it would try to
359 * increase the refcount and very likely we would end up with an endless
360 * recursion. Instead we must place the refcount blocks in a way that
361 * they can describe them themselves.
363 * - We need to consider that at this point we are inside update_refcounts
364 * and potentially doing an initial refcount increase. This means that
365 * some clusters have already been allocated by the caller, but their
366 * refcount isn't accurate yet. If we allocate clusters for metadata, we
367 * need to return -EAGAIN to signal the caller that it needs to restart
368 * the search for free clusters.
370 * - alloc_clusters_noref and qcow2_free_clusters may load a different
371 * refcount block into the cache
374 *refcount_block
= NULL
;
376 /* We write to the refcount table, so we might depend on L2 tables */
377 ret
= qcow2_cache_flush(bs
, s
->l2_table_cache
);
382 /* Allocate the refcount block itself and mark it as used */
383 int64_t new_block
= alloc_clusters_noref(bs
, s
->cluster_size
);
389 fprintf(stderr
, "qcow2: Allocate refcount block %d for %" PRIx64
391 refcount_table_index
, cluster_index
<< s
->cluster_bits
, new_block
);
394 if (in_same_refcount_block(s
, new_block
, cluster_index
<< s
->cluster_bits
)) {
395 /* Zero the new refcount block before updating it */
396 ret
= qcow2_cache_get_empty(bs
, s
->refcount_block_cache
, new_block
,
402 memset(*refcount_block
, 0, s
->cluster_size
);
404 /* The block describes itself, need to update the cache */
405 int block_index
= (new_block
>> s
->cluster_bits
) &
406 (s
->refcount_block_size
- 1);
407 s
->set_refcount(*refcount_block
, block_index
, 1);
409 /* Described somewhere else. This can recurse at most twice before we
410 * arrive at a block that describes itself. */
411 ret
= update_refcount(bs
, new_block
, s
->cluster_size
, 1, false,
412 QCOW2_DISCARD_NEVER
);
417 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
422 /* Initialize the new refcount block only after updating its refcount,
423 * update_refcount uses the refcount cache itself */
424 ret
= qcow2_cache_get_empty(bs
, s
->refcount_block_cache
, new_block
,
430 memset(*refcount_block
, 0, s
->cluster_size
);
433 /* Now the new refcount block needs to be written to disk */
434 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_WRITE
);
435 qcow2_cache_entry_mark_dirty(bs
, s
->refcount_block_cache
, *refcount_block
);
436 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
441 /* If the refcount table is big enough, just hook the block up there */
442 if (refcount_table_index
< s
->refcount_table_size
) {
443 uint64_t data64
= cpu_to_be64(new_block
);
444 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_HOOKUP
);
445 ret
= bdrv_pwrite_sync(bs
->file
,
446 s
->refcount_table_offset
+ refcount_table_index
* sizeof(uint64_t),
447 &data64
, sizeof(data64
));
452 s
->refcount_table
[refcount_table_index
] = new_block
;
453 /* If there's a hole in s->refcount_table then it can happen
454 * that refcount_table_index < s->max_refcount_table_index */
455 s
->max_refcount_table_index
=
456 MAX(s
->max_refcount_table_index
, refcount_table_index
);
458 /* The new refcount block may be where the caller intended to put its
459 * data, so let it restart the search. */
463 qcow2_cache_put(bs
, s
->refcount_block_cache
, refcount_block
);
466 * If we come here, we need to grow the refcount table. Again, a new
467 * refcount table needs some space and we can't simply allocate to avoid
470 * Therefore let's grab new refcount blocks at the end of the image, which
471 * will describe themselves and the new refcount table. This way we can
472 * reference them only in the new table and do the switch to the new
473 * refcount table at once without producing an inconsistent state in
476 BLKDBG_EVENT(bs
->file
, BLKDBG_REFTABLE_GROW
);
478 /* Calculate the number of refcount blocks needed so far; this will be the
479 * basis for calculating the index of the first cluster used for the
480 * self-describing refcount structures which we are about to create.
482 * Because we reached this point, there cannot be any refcount entries for
483 * cluster_index or higher indices yet. However, because new_block has been
484 * allocated to describe that cluster (and it will assume this role later
485 * on), we cannot use that index; also, new_block may actually have a higher
486 * cluster index than cluster_index, so it needs to be taken into account
487 * here (and 1 needs to be added to its value because that cluster is used).
489 uint64_t blocks_used
= DIV_ROUND_UP(MAX(cluster_index
+ 1,
490 (new_block
>> s
->cluster_bits
) + 1),
491 s
->refcount_block_size
);
493 if (blocks_used
> QCOW_MAX_REFTABLE_SIZE
/ sizeof(uint64_t)) {
497 /* And now we need at least one block more for the new metadata */
498 uint64_t table_size
= next_refcount_table_size(s
, blocks_used
+ 1);
499 uint64_t last_table_size
;
500 uint64_t blocks_clusters
;
502 uint64_t table_clusters
=
503 size_to_clusters(s
, table_size
* sizeof(uint64_t));
504 blocks_clusters
= 1 +
505 DIV_ROUND_UP(table_clusters
, s
->refcount_block_size
);
506 uint64_t meta_clusters
= table_clusters
+ blocks_clusters
;
508 last_table_size
= table_size
;
509 table_size
= next_refcount_table_size(s
, blocks_used
+
510 DIV_ROUND_UP(meta_clusters
, s
->refcount_block_size
));
512 } while (last_table_size
!= table_size
);
515 fprintf(stderr
, "qcow2: Grow refcount table %" PRId32
" => %" PRId64
"\n",
516 s
->refcount_table_size
, table_size
);
519 /* Create the new refcount table and blocks */
520 uint64_t meta_offset
= (blocks_used
* s
->refcount_block_size
) *
522 uint64_t table_offset
= meta_offset
+ blocks_clusters
* s
->cluster_size
;
523 uint64_t *new_table
= g_try_new0(uint64_t, table_size
);
524 void *new_blocks
= g_try_malloc0(blocks_clusters
* s
->cluster_size
);
526 assert(table_size
> 0 && blocks_clusters
> 0);
527 if (new_table
== NULL
|| new_blocks
== NULL
) {
532 /* Fill the new refcount table */
533 memcpy(new_table
, s
->refcount_table
,
534 s
->refcount_table_size
* sizeof(uint64_t));
535 new_table
[refcount_table_index
] = new_block
;
538 for (i
= 0; i
< blocks_clusters
; i
++) {
539 new_table
[blocks_used
+ i
] = meta_offset
+ (i
* s
->cluster_size
);
542 /* Fill the refcount blocks */
543 uint64_t table_clusters
= size_to_clusters(s
, table_size
* sizeof(uint64_t));
545 for (i
= 0; i
< table_clusters
+ blocks_clusters
; i
++) {
546 s
->set_refcount(new_blocks
, block
++, 1);
549 /* Write refcount blocks to disk */
550 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS
);
551 ret
= bdrv_pwrite_sync(bs
->file
, meta_offset
, new_blocks
,
552 blocks_clusters
* s
->cluster_size
);
559 /* Write refcount table to disk */
560 for(i
= 0; i
< table_size
; i
++) {
561 cpu_to_be64s(&new_table
[i
]);
564 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE
);
565 ret
= bdrv_pwrite_sync(bs
->file
, table_offset
, new_table
,
566 table_size
* sizeof(uint64_t));
571 for(i
= 0; i
< table_size
; i
++) {
572 be64_to_cpus(&new_table
[i
]);
575 /* Hook up the new refcount table in the qcow2 header */
580 data
.d64
= cpu_to_be64(table_offset
);
581 data
.d32
= cpu_to_be32(table_clusters
);
582 BLKDBG_EVENT(bs
->file
, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE
);
583 ret
= bdrv_pwrite_sync(bs
->file
,
584 offsetof(QCowHeader
, refcount_table_offset
),
585 &data
, sizeof(data
));
590 /* And switch it in memory */
591 uint64_t old_table_offset
= s
->refcount_table_offset
;
592 uint64_t old_table_size
= s
->refcount_table_size
;
594 g_free(s
->refcount_table
);
595 s
->refcount_table
= new_table
;
596 s
->refcount_table_size
= table_size
;
597 s
->refcount_table_offset
= table_offset
;
598 update_max_refcount_table_index(s
);
600 /* Free old table. */
601 qcow2_free_clusters(bs
, old_table_offset
, old_table_size
* sizeof(uint64_t),
602 QCOW2_DISCARD_OTHER
);
604 ret
= load_refcount_block(bs
, new_block
, refcount_block
);
609 /* If we were trying to do the initial refcount update for some cluster
610 * allocation, we might have used the same clusters to store newly
611 * allocated metadata. Make the caller search some new space. */
618 if (*refcount_block
!= NULL
) {
619 qcow2_cache_put(bs
, s
->refcount_block_cache
, refcount_block
);
624 void qcow2_process_discards(BlockDriverState
*bs
, int ret
)
626 BDRVQcow2State
*s
= bs
->opaque
;
627 Qcow2DiscardRegion
*d
, *next
;
629 QTAILQ_FOREACH_SAFE(d
, &s
->discards
, next
, next
) {
630 QTAILQ_REMOVE(&s
->discards
, d
, next
);
632 /* Discard is optional, ignore the return value */
634 bdrv_pdiscard(bs
->file
->bs
, d
->offset
, d
->bytes
);
641 static void update_refcount_discard(BlockDriverState
*bs
,
642 uint64_t offset
, uint64_t length
)
644 BDRVQcow2State
*s
= bs
->opaque
;
645 Qcow2DiscardRegion
*d
, *p
, *next
;
647 QTAILQ_FOREACH(d
, &s
->discards
, next
) {
648 uint64_t new_start
= MIN(offset
, d
->offset
);
649 uint64_t new_end
= MAX(offset
+ length
, d
->offset
+ d
->bytes
);
651 if (new_end
- new_start
<= length
+ d
->bytes
) {
652 /* There can't be any overlap, areas ending up here have no
653 * references any more and therefore shouldn't get freed another
655 assert(d
->bytes
+ length
== new_end
- new_start
);
656 d
->offset
= new_start
;
657 d
->bytes
= new_end
- new_start
;
662 d
= g_malloc(sizeof(*d
));
663 *d
= (Qcow2DiscardRegion
) {
668 QTAILQ_INSERT_TAIL(&s
->discards
, d
, next
);
671 /* Merge discard requests if they are adjacent now */
672 QTAILQ_FOREACH_SAFE(p
, &s
->discards
, next
, next
) {
674 || p
->offset
> d
->offset
+ d
->bytes
675 || d
->offset
> p
->offset
+ p
->bytes
)
680 /* Still no overlap possible */
681 assert(p
->offset
== d
->offset
+ d
->bytes
682 || d
->offset
== p
->offset
+ p
->bytes
);
684 QTAILQ_REMOVE(&s
->discards
, p
, next
);
685 d
->offset
= MIN(d
->offset
, p
->offset
);
686 d
->bytes
+= p
->bytes
;
691 /* XXX: cache several refcount block clusters ? */
692 /* @addend is the absolute value of the addend; if @decrease is set, @addend
693 * will be subtracted from the current refcount, otherwise it will be added */
694 static int QEMU_WARN_UNUSED_RESULT
update_refcount(BlockDriverState
*bs
,
699 enum qcow2_discard_type type
)
701 BDRVQcow2State
*s
= bs
->opaque
;
702 int64_t start
, last
, cluster_offset
;
703 void *refcount_block
= NULL
;
704 int64_t old_table_index
= -1;
708 fprintf(stderr
, "update_refcount: offset=%" PRId64
" size=%" PRId64
709 " addend=%s%" PRIu64
"\n", offset
, length
, decrease
? "-" : "",
714 } else if (length
== 0) {
719 qcow2_cache_set_dependency(bs
, s
->refcount_block_cache
,
723 start
= start_of_cluster(s
, offset
);
724 last
= start_of_cluster(s
, offset
+ length
- 1);
725 for(cluster_offset
= start
; cluster_offset
<= last
;
726 cluster_offset
+= s
->cluster_size
)
730 int64_t cluster_index
= cluster_offset
>> s
->cluster_bits
;
731 int64_t table_index
= cluster_index
>> s
->refcount_block_bits
;
733 /* Load the refcount block and allocate it if needed */
734 if (table_index
!= old_table_index
) {
735 if (refcount_block
) {
736 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refcount_block
);
738 ret
= alloc_refcount_block(bs
, cluster_index
, &refcount_block
);
743 old_table_index
= table_index
;
745 qcow2_cache_entry_mark_dirty(bs
, s
->refcount_block_cache
,
748 /* we can update the count and save it */
749 block_index
= cluster_index
& (s
->refcount_block_size
- 1);
751 refcount
= s
->get_refcount(refcount_block
, block_index
);
752 if (decrease
? (refcount
- addend
> refcount
)
753 : (refcount
+ addend
< refcount
||
754 refcount
+ addend
> s
->refcount_max
))
764 if (refcount
== 0 && cluster_index
< s
->free_cluster_index
) {
765 s
->free_cluster_index
= cluster_index
;
767 s
->set_refcount(refcount_block
, block_index
, refcount
);
769 if (refcount
== 0 && s
->discard_passthrough
[type
]) {
770 update_refcount_discard(bs
, cluster_offset
, s
->cluster_size
);
776 if (!s
->cache_discards
) {
777 qcow2_process_discards(bs
, ret
);
780 /* Write last changed block to disk */
781 if (refcount_block
) {
782 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refcount_block
);
786 * Try do undo any updates if an error is returned (This may succeed in
787 * some cases like ENOSPC for allocating a new refcount block)
791 dummy
= update_refcount(bs
, offset
, cluster_offset
- offset
, addend
,
792 !decrease
, QCOW2_DISCARD_NEVER
);
800 * Increases or decreases the refcount of a given cluster.
802 * @addend is the absolute value of the addend; if @decrease is set, @addend
803 * will be subtracted from the current refcount, otherwise it will be added.
805 * On success 0 is returned; on failure -errno is returned.
807 int qcow2_update_cluster_refcount(BlockDriverState
*bs
,
808 int64_t cluster_index
,
809 uint64_t addend
, bool decrease
,
810 enum qcow2_discard_type type
)
812 BDRVQcow2State
*s
= bs
->opaque
;
815 ret
= update_refcount(bs
, cluster_index
<< s
->cluster_bits
, 1, addend
,
826 /*********************************************************/
827 /* cluster allocation functions */
831 /* return < 0 if error */
832 static int64_t alloc_clusters_noref(BlockDriverState
*bs
, uint64_t size
)
834 BDRVQcow2State
*s
= bs
->opaque
;
835 uint64_t i
, nb_clusters
, refcount
;
838 /* We can't allocate clusters if they may still be queued for discard. */
839 if (s
->cache_discards
) {
840 qcow2_process_discards(bs
, 0);
843 nb_clusters
= size_to_clusters(s
, size
);
845 for(i
= 0; i
< nb_clusters
; i
++) {
846 uint64_t next_cluster_index
= s
->free_cluster_index
++;
847 ret
= qcow2_get_refcount(bs
, next_cluster_index
, &refcount
);
851 } else if (refcount
!= 0) {
856 /* Make sure that all offsets in the "allocated" range are representable
858 if (s
->free_cluster_index
> 0 &&
859 s
->free_cluster_index
- 1 > (INT64_MAX
>> s
->cluster_bits
))
865 fprintf(stderr
, "alloc_clusters: size=%" PRId64
" -> %" PRId64
"\n",
867 (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
);
869 return (s
->free_cluster_index
- nb_clusters
) << s
->cluster_bits
;
872 int64_t qcow2_alloc_clusters(BlockDriverState
*bs
, uint64_t size
)
877 BLKDBG_EVENT(bs
->file
, BLKDBG_CLUSTER_ALLOC
);
879 offset
= alloc_clusters_noref(bs
, size
);
884 ret
= update_refcount(bs
, offset
, size
, 1, false, QCOW2_DISCARD_NEVER
);
885 } while (ret
== -EAGAIN
);
894 int64_t qcow2_alloc_clusters_at(BlockDriverState
*bs
, uint64_t offset
,
897 BDRVQcow2State
*s
= bs
->opaque
;
898 uint64_t cluster_index
, refcount
;
902 assert(nb_clusters
>= 0);
903 if (nb_clusters
== 0) {
908 /* Check how many clusters there are free */
909 cluster_index
= offset
>> s
->cluster_bits
;
910 for(i
= 0; i
< nb_clusters
; i
++) {
911 ret
= qcow2_get_refcount(bs
, cluster_index
++, &refcount
);
914 } else if (refcount
!= 0) {
919 /* And then allocate them */
920 ret
= update_refcount(bs
, offset
, i
<< s
->cluster_bits
, 1, false,
921 QCOW2_DISCARD_NEVER
);
922 } while (ret
== -EAGAIN
);
931 /* only used to allocate compressed sectors. We try to allocate
932 contiguous sectors. size must be <= cluster_size */
933 int64_t qcow2_alloc_bytes(BlockDriverState
*bs
, int size
)
935 BDRVQcow2State
*s
= bs
->opaque
;
937 size_t free_in_cluster
;
940 BLKDBG_EVENT(bs
->file
, BLKDBG_CLUSTER_ALLOC_BYTES
);
941 assert(size
> 0 && size
<= s
->cluster_size
);
942 assert(!s
->free_byte_offset
|| offset_into_cluster(s
, s
->free_byte_offset
));
944 offset
= s
->free_byte_offset
;
948 ret
= qcow2_get_refcount(bs
, offset
>> s
->cluster_bits
, &refcount
);
953 if (refcount
== s
->refcount_max
) {
958 free_in_cluster
= s
->cluster_size
- offset_into_cluster(s
, offset
);
960 if (!offset
|| free_in_cluster
< size
) {
961 int64_t new_cluster
= alloc_clusters_noref(bs
, s
->cluster_size
);
962 if (new_cluster
< 0) {
966 if (!offset
|| ROUND_UP(offset
, s
->cluster_size
) != new_cluster
) {
967 offset
= new_cluster
;
968 free_in_cluster
= s
->cluster_size
;
970 free_in_cluster
+= s
->cluster_size
;
975 ret
= update_refcount(bs
, offset
, size
, 1, false, QCOW2_DISCARD_NEVER
);
979 } while (ret
== -EAGAIN
);
984 /* The cluster refcount was incremented; refcount blocks must be flushed
985 * before the caller's L2 table updates. */
986 qcow2_cache_set_dependency(bs
, s
->l2_table_cache
, s
->refcount_block_cache
);
988 s
->free_byte_offset
= offset
+ size
;
989 if (!offset_into_cluster(s
, s
->free_byte_offset
)) {
990 s
->free_byte_offset
= 0;
996 void qcow2_free_clusters(BlockDriverState
*bs
,
997 int64_t offset
, int64_t size
,
998 enum qcow2_discard_type type
)
1002 BLKDBG_EVENT(bs
->file
, BLKDBG_CLUSTER_FREE
);
1003 ret
= update_refcount(bs
, offset
, size
, 1, true, type
);
1005 fprintf(stderr
, "qcow2_free_clusters failed: %s\n", strerror(-ret
));
1006 /* TODO Remember the clusters to free them later and avoid leaking */
1011 * Free a cluster using its L2 entry (handles clusters of all types, e.g.
1012 * normal cluster, compressed cluster, etc.)
1014 void qcow2_free_any_clusters(BlockDriverState
*bs
, uint64_t l2_entry
,
1015 int nb_clusters
, enum qcow2_discard_type type
)
1017 BDRVQcow2State
*s
= bs
->opaque
;
1019 switch (qcow2_get_cluster_type(l2_entry
)) {
1020 case QCOW2_CLUSTER_COMPRESSED
:
1023 nb_csectors
= ((l2_entry
>> s
->csize_shift
) &
1025 qcow2_free_clusters(bs
,
1026 (l2_entry
& s
->cluster_offset_mask
) & ~511,
1027 nb_csectors
* 512, type
);
1030 case QCOW2_CLUSTER_NORMAL
:
1031 case QCOW2_CLUSTER_ZERO_ALLOC
:
1032 if (offset_into_cluster(s
, l2_entry
& L2E_OFFSET_MASK
)) {
1033 qcow2_signal_corruption(bs
, false, -1, -1,
1034 "Cannot free unaligned cluster %#llx",
1035 l2_entry
& L2E_OFFSET_MASK
);
1037 qcow2_free_clusters(bs
, l2_entry
& L2E_OFFSET_MASK
,
1038 nb_clusters
<< s
->cluster_bits
, type
);
1041 case QCOW2_CLUSTER_ZERO_PLAIN
:
1042 case QCOW2_CLUSTER_UNALLOCATED
:
1051 /*********************************************************/
1052 /* snapshots and image creation */
1056 /* update the refcounts of snapshots and the copied flag */
1057 int qcow2_update_snapshot_refcount(BlockDriverState
*bs
,
1058 int64_t l1_table_offset
, int l1_size
, int addend
)
1060 BDRVQcow2State
*s
= bs
->opaque
;
1061 uint64_t *l1_table
, *l2_table
, l2_offset
, entry
, l1_size2
, refcount
;
1062 bool l1_allocated
= false;
1063 int64_t old_entry
, old_l2_offset
;
1064 int i
, j
, l1_modified
= 0, nb_csectors
;
1067 assert(addend
>= -1 && addend
<= 1);
1071 l1_size2
= l1_size
* sizeof(uint64_t);
1073 s
->cache_discards
= true;
1075 /* WARNING: qcow2_snapshot_goto relies on this function not using the
1076 * l1_table_offset when it is the current s->l1_table_offset! Be careful
1077 * when changing this! */
1078 if (l1_table_offset
!= s
->l1_table_offset
) {
1079 l1_table
= g_try_malloc0(align_offset(l1_size2
, 512));
1080 if (l1_size2
&& l1_table
== NULL
) {
1084 l1_allocated
= true;
1086 ret
= bdrv_pread(bs
->file
, l1_table_offset
, l1_table
, l1_size2
);
1091 for (i
= 0; i
< l1_size
; i
++) {
1092 be64_to_cpus(&l1_table
[i
]);
1095 assert(l1_size
== s
->l1_size
);
1096 l1_table
= s
->l1_table
;
1097 l1_allocated
= false;
1100 for (i
= 0; i
< l1_size
; i
++) {
1101 l2_offset
= l1_table
[i
];
1103 old_l2_offset
= l2_offset
;
1104 l2_offset
&= L1E_OFFSET_MASK
;
1106 if (offset_into_cluster(s
, l2_offset
)) {
1107 qcow2_signal_corruption(bs
, true, -1, -1, "L2 table offset %#"
1108 PRIx64
" unaligned (L1 index: %#x)",
1114 ret
= qcow2_cache_get(bs
, s
->l2_table_cache
, l2_offset
,
1115 (void**) &l2_table
);
1120 for (j
= 0; j
< s
->l2_size
; j
++) {
1121 uint64_t cluster_index
;
1124 entry
= be64_to_cpu(l2_table
[j
]);
1126 entry
&= ~QCOW_OFLAG_COPIED
;
1127 offset
= entry
& L2E_OFFSET_MASK
;
1129 switch (qcow2_get_cluster_type(entry
)) {
1130 case QCOW2_CLUSTER_COMPRESSED
:
1131 nb_csectors
= ((entry
>> s
->csize_shift
) &
1134 ret
= update_refcount(bs
,
1135 (entry
& s
->cluster_offset_mask
) & ~511,
1136 nb_csectors
* 512, abs(addend
), addend
< 0,
1137 QCOW2_DISCARD_SNAPSHOT
);
1142 /* compressed clusters are never modified */
1146 case QCOW2_CLUSTER_NORMAL
:
1147 case QCOW2_CLUSTER_ZERO_ALLOC
:
1148 if (offset_into_cluster(s
, offset
)) {
1149 qcow2_signal_corruption(bs
, true, -1, -1, "Cluster "
1150 "allocation offset %#" PRIx64
1151 " unaligned (L2 offset: %#"
1152 PRIx64
", L2 index: %#x)",
1153 offset
, l2_offset
, j
);
1158 cluster_index
= offset
>> s
->cluster_bits
;
1159 assert(cluster_index
);
1161 ret
= qcow2_update_cluster_refcount(bs
,
1162 cluster_index
, abs(addend
), addend
< 0,
1163 QCOW2_DISCARD_SNAPSHOT
);
1169 ret
= qcow2_get_refcount(bs
, cluster_index
, &refcount
);
1175 case QCOW2_CLUSTER_ZERO_PLAIN
:
1176 case QCOW2_CLUSTER_UNALLOCATED
:
1184 if (refcount
== 1) {
1185 entry
|= QCOW_OFLAG_COPIED
;
1187 if (entry
!= old_entry
) {
1189 qcow2_cache_set_dependency(bs
, s
->l2_table_cache
,
1190 s
->refcount_block_cache
);
1192 l2_table
[j
] = cpu_to_be64(entry
);
1193 qcow2_cache_entry_mark_dirty(bs
, s
->l2_table_cache
,
1198 qcow2_cache_put(bs
, s
->l2_table_cache
, (void **) &l2_table
);
1201 ret
= qcow2_update_cluster_refcount(bs
, l2_offset
>>
1203 abs(addend
), addend
< 0,
1204 QCOW2_DISCARD_SNAPSHOT
);
1209 ret
= qcow2_get_refcount(bs
, l2_offset
>> s
->cluster_bits
,
1213 } else if (refcount
== 1) {
1214 l2_offset
|= QCOW_OFLAG_COPIED
;
1216 if (l2_offset
!= old_l2_offset
) {
1217 l1_table
[i
] = l2_offset
;
1223 ret
= bdrv_flush(bs
);
1226 qcow2_cache_put(bs
, s
->l2_table_cache
, (void**) &l2_table
);
1229 s
->cache_discards
= false;
1230 qcow2_process_discards(bs
, ret
);
1232 /* Update L1 only if it isn't deleted anyway (addend = -1) */
1233 if (ret
== 0 && addend
>= 0 && l1_modified
) {
1234 for (i
= 0; i
< l1_size
; i
++) {
1235 cpu_to_be64s(&l1_table
[i
]);
1238 ret
= bdrv_pwrite_sync(bs
->file
, l1_table_offset
,
1239 l1_table
, l1_size2
);
1241 for (i
= 0; i
< l1_size
; i
++) {
1242 be64_to_cpus(&l1_table
[i
]);
1253 /*********************************************************/
1254 /* refcount checking functions */
1257 static uint64_t refcount_array_byte_size(BDRVQcow2State
*s
, uint64_t entries
)
1259 /* This assertion holds because there is no way we can address more than
1260 * 2^(64 - 9) clusters at once (with cluster size 512 = 2^9, and because
1261 * offsets have to be representable in bytes); due to every cluster
1262 * corresponding to one refcount entry, we are well below that limit */
1263 assert(entries
< (UINT64_C(1) << (64 - 9)));
1265 /* Thanks to the assertion this will not overflow, because
1266 * s->refcount_order < 7.
1267 * (note: x << s->refcount_order == x * s->refcount_bits) */
1268 return DIV_ROUND_UP(entries
<< s
->refcount_order
, 8);
1272 * Reallocates *array so that it can hold new_size entries. *size must contain
1273 * the current number of entries in *array. If the reallocation fails, *array
1274 * and *size will not be modified and -errno will be returned. If the
1275 * reallocation is successful, *array will be set to the new buffer, *size
1276 * will be set to new_size and 0 will be returned. The size of the reallocated
1277 * refcount array buffer will be aligned to a cluster boundary, and the newly
1278 * allocated area will be zeroed.
1280 static int realloc_refcount_array(BDRVQcow2State
*s
, void **array
,
1281 int64_t *size
, int64_t new_size
)
1283 int64_t old_byte_size
, new_byte_size
;
1286 /* Round to clusters so the array can be directly written to disk */
1287 old_byte_size
= size_to_clusters(s
, refcount_array_byte_size(s
, *size
))
1289 new_byte_size
= size_to_clusters(s
, refcount_array_byte_size(s
, new_size
))
1292 if (new_byte_size
== old_byte_size
) {
1297 assert(new_byte_size
> 0);
1299 if (new_byte_size
> SIZE_MAX
) {
1303 new_ptr
= g_try_realloc(*array
, new_byte_size
);
1308 if (new_byte_size
> old_byte_size
) {
1309 memset((char *)new_ptr
+ old_byte_size
, 0,
1310 new_byte_size
- old_byte_size
);
1320 * Increases the refcount for a range of clusters in a given refcount table.
1321 * This is used to construct a temporary refcount table out of L1 and L2 tables
1322 * which can be compared to the refcount table saved in the image.
1324 * Modifies the number of errors in res.
1326 static int inc_refcounts(BlockDriverState
*bs
,
1327 BdrvCheckResult
*res
,
1328 void **refcount_table
,
1329 int64_t *refcount_table_size
,
1330 int64_t offset
, int64_t size
)
1332 BDRVQcow2State
*s
= bs
->opaque
;
1333 uint64_t start
, last
, cluster_offset
, k
, refcount
;
1340 start
= start_of_cluster(s
, offset
);
1341 last
= start_of_cluster(s
, offset
+ size
- 1);
1342 for(cluster_offset
= start
; cluster_offset
<= last
;
1343 cluster_offset
+= s
->cluster_size
) {
1344 k
= cluster_offset
>> s
->cluster_bits
;
1345 if (k
>= *refcount_table_size
) {
1346 ret
= realloc_refcount_array(s
, refcount_table
,
1347 refcount_table_size
, k
+ 1);
1349 res
->check_errors
++;
1354 refcount
= s
->get_refcount(*refcount_table
, k
);
1355 if (refcount
== s
->refcount_max
) {
1356 fprintf(stderr
, "ERROR: overflow cluster offset=0x%" PRIx64
1357 "\n", cluster_offset
);
1358 fprintf(stderr
, "Use qemu-img amend to increase the refcount entry "
1359 "width or qemu-img convert to create a clean copy if the "
1360 "image cannot be opened for writing\n");
1364 s
->set_refcount(*refcount_table
, k
, refcount
+ 1);
1370 /* Flags for check_refcounts_l1() and check_refcounts_l2() */
1372 CHECK_FRAG_INFO
= 0x2, /* update BlockFragInfo counters */
1376 * Increases the refcount in the given refcount table for the all clusters
1377 * referenced in the L2 table. While doing so, performs some checks on L2
1380 * Returns the number of errors found by the checks or -errno if an internal
1383 static int check_refcounts_l2(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1384 void **refcount_table
,
1385 int64_t *refcount_table_size
, int64_t l2_offset
,
1388 BDRVQcow2State
*s
= bs
->opaque
;
1389 uint64_t *l2_table
, l2_entry
;
1390 uint64_t next_contiguous_offset
= 0;
1391 int i
, l2_size
, nb_csectors
, ret
;
1393 /* Read L2 table from disk */
1394 l2_size
= s
->l2_size
* sizeof(uint64_t);
1395 l2_table
= g_malloc(l2_size
);
1397 ret
= bdrv_pread(bs
->file
, l2_offset
, l2_table
, l2_size
);
1399 fprintf(stderr
, "ERROR: I/O error in check_refcounts_l2\n");
1400 res
->check_errors
++;
1404 /* Do the actual checks */
1405 for(i
= 0; i
< s
->l2_size
; i
++) {
1406 l2_entry
= be64_to_cpu(l2_table
[i
]);
1408 switch (qcow2_get_cluster_type(l2_entry
)) {
1409 case QCOW2_CLUSTER_COMPRESSED
:
1410 /* Compressed clusters don't have QCOW_OFLAG_COPIED */
1411 if (l2_entry
& QCOW_OFLAG_COPIED
) {
1412 fprintf(stderr
, "ERROR: cluster %" PRId64
": "
1413 "copied flag must never be set for compressed "
1414 "clusters\n", l2_entry
>> s
->cluster_bits
);
1415 l2_entry
&= ~QCOW_OFLAG_COPIED
;
1419 /* Mark cluster as used */
1420 nb_csectors
= ((l2_entry
>> s
->csize_shift
) &
1422 l2_entry
&= s
->cluster_offset_mask
;
1423 ret
= inc_refcounts(bs
, res
, refcount_table
, refcount_table_size
,
1424 l2_entry
& ~511, nb_csectors
* 512);
1429 if (flags
& CHECK_FRAG_INFO
) {
1430 res
->bfi
.allocated_clusters
++;
1431 res
->bfi
.compressed_clusters
++;
1433 /* Compressed clusters are fragmented by nature. Since they
1434 * take up sub-sector space but we only have sector granularity
1435 * I/O we need to re-read the same sectors even for adjacent
1436 * compressed clusters.
1438 res
->bfi
.fragmented_clusters
++;
1442 case QCOW2_CLUSTER_ZERO_ALLOC
:
1443 case QCOW2_CLUSTER_NORMAL
:
1445 uint64_t offset
= l2_entry
& L2E_OFFSET_MASK
;
1447 if (flags
& CHECK_FRAG_INFO
) {
1448 res
->bfi
.allocated_clusters
++;
1449 if (next_contiguous_offset
&&
1450 offset
!= next_contiguous_offset
) {
1451 res
->bfi
.fragmented_clusters
++;
1453 next_contiguous_offset
= offset
+ s
->cluster_size
;
1456 /* Mark cluster as used */
1457 ret
= inc_refcounts(bs
, res
, refcount_table
, refcount_table_size
,
1458 offset
, s
->cluster_size
);
1463 /* Correct offsets are cluster aligned */
1464 if (offset_into_cluster(s
, offset
)) {
1465 fprintf(stderr
, "ERROR offset=%" PRIx64
": Cluster is not "
1466 "properly aligned; L2 entry corrupted.\n", offset
);
1472 case QCOW2_CLUSTER_ZERO_PLAIN
:
1473 case QCOW2_CLUSTER_UNALLOCATED
:
1490 * Increases the refcount for the L1 table, its L2 tables and all referenced
1491 * clusters in the given refcount table. While doing so, performs some checks
1492 * on L1 and L2 entries.
1494 * Returns the number of errors found by the checks or -errno if an internal
1497 static int check_refcounts_l1(BlockDriverState
*bs
,
1498 BdrvCheckResult
*res
,
1499 void **refcount_table
,
1500 int64_t *refcount_table_size
,
1501 int64_t l1_table_offset
, int l1_size
,
1504 BDRVQcow2State
*s
= bs
->opaque
;
1505 uint64_t *l1_table
= NULL
, l2_offset
, l1_size2
;
1508 l1_size2
= l1_size
* sizeof(uint64_t);
1510 /* Mark L1 table as used */
1511 ret
= inc_refcounts(bs
, res
, refcount_table
, refcount_table_size
,
1512 l1_table_offset
, l1_size2
);
1517 /* Read L1 table entries from disk */
1519 l1_table
= g_try_malloc(l1_size2
);
1520 if (l1_table
== NULL
) {
1522 res
->check_errors
++;
1525 ret
= bdrv_pread(bs
->file
, l1_table_offset
, l1_table
, l1_size2
);
1527 fprintf(stderr
, "ERROR: I/O error in check_refcounts_l1\n");
1528 res
->check_errors
++;
1531 for(i
= 0;i
< l1_size
; i
++)
1532 be64_to_cpus(&l1_table
[i
]);
1535 /* Do the actual checks */
1536 for(i
= 0; i
< l1_size
; i
++) {
1537 l2_offset
= l1_table
[i
];
1539 /* Mark L2 table as used */
1540 l2_offset
&= L1E_OFFSET_MASK
;
1541 ret
= inc_refcounts(bs
, res
, refcount_table
, refcount_table_size
,
1542 l2_offset
, s
->cluster_size
);
1547 /* L2 tables are cluster aligned */
1548 if (offset_into_cluster(s
, l2_offset
)) {
1549 fprintf(stderr
, "ERROR l2_offset=%" PRIx64
": Table is not "
1550 "cluster aligned; L1 entry corrupted\n", l2_offset
);
1554 /* Process and check L2 entries */
1555 ret
= check_refcounts_l2(bs
, res
, refcount_table
,
1556 refcount_table_size
, l2_offset
, flags
);
1571 * Checks the OFLAG_COPIED flag for all L1 and L2 entries.
1573 * This function does not print an error message nor does it increment
1574 * check_errors if qcow2_get_refcount fails (this is because such an error will
1575 * have been already detected and sufficiently signaled by the calling function
1576 * (qcow2_check_refcounts) by the time this function is called).
1578 static int check_oflag_copied(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1581 BDRVQcow2State
*s
= bs
->opaque
;
1582 uint64_t *l2_table
= qemu_blockalign(bs
, s
->cluster_size
);
1587 for (i
= 0; i
< s
->l1_size
; i
++) {
1588 uint64_t l1_entry
= s
->l1_table
[i
];
1589 uint64_t l2_offset
= l1_entry
& L1E_OFFSET_MASK
;
1590 bool l2_dirty
= false;
1596 ret
= qcow2_get_refcount(bs
, l2_offset
>> s
->cluster_bits
,
1599 /* don't print message nor increment check_errors */
1602 if ((refcount
== 1) != ((l1_entry
& QCOW_OFLAG_COPIED
) != 0)) {
1603 fprintf(stderr
, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
1604 "l1_entry=%" PRIx64
" refcount=%" PRIu64
"\n",
1605 fix
& BDRV_FIX_ERRORS
? "Repairing" :
1607 i
, l1_entry
, refcount
);
1608 if (fix
& BDRV_FIX_ERRORS
) {
1609 s
->l1_table
[i
] = refcount
== 1
1610 ? l1_entry
| QCOW_OFLAG_COPIED
1611 : l1_entry
& ~QCOW_OFLAG_COPIED
;
1612 ret
= qcow2_write_l1_entry(bs
, i
);
1614 res
->check_errors
++;
1617 res
->corruptions_fixed
++;
1623 ret
= bdrv_pread(bs
->file
, l2_offset
, l2_table
,
1624 s
->l2_size
* sizeof(uint64_t));
1626 fprintf(stderr
, "ERROR: Could not read L2 table: %s\n",
1628 res
->check_errors
++;
1632 for (j
= 0; j
< s
->l2_size
; j
++) {
1633 uint64_t l2_entry
= be64_to_cpu(l2_table
[j
]);
1634 uint64_t data_offset
= l2_entry
& L2E_OFFSET_MASK
;
1635 QCow2ClusterType cluster_type
= qcow2_get_cluster_type(l2_entry
);
1637 if (cluster_type
== QCOW2_CLUSTER_NORMAL
||
1638 cluster_type
== QCOW2_CLUSTER_ZERO_ALLOC
) {
1639 ret
= qcow2_get_refcount(bs
,
1640 data_offset
>> s
->cluster_bits
,
1643 /* don't print message nor increment check_errors */
1646 if ((refcount
== 1) != ((l2_entry
& QCOW_OFLAG_COPIED
) != 0)) {
1647 fprintf(stderr
, "%s OFLAG_COPIED data cluster: "
1648 "l2_entry=%" PRIx64
" refcount=%" PRIu64
"\n",
1649 fix
& BDRV_FIX_ERRORS
? "Repairing" :
1651 l2_entry
, refcount
);
1652 if (fix
& BDRV_FIX_ERRORS
) {
1653 l2_table
[j
] = cpu_to_be64(refcount
== 1
1654 ? l2_entry
| QCOW_OFLAG_COPIED
1655 : l2_entry
& ~QCOW_OFLAG_COPIED
);
1657 res
->corruptions_fixed
++;
1666 ret
= qcow2_pre_write_overlap_check(bs
, QCOW2_OL_ACTIVE_L2
,
1667 l2_offset
, s
->cluster_size
);
1669 fprintf(stderr
, "ERROR: Could not write L2 table; metadata "
1670 "overlap check failed: %s\n", strerror(-ret
));
1671 res
->check_errors
++;
1675 ret
= bdrv_pwrite(bs
->file
, l2_offset
, l2_table
,
1678 fprintf(stderr
, "ERROR: Could not write L2 table: %s\n",
1680 res
->check_errors
++;
1689 qemu_vfree(l2_table
);
1694 * Checks consistency of refblocks and accounts for each refblock in
1697 static int check_refblocks(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1698 BdrvCheckMode fix
, bool *rebuild
,
1699 void **refcount_table
, int64_t *nb_clusters
)
1701 BDRVQcow2State
*s
= bs
->opaque
;
1705 for(i
= 0; i
< s
->refcount_table_size
; i
++) {
1706 uint64_t offset
, cluster
;
1707 offset
= s
->refcount_table
[i
];
1708 cluster
= offset
>> s
->cluster_bits
;
1710 /* Refcount blocks are cluster aligned */
1711 if (offset_into_cluster(s
, offset
)) {
1712 fprintf(stderr
, "ERROR refcount block %" PRId64
" is not "
1713 "cluster aligned; refcount table entry corrupted\n", i
);
1719 if (cluster
>= *nb_clusters
) {
1720 fprintf(stderr
, "%s refcount block %" PRId64
" is outside image\n",
1721 fix
& BDRV_FIX_ERRORS
? "Repairing" : "ERROR", i
);
1723 if (fix
& BDRV_FIX_ERRORS
) {
1724 int64_t new_nb_clusters
;
1725 Error
*local_err
= NULL
;
1727 if (offset
> INT64_MAX
- s
->cluster_size
) {
1732 ret
= bdrv_truncate(bs
->file
, offset
+ s
->cluster_size
,
1735 error_report_err(local_err
);
1738 size
= bdrv_getlength(bs
->file
->bs
);
1744 new_nb_clusters
= size_to_clusters(s
, size
);
1745 assert(new_nb_clusters
>= *nb_clusters
);
1747 ret
= realloc_refcount_array(s
, refcount_table
,
1748 nb_clusters
, new_nb_clusters
);
1750 res
->check_errors
++;
1754 if (cluster
>= *nb_clusters
) {
1759 res
->corruptions_fixed
++;
1760 ret
= inc_refcounts(bs
, res
, refcount_table
, nb_clusters
,
1761 offset
, s
->cluster_size
);
1765 /* No need to check whether the refcount is now greater than 1:
1766 * This area was just allocated and zeroed, so it can only be
1767 * exactly 1 after inc_refcounts() */
1773 fprintf(stderr
, "ERROR could not resize image: %s\n",
1782 ret
= inc_refcounts(bs
, res
, refcount_table
, nb_clusters
,
1783 offset
, s
->cluster_size
);
1787 if (s
->get_refcount(*refcount_table
, cluster
) != 1) {
1788 fprintf(stderr
, "ERROR refcount block %" PRId64
1789 " refcount=%" PRIu64
"\n", i
,
1790 s
->get_refcount(*refcount_table
, cluster
));
1801 * Calculates an in-memory refcount table.
1803 static int calculate_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1804 BdrvCheckMode fix
, bool *rebuild
,
1805 void **refcount_table
, int64_t *nb_clusters
)
1807 BDRVQcow2State
*s
= bs
->opaque
;
1812 if (!*refcount_table
) {
1813 int64_t old_size
= 0;
1814 ret
= realloc_refcount_array(s
, refcount_table
,
1815 &old_size
, *nb_clusters
);
1817 res
->check_errors
++;
1823 ret
= inc_refcounts(bs
, res
, refcount_table
, nb_clusters
,
1824 0, s
->cluster_size
);
1829 /* current L1 table */
1830 ret
= check_refcounts_l1(bs
, res
, refcount_table
, nb_clusters
,
1831 s
->l1_table_offset
, s
->l1_size
, CHECK_FRAG_INFO
);
1837 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
1838 sn
= s
->snapshots
+ i
;
1839 ret
= check_refcounts_l1(bs
, res
, refcount_table
, nb_clusters
,
1840 sn
->l1_table_offset
, sn
->l1_size
, 0);
1845 ret
= inc_refcounts(bs
, res
, refcount_table
, nb_clusters
,
1846 s
->snapshots_offset
, s
->snapshots_size
);
1852 ret
= inc_refcounts(bs
, res
, refcount_table
, nb_clusters
,
1853 s
->refcount_table_offset
,
1854 s
->refcount_table_size
* sizeof(uint64_t));
1859 return check_refblocks(bs
, res
, fix
, rebuild
, refcount_table
, nb_clusters
);
1863 * Compares the actual reference count for each cluster in the image against the
1864 * refcount as reported by the refcount structures on-disk.
1866 static void compare_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
1867 BdrvCheckMode fix
, bool *rebuild
,
1868 int64_t *highest_cluster
,
1869 void *refcount_table
, int64_t nb_clusters
)
1871 BDRVQcow2State
*s
= bs
->opaque
;
1873 uint64_t refcount1
, refcount2
;
1876 for (i
= 0, *highest_cluster
= 0; i
< nb_clusters
; i
++) {
1877 ret
= qcow2_get_refcount(bs
, i
, &refcount1
);
1879 fprintf(stderr
, "Can't get refcount for cluster %" PRId64
": %s\n",
1881 res
->check_errors
++;
1885 refcount2
= s
->get_refcount(refcount_table
, i
);
1887 if (refcount1
> 0 || refcount2
> 0) {
1888 *highest_cluster
= i
;
1891 if (refcount1
!= refcount2
) {
1892 /* Check if we're allowed to fix the mismatch */
1893 int *num_fixed
= NULL
;
1894 if (refcount1
== 0) {
1896 } else if (refcount1
> refcount2
&& (fix
& BDRV_FIX_LEAKS
)) {
1897 num_fixed
= &res
->leaks_fixed
;
1898 } else if (refcount1
< refcount2
&& (fix
& BDRV_FIX_ERRORS
)) {
1899 num_fixed
= &res
->corruptions_fixed
;
1902 fprintf(stderr
, "%s cluster %" PRId64
" refcount=%" PRIu64
1903 " reference=%" PRIu64
"\n",
1904 num_fixed
!= NULL
? "Repairing" :
1905 refcount1
< refcount2
? "ERROR" :
1907 i
, refcount1
, refcount2
);
1910 ret
= update_refcount(bs
, i
<< s
->cluster_bits
, 1,
1911 refcount_diff(refcount1
, refcount2
),
1912 refcount1
> refcount2
,
1913 QCOW2_DISCARD_ALWAYS
);
1920 /* And if we couldn't, print an error */
1921 if (refcount1
< refcount2
) {
1931 * Allocates clusters using an in-memory refcount table (IMRT) in contrast to
1932 * the on-disk refcount structures.
1934 * On input, *first_free_cluster tells where to start looking, and need not
1935 * actually be a free cluster; the returned offset will not be before that
1936 * cluster. On output, *first_free_cluster points to the first gap found, even
1937 * if that gap was too small to be used as the returned offset.
1939 * Note that *first_free_cluster is a cluster index whereas the return value is
1942 static int64_t alloc_clusters_imrt(BlockDriverState
*bs
,
1944 void **refcount_table
,
1945 int64_t *imrt_nb_clusters
,
1946 int64_t *first_free_cluster
)
1948 BDRVQcow2State
*s
= bs
->opaque
;
1949 int64_t cluster
= *first_free_cluster
, i
;
1950 bool first_gap
= true;
1951 int contiguous_free_clusters
;
1954 /* Starting at *first_free_cluster, find a range of at least cluster_count
1955 * continuously free clusters */
1956 for (contiguous_free_clusters
= 0;
1957 cluster
< *imrt_nb_clusters
&&
1958 contiguous_free_clusters
< cluster_count
;
1961 if (!s
->get_refcount(*refcount_table
, cluster
)) {
1962 contiguous_free_clusters
++;
1964 /* If this is the first free cluster found, update
1965 * *first_free_cluster accordingly */
1966 *first_free_cluster
= cluster
;
1969 } else if (contiguous_free_clusters
) {
1970 contiguous_free_clusters
= 0;
1974 /* If contiguous_free_clusters is greater than zero, it contains the number
1975 * of continuously free clusters until the current cluster; the first free
1976 * cluster in the current "gap" is therefore
1977 * cluster - contiguous_free_clusters */
1979 /* If no such range could be found, grow the in-memory refcount table
1980 * accordingly to append free clusters at the end of the image */
1981 if (contiguous_free_clusters
< cluster_count
) {
1982 /* contiguous_free_clusters clusters are already empty at the image end;
1983 * we need cluster_count clusters; therefore, we have to allocate
1984 * cluster_count - contiguous_free_clusters new clusters at the end of
1985 * the image (which is the current value of cluster; note that cluster
1986 * may exceed old_imrt_nb_clusters if *first_free_cluster pointed beyond
1988 ret
= realloc_refcount_array(s
, refcount_table
, imrt_nb_clusters
,
1989 cluster
+ cluster_count
1990 - contiguous_free_clusters
);
1996 /* Go back to the first free cluster */
1997 cluster
-= contiguous_free_clusters
;
1998 for (i
= 0; i
< cluster_count
; i
++) {
1999 s
->set_refcount(*refcount_table
, cluster
+ i
, 1);
2002 return cluster
<< s
->cluster_bits
;
2006 * Creates a new refcount structure based solely on the in-memory information
2007 * given through *refcount_table. All necessary allocations will be reflected
2010 * On success, the old refcount structure is leaked (it will be covered by the
2011 * new refcount structure).
2013 static int rebuild_refcount_structure(BlockDriverState
*bs
,
2014 BdrvCheckResult
*res
,
2015 void **refcount_table
,
2016 int64_t *nb_clusters
)
2018 BDRVQcow2State
*s
= bs
->opaque
;
2019 int64_t first_free_cluster
= 0, reftable_offset
= -1, cluster
= 0;
2020 int64_t refblock_offset
, refblock_start
, refblock_index
;
2021 uint32_t reftable_size
= 0;
2022 uint64_t *on_disk_reftable
= NULL
;
2023 void *on_disk_refblock
;
2026 uint64_t reftable_offset
;
2027 uint32_t reftable_clusters
;
2028 } QEMU_PACKED reftable_offset_and_clusters
;
2030 qcow2_cache_empty(bs
, s
->refcount_block_cache
);
2033 for (; cluster
< *nb_clusters
; cluster
++) {
2034 if (!s
->get_refcount(*refcount_table
, cluster
)) {
2038 refblock_index
= cluster
>> s
->refcount_block_bits
;
2039 refblock_start
= refblock_index
<< s
->refcount_block_bits
;
2041 /* Don't allocate a cluster in a refblock already written to disk */
2042 if (first_free_cluster
< refblock_start
) {
2043 first_free_cluster
= refblock_start
;
2045 refblock_offset
= alloc_clusters_imrt(bs
, 1, refcount_table
,
2046 nb_clusters
, &first_free_cluster
);
2047 if (refblock_offset
< 0) {
2048 fprintf(stderr
, "ERROR allocating refblock: %s\n",
2049 strerror(-refblock_offset
));
2050 res
->check_errors
++;
2051 ret
= refblock_offset
;
2055 if (reftable_size
<= refblock_index
) {
2056 uint32_t old_reftable_size
= reftable_size
;
2057 uint64_t *new_on_disk_reftable
;
2059 reftable_size
= ROUND_UP((refblock_index
+ 1) * sizeof(uint64_t),
2060 s
->cluster_size
) / sizeof(uint64_t);
2061 new_on_disk_reftable
= g_try_realloc(on_disk_reftable
,
2064 if (!new_on_disk_reftable
) {
2065 res
->check_errors
++;
2069 on_disk_reftable
= new_on_disk_reftable
;
2071 memset(on_disk_reftable
+ old_reftable_size
, 0,
2072 (reftable_size
- old_reftable_size
) * sizeof(uint64_t));
2074 /* The offset we have for the reftable is now no longer valid;
2075 * this will leak that range, but we can easily fix that by running
2076 * a leak-fixing check after this rebuild operation */
2077 reftable_offset
= -1;
2079 on_disk_reftable
[refblock_index
] = refblock_offset
;
2081 /* If this is apparently the last refblock (for now), try to squeeze the
2083 if (refblock_index
== (*nb_clusters
- 1) >> s
->refcount_block_bits
&&
2084 reftable_offset
< 0)
2086 uint64_t reftable_clusters
= size_to_clusters(s
, reftable_size
*
2088 reftable_offset
= alloc_clusters_imrt(bs
, reftable_clusters
,
2089 refcount_table
, nb_clusters
,
2090 &first_free_cluster
);
2091 if (reftable_offset
< 0) {
2092 fprintf(stderr
, "ERROR allocating reftable: %s\n",
2093 strerror(-reftable_offset
));
2094 res
->check_errors
++;
2095 ret
= reftable_offset
;
2100 ret
= qcow2_pre_write_overlap_check(bs
, 0, refblock_offset
,
2103 fprintf(stderr
, "ERROR writing refblock: %s\n", strerror(-ret
));
2107 /* The size of *refcount_table is always cluster-aligned, therefore the
2108 * write operation will not overflow */
2109 on_disk_refblock
= (void *)((char *) *refcount_table
+
2110 refblock_index
* s
->cluster_size
);
2112 ret
= bdrv_write(bs
->file
, refblock_offset
/ BDRV_SECTOR_SIZE
,
2113 on_disk_refblock
, s
->cluster_sectors
);
2115 fprintf(stderr
, "ERROR writing refblock: %s\n", strerror(-ret
));
2119 /* Go to the end of this refblock */
2120 cluster
= refblock_start
+ s
->refcount_block_size
- 1;
2123 if (reftable_offset
< 0) {
2124 uint64_t post_refblock_start
, reftable_clusters
;
2126 post_refblock_start
= ROUND_UP(*nb_clusters
, s
->refcount_block_size
);
2127 reftable_clusters
= size_to_clusters(s
,
2128 reftable_size
* sizeof(uint64_t));
2129 /* Not pretty but simple */
2130 if (first_free_cluster
< post_refblock_start
) {
2131 first_free_cluster
= post_refblock_start
;
2133 reftable_offset
= alloc_clusters_imrt(bs
, reftable_clusters
,
2134 refcount_table
, nb_clusters
,
2135 &first_free_cluster
);
2136 if (reftable_offset
< 0) {
2137 fprintf(stderr
, "ERROR allocating reftable: %s\n",
2138 strerror(-reftable_offset
));
2139 res
->check_errors
++;
2140 ret
= reftable_offset
;
2144 goto write_refblocks
;
2147 assert(on_disk_reftable
);
2149 for (refblock_index
= 0; refblock_index
< reftable_size
; refblock_index
++) {
2150 cpu_to_be64s(&on_disk_reftable
[refblock_index
]);
2153 ret
= qcow2_pre_write_overlap_check(bs
, 0, reftable_offset
,
2154 reftable_size
* sizeof(uint64_t));
2156 fprintf(stderr
, "ERROR writing reftable: %s\n", strerror(-ret
));
2160 assert(reftable_size
< INT_MAX
/ sizeof(uint64_t));
2161 ret
= bdrv_pwrite(bs
->file
, reftable_offset
, on_disk_reftable
,
2162 reftable_size
* sizeof(uint64_t));
2164 fprintf(stderr
, "ERROR writing reftable: %s\n", strerror(-ret
));
2168 /* Enter new reftable into the image header */
2169 reftable_offset_and_clusters
.reftable_offset
= cpu_to_be64(reftable_offset
);
2170 reftable_offset_and_clusters
.reftable_clusters
=
2171 cpu_to_be32(size_to_clusters(s
, reftable_size
* sizeof(uint64_t)));
2172 ret
= bdrv_pwrite_sync(bs
->file
,
2173 offsetof(QCowHeader
, refcount_table_offset
),
2174 &reftable_offset_and_clusters
,
2175 sizeof(reftable_offset_and_clusters
));
2177 fprintf(stderr
, "ERROR setting reftable: %s\n", strerror(-ret
));
2181 for (refblock_index
= 0; refblock_index
< reftable_size
; refblock_index
++) {
2182 be64_to_cpus(&on_disk_reftable
[refblock_index
]);
2184 s
->refcount_table
= on_disk_reftable
;
2185 s
->refcount_table_offset
= reftable_offset
;
2186 s
->refcount_table_size
= reftable_size
;
2187 update_max_refcount_table_index(s
);
2192 g_free(on_disk_reftable
);
2197 * Checks an image for refcount consistency.
2199 * Returns 0 if no errors are found, the number of errors in case the image is
2200 * detected as corrupted, and -errno when an internal error occurred.
2202 int qcow2_check_refcounts(BlockDriverState
*bs
, BdrvCheckResult
*res
,
2205 BDRVQcow2State
*s
= bs
->opaque
;
2206 BdrvCheckResult pre_compare_res
;
2207 int64_t size
, highest_cluster
, nb_clusters
;
2208 void *refcount_table
= NULL
;
2209 bool rebuild
= false;
2212 size
= bdrv_getlength(bs
->file
->bs
);
2214 res
->check_errors
++;
2218 nb_clusters
= size_to_clusters(s
, size
);
2219 if (nb_clusters
> INT_MAX
) {
2220 res
->check_errors
++;
2224 res
->bfi
.total_clusters
=
2225 size_to_clusters(s
, bs
->total_sectors
* BDRV_SECTOR_SIZE
);
2227 ret
= calculate_refcounts(bs
, res
, fix
, &rebuild
, &refcount_table
,
2233 /* In case we don't need to rebuild the refcount structure (but want to fix
2234 * something), this function is immediately called again, in which case the
2235 * result should be ignored */
2236 pre_compare_res
= *res
;
2237 compare_refcounts(bs
, res
, 0, &rebuild
, &highest_cluster
, refcount_table
,
2240 if (rebuild
&& (fix
& BDRV_FIX_ERRORS
)) {
2241 BdrvCheckResult old_res
= *res
;
2242 int fresh_leaks
= 0;
2244 fprintf(stderr
, "Rebuilding refcount structure\n");
2245 ret
= rebuild_refcount_structure(bs
, res
, &refcount_table
,
2251 res
->corruptions
= 0;
2254 /* Because the old reftable has been exchanged for a new one the
2255 * references have to be recalculated */
2257 memset(refcount_table
, 0, refcount_array_byte_size(s
, nb_clusters
));
2258 ret
= calculate_refcounts(bs
, res
, 0, &rebuild
, &refcount_table
,
2264 if (fix
& BDRV_FIX_LEAKS
) {
2265 /* The old refcount structures are now leaked, fix it; the result
2266 * can be ignored, aside from leaks which were introduced by
2267 * rebuild_refcount_structure() that could not be fixed */
2268 BdrvCheckResult saved_res
= *res
;
2269 *res
= (BdrvCheckResult
){ 0 };
2271 compare_refcounts(bs
, res
, BDRV_FIX_LEAKS
, &rebuild
,
2272 &highest_cluster
, refcount_table
, nb_clusters
);
2274 fprintf(stderr
, "ERROR rebuilt refcount structure is still "
2278 /* Any leaks accounted for here were introduced by
2279 * rebuild_refcount_structure() because that function has created a
2280 * new refcount structure from scratch */
2281 fresh_leaks
= res
->leaks
;
2285 if (res
->corruptions
< old_res
.corruptions
) {
2286 res
->corruptions_fixed
+= old_res
.corruptions
- res
->corruptions
;
2288 if (res
->leaks
< old_res
.leaks
) {
2289 res
->leaks_fixed
+= old_res
.leaks
- res
->leaks
;
2291 res
->leaks
+= fresh_leaks
;
2294 fprintf(stderr
, "ERROR need to rebuild refcount structures\n");
2295 res
->check_errors
++;
2300 if (res
->leaks
|| res
->corruptions
) {
2301 *res
= pre_compare_res
;
2302 compare_refcounts(bs
, res
, fix
, &rebuild
, &highest_cluster
,
2303 refcount_table
, nb_clusters
);
2307 /* check OFLAG_COPIED */
2308 ret
= check_oflag_copied(bs
, res
, fix
);
2313 res
->image_end_offset
= (highest_cluster
+ 1) * s
->cluster_size
;
2317 g_free(refcount_table
);
2322 #define overlaps_with(ofs, sz) \
2323 ranges_overlap(offset, size, ofs, sz)
2326 * Checks if the given offset into the image file is actually free to use by
2327 * looking for overlaps with important metadata sections (L1/L2 tables etc.),
2328 * i.e. a sanity check without relying on the refcount tables.
2330 * The ign parameter specifies what checks not to perform (being a bitmask of
2331 * QCow2MetadataOverlap values), i.e., what sections to ignore.
2334 * - 0 if writing to this offset will not affect the mentioned metadata
2335 * - a positive QCow2MetadataOverlap value indicating one overlapping section
2336 * - a negative value (-errno) indicating an error while performing a check,
2337 * e.g. when bdrv_read failed on QCOW2_OL_INACTIVE_L2
2339 int qcow2_check_metadata_overlap(BlockDriverState
*bs
, int ign
, int64_t offset
,
2342 BDRVQcow2State
*s
= bs
->opaque
;
2343 int chk
= s
->overlap_check
& ~ign
;
2350 if (chk
& QCOW2_OL_MAIN_HEADER
) {
2351 if (offset
< s
->cluster_size
) {
2352 return QCOW2_OL_MAIN_HEADER
;
2356 /* align range to test to cluster boundaries */
2357 size
= align_offset(offset_into_cluster(s
, offset
) + size
, s
->cluster_size
);
2358 offset
= start_of_cluster(s
, offset
);
2360 if ((chk
& QCOW2_OL_ACTIVE_L1
) && s
->l1_size
) {
2361 if (overlaps_with(s
->l1_table_offset
, s
->l1_size
* sizeof(uint64_t))) {
2362 return QCOW2_OL_ACTIVE_L1
;
2366 if ((chk
& QCOW2_OL_REFCOUNT_TABLE
) && s
->refcount_table_size
) {
2367 if (overlaps_with(s
->refcount_table_offset
,
2368 s
->refcount_table_size
* sizeof(uint64_t))) {
2369 return QCOW2_OL_REFCOUNT_TABLE
;
2373 if ((chk
& QCOW2_OL_SNAPSHOT_TABLE
) && s
->snapshots_size
) {
2374 if (overlaps_with(s
->snapshots_offset
, s
->snapshots_size
)) {
2375 return QCOW2_OL_SNAPSHOT_TABLE
;
2379 if ((chk
& QCOW2_OL_INACTIVE_L1
) && s
->snapshots
) {
2380 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
2381 if (s
->snapshots
[i
].l1_size
&&
2382 overlaps_with(s
->snapshots
[i
].l1_table_offset
,
2383 s
->snapshots
[i
].l1_size
* sizeof(uint64_t))) {
2384 return QCOW2_OL_INACTIVE_L1
;
2389 if ((chk
& QCOW2_OL_ACTIVE_L2
) && s
->l1_table
) {
2390 for (i
= 0; i
< s
->l1_size
; i
++) {
2391 if ((s
->l1_table
[i
] & L1E_OFFSET_MASK
) &&
2392 overlaps_with(s
->l1_table
[i
] & L1E_OFFSET_MASK
,
2394 return QCOW2_OL_ACTIVE_L2
;
2399 if ((chk
& QCOW2_OL_REFCOUNT_BLOCK
) && s
->refcount_table
) {
2400 unsigned last_entry
= s
->max_refcount_table_index
;
2401 assert(last_entry
< s
->refcount_table_size
);
2402 assert(last_entry
+ 1 == s
->refcount_table_size
||
2403 (s
->refcount_table
[last_entry
+ 1] & REFT_OFFSET_MASK
) == 0);
2404 for (i
= 0; i
<= last_entry
; i
++) {
2405 if ((s
->refcount_table
[i
] & REFT_OFFSET_MASK
) &&
2406 overlaps_with(s
->refcount_table
[i
] & REFT_OFFSET_MASK
,
2408 return QCOW2_OL_REFCOUNT_BLOCK
;
2413 if ((chk
& QCOW2_OL_INACTIVE_L2
) && s
->snapshots
) {
2414 for (i
= 0; i
< s
->nb_snapshots
; i
++) {
2415 uint64_t l1_ofs
= s
->snapshots
[i
].l1_table_offset
;
2416 uint32_t l1_sz
= s
->snapshots
[i
].l1_size
;
2417 uint64_t l1_sz2
= l1_sz
* sizeof(uint64_t);
2418 uint64_t *l1
= g_try_malloc(l1_sz2
);
2421 if (l1_sz2
&& l1
== NULL
) {
2425 ret
= bdrv_pread(bs
->file
, l1_ofs
, l1
, l1_sz2
);
2431 for (j
= 0; j
< l1_sz
; j
++) {
2432 uint64_t l2_ofs
= be64_to_cpu(l1
[j
]) & L1E_OFFSET_MASK
;
2433 if (l2_ofs
&& overlaps_with(l2_ofs
, s
->cluster_size
)) {
2435 return QCOW2_OL_INACTIVE_L2
;
2446 static const char *metadata_ol_names
[] = {
2447 [QCOW2_OL_MAIN_HEADER_BITNR
] = "qcow2_header",
2448 [QCOW2_OL_ACTIVE_L1_BITNR
] = "active L1 table",
2449 [QCOW2_OL_ACTIVE_L2_BITNR
] = "active L2 table",
2450 [QCOW2_OL_REFCOUNT_TABLE_BITNR
] = "refcount table",
2451 [QCOW2_OL_REFCOUNT_BLOCK_BITNR
] = "refcount block",
2452 [QCOW2_OL_SNAPSHOT_TABLE_BITNR
] = "snapshot table",
2453 [QCOW2_OL_INACTIVE_L1_BITNR
] = "inactive L1 table",
2454 [QCOW2_OL_INACTIVE_L2_BITNR
] = "inactive L2 table",
2458 * First performs a check for metadata overlaps (through
2459 * qcow2_check_metadata_overlap); if that fails with a negative value (error
2460 * while performing a check), that value is returned. If an impending overlap
2461 * is detected, the BDS will be made unusable, the qcow2 file marked corrupt
2462 * and -EIO returned.
2464 * Returns 0 if there were neither overlaps nor errors while checking for
2465 * overlaps; or a negative value (-errno) on error.
2467 int qcow2_pre_write_overlap_check(BlockDriverState
*bs
, int ign
, int64_t offset
,
2470 int ret
= qcow2_check_metadata_overlap(bs
, ign
, offset
, size
);
2474 } else if (ret
> 0) {
2475 int metadata_ol_bitnr
= ctz32(ret
);
2476 assert(metadata_ol_bitnr
< QCOW2_OL_MAX_BITNR
);
2478 qcow2_signal_corruption(bs
, true, offset
, size
, "Preventing invalid "
2479 "write on metadata (overlaps with %s)",
2480 metadata_ol_names
[metadata_ol_bitnr
]);
2487 /* A pointer to a function of this type is given to walk_over_reftable(). That
2488 * function will create refblocks and pass them to a RefblockFinishOp once they
2489 * are completed (@refblock). @refblock_empty is set if the refblock is
2492 * Along with the refblock, a corresponding reftable entry is passed, in the
2493 * reftable @reftable (which may be reallocated) at @reftable_index.
2495 * @allocated should be set to true if a new cluster has been allocated.
2497 typedef int (RefblockFinishOp
)(BlockDriverState
*bs
, uint64_t **reftable
,
2498 uint64_t reftable_index
, uint64_t *reftable_size
,
2499 void *refblock
, bool refblock_empty
,
2500 bool *allocated
, Error
**errp
);
2503 * This "operation" for walk_over_reftable() allocates the refblock on disk (if
2504 * it is not empty) and inserts its offset into the new reftable. The size of
2505 * this new reftable is increased as required.
2507 static int alloc_refblock(BlockDriverState
*bs
, uint64_t **reftable
,
2508 uint64_t reftable_index
, uint64_t *reftable_size
,
2509 void *refblock
, bool refblock_empty
, bool *allocated
,
2512 BDRVQcow2State
*s
= bs
->opaque
;
2515 if (!refblock_empty
&& reftable_index
>= *reftable_size
) {
2516 uint64_t *new_reftable
;
2517 uint64_t new_reftable_size
;
2519 new_reftable_size
= ROUND_UP(reftable_index
+ 1,
2520 s
->cluster_size
/ sizeof(uint64_t));
2521 if (new_reftable_size
> QCOW_MAX_REFTABLE_SIZE
/ sizeof(uint64_t)) {
2523 "This operation would make the refcount table grow "
2524 "beyond the maximum size supported by QEMU, aborting");
2528 new_reftable
= g_try_realloc(*reftable
, new_reftable_size
*
2530 if (!new_reftable
) {
2531 error_setg(errp
, "Failed to increase reftable buffer size");
2535 memset(new_reftable
+ *reftable_size
, 0,
2536 (new_reftable_size
- *reftable_size
) * sizeof(uint64_t));
2538 *reftable
= new_reftable
;
2539 *reftable_size
= new_reftable_size
;
2542 if (!refblock_empty
&& !(*reftable
)[reftable_index
]) {
2543 offset
= qcow2_alloc_clusters(bs
, s
->cluster_size
);
2545 error_setg_errno(errp
, -offset
, "Failed to allocate refblock");
2548 (*reftable
)[reftable_index
] = offset
;
2556 * This "operation" for walk_over_reftable() writes the refblock to disk at the
2557 * offset specified by the new reftable's entry. It does not modify the new
2558 * reftable or change any refcounts.
2560 static int flush_refblock(BlockDriverState
*bs
, uint64_t **reftable
,
2561 uint64_t reftable_index
, uint64_t *reftable_size
,
2562 void *refblock
, bool refblock_empty
, bool *allocated
,
2565 BDRVQcow2State
*s
= bs
->opaque
;
2569 if (reftable_index
< *reftable_size
&& (*reftable
)[reftable_index
]) {
2570 offset
= (*reftable
)[reftable_index
];
2572 ret
= qcow2_pre_write_overlap_check(bs
, 0, offset
, s
->cluster_size
);
2574 error_setg_errno(errp
, -ret
, "Overlap check failed");
2578 ret
= bdrv_pwrite(bs
->file
, offset
, refblock
, s
->cluster_size
);
2580 error_setg_errno(errp
, -ret
, "Failed to write refblock");
2584 assert(refblock_empty
);
2591 * This function walks over the existing reftable and every referenced refblock;
2592 * if @new_set_refcount is non-NULL, it is called for every refcount entry to
2593 * create an equal new entry in the passed @new_refblock. Once that
2594 * @new_refblock is completely filled, @operation will be called.
2596 * @status_cb and @cb_opaque are used for the amend operation's status callback.
2597 * @index is the index of the walk_over_reftable() calls and @total is the total
2598 * number of walk_over_reftable() calls per amend operation. Both are used for
2599 * calculating the parameters for the status callback.
2601 * @allocated is set to true if a new cluster has been allocated.
2603 static int walk_over_reftable(BlockDriverState
*bs
, uint64_t **new_reftable
,
2604 uint64_t *new_reftable_index
,
2605 uint64_t *new_reftable_size
,
2606 void *new_refblock
, int new_refblock_size
,
2607 int new_refcount_bits
,
2608 RefblockFinishOp
*operation
, bool *allocated
,
2609 Qcow2SetRefcountFunc
*new_set_refcount
,
2610 BlockDriverAmendStatusCB
*status_cb
,
2611 void *cb_opaque
, int index
, int total
,
2614 BDRVQcow2State
*s
= bs
->opaque
;
2615 uint64_t reftable_index
;
2616 bool new_refblock_empty
= true;
2618 int new_refblock_index
= 0;
2621 for (reftable_index
= 0; reftable_index
< s
->refcount_table_size
;
2624 uint64_t refblock_offset
= s
->refcount_table
[reftable_index
]
2627 status_cb(bs
, (uint64_t)index
* s
->refcount_table_size
+ reftable_index
,
2628 (uint64_t)total
* s
->refcount_table_size
, cb_opaque
);
2630 if (refblock_offset
) {
2633 if (offset_into_cluster(s
, refblock_offset
)) {
2634 qcow2_signal_corruption(bs
, true, -1, -1, "Refblock offset %#"
2635 PRIx64
" unaligned (reftable index: %#"
2636 PRIx64
")", refblock_offset
,
2639 "Image is corrupt (unaligned refblock offset)");
2643 ret
= qcow2_cache_get(bs
, s
->refcount_block_cache
, refblock_offset
,
2646 error_setg_errno(errp
, -ret
, "Failed to retrieve refblock");
2650 for (refblock_index
= 0; refblock_index
< s
->refcount_block_size
;
2655 if (new_refblock_index
>= new_refblock_size
) {
2656 /* new_refblock is now complete */
2657 ret
= operation(bs
, new_reftable
, *new_reftable_index
,
2658 new_reftable_size
, new_refblock
,
2659 new_refblock_empty
, allocated
, errp
);
2661 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
2665 (*new_reftable_index
)++;
2666 new_refblock_index
= 0;
2667 new_refblock_empty
= true;
2670 refcount
= s
->get_refcount(refblock
, refblock_index
);
2671 if (new_refcount_bits
< 64 && refcount
>> new_refcount_bits
) {
2674 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
2676 offset
= ((reftable_index
<< s
->refcount_block_bits
)
2677 + refblock_index
) << s
->cluster_bits
;
2679 error_setg(errp
, "Cannot decrease refcount entry width to "
2680 "%i bits: Cluster at offset %#" PRIx64
" has a "
2681 "refcount of %" PRIu64
, new_refcount_bits
,
2686 if (new_set_refcount
) {
2687 new_set_refcount(new_refblock
, new_refblock_index
++,
2690 new_refblock_index
++;
2692 new_refblock_empty
= new_refblock_empty
&& refcount
== 0;
2695 qcow2_cache_put(bs
, s
->refcount_block_cache
, &refblock
);
2697 /* No refblock means every refcount is 0 */
2698 for (refblock_index
= 0; refblock_index
< s
->refcount_block_size
;
2701 if (new_refblock_index
>= new_refblock_size
) {
2702 /* new_refblock is now complete */
2703 ret
= operation(bs
, new_reftable
, *new_reftable_index
,
2704 new_reftable_size
, new_refblock
,
2705 new_refblock_empty
, allocated
, errp
);
2710 (*new_reftable_index
)++;
2711 new_refblock_index
= 0;
2712 new_refblock_empty
= true;
2715 if (new_set_refcount
) {
2716 new_set_refcount(new_refblock
, new_refblock_index
++, 0);
2718 new_refblock_index
++;
2724 if (new_refblock_index
> 0) {
2725 /* Complete the potentially existing partially filled final refblock */
2726 if (new_set_refcount
) {
2727 for (; new_refblock_index
< new_refblock_size
;
2728 new_refblock_index
++)
2730 new_set_refcount(new_refblock
, new_refblock_index
, 0);
2734 ret
= operation(bs
, new_reftable
, *new_reftable_index
,
2735 new_reftable_size
, new_refblock
, new_refblock_empty
,
2741 (*new_reftable_index
)++;
2744 status_cb(bs
, (uint64_t)(index
+ 1) * s
->refcount_table_size
,
2745 (uint64_t)total
* s
->refcount_table_size
, cb_opaque
);
2750 int qcow2_change_refcount_order(BlockDriverState
*bs
, int refcount_order
,
2751 BlockDriverAmendStatusCB
*status_cb
,
2752 void *cb_opaque
, Error
**errp
)
2754 BDRVQcow2State
*s
= bs
->opaque
;
2755 Qcow2GetRefcountFunc
*new_get_refcount
;
2756 Qcow2SetRefcountFunc
*new_set_refcount
;
2757 void *new_refblock
= qemu_blockalign(bs
->file
->bs
, s
->cluster_size
);
2758 uint64_t *new_reftable
= NULL
, new_reftable_size
= 0;
2759 uint64_t *old_reftable
, old_reftable_size
, old_reftable_offset
;
2760 uint64_t new_reftable_index
= 0;
2762 int64_t new_reftable_offset
= 0, allocated_reftable_size
= 0;
2763 int new_refblock_size
, new_refcount_bits
= 1 << refcount_order
;
2764 int old_refcount_order
;
2767 bool new_allocation
;
2769 assert(s
->qcow_version
>= 3);
2770 assert(refcount_order
>= 0 && refcount_order
<= 6);
2772 /* see qcow2_open() */
2773 new_refblock_size
= 1 << (s
->cluster_bits
- (refcount_order
- 3));
2775 new_get_refcount
= get_refcount_funcs
[refcount_order
];
2776 new_set_refcount
= set_refcount_funcs
[refcount_order
];
2782 new_allocation
= false;
2784 /* At least we have to do this walk and the one which writes the
2785 * refblocks; also, at least we have to do this loop here at least
2786 * twice (normally), first to do the allocations, and second to
2787 * determine that everything is correctly allocated, this then makes
2788 * three walks in total */
2789 total_walks
= MAX(walk_index
+ 2, 3);
2791 /* First, allocate the structures so they are present in the refcount
2793 ret
= walk_over_reftable(bs
, &new_reftable
, &new_reftable_index
,
2794 &new_reftable_size
, NULL
, new_refblock_size
,
2795 new_refcount_bits
, &alloc_refblock
,
2796 &new_allocation
, NULL
, status_cb
, cb_opaque
,
2797 walk_index
++, total_walks
, errp
);
2802 new_reftable_index
= 0;
2804 if (new_allocation
) {
2805 if (new_reftable_offset
) {
2806 qcow2_free_clusters(bs
, new_reftable_offset
,
2807 allocated_reftable_size
* sizeof(uint64_t),
2808 QCOW2_DISCARD_NEVER
);
2811 new_reftable_offset
= qcow2_alloc_clusters(bs
, new_reftable_size
*
2813 if (new_reftable_offset
< 0) {
2814 error_setg_errno(errp
, -new_reftable_offset
,
2815 "Failed to allocate the new reftable");
2816 ret
= new_reftable_offset
;
2819 allocated_reftable_size
= new_reftable_size
;
2821 } while (new_allocation
);
2823 /* Second, write the new refblocks */
2824 ret
= walk_over_reftable(bs
, &new_reftable
, &new_reftable_index
,
2825 &new_reftable_size
, new_refblock
,
2826 new_refblock_size
, new_refcount_bits
,
2827 &flush_refblock
, &new_allocation
, new_set_refcount
,
2828 status_cb
, cb_opaque
, walk_index
, walk_index
+ 1,
2833 assert(!new_allocation
);
2836 /* Write the new reftable */
2837 ret
= qcow2_pre_write_overlap_check(bs
, 0, new_reftable_offset
,
2838 new_reftable_size
* sizeof(uint64_t));
2840 error_setg_errno(errp
, -ret
, "Overlap check failed");
2844 for (i
= 0; i
< new_reftable_size
; i
++) {
2845 cpu_to_be64s(&new_reftable
[i
]);
2848 ret
= bdrv_pwrite(bs
->file
, new_reftable_offset
, new_reftable
,
2849 new_reftable_size
* sizeof(uint64_t));
2851 for (i
= 0; i
< new_reftable_size
; i
++) {
2852 be64_to_cpus(&new_reftable
[i
]);
2856 error_setg_errno(errp
, -ret
, "Failed to write the new reftable");
2861 /* Empty the refcount cache */
2862 ret
= qcow2_cache_flush(bs
, s
->refcount_block_cache
);
2864 error_setg_errno(errp
, -ret
, "Failed to flush the refblock cache");
2868 /* Update the image header to point to the new reftable; this only updates
2869 * the fields which are relevant to qcow2_update_header(); other fields
2870 * such as s->refcount_table or s->refcount_bits stay stale for now
2871 * (because we have to restore everything if qcow2_update_header() fails) */
2872 old_refcount_order
= s
->refcount_order
;
2873 old_reftable_size
= s
->refcount_table_size
;
2874 old_reftable_offset
= s
->refcount_table_offset
;
2876 s
->refcount_order
= refcount_order
;
2877 s
->refcount_table_size
= new_reftable_size
;
2878 s
->refcount_table_offset
= new_reftable_offset
;
2880 ret
= qcow2_update_header(bs
);
2882 s
->refcount_order
= old_refcount_order
;
2883 s
->refcount_table_size
= old_reftable_size
;
2884 s
->refcount_table_offset
= old_reftable_offset
;
2885 error_setg_errno(errp
, -ret
, "Failed to update the qcow2 header");
2889 /* Now update the rest of the in-memory information */
2890 old_reftable
= s
->refcount_table
;
2891 s
->refcount_table
= new_reftable
;
2892 update_max_refcount_table_index(s
);
2894 s
->refcount_bits
= 1 << refcount_order
;
2895 s
->refcount_max
= UINT64_C(1) << (s
->refcount_bits
- 1);
2896 s
->refcount_max
+= s
->refcount_max
- 1;
2898 s
->refcount_block_bits
= s
->cluster_bits
- (refcount_order
- 3);
2899 s
->refcount_block_size
= 1 << s
->refcount_block_bits
;
2901 s
->get_refcount
= new_get_refcount
;
2902 s
->set_refcount
= new_set_refcount
;
2904 /* For cleaning up all old refblocks and the old reftable below the "done"
2906 new_reftable
= old_reftable
;
2907 new_reftable_size
= old_reftable_size
;
2908 new_reftable_offset
= old_reftable_offset
;
2912 /* On success, new_reftable actually points to the old reftable (and
2913 * new_reftable_size is the old reftable's size); but that is just
2915 for (i
= 0; i
< new_reftable_size
; i
++) {
2916 uint64_t offset
= new_reftable
[i
] & REFT_OFFSET_MASK
;
2918 qcow2_free_clusters(bs
, offset
, s
->cluster_size
,
2919 QCOW2_DISCARD_OTHER
);
2922 g_free(new_reftable
);
2924 if (new_reftable_offset
> 0) {
2925 qcow2_free_clusters(bs
, new_reftable_offset
,
2926 new_reftable_size
* sizeof(uint64_t),
2927 QCOW2_DISCARD_OTHER
);
2931 qemu_vfree(new_refblock
);