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