blob: 0266542ceea26e0829c9757f5d7a1ac067a714ae [file] [log] [blame]
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001/*
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
Peter Maydell80c71a22016-01-18 18:01:42 +000025#include "qemu/osdep.h"
Markus Armbrustere2c1c342022-12-21 14:35:49 +010026#include "block/block-io.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010027#include "qapi/error.h"
Michael S. Tsirkin0d8c41d2018-05-03 22:50:20 +030028#include "qcow2.h"
Max Reitza40f1c22013-08-30 14:34:25 +020029#include "qemu/range.h"
Paolo Bonzini58369e22016-03-15 17:22:36 +010030#include "qemu/bswap.h"
Pavel Butsykin46b732c2017-09-18 15:42:29 +030031#include "qemu/cutils.h"
Peter Maydell5df022c2022-02-26 18:07:23 +000032#include "qemu/memalign.h"
Vladimir Sementsov-Ogievskiy1477b6c2019-04-23 15:57:04 +030033#include "trace.h"
Kevin Wolff7d0fe02009-05-28 16:07:04 +020034
Eric Blake77d6a212018-11-13 17:03:18 -060035static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size,
36 uint64_t max);
Marc-André Lureauc0840172022-02-24 00:58:22 +040037
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);
Kevin Wolff7d0fe02009-05-28 16:07:04 +020042
Max Reitz59c0cb72015-02-10 15:28:51 -050043static 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);
Max Reitz7453c962015-02-10 15:28:50 -050047static uint64_t get_refcount_ro4(const void *refcount_array, uint64_t index);
Max Reitz59c0cb72015-02-10 15:28:51 -050048static 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);
Max Reitz7453c962015-02-10 15:28:50 -050050
Max Reitz59c0cb72015-02-10 15:28:51 -050051static 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);
Max Reitz7453c962015-02-10 15:28:50 -050059static void set_refcount_ro4(void *refcount_array, uint64_t index,
60 uint64_t value);
Max Reitz59c0cb72015-02-10 15:28:51 -050061static 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};
Max Reitz7453c962015-02-10 15:28:50 -050086
Kevin Wolf3b88e522009-06-26 20:19:38 +020087
Kevin Wolff7d0fe02009-05-28 16:07:04 +020088/*********************************************************/
89/* refcount handling */
90
Alberto Garcia7061a072017-02-01 14:38:28 +020091static 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
Paolo Bonzinia1b4ecf2022-10-13 14:36:59 +0200101int coroutine_fn qcow2_refcount_init(BlockDriverState *bs)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200102{
Kevin Wolfff991292015-09-07 17:12:56 +0200103 BDRVQcow2State *s = bs->opaque;
Kevin Wolf5dab2fa2014-03-26 13:05:43 +0100104 unsigned int refcount_table_size2, i;
105 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200106
Max Reitz59c0cb72015-02-10 15:28:51 -0500107 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];
Max Reitz7453c962015-02-10 15:28:50 -0500111
Alberto Garcia02b1ecf2020-08-28 13:08:28 +0200112 assert(s->refcount_table_size <= INT_MAX / REFTABLE_ENTRY_SIZE);
113 refcount_table_size2 = s->refcount_table_size * REFTABLE_ENTRY_SIZE;
Kevin Wolfde828152014-05-20 17:12:47 +0200114 s->refcount_table = g_try_malloc(refcount_table_size2);
115
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200116 if (s->refcount_table_size > 0) {
Kevin Wolfde828152014-05-20 17:12:47 +0200117 if (s->refcount_table == NULL) {
Max Reitz8fcffa92014-05-29 00:19:54 +0200118 ret = -ENOMEM;
Kevin Wolfde828152014-05-20 17:12:47 +0200119 goto fail;
120 }
Paolo Bonzini17362392023-06-01 13:51:45 +0200121 BLKDBG_CO_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
Alberto Faria38505e22022-10-13 14:37:06 +0200122 ret = bdrv_co_pread(bs->file, s->refcount_table_offset,
123 refcount_table_size2, s->refcount_table, 0);
Max Reitz8fcffa92014-05-29 00:19:54 +0200124 if (ret < 0) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200125 goto fail;
Max Reitz8fcffa92014-05-29 00:19:54 +0200126 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200127 for(i = 0; i < s->refcount_table_size; i++)
128 be64_to_cpus(&s->refcount_table[i]);
Alberto Garcia7061a072017-02-01 14:38:28 +0200129 update_max_refcount_table_index(s);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200130 }
131 return 0;
132 fail:
Max Reitz8fcffa92014-05-29 00:19:54 +0200133 return ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200134}
135
Kevin Wolfed6ccf02009-05-28 16:07:07 +0200136void qcow2_refcount_close(BlockDriverState *bs)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200137{
Kevin Wolfff991292015-09-07 17:12:56 +0200138 BDRVQcow2State *s = bs->opaque;
Anthony Liguori7267c092011-08-20 22:09:37 -0500139 g_free(s->refcount_table);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200140}
141
142
Max Reitz59c0cb72015-02-10 15:28:51 -0500143static 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
Max Reitz7453c962015-02-10 15:28:50 -0500196static 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
Max Reitz59c0cb72015-02-10 15:28:51 -0500208static 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
Max Reitz7453c962015-02-10 15:28:50 -0500231
Kevin Wolf0bb79c92023-09-29 16:51:49 +0200232static int GRAPH_RDLOCK
233load_refcount_block(BlockDriverState *bs, int64_t refcount_block_offset,
234 void **refcount_block)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200235{
Kevin Wolfff991292015-09-07 17:12:56 +0200236 BDRVQcow2State *s = bs->opaque;
Kevin Wolf3b88e522009-06-26 20:19:38 +0200237
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200238 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_LOAD);
Eduardo Habkost9be38592016-06-13 18:57:58 -0300239 return qcow2_cache_get(bs, s->refcount_block_cache, refcount_block_offset,
240 refcount_block);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200241}
242
Kevin Wolf018faaf2010-06-04 11:16:11 +0200243/*
Max Reitz7324c102015-02-10 15:28:46 -0500244 * Retrieves the refcount of the cluster given by its index and stores it in
245 * *refcount. Returns 0 on success and -errno on failure.
Kevin Wolf018faaf2010-06-04 11:16:11 +0200246 */
Max Reitz7324c102015-02-10 15:28:46 -0500247int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index,
Max Reitz0e065282015-02-10 15:28:48 -0500248 uint64_t *refcount)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200249{
Kevin Wolfff991292015-09-07 17:12:56 +0200250 BDRVQcow2State *s = bs->opaque;
Kevin Wolfdb8a31d2014-03-26 13:05:49 +0100251 uint64_t refcount_table_index, block_index;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200252 int64_t refcount_block_offset;
Kevin Wolf018faaf2010-06-04 11:16:11 +0200253 int ret;
Max Reitz7453c962015-02-10 15:28:50 -0500254 void *refcount_block;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200255
Max Reitz17bd5f42014-09-03 00:25:07 +0200256 refcount_table_index = cluster_index >> s->refcount_block_bits;
Max Reitz7324c102015-02-10 15:28:46 -0500257 if (refcount_table_index >= s->refcount_table_size) {
258 *refcount = 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200259 return 0;
Max Reitz7324c102015-02-10 15:28:46 -0500260 }
Max Reitz26d49c42014-03-07 23:10:12 +0100261 refcount_block_offset =
262 s->refcount_table[refcount_table_index] & REFT_OFFSET_MASK;
Max Reitz7324c102015-02-10 15:28:46 -0500263 if (!refcount_block_offset) {
264 *refcount = 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200265 return 0;
Max Reitz7324c102015-02-10 15:28:46 -0500266 }
Kevin Wolf29c1a732011-01-10 17:17:28 +0100267
Max Reitza97c67e2014-09-05 16:07:18 +0200268 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
Kevin Wolf29c1a732011-01-10 17:17:28 +0100275 ret = qcow2_cache_get(bs, s->refcount_block_cache, refcount_block_offset,
Max Reitz7453c962015-02-10 15:28:50 -0500276 &refcount_block);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100277 if (ret < 0) {
278 return ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200279 }
Kevin Wolf29c1a732011-01-10 17:17:28 +0100280
Max Reitz17bd5f42014-09-03 00:25:07 +0200281 block_index = cluster_index & (s->refcount_block_size - 1);
Max Reitz7453c962015-02-10 15:28:50 -0500282 *refcount = s->get_refcount(refcount_block, block_index);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100283
Alberto Garcia2013c3d2018-02-05 16:33:07 +0200284 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100285
Max Reitz7324c102015-02-10 15:28:46 -0500286 return 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200287}
288
Kevin Wolf92dcb592010-02-23 16:40:53 +0100289/* Checks if two offsets are described by the same refcount block */
Kevin Wolfff991292015-09-07 17:12:56 +0200290static int in_same_refcount_block(BDRVQcow2State *s, uint64_t offset_a,
Kevin Wolf92dcb592010-02-23 16:40:53 +0100291 uint64_t offset_b)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200292{
Max Reitz17bd5f42014-09-03 00:25:07 +0200293 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);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200295
Kevin Wolf92dcb592010-02-23 16:40:53 +0100296 return (block_a == block_b);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200297}
298
Kevin Wolf92dcb592010-02-23 16:40:53 +0100299/*
300 * Loads a refcount block. If it doesn't exist yet, it is allocated first
301 * (including growing the refcount table if needed).
302 *
Kevin Wolf29c1a732011-01-10 17:17:28 +0100303 * Returns 0 on success or -errno in error case
Kevin Wolf92dcb592010-02-23 16:40:53 +0100304 */
Kevin Wolf0bb79c92023-09-29 16:51:49 +0200305static int GRAPH_RDLOCK
306alloc_refcount_block(BlockDriverState *bs, int64_t cluster_index,
307 void **refcount_block)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200308{
Kevin Wolfff991292015-09-07 17:12:56 +0200309 BDRVQcow2State *s = bs->opaque;
Kevin Wolf80ee15a2009-09-15 12:30:43 +0200310 unsigned int refcount_table_index;
Max Reitz12cc30a2017-06-13 22:21:03 +0200311 int64_t ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200312
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200313 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
Kevin Wolf82522782010-03-15 17:38:05 +0100314
Kevin Wolf92dcb592010-02-23 16:40:53 +0100315 /* Find the refcount block for the given cluster */
Max Reitz17bd5f42014-09-03 00:25:07 +0200316 refcount_table_index = cluster_index >> s->refcount_block_bits;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100317
318 if (refcount_table_index < s->refcount_table_size) {
319
320 uint64_t refcount_block_offset =
Kevin Wolf76dc9e02012-03-16 14:09:08 +0100321 s->refcount_table[refcount_table_index] & REFT_OFFSET_MASK;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100322
323 /* If it's already there, we're done */
324 if (refcount_block_offset) {
Max Reitza97c67e2014-09-05 16:07:18 +0200325 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
Kevin Wolf29c1a732011-01-10 17:17:28 +0100333 return load_refcount_block(bs, refcount_block_offset,
Max Reitz7453c962015-02-10 15:28:50 -0500334 refcount_block);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100335 }
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
Kevin Wolfb106ad92014-03-28 18:06:31 +0100351 * 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.
Kevin Wolf92dcb592010-02-23 16:40:53 +0100356 *
357 * - alloc_clusters_noref and qcow2_free_clusters may load a different
358 * refcount block into the cache
359 */
360
Kevin Wolf29c1a732011-01-10 17:17:28 +0100361 *refcount_block = NULL;
362
363 /* We write to the refcount table, so we might depend on L2 tables */
Stefan Hajnoczi99919232013-03-04 15:02:30 +0100364 ret = qcow2_cache_flush(bs, s->l2_table_cache);
365 if (ret < 0) {
366 return ret;
367 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200368
Kevin Wolf92dcb592010-02-23 16:40:53 +0100369 /* Allocate the refcount block itself and mark it as used */
Eric Blake77d6a212018-11-13 17:03:18 -0600370 int64_t new_block = alloc_clusters_noref(bs, s->cluster_size, INT64_MAX);
Kevin Wolf2eaa8f62010-06-04 11:22:39 +0200371 if (new_block < 0) {
372 return new_block;
373 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200374
Alberto Garciacdc674c2018-11-14 16:58:57 +0200375 /* The offset must fit in the offset field of the refcount table entry */
376 assert((new_block & REFT_OFFSET_MASK) == new_block);
377
Alberto Garcia6bf45d52017-11-03 16:18:50 +0200378 /* 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
Kevin Wolf92dcb592010-02-23 16:40:53 +0100385#ifdef DEBUG_ALLOC2
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);
389#endif
390
391 if (in_same_refcount_block(s, new_block, cluster_index << s->cluster_bits)) {
Kevin Wolf25408c02010-05-28 12:05:45 +0200392 /* Zero the new refcount block before updating it */
Kevin Wolf29c1a732011-01-10 17:17:28 +0100393 ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
Max Reitz7453c962015-02-10 15:28:50 -0500394 refcount_block);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100395 if (ret < 0) {
Max Reitz60c48a22017-06-13 22:21:04 +0200396 goto fail;
Kevin Wolf29c1a732011-01-10 17:17:28 +0100397 }
398
399 memset(*refcount_block, 0, s->cluster_size);
Kevin Wolf25408c02010-05-28 12:05:45 +0200400
Kevin Wolf92dcb592010-02-23 16:40:53 +0100401 /* The block describes itself, need to update the cache */
402 int block_index = (new_block >> s->cluster_bits) &
Max Reitz17bd5f42014-09-03 00:25:07 +0200403 (s->refcount_block_size - 1);
Max Reitz7453c962015-02-10 15:28:50 -0500404 s->set_refcount(*refcount_block, block_index, 1);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200405 } else {
Kevin Wolf92dcb592010-02-23 16:40:53 +0100406 /* Described somewhere else. This can recurse at most twice before we
407 * arrive at a block that describes itself. */
Max Reitz2aabe7c2015-02-10 15:28:47 -0500408 ret = update_refcount(bs, new_block, s->cluster_size, 1, false,
Kevin Wolf6cfcb9b2013-06-19 13:44:18 +0200409 QCOW2_DISCARD_NEVER);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100410 if (ret < 0) {
Max Reitz60c48a22017-06-13 22:21:04 +0200411 goto fail;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200412 }
Kevin Wolf25408c02010-05-28 12:05:45 +0200413
Stefan Hajnoczi99919232013-03-04 15:02:30 +0100414 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
415 if (ret < 0) {
Max Reitz60c48a22017-06-13 22:21:04 +0200416 goto fail;
Stefan Hajnoczi99919232013-03-04 15:02:30 +0100417 }
Kevin Wolf1c4c2812010-09-17 16:36:58 +0200418
Kevin Wolf25408c02010-05-28 12:05:45 +0200419 /* Initialize the new refcount block only after updating its refcount,
420 * update_refcount uses the refcount cache itself */
Kevin Wolf29c1a732011-01-10 17:17:28 +0100421 ret = qcow2_cache_get_empty(bs, s->refcount_block_cache, new_block,
Max Reitz7453c962015-02-10 15:28:50 -0500422 refcount_block);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100423 if (ret < 0) {
Max Reitz60c48a22017-06-13 22:21:04 +0200424 goto fail;
Kevin Wolf29c1a732011-01-10 17:17:28 +0100425 }
426
427 memset(*refcount_block, 0, s->cluster_size);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200428 }
429
Kevin Wolf92dcb592010-02-23 16:40:53 +0100430 /* Now the new refcount block needs to be written to disk */
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200431 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE);
Alberto Garcia2d135ee2018-02-05 16:33:06 +0200432 qcow2_cache_entry_mark_dirty(s->refcount_block_cache, *refcount_block);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100433 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100434 if (ret < 0) {
Max Reitz60c48a22017-06-13 22:21:04 +0200435 goto fail;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100436 }
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);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200441 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);
Alberto Garcia02b1ecf2020-08-28 13:08:28 +0200442 ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset +
443 refcount_table_index * REFTABLE_ENTRY_SIZE,
Alberto Faria32cc71d2022-06-09 16:27:36 +0100444 sizeof(data64), &data64, 0);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100445 if (ret < 0) {
Max Reitz60c48a22017-06-13 22:21:04 +0200446 goto fail;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100447 }
448
449 s->refcount_table[refcount_table_index] = new_block;
Alberto Garcia7061a072017-02-01 14:38:28 +0200450 /* 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);
Kevin Wolfb106ad92014-03-28 18:06:31 +0100454
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;
Kevin Wolf29c1a732011-01-10 17:17:28 +0100458 }
459
Alberto Garcia2013c3d2018-02-05 16:33:07 +0200460 qcow2_cache_put(s->refcount_block_cache, refcount_block);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100461
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 */
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200473 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_GROW);
Kevin Wolf82522782010-03-15 17:38:05 +0100474
Max Reitz14a58a42015-02-10 15:02:31 -0500475 /* 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);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100489
Kevin Wolf92dcb592010-02-23 16:40:53 +0100490 /* Create the new refcount table and blocks */
Max Reitz17bd5f42014-09-03 00:25:07 +0200491 uint64_t meta_offset = (blocks_used * s->refcount_block_size) *
Kevin Wolf92dcb592010-02-23 16:40:53 +0100492 s->cluster_size;
Kevin Wolfde828152014-05-20 17:12:47 +0200493
Max Reitz12cc30a2017-06-13 22:21:03 +0200494 ret = qcow2_refcount_area(bs, meta_offset, 0, false,
495 refcount_table_index, new_block);
496 if (ret < 0) {
497 return ret;
498 }
499
500 ret = load_refcount_block(bs, new_block, refcount_block);
501 if (ret < 0) {
502 return ret;
503 }
504
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;
509
Max Reitz60c48a22017-06-13 22:21:04 +0200510fail:
Max Reitz12cc30a2017-06-13 22:21:03 +0200511 if (*refcount_block != NULL) {
Alberto Garcia2013c3d2018-02-05 16:33:07 +0200512 qcow2_cache_put(s->refcount_block_cache, refcount_block);
Max Reitz12cc30a2017-06-13 22:21:03 +0200513 }
514 return ret;
515}
516
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 */
Max Reitz772d1f92017-06-13 22:21:05 +0200532int64_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)
Max Reitz12cc30a2017-06-13 22:21:03 +0200536{
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;
544
545 assert(!(start_offset % s->cluster_size));
546
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 */
Alberto Garcia02b1ecf2020-08-28 13:08:28 +0200570 table_size = ROUND_UP(table_size, s->cluster_size / REFTABLE_ENTRY_SIZE);
571 table_clusters = (table_size * REFTABLE_ENTRY_SIZE) / s->cluster_size;
Max Reitz12cc30a2017-06-13 22:21:03 +0200572
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) {
Kevin Wolfde828152014-05-20 17:12:47 +0200581 ret = -ENOMEM;
Max Reitz12cc30a2017-06-13 22:21:03 +0200582 goto fail;
Kevin Wolfde828152014-05-20 17:12:47 +0200583 }
Kevin Wolf92dcb592010-02-23 16:40:53 +0100584
Kevin Wolf92dcb592010-02-23 16:40:53 +0100585 /* Fill the new refcount table */
Max Reitz12cc30a2017-06-13 22:21:03 +0200586 if (table_size > s->max_refcount_table_index) {
587 /* We're actually growing the reftable */
588 memcpy(new_table, s->refcount_table,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +0200589 (s->max_refcount_table_index + 1) * REFTABLE_ENTRY_SIZE);
Max Reitz12cc30a2017-06-13 22:21:03 +0200590 } 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. */
Alberto Garcia02b1ecf2020-08-28 13:08:28 +0200595 memcpy(new_table, s->refcount_table, table_size * REFTABLE_ENTRY_SIZE);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100596 }
597
Max Reitz12cc30a2017-06-13 22:21:03 +0200598 if (new_refblock_offset) {
599 assert(new_refblock_index < total_refblock_count);
600 new_table[new_refblock_index] = new_refblock_offset;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100601 }
602
Max Reitz12cc30a2017-06-13 22:21:03 +0200603 /* 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 }
609 }
610
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);
Alberto Garcia2d135ee2018-02-05 16:33:06 +0200634 qcow2_cache_entry_mark_dirty(s->refcount_block_cache,
Max Reitz12cc30a2017-06-13 22:21:03 +0200635 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
Alberto Garcia2d135ee2018-02-05 16:33:06 +0200667 qcow2_cache_entry_mark_dirty(s->refcount_block_cache,
Max Reitz12cc30a2017-06-13 22:21:03 +0200668 refblock_data);
669 }
670
Alberto Garcia2013c3d2018-02-05 16:33:07 +0200671 qcow2_cache_put(s->refcount_block_cache, &refblock_data);
Max Reitz12cc30a2017-06-13 22:21:03 +0200672 }
673
674 assert(block_offset == table_offset);
675
Kevin Wolf92dcb592010-02-23 16:40:53 +0100676 /* Write refcount blocks to disk */
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200677 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);
Max Reitz12cc30a2017-06-13 22:21:03 +0200678 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100679 if (ret < 0) {
Max Reitz12cc30a2017-06-13 22:21:03 +0200680 goto fail;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100681 }
682
683 /* Write refcount table to disk */
Max Reitz12cc30a2017-06-13 22:21:03 +0200684 for (i = 0; i < total_refblock_count; i++) {
Kevin Wolf92dcb592010-02-23 16:40:53 +0100685 cpu_to_be64s(&new_table[i]);
686 }
687
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200688 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);
Alberto Faria32cc71d2022-06-09 16:27:36 +0100689 ret = bdrv_pwrite_sync(bs->file, table_offset,
690 table_size * REFTABLE_ENTRY_SIZE, new_table, 0);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100691 if (ret < 0) {
Max Reitz12cc30a2017-06-13 22:21:03 +0200692 goto fail;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100693 }
694
Max Reitz12cc30a2017-06-13 22:21:03 +0200695 for (i = 0; i < total_refblock_count; i++) {
Zhi Yong Wu87267752012-04-28 15:38:08 +0800696 be64_to_cpus(&new_table[i]);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100697 }
698
699 /* Hook up the new refcount table in the qcow2 header */
John Snow95334232015-11-02 18:32:06 -0500700 struct QEMU_PACKED {
701 uint64_t d64;
702 uint32_t d32;
703 } data;
Peter Maydellf1f7a1d2016-06-16 17:06:17 +0100704 data.d64 = cpu_to_be64(table_offset);
705 data.d32 = cpu_to_be32(table_clusters);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200706 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
Kevin Wolfd9ca2ea2016-06-20 20:09:15 +0200707 ret = bdrv_pwrite_sync(bs->file,
Alberto Faria32cc71d2022-06-09 16:27:36 +0100708 offsetof(QCowHeader, refcount_table_offset),
709 sizeof(data), &data, 0);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100710 if (ret < 0) {
Max Reitz12cc30a2017-06-13 22:21:03 +0200711 goto fail;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100712 }
713
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
Anthony Liguori7267c092011-08-20 22:09:37 -0500718 g_free(s->refcount_table);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100719 s->refcount_table = new_table;
720 s->refcount_table_size = table_size;
721 s->refcount_table_offset = table_offset;
Alberto Garcia7061a072017-02-01 14:38:28 +0200722 update_max_refcount_table_index(s);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100723
Kevin Wolfb106ad92014-03-28 18:06:31 +0100724 /* Free old table. */
Alberto Garcia02b1ecf2020-08-28 13:08:28 +0200725 qcow2_free_clusters(bs, old_table_offset,
726 old_table_size * REFTABLE_ENTRY_SIZE,
Kevin Wolf6cfcb9b2013-06-19 13:44:18 +0200727 QCOW2_DISCARD_OTHER);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100728
Max Reitz12cc30a2017-06-13 22:21:03 +0200729 return end_offset;
Kevin Wolf92dcb592010-02-23 16:40:53 +0100730
Max Reitz12cc30a2017-06-13 22:21:03 +0200731fail:
Anthony Liguori7267c092011-08-20 22:09:37 -0500732 g_free(new_table);
Kevin Wolf92dcb592010-02-23 16:40:53 +0100733 return ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200734}
735
Kevin Wolf0b919fa2013-06-19 13:44:20 +0200736void qcow2_process_discards(BlockDriverState *bs, int ret)
737{
Kevin Wolfff991292015-09-07 17:12:56 +0200738 BDRVQcow2State *s = bs->opaque;
Kevin Wolf0b919fa2013-06-19 13:44:20 +0200739 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) {
Vladimir Sementsov-Ogievskiy1477b6c2019-04-23 15:57:04 +0300746 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 }
Kevin Wolf0b919fa2013-06-19 13:44:20 +0200751 }
752
753 g_free(d);
754 }
755}
756
757static void update_refcount_discard(BlockDriverState *bs,
758 uint64_t offset, uint64_t length)
759{
Kevin Wolfff991292015-09-07 17:12:56 +0200760 BDRVQcow2State *s = bs->opaque;
Kevin Wolf0b919fa2013-06-19 13:44:20 +0200761 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;
Zhang Haoyud8bb71b2014-10-11 16:35:43 +0800803 g_free(p);
Kevin Wolf0b919fa2013-06-19 13:44:20 +0200804 }
805}
806
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200807/* XXX: cache several refcount block clusters ? */
Max Reitz2aabe7c2015-02-10 15:28:47 -0500808/* @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 */
Kevin Wolf0bb79c92023-09-29 16:51:49 +0200810static int GRAPH_RDLOCK
811update_refcount(BlockDriverState *bs, int64_t offset, int64_t length,
812 uint64_t addend, bool decrease, enum qcow2_discard_type type)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200813{
Kevin Wolfff991292015-09-07 17:12:56 +0200814 BDRVQcow2State *s = bs->opaque;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200815 int64_t start, last, cluster_offset;
Max Reitz7453c962015-02-10 15:28:50 -0500816 void *refcount_block = NULL;
Kevin Wolf29c1a732011-01-10 17:17:28 +0100817 int64_t old_table_index = -1;
Kevin Wolf09508d12010-01-20 15:03:04 +0100818 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200819
820#ifdef DEBUG_ALLOC2
Max Reitz2aabe7c2015-02-10 15:28:47 -0500821 fprintf(stderr, "update_refcount: offset=%" PRId64 " size=%" PRId64
Max Reitz0e065282015-02-10 15:28:48 -0500822 " addend=%s%" PRIu64 "\n", offset, length, decrease ? "-" : "",
Max Reitz2aabe7c2015-02-10 15:28:47 -0500823 addend);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200824#endif
Kevin Wolf7322afe2010-01-20 15:03:05 +0100825 if (length < 0) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200826 return -EINVAL;
Kevin Wolf7322afe2010-01-20 15:03:05 +0100827 } else if (length == 0) {
828 return 0;
829 }
830
Max Reitz2aabe7c2015-02-10 15:28:47 -0500831 if (decrease) {
Kevin Wolf29c1a732011-01-10 17:17:28 +0100832 qcow2_cache_set_dependency(bs, s->refcount_block_cache,
833 s->l2_table_cache);
834 }
835
Hu Taoac95acd2013-12-05 14:32:34 +0800836 start = start_of_cluster(s, offset);
837 last = start_of_cluster(s, offset + length - 1);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200838 for(cluster_offset = start; cluster_offset <= last;
839 cluster_offset += s->cluster_size)
840 {
Max Reitz2aabe7c2015-02-10 15:28:47 -0500841 int block_index;
Max Reitz0e065282015-02-10 15:28:48 -0500842 uint64_t refcount;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200843 int64_t cluster_index = cluster_offset >> s->cluster_bits;
Max Reitz17bd5f42014-09-03 00:25:07 +0200844 int64_t table_index = cluster_index >> s->refcount_block_bits;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200845
846 /* Load the refcount block and allocate it if needed */
Kevin Wolf29c1a732011-01-10 17:17:28 +0100847 if (table_index != old_table_index) {
848 if (refcount_block) {
Alberto Garcia2013c3d2018-02-05 16:33:07 +0200849 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
Kevin Wolf29c1a732011-01-10 17:17:28 +0100850 }
Kevin Wolf29c1a732011-01-10 17:17:28 +0100851 ret = alloc_refcount_block(bs, cluster_index, &refcount_block);
Alberto Garciaabf754f2018-03-21 15:38:52 +0200852 /* 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 }
Kevin Wolf29c1a732011-01-10 17:17:28 +0100859 if (ret < 0) {
860 goto fail;
861 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200862 }
Kevin Wolf29c1a732011-01-10 17:17:28 +0100863 old_table_index = table_index;
864
Alberto Garcia2d135ee2018-02-05 16:33:06 +0200865 qcow2_cache_entry_mark_dirty(s->refcount_block_cache, refcount_block);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200866
867 /* we can update the count and save it */
Max Reitz17bd5f42014-09-03 00:25:07 +0200868 block_index = cluster_index & (s->refcount_block_size - 1);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200869
Max Reitz7453c962015-02-10 15:28:50 -0500870 refcount = s->get_refcount(refcount_block, block_index);
Max Reitz0e065282015-02-10 15:28:48 -0500871 if (decrease ? (refcount - addend > refcount)
872 : (refcount + addend < refcount ||
873 refcount + addend > s->refcount_max))
Max Reitz2aabe7c2015-02-10 15:28:47 -0500874 {
Kevin Wolf09508d12010-01-20 15:03:04 +0100875 ret = -EINVAL;
876 goto fail;
877 }
Max Reitz2aabe7c2015-02-10 15:28:47 -0500878 if (decrease) {
879 refcount -= addend;
880 } else {
881 refcount += addend;
882 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200883 if (refcount == 0 && cluster_index < s->free_cluster_index) {
884 s->free_cluster_index = cluster_index;
885 }
Max Reitz7453c962015-02-10 15:28:50 -0500886 s->set_refcount(refcount_block, block_index, refcount);
Kevin Wolf0b919fa2013-06-19 13:44:20 +0200887
Pavel Butsykinf71c08e2017-09-18 15:42:28 +0300888 if (refcount == 0) {
889 void *table;
890
Alberto Garcia6e6fa762018-02-05 16:33:11 +0200891 table = qcow2_cache_is_table_offset(s->refcount_block_cache,
Pavel Butsykinf71c08e2017-09-18 15:42:28 +0300892 offset);
893 if (table != NULL) {
Alberto Garcia2013c3d2018-02-05 16:33:07 +0200894 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
Kevin Wolfdea90522020-02-11 10:48:58 +0100895 old_table_index = -1;
Alberto Garcia77aadd72018-02-05 16:33:10 +0200896 qcow2_cache_discard(s->refcount_block_cache, table);
Pavel Butsykinf71c08e2017-09-18 15:42:28 +0300897 }
898
Alberto Garcia6e6fa762018-02-05 16:33:11 +0200899 table = qcow2_cache_is_table_offset(s->l2_table_cache, offset);
Pavel Butsykinf71c08e2017-09-18 15:42:28 +0300900 if (table != NULL) {
Alberto Garcia77aadd72018-02-05 16:33:10 +0200901 qcow2_cache_discard(s->l2_table_cache, table);
Pavel Butsykinf71c08e2017-09-18 15:42:28 +0300902 }
903
904 if (s->discard_passthrough[type]) {
905 update_refcount_discard(bs, cluster_offset, s->cluster_size);
906 }
Kevin Wolf67af6742013-06-19 13:44:19 +0200907 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200908 }
909
Kevin Wolf09508d12010-01-20 15:03:04 +0100910 ret = 0;
911fail:
Kevin Wolf0b919fa2013-06-19 13:44:20 +0200912 if (!s->cache_discards) {
913 qcow2_process_discards(bs, ret);
914 }
915
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200916 /* Write last changed block to disk */
Kevin Wolf29c1a732011-01-10 17:17:28 +0100917 if (refcount_block) {
Alberto Garcia2013c3d2018-02-05 16:33:07 +0200918 qcow2_cache_put(s->refcount_block_cache, &refcount_block);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200919 }
920
Kevin Wolf09508d12010-01-20 15:03:04 +0100921 /*
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;
Max Reitz2aabe7c2015-02-10 15:28:47 -0500927 dummy = update_refcount(bs, offset, cluster_offset - offset, addend,
928 !decrease, QCOW2_DISCARD_NEVER);
Blue Swirl83e3f762010-10-13 18:38:07 +0000929 (void)dummy;
Kevin Wolf09508d12010-01-20 15:03:04 +0100930 }
931
932 return ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200933}
934
Kevin Wolf018faaf2010-06-04 11:16:11 +0200935/*
Max Reitz44751912014-10-27 11:12:54 +0100936 * Increases or decreases the refcount of a given cluster.
Kevin Wolf018faaf2010-06-04 11:16:11 +0200937 *
Max Reitz2aabe7c2015-02-10 15:28:47 -0500938 * @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 *
Max Reitzc6e9d8a2015-02-10 15:28:45 -0500941 * On success 0 is returned; on failure -errno is returned.
Kevin Wolf018faaf2010-06-04 11:16:11 +0200942 */
Max Reitz32b64442013-09-03 10:09:52 +0200943int qcow2_update_cluster_refcount(BlockDriverState *bs,
944 int64_t cluster_index,
Max Reitz0e065282015-02-10 15:28:48 -0500945 uint64_t addend, bool decrease,
Max Reitz32b64442013-09-03 10:09:52 +0200946 enum qcow2_discard_type type)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200947{
Kevin Wolfff991292015-09-07 17:12:56 +0200948 BDRVQcow2State *s = bs->opaque;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200949 int ret;
950
Kevin Wolf6cfcb9b2013-06-19 13:44:18 +0200951 ret = update_refcount(bs, cluster_index << s->cluster_bits, 1, addend,
Max Reitz2aabe7c2015-02-10 15:28:47 -0500952 decrease, type);
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200953 if (ret < 0) {
954 return ret;
955 }
956
Max Reitzc6e9d8a2015-02-10 15:28:45 -0500957 return 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200958}
959
960
961
962/*********************************************************/
963/* cluster allocation functions */
964
965
966
967/* return < 0 if error */
Kevin Wolf0bb79c92023-09-29 16:51:49 +0200968static int64_t GRAPH_RDLOCK
969alloc_clusters_noref(BlockDriverState *bs, uint64_t size, uint64_t max)
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200970{
Kevin Wolfff991292015-09-07 17:12:56 +0200971 BDRVQcow2State *s = bs->opaque;
Max Reitz0e065282015-02-10 15:28:48 -0500972 uint64_t i, nb_clusters, refcount;
Max Reitz7324c102015-02-10 15:28:46 -0500973 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200974
Kevin Wolfecbda7a2015-05-06 13:21:51 +0200975 /* 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
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200980 nb_clusters = size_to_clusters(s, size);
981retry:
982 for(i = 0; i < nb_clusters; i++) {
Kevin Wolfbb572ae2014-03-26 13:05:51 +0100983 uint64_t next_cluster_index = s->free_cluster_index++;
Max Reitz7324c102015-02-10 15:28:46 -0500984 ret = qcow2_get_refcount(bs, next_cluster_index, &refcount);
Kevin Wolf2eaa8f62010-06-04 11:22:39 +0200985
Max Reitz7324c102015-02-10 15:28:46 -0500986 if (ret < 0) {
987 return ret;
Kevin Wolf2eaa8f62010-06-04 11:22:39 +0200988 } else if (refcount != 0) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200989 goto retry;
Kevin Wolf2eaa8f62010-06-04 11:22:39 +0200990 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +0200991 }
Max Reitz91f827d2014-04-29 19:03:11 +0200992
993 /* Make sure that all offsets in the "allocated" range are representable
Eric Blake77d6a212018-11-13 17:03:18 -0600994 * in the requested max */
Max Reitz65f33bc2014-05-04 05:31:40 +0200995 if (s->free_cluster_index > 0 &&
Eric Blake77d6a212018-11-13 17:03:18 -0600996 s->free_cluster_index - 1 > (max >> s->cluster_bits))
Max Reitz65f33bc2014-05-04 05:31:40 +0200997 {
Max Reitz91f827d2014-04-29 19:03:11 +0200998 return -EFBIG;
999 }
1000
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001001#ifdef DEBUG_ALLOC2
Frediano Ziglio35ee5e32011-08-25 09:23:55 +02001002 fprintf(stderr, "alloc_clusters: size=%" PRId64 " -> %" PRId64 "\n",
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001003 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
Kevin Wolfbb572ae2014-03-26 13:05:51 +01001009int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size)
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001010{
1011 int64_t offset;
Kevin Wolfdb3a9642010-01-20 15:03:06 +01001012 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001013
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001014 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
Kevin Wolfb106ad92014-03-28 18:06:31 +01001015 do {
Eric Blake77d6a212018-11-13 17:03:18 -06001016 offset = alloc_clusters_noref(bs, size, QCOW_MAX_CLUSTER_OFFSET);
Kevin Wolfb106ad92014-03-28 18:06:31 +01001017 if (offset < 0) {
1018 return offset;
1019 }
Kevin Wolf2eaa8f62010-06-04 11:22:39 +02001020
Max Reitz2aabe7c2015-02-10 15:28:47 -05001021 ret = update_refcount(bs, offset, size, 1, false, QCOW2_DISCARD_NEVER);
Kevin Wolfb106ad92014-03-28 18:06:31 +01001022 } while (ret == -EAGAIN);
1023
Kevin Wolfdb3a9642010-01-20 15:03:06 +01001024 if (ret < 0) {
1025 return ret;
1026 }
Kevin Wolf1c4c2812010-09-17 16:36:58 +02001027
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001028 return offset;
1029}
1030
Paolo Bonzinia39bae42023-03-09 09:44:55 +01001031int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
1032 int64_t nb_clusters)
Kevin Wolf256900b2012-03-02 19:35:58 +01001033{
Kevin Wolfff991292015-09-07 17:12:56 +02001034 BDRVQcow2State *s = bs->opaque;
Max Reitz0e065282015-02-10 15:28:48 -05001035 uint64_t cluster_index, refcount;
Hu Tao33304ec2014-01-26 11:12:38 +08001036 uint64_t i;
Max Reitz7324c102015-02-10 15:28:46 -05001037 int ret;
Hu Tao33304ec2014-01-26 11:12:38 +08001038
1039 assert(nb_clusters >= 0);
1040 if (nb_clusters == 0) {
1041 return 0;
1042 }
Kevin Wolf256900b2012-03-02 19:35:58 +01001043
Kevin Wolfb106ad92014-03-28 18:06:31 +01001044 do {
1045 /* Check how many clusters there are free */
1046 cluster_index = offset >> s->cluster_bits;
1047 for(i = 0; i < nb_clusters; i++) {
Max Reitz7324c102015-02-10 15:28:46 -05001048 ret = qcow2_get_refcount(bs, cluster_index++, &refcount);
1049 if (ret < 0) {
1050 return ret;
Kevin Wolfb106ad92014-03-28 18:06:31 +01001051 } else if (refcount != 0) {
1052 break;
1053 }
Kevin Wolf256900b2012-03-02 19:35:58 +01001054 }
Kevin Wolf256900b2012-03-02 19:35:58 +01001055
Kevin Wolfb106ad92014-03-28 18:06:31 +01001056 /* And then allocate them */
Max Reitz2aabe7c2015-02-10 15:28:47 -05001057 ret = update_refcount(bs, offset, i << s->cluster_bits, 1, false,
Kevin Wolfb106ad92014-03-28 18:06:31 +01001058 QCOW2_DISCARD_NEVER);
1059 } while (ret == -EAGAIN);
Kevin Wolff24423b2012-04-20 15:50:39 +02001060
Kevin Wolf256900b2012-03-02 19:35:58 +01001061 if (ret < 0) {
1062 return ret;
1063 }
1064
1065 return i;
1066}
1067
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001068/* only used to allocate compressed sectors. We try to allocate
1069 contiguous sectors. size must be <= cluster_size */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001070int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int size)
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001071{
Kevin Wolfff991292015-09-07 17:12:56 +02001072 BDRVQcow2State *s = bs->opaque;
Max Reitz8c44dfb2015-02-06 09:39:16 -05001073 int64_t offset;
1074 size_t free_in_cluster;
1075 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001076
Paolo Bonzini17362392023-06-01 13:51:45 +02001077 BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_BYTES);
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001078 assert(size > 0 && size <= s->cluster_size);
Max Reitz8c44dfb2015-02-06 09:39:16 -05001079 assert(!s->free_byte_offset || offset_into_cluster(s, s->free_byte_offset));
1080
1081 offset = s->free_byte_offset;
1082
1083 if (offset) {
Max Reitz0e065282015-02-10 15:28:48 -05001084 uint64_t refcount;
Max Reitz7324c102015-02-10 15:28:46 -05001085 ret = qcow2_get_refcount(bs, offset >> s->cluster_bits, &refcount);
1086 if (ret < 0) {
1087 return ret;
Kevin Wolf5d757b52010-01-20 15:04:01 +01001088 }
Max Reitz8c44dfb2015-02-06 09:39:16 -05001089
Max Reitz346a53d2015-02-10 15:28:43 -05001090 if (refcount == s->refcount_max) {
Max Reitz8c44dfb2015-02-06 09:39:16 -05001091 offset = 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001092 }
1093 }
Kevin Wolf29216ed2010-09-17 16:57:48 +02001094
Max Reitz8c44dfb2015-02-06 09:39:16 -05001095 free_in_cluster = s->cluster_size - offset_into_cluster(s, offset);
Jindřich Makovička3e5feb62015-06-24 07:05:25 +02001096 do {
1097 if (!offset || free_in_cluster < size) {
Eric Blake77d6a212018-11-13 17:03:18 -06001098 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));
Jindřich Makovička3e5feb62015-06-24 07:05:25 +02001103 if (new_cluster < 0) {
1104 return new_cluster;
1105 }
1106
Alberto Garcia8aa34832017-11-03 16:18:52 +02001107 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
Jindřich Makovička3e5feb62015-06-24 07:05:25 +02001114 if (!offset || ROUND_UP(offset, s->cluster_size) != new_cluster) {
1115 offset = new_cluster;
Max Reitz2ac01522015-09-11 18:47:51 +02001116 free_in_cluster = s->cluster_size;
1117 } else {
1118 free_in_cluster += s->cluster_size;
Jindřich Makovička3e5feb62015-06-24 07:05:25 +02001119 }
Max Reitz8c44dfb2015-02-06 09:39:16 -05001120 }
1121
Jindřich Makovička3e5feb62015-06-24 07:05:25 +02001122 assert(offset);
1123 ret = update_refcount(bs, offset, size, 1, false, QCOW2_DISCARD_NEVER);
Max Reitz2ac01522015-09-11 18:47:51 +02001124 if (ret < 0) {
1125 offset = 0;
1126 }
Jindřich Makovička3e5feb62015-06-24 07:05:25 +02001127 } while (ret == -EAGAIN);
Max Reitz8c44dfb2015-02-06 09:39:16 -05001128 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. */
Stefan Hajnoczic1f5baf2013-03-04 15:02:32 +01001134 qcow2_cache_set_dependency(bs, s->l2_table_cache, s->refcount_block_cache);
Max Reitz8c44dfb2015-02-06 09:39:16 -05001135
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
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001141 return offset;
1142}
1143
Kevin Wolfed6ccf02009-05-28 16:07:07 +02001144void qcow2_free_clusters(BlockDriverState *bs,
Kevin Wolf6cfcb9b2013-06-19 13:44:18 +02001145 int64_t offset, int64_t size,
1146 enum qcow2_discard_type type)
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001147{
Kevin Wolfdb3a9642010-01-20 15:03:06 +01001148 int ret;
1149
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001150 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_FREE);
Max Reitz2aabe7c2015-02-10 15:28:47 -05001151 ret = update_refcount(bs, offset, size, 1, true, type);
Kevin Wolfdb3a9642010-01-20 15:03:06 +01001152 if (ret < 0) {
1153 fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret));
Kevin Wolf003fad62010-04-21 11:37:52 +02001154 /* TODO Remember the clusters to free them later and avoid leaking */
Kevin Wolfdb3a9642010-01-20 15:03:06 +01001155 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001156}
1157
Kevin Wolf45aba422009-05-28 16:07:05 +02001158/*
Kevin Wolfc7a4c372012-03-27 13:09:22 +02001159 * Free a cluster using its L2 entry (handles clusters of all types, e.g.
1160 * normal cluster, compressed cluster, etc.)
Kevin Wolf45aba422009-05-28 16:07:05 +02001161 */
Alberto Garcia3fec2372020-09-08 16:08:28 +02001162void qcow2_free_any_cluster(BlockDriverState *bs, uint64_t l2_entry,
1163 enum qcow2_discard_type type)
Kevin Wolf45aba422009-05-28 16:07:05 +02001164{
Kevin Wolfff991292015-09-07 17:12:56 +02001165 BDRVQcow2State *s = bs->opaque;
Kevin Wolf966b0002019-01-15 20:39:06 +01001166 QCow2ClusterType ctype = qcow2_get_cluster_type(bs, l2_entry);
Kevin Wolf45aba422009-05-28 16:07:05 +02001167
Kevin Wolf966b0002019-01-15 20:39:06 +01001168 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,
Alberto Garcia3fec2372020-09-08 16:08:28 +02001174 s->cluster_size);
Kevin Wolf966b0002019-01-15 20:39:06 +01001175 }
1176 return;
1177 }
1178
1179 switch (ctype) {
Kevin Wolfc7a4c372012-03-27 13:09:22 +02001180 case QCOW2_CLUSTER_COMPRESSED:
1181 {
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001182 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);
Kevin Wolfc7a4c372012-03-27 13:09:22 +02001187 }
1188 break;
1189 case QCOW2_CLUSTER_NORMAL:
Eric Blakefdfab372017-05-06 19:05:46 -05001190 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,
Alberto Garcia3fec2372020-09-08 16:08:28 +02001197 s->cluster_size, type);
Max Reitz8f730dd2013-10-09 10:44:28 +02001198 }
Kevin Wolfc7a4c372012-03-27 13:09:22 +02001199 break;
Eric Blakefdfab372017-05-06 19:05:46 -05001200 case QCOW2_CLUSTER_ZERO_PLAIN:
Kevin Wolfc7a4c372012-03-27 13:09:22 +02001201 case QCOW2_CLUSTER_UNALLOCATED:
1202 break;
1203 default:
1204 abort();
Kevin Wolf45aba422009-05-28 16:07:05 +02001205 }
Kevin Wolf45aba422009-05-28 16:07:05 +02001206}
1207
Paolo Bonzini38401442022-09-22 10:49:01 +02001208int qcow2_write_caches(BlockDriverState *bs)
Paolo Bonzini8b220eb2018-03-01 17:36:14 +01001209{
1210 BDRVQcow2State *s = bs->opaque;
1211 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001212
Paolo Bonzini8b220eb2018-03-01 17:36:14 +01001213 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
Paolo Bonzini38401442022-09-22 10:49:01 +02001228int qcow2_flush_caches(BlockDriverState *bs)
Paolo Bonzini8b220eb2018-03-01 17:36:14 +01001229{
1230 int ret = qcow2_write_caches(bs);
1231 if (ret < 0) {
1232 return ret;
1233 }
1234
1235 return bdrv_flush(bs->file->bs);
1236}
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001237
1238/*********************************************************/
1239/* snapshots and image creation */
1240
1241
1242
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001243/* update the refcounts of snapshots and the copied flag */
Kevin Wolfed6ccf02009-05-28 16:07:07 +02001244int qcow2_update_snapshot_refcount(BlockDriverState *bs,
1245 int64_t l1_table_offset, int l1_size, int addend)
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001246{
Kevin Wolfff991292015-09-07 17:12:56 +02001247 BDRVQcow2State *s = bs->opaque;
Alberto Garcia83ad1652018-02-05 16:33:27 +02001248 uint64_t *l1_table, *l2_slice, l2_offset, entry, l1_size2, refcount;
Kevin Wolfde828152014-05-20 17:12:47 +02001249 bool l1_allocated = false;
Eric Blakeb32cbae2017-05-06 19:05:41 -05001250 int64_t old_entry, old_l2_offset;
Alberto Garcia83ad1652018-02-05 16:33:27 +02001251 unsigned slice, slice_size2, n_slices;
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001252 int i, j, l1_modified = 0;
Kevin Wolf29c1a732011-01-10 17:17:28 +01001253 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001254
Max Reitz2aabe7c2015-02-10 15:28:47 -05001255 assert(addend >= -1 && addend <= 1);
1256
Alberto Garcia83ad1652018-02-05 16:33:27 +02001257 l2_slice = NULL;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001258 l1_table = NULL;
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02001259 l1_size2 = l1_size * L1E_SIZE;
Alberto Garciac8fd8552020-07-10 18:12:54 +02001260 slice_size2 = s->l2_slice_size * l2_entry_size(s);
Alberto Garcia83ad1652018-02-05 16:33:27 +02001261 n_slices = s->cluster_size / slice_size2;
Kevin Wolf43a0cac2011-11-16 15:20:45 +01001262
Kevin Wolf0b919fa2013-06-19 13:44:20 +02001263 s->cache_discards = true;
1264
Kevin Wolf43a0cac2011-11-16 15:20:45 +01001265 /* 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! */
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001268 if (l1_table_offset != s->l1_table_offset) {
Alberto Garciaef97d602020-01-18 20:09:26 +01001269 l1_table = g_try_malloc0(l1_size2);
Kevin Wolfde828152014-05-20 17:12:47 +02001270 if (l1_size2 && l1_table == NULL) {
1271 ret = -ENOMEM;
1272 goto fail;
1273 }
1274 l1_allocated = true;
Kevin Wolfc2bc78b2013-04-05 12:51:31 +02001275
Alberto Faria32cc71d2022-06-09 16:27:36 +01001276 ret = bdrv_pread(bs->file, l1_table_offset, l1_size2, l1_table, 0);
Kevin Wolfc2bc78b2013-04-05 12:51:31 +02001277 if (ret < 0) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001278 goto fail;
Kevin Wolf93913df2011-07-19 13:01:48 +02001279 }
1280
Eric Blakeb32cbae2017-05-06 19:05:41 -05001281 for (i = 0; i < l1_size; i++) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001282 be64_to_cpus(&l1_table[i]);
Eric Blakeb32cbae2017-05-06 19:05:41 -05001283 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001284 } else {
1285 assert(l1_size == s->l1_size);
1286 l1_table = s->l1_table;
Kevin Wolfde828152014-05-20 17:12:47 +02001287 l1_allocated = false;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001288 }
1289
Eric Blakeb32cbae2017-05-06 19:05:41 -05001290 for (i = 0; i < l1_size; i++) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001291 l2_offset = l1_table[i];
1292 if (l2_offset) {
1293 old_l2_offset = l2_offset;
Kevin Wolf8e37f682012-02-23 15:40:55 +01001294 l2_offset &= L1E_OFFSET_MASK;
Kevin Wolf29c1a732011-01-10 17:17:28 +01001295
Max Reitza97c67e2014-09-05 16:07:18 +02001296 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
Alberto Garcia83ad1652018-02-05 16:33:27 +02001304 for (slice = 0; slice < n_slices; slice++) {
Alberto Garciaca62dd52018-02-05 16:33:26 +02001305 ret = qcow2_cache_get(bs, s->l2_table_cache,
Alberto Garcia83ad1652018-02-05 16:33:27 +02001306 l2_offset + slice * slice_size2,
1307 (void **) &l2_slice);
Alberto Garciaca62dd52018-02-05 16:33:26 +02001308 if (ret < 0) {
1309 goto fail;
1310 }
Kevin Wolf29c1a732011-01-10 17:17:28 +01001311
Alberto Garcia83ad1652018-02-05 16:33:27 +02001312 for (j = 0; j < s->l2_slice_size; j++) {
Alberto Garciaca62dd52018-02-05 16:33:26 +02001313 uint64_t cluster_index;
1314 uint64_t offset;
Max Reitz8b81a7b2013-08-30 10:40:14 +02001315
Alberto Garcia12c6aeb2020-07-10 18:12:48 +02001316 entry = get_l2_entry(s, l2_slice, j);
Alberto Garciaca62dd52018-02-05 16:33:26 +02001317 old_entry = entry;
1318 entry &= ~QCOW_OFLAG_COPIED;
1319 offset = entry & L2E_OFFSET_MASK;
Max Reitz8b81a7b2013-08-30 10:40:14 +02001320
Kevin Wolf808c2bb2019-01-17 18:42:40 +01001321 switch (qcow2_get_cluster_type(bs, entry)) {
Alberto Garciaca62dd52018-02-05 16:33:26 +02001322 case QCOW2_CLUSTER_COMPRESSED:
Alberto Garciaca62dd52018-02-05 16:33:26 +02001323 if (addend != 0) {
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001324 uint64_t coffset;
1325 int csize;
1326
1327 qcow2_parse_compressed_l2_entry(bs, entry,
1328 &coffset, &csize);
Alberto Garciaca62dd52018-02-05 16:33:26 +02001329 ret = update_refcount(
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001330 bs, coffset, csize,
Alberto Garciab6c24692019-05-10 19:22:54 +03001331 abs(addend), addend < 0,
Kevin Wolf6cfcb9b2013-06-19 13:44:18 +02001332 QCOW2_DISCARD_SNAPSHOT);
Alberto Garciaca62dd52018-02-05 16:33:26 +02001333 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)) {
Alberto Garcia83ad1652018-02-05 16:33:27 +02001344 /* Here l2_index means table (not slice) index */
1345 int l2_index = slice * s->l2_slice_size + j;
Alberto Garciaca62dd52018-02-05 16:33:26 +02001346 qcow2_signal_corruption(
1347 bs, true, -1, -1, "Cluster "
1348 "allocation offset %#" PRIx64
1349 " unaligned (L2 offset: %#"
1350 PRIx64 ", L2 index: %#x)",
Alberto Garcia83ad1652018-02-05 16:33:27 +02001351 offset, l2_offset, l2_index);
Alberto Garciaca62dd52018-02-05 16:33:26 +02001352 ret = -EIO;
1353 goto fail;
1354 }
1355
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);
Max Reitz7324c102015-02-10 15:28:46 -05001368 if (ret < 0) {
Kevin Wolf018faaf2010-06-04 11:16:11 +02001369 goto fail;
1370 }
Alberto Garciaca62dd52018-02-05 16:33:26 +02001371 break;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001372
Alberto Garciaca62dd52018-02-05 16:33:26 +02001373 case QCOW2_CLUSTER_ZERO_PLAIN:
1374 case QCOW2_CLUSTER_UNALLOCATED:
1375 refcount = 0;
1376 break;
1377
1378 default:
1379 abort();
Eric Blakebbd995d2017-05-06 19:05:42 -05001380 }
1381
Alberto Garciaca62dd52018-02-05 16:33:26 +02001382 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);
Eric Blakebbd995d2017-05-06 19:05:42 -05001389 }
Alberto Garcia12c6aeb2020-07-10 18:12:48 +02001390 set_l2_entry(s, l2_slice, j, entry);
Alberto Garciaca62dd52018-02-05 16:33:26 +02001391 qcow2_cache_entry_mark_dirty(s->l2_table_cache,
Alberto Garcia83ad1652018-02-05 16:33:27 +02001392 l2_slice);
Eric Blakebbd995d2017-05-06 19:05:42 -05001393 }
Max Reitz8b81a7b2013-08-30 10:40:14 +02001394 }
1395
Alberto Garcia83ad1652018-02-05 16:33:27 +02001396 qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001397 }
Kevin Wolf29c1a732011-01-10 17:17:28 +01001398
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001399 if (addend != 0) {
Max Reitzc6e9d8a2015-02-10 15:28:45 -05001400 ret = qcow2_update_cluster_refcount(bs, l2_offset >>
1401 s->cluster_bits,
Max Reitz2aabe7c2015-02-10 15:28:47 -05001402 abs(addend), addend < 0,
Max Reitzc6e9d8a2015-02-10 15:28:45 -05001403 QCOW2_DISCARD_SNAPSHOT);
1404 if (ret < 0) {
1405 goto fail;
1406 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001407 }
Max Reitz7324c102015-02-10 15:28:46 -05001408 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
1409 &refcount);
1410 if (ret < 0) {
Kevin Wolf018faaf2010-06-04 11:16:11 +02001411 goto fail;
1412 } else if (refcount == 1) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001413 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 }
Kevin Wolf93913df2011-07-19 13:01:48 +02001421
Stefan Hajnoczi2154f242013-03-04 15:02:33 +01001422 ret = bdrv_flush(bs);
Kevin Wolf93913df2011-07-19 13:01:48 +02001423fail:
Alberto Garcia83ad1652018-02-05 16:33:27 +02001424 if (l2_slice) {
1425 qcow2_cache_put(s->l2_table_cache, (void **) &l2_slice);
Kevin Wolf93913df2011-07-19 13:01:48 +02001426 }
1427
Kevin Wolf0b919fa2013-06-19 13:44:20 +02001428 s->cache_discards = false;
1429 qcow2_process_discards(bs, ret);
1430
Kevin Wolf43a0cac2011-11-16 15:20:45 +01001431 /* Update L1 only if it isn't deleted anyway (addend = -1) */
Kevin Wolfc2b6ff52013-04-05 12:57:10 +02001432 if (ret == 0 && addend >= 0 && l1_modified) {
1433 for (i = 0; i < l1_size; i++) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001434 cpu_to_be64s(&l1_table[i]);
Kevin Wolfc2b6ff52013-04-05 12:57:10 +02001435 }
1436
Alberto Faria32cc71d2022-06-09 16:27:36 +01001437 ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_size2, l1_table,
Alberto Faria53fb7842022-06-09 16:27:35 +01001438 0);
Kevin Wolfc2b6ff52013-04-05 12:57:10 +02001439
1440 for (i = 0; i < l1_size; i++) {
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001441 be64_to_cpus(&l1_table[i]);
Kevin Wolfc2b6ff52013-04-05 12:57:10 +02001442 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001443 }
1444 if (l1_allocated)
Anthony Liguori7267c092011-08-20 22:09:37 -05001445 g_free(l1_table);
Kevin Wolf93913df2011-07-19 13:01:48 +02001446 return ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001447}
1448
1449
1450
1451
1452/*********************************************************/
1453/* refcount checking functions */
1454
1455
Kevin Wolfc2551b42015-12-01 15:16:49 +01001456static uint64_t refcount_array_byte_size(BDRVQcow2State *s, uint64_t entries)
Max Reitz5fee1922015-02-10 15:28:49 -05001457{
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 */
Kevin Wolfff991292015-09-07 17:12:56 +02001479static int realloc_refcount_array(BDRVQcow2State *s, void **array,
Max Reitz5fee1922015-02-10 15:28:49 -05001480 int64_t *size, int64_t new_size)
1481{
Max Reitzb6d36de2015-09-14 16:39:47 +02001482 int64_t old_byte_size, new_byte_size;
Max Reitz7453c962015-02-10 15:28:50 -05001483 void *new_ptr;
Max Reitz5fee1922015-02-10 15:28:49 -05001484
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
Max Reitzb6d36de2015-09-14 16:39:47 +02001498 if (new_byte_size > SIZE_MAX) {
1499 return -ENOMEM;
1500 }
1501
Max Reitz5fee1922015-02-10 15:28:49 -05001502 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) {
Max Reitzb6d36de2015-09-14 16:39:47 +02001508 memset((char *)new_ptr + old_byte_size, 0,
Max Reitz5fee1922015-02-10 15:28:49 -05001509 new_byte_size - old_byte_size);
1510 }
1511
1512 *array = new_ptr;
1513 *size = new_size;
1514
1515 return 0;
1516}
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001517
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
Daniel P. Berrangeb6af0972015-08-26 12:17:13 +01001521 * which can be compared to the refcount table saved in the image.
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001522 *
Kevin Wolf9ac228e2010-06-29 12:37:54 +02001523 * Modifies the number of errors in res.
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001524 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001525int 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)
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001530{
Kevin Wolfff991292015-09-07 17:12:56 +02001531 BDRVQcow2State *s = bs->opaque;
Max Reitz7453c962015-02-10 15:28:50 -05001532 uint64_t start, last, cluster_offset, k, refcount;
Vladimir Sementsov-Ogievskiya5fff8d2019-02-27 16:14:30 +03001533 int64_t file_len;
Max Reitz5fee1922015-02-10 15:28:49 -05001534 int ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001535
Max Reitzfef4d3d2014-10-22 14:09:35 +02001536 if (size <= 0) {
1537 return 0;
1538 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001539
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001540 file_len = bdrv_co_getlength(bs->file->bs);
Vladimir Sementsov-Ogievskiya5fff8d2019-02-27 16:14:30 +03001541 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
Hu Taoac95acd2013-12-05 14:32:34 +08001558 start = start_of_cluster(s, offset);
1559 last = start_of_cluster(s, offset + size - 1);
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001560 for(cluster_offset = start; cluster_offset <= last;
1561 cluster_offset += s->cluster_size) {
1562 k = cluster_offset >> s->cluster_bits;
Max Reitz641bb632014-10-22 14:09:36 +02001563 if (k >= *refcount_table_size) {
Max Reitz5fee1922015-02-10 15:28:49 -05001564 ret = realloc_refcount_array(s, refcount_table,
1565 refcount_table_size, k + 1);
1566 if (ret < 0) {
Max Reitz641bb632014-10-22 14:09:36 +02001567 res->check_errors++;
Max Reitz5fee1922015-02-10 15:28:49 -05001568 return ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001569 }
Max Reitz641bb632014-10-22 14:09:36 +02001570 }
1571
Max Reitz7453c962015-02-10 15:28:50 -05001572 refcount = s->get_refcount(*refcount_table, k);
1573 if (refcount == s->refcount_max) {
Max Reitz641bb632014-10-22 14:09:36 +02001574 fprintf(stderr, "ERROR: overflow cluster offset=0x%" PRIx64
1575 "\n", cluster_offset);
Max Reitz03bb78e2015-07-27 17:51:39 +02001576 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");
Max Reitz641bb632014-10-22 14:09:36 +02001579 res->corruptions++;
Max Reitz7453c962015-02-10 15:28:50 -05001580 continue;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001581 }
Max Reitz7453c962015-02-10 15:28:50 -05001582 s->set_refcount(*refcount_table, k, refcount + 1);
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001583 }
Max Reitzfef4d3d2014-10-22 14:09:35 +02001584
1585 return 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001586}
1587
Stefan Hajnoczi801f7042013-02-07 17:15:01 +01001588/* Flags for check_refcounts_l1() and check_refcounts_l2() */
1589enum {
Stefan Hajnoczifba31ba2013-02-07 17:15:02 +01001590 CHECK_FRAG_INFO = 0x2, /* update BlockFragInfo counters */
Stefan Hajnoczi801f7042013-02-07 17:15:01 +01001591};
1592
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001593/*
Vladimir Sementsov-Ogievskiy5c3216c2021-09-14 15:24:49 +03001594 * Fix L2 entry by making it QCOW2_CLUSTER_ZERO_PLAIN (or making all its present
1595 * subclusters QCOW2_SUBCLUSTER_ZERO_PLAIN).
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001596 *
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 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001602static 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)
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001607{
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;
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001613
Vladimir Sementsov-Ogievskiy5c3216c2021-09-14 15:24:49 +03001614 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
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001627 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
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001637 ret = bdrv_co_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
1638 &l2_table[idx], 0);
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001639 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
1654/*
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001655 * 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 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001662static 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)
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001667{
Kevin Wolfff991292015-09-07 17:12:56 +02001668 BDRVQcow2State *s = bs->opaque;
Vladimir Sementsov-Ogievskiy9631c782021-09-14 15:24:50 +03001669 uint64_t l2_entry, l2_bitmap;
Stefan Hajnoczifba31ba2013-02-07 17:15:02 +01001670 uint64_t next_contiguous_offset = 0;
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001671 int i, ret;
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001672 size_t l2_size_bytes = s->l2_size * l2_entry_size(s);
1673 g_autofree uint64_t *l2_table = g_malloc(l2_size_bytes);
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001674 bool metadata_overlap;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001675
1676 /* Read L2 table from disk */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001677 ret = bdrv_co_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
Max Reitzad273902014-10-22 14:09:34 +02001678 if (ret < 0) {
1679 fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
1680 res->check_errors++;
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001681 return ret;
Max Reitzad273902014-10-22 14:09:34 +02001682 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001683
1684 /* Do the actual checks */
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001685 for (i = 0; i < s->l2_size; i++) {
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001686 uint64_t coffset;
1687 int csize;
Vladimir Sementsov-Ogievskiy289ef5f2021-09-14 15:24:51 +03001688 QCow2ClusterType type;
1689
Alberto Garcia12c6aeb2020-07-10 18:12:48 +02001690 l2_entry = get_l2_entry(s, l2_table, i);
Vladimir Sementsov-Ogievskiy9631c782021-09-14 15:24:50 +03001691 l2_bitmap = get_l2_bitmap(s, l2_table, i);
Vladimir Sementsov-Ogievskiy289ef5f2021-09-14 15:24:51 +03001692 type = qcow2_get_cluster_type(bs, l2_entry);
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001693
Vladimir Sementsov-Ogievskiy289ef5f2021-09-14 15:24:51 +03001694 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 }
1702
1703 switch (type) {
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001704 case QCOW2_CLUSTER_COMPRESSED:
1705 /* Compressed clusters don't have QCOW_OFLAG_COPIED */
1706 if (l2_entry & QCOW_OFLAG_COPIED) {
Alberto Garcia74c44a52018-04-10 18:05:03 +02001707 fprintf(stderr, "ERROR: coffset=0x%" PRIx64 ": "
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001708 "copied flag must never be set for compressed "
Alberto Garcia74c44a52018-04-10 18:05:03 +02001709 "clusters\n", l2_entry & s->cluster_offset_mask);
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001710 l2_entry &= ~QCOW_OFLAG_COPIED;
1711 res->corruptions++;
1712 }
1713
Kevin Wolfe9f5b6d2019-02-27 17:26:40 +01001714 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
Vladimir Sementsov-Ogievskiy9631c782021-09-14 15:24:50 +03001721 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
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001729 /* Mark cluster as used */
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001730 qcow2_parse_compressed_l2_entry(bs, l2_entry, &coffset, &csize);
Alberto Garciab6c24692019-05-10 19:22:54 +03001731 ret = qcow2_inc_refcounts_imrt(
Vladimir Sementsov-Ogievskiya6e09842021-09-14 15:24:47 +03001732 bs, res, refcount_table, refcount_table_size, coffset, csize);
Max Reitzfef4d3d2014-10-22 14:09:35 +02001733 if (ret < 0) {
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001734 return ret;
Max Reitzfef4d3d2014-10-22 14:09:35 +02001735 }
Stefan Hajnoczifba31ba2013-02-07 17:15:02 +01001736
1737 if (flags & CHECK_FRAG_INFO) {
1738 res->bfi.allocated_clusters++;
Stefan Hajnoczi4db35162013-02-07 17:15:05 +01001739 res->bfi.compressed_clusters++;
Stefan Hajnoczifba31ba2013-02-07 17:15:02 +01001740
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001741 /*
1742 * Compressed clusters are fragmented by nature. Since they
Stefan Hajnoczifba31ba2013-02-07 17:15:02 +01001743 * 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 }
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001749 break;
1750
Eric Blakefdfab372017-05-06 19:05:46 -05001751 case QCOW2_CLUSTER_ZERO_ALLOC:
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001752 case QCOW2_CLUSTER_NORMAL:
1753 {
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001754 uint64_t offset = l2_entry & L2E_OFFSET_MASK;
1755
Vladimir Sementsov-Ogievskiy9631c782021-09-14 15:24:50 +03001756 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
Max Reitzac5b7872017-11-10 21:37:59 +01001763 /* Correct offsets are cluster aligned */
1764 if (offset_into_cluster(s, offset)) {
Alberto Garciafc2e6522020-07-10 18:13:06 +02001765 bool contains_data;
Vladimir Sementsov-Ogievskiy54b10012019-02-27 16:14:33 +03001766 res->corruptions++;
1767
Alberto Garciafc2e6522020-07-10 18:13:06 +02001768 if (has_subclusters(s)) {
Alberto Garciafc2e6522020-07-10 18:13:06 +02001769 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 "
Max Reitzac5b7872017-11-10 21:37:59 +01001776 "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) {
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001781 ret = fix_l2_entry_by_zero(bs, res, l2_offset,
1782 l2_table, i, active,
1783 &metadata_overlap);
1784 if (metadata_overlap) {
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001785 /*
1786 * Something is seriously wrong, so abort checking
1787 * this L2 table.
1788 */
1789 return ret;
Max Reitzac5b7872017-11-10 21:37:59 +01001790 }
1791
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001792 if (ret == 0) {
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001793 /*
1794 * Skip marking the cluster as used
1795 * (it is unused now).
1796 */
Max Reitzac5b7872017-11-10 21:37:59 +01001797 continue;
1798 }
Vladimir Sementsov-Ogievskiya2debf62021-09-14 15:24:48 +03001799
1800 /*
1801 * Failed to fix.
1802 * Do not abort, continue checking the rest of this
1803 * L2 table's entries.
1804 */
Max Reitzac5b7872017-11-10 21:37:59 +01001805 }
1806 } else {
1807 fprintf(stderr, "ERROR offset=%" PRIx64 ": Data cluster is "
1808 "not properly aligned; L2 entry corrupted.\n", offset);
Max Reitzac5b7872017-11-10 21:37:59 +01001809 }
1810 }
1811
Vladimir Sementsov-Ogievskiycbb51e92019-02-27 16:14:32 +03001812 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
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001821 /* Mark cluster as used */
Kevin Wolfe9f5b6d2019-02-27 17:26:40 +01001822 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) {
Vladimir Sementsov-Ogievskiy786c22d2021-09-14 15:24:45 +03001827 return ret;
Kevin Wolfe9f5b6d2019-02-27 17:26:40 +01001828 }
Max Reitzfef4d3d2014-10-22 14:09:35 +02001829 }
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001830 break;
1831 }
1832
Eric Blakefdfab372017-05-06 19:05:46 -05001833 case QCOW2_CLUSTER_ZERO_PLAIN:
Vladimir Sementsov-Ogievskiy9631c782021-09-14 15:24:50 +03001834 /* Impossible when image has subclusters */
1835 assert(!l2_bitmap);
1836 break;
1837
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001838 case QCOW2_CLUSTER_UNALLOCATED:
Vladimir Sementsov-Ogievskiy9631c782021-09-14 15:24:50 +03001839 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 }
Kevin Wolfafdf0ab2012-03-27 13:44:56 +02001844 break;
1845
1846 default:
1847 abort();
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001848 }
1849 }
1850
Kevin Wolf9ac228e2010-06-29 12:37:54 +02001851 return 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001852}
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 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001862static 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)
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001867{
Kevin Wolfff991292015-09-07 17:12:56 +02001868 BDRVQcow2State *s = bs->opaque;
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001869 size_t l1_size_bytes = l1_size * L1E_SIZE;
1870 g_autofree uint64_t *l1_table = NULL;
1871 uint64_t l2_offset;
Max Reitz4f6ed882013-08-30 14:34:27 +02001872 int i, ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001873
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001874 if (!l1_size) {
1875 return 0;
1876 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001877
1878 /* Mark L1 table as used */
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03001879 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001880 l1_table_offset, l1_size_bytes);
Max Reitzfef4d3d2014-10-22 14:09:35 +02001881 if (ret < 0) {
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001882 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;
Max Reitzfef4d3d2014-10-22 14:09:35 +02001889 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001890
1891 /* Read L1 table entries from disk */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001892 ret = bdrv_co_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001893 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]);
Kevin Wolf702ef632009-11-27 17:35:55 +01001901 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001902
1903 /* Do the actual checks */
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001904 for (i = 0; i < l1_size; i++) {
1905 if (!l1_table[i]) {
1906 continue;
1907 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001908
Vladimir Sementsov-Ogievskiy98bc07d2021-09-14 15:24:53 +03001909 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
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001915 l2_offset = l1_table[i] & L1E_OFFSET_MASK;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001916
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001917 /* 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;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001938 }
1939 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001940
Vladimir Sementsov-Ogievskiycd6efd62021-09-14 15:24:52 +03001941 return 0;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02001942}
1943
1944/*
Max Reitz4f6ed882013-08-30 14:34:27 +02001945 * 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
Max Reitz44751912014-10-27 11:12:54 +01001948 * 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
Max Reitz4f6ed882013-08-30 14:34:27 +02001950 * (qcow2_check_refcounts) by the time this function is called).
1951 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02001952static int coroutine_fn GRAPH_RDLOCK
1953check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
Max Reitz4f6ed882013-08-30 14:34:27 +02001954{
Kevin Wolfff991292015-09-07 17:12:56 +02001955 BDRVQcow2State *s = bs->opaque;
Max Reitz4f6ed882013-08-30 14:34:27 +02001956 uint64_t *l2_table = qemu_blockalign(bs, s->cluster_size);
1957 int ret;
Max Reitz0e065282015-02-10 15:28:48 -05001958 uint64_t refcount;
Max Reitz4f6ed882013-08-30 14:34:27 +02001959 int i, j;
Max Reitz3cce51c2018-05-09 22:00:58 +02001960 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 }
Max Reitz4f6ed882013-08-30 14:34:27 +02001973
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;
Vladimir Sementsov-Ogievskiy7e3e7362019-02-27 16:14:29 +03001977 int l2_dirty = 0;
Max Reitz4f6ed882013-08-30 14:34:27 +02001978
1979 if (!l2_offset) {
1980 continue;
1981 }
1982
Max Reitz7324c102015-02-10 15:28:46 -05001983 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits,
1984 &refcount);
1985 if (ret < 0) {
Max Reitz4f6ed882013-08-30 14:34:27 +02001986 /* don't print message nor increment check_errors */
1987 continue;
1988 }
1989 if ((refcount == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
Vladimir Sementsov-Ogievskiy54b10012019-02-27 16:14:33 +03001990 res->corruptions++;
Max Reitze23e4002013-08-30 14:34:28 +02001991 fprintf(stderr, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
Max Reitz0e065282015-02-10 15:28:48 -05001992 "l1_entry=%" PRIx64 " refcount=%" PRIu64 "\n",
Max Reitz3cce51c2018-05-09 22:00:58 +02001993 repair ? "Repairing" : "ERROR", i, l1_entry, refcount);
1994 if (repair) {
Max Reitze23e4002013-08-30 14:34:28 +02001995 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 }
Vladimir Sementsov-Ogievskiy54b10012019-02-27 16:14:33 +03002003 res->corruptions--;
Max Reitze23e4002013-08-30 14:34:28 +02002004 res->corruptions_fixed++;
Max Reitze23e4002013-08-30 14:34:28 +02002005 }
Max Reitz4f6ed882013-08-30 14:34:27 +02002006 }
2007
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002008 ret = bdrv_co_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
2009 l2_table, 0);
Max Reitz4f6ed882013-08-30 14:34:27 +02002010 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++) {
Alberto Garcia12c6aeb2020-07-10 18:12:48 +02002018 uint64_t l2_entry = get_l2_entry(s, l2_table, j);
Max Reitz4f6ed882013-08-30 14:34:27 +02002019 uint64_t data_offset = l2_entry & L2E_OFFSET_MASK;
Kevin Wolf808c2bb2019-01-17 18:42:40 +01002020 QCow2ClusterType cluster_type = qcow2_get_cluster_type(bs, l2_entry);
Max Reitz4f6ed882013-08-30 14:34:27 +02002021
Eric Blakefdfab372017-05-06 19:05:46 -05002022 if (cluster_type == QCOW2_CLUSTER_NORMAL ||
2023 cluster_type == QCOW2_CLUSTER_ZERO_ALLOC) {
Kevin Wolfe9f5b6d2019-02-27 17:26:40 +01002024 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 }
Max Reitz4f6ed882013-08-30 14:34:27 +02002034 }
2035 if ((refcount == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
Vladimir Sementsov-Ogievskiy54b10012019-02-27 16:14:33 +03002036 res->corruptions++;
Max Reitze23e4002013-08-30 14:34:28 +02002037 fprintf(stderr, "%s OFLAG_COPIED data cluster: "
Max Reitz0e065282015-02-10 15:28:48 -05002038 "l2_entry=%" PRIx64 " refcount=%" PRIu64 "\n",
Max Reitz3cce51c2018-05-09 22:00:58 +02002039 repair ? "Repairing" : "ERROR", l2_entry, refcount);
2040 if (repair) {
Alberto Garcia12c6aeb2020-07-10 18:12:48 +02002041 set_l2_entry(s, l2_table, j,
2042 refcount == 1 ?
2043 l2_entry | QCOW_OFLAG_COPIED :
2044 l2_entry & ~QCOW_OFLAG_COPIED);
Vladimir Sementsov-Ogievskiy7e3e7362019-02-27 16:14:29 +03002045 l2_dirty++;
Max Reitze23e4002013-08-30 14:34:28 +02002046 }
Max Reitz4f6ed882013-08-30 14:34:27 +02002047 }
2048 }
2049 }
Max Reitze23e4002013-08-30 14:34:28 +02002050
Vladimir Sementsov-Ogievskiy7e3e7362019-02-27 16:14:29 +03002051 if (l2_dirty > 0) {
Max Reitz231bb262013-10-10 11:09:23 +02002052 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L2,
Kevin Wolf966b0002019-01-15 20:39:06 +01002053 l2_offset, s->cluster_size,
2054 false);
Max Reitze23e4002013-08-30 14:34:28 +02002055 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
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002062 ret = bdrv_co_pwrite(bs->file, l2_offset, s->cluster_size, l2_table, 0);
Max Reitze23e4002013-08-30 14:34:28 +02002063 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 }
Vladimir Sementsov-Ogievskiy54b10012019-02-27 16:14:33 +03002069 res->corruptions -= l2_dirty;
Vladimir Sementsov-Ogievskiy7e3e7362019-02-27 16:14:29 +03002070 res->corruptions_fixed += l2_dirty;
Max Reitze23e4002013-08-30 14:34:28 +02002071 }
Max Reitz4f6ed882013-08-30 14:34:27 +02002072 }
2073
2074 ret = 0;
2075
2076fail:
2077 qemu_vfree(l2_table);
2078 return ret;
2079}
2080
2081/*
Max Reitz6ca56bf2014-10-22 14:09:30 +02002082 * Checks consistency of refblocks and accounts for each refblock in
2083 * *refcount_table.
2084 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002085static int coroutine_fn GRAPH_RDLOCK
2086check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
2087 BdrvCheckMode fix, bool *rebuild,
2088 void **refcount_table, int64_t *nb_clusters)
Max Reitz6ca56bf2014-10-22 14:09:30 +02002089{
Kevin Wolfff991292015-09-07 17:12:56 +02002090 BDRVQcow2State *s = bs->opaque;
Max Reitz001c1582014-10-22 14:09:38 +02002091 int64_t i, size;
Max Reitzfef4d3d2014-10-22 14:09:35 +02002092 int ret;
Max Reitz6ca56bf2014-10-22 14:09:30 +02002093
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002094 for(i = 0; i < s->refcount_table_size; i++) {
Kevin Wolf6882c8f2010-06-22 12:31:45 +02002095 uint64_t offset, cluster;
Vladimir Sementsov-Ogievskiy8fba3952021-09-14 15:24:54 +03002096 offset = s->refcount_table[i] & REFT_OFFSET_MASK;
Kevin Wolf6882c8f2010-06-22 12:31:45 +02002097 cluster = offset >> s->cluster_bits;
Kevin Wolf746c3cb2010-02-23 16:40:54 +01002098
Vladimir Sementsov-Ogievskiy8fba3952021-09-14 15:24:54 +03002099 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
Kevin Wolf746c3cb2010-02-23 16:40:54 +01002107 /* Refcount blocks are cluster aligned */
Hu Taoac95acd2013-12-05 14:32:34 +08002108 if (offset_into_cluster(s, offset)) {
Kevin Wolf166acf52012-05-11 18:18:36 +02002109 fprintf(stderr, "ERROR refcount block %" PRId64 " is not "
Kevin Wolf746c3cb2010-02-23 16:40:54 +01002110 "cluster aligned; refcount table entry corrupted\n", i);
Kevin Wolf9ac228e2010-06-29 12:37:54 +02002111 res->corruptions++;
Max Reitzf307b252014-10-22 14:09:39 +02002112 *rebuild = true;
Kevin Wolf6882c8f2010-06-22 12:31:45 +02002113 continue;
2114 }
2115
Max Reitz6ca56bf2014-10-22 14:09:30 +02002116 if (cluster >= *nb_clusters) {
Vladimir Sementsov-Ogievskiy54b10012019-02-27 16:14:33 +03002117 res->corruptions++;
Max Reitz001c1582014-10-22 14:09:38 +02002118 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) {
Max Reitz5fee1922015-02-10 15:28:49 -05002122 int64_t new_nb_clusters;
Max Reitzed3d2ec2017-03-28 22:51:27 +02002123 Error *local_err = NULL;
Max Reitz001c1582014-10-22 14:09:38 +02002124
2125 if (offset > INT64_MAX - s->cluster_size) {
2126 ret = -EINVAL;
2127 goto resize_fail;
2128 }
2129
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002130 ret = bdrv_co_truncate(bs->file, offset + s->cluster_size, false,
2131 PREALLOC_MODE_OFF, 0, &local_err);
Max Reitz001c1582014-10-22 14:09:38 +02002132 if (ret < 0) {
Max Reitzed3d2ec2017-03-28 22:51:27 +02002133 error_report_err(local_err);
Max Reitz001c1582014-10-22 14:09:38 +02002134 goto resize_fail;
2135 }
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002136 size = bdrv_co_getlength(bs->file->bs);
Max Reitz001c1582014-10-22 14:09:38 +02002137 if (size < 0) {
2138 ret = size;
2139 goto resize_fail;
2140 }
2141
Max Reitz5fee1922015-02-10 15:28:49 -05002142 new_nb_clusters = size_to_clusters(s, size);
2143 assert(new_nb_clusters >= *nb_clusters);
Max Reitz001c1582014-10-22 14:09:38 +02002144
Max Reitz5fee1922015-02-10 15:28:49 -05002145 ret = realloc_refcount_array(s, refcount_table,
2146 nb_clusters, new_nb_clusters);
2147 if (ret < 0) {
Max Reitz001c1582014-10-22 14:09:38 +02002148 res->check_errors++;
Max Reitz5fee1922015-02-10 15:28:49 -05002149 return ret;
Max Reitz001c1582014-10-22 14:09:38 +02002150 }
Max Reitz001c1582014-10-22 14:09:38 +02002151
2152 if (cluster >= *nb_clusters) {
2153 ret = -EINVAL;
2154 goto resize_fail;
2155 }
2156
Vladimir Sementsov-Ogievskiy54b10012019-02-27 16:14:33 +03002157 res->corruptions--;
Max Reitz001c1582014-10-22 14:09:38 +02002158 res->corruptions_fixed++;
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03002159 ret = qcow2_inc_refcounts_imrt(bs, res,
2160 refcount_table, nb_clusters,
2161 offset, s->cluster_size);
Max Reitz001c1582014-10-22 14:09:38 +02002162 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
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03002167 * exactly 1 after qcow2_inc_refcounts_imrt() */
Max Reitz001c1582014-10-22 14:09:38 +02002168 continue;
2169
2170resize_fail:
Max Reitzf307b252014-10-22 14:09:39 +02002171 *rebuild = true;
Max Reitz001c1582014-10-22 14:09:38 +02002172 fprintf(stderr, "ERROR could not resize image: %s\n",
2173 strerror(-ret));
Max Reitz001c1582014-10-22 14:09:38 +02002174 }
Kevin Wolf6882c8f2010-06-22 12:31:45 +02002175 continue;
Kevin Wolf746c3cb2010-02-23 16:40:54 +01002176 }
2177
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002178 if (offset != 0) {
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03002179 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2180 offset, s->cluster_size);
Max Reitzfef4d3d2014-10-22 14:09:35 +02002181 if (ret < 0) {
2182 return ret;
2183 }
Max Reitz7453c962015-02-10 15:28:50 -05002184 if (s->get_refcount(*refcount_table, cluster) != 1) {
Max Reitzf307b252014-10-22 14:09:39 +02002185 fprintf(stderr, "ERROR refcount block %" PRId64
Max Reitz7453c962015-02-10 15:28:50 -05002186 " refcount=%" PRIu64 "\n", i,
2187 s->get_refcount(*refcount_table, cluster));
Max Reitzf307b252014-10-22 14:09:39 +02002188 res->corruptions++;
2189 *rebuild = true;
Kevin Wolf746c3cb2010-02-23 16:40:54 +01002190 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002191 }
2192 }
2193
Max Reitz6ca56bf2014-10-22 14:09:30 +02002194 return 0;
2195}
2196
2197/*
Max Reitz057a3fe2014-10-22 14:09:32 +02002198 * Calculates an in-memory refcount table.
2199 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002200static int coroutine_fn GRAPH_RDLOCK
2201calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
2202 BdrvCheckMode fix, bool *rebuild,
2203 void **refcount_table, int64_t *nb_clusters)
Max Reitz057a3fe2014-10-22 14:09:32 +02002204{
Kevin Wolfff991292015-09-07 17:12:56 +02002205 BDRVQcow2State *s = bs->opaque;
Max Reitz057a3fe2014-10-22 14:09:32 +02002206 int64_t i;
2207 QCowSnapshot *sn;
2208 int ret;
2209
Max Reitz9696df22014-10-22 14:09:37 +02002210 if (!*refcount_table) {
Max Reitz5fee1922015-02-10 15:28:49 -05002211 int64_t old_size = 0;
2212 ret = realloc_refcount_array(s, refcount_table,
2213 &old_size, *nb_clusters);
2214 if (ret < 0) {
Max Reitz9696df22014-10-22 14:09:37 +02002215 res->check_errors++;
Max Reitz5fee1922015-02-10 15:28:49 -05002216 return ret;
Max Reitz9696df22014-10-22 14:09:37 +02002217 }
Max Reitz057a3fe2014-10-22 14:09:32 +02002218 }
2219
2220 /* header */
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03002221 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2222 0, s->cluster_size);
Max Reitzfef4d3d2014-10-22 14:09:35 +02002223 if (ret < 0) {
2224 return ret;
2225 }
Max Reitz057a3fe2014-10-22 14:09:32 +02002226
2227 /* current L1 table */
Max Reitz641bb632014-10-22 14:09:36 +02002228 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
Max Reitzac5b7872017-11-10 21:37:59 +01002229 s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO,
Vladimir Sementsov-Ogievskiy1ef337b2019-02-27 16:14:31 +03002230 fix, true);
Max Reitz057a3fe2014-10-22 14:09:32 +02002231 if (ret < 0) {
2232 return ret;
2233 }
2234
2235 /* snapshots */
Kevin Wolfe9f5b6d2019-02-27 17:26:40 +01002236 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
Max Reitz057a3fe2014-10-22 14:09:32 +02002242 for (i = 0; i < s->nb_snapshots; i++) {
2243 sn = s->snapshots + i;
Alberto Garcia0c2ada82018-03-06 18:14:12 +02002244 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 }
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02002251 if (sn->l1_size > QCOW_MAX_L1_SIZE / L1E_SIZE) {
Alberto Garcia0c2ada82018-03-06 18:14:12 +02002252 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 }
Max Reitz641bb632014-10-22 14:09:36 +02002258 ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
Vladimir Sementsov-Ogievskiy1ef337b2019-02-27 16:14:31 +03002259 sn->l1_table_offset, sn->l1_size, 0, fix,
2260 false);
Max Reitz057a3fe2014-10-22 14:09:32 +02002261 if (ret < 0) {
2262 return ret;
2263 }
2264 }
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03002265 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2266 s->snapshots_offset, s->snapshots_size);
Max Reitzfef4d3d2014-10-22 14:09:35 +02002267 if (ret < 0) {
2268 return ret;
2269 }
Max Reitz057a3fe2014-10-22 14:09:32 +02002270
2271 /* refcount data */
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03002272 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2273 s->refcount_table_offset,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02002274 s->refcount_table_size *
2275 REFTABLE_ENTRY_SIZE);
Max Reitzfef4d3d2014-10-22 14:09:35 +02002276 if (ret < 0) {
2277 return ret;
2278 }
Max Reitz057a3fe2014-10-22 14:09:32 +02002279
Daniel P. Berrange4652b8f2017-06-23 17:24:12 +01002280 /* encryption */
2281 if (s->crypto_header.length) {
Vladimir Sementsov-Ogievskiy8a5bb1f2017-06-28 15:05:07 +03002282 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, nb_clusters,
2283 s->crypto_header.offset,
2284 s->crypto_header.length);
Daniel P. Berrange4652b8f2017-06-23 17:24:12 +01002285 if (ret < 0) {
2286 return ret;
2287 }
2288 }
2289
Vladimir Sementsov-Ogievskiy88ddffa2017-06-28 15:05:08 +03002290 /* bitmaps */
2291 ret = qcow2_check_bitmaps_refcounts(bs, res, refcount_table, nb_clusters);
2292 if (ret < 0) {
2293 return ret;
2294 }
2295
Max Reitzf307b252014-10-22 14:09:39 +02002296 return check_refblocks(bs, res, fix, rebuild, refcount_table, nb_clusters);
Max Reitz057a3fe2014-10-22 14:09:32 +02002297}
2298
2299/*
Max Reitz6ca56bf2014-10-22 14:09:30 +02002300 * Compares the actual reference count for each cluster in the image against the
2301 * refcount as reported by the refcount structures on-disk.
2302 */
Kevin Wolf0bb79c92023-09-29 16:51:49 +02002303static void coroutine_fn GRAPH_RDLOCK
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002304compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
2305 BdrvCheckMode fix, bool *rebuild,
2306 int64_t *highest_cluster,
2307 void *refcount_table, int64_t nb_clusters)
Max Reitz6ca56bf2014-10-22 14:09:30 +02002308{
Kevin Wolfff991292015-09-07 17:12:56 +02002309 BDRVQcow2State *s = bs->opaque;
Max Reitz6ca56bf2014-10-22 14:09:30 +02002310 int64_t i;
Max Reitz0e065282015-02-10 15:28:48 -05002311 uint64_t refcount1, refcount2;
Max Reitz7324c102015-02-10 15:28:46 -05002312 int ret;
Max Reitz6ca56bf2014-10-22 14:09:30 +02002313
2314 for (i = 0, *highest_cluster = 0; i < nb_clusters; i++) {
Max Reitz7324c102015-02-10 15:28:46 -05002315 ret = qcow2_get_refcount(bs, i, &refcount1);
2316 if (ret < 0) {
Kevin Wolf166acf52012-05-11 18:18:36 +02002317 fprintf(stderr, "Can't get refcount for cluster %" PRId64 ": %s\n",
Max Reitz7324c102015-02-10 15:28:46 -05002318 i, strerror(-ret));
Kevin Wolf9ac228e2010-06-29 12:37:54 +02002319 res->check_errors++;
Kevin Wolff74550f2010-06-22 12:35:07 +02002320 continue;
Kevin Wolf018faaf2010-06-04 11:16:11 +02002321 }
2322
Max Reitz7453c962015-02-10 15:28:50 -05002323 refcount2 = s->get_refcount(refcount_table, i);
Federico Simoncellic6bb9ad2013-01-28 06:59:46 -05002324
2325 if (refcount1 > 0 || refcount2 > 0) {
Max Reitz6ca56bf2014-10-22 14:09:30 +02002326 *highest_cluster = i;
Federico Simoncellic6bb9ad2013-01-28 06:59:46 -05002327 }
2328
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002329 if (refcount1 != refcount2) {
Kevin Wolf166acf52012-05-11 18:18:36 +02002330 /* Check if we're allowed to fix the mismatch */
2331 int *num_fixed = NULL;
Max Reitzf307b252014-10-22 14:09:39 +02002332 if (refcount1 == 0) {
2333 *rebuild = true;
2334 } else if (refcount1 > refcount2 && (fix & BDRV_FIX_LEAKS)) {
Kevin Wolf166acf52012-05-11 18:18:36 +02002335 num_fixed = &res->leaks_fixed;
2336 } else if (refcount1 < refcount2 && (fix & BDRV_FIX_ERRORS)) {
2337 num_fixed = &res->corruptions_fixed;
2338 }
2339
Max Reitz0e065282015-02-10 15:28:48 -05002340 fprintf(stderr, "%s cluster %" PRId64 " refcount=%" PRIu64
2341 " reference=%" PRIu64 "\n",
Kevin Wolf166acf52012-05-11 18:18:36 +02002342 num_fixed != NULL ? "Repairing" :
2343 refcount1 < refcount2 ? "ERROR" :
2344 "Leaked",
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002345 i, refcount1, refcount2);
Kevin Wolf166acf52012-05-11 18:18:36 +02002346
2347 if (num_fixed) {
2348 ret = update_refcount(bs, i << s->cluster_bits, 1,
Max Reitz2aabe7c2015-02-10 15:28:47 -05002349 refcount_diff(refcount1, refcount2),
2350 refcount1 > refcount2,
Kevin Wolf6cfcb9b2013-06-19 13:44:18 +02002351 QCOW2_DISCARD_ALWAYS);
Kevin Wolf166acf52012-05-11 18:18:36 +02002352 if (ret >= 0) {
2353 (*num_fixed)++;
2354 continue;
2355 }
2356 }
2357
2358 /* And if we couldn't, print an error */
Kevin Wolf9ac228e2010-06-29 12:37:54 +02002359 if (refcount1 < refcount2) {
2360 res->corruptions++;
2361 } else {
2362 res->leaks++;
2363 }
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002364 }
2365 }
Max Reitz6ca56bf2014-10-22 14:09:30 +02002366}
2367
2368/*
Max Reitzc7c06812014-10-22 14:09:40 +02002369 * 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,
Max Reitz7453c962015-02-10 15:28:50 -05002382 void **refcount_table,
Max Reitzc7c06812014-10-22 14:09:40 +02002383 int64_t *imrt_nb_clusters,
2384 int64_t *first_free_cluster)
2385{
Kevin Wolfff991292015-09-07 17:12:56 +02002386 BDRVQcow2State *s = bs->opaque;
Max Reitzc7c06812014-10-22 14:09:40 +02002387 int64_t cluster = *first_free_cluster, i;
2388 bool first_gap = true;
2389 int contiguous_free_clusters;
Max Reitz5fee1922015-02-10 15:28:49 -05002390 int ret;
Max Reitzc7c06812014-10-22 14:09:40 +02002391
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 {
Max Reitz7453c962015-02-10 15:28:50 -05002399 if (!s->get_refcount(*refcount_table, cluster)) {
Max Reitzc7c06812014-10-22 14:09:40 +02002400 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) {
Max Reitzc7c06812014-10-22 14:09:40 +02002420 /* 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) */
Max Reitz5fee1922015-02-10 15:28:49 -05002426 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;
Max Reitzc7c06812014-10-22 14:09:40 +02002431 }
Max Reitzc7c06812014-10-22 14:09:40 +02002432 }
2433
2434 /* Go back to the first free cluster */
2435 cluster -= contiguous_free_clusters;
2436 for (i = 0; i < cluster_count; i++) {
Max Reitz7453c962015-02-10 15:28:50 -05002437 s->set_refcount(*refcount_table, cluster + i, 1);
Max Reitzc7c06812014-10-22 14:09:40 +02002438 }
2439
2440 return cluster << s->cluster_bits;
2441}
2442
2443/*
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002444 * Helper function for rebuild_refcount_structure().
2445 *
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.
2467 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002468static int coroutine_fn GRAPH_RDLOCK
2469rebuild_refcounts_write_refblocks(
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002470 BlockDriverState *bs, void **refcount_table, int64_t *nb_clusters,
2471 int64_t first_cluster, int64_t end_cluster,
Hanna Reitz0423f752022-04-05 15:46:52 +02002472 uint64_t **on_disk_reftable_ptr, uint32_t *on_disk_reftable_entries_ptr,
2473 Error **errp
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002474 )
2475{
2476 BDRVQcow2State *s = bs->opaque;
2477 int64_t cluster;
2478 int64_t refblock_offset, refblock_start, refblock_index;
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;
2482 void *on_disk_refblock;
2483 bool reftable_grown = false;
2484 int ret;
2485
2486 for (cluster = first_cluster; cluster < end_cluster; cluster++) {
2487 /* Check all clusters to find refblocks that contain non-zero entries */
2488 if (!s->get_refcount(*refcount_table, cluster)) {
2489 continue;
2490 }
2491
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
2501 refblock_index = cluster >> s->refcount_block_bits;
2502 refblock_start = refblock_index << s->refcount_block_bits;
2503
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;
2515
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) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002524 error_setg_errno(errp, -refblock_offset,
2525 "ERROR allocating refblock");
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002526 return refblock_offset;
2527 }
2528
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;
2536 }
2537
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) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002547 error_setg(errp, "ERROR allocating reftable memory");
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002548 return -ENOMEM;
2549 }
2550
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);
2555
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);
2562 }
2563 on_disk_reftable[refblock_index] = refblock_offset;
2564 }
2565
2566 /* Refblock is allocated, write it to disk */
2567
2568 ret = qcow2_pre_write_overlap_check(bs, 0, refblock_offset,
2569 s->cluster_size, false);
2570 if (ret < 0) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002571 error_setg_errno(errp, -ret, "ERROR writing refblock");
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002572 return ret;
2573 }
2574
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 */
2581 on_disk_refblock = (void *)((char *) *refcount_table +
2582 refblock_index * s->cluster_size);
2583
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002584 ret = bdrv_co_pwrite(bs->file, refblock_offset, s->cluster_size,
2585 on_disk_refblock, 0);
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002586 if (ret < 0) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002587 error_setg_errno(errp, -ret, "ERROR writing refblock");
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002588 return ret;
2589 }
2590
2591 /* This refblock is done, skip to its end */
2592 cluster = refblock_start + s->refcount_block_size - 1;
2593 }
2594
2595 return reftable_grown;
2596}
2597
2598/*
Max Reitzc7c06812014-10-22 14:09:40 +02002599 * Creates a new refcount structure based solely on the in-memory information
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002600 * 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.
Max Reitzc7c06812014-10-22 14:09:40 +02002603 *
2604 * On success, the old refcount structure is leaked (it will be covered by the
2605 * new refcount structure).
2606 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002607static int coroutine_fn GRAPH_RDLOCK
2608rebuild_refcount_structure(BlockDriverState *bs, BdrvCheckResult *res,
2609 void **refcount_table, int64_t *nb_clusters,
2610 Error **errp)
Max Reitzc7c06812014-10-22 14:09:40 +02002611{
Kevin Wolfff991292015-09-07 17:12:56 +02002612 BDRVQcow2State *s = bs->opaque;
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002613 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;
Max Reitzc7c06812014-10-22 14:09:40 +02002618 uint64_t *on_disk_reftable = NULL;
Max Reitz7453c962015-02-10 15:28:50 -05002619 int ret = 0;
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002620 int reftable_size_changed = 0;
Max Reitzc7c06812014-10-22 14:09:40 +02002621 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
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002628 /*
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
Michael Tokarev3202d8e2023-07-14 14:06:05 +03002646 * reftable grows, it can accommodate a multitude of more refcounts,
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002647 * 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 */
Max Reitzc7c06812014-10-22 14:09:40 +02002656
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002657 reftable_size_changed =
2658 rebuild_refcounts_write_refblocks(bs, refcount_table, nb_clusters,
2659 0, *nb_clusters,
2660 &on_disk_reftable,
Hanna Reitz0423f752022-04-05 15:46:52 +02002661 &on_disk_reftable_entries, errp);
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002662 if (reftable_size_changed < 0) {
2663 res->check_errors++;
2664 ret = reftable_size_changed;
2665 goto fail;
Max Reitzc7c06812014-10-22 14:09:40 +02002666 }
2667
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002668 /*
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);
Max Reitzc7c06812014-10-22 14:09:40 +02002673
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002674 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);
2680
Max Reitzc7c06812014-10-22 14:09:40 +02002681 reftable_offset = alloc_clusters_imrt(bs, reftable_clusters,
2682 refcount_table, nb_clusters,
2683 &first_free_cluster);
2684 if (reftable_offset < 0) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002685 error_setg_errno(errp, -reftable_offset,
2686 "ERROR allocating reftable");
Max Reitzc7c06812014-10-22 14:09:40 +02002687 res->check_errors++;
2688 ret = reftable_offset;
2689 goto fail;
2690 }
2691
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002692 /*
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,
Hanna Reitz0423f752022-04-05 15:46:52 +02002704 &on_disk_reftable_entries, errp);
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002705 if (reftable_size_changed < 0) {
2706 res->check_errors++;
2707 ret = reftable_size_changed;
2708 goto fail;
2709 }
Max Reitzc7c06812014-10-22 14:09:40 +02002710
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002711 /*
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);
2716
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 {
Max Reitzc7c06812014-10-22 14:09:40 +02002728 cpu_to_be64s(&on_disk_reftable[refblock_index]);
2729 }
2730
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002731 ret = qcow2_pre_write_overlap_check(bs, 0, reftable_offset, reftable_length,
Kevin Wolf966b0002019-01-15 20:39:06 +01002732 false);
Max Reitzc7c06812014-10-22 14:09:40 +02002733 if (ret < 0) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002734 error_setg_errno(errp, -ret, "ERROR writing reftable");
Max Reitzc7c06812014-10-22 14:09:40 +02002735 goto fail;
2736 }
2737
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002738 assert(reftable_length < INT_MAX);
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002739 ret = bdrv_co_pwrite(bs->file, reftable_offset, reftable_length,
2740 on_disk_reftable, 0);
Max Reitzc7c06812014-10-22 14:09:40 +02002741 if (ret < 0) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002742 error_setg_errno(errp, -ret, "ERROR writing reftable");
Max Reitzc7c06812014-10-22 14:09:40 +02002743 goto fail;
2744 }
2745
2746 /* Enter new reftable into the image header */
Peter Maydellf1f7a1d2016-06-16 17:06:17 +01002747 reftable_offset_and_clusters.reftable_offset = cpu_to_be64(reftable_offset);
2748 reftable_offset_and_clusters.reftable_clusters =
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002749 cpu_to_be32(reftable_clusters);
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002750 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);
Max Reitzc7c06812014-10-22 14:09:40 +02002754 if (ret < 0) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002755 error_setg_errno(errp, -ret, "ERROR setting reftable");
Max Reitzc7c06812014-10-22 14:09:40 +02002756 goto fail;
2757 }
2758
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002759 for (refblock_index = 0; refblock_index < on_disk_reftable_entries;
2760 refblock_index++)
2761 {
Max Reitzc7c06812014-10-22 14:09:40 +02002762 be64_to_cpus(&on_disk_reftable[refblock_index]);
2763 }
2764 s->refcount_table = on_disk_reftable;
2765 s->refcount_table_offset = reftable_offset;
Hanna Reitza8c07ec2022-04-05 15:46:50 +02002766 s->refcount_table_size = on_disk_reftable_entries;
Alberto Garcia7061a072017-02-01 14:38:28 +02002767 update_max_refcount_table_index(s);
Max Reitzc7c06812014-10-22 14:09:40 +02002768
2769 return 0;
2770
2771fail:
2772 g_free(on_disk_reftable);
2773 return ret;
2774}
2775
2776/*
Max Reitz6ca56bf2014-10-22 14:09:30 +02002777 * 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 */
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002782int coroutine_fn GRAPH_RDLOCK
2783qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
Max Reitz6ca56bf2014-10-22 14:09:30 +02002784{
Kevin Wolfff991292015-09-07 17:12:56 +02002785 BDRVQcow2State *s = bs->opaque;
Max Reitzc7c06812014-10-22 14:09:40 +02002786 BdrvCheckResult pre_compare_res;
Max Reitz6ca56bf2014-10-22 14:09:30 +02002787 int64_t size, highest_cluster, nb_clusters;
Max Reitz7453c962015-02-10 15:28:50 -05002788 void *refcount_table = NULL;
Max Reitzf307b252014-10-22 14:09:39 +02002789 bool rebuild = false;
Max Reitz6ca56bf2014-10-22 14:09:30 +02002790 int ret;
2791
Paolo Bonzini70bacc42023-06-01 13:51:43 +02002792 size = bdrv_co_getlength(bs->file->bs);
Max Reitz6ca56bf2014-10-22 14:09:30 +02002793 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
Max Reitzf307b252014-10-22 14:09:39 +02002807 ret = calculate_refcounts(bs, res, fix, &rebuild, &refcount_table,
2808 &nb_clusters);
Max Reitz6ca56bf2014-10-22 14:09:30 +02002809 if (ret < 0) {
2810 goto fail;
2811 }
2812
Max Reitzc7c06812014-10-22 14:09:40 +02002813 /* 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,
Max Reitz6ca56bf2014-10-22 14:09:30 +02002818 nb_clusters);
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002819
Max Reitzc7c06812014-10-22 14:09:40 +02002820 if (rebuild && (fix & BDRV_FIX_ERRORS)) {
Max Reitz791230d2014-10-22 14:09:41 +02002821 BdrvCheckResult old_res = *res;
2822 int fresh_leaks = 0;
Hanna Reitz0423f752022-04-05 15:46:52 +02002823 Error *local_err = NULL;
Max Reitz791230d2014-10-22 14:09:41 +02002824
Max Reitzc7c06812014-10-22 14:09:40 +02002825 fprintf(stderr, "Rebuilding refcount structure\n");
2826 ret = rebuild_refcount_structure(bs, res, &refcount_table,
Hanna Reitz0423f752022-04-05 15:46:52 +02002827 &nb_clusters, &local_err);
Max Reitzc7c06812014-10-22 14:09:40 +02002828 if (ret < 0) {
Hanna Reitz0423f752022-04-05 15:46:52 +02002829 error_report_err(local_err);
Max Reitzc7c06812014-10-22 14:09:40 +02002830 goto fail;
2831 }
Max Reitz791230d2014-10-22 14:09:41 +02002832
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;
Max Reitz7453c962015-02-10 15:28:50 -05002839 memset(refcount_table, 0, refcount_array_byte_size(s, nb_clusters));
Max Reitz791230d2014-10-22 14:09:41 +02002840 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;
Max Reitzc7c06812014-10-22 14:09:40 +02002874 } 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 }
Max Reitzf307b252014-10-22 14:09:39 +02002887 }
2888
Max Reitz4f6ed882013-08-30 14:34:27 +02002889 /* check OFLAG_COPIED */
Max Reitze23e4002013-08-30 14:34:28 +02002890 ret = check_oflag_copied(bs, res, fix);
Max Reitz4f6ed882013-08-30 14:34:27 +02002891 if (ret < 0) {
2892 goto fail;
2893 }
2894
Federico Simoncellic6bb9ad2013-01-28 06:59:46 -05002895 res->image_end_offset = (highest_cluster + 1) * s->cluster_size;
Kevin Wolf80fa3342011-06-01 10:50:00 +02002896 ret = 0;
2897
2898fail:
Anthony Liguori7267c092011-08-20 22:09:37 -05002899 g_free(refcount_table);
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002900
Kevin Wolf80fa3342011-06-01 10:50:00 +02002901 return ret;
Kevin Wolff7d0fe02009-05-28 16:07:04 +02002902}
2903
Max Reitza40f1c22013-08-30 14:34:25 +02002904#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 *
Max Reitz231bb262013-10-10 11:09:23 +02002912 * The ign parameter specifies what checks not to perform (being a bitmask of
2913 * QCow2MetadataOverlap values), i.e., what sections to ignore.
Max Reitza40f1c22013-08-30 14:34:25 +02002914 *
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,
Eric Blakef4649062020-04-28 16:38:07 -05002919 * e.g. when bdrv_pread failed on QCOW2_OL_INACTIVE_L2
Max Reitza40f1c22013-08-30 14:34:25 +02002920 */
Max Reitz231bb262013-10-10 11:09:23 +02002921int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
Max Reitza40f1c22013-08-30 14:34:25 +02002922 int64_t size)
2923{
Kevin Wolfff991292015-09-07 17:12:56 +02002924 BDRVQcow2State *s = bs->opaque;
Max Reitz3e355392013-10-10 11:09:24 +02002925 int chk = s->overlap_check & ~ign;
Max Reitza40f1c22013-08-30 14:34:25 +02002926 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 */
Alberto Garcia9e029682018-02-15 15:10:08 +02002939 size = ROUND_UP(offset_into_cluster(s, offset) + size, s->cluster_size);
Max Reitza40f1c22013-08-30 14:34:25 +02002940 offset = start_of_cluster(s, offset);
2941
2942 if ((chk & QCOW2_OL_ACTIVE_L1) && s->l1_size) {
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02002943 if (overlaps_with(s->l1_table_offset, s->l1_size * L1E_SIZE)) {
Max Reitza40f1c22013-08-30 14:34:25 +02002944 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,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02002950 s->refcount_table_size * REFTABLE_ENTRY_SIZE)) {
Max Reitza40f1c22013-08-30 14:34:25 +02002951 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,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02002965 s->snapshots[i].l1_size * L1E_SIZE)) {
Max Reitza40f1c22013-08-30 14:34:25 +02002966 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) {
Alberto Garcia7061a072017-02-01 14:38:28 +02002982 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++) {
Max Reitza40f1c22013-08-30 14:34:25 +02002987 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;
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02002999 uint64_t l1_sz2 = l1_sz * L1E_SIZE;
Alberto Garciac7a9d812018-03-06 18:14:09 +02003000 uint64_t *l1;
Max Reitza40f1c22013-08-30 14:34:25 +02003001 int ret;
3002
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003003 ret = qcow2_validate_table(bs, l1_ofs, l1_sz, L1E_SIZE,
Alberto Garciac7a9d812018-03-06 18:14:09 +02003004 QCOW_MAX_L1_SIZE, "", NULL);
3005 if (ret < 0) {
3006 return ret;
3007 }
3008
3009 l1 = g_try_malloc(l1_sz2);
3010
Kevin Wolfde828152014-05-20 17:12:47 +02003011 if (l1_sz2 && l1 == NULL) {
3012 return -ENOMEM;
3013 }
3014
Alberto Faria32cc71d2022-06-09 16:27:36 +01003015 ret = bdrv_pread(bs->file, l1_ofs, l1_sz2, l1, 0);
Max Reitza40f1c22013-08-30 14:34:25 +02003016 if (ret < 0) {
3017 g_free(l1);
3018 return ret;
3019 }
3020
3021 for (j = 0; j < l1_sz; j++) {
Max Reitz1e242b52013-09-30 08:59:28 +02003022 uint64_t l2_ofs = be64_to_cpu(l1[j]) & L1E_OFFSET_MASK;
3023 if (l2_ofs && overlaps_with(l2_ofs, s->cluster_size)) {
Max Reitza40f1c22013-08-30 14:34:25 +02003024 g_free(l1);
3025 return QCOW2_OL_INACTIVE_L2;
3026 }
3027 }
3028
3029 g_free(l1);
3030 }
3031 }
3032
Vladimir Sementsov-Ogievskiy0e4e4312018-07-05 18:15:15 +03003033 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
Max Reitza40f1c22013-08-30 14:34:25 +02003043 return 0;
3044}
3045
3046static const char *metadata_ol_names[] = {
Liam Merwick7cb6d3c2018-11-05 21:38:39 +00003047 [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",
Max Reitza40f1c22013-08-30 14:34:25 +02003056};
Liam Merwick7cb6d3c2018-11-05 21:38:39 +00003057QEMU_BUILD_BUG_ON(QCOW2_OL_MAX_BITNR != ARRAY_SIZE(metadata_ol_names));
Max Reitza40f1c22013-08-30 14:34:25 +02003058
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 */
Max Reitz231bb262013-10-10 11:09:23 +02003069int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
Kevin Wolf966b0002019-01-15 20:39:06 +01003070 int64_t size, bool data_file)
Max Reitza40f1c22013-08-30 14:34:25 +02003071{
Kevin Wolf966b0002019-01-15 20:39:06 +01003072 int ret;
Max Reitza40f1c22013-08-30 14:34:25 +02003073
Kevin Wolf966b0002019-01-15 20:39:06 +01003074 if (data_file && has_data_file(bs)) {
3075 return 0;
3076 }
3077
3078 ret = qcow2_check_metadata_overlap(bs, ign, offset, size);
Max Reitza40f1c22013-08-30 14:34:25 +02003079 if (ret < 0) {
3080 return ret;
3081 } else if (ret > 0) {
Stefan Hajnoczi786a4ea2015-03-23 15:29:26 +00003082 int metadata_ol_bitnr = ctz32(ret);
Max Reitza40f1c22013-08-30 14:34:25 +02003083 assert(metadata_ol_bitnr < QCOW2_OL_MAX_BITNR);
3084
Max Reitzadb43552014-09-05 16:07:17 +02003085 qcow2_signal_corruption(bs, true, offset, size, "Preventing invalid "
3086 "write on metadata (overlaps with %s)",
3087 metadata_ol_names[metadata_ol_bitnr]);
Max Reitza40f1c22013-08-30 14:34:25 +02003088 return -EIO;
3089 }
3090
3091 return 0;
3092}
Max Reitz791c9a02015-07-27 17:51:37 +02003093
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 */
Kevin Wolf0bb79c92023-09-29 16:51:49 +02003104typedef 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);
Max Reitz791c9a02015-07-27 17:51:37 +02003109
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 */
Kevin Wolf0bb79c92023-09-29 16:51:49 +02003115static 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)
Max Reitz791c9a02015-07-27 17:51:37 +02003120{
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,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003129 s->cluster_size / REFTABLE_ENTRY_SIZE);
3130 if (new_reftable_size > QCOW_MAX_REFTABLE_SIZE / REFTABLE_ENTRY_SIZE) {
Max Reitz791c9a02015-07-27 17:51:37 +02003131 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 *
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003138 REFTABLE_ENTRY_SIZE);
Max Reitz791c9a02015-07-27 17:51:37 +02003139 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,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003145 (new_reftable_size - *reftable_size) * REFTABLE_ENTRY_SIZE);
Max Reitz791c9a02015-07-27 17:51:37 +02003146
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 */
Kevin Wolf0bb79c92023-09-29 16:51:49 +02003169static 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)
Max Reitz791c9a02015-07-27 17:51:37 +02003174{
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
Kevin Wolf966b0002019-01-15 20:39:06 +01003182 ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size,
3183 false);
Max Reitz791c9a02015-07-27 17:51:37 +02003184 if (ret < 0) {
3185 error_setg_errno(errp, -ret, "Overlap check failed");
3186 return ret;
3187 }
3188
Alberto Faria32cc71d2022-06-09 16:27:36 +01003189 ret = bdrv_pwrite(bs->file, offset, s->cluster_size, refblock, 0);
Max Reitz791c9a02015-07-27 17:51:37 +02003190 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 */
Kevin Wolf0bb79c92023-09-29 16:51:49 +02003214static 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)
Max Reitz791c9a02015-07-27 17:51:37 +02003225{
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) {
Alberto Garcia2013c3d2018-02-05 16:33:07 +02003273 qcow2_cache_put(s->refcount_block_cache, &refblock);
Max Reitz791c9a02015-07-27 17:51:37 +02003274 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
Alberto Garcia2013c3d2018-02-05 16:33:07 +02003286 qcow2_cache_put(s->refcount_block_cache, &refblock);
Max Reitz791c9a02015-07-27 17:51:37 +02003287
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
Alberto Garcia2013c3d2018-02-05 16:33:07 +02003307 qcow2_cache_put(s->refcount_block_cache, &refblock);
Max Reitz791c9a02015-07-27 17:51:37 +02003308 } 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) {
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003418 qcow2_free_clusters(
3419 bs, new_reftable_offset,
3420 allocated_reftable_size * REFTABLE_ENTRY_SIZE,
3421 QCOW2_DISCARD_NEVER);
Max Reitz791c9a02015-07-27 17:51:37 +02003422 }
3423
3424 new_reftable_offset = qcow2_alloc_clusters(bs, new_reftable_size *
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003425 REFTABLE_ENTRY_SIZE);
Max Reitz791c9a02015-07-27 17:51:37 +02003426 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,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003451 new_reftable_size * REFTABLE_ENTRY_SIZE,
Kevin Wolf966b0002019-01-15 20:39:06 +01003452 false);
Max Reitz791c9a02015-07-27 17:51:37 +02003453 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
Alberto Faria32cc71d2022-06-09 16:27:36 +01003462 ret = bdrv_pwrite(bs->file, new_reftable_offset,
3463 new_reftable_size * REFTABLE_ENTRY_SIZE, new_reftable,
3464 0);
Max Reitz791c9a02015-07-27 17:51:37 +02003465
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;
Alberto Garcia7061a072017-02-01 14:38:28 +02003507 update_max_refcount_table_index(s);
Max Reitz791c9a02015-07-27 17:51:37 +02003508
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,
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003541 new_reftable_size * REFTABLE_ENTRY_SIZE,
Max Reitz791c9a02015-07-27 17:51:37 +02003542 QCOW2_DISCARD_OTHER);
3543 }
3544 }
3545
3546 qemu_vfree(new_refblock);
3547 return ret;
3548}
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003549
Kevin Wolf0bb79c92023-09-29 16:51:49 +02003550static int64_t coroutine_fn GRAPH_RDLOCK
3551get_refblock_offset(BlockDriverState *bs, uint64_t offset)
Max Reitz23482f82017-11-10 21:31:10 +01003552{
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
Kevin Wolf0bb79c92023-09-29 16:51:49 +02003570static int coroutine_fn GRAPH_RDLOCK
Paolo Bonzinia1b4ecf2022-10-13 14:36:59 +02003571qcow2_discard_refcount_block(BlockDriverState *bs, uint64_t discard_block_offs)
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003572{
3573 BDRVQcow2State *s = bs->opaque;
Max Reitz23482f82017-11-10 21:31:10 +01003574 int64_t refblock_offs;
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003575 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
Max Reitz23482f82017-11-10 21:31:10 +01003580 refblock_offs = get_refblock_offset(bs, discard_block_offs);
3581 if (refblock_offs < 0) {
3582 return refblock_offs;
3583 }
3584
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003585 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));
Alberto Garcia2013c3d2018-02-05 16:33:07 +02003603 qcow2_cache_put(s->refcount_block_cache, &refblock);
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003604 return -EINVAL;
3605 }
3606 s->set_refcount(refblock, block_index, 0);
3607
Alberto Garcia2d135ee2018-02-05 16:33:06 +02003608 qcow2_cache_entry_mark_dirty(s->refcount_block_cache, refblock);
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003609
Alberto Garcia2013c3d2018-02-05 16:33:07 +02003610 qcow2_cache_put(s->refcount_block_cache, &refblock);
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003611
3612 if (cluster_index < s->free_cluster_index) {
3613 s->free_cluster_index = cluster_index;
3614 }
3615
Alberto Garcia6e6fa762018-02-05 16:33:11 +02003616 refblock = qcow2_cache_is_table_offset(s->refcount_block_cache,
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003617 discard_block_offs);
3618 if (refblock) {
3619 /* discard refblock from the cache if refblock is cached */
Alberto Garcia77aadd72018-02-05 16:33:10 +02003620 qcow2_cache_discard(s->refcount_block_cache, refblock);
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003621 }
3622 update_refcount_discard(bs, discard_block_offs, s->cluster_size);
3623
3624 return 0;
3625}
3626
Paolo Bonzinia1b4ecf2022-10-13 14:36:59 +02003627int coroutine_fn qcow2_shrink_reftable(BlockDriverState *bs)
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003628{
3629 BDRVQcow2State *s = bs->opaque;
3630 uint64_t *reftable_tmp =
Alberto Garcia02b1ecf2020-08-28 13:08:28 +02003631 g_malloc(s->refcount_table_size * REFTABLE_ENTRY_SIZE);
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003632 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 }
Alberto Garcia2013c3d2018-02-05 16:33:07 +02003663 qcow2_cache_put(s->refcount_block_cache, &refblock);
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003664
3665 reftable_tmp[i] = unused_block ? 0 : cpu_to_be64(s->refcount_table[i]);
3666 }
3667
Alberto Faria38505e22022-10-13 14:37:06 +02003668 ret = bdrv_co_pwrite_sync(bs->file, s->refcount_table_offset,
3669 s->refcount_table_size * REFTABLE_ENTRY_SIZE,
3670 reftable_tmp, 0);
Pavel Butsykin46b732c2017-09-18 15:42:29 +03003671 /*
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}
Pavel Butsykin163bc392017-09-29 15:16:13 +03003694
Paolo Bonzinia39bae42023-03-09 09:44:55 +01003695int64_t coroutine_fn qcow2_get_last_cluster(BlockDriverState *bs, int64_t size)
Pavel Butsykin163bc392017-09-29 15:16:13 +03003696{
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}
Vladimir Sementsov-Ogievskiy69f47502019-04-08 19:26:17 +03003716
Paolo Bonzini70bacc42023-06-01 13:51:43 +02003717int coroutine_fn GRAPH_RDLOCK
3718qcow2_detect_metadata_preallocation(BlockDriverState *bs)
Vladimir Sementsov-Ogievskiy69f47502019-04-08 19:26:17 +03003719{
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
Kevin Wolf5e978552019-10-24 16:26:58 +02003724 qemu_co_mutex_assert_locked(&s->lock);
3725
Kevin Wolf0050c162023-05-04 13:57:31 +02003726 file_length = bdrv_co_getlength(bs->file->bs);
Vladimir Sementsov-Ogievskiy69f47502019-04-08 19:26:17 +03003727 if (file_length < 0) {
3728 return file_length;
3729 }
3730
Emanuele Giuseppe Esposito82618d72023-01-13 21:42:07 +01003731 real_allocation = bdrv_co_get_allocated_file_size(bs->file->bs);
Vladimir Sementsov-Ogievskiy69f47502019-04-08 19:26:17 +03003732 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}