]> git.proxmox.com Git - mirror_qemu.git/blame - block/qcow2-refcount.c
Merge tag 'pull-aspeed-20240201' of https://github.com/legoater/qemu into staging
[mirror_qemu.git] / block / qcow2-refcount.c
CommitLineData
f7d0fe02
KW
1/*
2 * Block driver for the QCOW version 2 format
3 *
4 * Copyright (c) 2004-2006 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
23 */
24
80c71a24 25#include "qemu/osdep.h"
e2c1c34f 26#include "block/block-io.h"
da34e65c 27#include "qapi/error.h"
0d8c41da 28#include "qcow2.h"
a40f1c2a 29#include "qemu/range.h"
58369e22 30#include "qemu/bswap.h"
46b732cd 31#include "qemu/cutils.h"
5df022cf 32#include "qemu/memalign.h"
1477b6c8 33#include "trace.h"
f7d0fe02 34
77d6a215
EB
35static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size,
36 uint64_t max);
c0840179
MAL
37
38G_GNUC_WARN_UNUSED_RESULT
39static int update_refcount(BlockDriverState *bs,
40 int64_t offset, int64_t length, uint64_t addend,
41 bool decrease, enum qcow2_discard_type type);
f7d0fe02 42
59c0cb78
HR
43static uint64_t get_refcount_ro0(const void *refcount_array, uint64_t index);
44static uint64_t get_refcount_ro1(const void *refcount_array, uint64_t index);
45static uint64_t get_refcount_ro2(const void *refcount_array, uint64_t index);
46static uint64_t get_refcount_ro3(const void *refcount_array, uint64_t index);
7453c96b 47static uint64_t get_refcount_ro4(const void *refcount_array, uint64_t index);
59c0cb78
HR
48static uint64_t get_refcount_ro5(const void *refcount_array, uint64_t index);
49static uint64_t get_refcount_ro6(const void *refcount_array, uint64_t index);
7453c96b 50
59c0cb78
HR
51static void set_refcount_ro0(void *refcount_array, uint64_t index,
52 uint64_t value);
53static void set_refcount_ro1(void *refcount_array, uint64_t index,
54 uint64_t value);
55static void set_refcount_ro2(void *refcount_array, uint64_t index,
56 uint64_t value);
57static void set_refcount_ro3(void *refcount_array, uint64_t index,
58 uint64_t value);
7453c96b
HR
59static void set_refcount_ro4(void *refcount_array, uint64_t index,
60 uint64_t value);
59c0cb78
HR
61static void set_refcount_ro5(void *refcount_array, uint64_t index,
62 uint64_t value);
63static void set_refcount_ro6(void *refcount_array, uint64_t index,
64 uint64_t value);
65
66
67static Qcow2GetRefcountFunc *const get_refcount_funcs[] = {
68 &get_refcount_ro0,
69 &get_refcount_ro1,
70 &get_refcount_ro2,
71 &get_refcount_ro3,
72 &get_refcount_ro4,
73 &get_refcount_ro5,
74 &get_refcount_ro6
75};
76
77static Qcow2SetRefcountFunc *const set_refcount_funcs[] = {
78 &set_refcount_ro0,
79 &set_refcount_ro1,
80 &set_refcount_ro2,
81 &set_refcount_ro3,
82 &set_refcount_ro4,
83 &set_refcount_ro5,
84 &set_refcount_ro6
85};
7453c96b 86
3b88e52b 87
f7d0fe02
KW
88/*********************************************************/
89/* refcount handling */
90
7061a078
AG
91static void update_max_refcount_table_index(BDRVQcow2State *s)
92{
93 unsigned i = s->refcount_table_size - 1;
94 while (i > 0 && (s->refcount_table[i] & REFT_OFFSET_MASK) == 0) {
95 i--;
96 }
97 /* Set s->max_refcount_table_index to the index of the last used entry */
98 s->max_refcount_table_index = i;
99}
100
a1b4ecfd 101int coroutine_fn qcow2_refcount_init(BlockDriverState *bs)
f7d0fe02 102{
ff99129a 103 BDRVQcow2State *s = bs->opaque;
5dab2fad
KW
104 unsigned int refcount_table_size2, i;
105 int ret;
f7d0fe02 106
59c0cb78
HR
107 assert(s->refcount_order >= 0 && s->refcount_order <= 6);
108
109 s->get_refcount = get_refcount_funcs[s->refcount_order];
110 s->set_refcount = set_refcount_funcs[s->refcount_order];
7453c96b 111
02b1ecfa
AG
112 assert(s->refcount_table_size <= INT_MAX / REFTABLE_ENTRY_SIZE);
113 refcount_table_size2 = s->refcount_table_size * REFTABLE_ENTRY_SIZE;
de82815d
KW
114 s->refcount_table = g_try_malloc(refcount_table_size2);
115
f7d0fe02 116 if (s->refcount_table_size > 0) {
de82815d 117 if (s->refcount_table == NULL) {
8fcffa98 118 ret = -ENOMEM;
de82815d
KW
119 goto fail;
120 }
17362398 121 BLKDBG_CO_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
38505e2a
AF
122 ret = bdrv_co_pread(bs->file, s->refcount_table_offset,
123 refcount_table_size2, s->refcount_table, 0);
8fcffa98 124 if (ret < 0) {
f7d0fe02 125 goto fail;
8fcffa98 126 }
f7d0fe02
KW
127 for(i = 0; i < s->refcount_table_size; i++)
128 be64_to_cpus(&s->refcount_table[i]);
7061a078 129 update_max_refcount_table_index(s);
f7d0fe02
KW
130 }
131 return 0;
132 fail:
8fcffa98 133 return ret;
f7d0fe02
KW
134}
135
ed6ccf0f 136void qcow2_refcount_close(BlockDriverState *bs)
f7d0fe02 137{
ff99129a 138 BDRVQcow2State *s = bs->opaque;
7267c094 139 g_free(s->refcount_table);
f7d0fe02
KW
140}
141
142
59c0cb78
HR
143static uint64_t get_refcount_ro0(const void *refcount_array, uint64_t index)
144{
145 return (((const uint8_t *)refcount_array)[index / 8] >> (index % 8)) & 0x1;
146}
147
148static void set_refcount_ro0(void *refcount_array, uint64_t index,
149 uint64_t value)
150{
151 assert(!(value >> 1));
152 ((uint8_t *)refcount_array)[index / 8] &= ~(0x1 << (index % 8));
153 ((uint8_t *)refcount_array)[index / 8] |= value << (index % 8);
154}
155
156static uint64_t get_refcount_ro1(const void *refcount_array, uint64_t index)
157{
158 return (((const uint8_t *)refcount_array)[index / 4] >> (2 * (index % 4)))
159 & 0x3;
160}
161
162static void set_refcount_ro1(void *refcount_array, uint64_t index,
163 uint64_t value)
164{
165 assert(!(value >> 2));
166 ((uint8_t *)refcount_array)[index / 4] &= ~(0x3 << (2 * (index % 4)));
167 ((uint8_t *)refcount_array)[index / 4] |= value << (2 * (index % 4));
168}
169
170static uint64_t get_refcount_ro2(const void *refcount_array, uint64_t index)
171{
172 return (((const uint8_t *)refcount_array)[index / 2] >> (4 * (index % 2)))
173 & 0xf;
174}
175
176static void set_refcount_ro2(void *refcount_array, uint64_t index,
177 uint64_t value)
178{
179 assert(!(value >> 4));
180 ((uint8_t *)refcount_array)[index / 2] &= ~(0xf << (4 * (index % 2)));
181 ((uint8_t *)refcount_array)[index / 2] |= value << (4 * (index % 2));
182}
183
184static uint64_t get_refcount_ro3(const void *refcount_array, uint64_t index)
185{
186 return ((const uint8_t *)refcount_array)[index];
187}
188
189static void set_refcount_ro3(void *refcount_array, uint64_t index,
190 uint64_t value)
191{
192 assert(!(value >> 8));
193 ((uint8_t *)refcount_array)[index] = value;
194}
195
7453c96b
HR
196static uint64_t get_refcount_ro4(const void *refcount_array, uint64_t index)
197{
198 return be16_to_cpu(((const uint16_t *)refcount_array)[index]);
199}
200
201static void set_refcount_ro4(void *refcount_array, uint64_t index,
202 uint64_t value)
203{
204 assert(!(value >> 16));
205 ((uint16_t *)refcount_array)[index] = cpu_to_be16(value);
206}
207
59c0cb78
HR
208static uint64_t get_refcount_ro5(const void *refcount_array, uint64_t index)
209{
210 return be32_to_cpu(((const uint32_t *)refcount_array)[index]);
211}
212
213static void set_refcount_ro5(void *refcount_array, uint64_t index,
214 uint64_t value)
215{
216 assert(!(value >> 32));
217 ((uint32_t *)refcount_array)[index] = cpu_to_be32(value);
218}
219
220static uint64_t get_refcount_ro6(const void *refcount_array, uint64_t index)
221{
222 return be64_to_cpu(((const uint64_t *)refcount_array)[index]);
223}
224
225static void set_refcount_ro6(void *refcount_array, uint64_t index,
226 uint64_t value)
227{
228 ((uint64_t *)refcount_array)[index] = cpu_to_be64(value);
229}
230
7453c96b 231
0bb79c97
KW
232static int GRAPH_RDLOCK
233load_refcount_block(BlockDriverState *bs, int64_t refcount_block_offset,
234 void **refcount_block)
f7d0fe02 235{
ff99129a 236 BDRVQcow2State *s = bs->opaque;
3b88e52b 237
66f82cee 238 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_LOAD);
9be38598
EH
239 return qcow2_cache_get(bs, s->refcount_block_cache, refcount_block_offset,
240 refcount_block);
f7d0fe02
KW
241}
242
018faafd 243/*
7324c10f
HR
244 * Retrieves the refcount of the cluster given by its index and stores it in
245 * *refcount. Returns 0 on success and -errno on failure.
018faafd 246 */
7324c10f 247int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index,
0e06528e 248 uint64_t *refcount)
f7d0fe02 249{
ff99129a 250 BDRVQcow2State *s = bs->opaque;
db8a31d1 251 uint64_t refcount_table_index, block_index;
f7d0fe02 252 int64_t refcount_block_offset;
018faafd 253 int ret;
7453c96b 254 void *refcount_block;
f7d0fe02 255
17bd5f47 256 refcount_table_index = cluster_index >> s->refcount_block_bits;
7324c10f
HR
257 if (refcount_table_index >= s->refcount_table_size) {
258 *refcount = 0;
f7d0fe02 259 return 0;
7324c10f 260 }
26d49c46
HR
261 refcount_block_offset =
262 s->refcount_table[refcount_table_index] & REFT_OFFSET_MASK;
7324c10f
HR
263 if (!refcount_block_offset) {
264 *refcount = 0;
f7d0fe02 265 return 0;
7324c10f 266 }
29c1a730 267
a97c67ee
HR
268 if (offset_into_cluster(s, refcount_block_offset)) {
269 qcow2_signal_corruption(bs, true, -1, -1, "Refblock offset %#" PRIx64
270 " unaligned (reftable index: %#" PRIx64 ")",
271 refcount_block_offset, refcount_table_index);
272 return -EIO;
273 }
274
29c1a730 275 ret = qcow2_cache_get(bs, s->refcount_block_cache, refcount_block_offset,
7453c96b 276 &refcount_block);
29c1a730
KW
277 if (ret < 0) {
278 return ret;
f7d0fe02 279 }
29c1a730 280
17bd5f47 281 block_index = cluster_index & (s->refcount_block_size - 1);
7453c96b 282 *refcount = s->get_refcount(refcount_block, block_index);
29c1a730 283
2013c3d4 284 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
29c1a730 285
7324c10f 286 return 0;
f7d0fe02
KW
287}
288
92dcb59f 289/* Checks if two offsets are described by the same refcount block */
ff99129a 290static int in_same_refcount_block(BDRVQcow2State *s, uint64_t offset_a,
92dcb59f
KW
291 uint64_t offset_b)
292{
17bd5f47
HR
293 uint64_t block_a = offset_a >> (s->cluster_bits + s->refcount_block_bits);
294 uint64_t block_b = offset_b >> (s->cluster_bits + s->refcount_block_bits);
92dcb59f
KW
295
296 return (block_a == block_b);
297}
298
299/*
300 * Loads a refcount block. If it doesn't exist yet, it is allocated first
301 * (including growing the refcount table if needed).
302 *
29c1a730 303 * Returns 0 on success or -errno in error case
92dcb59f 304 */
0bb79c97
KW
305static int GRAPH_RDLOCK
306alloc_refcount_block(BlockDriverState *bs, int64_t cluster_index,
307 void **refcount_block)
f7d0fe02 308{
ff99129a 309 BDRVQcow2State *s = bs->opaque;
92dcb59f 310 unsigned int refcount_table_index;
12cc30a8 311 int64_t ret;
92dcb59f 312
66f82cee 313 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
8252278a 314
92dcb59f 315 /* Find the refcount block for the given cluster */
17bd5f47 316 refcount_table_index = cluster_index >> s->refcount_block_bits;
92dcb59f
KW
317
318 if (refcount_table_index < s->refcount_table_size) {
319
320 uint64_t refcount_block_offset =
76dc9e0c 321 s->refcount_table[refcount_table_index] & REFT_OFFSET_MASK;
92dcb59f
KW
322
323 /* If it's already there, we're done */
324 if (refcount_block_offset) {
a97c67ee
HR
325 if (offset_into_cluster(s, refcount_block_offset)) {
326 qcow2_signal_corruption(bs, true, -1, -1, "Refblock offset %#"
327 PRIx64 " unaligned (reftable index: "
328 "%#x)", refcount_block_offset,
329 refcount_table_index);
330 return -EIO;
331 }
332
29c1a730 333 return load_refcount_block(bs, refcount_block_offset,
7453c96b 334 refcount_block);
92dcb59f
KW
335 }
336 }
337
338 /*
339 * If we came here, we need to allocate something. Something is at least
340 * a cluster for the new refcount block. It may also include a new refcount
341 * table if the old refcount table is too small.
342 *
343 * Note that allocating clusters here needs some special care:
344 *
345 * - We can't use the normal qcow2_alloc_clusters(), it would try to
346 * increase the refcount and very likely we would end up with an endless
347 * recursion. Instead we must place the refcount blocks in a way that
348 * they can describe them themselves.
349 *
350 * - We need to consider that at this point we are inside update_refcounts
b106ad91
KW
351 * and potentially doing an initial refcount increase. This means that
352 * some clusters have already been allocated by the caller, but their
353 * refcount isn't accurate yet. If we allocate clusters for metadata, we
354 * need to return -EAGAIN to signal the caller that it needs to restart
355 * the search for free clusters.
92dcb59f
KW
356 *
357 * - alloc_clusters_noref and qcow2_free_clusters may load a different
358 * refcount block into the cache
359 */
360
29c1a730
KW
361 *refcount_block = NULL;
362
363 /* We write to the refcount table, so we might depend on L2 tables */
9991923b
SH
364 ret = qcow2_cache_flush(bs, s->l2_table_cache);
365 if (ret < 0) {
366 return ret;
367 }
92dcb59f
KW
368
369 /* Allocate the refcount block itself and mark it as used */
77d6a215 370 int64_t new_block = alloc_clusters_noref(bs, s->cluster_size, INT64_MAX);
2eaa8f63
KW
371 if (new_block < 0) {
372 return new_block;
373 }
f7d0fe02 374
cdc674c7
AG
375 /* The offset must fit in the offset field of the refcount table entry */
376 assert((new_block & REFT_OFFSET_MASK) == new_block);
377
6bf45d59
AG
378 /* If we're allocating the block at offset 0 then something is wrong */
379 if (new_block == 0) {
380 qcow2_signal_corruption(bs, true, -1, -1, "Preventing invalid "
381 "allocation of refcount block at offset 0");
382 return -EIO;
383 }
384
f7d0fe02 385#ifdef DEBUG_ALLOC2
92dcb59f
KW
386 fprintf(stderr, "qcow2: Allocate refcount block %d for %" PRIx64
387 " at %" PRIx64 "\n",
388 refcount_table_index, cluster_index << s->cluster_bits, new_block);
f7d0fe02 389#endif
92dcb59f
KW
390
391 if (in_same_refcount_block(s, new_block, cluster_index << s->cluster_bits)) {
25408c09 392 /* Zero the new refcount block before updating it */
29c1a730 393 ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
7453c96b 394 refcount_block);
29c1a730 395 if (ret < 0) {
60c48a29 396 goto fail;
29c1a730
KW
397 }
398
399 memset(*refcount_block, 0, s->cluster_size);
25408c09 400
92dcb59f
KW
401 /* The block describes itself, need to update the cache */
402 int block_index = (new_block >> s->cluster_bits) &
17bd5f47 403 (s->refcount_block_size - 1);
7453c96b 404 s->set_refcount(*refcount_block, block_index, 1);
92dcb59f
KW
405 } else {
406 /* Described somewhere else. This can recurse at most twice before we
407 * arrive at a block that describes itself. */
2aabe7c7 408 ret = update_refcount(bs, new_block, s->cluster_size, 1, false,
6cfcb9b8 409 QCOW2_DISCARD_NEVER);
92dcb59f 410 if (ret < 0) {
60c48a29 411 goto fail;
92dcb59f 412 }
25408c09 413
9991923b
SH
414 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
415 if (ret < 0) {
60c48a29 416 goto fail;
9991923b 417 }
1c4c2814 418
25408c09
KW
419 /* Initialize the new refcount block only after updating its refcount,
420 * update_refcount uses the refcount cache itself */
29c1a730 421 ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
7453c96b 422 refcount_block);
29c1a730 423 if (ret < 0) {
60c48a29 424 goto fail;
29c1a730
KW
425 }
426
427 memset(*refcount_block, 0, s->cluster_size);
92dcb59f
KW
428 }
429
430 /* Now the new refcount block needs to be written to disk */
66f82cee 431 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE);
2d135ee9 432 qcow2_cache_entry_mark_dirty(s->refcount_block_cache, *refcount_block);
29c1a730 433 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
92dcb59f 434 if (ret < 0) {
60c48a29 435 goto fail;
92dcb59f
KW
436 }
437
438 /* If the refcount table is big enough, just hook the block up there */
439 if (refcount_table_index < s->refcount_table_size) {
440 uint64_t data64 = cpu_to_be64(new_block);
66f82cee 441 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);
02b1ecfa
AG
442 ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset +
443 refcount_table_index * REFTABLE_ENTRY_SIZE,
32cc71de 444 sizeof(data64), &data64, 0);
92dcb59f 445 if (ret < 0) {
60c48a29 446 goto fail;
92dcb59f
KW
447 }
448
449 s->refcount_table[refcount_table_index] = new_block;
7061a078
AG
450 /* If there's a hole in s->refcount_table then it can happen
451 * that refcount_table_index < s->max_refcount_table_index */
452 s->max_refcount_table_index =
453 MAX(s->max_refcount_table_index, refcount_table_index);
b106ad91
KW
454
455 /* The new refcount block may be where the caller intended to put its
456 * data, so let it restart the search. */
457 return -EAGAIN;
29c1a730
KW
458 }
459
2013c3d4 460 qcow2_cache_put(s->refcount_block_cache, refcount_block);
92dcb59f
KW
461
462 /*
463 * If we come here, we need to grow the refcount table. Again, a new
464 * refcount table needs some space and we can't simply allocate to avoid
465 * endless recursion.
466 *
467 * Therefore let's grab new refcount blocks at the end of the image, which
468 * will describe themselves and the new refcount table. This way we can
469 * reference them only in the new table and do the switch to the new
470 * refcount table at once without producing an inconsistent state in
471 * between.
472 */
66f82cee 473 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_GROW);
8252278a 474
14a58a4e
HR
475 /* Calculate the number of refcount blocks needed so far; this will be the
476 * basis for calculating the index of the first cluster used for the
477 * self-describing refcount structures which we are about to create.
478 *
479 * Because we reached this point, there cannot be any refcount entries for
480 * cluster_index or higher indices yet. However, because new_block has been
481 * allocated to describe that cluster (and it will assume this role later
482 * on), we cannot use that index; also, new_block may actually have a higher
483 * cluster index than cluster_index, so it needs to be taken into account
484 * here (and 1 needs to be added to its value because that cluster is used).
485 */
486 uint64_t blocks_used = DIV_ROUND_UP(MAX(cluster_index + 1,
487 (new_block >> s->cluster_bits) + 1),
488 s->refcount_block_size);
92dcb59f 489
12cc30a8
HR
490 /* Create the new refcount table and blocks */
491 uint64_t meta_offset = (blocks_used * s->refcount_block_size) *
492 s->cluster_size;
493
494 ret = qcow2_refcount_area(bs, meta_offset, 0, false,
495 refcount_table_index, new_block);
496 if (ret < 0) {
497 return ret;
2b5d5953
KW
498 }
499
12cc30a8
HR
500 ret = load_refcount_block(bs, new_block, refcount_block);
501 if (ret < 0) {
502 return ret;
503 }
92dcb59f 504
12cc30a8
HR
505 /* If we were trying to do the initial refcount update for some cluster
506 * allocation, we might have used the same clusters to store newly
507 * allocated metadata. Make the caller search some new space. */
508 return -EAGAIN;
92dcb59f 509
60c48a29 510fail:
12cc30a8 511 if (*refcount_block != NULL) {
2013c3d4 512 qcow2_cache_put(s->refcount_block_cache, refcount_block);
12cc30a8
HR
513 }
514 return ret;
515}
92dcb59f 516
12cc30a8
HR
517/*
518 * Starting at @start_offset, this function creates new self-covering refcount
519 * structures: A new refcount table and refcount blocks which cover all of
520 * themselves, and a number of @additional_clusters beyond their end.
521 * @start_offset must be at the end of the image file, that is, there must be
522 * only empty space beyond it.
523 * If @exact_size is false, the refcount table will have 50 % more entries than
524 * necessary so it will not need to grow again soon.
525 * If @new_refblock_offset is not zero, it contains the offset of a refcount
526 * block that should be entered into the new refcount table at index
527 * @new_refblock_index.
528 *
529 * Returns: The offset after the new refcount structures (i.e. where the
530 * @additional_clusters may be placed) on success, -errno on error.
531 */
772d1f97
HR
532int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
533 uint64_t additional_clusters, bool exact_size,
534 int new_refblock_index,
535 uint64_t new_refblock_offset)
12cc30a8
HR
536{
537 BDRVQcow2State *s = bs->opaque;
538 uint64_t total_refblock_count_u64, additional_refblock_count;
539 int total_refblock_count, table_size, area_reftable_index, table_clusters;
540 int i;
541 uint64_t table_offset, block_offset, end_offset;
542 int ret;
543 uint64_t *new_table;
92dcb59f 544
12cc30a8 545 assert(!(start_offset % s->cluster_size));
de82815d 546
12cc30a8
HR
547 qcow2_refcount_metadata_size(start_offset / s->cluster_size +
548 additional_clusters,
549 s->cluster_size, s->refcount_order,
550 !exact_size, &total_refblock_count_u64);
551 if (total_refblock_count_u64 > QCOW_MAX_REFTABLE_SIZE) {
552 return -EFBIG;
553 }
554 total_refblock_count = total_refblock_count_u64;
555
556 /* Index in the refcount table of the first refcount block to cover the area
557 * of refcount structures we are about to create; we know that
558 * @total_refblock_count can cover @start_offset, so this will definitely
559 * fit into an int. */
560 area_reftable_index = (start_offset / s->cluster_size) /
561 s->refcount_block_size;
562
563 if (exact_size) {
564 table_size = total_refblock_count;
565 } else {
566 table_size = total_refblock_count +
567 DIV_ROUND_UP(total_refblock_count, 2);
568 }
569 /* The qcow2 file can only store the reftable size in number of clusters */
02b1ecfa
AG
570 table_size = ROUND_UP(table_size, s->cluster_size / REFTABLE_ENTRY_SIZE);
571 table_clusters = (table_size * REFTABLE_ENTRY_SIZE) / s->cluster_size;
12cc30a8
HR
572
573 if (table_size > QCOW_MAX_REFTABLE_SIZE) {
574 return -EFBIG;
575 }
576
577 new_table = g_try_new0(uint64_t, table_size);
578
579 assert(table_size > 0);
580 if (new_table == NULL) {
de82815d 581 ret = -ENOMEM;
12cc30a8 582 goto fail;
de82815d 583 }
92dcb59f 584
92dcb59f 585 /* Fill the new refcount table */
12cc30a8
HR
586 if (table_size > s->max_refcount_table_index) {
587 /* We're actually growing the reftable */
588 memcpy(new_table, s->refcount_table,
02b1ecfa 589 (s->max_refcount_table_index + 1) * REFTABLE_ENTRY_SIZE);
12cc30a8
HR
590 } else {
591 /* Improbable case: We're shrinking the reftable. However, the caller
592 * has assured us that there is only empty space beyond @start_offset,
593 * so we can simply drop all of the refblocks that won't fit into the
594 * new reftable. */
02b1ecfa 595 memcpy(new_table, s->refcount_table, table_size * REFTABLE_ENTRY_SIZE);
12cc30a8 596 }
92dcb59f 597
12cc30a8
HR
598 if (new_refblock_offset) {
599 assert(new_refblock_index < total_refblock_count);
600 new_table[new_refblock_index] = new_refblock_offset;
601 }
602
603 /* Count how many new refblocks we have to create */
604 additional_refblock_count = 0;
605 for (i = area_reftable_index; i < total_refblock_count; i++) {
606 if (!new_table[i]) {
607 additional_refblock_count++;
608 }
92dcb59f
KW
609 }
610
12cc30a8
HR
611 table_offset = start_offset + additional_refblock_count * s->cluster_size;
612 end_offset = table_offset + table_clusters * s->cluster_size;
613
614 /* Fill the refcount blocks, and create new ones, if necessary */
615 block_offset = start_offset;
616 for (i = area_reftable_index; i < total_refblock_count; i++) {
617 void *refblock_data;
618 uint64_t first_offset_covered;
619
620 /* Reuse an existing refblock if possible, create a new one otherwise */
621 if (new_table[i]) {
622 ret = qcow2_cache_get(bs, s->refcount_block_cache, new_table[i],
623 &refblock_data);
624 if (ret < 0) {
625 goto fail;
626 }
627 } else {
628 ret = qcow2_cache_get_empty(bs, s->refcount_block_cache,
629 block_offset, &refblock_data);
630 if (ret < 0) {
631 goto fail;
632 }
633 memset(refblock_data, 0, s->cluster_size);
2d135ee9 634 qcow2_cache_entry_mark_dirty(s->refcount_block_cache,
12cc30a8
HR
635 refblock_data);
636
637 new_table[i] = block_offset;
638 block_offset += s->cluster_size;
639 }
640
641 /* First host offset covered by this refblock */
642 first_offset_covered = (uint64_t)i * s->refcount_block_size *
643 s->cluster_size;
644 if (first_offset_covered < end_offset) {
645 int j, end_index;
646
647 /* Set the refcount of all of the new refcount structures to 1 */
648
649 if (first_offset_covered < start_offset) {
650 assert(i == area_reftable_index);
651 j = (start_offset - first_offset_covered) / s->cluster_size;
652 assert(j < s->refcount_block_size);
653 } else {
654 j = 0;
655 }
656
657 end_index = MIN((end_offset - first_offset_covered) /
658 s->cluster_size,
659 s->refcount_block_size);
660
661 for (; j < end_index; j++) {
662 /* The caller guaranteed us this space would be empty */
663 assert(s->get_refcount(refblock_data, j) == 0);
664 s->set_refcount(refblock_data, j, 1);
665 }
666
2d135ee9 667 qcow2_cache_entry_mark_dirty(s->refcount_block_cache,
12cc30a8
HR
668 refblock_data);
669 }
670
2013c3d4 671 qcow2_cache_put(s->refcount_block_cache, &refblock_data);
92dcb59f
KW
672 }
673
12cc30a8
HR
674 assert(block_offset == table_offset);
675
92dcb59f 676 /* Write refcount blocks to disk */
66f82cee 677 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);
12cc30a8 678 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
92dcb59f 679 if (ret < 0) {
12cc30a8 680 goto fail;
92dcb59f
KW
681 }
682
683 /* Write refcount table to disk */
12cc30a8 684 for (i = 0; i < total_refblock_count; i++) {
92dcb59f
KW
685 cpu_to_be64s(&new_table[i]);
686 }
687
66f82cee 688 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);
32cc71de
AF
689 ret = bdrv_pwrite_sync(bs->file, table_offset,
690 table_size * REFTABLE_ENTRY_SIZE, new_table, 0);
92dcb59f 691 if (ret < 0) {
12cc30a8 692 goto fail;
92dcb59f
KW
693 }
694
12cc30a8 695 for (i = 0; i < total_refblock_count; i++) {
87267753 696 be64_to_cpus(&new_table[i]);
92dcb59f 697 }
f7d0fe02 698
92dcb59f 699 /* Hook up the new refcount table in the qcow2 header */
95334230
JS
700 struct QEMU_PACKED {
701 uint64_t d64;
702 uint32_t d32;
703 } data;
f1f7a1dd
PM
704 data.d64 = cpu_to_be64(table_offset);
705 data.d32 = cpu_to_be32(table_clusters);
66f82cee 706 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
d9ca2ea2 707 ret = bdrv_pwrite_sync(bs->file,
32cc71de
AF
708 offsetof(QCowHeader, refcount_table_offset),
709 sizeof(data), &data, 0);
92dcb59f 710 if (ret < 0) {
12cc30a8 711 goto fail;
f2b7c8b3
KW
712 }
713
92dcb59f
KW
714 /* And switch it in memory */
715 uint64_t old_table_offset = s->refcount_table_offset;
716 uint64_t old_table_size = s->refcount_table_size;
717
7267c094 718 g_free(s->refcount_table);
f7d0fe02 719 s->refcount_table = new_table;
92dcb59f 720 s->refcount_table_size = table_size;
f7d0fe02 721 s->refcount_table_offset = table_offset;
7061a078 722 update_max_refcount_table_index(s);
f7d0fe02 723
b106ad91 724 /* Free old table. */
02b1ecfa
AG
725 qcow2_free_clusters(bs, old_table_offset,
726 old_table_size * REFTABLE_ENTRY_SIZE,
6cfcb9b8 727 QCOW2_DISCARD_OTHER);
f7d0fe02 728
12cc30a8 729 return end_offset;
f7d0fe02 730
12cc30a8 731fail:
7267c094 732 g_free(new_table);
29c1a730 733 return ret;
9923e05e
KW
734}
735
0b919fae
KW
736void qcow2_process_discards(BlockDriverState *bs, int ret)
737{
ff99129a 738 BDRVQcow2State *s = bs->opaque;
0b919fae
KW
739 Qcow2DiscardRegion *d, *next;
740
741 QTAILQ_FOREACH_SAFE(d, &s->discards, next, next) {
742 QTAILQ_REMOVE(&s->discards, d, next);
743
744 /* Discard is optional, ignore the return value */
745 if (ret >= 0) {
1477b6c8
VSO
746 int r2 = bdrv_pdiscard(bs->file, d->offset, d->bytes);
747 if (r2 < 0) {
748 trace_qcow2_process_discards_failed_region(d->offset, d->bytes,
749 r2);
750 }
0b919fae
KW
751 }
752
753 g_free(d);
754 }
755}
756
757static void update_refcount_discard(BlockDriverState *bs,
758 uint64_t offset, uint64_t length)
759{
ff99129a 760 BDRVQcow2State *s = bs->opaque;
0b919fae
KW
761 Qcow2DiscardRegion *d, *p, *next;
762
763 QTAILQ_FOREACH(d, &s->discards, next) {
764 uint64_t new_start = MIN(offset, d->offset);
765 uint64_t new_end = MAX(offset + length, d->offset + d->bytes);
766
767 if (new_end - new_start <= length + d->bytes) {
768 /* There can't be any overlap, areas ending up here have no
769 * references any more and therefore shouldn't get freed another
770 * time. */
771 assert(d->bytes + length == new_end - new_start);
772 d->offset = new_start;
773 d->bytes = new_end - new_start;
774 goto found;
775 }
776 }
777
778 d = g_malloc(sizeof(*d));
779 *d = (Qcow2DiscardRegion) {
780 .bs = bs,
781 .offset = offset,
782 .bytes = length,
783 };
784 QTAILQ_INSERT_TAIL(&s->discards, d, next);
785
786found:
787 /* Merge discard requests if they are adjacent now */
788 QTAILQ_FOREACH_SAFE(p, &s->discards, next, next) {
789 if (p == d
790 || p->offset > d->offset + d->bytes
791 || d->offset > p->offset + p->bytes)
792 {
793 continue;
794 }
795
796 /* Still no overlap possible */
797 assert(p->offset == d->offset + d->bytes
798 || d->offset == p->offset + p->bytes);
799
800 QTAILQ_REMOVE(&s->discards, p, next);
801 d->offset = MIN(d->offset, p->offset);
802 d->bytes += p->bytes;
d8bb71b6 803 g_free(p);
0b919fae
KW
804 }
805}
806
f7d0fe02 807/* XXX: cache several refcount block clusters ? */
2aabe7c7
HR
808/* @addend is the absolute value of the addend; if @decrease is set, @addend
809 * will be subtracted from the current refcount, otherwise it will be added */
0bb79c97
KW
810static int GRAPH_RDLOCK
811update_refcount(BlockDriverState *bs, int64_t offset, int64_t length,
812 uint64_t addend, bool decrease, enum qcow2_discard_type type)
f7d0fe02 813{
ff99129a 814 BDRVQcow2State *s = bs->opaque;
f7d0fe02 815 int64_t start, last, cluster_offset;
7453c96b 816 void *refcount_block = NULL;
29c1a730 817 int64_t old_table_index = -1;
09508d13 818 int ret;
f7d0fe02
KW
819
820#ifdef DEBUG_ALLOC2
2aabe7c7 821 fprintf(stderr, "update_refcount: offset=%" PRId64 " size=%" PRId64
0e06528e 822 " addend=%s%" PRIu64 "\n", offset, length, decrease ? "-" : "",
2aabe7c7 823 addend);
f7d0fe02 824#endif
7322afe7 825 if (length < 0) {
f7d0fe02 826 return -EINVAL;
7322afe7
KW
827 } else if (length == 0) {
828 return 0;
829 }
830
2aabe7c7 831 if (decrease) {
29c1a730
KW
832 qcow2_cache_set_dependency(bs, s->refcount_block_cache,
833 s->l2_table_cache);
834 }
835
ac95acdb
HT
836 start = start_of_cluster(s, offset);
837 last = start_of_cluster(s, offset + length - 1);
f7d0fe02
KW
838 for(cluster_offset = start; cluster_offset <= last;
839 cluster_offset += s->cluster_size)
840 {
2aabe7c7 841 int block_index;
0e06528e 842 uint64_t refcount;
f7d0fe02 843 int64_t cluster_index = cluster_offset >> s->cluster_bits;
17bd5f47 844 int64_t table_index = cluster_index >> s->refcount_block_bits;
f7d0fe02 845
29c1a730
KW
846 /* Load the refcount block and allocate it if needed */
847 if (table_index != old_table_index) {
848 if (refcount_block) {
2013c3d4 849 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
29c1a730 850 }
29c1a730 851 ret = alloc_refcount_block(bs, cluster_index, &refcount_block);
abf754fe
AG
852 /* If the caller needs to restart the search for free clusters,
853 * try the same ones first to see if they're still free. */
854 if (ret == -EAGAIN) {
855 if (s->free_cluster_index > (start >> s->cluster_bits)) {
856 s->free_cluster_index = (start >> s->cluster_bits);
857 }
858 }
ed0df867 859 if (ret < 0) {
29c1a730 860 goto fail;
f7d0fe02 861 }
f7d0fe02 862 }
29c1a730 863 old_table_index = table_index;
f7d0fe02 864
2d135ee9 865 qcow2_cache_entry_mark_dirty(s->refcount_block_cache, refcount_block);
f7d0fe02
KW
866
867 /* we can update the count and save it */
17bd5f47 868 block_index = cluster_index & (s->refcount_block_size - 1);
f7d0fe02 869
7453c96b 870 refcount = s->get_refcount(refcount_block, block_index);
0e06528e
HR
871 if (decrease ? (refcount - addend > refcount)
872 : (refcount + addend < refcount ||
873 refcount + addend > s->refcount_max))
2aabe7c7 874 {
09508d13
KW
875 ret = -EINVAL;
876 goto fail;
877 }
2aabe7c7
HR
878 if (decrease) {
879 refcount -= addend;
880 } else {
881 refcount += addend;
882 }
f7d0fe02
KW
883 if (refcount == 0 && cluster_index < s->free_cluster_index) {
884 s->free_cluster_index = cluster_index;
885 }
7453c96b 886 s->set_refcount(refcount_block, block_index, refcount);
0b919fae 887
f71c08ea
PB
888 if (refcount == 0) {
889 void *table;
890
6e6fa760 891 table = qcow2_cache_is_table_offset(s->refcount_block_cache,
f71c08ea
PB
892 offset);
893 if (table != NULL) {
2013c3d4 894 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
dea9052e 895 old_table_index = -1;
77aadd7b 896 qcow2_cache_discard(s->refcount_block_cache, table);
f71c08ea
PB
897 }
898
6e6fa760 899 table = qcow2_cache_is_table_offset(s->l2_table_cache, offset);
f71c08ea 900 if (table != NULL) {
77aadd7b 901 qcow2_cache_discard(s->l2_table_cache, table);
f71c08ea
PB
902 }
903
904 if (s->discard_passthrough[type]) {
905 update_refcount_discard(bs, cluster_offset, s->cluster_size);
906 }
67af674e 907 }
f7d0fe02
KW
908 }
909
09508d13
KW
910 ret = 0;
911fail:
0b919fae
KW
912 if (!s->cache_discards) {
913 qcow2_process_discards(bs, ret);
914 }
915
f7d0fe02 916 /* Write last changed block to disk */
29c1a730 917 if (refcount_block) {
2013c3d4 918 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
f7d0fe02
KW
919 }
920
09508d13
KW
921 /*
922 * Try do undo any updates if an error is returned (This may succeed in
923 * some cases like ENOSPC for allocating a new refcount block)
924 */
925 if (ret < 0) {
926 int dummy;
2aabe7c7
HR
927 dummy = update_refcount(bs, offset, cluster_offset - offset, addend,
928 !decrease, QCOW2_DISCARD_NEVER);
83e3f76c 929 (void)dummy;
09508d13
KW
930 }
931
932 return ret;
f7d0fe02
KW
933}
934
018faafd 935/*
44751917 936 * Increases or decreases the refcount of a given cluster.
018faafd 937 *
2aabe7c7
HR
938 * @addend is the absolute value of the addend; if @decrease is set, @addend
939 * will be subtracted from the current refcount, otherwise it will be added.
940 *
c6e9d8ae 941 * On success 0 is returned; on failure -errno is returned.
018faafd 942 */
32b6444d
HR
943int qcow2_update_cluster_refcount(BlockDriverState *bs,
944 int64_t cluster_index,
0e06528e 945 uint64_t addend, bool decrease,
32b6444d 946 enum qcow2_discard_type type)
f7d0fe02 947{
ff99129a 948 BDRVQcow2State *s = bs->opaque;
f7d0fe02
KW
949 int ret;
950
6cfcb9b8 951 ret = update_refcount(bs, cluster_index << s->cluster_bits, 1, addend,
2aabe7c7 952 decrease, type);
f7d0fe02
KW
953 if (ret < 0) {
954 return ret;
955 }
956
c6e9d8ae 957 return 0;
f7d0fe02
KW
958}
959
960
961
962/*********************************************************/
963/* cluster allocation functions */
964
965
966
967/* return < 0 if error */
0bb79c97
KW
968static int64_t GRAPH_RDLOCK
969alloc_clusters_noref(BlockDriverState *bs, uint64_t size, uint64_t max)
f7d0fe02 970{
ff99129a 971 BDRVQcow2State *s = bs->opaque;
0e06528e 972 uint64_t i, nb_clusters, refcount;
7324c10f 973 int ret;
f7d0fe02 974
ecbda7a2
KW
975 /* We can't allocate clusters if they may still be queued for discard. */
976 if (s->cache_discards) {
977 qcow2_process_discards(bs, 0);
978 }
979
f7d0fe02
KW
980 nb_clusters = size_to_clusters(s, size);
981retry:
982 for(i = 0; i < nb_clusters; i++) {
bb572aef 983 uint64_t next_cluster_index = s->free_cluster_index++;
7324c10f 984 ret = qcow2_get_refcount(bs, next_cluster_index, &refcount);
2eaa8f63 985
7324c10f
HR
986 if (ret < 0) {
987 return ret;
2eaa8f63 988 } else if (refcount != 0) {
f7d0fe02 989 goto retry;
2eaa8f63 990 }
f7d0fe02 991 }
91f827dc
HR
992
993 /* Make sure that all offsets in the "allocated" range are representable
77d6a215 994 * in the requested max */
65f33bc0 995 if (s->free_cluster_index > 0 &&
77d6a215 996 s->free_cluster_index - 1 > (max >> s->cluster_bits))
65f33bc0 997 {
91f827dc
HR
998 return -EFBIG;
999 }
1000
f7d0fe02 1001#ifdef DEBUG_ALLOC2
35ee5e39 1002 fprintf(stderr, "alloc_clusters: size=%" PRId64 " -> %" PRId64 "\n",
f7d0fe02
KW
1003 size,
1004 (s->free_cluster_index - nb_clusters) << s->cluster_bits);
1005#endif
1006 return (s->free_cluster_index - nb_clusters) << s->cluster_bits;
1007}
1008
bb572aef 1009int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size)
f7d0fe02
KW
1010{
1011 int64_t offset;
db3a964f 1012 int ret;
f7d0fe02 1013
66f82cee 1014 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
b106ad91 1015 do {
77d6a215 1016 offset = alloc_clusters_noref(bs, size, QCOW_MAX_CLUSTER_OFFSET);
b106ad91
KW
1017 if (offset < 0) {
1018 return offset;
1019 }
1020
2aabe7c7 1021 ret = update_refcount(bs, offset, size, 1, false, QCOW2_DISCARD_NEVER);
b106ad91 1022 } while (ret == -EAGAIN);
2eaa8f63 1023
db3a964f
KW
1024 if (ret < 0) {
1025 return ret;
1026 }
1c4c2814 1027
f7d0fe02
KW
1028 return offset;
1029}
1030
a39bae4e
PB
1031int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
1032 int64_t nb_clusters)
256900b1 1033{
ff99129a 1034 BDRVQcow2State *s = bs->opaque;
0e06528e 1035 uint64_t cluster_index, refcount;
33304ec9 1036 uint64_t i;
7324c10f 1037 int ret;
33304ec9
HT
1038
1039 assert(nb_clusters >= 0);
1040 if (nb_clusters == 0) {
1041 return 0;
1042 }
256900b1 1043
b106ad91
KW
1044 do {
1045 /* Check how many clusters there are free */
1046 cluster_index = offset >> s->cluster_bits;
1047 for(i = 0; i < nb_clusters; i++) {
7324c10f
HR
1048 ret = qcow2_get_refcount(bs, cluster_index++, &refcount);
1049 if (ret < 0) {
1050 return ret;
b106ad91
KW
1051 } else if (refcount != 0) {
1052 break;
1053 }
256900b1 1054 }
256900b1 1055
b106ad91 1056 /* And then allocate them */
2aabe7c7 1057 ret = update_refcount(bs, offset, i << s->cluster_bits, 1, false,
b106ad91
KW
1058 QCOW2_DISCARD_NEVER);
1059 } while (ret == -EAGAIN);
f24423bd 1060
256900b1
KW
1061 if (ret < 0) {
1062 return ret;
1063 }
1064
1065 return i;
1066}
1067
f7d0fe02
KW
1068/* only used to allocate compressed sectors. We try to allocate
1069 contiguous sectors. size must be <= cluster_size */
70bacc44 1070int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int size)
f7d0fe02 1071{
ff99129a 1072 BDRVQcow2State *s = bs->opaque;
8c44dfbc
HR
1073 int64_t offset;
1074 size_t free_in_cluster;
1075 int ret;
f7d0fe02 1076
17362398 1077 BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_BYTES);
f7d0fe02 1078 assert(size > 0 && size <= s->cluster_size);
8c44dfbc
HR
1079 assert(!s->free_byte_offset || offset_into_cluster(s, s->free_byte_offset));
1080
1081 offset = s->free_byte_offset;
1082
1083 if (offset) {
0e06528e 1084 uint64_t refcount;
7324c10f
HR
1085 ret = qcow2_get_refcount(bs, offset >> s->cluster_bits, &refcount);
1086 if (ret < 0) {
1087 return ret;
5d757b56 1088 }
8c44dfbc 1089
346a53df 1090 if (refcount == s->refcount_max) {
8c44dfbc 1091 offset = 0;
5d757b56 1092 }
8c44dfbc
HR
1093 }
1094
1095 free_in_cluster = s->cluster_size - offset_into_cluster(s, offset);
3e5feb62
JM
1096 do {
1097 if (!offset || free_in_cluster < size) {
77d6a215
EB
1098 int64_t new_cluster;
1099
1100 new_cluster = alloc_clusters_noref(bs, s->cluster_size,
1101 MIN(s->cluster_offset_mask,
1102 QCOW_MAX_CLUSTER_OFFSET));
3e5feb62
JM
1103 if (new_cluster < 0) {
1104 return new_cluster;
1105 }
8c44dfbc 1106
8aa34834
AG
1107 if (new_cluster == 0) {
1108 qcow2_signal_corruption(bs, true, -1, -1, "Preventing invalid "
1109 "allocation of compressed cluster "
1110 "at offset 0");
1111 return -EIO;
1112 }
1113
3e5feb62
JM
1114 if (!offset || ROUND_UP(offset, s->cluster_size) != new_cluster) {
1115 offset = new_cluster;
2ac01520
HR
1116 free_in_cluster = s->cluster_size;
1117 } else {
1118 free_in_cluster += s->cluster_size;
3e5feb62 1119 }
f7d0fe02 1120 }
29216ed1 1121
3e5feb62
JM
1122 assert(offset);
1123 ret = update_refcount(bs, offset, size, 1, false, QCOW2_DISCARD_NEVER);
2ac01520
HR
1124 if (ret < 0) {
1125 offset = 0;
1126 }
3e5feb62 1127 } while (ret == -EAGAIN);
8c44dfbc
HR
1128 if (ret < 0) {
1129 return ret;
1130 }
1131
1132 /* The cluster refcount was incremented; refcount blocks must be flushed
1133 * before the caller's L2 table updates. */
c1f5bafd 1134 qcow2_cache_set_dependency(bs, s->l2_table_cache, s->refcount_block_cache);
8c44dfbc
HR
1135
1136 s->free_byte_offset = offset + size;
1137 if (!offset_into_cluster(s, s->free_byte_offset)) {
1138 s->free_byte_offset = 0;
1139 }
1140
f7d0fe02
KW
1141 return offset;
1142}
1143
ed6ccf0f 1144void qcow2_free_clusters(BlockDriverState *bs,
6cfcb9b8
KW
1145 int64_t offset, int64_t size,
1146 enum qcow2_discard_type type)
f7d0fe02 1147{
db3a964f
KW
1148 int ret;
1149
66f82cee 1150 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_FREE);
2aabe7c7 1151 ret = update_refcount(bs, offset, size, 1, true, type);
db3a964f
KW
1152 if (ret < 0) {
1153 fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret));
003fad6e 1154 /* TODO Remember the clusters to free them later and avoid leaking */
db3a964f 1155 }
f7d0fe02
KW
1156}
1157
45aba42f 1158/*
c7a4c37a
KW
1159 * Free a cluster using its L2 entry (handles clusters of all types, e.g.
1160 * normal cluster, compressed cluster, etc.)
45aba42f 1161 */
3fec237f
AG
1162void qcow2_free_any_cluster(BlockDriverState *bs, uint64_t l2_entry,
1163 enum qcow2_discard_type type)
45aba42f 1164{
ff99129a 1165 BDRVQcow2State *s = bs->opaque;
966b000f 1166 QCow2ClusterType ctype = qcow2_get_cluster_type(bs, l2_entry);
45aba42f 1167
966b000f
KW
1168 if (has_data_file(bs)) {
1169 if (s->discard_passthrough[type] &&
1170 (ctype == QCOW2_CLUSTER_NORMAL ||
1171 ctype == QCOW2_CLUSTER_ZERO_ALLOC))
1172 {
1173 bdrv_pdiscard(s->data_file, l2_entry & L2E_OFFSET_MASK,
3fec237f 1174 s->cluster_size);
966b000f
KW
1175 }
1176 return;
1177 }
1178
1179 switch (ctype) {
c7a4c37a
KW
1180 case QCOW2_CLUSTER_COMPRESSED:
1181 {
a6e09846
VSO
1182 uint64_t coffset;
1183 int csize;
1184
1185 qcow2_parse_compressed_l2_entry(bs, l2_entry, &coffset, &csize);
1186 qcow2_free_clusters(bs, coffset, csize, type);
c7a4c37a
KW
1187 }
1188 break;
1189 case QCOW2_CLUSTER_NORMAL:
fdfab37d
EB
1190 case QCOW2_CLUSTER_ZERO_ALLOC:
1191 if (offset_into_cluster(s, l2_entry & L2E_OFFSET_MASK)) {
1192 qcow2_signal_corruption(bs, false, -1, -1,
1193 "Cannot free unaligned cluster %#llx",
1194 l2_entry & L2E_OFFSET_MASK);
1195 } else {
1196 qcow2_free_clusters(bs, l2_entry & L2E_OFFSET_MASK,
3fec237f 1197 s->cluster_size, type);
8f730dd2 1198 }
c7a4c37a 1199 break;
fdfab37d 1200 case QCOW2_CLUSTER_ZERO_PLAIN:
c7a4c37a
KW
1201 case QCOW2_CLUSTER_UNALLOCATED:
1202 break;
1203 default:
1204 abort();
45aba42f 1205 }
45aba42f
KW
1206}
1207
38401449 1208int qcow2_write_caches(BlockDriverState *bs)
8b220eb7
PB
1209{
1210 BDRVQcow2State *s = bs->opaque;
1211 int ret;
f7d0fe02 1212
8b220eb7
PB
1213 ret = qcow2_cache_write(bs, s->l2_table_cache);
1214 if (ret < 0) {
1215 return ret;
1216 }
1217
1218 if (qcow2_need_accurate_refcounts(s)) {
1219 ret = qcow2_cache_write(bs, s->refcount_block_cache);
1220 if (ret < 0) {
1221 return ret;
1222 }
1223 }
1224
1225 return 0;
1226}
1227
38401449 1228int qcow2_flush_caches(BlockDriverState *bs)
8b220eb7
PB
1229{
1230 int ret = qcow2_write_caches(bs);
1231 if (ret < 0) {
1232 return ret;
1233 }
1234
1235 return bdrv_flush(bs->file->bs);
1236}
f7d0fe02
KW
1237
1238/*********************************************************/
1239/* snapshots and image creation */
1240
1241
1242
f7d0fe02 1243/* update the refcounts of snapshots and the copied flag */
ed6ccf0f
KW
1244int qcow2_update_snapshot_refcount(BlockDriverState *bs,
1245 int64_t l1_table_offset, int l1_size, int addend)
f7d0fe02 1246{
ff99129a 1247 BDRVQcow2State *s = bs->opaque;
83ad165b 1248 uint64_t *l1_table, *l2_slice, l2_offset, entry, l1_size2, refcount;
de82815d 1249 bool l1_allocated = false;
b32cbae1 1250 int64_t old_entry, old_l2_offset;
83ad165b 1251 unsigned slice, slice_size2, n_slices;
a6e09846 1252 int i, j, l1_modified = 0;
29c1a730 1253 int ret;
f7d0fe02 1254
2aabe7c7
HR
1255 assert(addend >= -1 && addend <= 1);
1256
83ad165b 1257 l2_slice = NULL;
f7d0fe02 1258 l1_table = NULL;
02b1ecfa 1259 l1_size2 = l1_size * L1E_SIZE;
c8fd8554 1260 slice_size2 = s->l2_slice_size * l2_entry_size(s);
83ad165b 1261 n_slices = s->cluster_size / slice_size2;
43a0cac4 1262
0b919fae
KW
1263 s->cache_discards = true;
1264
43a0cac4
KW
1265 /* WARNING: qcow2_snapshot_goto relies on this function not using the
1266 * l1_table_offset when it is the current s->l1_table_offset! Be careful
1267 * when changing this! */
f7d0fe02 1268 if (l1_table_offset != s->l1_table_offset) {
ef97d608 1269 l1_table = g_try_malloc0(l1_size2);
de82815d
KW
1270 if (l1_size2 && l1_table == NULL) {
1271 ret = -ENOMEM;
1272 goto fail;
1273 }
1274 l1_allocated = true;
c2bc78b6 1275
32cc71de 1276 ret = bdrv_pread(bs->file, l1_table_offset, l1_size2, l1_table, 0);
c2bc78b6 1277 if (ret < 0) {
f7d0fe02 1278 goto fail;
93913dfd
KW
1279 }
1280
b32cbae1 1281 for (i = 0; i < l1_size; i++) {
f7d0fe02 1282 be64_to_cpus(&l1_table[i]);
b32cbae1 1283 }
f7d0fe02
KW
1284 } else {
1285 assert(l1_size == s->l1_size);
1286 l1_table = s->l1_table;
de82815d 1287 l1_allocated = false;
f7d0fe02
KW
1288 }
1289
b32cbae1 1290 for (i = 0; i < l1_size; i++) {
f7d0fe02
KW
1291 l2_offset = l1_table[i];
1292 if (l2_offset) {
1293 old_l2_offset = l2_offset;
8e37f681 1294 l2_offset &= L1E_OFFSET_MASK;
29c1a730 1295
a97c67ee
HR
1296 if (offset_into_cluster(s, l2_offset)) {
1297 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#"
1298 PRIx64 " unaligned (L1 index: %#x)",
1299 l2_offset, i);
1300 ret = -EIO;
1301 goto fail;
1302 }
1303
83ad165b 1304 for (slice = 0; slice < n_slices; slice++) {
ca62dd5c 1305 ret = qcow2_cache_get(bs, s->l2_table_cache,
83ad165b
AG
1306 l2_offset + slice * slice_size2,
1307 (void **) &l2_slice);
ca62dd5c
AG
1308 if (ret < 0) {
1309 goto fail;
1310 }
29c1a730 1311
83ad165b 1312 for (j = 0; j < s->l2_slice_size; j++) {
ca62dd5c
AG
1313 uint64_t cluster_index;
1314 uint64_t offset;
1315
12c6aebe 1316 entry = get_l2_entry(s, l2_slice, j);
ca62dd5c
AG
1317 old_entry = entry;
1318 entry &= ~QCOW_OFLAG_COPIED;
1319 offset = entry & L2E_OFFSET_MASK;
1320
808c2bb4 1321 switch (qcow2_get_cluster_type(bs, entry)) {
ca62dd5c 1322 case QCOW2_CLUSTER_COMPRESSED:
ca62dd5c 1323 if (addend != 0) {
a6e09846
VSO
1324 uint64_t coffset;
1325 int csize;
1326
1327 qcow2_parse_compressed_l2_entry(bs, entry,
1328 &coffset, &csize);
ca62dd5c 1329 ret = update_refcount(
a6e09846 1330 bs, coffset, csize,
b6c24694 1331 abs(addend), addend < 0,
6cfcb9b8 1332 QCOW2_DISCARD_SNAPSHOT);
ca62dd5c
AG
1333 if (ret < 0) {
1334 goto fail;
1335 }
1336 }
1337 /* compressed clusters are never modified */
1338 refcount = 2;
1339 break;
1340
1341 case QCOW2_CLUSTER_NORMAL:
1342 case QCOW2_CLUSTER_ZERO_ALLOC:
1343 if (offset_into_cluster(s, offset)) {
83ad165b
AG
1344 /* Here l2_index means table (not slice) index */
1345 int l2_index = slice * s->l2_slice_size + j;
ca62dd5c
AG
1346 qcow2_signal_corruption(
1347 bs, true, -1, -1, "Cluster "
1348 "allocation offset %#" PRIx64
1349 " unaligned (L2 offset: %#"
1350 PRIx64 ", L2 index: %#x)",
83ad165b 1351 offset, l2_offset, l2_index);
ca62dd5c 1352 ret = -EIO;
a97c67ee
HR
1353 goto fail;
1354 }
1355
ca62dd5c
AG
1356 cluster_index = offset >> s->cluster_bits;
1357 assert(cluster_index);
1358 if (addend != 0) {
1359 ret = qcow2_update_cluster_refcount(
1360 bs, cluster_index, abs(addend), addend < 0,
1361 QCOW2_DISCARD_SNAPSHOT);
1362 if (ret < 0) {
1363 goto fail;
1364 }
1365 }
1366
1367 ret = qcow2_get_refcount(bs, cluster_index, &refcount);
7324c10f 1368 if (ret < 0) {
018faafd
KW
1369 goto fail;
1370 }
ca62dd5c 1371 break;
bbd995d8 1372
ca62dd5c
AG
1373 case QCOW2_CLUSTER_ZERO_PLAIN:
1374 case QCOW2_CLUSTER_UNALLOCATED:
1375 refcount = 0;
1376 break;
8b81a7b6 1377
ca62dd5c
AG
1378 default:
1379 abort();
1380 }
8b81a7b6 1381
ca62dd5c
AG
1382 if (refcount == 1) {
1383 entry |= QCOW_OFLAG_COPIED;
1384 }
1385 if (entry != old_entry) {
1386 if (addend > 0) {
1387 qcow2_cache_set_dependency(bs, s->l2_table_cache,
1388 s->refcount_block_cache);
1389 }
12c6aebe 1390 set_l2_entry(s, l2_slice, j, entry);
ca62dd5c 1391 qcow2_cache_entry_mark_dirty(s->l2_table_cache,
83ad165b 1392 l2_slice);
f7d0fe02
KW
1393 }
1394 }
29c1a730 1395
83ad165b 1396 qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
ca62dd5c 1397 }
29c1a730 1398
f7d0fe02 1399 if (addend != 0) {
c6e9d8ae
HR
1400 ret = qcow2_update_cluster_refcount(bs, l2_offset >>
1401 s->cluster_bits,
2aabe7c7 1402 abs(addend), addend < 0,
c6e9d8ae
HR
1403 QCOW2_DISCARD_SNAPSHOT);
1404 if (ret < 0) {
1405 goto fail;
1406 }
f7d0fe02 1407 }
7324c10f
HR
1408 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
1409 &refcount);
1410 if (ret < 0) {
018faafd
KW
1411 goto fail;
1412 } else if (refcount == 1) {
f7d0fe02
KW
1413 l2_offset |= QCOW_OFLAG_COPIED;
1414 }
1415 if (l2_offset != old_l2_offset) {
1416 l1_table[i] = l2_offset;
1417 l1_modified = 1;
1418 }
1419 }
1420 }
93913dfd 1421
2154f24e 1422 ret = bdrv_flush(bs);
93913dfd 1423fail:
83ad165b
AG
1424 if (l2_slice) {
1425 qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
93913dfd
KW
1426 }
1427
0b919fae
KW
1428 s->cache_discards = false;
1429 qcow2_process_discards(bs, ret);
1430
43a0cac4 1431 /* Update L1 only if it isn't deleted anyway (addend = -1) */
c2b6ff51
KW
1432 if (ret == 0 && addend >= 0 && l1_modified) {
1433 for (i = 0; i < l1_size; i++) {
f7d0fe02 1434 cpu_to_be64s(&l1_table[i]);
c2b6ff51
KW
1435 }
1436
32cc71de 1437 ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_size2, l1_table,
53fb7844 1438 0);
c2b6ff51
KW
1439
1440 for (i = 0; i < l1_size; i++) {
f7d0fe02 1441 be64_to_cpus(&l1_table[i]);
c2b6ff51 1442 }
f7d0fe02
KW
1443 }
1444 if (l1_allocated)
7267c094 1445 g_free(l1_table);
93913dfd 1446 return ret;
f7d0fe02
KW
1447}
1448
1449
1450
1451
1452/*********************************************************/
1453/* refcount checking functions */
1454
1455
c2551b47 1456static uint64_t refcount_array_byte_size(BDRVQcow2State *s, uint64_t entries)
5fee192e
HR
1457{
1458 /* This assertion holds because there is no way we can address more than
1459 * 2^(64 - 9) clusters at once (with cluster size 512 = 2^9, and because
1460 * offsets have to be representable in bytes); due to every cluster
1461 * corresponding to one refcount entry, we are well below that limit */
1462 assert(entries < (UINT64_C(1) << (64 - 9)));
1463
1464 /* Thanks to the assertion this will not overflow, because
1465 * s->refcount_order < 7.
1466 * (note: x << s->refcount_order == x * s->refcount_bits) */
1467 return DIV_ROUND_UP(entries << s->refcount_order, 8);
1468}
1469
1470/**
1471 * Reallocates *array so that it can hold new_size entries. *size must contain
1472 * the current number of entries in *array. If the reallocation fails, *array
1473 * and *size will not be modified and -errno will be returned. If the
1474 * reallocation is successful, *array will be set to the new buffer, *size
1475 * will be set to new_size and 0 will be returned. The size of the reallocated
1476 * refcount array buffer will be aligned to a cluster boundary, and the newly
1477 * allocated area will be zeroed.
1478 */
ff99129a 1479static int realloc_refcount_array(BDRVQcow2State *s, void **array,
5fee192e
HR
1480 int64_t *size, int64_t new_size)
1481{
b6d36def 1482 int64_t old_byte_size, new_byte_size;
7453c96b 1483 void *new_ptr;
5fee192e
HR
1484
1485 /* Round to clusters so the array can be directly written to disk */
1486 old_byte_size = size_to_clusters(s, refcount_array_byte_size(s, *size))
1487 * s->cluster_size;
1488 new_byte_size = size_to_clusters(s, refcount_array_byte_size(s, new_size))
1489 * s->cluster_size;
1490
1491 if (new_byte_size == old_byte_size) {
1492 *size = new_size;
1493 return 0;
1494 }
1495
1496 assert(new_byte_size > 0);
1497
b6d36def
HR
1498 if (new_byte_size > SIZE_MAX) {
1499 return -ENOMEM;
1500 }
1501
5fee192e
HR
1502 new_ptr = g_try_realloc(*array, new_byte_size);
1503 if (!new_ptr) {
1504 return -ENOMEM;
1505 }
1506
1507 if (new_byte_size > old_byte_size) {
b6d36def 1508 memset((char *)new_ptr + old_byte_size, 0,
5fee192e
HR
1509 new_byte_size - old_byte_size);
1510 }
1511
1512 *array = new_ptr;
1513 *size = new_size;
1514
1515 return 0;
1516}
f7d0fe02
KW
1517
1518/*
1519 * Increases the refcount for a range of clusters in a given refcount table.
1520 * This is used to construct a temporary refcount table out of L1 and L2 tables
b6af0975 1521 * which can be compared to the refcount table saved in the image.
f7d0fe02 1522 *
9ac228e0 1523 * Modifies the number of errors in res.
f7d0fe02 1524 */
70bacc44
PB
1525int coroutine_fn GRAPH_RDLOCK
1526qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
1527 void **refcount_table,
1528 int64_t *refcount_table_size,
1529 int64_t offset, int64_t size)
f7d0fe02 1530{
ff99129a 1531 BDRVQcow2State *s = bs->opaque;
7453c96b 1532 uint64_t start, last, cluster_offset, k, refcount;
a5fff8d4 1533 int64_t file_len;
5fee192e 1534 int ret;
f7d0fe02 1535
fef4d3d5
HR
1536 if (size <= 0) {
1537 return 0;
1538 }
f7d0fe02 1539
70bacc44 1540 file_len = bdrv_co_getlength(bs->file->bs);
a5fff8d4
VSO
1541 if (file_len < 0) {
1542 return file_len;
1543 }
1544
1545 /*
1546 * Last cluster of qcow2 image may be semi-allocated, so it may be OK to
1547 * reference some space after file end but it should be less than one
1548 * cluster.
1549 */
1550 if (offset + size - file_len >= s->cluster_size) {
1551 fprintf(stderr, "ERROR: counting reference for region exceeding the "
1552 "end of the file by one cluster or more: offset 0x%" PRIx64
1553 " size 0x%" PRIx64 "\n", offset, size);
1554 res->corruptions++;
1555 return 0;
1556 }
1557
ac95acdb
HT
1558 start = start_of_cluster(s, offset);
1559 last = start_of_cluster(s, offset + size - 1);
f7d0fe02
KW
1560 for(cluster_offset = start; cluster_offset <= last;
1561 cluster_offset += s->cluster_size) {
1562 k = cluster_offset >> s->cluster_bits;
641bb63c 1563 if (k >= *refcount_table_size) {
5fee192e
HR
1564 ret = realloc_refcount_array(s, refcount_table,
1565 refcount_table_size, k + 1);
1566 if (ret < 0) {
641bb63c 1567 res->check_errors++;
5fee192e 1568 return ret;
f7d0fe02 1569 }
641bb63c
HR
1570 }
1571
7453c96b
HR
1572 refcount = s->get_refcount(*refcount_table, k);
1573 if (refcount == s->refcount_max) {
641bb63c
HR
1574 fprintf(stderr, "ERROR: overflow cluster offset=0x%" PRIx64
1575 "\n", cluster_offset);
03bb78ed
HR
1576 fprintf(stderr, "Use qemu-img amend to increase the refcount entry "
1577 "width or qemu-img convert to create a clean copy if the "
1578 "image cannot be opened for writing\n");
641bb63c 1579 res->corruptions++;
7453c96b 1580 continue;
f7d0fe02 1581 }
7453c96b 1582 s->set_refcount(*refcount_table, k, refcount + 1);
f7d0fe02 1583 }
fef4d3d5
HR
1584
1585 return 0;
f7d0fe02
KW
1586}
1587
801f7044
SH
1588/* Flags for check_refcounts_l1() and check_refcounts_l2() */
1589enum {
fba31bae 1590 CHECK_FRAG_INFO = 0x2, /* update BlockFragInfo counters */
801f7044
SH
1591};
1592
a2debf65 1593/*
5c3216c0
VSO
1594 * Fix L2 entry by making it QCOW2_CLUSTER_ZERO_PLAIN (or making all its present
1595 * subclusters QCOW2_SUBCLUSTER_ZERO_PLAIN).
a2debf65
VSO
1596 *
1597 * This function decrements res->corruptions on success, so the caller is
1598 * responsible to increment res->corruptions prior to the call.
1599 *
1600 * On failure in-memory @l2_table may be modified.
1601 */
70bacc44
PB
1602static int coroutine_fn GRAPH_RDLOCK
1603fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
1604 uint64_t l2_offset, uint64_t *l2_table,
1605 int l2_index, bool active,
1606 bool *metadata_overlap)
a2debf65
VSO
1607{
1608 BDRVQcow2State *s = bs->opaque;
1609 int ret;
1610 int idx = l2_index * (l2_entry_size(s) / sizeof(uint64_t));
1611 uint64_t l2e_offset = l2_offset + (uint64_t)l2_index * l2_entry_size(s);
1612 int ign = active ? QCOW2_OL_ACTIVE_L2 : QCOW2_OL_INACTIVE_L2;
a2debf65 1613
5c3216c0
VSO
1614 if (has_subclusters(s)) {
1615 uint64_t l2_bitmap = get_l2_bitmap(s, l2_table, l2_index);
1616
1617 /* Allocated subclusters become zero */
1618 l2_bitmap |= l2_bitmap << 32;
1619 l2_bitmap &= QCOW_L2_BITMAP_ALL_ZEROES;
1620
1621 set_l2_bitmap(s, l2_table, l2_index, l2_bitmap);
1622 set_l2_entry(s, l2_table, l2_index, 0);
1623 } else {
1624 set_l2_entry(s, l2_table, l2_index, QCOW_OFLAG_ZERO);
1625 }
1626
a2debf65
VSO
1627 ret = qcow2_pre_write_overlap_check(bs, ign, l2e_offset, l2_entry_size(s),
1628 false);
1629 if (metadata_overlap) {
1630 *metadata_overlap = ret < 0;
1631 }
1632 if (ret < 0) {
1633 fprintf(stderr, "ERROR: Overlap check failed\n");
1634 goto fail;
1635 }
1636
70bacc44
PB
1637 ret = bdrv_co_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
1638 &l2_table[idx], 0);
a2debf65
VSO
1639 if (ret < 0) {
1640 fprintf(stderr, "ERROR: Failed to overwrite L2 "
1641 "table entry: %s\n", strerror(-ret));
1642 goto fail;
1643 }
1644
1645 res->corruptions--;
1646 res->corruptions_fixed++;
1647 return 0;
1648
1649fail:
1650 res->check_errors++;
1651 return ret;
1652}
1653
f7d0fe02
KW
1654/*
1655 * Increases the refcount in the given refcount table for the all clusters
1656 * referenced in the L2 table. While doing so, performs some checks on L2
1657 * entries.
1658 *
1659 * Returns the number of errors found by the checks or -errno if an internal
1660 * error occurred.
1661 */
70bacc44
PB
1662static int coroutine_fn GRAPH_RDLOCK
1663check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
1664 void **refcount_table,
1665 int64_t *refcount_table_size, int64_t l2_offset,
1666 int flags, BdrvCheckMode fix, bool active)
f7d0fe02 1667{
ff99129a 1668 BDRVQcow2State *s = bs->opaque;
9631c782 1669 uint64_t l2_entry, l2_bitmap;
fba31bae 1670 uint64_t next_contiguous_offset = 0;
a6e09846 1671 int i, ret;
786c22d9
VSO
1672 size_t l2_size_bytes = s->l2_size * l2_entry_size(s);
1673 g_autofree uint64_t *l2_table = g_malloc(l2_size_bytes);
a2debf65 1674 bool metadata_overlap;
f7d0fe02
KW
1675
1676 /* Read L2 table from disk */
70bacc44 1677 ret = bdrv_co_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
ad27390c
HR
1678 if (ret < 0) {
1679 fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
1680 res->check_errors++;
786c22d9 1681 return ret;
ad27390c 1682 }
f7d0fe02
KW
1683
1684 /* Do the actual checks */
786c22d9 1685 for (i = 0; i < s->l2_size; i++) {
a6e09846
VSO
1686 uint64_t coffset;
1687 int csize;
289ef5f2
VSO
1688 QCow2ClusterType type;
1689
12c6aebe 1690 l2_entry = get_l2_entry(s, l2_table, i);
9631c782 1691 l2_bitmap = get_l2_bitmap(s, l2_table, i);
289ef5f2
VSO
1692 type = qcow2_get_cluster_type(bs, l2_entry);
1693
1694 if (type != QCOW2_CLUSTER_COMPRESSED) {
1695 /* Check reserved bits of Standard Cluster Descriptor */
1696 if (l2_entry & L2E_STD_RESERVED_MASK) {
1697 fprintf(stderr, "ERROR found l2 entry with reserved bits set: "
1698 "%" PRIx64 "\n", l2_entry);
1699 res->corruptions++;
1700 }
1701 }
afdf0abe 1702
289ef5f2 1703 switch (type) {
afdf0abe
KW
1704 case QCOW2_CLUSTER_COMPRESSED:
1705 /* Compressed clusters don't have QCOW_OFLAG_COPIED */
1706 if (l2_entry & QCOW_OFLAG_COPIED) {
74c44a59 1707 fprintf(stderr, "ERROR: coffset=0x%" PRIx64 ": "
afdf0abe 1708 "copied flag must never be set for compressed "
74c44a59 1709 "clusters\n", l2_entry & s->cluster_offset_mask);
afdf0abe
KW
1710 l2_entry &= ~QCOW_OFLAG_COPIED;
1711 res->corruptions++;
1712 }
f7d0fe02 1713
e9f5b6de
KW
1714 if (has_data_file(bs)) {
1715 fprintf(stderr, "ERROR compressed cluster %d with data file, "
1716 "entry=0x%" PRIx64 "\n", i, l2_entry);
1717 res->corruptions++;
1718 break;
1719 }
1720
9631c782
VSO
1721 if (l2_bitmap) {
1722 fprintf(stderr, "ERROR compressed cluster %d with non-zero "
1723 "subcluster allocation bitmap, entry=0x%" PRIx64 "\n",
1724 i, l2_entry);
1725 res->corruptions++;
1726 break;
1727 }
1728
afdf0abe 1729 /* Mark cluster as used */
a6e09846 1730 qcow2_parse_compressed_l2_entry(bs, l2_entry, &coffset, &csize);
b6c24694 1731 ret = qcow2_inc_refcounts_imrt(
a6e09846 1732 bs, res, refcount_table, refcount_table_size, coffset, csize);
fef4d3d5 1733 if (ret < 0) {
786c22d9 1734 return ret;
fef4d3d5 1735 }
fba31bae
SH
1736
1737 if (flags & CHECK_FRAG_INFO) {
1738 res->bfi.allocated_clusters++;
4db35162 1739 res->bfi.compressed_clusters++;
fba31bae 1740
786c22d9
VSO
1741 /*
1742 * Compressed clusters are fragmented by nature. Since they
fba31bae
SH
1743 * take up sub-sector space but we only have sector granularity
1744 * I/O we need to re-read the same sectors even for adjacent
1745 * compressed clusters.
1746 */
1747 res->bfi.fragmented_clusters++;
1748 }
afdf0abe 1749 break;
f7d0fe02 1750
fdfab37d 1751 case QCOW2_CLUSTER_ZERO_ALLOC:
afdf0abe
KW
1752 case QCOW2_CLUSTER_NORMAL:
1753 {
afdf0abe 1754 uint64_t offset = l2_entry & L2E_OFFSET_MASK;
f7d0fe02 1755
9631c782
VSO
1756 if ((l2_bitmap >> 32) & l2_bitmap) {
1757 res->corruptions++;
1758 fprintf(stderr, "ERROR offset=%" PRIx64 ": Allocated "
1759 "cluster has corrupted subcluster allocation bitmap\n",
1760 offset);
1761 }
1762
ac5b787a
HR
1763 /* Correct offsets are cluster aligned */
1764 if (offset_into_cluster(s, offset)) {
fc2e6528 1765 bool contains_data;
54b10010
VSO
1766 res->corruptions++;
1767
fc2e6528 1768 if (has_subclusters(s)) {
fc2e6528
AG
1769 contains_data = (l2_bitmap & QCOW_L2_BITMAP_ALL_ALLOC);
1770 } else {
1771 contains_data = !(l2_entry & QCOW_OFLAG_ZERO);
1772 }
1773
1774 if (!contains_data) {
1775 fprintf(stderr, "%s offset=%" PRIx64 ": Preallocated "
ac5b787a
HR
1776 "cluster is not properly aligned; L2 entry "
1777 "corrupted.\n",
1778 fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR",
1779 offset);
1780 if (fix & BDRV_FIX_ERRORS) {
a2debf65
VSO
1781 ret = fix_l2_entry_by_zero(bs, res, l2_offset,
1782 l2_table, i, active,
1783 &metadata_overlap);
1784 if (metadata_overlap) {
786c22d9
VSO
1785 /*
1786 * Something is seriously wrong, so abort checking
1787 * this L2 table.
1788 */
1789 return ret;
ac5b787a
HR
1790 }
1791
a2debf65 1792 if (ret == 0) {
786c22d9
VSO
1793 /*
1794 * Skip marking the cluster as used
1795 * (it is unused now).
1796 */
ac5b787a
HR
1797 continue;
1798 }
a2debf65
VSO
1799
1800 /*
1801 * Failed to fix.
1802 * Do not abort, continue checking the rest of this
1803 * L2 table's entries.
1804 */
ac5b787a
HR
1805 }
1806 } else {
1807 fprintf(stderr, "ERROR offset=%" PRIx64 ": Data cluster is "
1808 "not properly aligned; L2 entry corrupted.\n", offset);
ac5b787a
HR
1809 }
1810 }
1811
cbb51e9f
VSO
1812 if (flags & CHECK_FRAG_INFO) {
1813 res->bfi.allocated_clusters++;
1814 if (next_contiguous_offset &&
1815 offset != next_contiguous_offset) {
1816 res->bfi.fragmented_clusters++;
1817 }
1818 next_contiguous_offset = offset + s->cluster_size;
1819 }
1820
afdf0abe 1821 /* Mark cluster as used */
e9f5b6de
KW
1822 if (!has_data_file(bs)) {
1823 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table,
1824 refcount_table_size,
1825 offset, s->cluster_size);
1826 if (ret < 0) {
786c22d9 1827 return ret;
e9f5b6de 1828 }
fef4d3d5 1829 }
afdf0abe
KW
1830 break;
1831 }
1832
fdfab37d 1833 case QCOW2_CLUSTER_ZERO_PLAIN:
9631c782
VSO
1834 /* Impossible when image has subclusters */
1835 assert(!l2_bitmap);
1836 break;
1837
afdf0abe 1838 case QCOW2_CLUSTER_UNALLOCATED:
9631c782
VSO
1839 if (l2_bitmap & QCOW_L2_BITMAP_ALL_ALLOC) {
1840 res->corruptions++;
1841 fprintf(stderr, "ERROR: Unallocated "
1842 "cluster has non-zero subcluster allocation map\n");
1843 }
afdf0abe
KW
1844 break;
1845
1846 default:
1847 abort();
f7d0fe02
KW
1848 }
1849 }
1850
9ac228e0 1851 return 0;
f7d0fe02
KW
1852}
1853
1854/*
1855 * Increases the refcount for the L1 table, its L2 tables and all referenced
1856 * clusters in the given refcount table. While doing so, performs some checks
1857 * on L1 and L2 entries.
1858 *
1859 * Returns the number of errors found by the checks or -errno if an internal
1860 * error occurred.
1861 */
70bacc44
PB
1862static int coroutine_fn GRAPH_RDLOCK
1863check_refcounts_l1(BlockDriverState *bs, BdrvCheckResult *res,
1864 void **refcount_table, int64_t *refcount_table_size,
1865 int64_t l1_table_offset, int l1_size,
1866 int flags, BdrvCheckMode fix, bool active)
f7d0fe02 1867{
ff99129a 1868 BDRVQcow2State *s = bs->opaque;
cd6efd60
VSO
1869 size_t l1_size_bytes = l1_size * L1E_SIZE;
1870 g_autofree uint64_t *l1_table = NULL;
1871 uint64_t l2_offset;
4f6ed88c 1872 int i, ret;
f7d0fe02 1873
cd6efd60
VSO
1874 if (!l1_size) {
1875 return 0;
1876 }
f7d0fe02
KW
1877
1878 /* Mark L1 table as used */
8a5bb1f1 1879 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,
cd6efd60 1880 l1_table_offset, l1_size_bytes);
fef4d3d5 1881 if (ret < 0) {
cd6efd60
VSO
1882 return ret;
1883 }
1884
1885 l1_table = g_try_malloc(l1_size_bytes);
1886 if (l1_table == NULL) {
1887 res->check_errors++;
1888 return -ENOMEM;
fef4d3d5 1889 }
f7d0fe02
KW
1890
1891 /* Read L1 table entries from disk */
70bacc44 1892 ret = bdrv_co_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
cd6efd60
VSO
1893 if (ret < 0) {
1894 fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
1895 res->check_errors++;
1896 return ret;
1897 }
1898
1899 for (i = 0; i < l1_size; i++) {
1900 be64_to_cpus(&l1_table[i]);
702ef63f 1901 }
f7d0fe02
KW
1902
1903 /* Do the actual checks */
cd6efd60
VSO
1904 for (i = 0; i < l1_size; i++) {
1905 if (!l1_table[i]) {
1906 continue;
1907 }
f7d0fe02 1908
98bc07d6
VSO
1909 if (l1_table[i] & L1E_RESERVED_MASK) {
1910 fprintf(stderr, "ERROR found L1 entry with reserved bits set: "
1911 "%" PRIx64 "\n", l1_table[i]);
1912 res->corruptions++;
1913 }
1914
cd6efd60 1915 l2_offset = l1_table[i] & L1E_OFFSET_MASK;
f7d0fe02 1916
cd6efd60
VSO
1917 /* Mark L2 table as used */
1918 ret = qcow2_inc_refcounts_imrt(bs, res,
1919 refcount_table, refcount_table_size,
1920 l2_offset, s->cluster_size);
1921 if (ret < 0) {
1922 return ret;
1923 }
1924
1925 /* L2 tables are cluster aligned */
1926 if (offset_into_cluster(s, l2_offset)) {
1927 fprintf(stderr, "ERROR l2_offset=%" PRIx64 ": Table is not "
1928 "cluster aligned; L1 entry corrupted\n", l2_offset);
1929 res->corruptions++;
1930 }
1931
1932 /* Process and check L2 entries */
1933 ret = check_refcounts_l2(bs, res, refcount_table,
1934 refcount_table_size, l2_offset, flags,
1935 fix, active);
1936 if (ret < 0) {
1937 return ret;
f7d0fe02
KW
1938 }
1939 }
f7d0fe02 1940
cd6efd60 1941 return 0;
f7d0fe02
KW
1942}
1943
4f6ed88c
HR
1944/*
1945 * Checks the OFLAG_COPIED flag for all L1 and L2 entries.
1946 *
1947 * This function does not print an error message nor does it increment
44751917
HR
1948 * check_errors if qcow2_get_refcount fails (this is because such an error will
1949 * have been already detected and sufficiently signaled by the calling function
4f6ed88c
HR
1950 * (qcow2_check_refcounts) by the time this function is called).
1951 */
70bacc44
PB
1952static int coroutine_fn GRAPH_RDLOCK
1953check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
4f6ed88c 1954{
ff99129a 1955 BDRVQcow2State *s = bs->opaque;
4f6ed88c
HR
1956 uint64_t *l2_table = qemu_blockalign(bs, s->cluster_size);
1957 int ret;
0e06528e 1958 uint64_t refcount;
4f6ed88c 1959 int i, j;
3cce51c9
HR
1960 bool repair;
1961
1962 if (fix & BDRV_FIX_ERRORS) {
1963 /* Always repair */
1964 repair = true;
1965 } else if (fix & BDRV_FIX_LEAKS) {
1966 /* Repair only if that seems safe: This function is always
1967 * called after the refcounts have been fixed, so the refcount
1968 * is accurate if that repair was successful */
1969 repair = !res->check_errors && !res->corruptions && !res->leaks;
1970 } else {
1971 repair = false;
1972 }
4f6ed88c
HR
1973
1974 for (i = 0; i < s->l1_size; i++) {
1975 uint64_t l1_entry = s->l1_table[i];
1976 uint64_t l2_offset = l1_entry & L1E_OFFSET_MASK;
7e3e736c 1977 int l2_dirty = 0;
4f6ed88c
HR
1978
1979 if (!l2_offset) {
1980 continue;
1981 }
1982
7324c10f
HR
1983 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
1984 &refcount);
1985 if (ret < 0) {
4f6ed88c
HR
1986 /* don't print message nor increment check_errors */
1987 continue;
1988 }
1989 if ((refcount == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
54b10010 1990 res->corruptions++;
e23e400e 1991 fprintf(stderr, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
0e06528e 1992 "l1_entry=%" PRIx64 " refcount=%" PRIu64 "\n",
3cce51c9
HR
1993 repair ? "Repairing" : "ERROR", i, l1_entry, refcount);
1994 if (repair) {
e23e400e
HR
1995 s->l1_table[i] = refcount == 1
1996 ? l1_entry | QCOW_OFLAG_COPIED
1997 : l1_entry & ~QCOW_OFLAG_COPIED;
1998 ret = qcow2_write_l1_entry(bs, i);
1999 if (ret < 0) {
2000 res->check_errors++;
2001 goto fail;
2002 }
54b10010 2003 res->corruptions--;
e23e400e 2004 res->corruptions_fixed++;
e23e400e 2005 }
4f6ed88c
HR
2006 }
2007
70bacc44
PB
2008 ret = bdrv_co_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
2009 l2_table, 0);
4f6ed88c
HR
2010 if (ret < 0) {
2011 fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
2012 strerror(-ret));
2013 res->check_errors++;
2014 goto fail;
2015 }
2016
2017 for (j = 0; j < s->l2_size; j++) {
12c6aebe 2018 uint64_t l2_entry = get_l2_entry(s, l2_table, j);
4f6ed88c 2019 uint64_t data_offset = l2_entry & L2E_OFFSET_MASK;
808c2bb4 2020 QCow2ClusterType cluster_type = qcow2_get_cluster_type(bs, l2_entry);
4f6ed88c 2021
fdfab37d
EB
2022 if (cluster_type == QCOW2_CLUSTER_NORMAL ||
2023 cluster_type == QCOW2_CLUSTER_ZERO_ALLOC) {
e9f5b6de
KW
2024 if (has_data_file(bs)) {
2025 refcount = 1;
2026 } else {
2027 ret = qcow2_get_refcount(bs,
2028 data_offset >> s->cluster_bits,
2029 &refcount);
2030 if (ret < 0) {
2031 /* don't print message nor increment check_errors */
2032 continue;
2033 }
4f6ed88c
HR
2034 }
2035 if ((refcount == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
54b10010 2036 res->corruptions++;
e23e400e 2037 fprintf(stderr, "%s OFLAG_COPIED data cluster: "
0e06528e 2038 "l2_entry=%" PRIx64 " refcount=%" PRIu64 "\n",
3cce51c9
HR
2039 repair ? "Repairing" : "ERROR", l2_entry, refcount);
2040 if (repair) {
12c6aebe
AG
2041 set_l2_entry(s, l2_table, j,
2042 refcount == 1 ?
2043 l2_entry | QCOW_OFLAG_COPIED :
2044 l2_entry & ~QCOW_OFLAG_COPIED);
7e3e736c 2045 l2_dirty++;
e23e400e 2046 }
4f6ed88c
HR
2047 }
2048 }
2049 }
e23e400e 2050
7e3e736c 2051 if (l2_dirty > 0) {
231bb267 2052 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
966b000f
KW
2053 l2_offset, s->cluster_size,
2054 false);
e23e400e
HR
2055 if (ret < 0) {
2056 fprintf(stderr, "ERROR: Could not write L2 table; metadata "
2057 "overlap check failed: %s\n", strerror(-ret));
2058 res->check_errors++;
2059 goto fail;
2060 }
2061
70bacc44 2062 ret = bdrv_co_pwrite(bs->file, l2_offset, s->cluster_size, l2_table, 0);
e23e400e
HR
2063 if (ret < 0) {
2064 fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
2065 strerror(-ret));
2066 res->check_errors++;
2067 goto fail;
2068 }
54b10010 2069 res->corruptions -= l2_dirty;
7e3e736c 2070 res->corruptions_fixed += l2_dirty;
e23e400e 2071 }
4f6ed88c
HR
2072 }
2073
2074 ret = 0;
2075
2076fail:
2077 qemu_vfree(l2_table);
2078 return ret;
2079}
2080
6ca56bf5
HR
2081/*
2082 * Checks consistency of refblocks and accounts for each refblock in
2083 * *refcount_table.
2084 */
70bacc44
PB
2085static int coroutine_fn GRAPH_RDLOCK
2086check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
2087 BdrvCheckMode fix, bool *rebuild,
2088 void **refcount_table, int64_t *nb_clusters)
6ca56bf5 2089{
ff99129a 2090 BDRVQcow2State *s = bs->opaque;
001c158d 2091 int64_t i, size;
fef4d3d5 2092 int ret;
6ca56bf5 2093
f7d0fe02 2094 for(i = 0; i < s->refcount_table_size; i++) {
6882c8fa 2095 uint64_t offset, cluster;
8fba3951 2096 offset = s->refcount_table[i] & REFT_OFFSET_MASK;
6882c8fa 2097 cluster = offset >> s->cluster_bits;
746c3cb5 2098
8fba3951
VSO
2099 if (s->refcount_table[i] & REFT_RESERVED_MASK) {
2100 fprintf(stderr, "ERROR refcount table entry %" PRId64 " has "
2101 "reserved bits set\n", i);
2102 res->corruptions++;
2103 *rebuild = true;
2104 continue;
2105 }
2106
746c3cb5 2107 /* Refcount blocks are cluster aligned */
ac95acdb 2108 if (offset_into_cluster(s, offset)) {
166acf54 2109 fprintf(stderr, "ERROR refcount block %" PRId64 " is not "
746c3cb5 2110 "cluster aligned; refcount table entry corrupted\n", i);
9ac228e0 2111 res->corruptions++;
f307b255 2112 *rebuild = true;
6882c8fa
KW
2113 continue;
2114 }
2115
6ca56bf5 2116 if (cluster >= *nb_clusters) {
54b10010 2117 res->corruptions++;
001c158d
HR
2118 fprintf(stderr, "%s refcount block %" PRId64 " is outside image\n",
2119 fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);
2120
2121 if (fix & BDRV_FIX_ERRORS) {
5fee192e 2122 int64_t new_nb_clusters;
ed3d2ec9 2123 Error *local_err = NULL;
001c158d
HR
2124
2125 if (offset > INT64_MAX - s->cluster_size) {
2126 ret = -EINVAL;
2127 goto resize_fail;
2128 }
2129
70bacc44
PB
2130 ret = bdrv_co_truncate(bs->file, offset + s->cluster_size, false,
2131 PREALLOC_MODE_OFF, 0, &local_err);
001c158d 2132 if (ret < 0) {
ed3d2ec9 2133 error_report_err(local_err);
001c158d
HR
2134 goto resize_fail;
2135 }
70bacc44 2136 size = bdrv_co_getlength(bs->file->bs);
001c158d
HR
2137 if (size < 0) {
2138 ret = size;
2139 goto resize_fail;
2140 }
2141
5fee192e
HR
2142 new_nb_clusters = size_to_clusters(s, size);
2143 assert(new_nb_clusters >= *nb_clusters);
001c158d 2144
5fee192e
HR
2145 ret = realloc_refcount_array(s, refcount_table,
2146 nb_clusters, new_nb_clusters);
2147 if (ret < 0) {
001c158d 2148 res->check_errors++;
5fee192e 2149 return ret;
001c158d 2150 }
001c158d
HR
2151
2152 if (cluster >= *nb_clusters) {
2153 ret = -EINVAL;
2154 goto resize_fail;
2155 }
2156
54b10010 2157 res->corruptions--;
001c158d 2158 res->corruptions_fixed++;
8a5bb1f1
VSO
2159 ret = qcow2_inc_refcounts_imrt(bs, res,
2160 refcount_table, nb_clusters,
2161 offset, s->cluster_size);
001c158d
HR
2162 if (ret < 0) {
2163 return ret;
2164 }
2165 /* No need to check whether the refcount is now greater than 1:
2166 * This area was just allocated and zeroed, so it can only be
8a5bb1f1 2167 * exactly 1 after qcow2_inc_refcounts_imrt() */
001c158d
HR
2168 continue;
2169
2170resize_fail:
f307b255 2171 *rebuild = true;
001c158d
HR
2172 fprintf(stderr, "ERROR could not resize image: %s\n",
2173 strerror(-ret));
001c158d 2174 }
6882c8fa 2175 continue;
746c3cb5
KW
2176 }
2177
f7d0fe02 2178 if (offset != 0) {
8a5bb1f1
VSO
2179 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2180 offset, s->cluster_size);
fef4d3d5
HR
2181 if (ret < 0) {
2182 return ret;
2183 }
7453c96b 2184 if (s->get_refcount(*refcount_table, cluster) != 1) {
f307b255 2185 fprintf(stderr, "ERROR refcount block %" PRId64
7453c96b
HR
2186 " refcount=%" PRIu64 "\n", i,
2187 s->get_refcount(*refcount_table, cluster));
f307b255
HR
2188 res->corruptions++;
2189 *rebuild = true;
746c3cb5 2190 }
f7d0fe02
KW
2191 }
2192 }
2193
6ca56bf5
HR
2194 return 0;
2195}
2196
057a3fe5
HR
2197/*
2198 * Calculates an in-memory refcount table.
2199 */
70bacc44
PB
2200static int coroutine_fn GRAPH_RDLOCK
2201calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
2202 BdrvCheckMode fix, bool *rebuild,
2203 void **refcount_table, int64_t *nb_clusters)
057a3fe5 2204{
ff99129a 2205 BDRVQcow2State *s = bs->opaque;
057a3fe5
HR
2206 int64_t i;
2207 QCowSnapshot *sn;
2208 int ret;
2209
9696df21 2210 if (!*refcount_table) {
5fee192e
HR
2211 int64_t old_size = 0;
2212 ret = realloc_refcount_array(s, refcount_table,
2213 &old_size, *nb_clusters);
2214 if (ret < 0) {
9696df21 2215 res->check_errors++;
5fee192e 2216 return ret;
9696df21 2217 }
057a3fe5
HR
2218 }
2219
2220 /* header */
8a5bb1f1
VSO
2221 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2222 0, s->cluster_size);
fef4d3d5
HR
2223 if (ret < 0) {
2224 return ret;
2225 }
057a3fe5
HR
2226
2227 /* current L1 table */
641bb63c 2228 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
ac5b787a 2229 s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO,
1ef337b7 2230 fix, true);
057a3fe5
HR
2231 if (ret < 0) {
2232 return ret;
2233 }
2234
2235 /* snapshots */
e9f5b6de
KW
2236 if (has_data_file(bs) && s->nb_snapshots) {
2237 fprintf(stderr, "ERROR %d snapshots in image with data file\n",
2238 s->nb_snapshots);
2239 res->corruptions++;
2240 }
2241
057a3fe5
HR
2242 for (i = 0; i < s->nb_snapshots; i++) {
2243 sn = s->snapshots + i;
0c2ada81
AG
2244 if (offset_into_cluster(s, sn->l1_table_offset)) {
2245 fprintf(stderr, "ERROR snapshot %s (%s) l1_offset=%#" PRIx64 ": "
2246 "L1 table is not cluster aligned; snapshot table entry "
2247 "corrupted\n", sn->id_str, sn->name, sn->l1_table_offset);
2248 res->corruptions++;
2249 continue;
2250 }
02b1ecfa 2251 if (sn->l1_size > QCOW_MAX_L1_SIZE / L1E_SIZE) {
0c2ada81
AG
2252 fprintf(stderr, "ERROR snapshot %s (%s) l1_size=%#" PRIx32 ": "
2253 "L1 table is too large; snapshot table entry corrupted\n",
2254 sn->id_str, sn->name, sn->l1_size);
2255 res->corruptions++;
2256 continue;
2257 }
641bb63c 2258 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
1ef337b7
VSO
2259 sn->l1_table_offset, sn->l1_size, 0, fix,
2260 false);
057a3fe5
HR
2261 if (ret < 0) {
2262 return ret;
2263 }
2264 }
8a5bb1f1
VSO
2265 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2266 s->snapshots_offset, s->snapshots_size);
fef4d3d5
HR
2267 if (ret < 0) {
2268 return ret;
2269 }
057a3fe5
HR
2270
2271 /* refcount data */
8a5bb1f1
VSO
2272 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2273 s->refcount_table_offset,
02b1ecfa
AG
2274 s->refcount_table_size *
2275 REFTABLE_ENTRY_SIZE);
fef4d3d5
HR
2276 if (ret < 0) {
2277 return ret;
2278 }
057a3fe5 2279
4652b8f3
DB
2280 /* encryption */
2281 if (s->crypto_header.length) {
8a5bb1f1
VSO
2282 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2283 s->crypto_header.offset,
2284 s->crypto_header.length);
4652b8f3
DB
2285 if (ret < 0) {
2286 return ret;
2287 }
2288 }
2289
88ddffae
VSO
2290 /* bitmaps */
2291 ret = qcow2_check_bitmaps_refcounts(bs, res, refcount_table, nb_clusters);
2292 if (ret < 0) {
2293 return ret;
2294 }
2295
f307b255 2296 return check_refblocks(bs, res, fix, rebuild, refcount_table, nb_clusters);
057a3fe5
HR
2297}
2298
6ca56bf5
HR
2299/*
2300 * Compares the actual reference count for each cluster in the image against the
2301 * refcount as reported by the refcount structures on-disk.
2302 */
0bb79c97 2303static void coroutine_fn GRAPH_RDLOCK
70bacc44
PB
2304compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
2305 BdrvCheckMode fix, bool *rebuild,
2306 int64_t *highest_cluster,
2307 void *refcount_table, int64_t nb_clusters)
6ca56bf5 2308{
ff99129a 2309 BDRVQcow2State *s = bs->opaque;
6ca56bf5 2310 int64_t i;
0e06528e 2311 uint64_t refcount1, refcount2;
7324c10f 2312 int ret;
6ca56bf5
HR
2313
2314 for (i = 0, *highest_cluster = 0; i < nb_clusters; i++) {
7324c10f
HR
2315 ret = qcow2_get_refcount(bs, i, &refcount1);
2316 if (ret < 0) {
166acf54 2317 fprintf(stderr, "Can't get refcount for cluster %" PRId64 ": %s\n",
7324c10f 2318 i, strerror(-ret));
9ac228e0 2319 res->check_errors++;
f74550fd 2320 continue;
018faafd
KW
2321 }
2322
7453c96b 2323 refcount2 = s->get_refcount(refcount_table, i);
c6bb9ad1
FS
2324
2325 if (refcount1 > 0 || refcount2 > 0) {
6ca56bf5 2326 *highest_cluster = i;
c6bb9ad1
FS
2327 }
2328
f7d0fe02 2329 if (refcount1 != refcount2) {
166acf54
KW
2330 /* Check if we're allowed to fix the mismatch */
2331 int *num_fixed = NULL;
f307b255
HR
2332 if (refcount1 == 0) {
2333 *rebuild = true;
2334 } else if (refcount1 > refcount2 && (fix & BDRV_FIX_LEAKS)) {
166acf54
KW
2335 num_fixed = &res->leaks_fixed;
2336 } else if (refcount1 < refcount2 && (fix & BDRV_FIX_ERRORS)) {
2337 num_fixed = &res->corruptions_fixed;
2338 }
2339
0e06528e
HR
2340 fprintf(stderr, "%s cluster %" PRId64 " refcount=%" PRIu64
2341 " reference=%" PRIu64 "\n",
166acf54
KW
2342 num_fixed != NULL ? "Repairing" :
2343 refcount1 < refcount2 ? "ERROR" :
2344 "Leaked",
f7d0fe02 2345 i, refcount1, refcount2);
166acf54
KW
2346
2347 if (num_fixed) {
2348 ret = update_refcount(bs, i << s->cluster_bits, 1,
2aabe7c7
HR
2349 refcount_diff(refcount1, refcount2),
2350 refcount1 > refcount2,
6cfcb9b8 2351 QCOW2_DISCARD_ALWAYS);
166acf54
KW
2352 if (ret >= 0) {
2353 (*num_fixed)++;
2354 continue;
2355 }
2356 }
2357
2358 /* And if we couldn't, print an error */
9ac228e0
KW
2359 if (refcount1 < refcount2) {
2360 res->corruptions++;
2361 } else {
2362 res->leaks++;
2363 }
f7d0fe02
KW
2364 }
2365 }
6ca56bf5
HR
2366}
2367
c7c0681b
HR
2368/*
2369 * Allocates clusters using an in-memory refcount table (IMRT) in contrast to
2370 * the on-disk refcount structures.
2371 *
2372 * On input, *first_free_cluster tells where to start looking, and need not
2373 * actually be a free cluster; the returned offset will not be before that
2374 * cluster. On output, *first_free_cluster points to the first gap found, even
2375 * if that gap was too small to be used as the returned offset.
2376 *
2377 * Note that *first_free_cluster is a cluster index whereas the return value is
2378 * an offset.
2379 */
2380static int64_t alloc_clusters_imrt(BlockDriverState *bs,
2381 int cluster_count,
7453c96b 2382 void **refcount_table,
c7c0681b
HR
2383 int64_t *imrt_nb_clusters,
2384 int64_t *first_free_cluster)
2385{
ff99129a 2386 BDRVQcow2State *s = bs->opaque;
c7c0681b
HR
2387 int64_t cluster = *first_free_cluster, i;
2388 bool first_gap = true;
2389 int contiguous_free_clusters;
5fee192e 2390 int ret;
c7c0681b
HR
2391
2392 /* Starting at *first_free_cluster, find a range of at least cluster_count
2393 * continuously free clusters */
2394 for (contiguous_free_clusters = 0;
2395 cluster < *imrt_nb_clusters &&
2396 contiguous_free_clusters < cluster_count;
2397 cluster++)
2398 {
7453c96b 2399 if (!s->get_refcount(*refcount_table, cluster)) {
c7c0681b
HR
2400 contiguous_free_clusters++;
2401 if (first_gap) {
2402 /* If this is the first free cluster found, update
2403 * *first_free_cluster accordingly */
2404 *first_free_cluster = cluster;
2405 first_gap = false;
2406 }
2407 } else if (contiguous_free_clusters) {
2408 contiguous_free_clusters = 0;
2409 }
2410 }
2411
2412 /* If contiguous_free_clusters is greater than zero, it contains the number
2413 * of continuously free clusters until the current cluster; the first free
2414 * cluster in the current "gap" is therefore
2415 * cluster - contiguous_free_clusters */
2416
2417 /* If no such range could be found, grow the in-memory refcount table
2418 * accordingly to append free clusters at the end of the image */
2419 if (contiguous_free_clusters < cluster_count) {
c7c0681b
HR
2420 /* contiguous_free_clusters clusters are already empty at the image end;
2421 * we need cluster_count clusters; therefore, we have to allocate
2422 * cluster_count - contiguous_free_clusters new clusters at the end of
2423 * the image (which is the current value of cluster; note that cluster
2424 * may exceed old_imrt_nb_clusters if *first_free_cluster pointed beyond
2425 * the image end) */
5fee192e
HR
2426 ret = realloc_refcount_array(s, refcount_table, imrt_nb_clusters,
2427 cluster + cluster_count
2428 - contiguous_free_clusters);
2429 if (ret < 0) {
2430 return ret;
c7c0681b 2431 }
c7c0681b
HR
2432 }
2433
2434 /* Go back to the first free cluster */
2435 cluster -= contiguous_free_clusters;
2436 for (i = 0; i < cluster_count; i++) {
7453c96b 2437 s->set_refcount(*refcount_table, cluster + i, 1);
c7c0681b
HR
2438 }
2439
2440 return cluster << s->cluster_bits;
2441}
2442
2443/*
a8c07ec2 2444 * Helper function for rebuild_refcount_structure().
c7c0681b 2445 *
a8c07ec2
HR
2446 * Scan the range of clusters [first_cluster, end_cluster) for allocated
2447 * clusters and write all corresponding refblocks to disk. The refblock
2448 * and allocation data is taken from the in-memory refcount table
2449 * *refcount_table[] (of size *nb_clusters), which is basically one big
2450 * (unlimited size) refblock for the whole image.
2451 *
2452 * For these refblocks, clusters are allocated using said in-memory
2453 * refcount table. Care is taken that these allocations are reflected
2454 * in the refblocks written to disk.
2455 *
2456 * The refblocks' offsets are written into a reftable, which is
2457 * *on_disk_reftable_ptr[] (of size *on_disk_reftable_entries_ptr). If
2458 * that reftable is of insufficient size, it will be resized to fit.
2459 * This reftable is not written to disk.
2460 *
2461 * (If *on_disk_reftable_ptr is not NULL, the entries within are assumed
2462 * to point to existing valid refblocks that do not need to be allocated
2463 * again.)
2464 *
2465 * Return whether the on-disk reftable array was resized (true/false),
2466 * or -errno on error.
c7c0681b 2467 */
70bacc44
PB
2468static int coroutine_fn GRAPH_RDLOCK
2469rebuild_refcounts_write_refblocks(
a8c07ec2
HR
2470 BlockDriverState *bs, void **refcount_table, int64_t *nb_clusters,
2471 int64_t first_cluster, int64_t end_cluster,
0423f753
HR
2472 uint64_t **on_disk_reftable_ptr, uint32_t *on_disk_reftable_entries_ptr,
2473 Error **errp
a8c07ec2 2474 )
c7c0681b 2475{
ff99129a 2476 BDRVQcow2State *s = bs->opaque;
a8c07ec2 2477 int64_t cluster;
c7c0681b 2478 int64_t refblock_offset, refblock_start, refblock_index;
a8c07ec2
HR
2479 int64_t first_free_cluster = 0;
2480 uint64_t *on_disk_reftable = *on_disk_reftable_ptr;
2481 uint32_t on_disk_reftable_entries = *on_disk_reftable_entries_ptr;
7453c96b 2482 void *on_disk_refblock;
a8c07ec2
HR
2483 bool reftable_grown = false;
2484 int ret;
c7c0681b 2485
a8c07ec2
HR
2486 for (cluster = first_cluster; cluster < end_cluster; cluster++) {
2487 /* Check all clusters to find refblocks that contain non-zero entries */
7453c96b 2488 if (!s->get_refcount(*refcount_table, cluster)) {
c7c0681b
HR
2489 continue;
2490 }
2491
a8c07ec2
HR
2492 /*
2493 * This cluster is allocated, so we need to create a refblock
2494 * for it. The data we will write to disk is just the
2495 * respective slice from *refcount_table, so it will contain
2496 * accurate refcounts for all clusters belonging to this
2497 * refblock. After we have written it, we will therefore skip
2498 * all remaining clusters in this refblock.
2499 */
2500
c7c0681b
HR
2501 refblock_index = cluster >> s->refcount_block_bits;
2502 refblock_start = refblock_index << s->refcount_block_bits;
2503
a8c07ec2
HR
2504 if (on_disk_reftable_entries > refblock_index &&
2505 on_disk_reftable[refblock_index])
2506 {
2507 /*
2508 * We can get here after a `goto write_refblocks`: We have a
2509 * reftable from a previous run, and the refblock is already
2510 * allocated. No need to allocate it again.
2511 */
2512 refblock_offset = on_disk_reftable[refblock_index];
2513 } else {
2514 int64_t refblock_cluster_index;
c7c0681b 2515
a8c07ec2
HR
2516 /* Don't allocate a cluster in a refblock already written to disk */
2517 if (first_free_cluster < refblock_start) {
2518 first_free_cluster = refblock_start;
2519 }
2520 refblock_offset = alloc_clusters_imrt(bs, 1, refcount_table,
2521 nb_clusters,
2522 &first_free_cluster);
2523 if (refblock_offset < 0) {
0423f753
HR
2524 error_setg_errno(errp, -refblock_offset,
2525 "ERROR allocating refblock");
a8c07ec2
HR
2526 return refblock_offset;
2527 }
c7c0681b 2528
a8c07ec2
HR
2529 refblock_cluster_index = refblock_offset / s->cluster_size;
2530 if (refblock_cluster_index >= end_cluster) {
2531 /*
2532 * We must write the refblock that holds this refblock's
2533 * refcount
2534 */
2535 end_cluster = refblock_cluster_index + 1;
c7c0681b 2536 }
c7c0681b 2537
a8c07ec2
HR
2538 if (on_disk_reftable_entries <= refblock_index) {
2539 on_disk_reftable_entries =
2540 ROUND_UP((refblock_index + 1) * REFTABLE_ENTRY_SIZE,
2541 s->cluster_size) / REFTABLE_ENTRY_SIZE;
2542 on_disk_reftable =
2543 g_try_realloc(on_disk_reftable,
2544 on_disk_reftable_entries *
2545 REFTABLE_ENTRY_SIZE);
2546 if (!on_disk_reftable) {
0423f753 2547 error_setg(errp, "ERROR allocating reftable memory");
a8c07ec2
HR
2548 return -ENOMEM;
2549 }
c7c0681b 2550
a8c07ec2
HR
2551 memset(on_disk_reftable + *on_disk_reftable_entries_ptr, 0,
2552 (on_disk_reftable_entries -
2553 *on_disk_reftable_entries_ptr) *
2554 REFTABLE_ENTRY_SIZE);
c7c0681b 2555
a8c07ec2
HR
2556 *on_disk_reftable_ptr = on_disk_reftable;
2557 *on_disk_reftable_entries_ptr = on_disk_reftable_entries;
2558
2559 reftable_grown = true;
2560 } else {
2561 assert(on_disk_reftable);
c7c0681b 2562 }
a8c07ec2 2563 on_disk_reftable[refblock_index] = refblock_offset;
c7c0681b
HR
2564 }
2565
a8c07ec2
HR
2566 /* Refblock is allocated, write it to disk */
2567
c7c0681b 2568 ret = qcow2_pre_write_overlap_check(bs, 0, refblock_offset,
966b000f 2569 s->cluster_size, false);
c7c0681b 2570 if (ret < 0) {
0423f753 2571 error_setg_errno(errp, -ret, "ERROR writing refblock");
a8c07ec2 2572 return ret;
c7c0681b
HR
2573 }
2574
a8c07ec2
HR
2575 /*
2576 * The refblock is simply a slice of *refcount_table.
2577 * Note that the size of *refcount_table is always aligned to
2578 * whole clusters, so the write operation will not result in
2579 * out-of-bounds accesses.
2580 */
7453c96b
HR
2581 on_disk_refblock = (void *)((char *) *refcount_table +
2582 refblock_index * s->cluster_size);
c7c0681b 2583
70bacc44
PB
2584 ret = bdrv_co_pwrite(bs->file, refblock_offset, s->cluster_size,
2585 on_disk_refblock, 0);
c7c0681b 2586 if (ret < 0) {
0423f753 2587 error_setg_errno(errp, -ret, "ERROR writing refblock");
a8c07ec2 2588 return ret;
c7c0681b
HR
2589 }
2590
a8c07ec2 2591 /* This refblock is done, skip to its end */
c7c0681b
HR
2592 cluster = refblock_start + s->refcount_block_size - 1;
2593 }
2594
a8c07ec2
HR
2595 return reftable_grown;
2596}
2597
2598/*
2599 * Creates a new refcount structure based solely on the in-memory information
2600 * given through *refcount_table (this in-memory information is basically just
2601 * the concatenation of all refblocks). All necessary allocations will be
2602 * reflected in that array.
2603 *
2604 * On success, the old refcount structure is leaked (it will be covered by the
2605 * new refcount structure).
2606 */
70bacc44
PB
2607static int coroutine_fn GRAPH_RDLOCK
2608rebuild_refcount_structure(BlockDriverState *bs, BdrvCheckResult *res,
2609 void **refcount_table, int64_t *nb_clusters,
2610 Error **errp)
a8c07ec2
HR
2611{
2612 BDRVQcow2State *s = bs->opaque;
2613 int64_t reftable_offset = -1;
2614 int64_t reftable_length = 0;
2615 int64_t reftable_clusters;
2616 int64_t refblock_index;
2617 uint32_t on_disk_reftable_entries = 0;
2618 uint64_t *on_disk_reftable = NULL;
2619 int ret = 0;
2620 int reftable_size_changed = 0;
2621 struct {
2622 uint64_t reftable_offset;
2623 uint32_t reftable_clusters;
2624 } QEMU_PACKED reftable_offset_and_clusters;
2625
2626 qcow2_cache_empty(bs, s->refcount_block_cache);
2627
2628 /*
2629 * For each refblock containing entries, we try to allocate a
2630 * cluster (in the in-memory refcount table) and write its offset
2631 * into on_disk_reftable[]. We then write the whole refblock to
2632 * disk (as a slice of the in-memory refcount table).
2633 * This is done by rebuild_refcounts_write_refblocks().
2634 *
2635 * Once we have scanned all clusters, we try to find space for the
2636 * reftable. This will dirty the in-memory refcount table (i.e.
2637 * make it differ from the refblocks we have already written), so we
2638 * need to run rebuild_refcounts_write_refblocks() again for the
2639 * range of clusters where the reftable has been allocated.
2640 *
2641 * This second run might make the reftable grow again, in which case
2642 * we will need to allocate another space for it, which is why we
2643 * repeat all this until the reftable stops growing.
2644 *
2645 * (This loop will terminate, because with every cluster the
3202d8e4 2646 * reftable grows, it can accommodate a multitude of more refcounts,
a8c07ec2
HR
2647 * so that at some point this must be able to cover the reftable
2648 * and all refblocks describing it.)
2649 *
2650 * We then convert the reftable to big-endian and write it to disk.
2651 *
2652 * Note that we never free any reftable allocations. Doing so would
2653 * needlessly complicate the algorithm: The eventual second check
2654 * run we do will clean up all leaks we have caused.
2655 */
2656
2657 reftable_size_changed =
2658 rebuild_refcounts_write_refblocks(bs, refcount_table, nb_clusters,
2659 0, *nb_clusters,
2660 &on_disk_reftable,
0423f753 2661 &on_disk_reftable_entries, errp);
a8c07ec2
HR
2662 if (reftable_size_changed < 0) {
2663 res->check_errors++;
2664 ret = reftable_size_changed;
2665 goto fail;
2666 }
2667
2668 /*
2669 * There was no reftable before, so rebuild_refcounts_write_refblocks()
2670 * must have increased its size (from 0 to something).
2671 */
2672 assert(reftable_size_changed);
2673
2674 do {
2675 int64_t reftable_start_cluster, reftable_end_cluster;
2676 int64_t first_free_cluster = 0;
2677
2678 reftable_length = on_disk_reftable_entries * REFTABLE_ENTRY_SIZE;
2679 reftable_clusters = size_to_clusters(s, reftable_length);
c7c0681b 2680
c7c0681b
HR
2681 reftable_offset = alloc_clusters_imrt(bs, reftable_clusters,
2682 refcount_table, nb_clusters,
2683 &first_free_cluster);
2684 if (reftable_offset < 0) {
0423f753
HR
2685 error_setg_errno(errp, -reftable_offset,
2686 "ERROR allocating reftable");
c7c0681b
HR
2687 res->check_errors++;
2688 ret = reftable_offset;
2689 goto fail;
2690 }
2691
a8c07ec2
HR
2692 /*
2693 * We need to update the affected refblocks, so re-run the
2694 * write_refblocks loop for the reftable's range of clusters.
2695 */
2696 assert(offset_into_cluster(s, reftable_offset) == 0);
2697 reftable_start_cluster = reftable_offset / s->cluster_size;
2698 reftable_end_cluster = reftable_start_cluster + reftable_clusters;
2699 reftable_size_changed =
2700 rebuild_refcounts_write_refblocks(bs, refcount_table, nb_clusters,
2701 reftable_start_cluster,
2702 reftable_end_cluster,
2703 &on_disk_reftable,
0423f753 2704 &on_disk_reftable_entries, errp);
a8c07ec2
HR
2705 if (reftable_size_changed < 0) {
2706 res->check_errors++;
2707 ret = reftable_size_changed;
2708 goto fail;
2709 }
2710
2711 /*
2712 * If the reftable size has changed, we will need to find a new
2713 * allocation, repeating the loop.
2714 */
2715 } while (reftable_size_changed);
c7c0681b 2716
a8c07ec2
HR
2717 /* The above loop must have run at least once */
2718 assert(reftable_offset >= 0);
2719
2720 /*
2721 * All allocations are done, all refblocks are written, convert the
2722 * reftable to big-endian and write it to disk.
2723 */
2724
2725 for (refblock_index = 0; refblock_index < on_disk_reftable_entries;
2726 refblock_index++)
2727 {
c7c0681b
HR
2728 cpu_to_be64s(&on_disk_reftable[refblock_index]);
2729 }
2730
a8c07ec2 2731 ret = qcow2_pre_write_overlap_check(bs, 0, reftable_offset, reftable_length,
966b000f 2732 false);
c7c0681b 2733 if (ret < 0) {
0423f753 2734 error_setg_errno(errp, -ret, "ERROR writing reftable");
c7c0681b
HR
2735 goto fail;
2736 }
2737
a8c07ec2 2738 assert(reftable_length < INT_MAX);
70bacc44
PB
2739 ret = bdrv_co_pwrite(bs->file, reftable_offset, reftable_length,
2740 on_disk_reftable, 0);
c7c0681b 2741 if (ret < 0) {
0423f753 2742 error_setg_errno(errp, -ret, "ERROR writing reftable");
c7c0681b
HR
2743 goto fail;
2744 }
2745
2746 /* Enter new reftable into the image header */
f1f7a1dd
PM
2747 reftable_offset_and_clusters.reftable_offset = cpu_to_be64(reftable_offset);
2748 reftable_offset_and_clusters.reftable_clusters =
a8c07ec2 2749 cpu_to_be32(reftable_clusters);
70bacc44
PB
2750 ret = bdrv_co_pwrite_sync(bs->file,
2751 offsetof(QCowHeader, refcount_table_offset),
2752 sizeof(reftable_offset_and_clusters),
2753 &reftable_offset_and_clusters, 0);
c7c0681b 2754 if (ret < 0) {
0423f753 2755 error_setg_errno(errp, -ret, "ERROR setting reftable");
c7c0681b
HR
2756 goto fail;
2757 }
2758
a8c07ec2
HR
2759 for (refblock_index = 0; refblock_index < on_disk_reftable_entries;
2760 refblock_index++)
2761 {
c7c0681b
HR
2762 be64_to_cpus(&on_disk_reftable[refblock_index]);
2763 }
2764 s->refcount_table = on_disk_reftable;
2765 s->refcount_table_offset = reftable_offset;
a8c07ec2 2766 s->refcount_table_size = on_disk_reftable_entries;
7061a078 2767 update_max_refcount_table_index(s);
c7c0681b
HR
2768
2769 return 0;
2770
2771fail:
2772 g_free(on_disk_reftable);
2773 return ret;
2774}
2775
6ca56bf5
HR
2776/*
2777 * Checks an image for refcount consistency.
2778 *
2779 * Returns 0 if no errors are found, the number of errors in case the image is
2780 * detected as corrupted, and -errno when an internal error occurred.
2781 */
70bacc44
PB
2782int coroutine_fn GRAPH_RDLOCK
2783qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
6ca56bf5 2784{
ff99129a 2785 BDRVQcow2State *s = bs->opaque;
c7c0681b 2786 BdrvCheckResult pre_compare_res;
6ca56bf5 2787 int64_t size, highest_cluster, nb_clusters;
7453c96b 2788 void *refcount_table = NULL;
f307b255 2789 bool rebuild = false;
6ca56bf5
HR
2790 int ret;
2791
70bacc44 2792 size = bdrv_co_getlength(bs->file->bs);
6ca56bf5
HR
2793 if (size < 0) {
2794 res->check_errors++;
2795 return size;
2796 }
2797
2798 nb_clusters = size_to_clusters(s, size);
2799 if (nb_clusters > INT_MAX) {
2800 res->check_errors++;
2801 return -EFBIG;
2802 }
2803
2804 res->bfi.total_clusters =
2805 size_to_clusters(s, bs->total_sectors * BDRV_SECTOR_SIZE);
2806
f307b255
HR
2807 ret = calculate_refcounts(bs, res, fix, &rebuild, &refcount_table,
2808 &nb_clusters);
6ca56bf5
HR
2809 if (ret < 0) {
2810 goto fail;
2811 }
2812
c7c0681b
HR
2813 /* In case we don't need to rebuild the refcount structure (but want to fix
2814 * something), this function is immediately called again, in which case the
2815 * result should be ignored */
2816 pre_compare_res = *res;
2817 compare_refcounts(bs, res, 0, &rebuild, &highest_cluster, refcount_table,
6ca56bf5 2818 nb_clusters);
f7d0fe02 2819
c7c0681b 2820 if (rebuild && (fix & BDRV_FIX_ERRORS)) {
791230d8
HR
2821 BdrvCheckResult old_res = *res;
2822 int fresh_leaks = 0;
0423f753 2823 Error *local_err = NULL;
791230d8 2824
c7c0681b
HR
2825 fprintf(stderr, "Rebuilding refcount structure\n");
2826 ret = rebuild_refcount_structure(bs, res, &refcount_table,
0423f753 2827 &nb_clusters, &local_err);
c7c0681b 2828 if (ret < 0) {
0423f753 2829 error_report_err(local_err);
c7c0681b
HR
2830 goto fail;
2831 }
791230d8
HR
2832
2833 res->corruptions = 0;
2834 res->leaks = 0;
2835
2836 /* Because the old reftable has been exchanged for a new one the
2837 * references have to be recalculated */
2838 rebuild = false;
7453c96b 2839 memset(refcount_table, 0, refcount_array_byte_size(s, nb_clusters));
791230d8
HR
2840 ret = calculate_refcounts(bs, res, 0, &rebuild, &refcount_table,
2841 &nb_clusters);
2842 if (ret < 0) {
2843 goto fail;
2844 }
2845
2846 if (fix & BDRV_FIX_LEAKS) {
2847 /* The old refcount structures are now leaked, fix it; the result
2848 * can be ignored, aside from leaks which were introduced by
2849 * rebuild_refcount_structure() that could not be fixed */
2850 BdrvCheckResult saved_res = *res;
2851 *res = (BdrvCheckResult){ 0 };
2852
2853 compare_refcounts(bs, res, BDRV_FIX_LEAKS, &rebuild,
2854 &highest_cluster, refcount_table, nb_clusters);
2855 if (rebuild) {
2856 fprintf(stderr, "ERROR rebuilt refcount structure is still "
2857 "broken\n");
2858 }
2859
2860 /* Any leaks accounted for here were introduced by
2861 * rebuild_refcount_structure() because that function has created a
2862 * new refcount structure from scratch */
2863 fresh_leaks = res->leaks;
2864 *res = saved_res;
2865 }
2866
2867 if (res->corruptions < old_res.corruptions) {
2868 res->corruptions_fixed += old_res.corruptions - res->corruptions;
2869 }
2870 if (res->leaks < old_res.leaks) {
2871 res->leaks_fixed += old_res.leaks - res->leaks;
2872 }
2873 res->leaks += fresh_leaks;
c7c0681b
HR
2874 } else if (fix) {
2875 if (rebuild) {
2876 fprintf(stderr, "ERROR need to rebuild refcount structures\n");
2877 res->check_errors++;
2878 ret = -EIO;
2879 goto fail;
2880 }
2881
2882 if (res->leaks || res->corruptions) {
2883 *res = pre_compare_res;
2884 compare_refcounts(bs, res, fix, &rebuild, &highest_cluster,
2885 refcount_table, nb_clusters);
2886 }
f307b255
HR
2887 }
2888
4f6ed88c 2889 /* check OFLAG_COPIED */
e23e400e 2890 ret = check_oflag_copied(bs, res, fix);
4f6ed88c
HR
2891 if (ret < 0) {
2892 goto fail;
2893 }
2894
c6bb9ad1 2895 res->image_end_offset = (highest_cluster + 1) * s->cluster_size;
80fa3341
KW
2896 ret = 0;
2897
2898fail:
7267c094 2899 g_free(refcount_table);
f7d0fe02 2900
80fa3341 2901 return ret;
f7d0fe02
KW
2902}
2903
a40f1c2a
HR
2904#define overlaps_with(ofs, sz) \
2905 ranges_overlap(offset, size, ofs, sz)
2906
2907/*
2908 * Checks if the given offset into the image file is actually free to use by
2909 * looking for overlaps with important metadata sections (L1/L2 tables etc.),
2910 * i.e. a sanity check without relying on the refcount tables.
2911 *
231bb267
HR
2912 * The ign parameter specifies what checks not to perform (being a bitmask of
2913 * QCow2MetadataOverlap values), i.e., what sections to ignore.
a40f1c2a
HR
2914 *
2915 * Returns:
2916 * - 0 if writing to this offset will not affect the mentioned metadata
2917 * - a positive QCow2MetadataOverlap value indicating one overlapping section
2918 * - a negative value (-errno) indicating an error while performing a check,
f4649069 2919 * e.g. when bdrv_pread failed on QCOW2_OL_INACTIVE_L2
a40f1c2a 2920 */
231bb267 2921int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
a40f1c2a
HR
2922 int64_t size)
2923{
ff99129a 2924 BDRVQcow2State *s = bs->opaque;
3e355390 2925 int chk = s->overlap_check & ~ign;
a40f1c2a
HR
2926 int i, j;
2927
2928 if (!size) {
2929 return 0;
2930 }
2931
2932 if (chk & QCOW2_OL_MAIN_HEADER) {
2933 if (offset < s->cluster_size) {
2934 return QCOW2_OL_MAIN_HEADER;
2935 }
2936 }
2937
2938 /* align range to test to cluster boundaries */
9e029689 2939 size = ROUND_UP(offset_into_cluster(s, offset) + size, s->cluster_size);
a40f1c2a
HR
2940 offset = start_of_cluster(s, offset);
2941
2942 if ((chk & QCOW2_OL_ACTIVE_L1) && s->l1_size) {
02b1ecfa 2943 if (overlaps_with(s->l1_table_offset, s->l1_size * L1E_SIZE)) {
a40f1c2a
HR
2944 return QCOW2_OL_ACTIVE_L1;
2945 }
2946 }
2947
2948 if ((chk & QCOW2_OL_REFCOUNT_TABLE) && s->refcount_table_size) {
2949 if (overlaps_with(s->refcount_table_offset,
02b1ecfa 2950 s->refcount_table_size * REFTABLE_ENTRY_SIZE)) {
a40f1c2a
HR
2951 return QCOW2_OL_REFCOUNT_TABLE;
2952 }
2953 }
2954
2955 if ((chk & QCOW2_OL_SNAPSHOT_TABLE) && s->snapshots_size) {
2956 if (overlaps_with(s->snapshots_offset, s->snapshots_size)) {
2957 return QCOW2_OL_SNAPSHOT_TABLE;
2958 }
2959 }
2960
2961 if ((chk & QCOW2_OL_INACTIVE_L1) && s->snapshots) {
2962 for (i = 0; i < s->nb_snapshots; i++) {
2963 if (s->snapshots[i].l1_size &&
2964 overlaps_with(s->snapshots[i].l1_table_offset,
02b1ecfa 2965 s->snapshots[i].l1_size * L1E_SIZE)) {
a40f1c2a
HR
2966 return QCOW2_OL_INACTIVE_L1;
2967 }
2968 }
2969 }
2970
2971 if ((chk & QCOW2_OL_ACTIVE_L2) && s->l1_table) {
2972 for (i = 0; i < s->l1_size; i++) {
2973 if ((s->l1_table[i] & L1E_OFFSET_MASK) &&
2974 overlaps_with(s->l1_table[i] & L1E_OFFSET_MASK,
2975 s->cluster_size)) {
2976 return QCOW2_OL_ACTIVE_L2;
2977 }
2978 }
2979 }
2980
2981 if ((chk & QCOW2_OL_REFCOUNT_BLOCK) && s->refcount_table) {
7061a078
AG
2982 unsigned last_entry = s->max_refcount_table_index;
2983 assert(last_entry < s->refcount_table_size);
2984 assert(last_entry + 1 == s->refcount_table_size ||
2985 (s->refcount_table[last_entry + 1] & REFT_OFFSET_MASK) == 0);
2986 for (i = 0; i <= last_entry; i++) {
a40f1c2a
HR
2987 if ((s->refcount_table[i] & REFT_OFFSET_MASK) &&
2988 overlaps_with(s->refcount_table[i] & REFT_OFFSET_MASK,
2989 s->cluster_size)) {
2990 return QCOW2_OL_REFCOUNT_BLOCK;
2991 }
2992 }
2993 }
2994
2995 if ((chk & QCOW2_OL_INACTIVE_L2) && s->snapshots) {
2996 for (i = 0; i < s->nb_snapshots; i++) {
2997 uint64_t l1_ofs = s->snapshots[i].l1_table_offset;
2998 uint32_t l1_sz = s->snapshots[i].l1_size;
02b1ecfa 2999 uint64_t l1_sz2 = l1_sz * L1E_SIZE;
c7a9d81d 3000 uint64_t *l1;
a40f1c2a
HR
3001 int ret;
3002
02b1ecfa 3003 ret = qcow2_validate_table(bs, l1_ofs, l1_sz, L1E_SIZE,
c7a9d81d
AG
3004 QCOW_MAX_L1_SIZE, "", NULL);
3005 if (ret < 0) {
3006 return ret;
3007 }
3008
3009 l1 = g_try_malloc(l1_sz2);
3010
de82815d
KW
3011 if (l1_sz2 && l1 == NULL) {
3012 return -ENOMEM;
3013 }
3014
32cc71de 3015 ret = bdrv_pread(bs->file, l1_ofs, l1_sz2, l1, 0);
a40f1c2a
HR
3016 if (ret < 0) {
3017 g_free(l1);
3018 return ret;
3019 }
3020
3021 for (j = 0; j < l1_sz; j++) {
1e242b55
HR
3022 uint64_t l2_ofs = be64_to_cpu(l1[j]) & L1E_OFFSET_MASK;
3023 if (l2_ofs && overlaps_with(l2_ofs, s->cluster_size)) {
a40f1c2a
HR
3024 g_free(l1);
3025 return QCOW2_OL_INACTIVE_L2;
3026 }
3027 }
3028
3029 g_free(l1);
3030 }
3031 }
3032
0e4e4318
VSO
3033 if ((chk & QCOW2_OL_BITMAP_DIRECTORY) &&
3034 (s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS))
3035 {
3036 if (overlaps_with(s->bitmap_directory_offset,
3037 s->bitmap_directory_size))
3038 {
3039 return QCOW2_OL_BITMAP_DIRECTORY;
3040 }
3041 }
3042
a40f1c2a
HR
3043 return 0;
3044}
3045
3046static const char *metadata_ol_names[] = {
7cb6d3c9
LM
3047 [QCOW2_OL_MAIN_HEADER_BITNR] = "qcow2_header",
3048 [QCOW2_OL_ACTIVE_L1_BITNR] = "active L1 table",
3049 [QCOW2_OL_ACTIVE_L2_BITNR] = "active L2 table",
3050 [QCOW2_OL_REFCOUNT_TABLE_BITNR] = "refcount table",
3051 [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = "refcount block",
3052 [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = "snapshot table",
3053 [QCOW2_OL_INACTIVE_L1_BITNR] = "inactive L1 table",
3054 [QCOW2_OL_INACTIVE_L2_BITNR] = "inactive L2 table",
3055 [QCOW2_OL_BITMAP_DIRECTORY_BITNR] = "bitmap directory",
a40f1c2a 3056};
7cb6d3c9 3057QEMU_BUILD_BUG_ON(QCOW2_OL_MAX_BITNR != ARRAY_SIZE(metadata_ol_names));
a40f1c2a
HR
3058
3059/*
3060 * First performs a check for metadata overlaps (through
3061 * qcow2_check_metadata_overlap); if that fails with a negative value (error
3062 * while performing a check), that value is returned. If an impending overlap
3063 * is detected, the BDS will be made unusable, the qcow2 file marked corrupt
3064 * and -EIO returned.
3065 *
3066 * Returns 0 if there were neither overlaps nor errors while checking for
3067 * overlaps; or a negative value (-errno) on error.
3068 */
231bb267 3069int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
966b000f 3070 int64_t size, bool data_file)
a40f1c2a 3071{
966b000f
KW
3072 int ret;
3073
3074 if (data_file && has_data_file(bs)) {
3075 return 0;
3076 }
a40f1c2a 3077
966b000f 3078 ret = qcow2_check_metadata_overlap(bs, ign, offset, size);
a40f1c2a
HR
3079 if (ret < 0) {
3080 return ret;
3081 } else if (ret > 0) {
786a4ea8 3082 int metadata_ol_bitnr = ctz32(ret);
a40f1c2a
HR
3083 assert(metadata_ol_bitnr < QCOW2_OL_MAX_BITNR);
3084
adb43552
HR
3085 qcow2_signal_corruption(bs, true, offset, size, "Preventing invalid "
3086 "write on metadata (overlaps with %s)",
3087 metadata_ol_names[metadata_ol_bitnr]);
a40f1c2a
HR
3088 return -EIO;
3089 }
3090
3091 return 0;
3092}
791c9a00
HR
3093
3094/* A pointer to a function of this type is given to walk_over_reftable(). That
3095 * function will create refblocks and pass them to a RefblockFinishOp once they
3096 * are completed (@refblock). @refblock_empty is set if the refblock is
3097 * completely empty.
3098 *
3099 * Along with the refblock, a corresponding reftable entry is passed, in the
3100 * reftable @reftable (which may be reallocated) at @reftable_index.
3101 *
3102 * @allocated should be set to true if a new cluster has been allocated.
3103 */
0bb79c97
KW
3104typedef int /* GRAPH_RDLOCK_PTR */
3105 (RefblockFinishOp)(BlockDriverState *bs, uint64_t **reftable,
3106 uint64_t reftable_index, uint64_t *reftable_size,
3107 void *refblock, bool refblock_empty,
3108 bool *allocated, Error **errp);
791c9a00
HR
3109
3110/**
3111 * This "operation" for walk_over_reftable() allocates the refblock on disk (if
3112 * it is not empty) and inserts its offset into the new reftable. The size of
3113 * this new reftable is increased as required.
3114 */
0bb79c97
KW
3115static int GRAPH_RDLOCK
3116alloc_refblock(BlockDriverState *bs, uint64_t **reftable,
3117 uint64_t reftable_index, uint64_t *reftable_size,
3118 void *refblock, bool refblock_empty, bool *allocated,
3119 Error **errp)
791c9a00
HR
3120{
3121 BDRVQcow2State *s = bs->opaque;
3122 int64_t offset;
3123
3124 if (!refblock_empty && reftable_index >= *reftable_size) {
3125 uint64_t *new_reftable;
3126 uint64_t new_reftable_size;
3127
3128 new_reftable_size = ROUND_UP(reftable_index + 1,
02b1ecfa
AG
3129 s->cluster_size / REFTABLE_ENTRY_SIZE);
3130 if (new_reftable_size > QCOW_MAX_REFTABLE_SIZE / REFTABLE_ENTRY_SIZE) {
791c9a00
HR
3131 error_setg(errp,
3132 "This operation would make the refcount table grow "
3133 "beyond the maximum size supported by QEMU, aborting");
3134 return -ENOTSUP;
3135 }
3136
3137 new_reftable = g_try_realloc(*reftable, new_reftable_size *
02b1ecfa 3138 REFTABLE_ENTRY_SIZE);
791c9a00
HR
3139 if (!new_reftable) {
3140 error_setg(errp, "Failed to increase reftable buffer size");
3141 return -ENOMEM;
3142 }
3143
3144 memset(new_reftable + *reftable_size, 0,
02b1ecfa 3145 (new_reftable_size - *reftable_size) * REFTABLE_ENTRY_SIZE);
791c9a00
HR
3146
3147 *reftable = new_reftable;
3148 *reftable_size = new_reftable_size;
3149 }
3150
3151 if (!refblock_empty && !(*reftable)[reftable_index]) {
3152 offset = qcow2_alloc_clusters(bs, s->cluster_size);
3153 if (offset < 0) {
3154 error_setg_errno(errp, -offset, "Failed to allocate refblock");
3155 return offset;
3156 }
3157 (*reftable)[reftable_index] = offset;
3158 *allocated = true;
3159 }
3160
3161 return 0;
3162}
3163
3164/**
3165 * This "operation" for walk_over_reftable() writes the refblock to disk at the
3166 * offset specified by the new reftable's entry. It does not modify the new
3167 * reftable or change any refcounts.
3168 */
0bb79c97
KW
3169static int GRAPH_RDLOCK
3170flush_refblock(BlockDriverState *bs, uint64_t **reftable,
3171 uint64_t reftable_index, uint64_t *reftable_size,
3172 void *refblock, bool refblock_empty, bool *allocated,
3173 Error **errp)
791c9a00
HR
3174{
3175 BDRVQcow2State *s = bs->opaque;
3176 int64_t offset;
3177 int ret;
3178
3179 if (reftable_index < *reftable_size && (*reftable)[reftable_index]) {
3180 offset = (*reftable)[reftable_index];
3181
966b000f
KW
3182 ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size,
3183 false);
791c9a00
HR
3184 if (ret < 0) {
3185 error_setg_errno(errp, -ret, "Overlap check failed");
3186 return ret;
3187 }
3188
32cc71de 3189 ret = bdrv_pwrite(bs->file, offset, s->cluster_size, refblock, 0);
791c9a00
HR
3190 if (ret < 0) {
3191 error_setg_errno(errp, -ret, "Failed to write refblock");
3192 return ret;
3193 }
3194 } else {
3195 assert(refblock_empty);
3196 }
3197
3198 return 0;
3199}
3200
3201/**
3202 * This function walks over the existing reftable and every referenced refblock;
3203 * if @new_set_refcount is non-NULL, it is called for every refcount entry to
3204 * create an equal new entry in the passed @new_refblock. Once that
3205 * @new_refblock is completely filled, @operation will be called.
3206 *
3207 * @status_cb and @cb_opaque are used for the amend operation's status callback.
3208 * @index is the index of the walk_over_reftable() calls and @total is the total
3209 * number of walk_over_reftable() calls per amend operation. Both are used for
3210 * calculating the parameters for the status callback.
3211 *
3212 * @allocated is set to true if a new cluster has been allocated.
3213 */
0bb79c97
KW
3214static int GRAPH_RDLOCK
3215walk_over_reftable(BlockDriverState *bs, uint64_t **new_reftable,
3216 uint64_t *new_reftable_index,
3217 uint64_t *new_reftable_size,
3218 void *new_refblock, int new_refblock_size,
3219 int new_refcount_bits,
3220 RefblockFinishOp *operation, bool *allocated,
3221 Qcow2SetRefcountFunc *new_set_refcount,
3222 BlockDriverAmendStatusCB *status_cb,
3223 void *cb_opaque, int index, int total,
3224 Error **errp)
791c9a00
HR
3225{
3226 BDRVQcow2State *s = bs->opaque;
3227 uint64_t reftable_index;
3228 bool new_refblock_empty = true;
3229 int refblock_index;
3230 int new_refblock_index = 0;
3231 int ret;
3232
3233 for (reftable_index = 0; reftable_index < s->refcount_table_size;
3234 reftable_index++)
3235 {
3236 uint64_t refblock_offset = s->refcount_table[reftable_index]
3237 & REFT_OFFSET_MASK;
3238
3239 status_cb(bs, (uint64_t)index * s->refcount_table_size + reftable_index,
3240 (uint64_t)total * s->refcount_table_size, cb_opaque);
3241
3242 if (refblock_offset) {
3243 void *refblock;
3244
3245 if (offset_into_cluster(s, refblock_offset)) {
3246 qcow2_signal_corruption(bs, true, -1, -1, "Refblock offset %#"
3247 PRIx64 " unaligned (reftable index: %#"
3248 PRIx64 ")", refblock_offset,
3249 reftable_index);
3250 error_setg(errp,
3251 "Image is corrupt (unaligned refblock offset)");
3252 return -EIO;
3253 }
3254
3255 ret = qcow2_cache_get(bs, s->refcount_block_cache, refblock_offset,
3256 &refblock);
3257 if (ret < 0) {
3258 error_setg_errno(errp, -ret, "Failed to retrieve refblock");
3259 return ret;
3260 }
3261
3262 for (refblock_index = 0; refblock_index < s->refcount_block_size;
3263 refblock_index++)
3264 {
3265 uint64_t refcount;
3266
3267 if (new_refblock_index >= new_refblock_size) {
3268 /* new_refblock is now complete */
3269 ret = operation(bs, new_reftable, *new_reftable_index,
3270 new_reftable_size, new_refblock,
3271 new_refblock_empty, allocated, errp);
3272 if (ret < 0) {
2013c3d4 3273 qcow2_cache_put(s->refcount_block_cache, &refblock);
791c9a00
HR
3274 return ret;
3275 }
3276
3277 (*new_reftable_index)++;
3278 new_refblock_index = 0;
3279 new_refblock_empty = true;
3280 }
3281
3282 refcount = s->get_refcount(refblock, refblock_index);
3283 if (new_refcount_bits < 64 && refcount >> new_refcount_bits) {
3284 uint64_t offset;
3285
2013c3d4 3286 qcow2_cache_put(s->refcount_block_cache, &refblock);
791c9a00
HR
3287
3288 offset = ((reftable_index << s->refcount_block_bits)
3289 + refblock_index) << s->cluster_bits;
3290
3291 error_setg(errp, "Cannot decrease refcount entry width to "
3292 "%i bits: Cluster at offset %#" PRIx64 " has a "
3293 "refcount of %" PRIu64, new_refcount_bits,
3294 offset, refcount);
3295 return -EINVAL;
3296 }
3297
3298 if (new_set_refcount) {
3299 new_set_refcount(new_refblock, new_refblock_index++,
3300 refcount);
3301 } else {
3302 new_refblock_index++;
3303 }
3304 new_refblock_empty = new_refblock_empty && refcount == 0;
3305 }
3306
2013c3d4 3307 qcow2_cache_put(s->refcount_block_cache, &refblock);
791c9a00
HR
3308 } else {
3309 /* No refblock means every refcount is 0 */
3310 for (refblock_index = 0; refblock_index < s->refcount_block_size;
3311 refblock_index++)
3312 {
3313 if (new_refblock_index >= new_refblock_size) {
3314 /* new_refblock is now complete */
3315 ret = operation(bs, new_reftable, *new_reftable_index,
3316 new_reftable_size, new_refblock,
3317 new_refblock_empty, allocated, errp);
3318 if (ret < 0) {
3319 return ret;
3320 }
3321
3322 (*new_reftable_index)++;
3323 new_refblock_index = 0;
3324 new_refblock_empty = true;
3325 }
3326
3327 if (new_set_refcount) {
3328 new_set_refcount(new_refblock, new_refblock_index++, 0);
3329 } else {
3330 new_refblock_index++;
3331 }
3332 }
3333 }
3334 }
3335
3336 if (new_refblock_index > 0) {
3337 /* Complete the potentially existing partially filled final refblock */
3338 if (new_set_refcount) {
3339 for (; new_refblock_index < new_refblock_size;
3340 new_refblock_index++)
3341 {
3342 new_set_refcount(new_refblock, new_refblock_index, 0);
3343 }
3344 }
3345
3346 ret = operation(bs, new_reftable, *new_reftable_index,
3347 new_reftable_size, new_refblock, new_refblock_empty,
3348 allocated, errp);
3349 if (ret < 0) {
3350 return ret;
3351 }
3352
3353 (*new_reftable_index)++;
3354 }
3355
3356 status_cb(bs, (uint64_t)(index + 1) * s->refcount_table_size,
3357 (uint64_t)total * s->refcount_table_size, cb_opaque);
3358
3359 return 0;
3360}
3361
3362int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
3363 BlockDriverAmendStatusCB *status_cb,
3364 void *cb_opaque, Error **errp)
3365{
3366 BDRVQcow2State *s = bs->opaque;
3367 Qcow2GetRefcountFunc *new_get_refcount;
3368 Qcow2SetRefcountFunc *new_set_refcount;
3369 void *new_refblock = qemu_blockalign(bs->file->bs, s->cluster_size);
3370 uint64_t *new_reftable = NULL, new_reftable_size = 0;
3371 uint64_t *old_reftable, old_reftable_size, old_reftable_offset;
3372 uint64_t new_reftable_index = 0;
3373 uint64_t i;
3374 int64_t new_reftable_offset = 0, allocated_reftable_size = 0;
3375 int new_refblock_size, new_refcount_bits = 1 << refcount_order;
3376 int old_refcount_order;
3377 int walk_index = 0;
3378 int ret;
3379 bool new_allocation;
3380
3381 assert(s->qcow_version >= 3);
3382 assert(refcount_order >= 0 && refcount_order <= 6);
3383
3384 /* see qcow2_open() */
3385 new_refblock_size = 1 << (s->cluster_bits - (refcount_order - 3));
3386
3387 new_get_refcount = get_refcount_funcs[refcount_order];
3388 new_set_refcount = set_refcount_funcs[refcount_order];
3389
3390
3391 do {
3392 int total_walks;
3393
3394 new_allocation = false;
3395
3396 /* At least we have to do this walk and the one which writes the
3397 * refblocks; also, at least we have to do this loop here at least
3398 * twice (normally), first to do the allocations, and second to
3399 * determine that everything is correctly allocated, this then makes
3400 * three walks in total */
3401 total_walks = MAX(walk_index + 2, 3);
3402
3403 /* First, allocate the structures so they are present in the refcount
3404 * structures */
3405 ret = walk_over_reftable(bs, &new_reftable, &new_reftable_index,
3406 &new_reftable_size, NULL, new_refblock_size,
3407 new_refcount_bits, &alloc_refblock,
3408 &new_allocation, NULL, status_cb, cb_opaque,
3409 walk_index++, total_walks, errp);
3410 if (ret < 0) {
3411 goto done;
3412 }
3413
3414 new_reftable_index = 0;
3415
3416 if (new_allocation) {
3417 if (new_reftable_offset) {
02b1ecfa
AG
3418 qcow2_free_clusters(
3419 bs, new_reftable_offset,
3420 allocated_reftable_size * REFTABLE_ENTRY_SIZE,
3421 QCOW2_DISCARD_NEVER);
791c9a00
HR
3422 }
3423
3424 new_reftable_offset = qcow2_alloc_clusters(bs, new_reftable_size *
02b1ecfa 3425 REFTABLE_ENTRY_SIZE);
791c9a00
HR
3426 if (new_reftable_offset < 0) {
3427 error_setg_errno(errp, -new_reftable_offset,
3428 "Failed to allocate the new reftable");
3429 ret = new_reftable_offset;
3430 goto done;
3431 }
3432 allocated_reftable_size = new_reftable_size;
3433 }
3434 } while (new_allocation);
3435
3436 /* Second, write the new refblocks */
3437 ret = walk_over_reftable(bs, &new_reftable, &new_reftable_index,
3438 &new_reftable_size, new_refblock,
3439 new_refblock_size, new_refcount_bits,
3440 &flush_refblock, &new_allocation, new_set_refcount,
3441 status_cb, cb_opaque, walk_index, walk_index + 1,
3442 errp);
3443 if (ret < 0) {
3444 goto done;
3445 }
3446 assert(!new_allocation);
3447
3448
3449 /* Write the new reftable */
3450 ret = qcow2_pre_write_overlap_check(bs, 0, new_reftable_offset,
02b1ecfa 3451 new_reftable_size * REFTABLE_ENTRY_SIZE,
966b000f 3452 false);
791c9a00
HR
3453 if (ret < 0) {
3454 error_setg_errno(errp, -ret, "Overlap check failed");
3455 goto done;
3456 }
3457
3458 for (i = 0; i < new_reftable_size; i++) {
3459 cpu_to_be64s(&new_reftable[i]);
3460 }
3461
32cc71de
AF
3462 ret = bdrv_pwrite(bs->file, new_reftable_offset,
3463 new_reftable_size * REFTABLE_ENTRY_SIZE, new_reftable,
3464 0);
791c9a00
HR
3465
3466 for (i = 0; i < new_reftable_size; i++) {
3467 be64_to_cpus(&new_reftable[i]);
3468 }
3469
3470 if (ret < 0) {
3471 error_setg_errno(errp, -ret, "Failed to write the new reftable");
3472 goto done;
3473 }
3474
3475
3476 /* Empty the refcount cache */
3477 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
3478 if (ret < 0) {
3479 error_setg_errno(errp, -ret, "Failed to flush the refblock cache");
3480 goto done;
3481 }
3482
3483 /* Update the image header to point to the new reftable; this only updates
3484 * the fields which are relevant to qcow2_update_header(); other fields
3485 * such as s->refcount_table or s->refcount_bits stay stale for now
3486 * (because we have to restore everything if qcow2_update_header() fails) */
3487 old_refcount_order = s->refcount_order;
3488 old_reftable_size = s->refcount_table_size;
3489 old_reftable_offset = s->refcount_table_offset;
3490
3491 s->refcount_order = refcount_order;
3492 s->refcount_table_size = new_reftable_size;
3493 s->refcount_table_offset = new_reftable_offset;
3494
3495 ret = qcow2_update_header(bs);
3496 if (ret < 0) {
3497 s->refcount_order = old_refcount_order;
3498 s->refcount_table_size = old_reftable_size;
3499 s->refcount_table_offset = old_reftable_offset;
3500 error_setg_errno(errp, -ret, "Failed to update the qcow2 header");
3501 goto done;
3502 }
3503
3504 /* Now update the rest of the in-memory information */
3505 old_reftable = s->refcount_table;
3506 s->refcount_table = new_reftable;
7061a078 3507 update_max_refcount_table_index(s);
791c9a00
HR
3508
3509 s->refcount_bits = 1 << refcount_order;
3510 s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
3511 s->refcount_max += s->refcount_max - 1;
3512
3513 s->refcount_block_bits = s->cluster_bits - (refcount_order - 3);
3514 s->refcount_block_size = 1 << s->refcount_block_bits;
3515
3516 s->get_refcount = new_get_refcount;
3517 s->set_refcount = new_set_refcount;
3518
3519 /* For cleaning up all old refblocks and the old reftable below the "done"
3520 * label */
3521 new_reftable = old_reftable;
3522 new_reftable_size = old_reftable_size;
3523 new_reftable_offset = old_reftable_offset;
3524
3525done:
3526 if (new_reftable) {
3527 /* On success, new_reftable actually points to the old reftable (and
3528 * new_reftable_size is the old reftable's size); but that is just
3529 * fine */
3530 for (i = 0; i < new_reftable_size; i++) {
3531 uint64_t offset = new_reftable[i] & REFT_OFFSET_MASK;
3532 if (offset) {
3533 qcow2_free_clusters(bs, offset, s->cluster_size,
3534 QCOW2_DISCARD_OTHER);
3535 }
3536 }
3537 g_free(new_reftable);
3538
3539 if (new_reftable_offset > 0) {
3540 qcow2_free_clusters(bs, new_reftable_offset,
02b1ecfa 3541 new_reftable_size * REFTABLE_ENTRY_SIZE,
791c9a00
HR
3542 QCOW2_DISCARD_OTHER);
3543 }
3544 }
3545
3546 qemu_vfree(new_refblock);
3547 return ret;
3548}
46b732cd 3549
0bb79c97
KW
3550static int64_t coroutine_fn GRAPH_RDLOCK
3551get_refblock_offset(BlockDriverState *bs, uint64_t offset)
23482f8a
HR
3552{
3553 BDRVQcow2State *s = bs->opaque;
3554 uint32_t index = offset_to_reftable_index(s, offset);
3555 int64_t covering_refblock_offset = 0;
3556
3557 if (index < s->refcount_table_size) {
3558 covering_refblock_offset = s->refcount_table[index] & REFT_OFFSET_MASK;
3559 }
3560 if (!covering_refblock_offset) {
3561 qcow2_signal_corruption(bs, true, -1, -1, "Refblock at %#" PRIx64 " is "
3562 "not covered by the refcount structures",
3563 offset);
3564 return -EIO;
3565 }
3566
3567 return covering_refblock_offset;
3568}
3569
0bb79c97 3570static int coroutine_fn GRAPH_RDLOCK
a1b4ecfd 3571qcow2_discard_refcount_block(BlockDriverState *bs, uint64_t discard_block_offs)
46b732cd
PB
3572{
3573 BDRVQcow2State *s = bs->opaque;
23482f8a 3574 int64_t refblock_offs;
46b732cd
PB
3575 uint64_t cluster_index = discard_block_offs >> s->cluster_bits;
3576 uint32_t block_index = cluster_index & (s->refcount_block_size - 1);
3577 void *refblock;
3578 int ret;
3579
23482f8a
HR
3580 refblock_offs = get_refblock_offset(bs, discard_block_offs);
3581 if (refblock_offs < 0) {
3582 return refblock_offs;
3583 }
3584
46b732cd
PB
3585 assert(discard_block_offs != 0);
3586
3587 ret = qcow2_cache_get(bs, s->refcount_block_cache, refblock_offs,
3588 &refblock);
3589 if (ret < 0) {
3590 return ret;
3591 }
3592
3593 if (s->get_refcount(refblock, block_index) != 1) {
3594 qcow2_signal_corruption(bs, true, -1, -1, "Invalid refcount:"
3595 " refblock offset %#" PRIx64
3596 ", reftable index %u"
3597 ", block offset %#" PRIx64
3598 ", refcount %#" PRIx64,
3599 refblock_offs,
3600 offset_to_reftable_index(s, discard_block_offs),
3601 discard_block_offs,
3602 s->get_refcount(refblock, block_index));
2013c3d4 3603 qcow2_cache_put(s->refcount_block_cache, &refblock);
46b732cd
PB
3604 return -EINVAL;
3605 }
3606 s->set_refcount(refblock, block_index, 0);
3607
2d135ee9 3608 qcow2_cache_entry_mark_dirty(s->refcount_block_cache, refblock);
46b732cd 3609
2013c3d4 3610 qcow2_cache_put(s->refcount_block_cache, &refblock);
46b732cd
PB
3611
3612 if (cluster_index < s->free_cluster_index) {
3613 s->free_cluster_index = cluster_index;
3614 }
3615
6e6fa760 3616 refblock = qcow2_cache_is_table_offset(s->refcount_block_cache,
46b732cd
PB
3617 discard_block_offs);
3618 if (refblock) {
3619 /* discard refblock from the cache if refblock is cached */
77aadd7b 3620 qcow2_cache_discard(s->refcount_block_cache, refblock);
46b732cd
PB
3621 }
3622 update_refcount_discard(bs, discard_block_offs, s->cluster_size);
3623
3624 return 0;
3625}
3626
a1b4ecfd 3627int coroutine_fn qcow2_shrink_reftable(BlockDriverState *bs)
46b732cd
PB
3628{
3629 BDRVQcow2State *s = bs->opaque;
3630 uint64_t *reftable_tmp =
02b1ecfa 3631 g_malloc(s->refcount_table_size * REFTABLE_ENTRY_SIZE);
46b732cd
PB
3632 int i, ret;
3633
3634 for (i = 0; i < s->refcount_table_size; i++) {
3635 int64_t refblock_offs = s->refcount_table[i] & REFT_OFFSET_MASK;
3636 void *refblock;
3637 bool unused_block;
3638
3639 if (refblock_offs == 0) {
3640 reftable_tmp[i] = 0;
3641 continue;
3642 }
3643 ret = qcow2_cache_get(bs, s->refcount_block_cache, refblock_offs,
3644 &refblock);
3645 if (ret < 0) {
3646 goto out;
3647 }
3648
3649 /* the refblock has own reference */
3650 if (i == offset_to_reftable_index(s, refblock_offs)) {
3651 uint64_t block_index = (refblock_offs >> s->cluster_bits) &
3652 (s->refcount_block_size - 1);
3653 uint64_t refcount = s->get_refcount(refblock, block_index);
3654
3655 s->set_refcount(refblock, block_index, 0);
3656
3657 unused_block = buffer_is_zero(refblock, s->cluster_size);
3658
3659 s->set_refcount(refblock, block_index, refcount);
3660 } else {
3661 unused_block = buffer_is_zero(refblock, s->cluster_size);
3662 }
2013c3d4 3663 qcow2_cache_put(s->refcount_block_cache, &refblock);
46b732cd
PB
3664
3665 reftable_tmp[i] = unused_block ? 0 : cpu_to_be64(s->refcount_table[i]);
3666 }
3667
38505e2a
AF
3668 ret = bdrv_co_pwrite_sync(bs->file, s->refcount_table_offset,
3669 s->refcount_table_size * REFTABLE_ENTRY_SIZE,
3670 reftable_tmp, 0);
46b732cd
PB
3671 /*
3672 * If the write in the reftable failed the image may contain a partially
3673 * overwritten reftable. In this case it would be better to clear the
3674 * reftable in memory to avoid possible image corruption.
3675 */
3676 for (i = 0; i < s->refcount_table_size; i++) {
3677 if (s->refcount_table[i] && !reftable_tmp[i]) {
3678 if (ret == 0) {
3679 ret = qcow2_discard_refcount_block(bs, s->refcount_table[i] &
3680 REFT_OFFSET_MASK);
3681 }
3682 s->refcount_table[i] = 0;
3683 }
3684 }
3685
3686 if (!s->cache_discards) {
3687 qcow2_process_discards(bs, ret);
3688 }
3689
3690out:
3691 g_free(reftable_tmp);
3692 return ret;
3693}
163bc39d 3694
a39bae4e 3695int64_t coroutine_fn qcow2_get_last_cluster(BlockDriverState *bs, int64_t size)
163bc39d
PB
3696{
3697 BDRVQcow2State *s = bs->opaque;
3698 int64_t i;
3699
3700 for (i = size_to_clusters(s, size) - 1; i >= 0; i--) {
3701 uint64_t refcount;
3702 int ret = qcow2_get_refcount(bs, i, &refcount);
3703 if (ret < 0) {
3704 fprintf(stderr, "Can't get refcount for cluster %" PRId64 ": %s\n",
3705 i, strerror(-ret));
3706 return ret;
3707 }
3708 if (refcount > 0) {
3709 return i;
3710 }
3711 }
3712 qcow2_signal_corruption(bs, true, -1, -1,
3713 "There are no references in the refcount table.");
3714 return -EIO;
3715}
69f47505 3716
70bacc44
PB
3717int coroutine_fn GRAPH_RDLOCK
3718qcow2_detect_metadata_preallocation(BlockDriverState *bs)
69f47505
VSO
3719{
3720 BDRVQcow2State *s = bs->opaque;
3721 int64_t i, end_cluster, cluster_count = 0, threshold;
3722 int64_t file_length, real_allocation, real_clusters;
3723
5e978550
KW
3724 qemu_co_mutex_assert_locked(&s->lock);
3725
0050c163 3726 file_length = bdrv_co_getlength(bs->file->bs);
69f47505
VSO
3727 if (file_length < 0) {
3728 return file_length;
3729 }
3730
82618d7b 3731 real_allocation = bdrv_co_get_allocated_file_size(bs->file->bs);
69f47505
VSO
3732 if (real_allocation < 0) {
3733 return real_allocation;
3734 }
3735
3736 real_clusters = real_allocation / s->cluster_size;
3737 threshold = MAX(real_clusters * 10 / 9, real_clusters + 2);
3738
3739 end_cluster = size_to_clusters(s, file_length);
3740 for (i = 0; i < end_cluster && cluster_count < threshold; i++) {
3741 uint64_t refcount;
3742 int ret = qcow2_get_refcount(bs, i, &refcount);
3743 if (ret < 0) {
3744 return ret;
3745 }
3746 cluster_count += !!refcount;
3747 }
3748
3749 return cluster_count >= threshold;
3750}