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 int qcow2_refcount_init(BlockDriverState *bs)
88 BDRVQcow2State *s = bs->opaque;
89 unsigned int refcount_table_size2, i;
92 assert(s->refcount_order >= 0 && s->refcount_order <= 6);
94 s->get_refcount = get_refcount_funcs[s->refcount_order];
95 s->set_refcount = set_refcount_funcs[s->refcount_order];
97 assert(s->refcount_table_size <= INT_MAX / sizeof(uint64_t));
98 refcount_table_size2 = s->refcount_table_size * sizeof(uint64_t);
99 s->refcount_table = g_try_malloc(refcount_table_size2);
101 if (s->refcount_table_size > 0) {
102 if (s->refcount_table == NULL) {
106 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
107 ret = bdrv_pread(bs->file, s->refcount_table_offset,
108 s->refcount_table, refcount_table_size2);
112 for(i = 0; i < s->refcount_table_size; i++)
113 be64_to_cpus(&s->refcount_table[i]);
120 void qcow2_refcount_close(BlockDriverState *bs)
122 BDRVQcow2State *s = bs->opaque;
123 g_free(s->refcount_table);
127 static uint64_t get_refcount_ro0(const void *refcount_array, uint64_t index)
129 return (((const uint8_t *)refcount_array)[index / 8] >> (index % 8)) & 0x1;
132 static void set_refcount_ro0(void *refcount_array, uint64_t index,
135 assert(!(value >> 1));
136 ((uint8_t *)refcount_array)[index / 8] &= ~(0x1 << (index % 8));
137 ((uint8_t *)refcount_array)[index / 8] |= value << (index % 8);
140 static uint64_t get_refcount_ro1(const void *refcount_array, uint64_t index)
142 return (((const uint8_t *)refcount_array)[index / 4] >> (2 * (index % 4)))
146 static void set_refcount_ro1(void *refcount_array, uint64_t index,
149 assert(!(value >> 2));
150 ((uint8_t *)refcount_array)[index / 4] &= ~(0x3 << (2 * (index % 4)));
151 ((uint8_t *)refcount_array)[index / 4] |= value << (2 * (index % 4));
154 static uint64_t get_refcount_ro2(const void *refcount_array, uint64_t index)
156 return (((const uint8_t *)refcount_array)[index / 2] >> (4 * (index % 2)))
160 static void set_refcount_ro2(void *refcount_array, uint64_t index,
163 assert(!(value >> 4));
164 ((uint8_t *)refcount_array)[index / 2] &= ~(0xf << (4 * (index % 2)));
165 ((uint8_t *)refcount_array)[index / 2] |= value << (4 * (index % 2));
168 static uint64_t get_refcount_ro3(const void *refcount_array, uint64_t index)
170 return ((const uint8_t *)refcount_array)[index];
173 static void set_refcount_ro3(void *refcount_array, uint64_t index,
176 assert(!(value >> 8));
177 ((uint8_t *)refcount_array)[index] = value;
180 static uint64_t get_refcount_ro4(const void *refcount_array, uint64_t index)
182 return be16_to_cpu(((const uint16_t *)refcount_array)[index]);
185 static void set_refcount_ro4(void *refcount_array, uint64_t index,
188 assert(!(value >> 16));
189 ((uint16_t *)refcount_array)[index] = cpu_to_be16(value);
192 static uint64_t get_refcount_ro5(const void *refcount_array, uint64_t index)
194 return be32_to_cpu(((const uint32_t *)refcount_array)[index]);
197 static void set_refcount_ro5(void *refcount_array, uint64_t index,
200 assert(!(value >> 32));
201 ((uint32_t *)refcount_array)[index] = cpu_to_be32(value);
204 static uint64_t get_refcount_ro6(const void *refcount_array, uint64_t index)
206 return be64_to_cpu(((const uint64_t *)refcount_array)[index]);
209 static void set_refcount_ro6(void *refcount_array, uint64_t index,
212 ((uint64_t *)refcount_array)[index] = cpu_to_be64(value);
216 static int load_refcount_block(BlockDriverState *bs,
217 int64_t refcount_block_offset,
218 void **refcount_block)
220 BDRVQcow2State *s = bs->opaque;
222 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_LOAD);
223 return qcow2_cache_get(bs, s->refcount_block_cache, refcount_block_offset,
228 * Retrieves the refcount of the cluster given by its index and stores it in
229 * *refcount. Returns 0 on success and -errno on failure.
231 int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index,
234 BDRVQcow2State *s = bs->opaque;
235 uint64_t refcount_table_index, block_index;
236 int64_t refcount_block_offset;
238 void *refcount_block;
240 refcount_table_index = cluster_index >> s->refcount_block_bits;
241 if (refcount_table_index >= s->refcount_table_size) {
245 refcount_block_offset =
246 s->refcount_table[refcount_table_index] & REFT_OFFSET_MASK;
247 if (!refcount_block_offset) {
252 if (offset_into_cluster(s, refcount_block_offset)) {
253 qcow2_signal_corruption(bs, true, -1, -1, "Refblock offset %#" PRIx64
254 " unaligned (reftable index: %#" PRIx64 ")",
255 refcount_block_offset, refcount_table_index);
259 ret = qcow2_cache_get(bs, s->refcount_block_cache, refcount_block_offset,
265 block_index = cluster_index & (s->refcount_block_size - 1);
266 *refcount = s->get_refcount(refcount_block, block_index);
268 qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);
274 * Rounds the refcount table size up to avoid growing the table for each single
275 * refcount block that is allocated.
277 static unsigned int next_refcount_table_size(BDRVQcow2State *s,
278 unsigned int min_size)
280 unsigned int min_clusters = (min_size >> (s->cluster_bits - 3)) + 1;
281 unsigned int refcount_table_clusters =
282 MAX(1, s->refcount_table_size >> (s->cluster_bits - 3));
284 while (min_clusters > refcount_table_clusters) {
285 refcount_table_clusters = (refcount_table_clusters * 3 + 1) / 2;
288 return refcount_table_clusters << (s->cluster_bits - 3);
292 /* Checks if two offsets are described by the same refcount block */
293 static int in_same_refcount_block(BDRVQcow2State *s, uint64_t offset_a,
296 uint64_t block_a = offset_a >> (s->cluster_bits + s->refcount_block_bits);
297 uint64_t block_b = offset_b >> (s->cluster_bits + s->refcount_block_bits);
299 return (block_a == block_b);
303 * Loads a refcount block. If it doesn't exist yet, it is allocated first
304 * (including growing the refcount table if needed).
306 * Returns 0 on success or -errno in error case
308 static int alloc_refcount_block(BlockDriverState *bs,
309 int64_t cluster_index, void **refcount_block)
311 BDRVQcow2State *s = bs->opaque;
312 unsigned int refcount_table_index;
315 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
317 /* Find the refcount block for the given cluster */
318 refcount_table_index = cluster_index >> s->refcount_block_bits;
320 if (refcount_table_index < s->refcount_table_size) {
322 uint64_t refcount_block_offset =
323 s->refcount_table[refcount_table_index] & REFT_OFFSET_MASK;
325 /* If it's already there, we're done */
326 if (refcount_block_offset) {
327 if (offset_into_cluster(s, refcount_block_offset)) {
328 qcow2_signal_corruption(bs, true, -1, -1, "Refblock offset %#"
329 PRIx64 " unaligned (reftable index: "
330 "%#x)", refcount_block_offset,
331 refcount_table_index);
335 return load_refcount_block(bs, refcount_block_offset,
341 * If we came here, we need to allocate something. Something is at least
342 * a cluster for the new refcount block. It may also include a new refcount
343 * table if the old refcount table is too small.
345 * Note that allocating clusters here needs some special care:
347 * - We can't use the normal qcow2_alloc_clusters(), it would try to
348 * increase the refcount and very likely we would end up with an endless
349 * recursion. Instead we must place the refcount blocks in a way that
350 * they can describe them themselves.
352 * - We need to consider that at this point we are inside update_refcounts
353 * and potentially doing an initial refcount increase. This means that
354 * some clusters have already been allocated by the caller, but their
355 * refcount isn't accurate yet. If we allocate clusters for metadata, we
356 * need to return -EAGAIN to signal the caller that it needs to restart
357 * the search for free clusters.
359 * - alloc_clusters_noref and qcow2_free_clusters may load a different
360 * refcount block into the cache
363 *refcount_block = NULL;
365 /* We write to the refcount table, so we might depend on L2 tables */
366 ret = qcow2_cache_flush(bs, s->l2_table_cache);
371 /* Allocate the refcount block itself and mark it as used */
372 int64_t new_block = alloc_clusters_noref(bs, s->cluster_size);
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;
443 /* The new refcount block may be where the caller intended to put its
444 * data, so let it restart the search. */
448 qcow2_cache_put(bs, s->refcount_block_cache, refcount_block);
451 * If we come here, we need to grow the refcount table. Again, a new
452 * refcount table needs some space and we can't simply allocate to avoid
455 * Therefore let's grab new refcount blocks at the end of the image, which
456 * will describe themselves and the new refcount table. This way we can
457 * reference them only in the new table and do the switch to the new
458 * refcount table at once without producing an inconsistent state in
461 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_GROW);
463 /* Calculate the number of refcount blocks needed so far; this will be the
464 * basis for calculating the index of the first cluster used for the
465 * self-describing refcount structures which we are about to create.
467 * Because we reached this point, there cannot be any refcount entries for
468 * cluster_index or higher indices yet. However, because new_block has been
469 * allocated to describe that cluster (and it will assume this role later
470 * on), we cannot use that index; also, new_block may actually have a higher
471 * cluster index than cluster_index, so it needs to be taken into account
472 * here (and 1 needs to be added to its value because that cluster is used).
474 uint64_t blocks_used = DIV_ROUND_UP(MAX(cluster_index + 1,
475 (new_block >> s->cluster_bits) + 1),
476 s->refcount_block_size);
478 if (blocks_used > QCOW_MAX_REFTABLE_SIZE / sizeof(uint64_t)) {
482 /* And now we need at least one block more for the new metadata */
483 uint64_t table_size = next_refcount_table_size(s, blocks_used + 1);
484 uint64_t last_table_size;
485 uint64_t blocks_clusters;
487 uint64_t table_clusters =
488 size_to_clusters(s, table_size * sizeof(uint64_t));
489 blocks_clusters = 1 +
490 DIV_ROUND_UP(table_clusters, s->refcount_block_size);
491 uint64_t meta_clusters = table_clusters + blocks_clusters;
493 last_table_size = table_size;
494 table_size = next_refcount_table_size(s, blocks_used +
495 DIV_ROUND_UP(meta_clusters, s->refcount_block_size));
497 } while (last_table_size != table_size);
500 fprintf(stderr, "qcow2: Grow refcount table %" PRId32 " => %" PRId64 "\n",
501 s->refcount_table_size, table_size);
504 /* Create the new refcount table and blocks */
505 uint64_t meta_offset = (blocks_used * s->refcount_block_size) *
507 uint64_t table_offset = meta_offset + blocks_clusters * s->cluster_size;
508 uint64_t *new_table = g_try_new0(uint64_t, table_size);
509 void *new_blocks = g_try_malloc0(blocks_clusters * s->cluster_size);
511 assert(table_size > 0 && blocks_clusters > 0);
512 if (new_table == NULL || new_blocks == NULL) {
517 /* Fill the new refcount table */
518 memcpy(new_table, s->refcount_table,
519 s->refcount_table_size * sizeof(uint64_t));
520 new_table[refcount_table_index] = new_block;
523 for (i = 0; i < blocks_clusters; i++) {
524 new_table[blocks_used + i] = meta_offset + (i * s->cluster_size);
527 /* Fill the refcount blocks */
528 uint64_t table_clusters = size_to_clusters(s, table_size * sizeof(uint64_t));
530 for (i = 0; i < table_clusters + blocks_clusters; i++) {
531 s->set_refcount(new_blocks, block++, 1);
534 /* Write refcount blocks to disk */
535 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);
536 ret = bdrv_pwrite_sync(bs->file, meta_offset, new_blocks,
537 blocks_clusters * s->cluster_size);
544 /* Write refcount table to disk */
545 for(i = 0; i < table_size; i++) {
546 cpu_to_be64s(&new_table[i]);
549 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);
550 ret = bdrv_pwrite_sync(bs->file, table_offset, new_table,
551 table_size * sizeof(uint64_t));
556 for(i = 0; i < table_size; i++) {
557 be64_to_cpus(&new_table[i]);
560 /* Hook up the new refcount table in the qcow2 header */
565 data.d64 = cpu_to_be64(table_offset);
566 data.d32 = cpu_to_be32(table_clusters);
567 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
568 ret = bdrv_pwrite_sync(bs->file,
569 offsetof(QCowHeader, refcount_table_offset),
570 &data, sizeof(data));
575 /* And switch it in memory */
576 uint64_t old_table_offset = s->refcount_table_offset;
577 uint64_t old_table_size = s->refcount_table_size;
579 g_free(s->refcount_table);
580 s->refcount_table = new_table;
581 s->refcount_table_size = table_size;
582 s->refcount_table_offset = table_offset;
584 /* Free old table. */
585 qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t),
586 QCOW2_DISCARD_OTHER);
588 ret = load_refcount_block(bs, new_block, refcount_block);
593 /* If we were trying to do the initial refcount update for some cluster
594 * allocation, we might have used the same clusters to store newly
595 * allocated metadata. Make the caller search some new space. */
602 if (*refcount_block != NULL) {
603 qcow2_cache_put(bs, s->refcount_block_cache, refcount_block);
608 void qcow2_process_discards(BlockDriverState *bs, int ret)
610 BDRVQcow2State *s = bs->opaque;
611 Qcow2DiscardRegion *d, *next;
613 QTAILQ_FOREACH_SAFE(d, &s->discards, next, next) {
614 QTAILQ_REMOVE(&s->discards, d, next);
616 /* Discard is optional, ignore the return value */
618 bdrv_pdiscard(bs->file->bs, d->offset, d->bytes);
625 static void update_refcount_discard(BlockDriverState *bs,
626 uint64_t offset, uint64_t length)
628 BDRVQcow2State *s = bs->opaque;
629 Qcow2DiscardRegion *d, *p, *next;
631 QTAILQ_FOREACH(d, &s->discards, next) {
632 uint64_t new_start = MIN(offset, d->offset);
633 uint64_t new_end = MAX(offset + length, d->offset + d->bytes);
635 if (new_end - new_start <= length + d->bytes) {
636 /* There can't be any overlap, areas ending up here have no
637 * references any more and therefore shouldn't get freed another
639 assert(d->bytes + length == new_end - new_start);
640 d->offset = new_start;
641 d->bytes = new_end - new_start;
646 d = g_malloc(sizeof(*d));
647 *d = (Qcow2DiscardRegion) {
652 QTAILQ_INSERT_TAIL(&s->discards, d, next);
655 /* Merge discard requests if they are adjacent now */
656 QTAILQ_FOREACH_SAFE(p, &s->discards, next, next) {
658 || p->offset > d->offset + d->bytes
659 || d->offset > p->offset + p->bytes)
664 /* Still no overlap possible */
665 assert(p->offset == d->offset + d->bytes
666 || d->offset == p->offset + p->bytes);
668 QTAILQ_REMOVE(&s->discards, p, next);
669 d->offset = MIN(d->offset, p->offset);
670 d->bytes += p->bytes;
675 /* XXX: cache several refcount block clusters ? */
676 /* @addend is the absolute value of the addend; if @decrease is set, @addend
677 * will be subtracted from the current refcount, otherwise it will be added */
678 static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
683 enum qcow2_discard_type type)
685 BDRVQcow2State *s = bs->opaque;
686 int64_t start, last, cluster_offset;
687 void *refcount_block = NULL;
688 int64_t old_table_index = -1;
692 fprintf(stderr, "update_refcount: offset=%" PRId64 " size=%" PRId64
693 " addend=%s%" PRIu64 "\n", offset, length, decrease ? "-" : "",
698 } else if (length == 0) {
703 qcow2_cache_set_dependency(bs, s->refcount_block_cache,
707 start = start_of_cluster(s, offset);
708 last = start_of_cluster(s, offset + length - 1);
709 for(cluster_offset = start; cluster_offset <= last;
710 cluster_offset += s->cluster_size)
714 int64_t cluster_index = cluster_offset >> s->cluster_bits;
715 int64_t table_index = cluster_index >> s->refcount_block_bits;
717 /* Load the refcount block and allocate it if needed */
718 if (table_index != old_table_index) {
719 if (refcount_block) {
720 qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);
722 ret = alloc_refcount_block(bs, cluster_index, &refcount_block);
727 old_table_index = table_index;
729 qcow2_cache_entry_mark_dirty(bs, s->refcount_block_cache,
732 /* we can update the count and save it */
733 block_index = cluster_index & (s->refcount_block_size - 1);
735 refcount = s->get_refcount(refcount_block, block_index);
736 if (decrease ? (refcount - addend > refcount)
737 : (refcount + addend < refcount ||
738 refcount + addend > s->refcount_max))
748 if (refcount == 0 && cluster_index < s->free_cluster_index) {
749 s->free_cluster_index = cluster_index;
751 s->set_refcount(refcount_block, block_index, refcount);
753 if (refcount == 0 && s->discard_passthrough[type]) {
754 update_refcount_discard(bs, cluster_offset, s->cluster_size);
760 if (!s->cache_discards) {
761 qcow2_process_discards(bs, ret);
764 /* Write last changed block to disk */
765 if (refcount_block) {
766 qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);
770 * Try do undo any updates if an error is returned (This may succeed in
771 * some cases like ENOSPC for allocating a new refcount block)
775 dummy = update_refcount(bs, offset, cluster_offset - offset, addend,
776 !decrease, QCOW2_DISCARD_NEVER);
784 * Increases or decreases the refcount of a given cluster.
786 * @addend is the absolute value of the addend; if @decrease is set, @addend
787 * will be subtracted from the current refcount, otherwise it will be added.
789 * On success 0 is returned; on failure -errno is returned.
791 int qcow2_update_cluster_refcount(BlockDriverState *bs,
792 int64_t cluster_index,
793 uint64_t addend, bool decrease,
794 enum qcow2_discard_type type)
796 BDRVQcow2State *s = bs->opaque;
799 ret = update_refcount(bs, cluster_index << s->cluster_bits, 1, addend,
810 /*********************************************************/
811 /* cluster allocation functions */
815 /* return < 0 if error */
816 static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size)
818 BDRVQcow2State *s = bs->opaque;
819 uint64_t i, nb_clusters, refcount;
822 /* We can't allocate clusters if they may still be queued for discard. */
823 if (s->cache_discards) {
824 qcow2_process_discards(bs, 0);
827 nb_clusters = size_to_clusters(s, size);
829 for(i = 0; i < nb_clusters; i++) {
830 uint64_t next_cluster_index = s->free_cluster_index++;
831 ret = qcow2_get_refcount(bs, next_cluster_index, &refcount);
835 } else if (refcount != 0) {
840 /* Make sure that all offsets in the "allocated" range are representable
842 if (s->free_cluster_index > 0 &&
843 s->free_cluster_index - 1 > (INT64_MAX >> s->cluster_bits))
849 fprintf(stderr, "alloc_clusters: size=%" PRId64 " -> %" PRId64 "\n",
851 (s->free_cluster_index - nb_clusters) << s->cluster_bits);
853 return (s->free_cluster_index - nb_clusters) << s->cluster_bits;
856 int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size)
861 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
863 offset = alloc_clusters_noref(bs, size);
868 ret = update_refcount(bs, offset, size, 1, false, QCOW2_DISCARD_NEVER);
869 } while (ret == -EAGAIN);
878 int64_t qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
881 BDRVQcow2State *s = bs->opaque;
882 uint64_t cluster_index, refcount;
886 assert(nb_clusters >= 0);
887 if (nb_clusters == 0) {
892 /* Check how many clusters there are free */
893 cluster_index = offset >> s->cluster_bits;
894 for(i = 0; i < nb_clusters; i++) {
895 ret = qcow2_get_refcount(bs, cluster_index++, &refcount);
898 } else if (refcount != 0) {
903 /* And then allocate them */
904 ret = update_refcount(bs, offset, i << s->cluster_bits, 1, false,
905 QCOW2_DISCARD_NEVER);
906 } while (ret == -EAGAIN);
915 /* only used to allocate compressed sectors. We try to allocate
916 contiguous sectors. size must be <= cluster_size */
917 int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)
919 BDRVQcow2State *s = bs->opaque;
921 size_t free_in_cluster;
924 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_BYTES);
925 assert(size > 0 && size <= s->cluster_size);
926 assert(!s->free_byte_offset || offset_into_cluster(s, s->free_byte_offset));
928 offset = s->free_byte_offset;
932 ret = qcow2_get_refcount(bs, offset >> s->cluster_bits, &refcount);
937 if (refcount == s->refcount_max) {
942 free_in_cluster = s->cluster_size - offset_into_cluster(s, offset);
944 if (!offset || free_in_cluster < size) {
945 int64_t new_cluster = alloc_clusters_noref(bs, s->cluster_size);
946 if (new_cluster < 0) {
950 if (!offset || ROUND_UP(offset, s->cluster_size) != new_cluster) {
951 offset = new_cluster;
952 free_in_cluster = s->cluster_size;
954 free_in_cluster += s->cluster_size;
959 ret = update_refcount(bs, offset, size, 1, false, QCOW2_DISCARD_NEVER);
963 } while (ret == -EAGAIN);
968 /* The cluster refcount was incremented; refcount blocks must be flushed
969 * before the caller's L2 table updates. */
970 qcow2_cache_set_dependency(bs, s->l2_table_cache, s->refcount_block_cache);
972 s->free_byte_offset = offset + size;
973 if (!offset_into_cluster(s, s->free_byte_offset)) {
974 s->free_byte_offset = 0;
980 void qcow2_free_clusters(BlockDriverState *bs,
981 int64_t offset, int64_t size,
982 enum qcow2_discard_type type)
986 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_FREE);
987 ret = update_refcount(bs, offset, size, 1, true, type);
989 fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret));
990 /* TODO Remember the clusters to free them later and avoid leaking */
995 * Free a cluster using its L2 entry (handles clusters of all types, e.g.
996 * normal cluster, compressed cluster, etc.)
998 void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry,
999 int nb_clusters, enum qcow2_discard_type type)
1001 BDRVQcow2State *s = bs->opaque;
1003 switch (qcow2_get_cluster_type(l2_entry)) {
1004 case QCOW2_CLUSTER_COMPRESSED:
1007 nb_csectors = ((l2_entry >> s->csize_shift) &
1009 qcow2_free_clusters(bs,
1010 (l2_entry & s->cluster_offset_mask) & ~511,
1011 nb_csectors * 512, type);
1014 case QCOW2_CLUSTER_NORMAL:
1015 case QCOW2_CLUSTER_ZERO:
1016 if (l2_entry & L2E_OFFSET_MASK) {
1017 if (offset_into_cluster(s, l2_entry & L2E_OFFSET_MASK)) {
1018 qcow2_signal_corruption(bs, false, -1, -1,
1019 "Cannot free unaligned cluster %#llx",
1020 l2_entry & L2E_OFFSET_MASK);
1022 qcow2_free_clusters(bs, l2_entry & L2E_OFFSET_MASK,
1023 nb_clusters << s->cluster_bits, type);
1027 case QCOW2_CLUSTER_UNALLOCATED:
1036 /*********************************************************/
1037 /* snapshots and image creation */
1041 /* update the refcounts of snapshots and the copied flag */
1042 int qcow2_update_snapshot_refcount(BlockDriverState *bs,
1043 int64_t l1_table_offset, int l1_size, int addend)
1045 BDRVQcow2State *s = bs->opaque;
1046 uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, refcount;
1047 bool l1_allocated = false;
1048 int64_t old_offset, old_l2_offset;
1049 int i, j, l1_modified = 0, nb_csectors;
1052 assert(addend >= -1 && addend <= 1);
1056 l1_size2 = l1_size * sizeof(uint64_t);
1058 s->cache_discards = true;
1060 /* WARNING: qcow2_snapshot_goto relies on this function not using the
1061 * l1_table_offset when it is the current s->l1_table_offset! Be careful
1062 * when changing this! */
1063 if (l1_table_offset != s->l1_table_offset) {
1064 l1_table = g_try_malloc0(align_offset(l1_size2, 512));
1065 if (l1_size2 && l1_table == NULL) {
1069 l1_allocated = true;
1071 ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2);
1076 for(i = 0;i < l1_size; i++)
1077 be64_to_cpus(&l1_table[i]);
1079 assert(l1_size == s->l1_size);
1080 l1_table = s->l1_table;
1081 l1_allocated = false;
1084 for(i = 0; i < l1_size; i++) {
1085 l2_offset = l1_table[i];
1087 old_l2_offset = l2_offset;
1088 l2_offset &= L1E_OFFSET_MASK;
1090 if (offset_into_cluster(s, l2_offset)) {
1091 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#"
1092 PRIx64 " unaligned (L1 index: %#x)",
1098 ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
1099 (void**) &l2_table);
1104 for(j = 0; j < s->l2_size; j++) {
1105 uint64_t cluster_index;
1107 offset = be64_to_cpu(l2_table[j]);
1108 old_offset = offset;
1109 offset &= ~QCOW_OFLAG_COPIED;
1111 switch (qcow2_get_cluster_type(offset)) {
1112 case QCOW2_CLUSTER_COMPRESSED:
1113 nb_csectors = ((offset >> s->csize_shift) &
1116 ret = update_refcount(bs,
1117 (offset & s->cluster_offset_mask) & ~511,
1118 nb_csectors * 512, abs(addend), addend < 0,
1119 QCOW2_DISCARD_SNAPSHOT);
1124 /* compressed clusters are never modified */
1128 case QCOW2_CLUSTER_NORMAL:
1129 case QCOW2_CLUSTER_ZERO:
1130 if (offset_into_cluster(s, offset & L2E_OFFSET_MASK)) {
1131 qcow2_signal_corruption(bs, true, -1, -1, "Data "
1132 "cluster offset %#llx "
1133 "unaligned (L2 offset: %#"
1134 PRIx64 ", L2 index: %#x)",
1135 offset & L2E_OFFSET_MASK,
1141 cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits;
1142 if (!cluster_index) {
1148 ret = qcow2_update_cluster_refcount(bs,
1149 cluster_index, abs(addend), addend < 0,
1150 QCOW2_DISCARD_SNAPSHOT);
1156 ret = qcow2_get_refcount(bs, cluster_index, &refcount);
1162 case QCOW2_CLUSTER_UNALLOCATED:
1170 if (refcount == 1) {
1171 offset |= QCOW_OFLAG_COPIED;
1173 if (offset != old_offset) {
1175 qcow2_cache_set_dependency(bs, s->l2_table_cache,
1176 s->refcount_block_cache);
1178 l2_table[j] = cpu_to_be64(offset);
1179 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache,
1184 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table);
1187 ret = qcow2_update_cluster_refcount(bs, l2_offset >>
1189 abs(addend), addend < 0,
1190 QCOW2_DISCARD_SNAPSHOT);
1195 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
1199 } else if (refcount == 1) {
1200 l2_offset |= QCOW_OFLAG_COPIED;
1202 if (l2_offset != old_l2_offset) {
1203 l1_table[i] = l2_offset;
1209 ret = bdrv_flush(bs);
1212 qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
1215 s->cache_discards = false;
1216 qcow2_process_discards(bs, ret);
1218 /* Update L1 only if it isn't deleted anyway (addend = -1) */
1219 if (ret == 0 && addend >= 0 && l1_modified) {
1220 for (i = 0; i < l1_size; i++) {
1221 cpu_to_be64s(&l1_table[i]);
1224 ret = bdrv_pwrite_sync(bs->file, l1_table_offset,
1225 l1_table, l1_size2);
1227 for (i = 0; i < l1_size; i++) {
1228 be64_to_cpus(&l1_table[i]);
1239 /*********************************************************/
1240 /* refcount checking functions */
1243 static uint64_t refcount_array_byte_size(BDRVQcow2State *s, uint64_t entries)
1245 /* This assertion holds because there is no way we can address more than
1246 * 2^(64 - 9) clusters at once (with cluster size 512 = 2^9, and because
1247 * offsets have to be representable in bytes); due to every cluster
1248 * corresponding to one refcount entry, we are well below that limit */
1249 assert(entries < (UINT64_C(1) << (64 - 9)));
1251 /* Thanks to the assertion this will not overflow, because
1252 * s->refcount_order < 7.
1253 * (note: x << s->refcount_order == x * s->refcount_bits) */
1254 return DIV_ROUND_UP(entries << s->refcount_order, 8);
1258 * Reallocates *array so that it can hold new_size entries. *size must contain
1259 * the current number of entries in *array. If the reallocation fails, *array
1260 * and *size will not be modified and -errno will be returned. If the
1261 * reallocation is successful, *array will be set to the new buffer, *size
1262 * will be set to new_size and 0 will be returned. The size of the reallocated
1263 * refcount array buffer will be aligned to a cluster boundary, and the newly
1264 * allocated area will be zeroed.
1266 static int realloc_refcount_array(BDRVQcow2State *s, void **array,
1267 int64_t *size, int64_t new_size)
1269 int64_t old_byte_size, new_byte_size;
1272 /* Round to clusters so the array can be directly written to disk */
1273 old_byte_size = size_to_clusters(s, refcount_array_byte_size(s, *size))
1275 new_byte_size = size_to_clusters(s, refcount_array_byte_size(s, new_size))
1278 if (new_byte_size == old_byte_size) {
1283 assert(new_byte_size > 0);
1285 if (new_byte_size > SIZE_MAX) {
1289 new_ptr = g_try_realloc(*array, new_byte_size);
1294 if (new_byte_size > old_byte_size) {
1295 memset((char *)new_ptr + old_byte_size, 0,
1296 new_byte_size - old_byte_size);
1306 * Increases the refcount for a range of clusters in a given refcount table.
1307 * This is used to construct a temporary refcount table out of L1 and L2 tables
1308 * which can be compared to the refcount table saved in the image.
1310 * Modifies the number of errors in res.
1312 static int inc_refcounts(BlockDriverState *bs,
1313 BdrvCheckResult *res,
1314 void **refcount_table,
1315 int64_t *refcount_table_size,
1316 int64_t offset, int64_t size)
1318 BDRVQcow2State *s = bs->opaque;
1319 uint64_t start, last, cluster_offset, k, refcount;
1326 start = start_of_cluster(s, offset);
1327 last = start_of_cluster(s, offset + size - 1);
1328 for(cluster_offset = start; cluster_offset <= last;
1329 cluster_offset += s->cluster_size) {
1330 k = cluster_offset >> s->cluster_bits;
1331 if (k >= *refcount_table_size) {
1332 ret = realloc_refcount_array(s, refcount_table,
1333 refcount_table_size, k + 1);
1335 res->check_errors++;
1340 refcount = s->get_refcount(*refcount_table, k);
1341 if (refcount == s->refcount_max) {
1342 fprintf(stderr, "ERROR: overflow cluster offset=0x%" PRIx64
1343 "\n", cluster_offset);
1344 fprintf(stderr, "Use qemu-img amend to increase the refcount entry "
1345 "width or qemu-img convert to create a clean copy if the "
1346 "image cannot be opened for writing\n");
1350 s->set_refcount(*refcount_table, k, refcount + 1);
1356 /* Flags for check_refcounts_l1() and check_refcounts_l2() */
1358 CHECK_FRAG_INFO = 0x2, /* update BlockFragInfo counters */
1362 * Increases the refcount in the given refcount table for the all clusters
1363 * referenced in the L2 table. While doing so, performs some checks on L2
1366 * Returns the number of errors found by the checks or -errno if an internal
1369 static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
1370 void **refcount_table,
1371 int64_t *refcount_table_size, int64_t l2_offset,
1374 BDRVQcow2State *s = bs->opaque;
1375 uint64_t *l2_table, l2_entry;
1376 uint64_t next_contiguous_offset = 0;
1377 int i, l2_size, nb_csectors, ret;
1379 /* Read L2 table from disk */
1380 l2_size = s->l2_size * sizeof(uint64_t);
1381 l2_table = g_malloc(l2_size);
1383 ret = bdrv_pread(bs->file, l2_offset, l2_table, l2_size);
1385 fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
1386 res->check_errors++;
1390 /* Do the actual checks */
1391 for(i = 0; i < s->l2_size; i++) {
1392 l2_entry = be64_to_cpu(l2_table[i]);
1394 switch (qcow2_get_cluster_type(l2_entry)) {
1395 case QCOW2_CLUSTER_COMPRESSED:
1396 /* Compressed clusters don't have QCOW_OFLAG_COPIED */
1397 if (l2_entry & QCOW_OFLAG_COPIED) {
1398 fprintf(stderr, "ERROR: cluster %" PRId64 ": "
1399 "copied flag must never be set for compressed "
1400 "clusters\n", l2_entry >> s->cluster_bits);
1401 l2_entry &= ~QCOW_OFLAG_COPIED;
1405 /* Mark cluster as used */
1406 nb_csectors = ((l2_entry >> s->csize_shift) &
1408 l2_entry &= s->cluster_offset_mask;
1409 ret = inc_refcounts(bs, res, refcount_table, refcount_table_size,
1410 l2_entry & ~511, nb_csectors * 512);
1415 if (flags & CHECK_FRAG_INFO) {
1416 res->bfi.allocated_clusters++;
1417 res->bfi.compressed_clusters++;
1419 /* Compressed clusters are fragmented by nature. Since they
1420 * take up sub-sector space but we only have sector granularity
1421 * I/O we need to re-read the same sectors even for adjacent
1422 * compressed clusters.
1424 res->bfi.fragmented_clusters++;
1428 case QCOW2_CLUSTER_ZERO:
1429 if ((l2_entry & L2E_OFFSET_MASK) == 0) {
1434 case QCOW2_CLUSTER_NORMAL:
1436 uint64_t offset = l2_entry & L2E_OFFSET_MASK;
1438 if (flags & CHECK_FRAG_INFO) {
1439 res->bfi.allocated_clusters++;
1440 if (next_contiguous_offset &&
1441 offset != next_contiguous_offset) {
1442 res->bfi.fragmented_clusters++;
1444 next_contiguous_offset = offset + s->cluster_size;
1447 /* Mark cluster as used */
1448 ret = inc_refcounts(bs, res, refcount_table, refcount_table_size,
1449 offset, s->cluster_size);
1454 /* Correct offsets are cluster aligned */
1455 if (offset_into_cluster(s, offset)) {
1456 fprintf(stderr, "ERROR offset=%" PRIx64 ": Cluster is not "
1457 "properly aligned; L2 entry corrupted.\n", offset);
1463 case QCOW2_CLUSTER_UNALLOCATED:
1480 * Increases the refcount for the L1 table, its L2 tables and all referenced
1481 * clusters in the given refcount table. While doing so, performs some checks
1482 * on L1 and L2 entries.
1484 * Returns the number of errors found by the checks or -errno if an internal
1487 static int check_refcounts_l1(BlockDriverState *bs,
1488 BdrvCheckResult *res,
1489 void **refcount_table,
1490 int64_t *refcount_table_size,
1491 int64_t l1_table_offset, int l1_size,
1494 BDRVQcow2State *s = bs->opaque;
1495 uint64_t *l1_table = NULL, l2_offset, l1_size2;
1498 l1_size2 = l1_size * sizeof(uint64_t);
1500 /* Mark L1 table as used */
1501 ret = inc_refcounts(bs, res, refcount_table, refcount_table_size,
1502 l1_table_offset, l1_size2);
1507 /* Read L1 table entries from disk */
1509 l1_table = g_try_malloc(l1_size2);
1510 if (l1_table == NULL) {
1512 res->check_errors++;
1515 ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2);
1517 fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
1518 res->check_errors++;
1521 for(i = 0;i < l1_size; i++)
1522 be64_to_cpus(&l1_table[i]);
1525 /* Do the actual checks */
1526 for(i = 0; i < l1_size; i++) {
1527 l2_offset = l1_table[i];
1529 /* Mark L2 table as used */
1530 l2_offset &= L1E_OFFSET_MASK;
1531 ret = inc_refcounts(bs, res, refcount_table, refcount_table_size,
1532 l2_offset, s->cluster_size);
1537 /* L2 tables are cluster aligned */
1538 if (offset_into_cluster(s, l2_offset)) {
1539 fprintf(stderr, "ERROR l2_offset=%" PRIx64 ": Table is not "
1540 "cluster aligned; L1 entry corrupted\n", l2_offset);
1544 /* Process and check L2 entries */
1545 ret = check_refcounts_l2(bs, res, refcount_table,
1546 refcount_table_size, l2_offset, flags);
1561 * Checks the OFLAG_COPIED flag for all L1 and L2 entries.
1563 * This function does not print an error message nor does it increment
1564 * check_errors if qcow2_get_refcount fails (this is because such an error will
1565 * have been already detected and sufficiently signaled by the calling function
1566 * (qcow2_check_refcounts) by the time this function is called).
1568 static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
1571 BDRVQcow2State *s = bs->opaque;
1572 uint64_t *l2_table = qemu_blockalign(bs, s->cluster_size);
1577 for (i = 0; i < s->l1_size; i++) {
1578 uint64_t l1_entry = s->l1_table[i];
1579 uint64_t l2_offset = l1_entry & L1E_OFFSET_MASK;
1580 bool l2_dirty = false;
1586 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
1589 /* don't print message nor increment check_errors */
1592 if ((refcount == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
1593 fprintf(stderr, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
1594 "l1_entry=%" PRIx64 " refcount=%" PRIu64 "\n",
1595 fix & BDRV_FIX_ERRORS ? "Repairing" :
1597 i, l1_entry, refcount);
1598 if (fix & BDRV_FIX_ERRORS) {
1599 s->l1_table[i] = refcount == 1
1600 ? l1_entry | QCOW_OFLAG_COPIED
1601 : l1_entry & ~QCOW_OFLAG_COPIED;
1602 ret = qcow2_write_l1_entry(bs, i);
1604 res->check_errors++;
1607 res->corruptions_fixed++;
1613 ret = bdrv_pread(bs->file, l2_offset, l2_table,
1614 s->l2_size * sizeof(uint64_t));
1616 fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
1618 res->check_errors++;
1622 for (j = 0; j < s->l2_size; j++) {
1623 uint64_t l2_entry = be64_to_cpu(l2_table[j]);
1624 uint64_t data_offset = l2_entry & L2E_OFFSET_MASK;
1625 int cluster_type = qcow2_get_cluster_type(l2_entry);
1627 if ((cluster_type == QCOW2_CLUSTER_NORMAL) ||
1628 ((cluster_type == QCOW2_CLUSTER_ZERO) && (data_offset != 0))) {
1629 ret = qcow2_get_refcount(bs,
1630 data_offset >> s->cluster_bits,
1633 /* don't print message nor increment check_errors */
1636 if ((refcount == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
1637 fprintf(stderr, "%s OFLAG_COPIED data cluster: "
1638 "l2_entry=%" PRIx64 " refcount=%" PRIu64 "\n",
1639 fix & BDRV_FIX_ERRORS ? "Repairing" :
1641 l2_entry, refcount);
1642 if (fix & BDRV_FIX_ERRORS) {
1643 l2_table[j] = cpu_to_be64(refcount == 1
1644 ? l2_entry | QCOW_OFLAG_COPIED
1645 : l2_entry & ~QCOW_OFLAG_COPIED);
1647 res->corruptions_fixed++;
1656 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
1657 l2_offset, s->cluster_size);
1659 fprintf(stderr, "ERROR: Could not write L2 table; metadata "
1660 "overlap check failed: %s\n", strerror(-ret));
1661 res->check_errors++;
1665 ret = bdrv_pwrite(bs->file, l2_offset, l2_table,
1668 fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
1670 res->check_errors++;
1679 qemu_vfree(l2_table);
1684 * Checks consistency of refblocks and accounts for each refblock in
1687 static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
1688 BdrvCheckMode fix, bool *rebuild,
1689 void **refcount_table, int64_t *nb_clusters)
1691 BDRVQcow2State *s = bs->opaque;
1695 for(i = 0; i < s->refcount_table_size; i++) {
1696 uint64_t offset, cluster;
1697 offset = s->refcount_table[i];
1698 cluster = offset >> s->cluster_bits;
1700 /* Refcount blocks are cluster aligned */
1701 if (offset_into_cluster(s, offset)) {
1702 fprintf(stderr, "ERROR refcount block %" PRId64 " is not "
1703 "cluster aligned; refcount table entry corrupted\n", i);
1709 if (cluster >= *nb_clusters) {
1710 fprintf(stderr, "%s refcount block %" PRId64 " is outside image\n",
1711 fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);
1713 if (fix & BDRV_FIX_ERRORS) {
1714 int64_t new_nb_clusters;
1716 if (offset > INT64_MAX - s->cluster_size) {
1721 ret = bdrv_truncate(bs->file->bs, offset + s->cluster_size);
1725 size = bdrv_getlength(bs->file->bs);
1731 new_nb_clusters = size_to_clusters(s, size);
1732 assert(new_nb_clusters >= *nb_clusters);
1734 ret = realloc_refcount_array(s, refcount_table,
1735 nb_clusters, new_nb_clusters);
1737 res->check_errors++;
1741 if (cluster >= *nb_clusters) {
1746 res->corruptions_fixed++;
1747 ret = inc_refcounts(bs, res, refcount_table, nb_clusters,
1748 offset, s->cluster_size);
1752 /* No need to check whether the refcount is now greater than 1:
1753 * This area was just allocated and zeroed, so it can only be
1754 * exactly 1 after inc_refcounts() */
1760 fprintf(stderr, "ERROR could not resize image: %s\n",
1769 ret = inc_refcounts(bs, res, refcount_table, nb_clusters,
1770 offset, s->cluster_size);
1774 if (s->get_refcount(*refcount_table, cluster) != 1) {
1775 fprintf(stderr, "ERROR refcount block %" PRId64
1776 " refcount=%" PRIu64 "\n", i,
1777 s->get_refcount(*refcount_table, cluster));
1788 * Calculates an in-memory refcount table.
1790 static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
1791 BdrvCheckMode fix, bool *rebuild,
1792 void **refcount_table, int64_t *nb_clusters)
1794 BDRVQcow2State *s = bs->opaque;
1799 if (!*refcount_table) {
1800 int64_t old_size = 0;
1801 ret = realloc_refcount_array(s, refcount_table,
1802 &old_size, *nb_clusters);
1804 res->check_errors++;
1810 ret = inc_refcounts(bs, res, refcount_table, nb_clusters,
1811 0, s->cluster_size);
1816 /* current L1 table */
1817 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
1818 s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO);
1824 for (i = 0; i < s->nb_snapshots; i++) {
1825 sn = s->snapshots + i;
1826 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
1827 sn->l1_table_offset, sn->l1_size, 0);
1832 ret = inc_refcounts(bs, res, refcount_table, nb_clusters,
1833 s->snapshots_offset, s->snapshots_size);
1839 ret = inc_refcounts(bs, res, refcount_table, nb_clusters,
1840 s->refcount_table_offset,
1841 s->refcount_table_size * sizeof(uint64_t));
1846 return check_refblocks(bs, res, fix, rebuild, refcount_table, nb_clusters);
1850 * Compares the actual reference count for each cluster in the image against the
1851 * refcount as reported by the refcount structures on-disk.
1853 static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
1854 BdrvCheckMode fix, bool *rebuild,
1855 int64_t *highest_cluster,
1856 void *refcount_table, int64_t nb_clusters)
1858 BDRVQcow2State *s = bs->opaque;
1860 uint64_t refcount1, refcount2;
1863 for (i = 0, *highest_cluster = 0; i < nb_clusters; i++) {
1864 ret = qcow2_get_refcount(bs, i, &refcount1);
1866 fprintf(stderr, "Can't get refcount for cluster %" PRId64 ": %s\n",
1868 res->check_errors++;
1872 refcount2 = s->get_refcount(refcount_table, i);
1874 if (refcount1 > 0 || refcount2 > 0) {
1875 *highest_cluster = i;
1878 if (refcount1 != refcount2) {
1879 /* Check if we're allowed to fix the mismatch */
1880 int *num_fixed = NULL;
1881 if (refcount1 == 0) {
1883 } else if (refcount1 > refcount2 && (fix & BDRV_FIX_LEAKS)) {
1884 num_fixed = &res->leaks_fixed;
1885 } else if (refcount1 < refcount2 && (fix & BDRV_FIX_ERRORS)) {
1886 num_fixed = &res->corruptions_fixed;
1889 fprintf(stderr, "%s cluster %" PRId64 " refcount=%" PRIu64
1890 " reference=%" PRIu64 "\n",
1891 num_fixed != NULL ? "Repairing" :
1892 refcount1 < refcount2 ? "ERROR" :
1894 i, refcount1, refcount2);
1897 ret = update_refcount(bs, i << s->cluster_bits, 1,
1898 refcount_diff(refcount1, refcount2),
1899 refcount1 > refcount2,
1900 QCOW2_DISCARD_ALWAYS);
1907 /* And if we couldn't, print an error */
1908 if (refcount1 < refcount2) {
1918 * Allocates clusters using an in-memory refcount table (IMRT) in contrast to
1919 * the on-disk refcount structures.
1921 * On input, *first_free_cluster tells where to start looking, and need not
1922 * actually be a free cluster; the returned offset will not be before that
1923 * cluster. On output, *first_free_cluster points to the first gap found, even
1924 * if that gap was too small to be used as the returned offset.
1926 * Note that *first_free_cluster is a cluster index whereas the return value is
1929 static int64_t alloc_clusters_imrt(BlockDriverState *bs,
1931 void **refcount_table,
1932 int64_t *imrt_nb_clusters,
1933 int64_t *first_free_cluster)
1935 BDRVQcow2State *s = bs->opaque;
1936 int64_t cluster = *first_free_cluster, i;
1937 bool first_gap = true;
1938 int contiguous_free_clusters;
1941 /* Starting at *first_free_cluster, find a range of at least cluster_count
1942 * continuously free clusters */
1943 for (contiguous_free_clusters = 0;
1944 cluster < *imrt_nb_clusters &&
1945 contiguous_free_clusters < cluster_count;
1948 if (!s->get_refcount(*refcount_table, cluster)) {
1949 contiguous_free_clusters++;
1951 /* If this is the first free cluster found, update
1952 * *first_free_cluster accordingly */
1953 *first_free_cluster = cluster;
1956 } else if (contiguous_free_clusters) {
1957 contiguous_free_clusters = 0;
1961 /* If contiguous_free_clusters is greater than zero, it contains the number
1962 * of continuously free clusters until the current cluster; the first free
1963 * cluster in the current "gap" is therefore
1964 * cluster - contiguous_free_clusters */
1966 /* If no such range could be found, grow the in-memory refcount table
1967 * accordingly to append free clusters at the end of the image */
1968 if (contiguous_free_clusters < cluster_count) {
1969 /* contiguous_free_clusters clusters are already empty at the image end;
1970 * we need cluster_count clusters; therefore, we have to allocate
1971 * cluster_count - contiguous_free_clusters new clusters at the end of
1972 * the image (which is the current value of cluster; note that cluster
1973 * may exceed old_imrt_nb_clusters if *first_free_cluster pointed beyond
1975 ret = realloc_refcount_array(s, refcount_table, imrt_nb_clusters,
1976 cluster + cluster_count
1977 - contiguous_free_clusters);
1983 /* Go back to the first free cluster */
1984 cluster -= contiguous_free_clusters;
1985 for (i = 0; i < cluster_count; i++) {
1986 s->set_refcount(*refcount_table, cluster + i, 1);
1989 return cluster << s->cluster_bits;
1993 * Creates a new refcount structure based solely on the in-memory information
1994 * given through *refcount_table. All necessary allocations will be reflected
1997 * On success, the old refcount structure is leaked (it will be covered by the
1998 * new refcount structure).
2000 static int rebuild_refcount_structure(BlockDriverState *bs,
2001 BdrvCheckResult *res,
2002 void **refcount_table,
2003 int64_t *nb_clusters)
2005 BDRVQcow2State *s = bs->opaque;
2006 int64_t first_free_cluster = 0, reftable_offset = -1, cluster = 0;
2007 int64_t refblock_offset, refblock_start, refblock_index;
2008 uint32_t reftable_size = 0;
2009 uint64_t *on_disk_reftable = NULL;
2010 void *on_disk_refblock;
2013 uint64_t reftable_offset;
2014 uint32_t reftable_clusters;
2015 } QEMU_PACKED reftable_offset_and_clusters;
2017 qcow2_cache_empty(bs, s->refcount_block_cache);
2020 for (; cluster < *nb_clusters; cluster++) {
2021 if (!s->get_refcount(*refcount_table, cluster)) {
2025 refblock_index = cluster >> s->refcount_block_bits;
2026 refblock_start = refblock_index << s->refcount_block_bits;
2028 /* Don't allocate a cluster in a refblock already written to disk */
2029 if (first_free_cluster < refblock_start) {
2030 first_free_cluster = refblock_start;
2032 refblock_offset = alloc_clusters_imrt(bs, 1, refcount_table,
2033 nb_clusters, &first_free_cluster);
2034 if (refblock_offset < 0) {
2035 fprintf(stderr, "ERROR allocating refblock: %s\n",
2036 strerror(-refblock_offset));
2037 res->check_errors++;
2038 ret = refblock_offset;
2042 if (reftable_size <= refblock_index) {
2043 uint32_t old_reftable_size = reftable_size;
2044 uint64_t *new_on_disk_reftable;
2046 reftable_size = ROUND_UP((refblock_index + 1) * sizeof(uint64_t),
2047 s->cluster_size) / sizeof(uint64_t);
2048 new_on_disk_reftable = g_try_realloc(on_disk_reftable,
2051 if (!new_on_disk_reftable) {
2052 res->check_errors++;
2056 on_disk_reftable = new_on_disk_reftable;
2058 memset(on_disk_reftable + old_reftable_size, 0,
2059 (reftable_size - old_reftable_size) * sizeof(uint64_t));
2061 /* The offset we have for the reftable is now no longer valid;
2062 * this will leak that range, but we can easily fix that by running
2063 * a leak-fixing check after this rebuild operation */
2064 reftable_offset = -1;
2066 on_disk_reftable[refblock_index] = refblock_offset;
2068 /* If this is apparently the last refblock (for now), try to squeeze the
2070 if (refblock_index == (*nb_clusters - 1) >> s->refcount_block_bits &&
2071 reftable_offset < 0)
2073 uint64_t reftable_clusters = size_to_clusters(s, reftable_size *
2075 reftable_offset = alloc_clusters_imrt(bs, reftable_clusters,
2076 refcount_table, nb_clusters,
2077 &first_free_cluster);
2078 if (reftable_offset < 0) {
2079 fprintf(stderr, "ERROR allocating reftable: %s\n",
2080 strerror(-reftable_offset));
2081 res->check_errors++;
2082 ret = reftable_offset;
2087 ret = qcow2_pre_write_overlap_check(bs, 0, refblock_offset,
2090 fprintf(stderr, "ERROR writing refblock: %s\n", strerror(-ret));
2094 /* The size of *refcount_table is always cluster-aligned, therefore the
2095 * write operation will not overflow */
2096 on_disk_refblock = (void *)((char *) *refcount_table +
2097 refblock_index * s->cluster_size);
2099 ret = bdrv_write(bs->file, refblock_offset / BDRV_SECTOR_SIZE,
2100 on_disk_refblock, s->cluster_sectors);
2102 fprintf(stderr, "ERROR writing refblock: %s\n", strerror(-ret));
2106 /* Go to the end of this refblock */
2107 cluster = refblock_start + s->refcount_block_size - 1;
2110 if (reftable_offset < 0) {
2111 uint64_t post_refblock_start, reftable_clusters;
2113 post_refblock_start = ROUND_UP(*nb_clusters, s->refcount_block_size);
2114 reftable_clusters = size_to_clusters(s,
2115 reftable_size * sizeof(uint64_t));
2116 /* Not pretty but simple */
2117 if (first_free_cluster < post_refblock_start) {
2118 first_free_cluster = post_refblock_start;
2120 reftable_offset = alloc_clusters_imrt(bs, reftable_clusters,
2121 refcount_table, nb_clusters,
2122 &first_free_cluster);
2123 if (reftable_offset < 0) {
2124 fprintf(stderr, "ERROR allocating reftable: %s\n",
2125 strerror(-reftable_offset));
2126 res->check_errors++;
2127 ret = reftable_offset;
2131 goto write_refblocks;
2134 assert(on_disk_reftable);
2136 for (refblock_index = 0; refblock_index < reftable_size; refblock_index++) {
2137 cpu_to_be64s(&on_disk_reftable[refblock_index]);
2140 ret = qcow2_pre_write_overlap_check(bs, 0, reftable_offset,
2141 reftable_size * sizeof(uint64_t));
2143 fprintf(stderr, "ERROR writing reftable: %s\n", strerror(-ret));
2147 assert(reftable_size < INT_MAX / sizeof(uint64_t));
2148 ret = bdrv_pwrite(bs->file, reftable_offset, on_disk_reftable,
2149 reftable_size * sizeof(uint64_t));
2151 fprintf(stderr, "ERROR writing reftable: %s\n", strerror(-ret));
2155 /* Enter new reftable into the image header */
2156 reftable_offset_and_clusters.reftable_offset = cpu_to_be64(reftable_offset);
2157 reftable_offset_and_clusters.reftable_clusters =
2158 cpu_to_be32(size_to_clusters(s, reftable_size * sizeof(uint64_t)));
2159 ret = bdrv_pwrite_sync(bs->file,
2160 offsetof(QCowHeader, refcount_table_offset),
2161 &reftable_offset_and_clusters,
2162 sizeof(reftable_offset_and_clusters));
2164 fprintf(stderr, "ERROR setting reftable: %s\n", strerror(-ret));
2168 for (refblock_index = 0; refblock_index < reftable_size; refblock_index++) {
2169 be64_to_cpus(&on_disk_reftable[refblock_index]);
2171 s->refcount_table = on_disk_reftable;
2172 s->refcount_table_offset = reftable_offset;
2173 s->refcount_table_size = reftable_size;
2178 g_free(on_disk_reftable);
2183 * Checks an image for refcount consistency.
2185 * Returns 0 if no errors are found, the number of errors in case the image is
2186 * detected as corrupted, and -errno when an internal error occurred.
2188 int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
2191 BDRVQcow2State *s = bs->opaque;
2192 BdrvCheckResult pre_compare_res;
2193 int64_t size, highest_cluster, nb_clusters;
2194 void *refcount_table = NULL;
2195 bool rebuild = false;
2198 size = bdrv_getlength(bs->file->bs);
2200 res->check_errors++;
2204 nb_clusters = size_to_clusters(s, size);
2205 if (nb_clusters > INT_MAX) {
2206 res->check_errors++;
2210 res->bfi.total_clusters =
2211 size_to_clusters(s, bs->total_sectors * BDRV_SECTOR_SIZE);
2213 ret = calculate_refcounts(bs, res, fix, &rebuild, &refcount_table,
2219 /* In case we don't need to rebuild the refcount structure (but want to fix
2220 * something), this function is immediately called again, in which case the
2221 * result should be ignored */
2222 pre_compare_res = *res;
2223 compare_refcounts(bs, res, 0, &rebuild, &highest_cluster, refcount_table,
2226 if (rebuild && (fix & BDRV_FIX_ERRORS)) {
2227 BdrvCheckResult old_res = *res;
2228 int fresh_leaks = 0;
2230 fprintf(stderr, "Rebuilding refcount structure\n");
2231 ret = rebuild_refcount_structure(bs, res, &refcount_table,
2237 res->corruptions = 0;
2240 /* Because the old reftable has been exchanged for a new one the
2241 * references have to be recalculated */
2243 memset(refcount_table, 0, refcount_array_byte_size(s, nb_clusters));
2244 ret = calculate_refcounts(bs, res, 0, &rebuild, &refcount_table,
2250 if (fix & BDRV_FIX_LEAKS) {
2251 /* The old refcount structures are now leaked, fix it; the result
2252 * can be ignored, aside from leaks which were introduced by
2253 * rebuild_refcount_structure() that could not be fixed */
2254 BdrvCheckResult saved_res = *res;
2255 *res = (BdrvCheckResult){ 0 };
2257 compare_refcounts(bs, res, BDRV_FIX_LEAKS, &rebuild,
2258 &highest_cluster, refcount_table, nb_clusters);
2260 fprintf(stderr, "ERROR rebuilt refcount structure is still "
2264 /* Any leaks accounted for here were introduced by
2265 * rebuild_refcount_structure() because that function has created a
2266 * new refcount structure from scratch */
2267 fresh_leaks = res->leaks;
2271 if (res->corruptions < old_res.corruptions) {
2272 res->corruptions_fixed += old_res.corruptions - res->corruptions;
2274 if (res->leaks < old_res.leaks) {
2275 res->leaks_fixed += old_res.leaks - res->leaks;
2277 res->leaks += fresh_leaks;
2280 fprintf(stderr, "ERROR need to rebuild refcount structures\n");
2281 res->check_errors++;
2286 if (res->leaks || res->corruptions) {
2287 *res = pre_compare_res;
2288 compare_refcounts(bs, res, fix, &rebuild, &highest_cluster,
2289 refcount_table, nb_clusters);
2293 /* check OFLAG_COPIED */
2294 ret = check_oflag_copied(bs, res, fix);
2299 res->image_end_offset = (highest_cluster + 1) * s->cluster_size;
2303 g_free(refcount_table);
2308 #define overlaps_with(ofs, sz) \
2309 ranges_overlap(offset, size, ofs, sz)
2312 * Checks if the given offset into the image file is actually free to use by
2313 * looking for overlaps with important metadata sections (L1/L2 tables etc.),
2314 * i.e. a sanity check without relying on the refcount tables.
2316 * The ign parameter specifies what checks not to perform (being a bitmask of
2317 * QCow2MetadataOverlap values), i.e., what sections to ignore.
2320 * - 0 if writing to this offset will not affect the mentioned metadata
2321 * - a positive QCow2MetadataOverlap value indicating one overlapping section
2322 * - a negative value (-errno) indicating an error while performing a check,
2323 * e.g. when bdrv_read failed on QCOW2_OL_INACTIVE_L2
2325 int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
2328 BDRVQcow2State *s = bs->opaque;
2329 int chk = s->overlap_check & ~ign;
2336 if (chk & QCOW2_OL_MAIN_HEADER) {
2337 if (offset < s->cluster_size) {
2338 return QCOW2_OL_MAIN_HEADER;
2342 /* align range to test to cluster boundaries */
2343 size = align_offset(offset_into_cluster(s, offset) + size, s->cluster_size);
2344 offset = start_of_cluster(s, offset);
2346 if ((chk & QCOW2_OL_ACTIVE_L1) && s->l1_size) {
2347 if (overlaps_with(s->l1_table_offset, s->l1_size * sizeof(uint64_t))) {
2348 return QCOW2_OL_ACTIVE_L1;
2352 if ((chk & QCOW2_OL_REFCOUNT_TABLE) && s->refcount_table_size) {
2353 if (overlaps_with(s->refcount_table_offset,
2354 s->refcount_table_size * sizeof(uint64_t))) {
2355 return QCOW2_OL_REFCOUNT_TABLE;
2359 if ((chk & QCOW2_OL_SNAPSHOT_TABLE) && s->snapshots_size) {
2360 if (overlaps_with(s->snapshots_offset, s->snapshots_size)) {
2361 return QCOW2_OL_SNAPSHOT_TABLE;
2365 if ((chk & QCOW2_OL_INACTIVE_L1) && s->snapshots) {
2366 for (i = 0; i < s->nb_snapshots; i++) {
2367 if (s->snapshots[i].l1_size &&
2368 overlaps_with(s->snapshots[i].l1_table_offset,
2369 s->snapshots[i].l1_size * sizeof(uint64_t))) {
2370 return QCOW2_OL_INACTIVE_L1;
2375 if ((chk & QCOW2_OL_ACTIVE_L2) && s->l1_table) {
2376 for (i = 0; i < s->l1_size; i++) {
2377 if ((s->l1_table[i] & L1E_OFFSET_MASK) &&
2378 overlaps_with(s->l1_table[i] & L1E_OFFSET_MASK,
2380 return QCOW2_OL_ACTIVE_L2;
2385 if ((chk & QCOW2_OL_REFCOUNT_BLOCK) && s->refcount_table) {
2386 for (i = 0; i < s->refcount_table_size; i++) {
2387 if ((s->refcount_table[i] & REFT_OFFSET_MASK) &&
2388 overlaps_with(s->refcount_table[i] & REFT_OFFSET_MASK,
2390 return QCOW2_OL_REFCOUNT_BLOCK;
2395 if ((chk & QCOW2_OL_INACTIVE_L2) && s->snapshots) {
2396 for (i = 0; i < s->nb_snapshots; i++) {
2397 uint64_t l1_ofs = s->snapshots[i].l1_table_offset;
2398 uint32_t l1_sz = s->snapshots[i].l1_size;
2399 uint64_t l1_sz2 = l1_sz * sizeof(uint64_t);
2400 uint64_t *l1 = g_try_malloc(l1_sz2);
2403 if (l1_sz2 && l1 == NULL) {
2407 ret = bdrv_pread(bs->file, l1_ofs, l1, l1_sz2);
2413 for (j = 0; j < l1_sz; j++) {
2414 uint64_t l2_ofs = be64_to_cpu(l1[j]) & L1E_OFFSET_MASK;
2415 if (l2_ofs && overlaps_with(l2_ofs, s->cluster_size)) {
2417 return QCOW2_OL_INACTIVE_L2;
2428 static const char *metadata_ol_names[] = {
2429 [QCOW2_OL_MAIN_HEADER_BITNR] = "qcow2_header",
2430 [QCOW2_OL_ACTIVE_L1_BITNR] = "active L1 table",
2431 [QCOW2_OL_ACTIVE_L2_BITNR] = "active L2 table",
2432 [QCOW2_OL_REFCOUNT_TABLE_BITNR] = "refcount table",
2433 [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = "refcount block",
2434 [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = "snapshot table",
2435 [QCOW2_OL_INACTIVE_L1_BITNR] = "inactive L1 table",
2436 [QCOW2_OL_INACTIVE_L2_BITNR] = "inactive L2 table",
2440 * First performs a check for metadata overlaps (through
2441 * qcow2_check_metadata_overlap); if that fails with a negative value (error
2442 * while performing a check), that value is returned. If an impending overlap
2443 * is detected, the BDS will be made unusable, the qcow2 file marked corrupt
2444 * and -EIO returned.
2446 * Returns 0 if there were neither overlaps nor errors while checking for
2447 * overlaps; or a negative value (-errno) on error.
2449 int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
2452 int ret = qcow2_check_metadata_overlap(bs, ign, offset, size);
2456 } else if (ret > 0) {
2457 int metadata_ol_bitnr = ctz32(ret);
2458 assert(metadata_ol_bitnr < QCOW2_OL_MAX_BITNR);
2460 qcow2_signal_corruption(bs, true, offset, size, "Preventing invalid "
2461 "write on metadata (overlaps with %s)",
2462 metadata_ol_names[metadata_ol_bitnr]);
2469 /* A pointer to a function of this type is given to walk_over_reftable(). That
2470 * function will create refblocks and pass them to a RefblockFinishOp once they
2471 * are completed (@refblock). @refblock_empty is set if the refblock is
2474 * Along with the refblock, a corresponding reftable entry is passed, in the
2475 * reftable @reftable (which may be reallocated) at @reftable_index.
2477 * @allocated should be set to true if a new cluster has been allocated.
2479 typedef int (RefblockFinishOp)(BlockDriverState *bs, uint64_t **reftable,
2480 uint64_t reftable_index, uint64_t *reftable_size,
2481 void *refblock, bool refblock_empty,
2482 bool *allocated, Error **errp);
2485 * This "operation" for walk_over_reftable() allocates the refblock on disk (if
2486 * it is not empty) and inserts its offset into the new reftable. The size of
2487 * this new reftable is increased as required.
2489 static int alloc_refblock(BlockDriverState *bs, uint64_t **reftable,
2490 uint64_t reftable_index, uint64_t *reftable_size,
2491 void *refblock, bool refblock_empty, bool *allocated,
2494 BDRVQcow2State *s = bs->opaque;
2497 if (!refblock_empty && reftable_index >= *reftable_size) {
2498 uint64_t *new_reftable;
2499 uint64_t new_reftable_size;
2501 new_reftable_size = ROUND_UP(reftable_index + 1,
2502 s->cluster_size / sizeof(uint64_t));
2503 if (new_reftable_size > QCOW_MAX_REFTABLE_SIZE / sizeof(uint64_t)) {
2505 "This operation would make the refcount table grow "
2506 "beyond the maximum size supported by QEMU, aborting");
2510 new_reftable = g_try_realloc(*reftable, new_reftable_size *
2512 if (!new_reftable) {
2513 error_setg(errp, "Failed to increase reftable buffer size");
2517 memset(new_reftable + *reftable_size, 0,
2518 (new_reftable_size - *reftable_size) * sizeof(uint64_t));
2520 *reftable = new_reftable;
2521 *reftable_size = new_reftable_size;
2524 if (!refblock_empty && !(*reftable)[reftable_index]) {
2525 offset = qcow2_alloc_clusters(bs, s->cluster_size);
2527 error_setg_errno(errp, -offset, "Failed to allocate refblock");
2530 (*reftable)[reftable_index] = offset;
2538 * This "operation" for walk_over_reftable() writes the refblock to disk at the
2539 * offset specified by the new reftable's entry. It does not modify the new
2540 * reftable or change any refcounts.
2542 static int flush_refblock(BlockDriverState *bs, uint64_t **reftable,
2543 uint64_t reftable_index, uint64_t *reftable_size,
2544 void *refblock, bool refblock_empty, bool *allocated,
2547 BDRVQcow2State *s = bs->opaque;
2551 if (reftable_index < *reftable_size && (*reftable)[reftable_index]) {
2552 offset = (*reftable)[reftable_index];
2554 ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size);
2556 error_setg_errno(errp, -ret, "Overlap check failed");
2560 ret = bdrv_pwrite(bs->file, offset, refblock, s->cluster_size);
2562 error_setg_errno(errp, -ret, "Failed to write refblock");
2566 assert(refblock_empty);
2573 * This function walks over the existing reftable and every referenced refblock;
2574 * if @new_set_refcount is non-NULL, it is called for every refcount entry to
2575 * create an equal new entry in the passed @new_refblock. Once that
2576 * @new_refblock is completely filled, @operation will be called.
2578 * @status_cb and @cb_opaque are used for the amend operation's status callback.
2579 * @index is the index of the walk_over_reftable() calls and @total is the total
2580 * number of walk_over_reftable() calls per amend operation. Both are used for
2581 * calculating the parameters for the status callback.
2583 * @allocated is set to true if a new cluster has been allocated.
2585 static int walk_over_reftable(BlockDriverState *bs, uint64_t **new_reftable,
2586 uint64_t *new_reftable_index,
2587 uint64_t *new_reftable_size,
2588 void *new_refblock, int new_refblock_size,
2589 int new_refcount_bits,
2590 RefblockFinishOp *operation, bool *allocated,
2591 Qcow2SetRefcountFunc *new_set_refcount,
2592 BlockDriverAmendStatusCB *status_cb,
2593 void *cb_opaque, int index, int total,
2596 BDRVQcow2State *s = bs->opaque;
2597 uint64_t reftable_index;
2598 bool new_refblock_empty = true;
2600 int new_refblock_index = 0;
2603 for (reftable_index = 0; reftable_index < s->refcount_table_size;
2606 uint64_t refblock_offset = s->refcount_table[reftable_index]
2609 status_cb(bs, (uint64_t)index * s->refcount_table_size + reftable_index,
2610 (uint64_t)total * s->refcount_table_size, cb_opaque);
2612 if (refblock_offset) {
2615 if (offset_into_cluster(s, refblock_offset)) {
2616 qcow2_signal_corruption(bs, true, -1, -1, "Refblock offset %#"
2617 PRIx64 " unaligned (reftable index: %#"
2618 PRIx64 ")", refblock_offset,
2621 "Image is corrupt (unaligned refblock offset)");
2625 ret = qcow2_cache_get(bs, s->refcount_block_cache, refblock_offset,
2628 error_setg_errno(errp, -ret, "Failed to retrieve refblock");
2632 for (refblock_index = 0; refblock_index < s->refcount_block_size;
2637 if (new_refblock_index >= new_refblock_size) {
2638 /* new_refblock is now complete */
2639 ret = operation(bs, new_reftable, *new_reftable_index,
2640 new_reftable_size, new_refblock,
2641 new_refblock_empty, allocated, errp);
2643 qcow2_cache_put(bs, s->refcount_block_cache, &refblock);
2647 (*new_reftable_index)++;
2648 new_refblock_index = 0;
2649 new_refblock_empty = true;
2652 refcount = s->get_refcount(refblock, refblock_index);
2653 if (new_refcount_bits < 64 && refcount >> new_refcount_bits) {
2656 qcow2_cache_put(bs, s->refcount_block_cache, &refblock);
2658 offset = ((reftable_index << s->refcount_block_bits)
2659 + refblock_index) << s->cluster_bits;
2661 error_setg(errp, "Cannot decrease refcount entry width to "
2662 "%i bits: Cluster at offset %#" PRIx64 " has a "
2663 "refcount of %" PRIu64, new_refcount_bits,
2668 if (new_set_refcount) {
2669 new_set_refcount(new_refblock, new_refblock_index++,
2672 new_refblock_index++;
2674 new_refblock_empty = new_refblock_empty && refcount == 0;
2677 qcow2_cache_put(bs, s->refcount_block_cache, &refblock);
2679 /* No refblock means every refcount is 0 */
2680 for (refblock_index = 0; refblock_index < s->refcount_block_size;
2683 if (new_refblock_index >= new_refblock_size) {
2684 /* new_refblock is now complete */
2685 ret = operation(bs, new_reftable, *new_reftable_index,
2686 new_reftable_size, new_refblock,
2687 new_refblock_empty, allocated, errp);
2692 (*new_reftable_index)++;
2693 new_refblock_index = 0;
2694 new_refblock_empty = true;
2697 if (new_set_refcount) {
2698 new_set_refcount(new_refblock, new_refblock_index++, 0);
2700 new_refblock_index++;
2706 if (new_refblock_index > 0) {
2707 /* Complete the potentially existing partially filled final refblock */
2708 if (new_set_refcount) {
2709 for (; new_refblock_index < new_refblock_size;
2710 new_refblock_index++)
2712 new_set_refcount(new_refblock, new_refblock_index, 0);
2716 ret = operation(bs, new_reftable, *new_reftable_index,
2717 new_reftable_size, new_refblock, new_refblock_empty,
2723 (*new_reftable_index)++;
2726 status_cb(bs, (uint64_t)(index + 1) * s->refcount_table_size,
2727 (uint64_t)total * s->refcount_table_size, cb_opaque);
2732 int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
2733 BlockDriverAmendStatusCB *status_cb,
2734 void *cb_opaque, Error **errp)
2736 BDRVQcow2State *s = bs->opaque;
2737 Qcow2GetRefcountFunc *new_get_refcount;
2738 Qcow2SetRefcountFunc *new_set_refcount;
2739 void *new_refblock = qemu_blockalign(bs->file->bs, s->cluster_size);
2740 uint64_t *new_reftable = NULL, new_reftable_size = 0;
2741 uint64_t *old_reftable, old_reftable_size, old_reftable_offset;
2742 uint64_t new_reftable_index = 0;
2744 int64_t new_reftable_offset = 0, allocated_reftable_size = 0;
2745 int new_refblock_size, new_refcount_bits = 1 << refcount_order;
2746 int old_refcount_order;
2749 bool new_allocation;
2751 assert(s->qcow_version >= 3);
2752 assert(refcount_order >= 0 && refcount_order <= 6);
2754 /* see qcow2_open() */
2755 new_refblock_size = 1 << (s->cluster_bits - (refcount_order - 3));
2757 new_get_refcount = get_refcount_funcs[refcount_order];
2758 new_set_refcount = set_refcount_funcs[refcount_order];
2764 new_allocation = false;
2766 /* At least we have to do this walk and the one which writes the
2767 * refblocks; also, at least we have to do this loop here at least
2768 * twice (normally), first to do the allocations, and second to
2769 * determine that everything is correctly allocated, this then makes
2770 * three walks in total */
2771 total_walks = MAX(walk_index + 2, 3);
2773 /* First, allocate the structures so they are present in the refcount
2775 ret = walk_over_reftable(bs, &new_reftable, &new_reftable_index,
2776 &new_reftable_size, NULL, new_refblock_size,
2777 new_refcount_bits, &alloc_refblock,
2778 &new_allocation, NULL, status_cb, cb_opaque,
2779 walk_index++, total_walks, errp);
2784 new_reftable_index = 0;
2786 if (new_allocation) {
2787 if (new_reftable_offset) {
2788 qcow2_free_clusters(bs, new_reftable_offset,
2789 allocated_reftable_size * sizeof(uint64_t),
2790 QCOW2_DISCARD_NEVER);
2793 new_reftable_offset = qcow2_alloc_clusters(bs, new_reftable_size *
2795 if (new_reftable_offset < 0) {
2796 error_setg_errno(errp, -new_reftable_offset,
2797 "Failed to allocate the new reftable");
2798 ret = new_reftable_offset;
2801 allocated_reftable_size = new_reftable_size;
2803 } while (new_allocation);
2805 /* Second, write the new refblocks */
2806 ret = walk_over_reftable(bs, &new_reftable, &new_reftable_index,
2807 &new_reftable_size, new_refblock,
2808 new_refblock_size, new_refcount_bits,
2809 &flush_refblock, &new_allocation, new_set_refcount,
2810 status_cb, cb_opaque, walk_index, walk_index + 1,
2815 assert(!new_allocation);
2818 /* Write the new reftable */
2819 ret = qcow2_pre_write_overlap_check(bs, 0, new_reftable_offset,
2820 new_reftable_size * sizeof(uint64_t));
2822 error_setg_errno(errp, -ret, "Overlap check failed");
2826 for (i = 0; i < new_reftable_size; i++) {
2827 cpu_to_be64s(&new_reftable[i]);
2830 ret = bdrv_pwrite(bs->file, new_reftable_offset, new_reftable,
2831 new_reftable_size * sizeof(uint64_t));
2833 for (i = 0; i < new_reftable_size; i++) {
2834 be64_to_cpus(&new_reftable[i]);
2838 error_setg_errno(errp, -ret, "Failed to write the new reftable");
2843 /* Empty the refcount cache */
2844 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2846 error_setg_errno(errp, -ret, "Failed to flush the refblock cache");
2850 /* Update the image header to point to the new reftable; this only updates
2851 * the fields which are relevant to qcow2_update_header(); other fields
2852 * such as s->refcount_table or s->refcount_bits stay stale for now
2853 * (because we have to restore everything if qcow2_update_header() fails) */
2854 old_refcount_order = s->refcount_order;
2855 old_reftable_size = s->refcount_table_size;
2856 old_reftable_offset = s->refcount_table_offset;
2858 s->refcount_order = refcount_order;
2859 s->refcount_table_size = new_reftable_size;
2860 s->refcount_table_offset = new_reftable_offset;
2862 ret = qcow2_update_header(bs);
2864 s->refcount_order = old_refcount_order;
2865 s->refcount_table_size = old_reftable_size;
2866 s->refcount_table_offset = old_reftable_offset;
2867 error_setg_errno(errp, -ret, "Failed to update the qcow2 header");
2871 /* Now update the rest of the in-memory information */
2872 old_reftable = s->refcount_table;
2873 s->refcount_table = new_reftable;
2875 s->refcount_bits = 1 << refcount_order;
2876 s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
2877 s->refcount_max += s->refcount_max - 1;
2879 s->refcount_block_bits = s->cluster_bits - (refcount_order - 3);
2880 s->refcount_block_size = 1 << s->refcount_block_bits;
2882 s->get_refcount = new_get_refcount;
2883 s->set_refcount = new_set_refcount;
2885 /* For cleaning up all old refblocks and the old reftable below the "done"
2887 new_reftable = old_reftable;
2888 new_reftable_size = old_reftable_size;
2889 new_reftable_offset = old_reftable_offset;
2893 /* On success, new_reftable actually points to the old reftable (and
2894 * new_reftable_size is the old reftable's size); but that is just
2896 for (i = 0; i < new_reftable_size; i++) {
2897 uint64_t offset = new_reftable[i] & REFT_OFFSET_MASK;
2899 qcow2_free_clusters(bs, offset, s->cluster_size,
2900 QCOW2_DISCARD_OTHER);
2903 g_free(new_reftable);
2905 if (new_reftable_offset > 0) {
2906 qcow2_free_clusters(bs, new_reftable_offset,
2907 new_reftable_size * sizeof(uint64_t),
2908 QCOW2_DISCARD_OTHER);
2912 qemu_vfree(new_refblock);