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 <zlib.h> 27 28 #include "qapi/error.h" 29 #include "qemu-common.h" 30 #include "block/block_int.h" 31 #include "block/qcow2.h" 32 #include "qemu/bswap.h" 33 #include "trace.h" 34 35 int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size, 36 bool exact_size) 37 { 38 BDRVQcow2State *s = bs->opaque; 39 int new_l1_size2, ret, i; 40 uint64_t *new_l1_table; 41 int64_t old_l1_table_offset, old_l1_size; 42 int64_t new_l1_table_offset, new_l1_size; 43 uint8_t data[12]; 44 45 if (min_size <= s->l1_size) 46 return 0; 47 48 /* Do a sanity check on min_size before trying to calculate new_l1_size 49 * (this prevents overflows during the while loop for the calculation of 50 * new_l1_size) */ 51 if (min_size > INT_MAX / sizeof(uint64_t)) { 52 return -EFBIG; 53 } 54 55 if (exact_size) { 56 new_l1_size = min_size; 57 } else { 58 /* Bump size up to reduce the number of times we have to grow */ 59 new_l1_size = s->l1_size; 60 if (new_l1_size == 0) { 61 new_l1_size = 1; 62 } 63 while (min_size > new_l1_size) { 64 new_l1_size = (new_l1_size * 3 + 1) / 2; 65 } 66 } 67 68 QEMU_BUILD_BUG_ON(QCOW_MAX_L1_SIZE > INT_MAX); 69 if (new_l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) { 70 return -EFBIG; 71 } 72 73 #ifdef DEBUG_ALLOC2 74 fprintf(stderr, "grow l1_table from %d to %" PRId64 "\n", 75 s->l1_size, new_l1_size); 76 #endif 77 78 new_l1_size2 = sizeof(uint64_t) * new_l1_size; 79 new_l1_table = qemu_try_blockalign(bs->file->bs, 80 align_offset(new_l1_size2, 512)); 81 if (new_l1_table == NULL) { 82 return -ENOMEM; 83 } 84 memset(new_l1_table, 0, align_offset(new_l1_size2, 512)); 85 86 memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t)); 87 88 /* write new table (align to cluster) */ 89 BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ALLOC_TABLE); 90 new_l1_table_offset = qcow2_alloc_clusters(bs, new_l1_size2); 91 if (new_l1_table_offset < 0) { 92 qemu_vfree(new_l1_table); 93 return new_l1_table_offset; 94 } 95 96 ret = qcow2_cache_flush(bs, s->refcount_block_cache); 97 if (ret < 0) { 98 goto fail; 99 } 100 101 /* the L1 position has not yet been updated, so these clusters must 102 * indeed be completely free */ 103 ret = qcow2_pre_write_overlap_check(bs, 0, new_l1_table_offset, 104 new_l1_size2); 105 if (ret < 0) { 106 goto fail; 107 } 108 109 BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE); 110 for(i = 0; i < s->l1_size; i++) 111 new_l1_table[i] = cpu_to_be64(new_l1_table[i]); 112 ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, 113 new_l1_table, new_l1_size2); 114 if (ret < 0) 115 goto fail; 116 for(i = 0; i < s->l1_size; i++) 117 new_l1_table[i] = be64_to_cpu(new_l1_table[i]); 118 119 /* set new table */ 120 BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE); 121 stl_be_p(data, new_l1_size); 122 stq_be_p(data + 4, new_l1_table_offset); 123 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size), 124 data, sizeof(data)); 125 if (ret < 0) { 126 goto fail; 127 } 128 qemu_vfree(s->l1_table); 129 old_l1_table_offset = s->l1_table_offset; 130 s->l1_table_offset = new_l1_table_offset; 131 s->l1_table = new_l1_table; 132 old_l1_size = s->l1_size; 133 s->l1_size = new_l1_size; 134 qcow2_free_clusters(bs, old_l1_table_offset, old_l1_size * sizeof(uint64_t), 135 QCOW2_DISCARD_OTHER); 136 return 0; 137 fail: 138 qemu_vfree(new_l1_table); 139 qcow2_free_clusters(bs, new_l1_table_offset, new_l1_size2, 140 QCOW2_DISCARD_OTHER); 141 return ret; 142 } 143 144 /* 145 * l2_load 146 * 147 * Loads a L2 table into memory. If the table is in the cache, the cache 148 * is used; otherwise the L2 table is loaded from the image file. 149 * 150 * Returns a pointer to the L2 table on success, or NULL if the read from 151 * the image file failed. 152 */ 153 154 static int l2_load(BlockDriverState *bs, uint64_t l2_offset, 155 uint64_t **l2_table) 156 { 157 BDRVQcow2State *s = bs->opaque; 158 159 return qcow2_cache_get(bs, s->l2_table_cache, l2_offset, 160 (void **)l2_table); 161 } 162 163 /* 164 * Writes one sector of the L1 table to the disk (can't update single entries 165 * and we really don't want bdrv_pread to perform a read-modify-write) 166 */ 167 #define L1_ENTRIES_PER_SECTOR (512 / 8) 168 int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index) 169 { 170 BDRVQcow2State *s = bs->opaque; 171 uint64_t buf[L1_ENTRIES_PER_SECTOR] = { 0 }; 172 int l1_start_index; 173 int i, ret; 174 175 l1_start_index = l1_index & ~(L1_ENTRIES_PER_SECTOR - 1); 176 for (i = 0; i < L1_ENTRIES_PER_SECTOR && l1_start_index + i < s->l1_size; 177 i++) 178 { 179 buf[i] = cpu_to_be64(s->l1_table[l1_start_index + i]); 180 } 181 182 ret = qcow2_pre_write_overlap_check(bs, QCOW2_OL_ACTIVE_L1, 183 s->l1_table_offset + 8 * l1_start_index, sizeof(buf)); 184 if (ret < 0) { 185 return ret; 186 } 187 188 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 189 ret = bdrv_pwrite_sync(bs->file, 190 s->l1_table_offset + 8 * l1_start_index, 191 buf, sizeof(buf)); 192 if (ret < 0) { 193 return ret; 194 } 195 196 return 0; 197 } 198 199 /* 200 * l2_allocate 201 * 202 * Allocate a new l2 entry in the file. If l1_index points to an already 203 * used entry in the L2 table (i.e. we are doing a copy on write for the L2 204 * table) copy the contents of the old L2 table into the newly allocated one. 205 * Otherwise the new table is initialized with zeros. 206 * 207 */ 208 209 static int l2_allocate(BlockDriverState *bs, int l1_index, uint64_t **table) 210 { 211 BDRVQcow2State *s = bs->opaque; 212 uint64_t old_l2_offset; 213 uint64_t *l2_table = NULL; 214 int64_t l2_offset; 215 int ret; 216 217 old_l2_offset = s->l1_table[l1_index]; 218 219 trace_qcow2_l2_allocate(bs, l1_index); 220 221 /* allocate a new l2 entry */ 222 223 l2_offset = qcow2_alloc_clusters(bs, s->l2_size * sizeof(uint64_t)); 224 if (l2_offset < 0) { 225 ret = l2_offset; 226 goto fail; 227 } 228 229 ret = qcow2_cache_flush(bs, s->refcount_block_cache); 230 if (ret < 0) { 231 goto fail; 232 } 233 234 /* allocate a new entry in the l2 cache */ 235 236 trace_qcow2_l2_allocate_get_empty(bs, l1_index); 237 ret = qcow2_cache_get_empty(bs, s->l2_table_cache, l2_offset, (void**) table); 238 if (ret < 0) { 239 goto fail; 240 } 241 242 l2_table = *table; 243 244 if ((old_l2_offset & L1E_OFFSET_MASK) == 0) { 245 /* if there was no old l2 table, clear the new table */ 246 memset(l2_table, 0, s->l2_size * sizeof(uint64_t)); 247 } else { 248 uint64_t* old_table; 249 250 /* if there was an old l2 table, read it from the disk */ 251 BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_COW_READ); 252 ret = qcow2_cache_get(bs, s->l2_table_cache, 253 old_l2_offset & L1E_OFFSET_MASK, 254 (void**) &old_table); 255 if (ret < 0) { 256 goto fail; 257 } 258 259 memcpy(l2_table, old_table, s->cluster_size); 260 261 qcow2_cache_put(bs, s->l2_table_cache, (void **) &old_table); 262 } 263 264 /* write the l2 table to the file */ 265 BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_WRITE); 266 267 trace_qcow2_l2_allocate_write_l2(bs, l1_index); 268 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table); 269 ret = qcow2_cache_flush(bs, s->l2_table_cache); 270 if (ret < 0) { 271 goto fail; 272 } 273 274 /* update the L1 entry */ 275 trace_qcow2_l2_allocate_write_l1(bs, l1_index); 276 s->l1_table[l1_index] = l2_offset | QCOW_OFLAG_COPIED; 277 ret = qcow2_write_l1_entry(bs, l1_index); 278 if (ret < 0) { 279 goto fail; 280 } 281 282 *table = l2_table; 283 trace_qcow2_l2_allocate_done(bs, l1_index, 0); 284 return 0; 285 286 fail: 287 trace_qcow2_l2_allocate_done(bs, l1_index, ret); 288 if (l2_table != NULL) { 289 qcow2_cache_put(bs, s->l2_table_cache, (void**) table); 290 } 291 s->l1_table[l1_index] = old_l2_offset; 292 if (l2_offset > 0) { 293 qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t), 294 QCOW2_DISCARD_ALWAYS); 295 } 296 return ret; 297 } 298 299 /* 300 * Checks how many clusters in a given L2 table are contiguous in the image 301 * file. As soon as one of the flags in the bitmask stop_flags changes compared 302 * to the first cluster, the search is stopped and the cluster is not counted 303 * as contiguous. (This allows it, for example, to stop at the first compressed 304 * cluster which may require a different handling) 305 */ 306 static int count_contiguous_clusters(int nb_clusters, int cluster_size, 307 uint64_t *l2_table, uint64_t stop_flags) 308 { 309 int i; 310 uint64_t mask = stop_flags | L2E_OFFSET_MASK | QCOW_OFLAG_COMPRESSED; 311 uint64_t first_entry = be64_to_cpu(l2_table[0]); 312 uint64_t offset = first_entry & mask; 313 314 if (!offset) 315 return 0; 316 317 assert(qcow2_get_cluster_type(first_entry) == QCOW2_CLUSTER_NORMAL); 318 319 for (i = 0; i < nb_clusters; i++) { 320 uint64_t l2_entry = be64_to_cpu(l2_table[i]) & mask; 321 if (offset + (uint64_t) i * cluster_size != l2_entry) { 322 break; 323 } 324 } 325 326 return i; 327 } 328 329 static int count_contiguous_clusters_by_type(int nb_clusters, 330 uint64_t *l2_table, 331 int wanted_type) 332 { 333 int i; 334 335 for (i = 0; i < nb_clusters; i++) { 336 int type = qcow2_get_cluster_type(be64_to_cpu(l2_table[i])); 337 338 if (type != wanted_type) { 339 break; 340 } 341 } 342 343 return i; 344 } 345 346 /* The crypt function is compatible with the linux cryptoloop 347 algorithm for < 4 GB images. NOTE: out_buf == in_buf is 348 supported */ 349 int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num, 350 uint8_t *out_buf, const uint8_t *in_buf, 351 int nb_sectors, bool enc, 352 Error **errp) 353 { 354 union { 355 uint64_t ll[2]; 356 uint8_t b[16]; 357 } ivec; 358 int i; 359 int ret; 360 361 for(i = 0; i < nb_sectors; i++) { 362 ivec.ll[0] = cpu_to_le64(sector_num); 363 ivec.ll[1] = 0; 364 if (qcrypto_cipher_setiv(s->cipher, 365 ivec.b, G_N_ELEMENTS(ivec.b), 366 errp) < 0) { 367 return -1; 368 } 369 if (enc) { 370 ret = qcrypto_cipher_encrypt(s->cipher, 371 in_buf, 372 out_buf, 373 512, 374 errp); 375 } else { 376 ret = qcrypto_cipher_decrypt(s->cipher, 377 in_buf, 378 out_buf, 379 512, 380 errp); 381 } 382 if (ret < 0) { 383 return -1; 384 } 385 sector_num++; 386 in_buf += 512; 387 out_buf += 512; 388 } 389 return 0; 390 } 391 392 static int coroutine_fn do_perform_cow(BlockDriverState *bs, 393 uint64_t src_cluster_offset, 394 uint64_t cluster_offset, 395 int offset_in_cluster, 396 int bytes) 397 { 398 BDRVQcow2State *s = bs->opaque; 399 QEMUIOVector qiov; 400 struct iovec iov; 401 int ret; 402 403 iov.iov_len = bytes; 404 iov.iov_base = qemu_try_blockalign(bs, iov.iov_len); 405 if (iov.iov_base == NULL) { 406 return -ENOMEM; 407 } 408 409 qemu_iovec_init_external(&qiov, &iov, 1); 410 411 BLKDBG_EVENT(bs->file, BLKDBG_COW_READ); 412 413 if (!bs->drv) { 414 ret = -ENOMEDIUM; 415 goto out; 416 } 417 418 /* Call .bdrv_co_readv() directly instead of using the public block-layer 419 * interface. This avoids double I/O throttling and request tracking, 420 * which can lead to deadlock when block layer copy-on-read is enabled. 421 */ 422 ret = bs->drv->bdrv_co_preadv(bs, src_cluster_offset + offset_in_cluster, 423 bytes, &qiov, 0); 424 if (ret < 0) { 425 goto out; 426 } 427 428 if (bs->encrypted) { 429 Error *err = NULL; 430 int64_t sector = (cluster_offset + offset_in_cluster) 431 >> BDRV_SECTOR_BITS; 432 assert(s->cipher); 433 assert((offset_in_cluster & ~BDRV_SECTOR_MASK) == 0); 434 assert((bytes & ~BDRV_SECTOR_MASK) == 0); 435 if (qcow2_encrypt_sectors(s, sector, iov.iov_base, iov.iov_base, 436 bytes >> BDRV_SECTOR_BITS, true, &err) < 0) { 437 ret = -EIO; 438 error_free(err); 439 goto out; 440 } 441 } 442 443 ret = qcow2_pre_write_overlap_check(bs, 0, 444 cluster_offset + offset_in_cluster, bytes); 445 if (ret < 0) { 446 goto out; 447 } 448 449 BLKDBG_EVENT(bs->file, BLKDBG_COW_WRITE); 450 ret = bdrv_co_pwritev(bs->file, cluster_offset + offset_in_cluster, 451 bytes, &qiov, 0); 452 if (ret < 0) { 453 goto out; 454 } 455 456 ret = 0; 457 out: 458 qemu_vfree(iov.iov_base); 459 return ret; 460 } 461 462 463 /* 464 * get_cluster_offset 465 * 466 * For a given offset of the virtual disk, find the cluster type and offset in 467 * the qcow2 file. The offset is stored in *cluster_offset. 468 * 469 * On entry, *bytes is the maximum number of contiguous bytes starting at 470 * offset that we are interested in. 471 * 472 * On exit, *bytes is the number of bytes starting at offset that have the same 473 * cluster type and (if applicable) are stored contiguously in the image file. 474 * Compressed clusters are always returned one by one. 475 * 476 * Returns the cluster type (QCOW2_CLUSTER_*) on success, -errno in error 477 * cases. 478 */ 479 int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, 480 unsigned int *bytes, uint64_t *cluster_offset) 481 { 482 BDRVQcow2State *s = bs->opaque; 483 unsigned int l2_index; 484 uint64_t l1_index, l2_offset, *l2_table; 485 int l1_bits, c; 486 unsigned int offset_in_cluster; 487 uint64_t bytes_available, bytes_needed, nb_clusters; 488 int ret; 489 490 offset_in_cluster = offset_into_cluster(s, offset); 491 bytes_needed = (uint64_t) *bytes + offset_in_cluster; 492 493 l1_bits = s->l2_bits + s->cluster_bits; 494 495 /* compute how many bytes there are between the start of the cluster 496 * containing offset and the end of the l1 entry */ 497 bytes_available = (1ULL << l1_bits) - (offset & ((1ULL << l1_bits) - 1)) 498 + offset_in_cluster; 499 500 if (bytes_needed > bytes_available) { 501 bytes_needed = bytes_available; 502 } 503 504 *cluster_offset = 0; 505 506 /* seek to the l2 offset in the l1 table */ 507 508 l1_index = offset >> l1_bits; 509 if (l1_index >= s->l1_size) { 510 ret = QCOW2_CLUSTER_UNALLOCATED; 511 goto out; 512 } 513 514 l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK; 515 if (!l2_offset) { 516 ret = QCOW2_CLUSTER_UNALLOCATED; 517 goto out; 518 } 519 520 if (offset_into_cluster(s, l2_offset)) { 521 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64 522 " unaligned (L1 index: %#" PRIx64 ")", 523 l2_offset, l1_index); 524 return -EIO; 525 } 526 527 /* load the l2 table in memory */ 528 529 ret = l2_load(bs, l2_offset, &l2_table); 530 if (ret < 0) { 531 return ret; 532 } 533 534 /* find the cluster offset for the given disk offset */ 535 536 l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1); 537 *cluster_offset = be64_to_cpu(l2_table[l2_index]); 538 539 nb_clusters = size_to_clusters(s, bytes_needed); 540 /* bytes_needed <= *bytes + offset_in_cluster, both of which are unsigned 541 * integers; the minimum cluster size is 512, so this assertion is always 542 * true */ 543 assert(nb_clusters <= INT_MAX); 544 545 ret = qcow2_get_cluster_type(*cluster_offset); 546 switch (ret) { 547 case QCOW2_CLUSTER_COMPRESSED: 548 /* Compressed clusters can only be processed one by one */ 549 c = 1; 550 *cluster_offset &= L2E_COMPRESSED_OFFSET_SIZE_MASK; 551 break; 552 case QCOW2_CLUSTER_ZERO: 553 if (s->qcow_version < 3) { 554 qcow2_signal_corruption(bs, true, -1, -1, "Zero cluster entry found" 555 " in pre-v3 image (L2 offset: %#" PRIx64 556 ", L2 index: %#x)", l2_offset, l2_index); 557 ret = -EIO; 558 goto fail; 559 } 560 c = count_contiguous_clusters_by_type(nb_clusters, &l2_table[l2_index], 561 QCOW2_CLUSTER_ZERO); 562 *cluster_offset = 0; 563 break; 564 case QCOW2_CLUSTER_UNALLOCATED: 565 /* how many empty clusters ? */ 566 c = count_contiguous_clusters_by_type(nb_clusters, &l2_table[l2_index], 567 QCOW2_CLUSTER_UNALLOCATED); 568 *cluster_offset = 0; 569 break; 570 case QCOW2_CLUSTER_NORMAL: 571 /* how many allocated clusters ? */ 572 c = count_contiguous_clusters(nb_clusters, s->cluster_size, 573 &l2_table[l2_index], QCOW_OFLAG_ZERO); 574 *cluster_offset &= L2E_OFFSET_MASK; 575 if (offset_into_cluster(s, *cluster_offset)) { 576 qcow2_signal_corruption(bs, true, -1, -1, "Data cluster offset %#" 577 PRIx64 " unaligned (L2 offset: %#" PRIx64 578 ", L2 index: %#x)", *cluster_offset, 579 l2_offset, l2_index); 580 ret = -EIO; 581 goto fail; 582 } 583 break; 584 default: 585 abort(); 586 } 587 588 qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table); 589 590 bytes_available = (int64_t)c * s->cluster_size; 591 592 out: 593 if (bytes_available > bytes_needed) { 594 bytes_available = bytes_needed; 595 } 596 597 /* bytes_available <= bytes_needed <= *bytes + offset_in_cluster; 598 * subtracting offset_in_cluster will therefore definitely yield something 599 * not exceeding UINT_MAX */ 600 assert(bytes_available - offset_in_cluster <= UINT_MAX); 601 *bytes = bytes_available - offset_in_cluster; 602 603 return ret; 604 605 fail: 606 qcow2_cache_put(bs, s->l2_table_cache, (void **)&l2_table); 607 return ret; 608 } 609 610 /* 611 * get_cluster_table 612 * 613 * for a given disk offset, load (and allocate if needed) 614 * the l2 table. 615 * 616 * the l2 table offset in the qcow2 file and the cluster index 617 * in the l2 table are given to the caller. 618 * 619 * Returns 0 on success, -errno in failure case 620 */ 621 static int get_cluster_table(BlockDriverState *bs, uint64_t offset, 622 uint64_t **new_l2_table, 623 int *new_l2_index) 624 { 625 BDRVQcow2State *s = bs->opaque; 626 unsigned int l2_index; 627 uint64_t l1_index, l2_offset; 628 uint64_t *l2_table = NULL; 629 int ret; 630 631 /* seek to the l2 offset in the l1 table */ 632 633 l1_index = offset >> (s->l2_bits + s->cluster_bits); 634 if (l1_index >= s->l1_size) { 635 ret = qcow2_grow_l1_table(bs, l1_index + 1, false); 636 if (ret < 0) { 637 return ret; 638 } 639 } 640 641 assert(l1_index < s->l1_size); 642 l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK; 643 if (offset_into_cluster(s, l2_offset)) { 644 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64 645 " unaligned (L1 index: %#" PRIx64 ")", 646 l2_offset, l1_index); 647 return -EIO; 648 } 649 650 /* seek the l2 table of the given l2 offset */ 651 652 if (s->l1_table[l1_index] & QCOW_OFLAG_COPIED) { 653 /* load the l2 table in memory */ 654 ret = l2_load(bs, l2_offset, &l2_table); 655 if (ret < 0) { 656 return ret; 657 } 658 } else { 659 /* First allocate a new L2 table (and do COW if needed) */ 660 ret = l2_allocate(bs, l1_index, &l2_table); 661 if (ret < 0) { 662 return ret; 663 } 664 665 /* Then decrease the refcount of the old table */ 666 if (l2_offset) { 667 qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t), 668 QCOW2_DISCARD_OTHER); 669 } 670 } 671 672 /* find the cluster offset for the given disk offset */ 673 674 l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1); 675 676 *new_l2_table = l2_table; 677 *new_l2_index = l2_index; 678 679 return 0; 680 } 681 682 /* 683 * alloc_compressed_cluster_offset 684 * 685 * For a given offset of the disk image, return cluster offset in 686 * qcow2 file. 687 * 688 * If the offset is not found, allocate a new compressed cluster. 689 * 690 * Return the cluster offset if successful, 691 * Return 0, otherwise. 692 * 693 */ 694 695 uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, 696 uint64_t offset, 697 int compressed_size) 698 { 699 BDRVQcow2State *s = bs->opaque; 700 int l2_index, ret; 701 uint64_t *l2_table; 702 int64_t cluster_offset; 703 int nb_csectors; 704 705 ret = get_cluster_table(bs, offset, &l2_table, &l2_index); 706 if (ret < 0) { 707 return 0; 708 } 709 710 /* Compression can't overwrite anything. Fail if the cluster was already 711 * allocated. */ 712 cluster_offset = be64_to_cpu(l2_table[l2_index]); 713 if (cluster_offset & L2E_OFFSET_MASK) { 714 qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table); 715 return 0; 716 } 717 718 cluster_offset = qcow2_alloc_bytes(bs, compressed_size); 719 if (cluster_offset < 0) { 720 qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table); 721 return 0; 722 } 723 724 nb_csectors = ((cluster_offset + compressed_size - 1) >> 9) - 725 (cluster_offset >> 9); 726 727 cluster_offset |= QCOW_OFLAG_COMPRESSED | 728 ((uint64_t)nb_csectors << s->csize_shift); 729 730 /* update L2 table */ 731 732 /* compressed clusters never have the copied flag */ 733 734 BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED); 735 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table); 736 l2_table[l2_index] = cpu_to_be64(cluster_offset); 737 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 738 739 return cluster_offset; 740 } 741 742 static int perform_cow(BlockDriverState *bs, QCowL2Meta *m, Qcow2COWRegion *r) 743 { 744 BDRVQcow2State *s = bs->opaque; 745 int ret; 746 747 if (r->nb_bytes == 0) { 748 return 0; 749 } 750 751 qemu_co_mutex_unlock(&s->lock); 752 ret = do_perform_cow(bs, m->offset, m->alloc_offset, r->offset, r->nb_bytes); 753 qemu_co_mutex_lock(&s->lock); 754 755 if (ret < 0) { 756 return ret; 757 } 758 759 /* 760 * Before we update the L2 table to actually point to the new cluster, we 761 * need to be sure that the refcounts have been increased and COW was 762 * handled. 763 */ 764 qcow2_cache_depends_on_flush(s->l2_table_cache); 765 766 return 0; 767 } 768 769 int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m) 770 { 771 BDRVQcow2State *s = bs->opaque; 772 int i, j = 0, l2_index, ret; 773 uint64_t *old_cluster, *l2_table; 774 uint64_t cluster_offset = m->alloc_offset; 775 776 trace_qcow2_cluster_link_l2(qemu_coroutine_self(), m->nb_clusters); 777 assert(m->nb_clusters > 0); 778 779 old_cluster = g_try_new(uint64_t, m->nb_clusters); 780 if (old_cluster == NULL) { 781 ret = -ENOMEM; 782 goto err; 783 } 784 785 /* copy content of unmodified sectors */ 786 ret = perform_cow(bs, m, &m->cow_start); 787 if (ret < 0) { 788 goto err; 789 } 790 791 ret = perform_cow(bs, m, &m->cow_end); 792 if (ret < 0) { 793 goto err; 794 } 795 796 /* Update L2 table. */ 797 if (s->use_lazy_refcounts) { 798 qcow2_mark_dirty(bs); 799 } 800 if (qcow2_need_accurate_refcounts(s)) { 801 qcow2_cache_set_dependency(bs, s->l2_table_cache, 802 s->refcount_block_cache); 803 } 804 805 ret = get_cluster_table(bs, m->offset, &l2_table, &l2_index); 806 if (ret < 0) { 807 goto err; 808 } 809 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table); 810 811 assert(l2_index + m->nb_clusters <= s->l2_size); 812 for (i = 0; i < m->nb_clusters; i++) { 813 /* if two concurrent writes happen to the same unallocated cluster 814 * each write allocates separate cluster and writes data concurrently. 815 * The first one to complete updates l2 table with pointer to its 816 * cluster the second one has to do RMW (which is done above by 817 * perform_cow()), update l2 table with its cluster pointer and free 818 * old cluster. This is what this loop does */ 819 if (l2_table[l2_index + i] != 0) { 820 old_cluster[j++] = l2_table[l2_index + i]; 821 } 822 823 l2_table[l2_index + i] = cpu_to_be64((cluster_offset + 824 (i << s->cluster_bits)) | QCOW_OFLAG_COPIED); 825 } 826 827 828 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 829 830 /* 831 * If this was a COW, we need to decrease the refcount of the old cluster. 832 * 833 * Don't discard clusters that reach a refcount of 0 (e.g. compressed 834 * clusters), the next write will reuse them anyway. 835 */ 836 if (j != 0) { 837 for (i = 0; i < j; i++) { 838 qcow2_free_any_clusters(bs, be64_to_cpu(old_cluster[i]), 1, 839 QCOW2_DISCARD_NEVER); 840 } 841 } 842 843 ret = 0; 844 err: 845 g_free(old_cluster); 846 return ret; 847 } 848 849 /* 850 * Returns the number of contiguous clusters that can be used for an allocating 851 * write, but require COW to be performed (this includes yet unallocated space, 852 * which must copy from the backing file) 853 */ 854 static int count_cow_clusters(BDRVQcow2State *s, int nb_clusters, 855 uint64_t *l2_table, int l2_index) 856 { 857 int i; 858 859 for (i = 0; i < nb_clusters; i++) { 860 uint64_t l2_entry = be64_to_cpu(l2_table[l2_index + i]); 861 int cluster_type = qcow2_get_cluster_type(l2_entry); 862 863 switch(cluster_type) { 864 case QCOW2_CLUSTER_NORMAL: 865 if (l2_entry & QCOW_OFLAG_COPIED) { 866 goto out; 867 } 868 break; 869 case QCOW2_CLUSTER_UNALLOCATED: 870 case QCOW2_CLUSTER_COMPRESSED: 871 case QCOW2_CLUSTER_ZERO: 872 break; 873 default: 874 abort(); 875 } 876 } 877 878 out: 879 assert(i <= nb_clusters); 880 return i; 881 } 882 883 /* 884 * Check if there already is an AIO write request in flight which allocates 885 * the same cluster. In this case we need to wait until the previous 886 * request has completed and updated the L2 table accordingly. 887 * 888 * Returns: 889 * 0 if there was no dependency. *cur_bytes indicates the number of 890 * bytes from guest_offset that can be read before the next 891 * dependency must be processed (or the request is complete) 892 * 893 * -EAGAIN if we had to wait for another request, previously gathered 894 * information on cluster allocation may be invalid now. The caller 895 * must start over anyway, so consider *cur_bytes undefined. 896 */ 897 static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset, 898 uint64_t *cur_bytes, QCowL2Meta **m) 899 { 900 BDRVQcow2State *s = bs->opaque; 901 QCowL2Meta *old_alloc; 902 uint64_t bytes = *cur_bytes; 903 904 QLIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) { 905 906 uint64_t start = guest_offset; 907 uint64_t end = start + bytes; 908 uint64_t old_start = l2meta_cow_start(old_alloc); 909 uint64_t old_end = l2meta_cow_end(old_alloc); 910 911 if (end <= old_start || start >= old_end) { 912 /* No intersection */ 913 } else { 914 if (start < old_start) { 915 /* Stop at the start of a running allocation */ 916 bytes = old_start - start; 917 } else { 918 bytes = 0; 919 } 920 921 /* Stop if already an l2meta exists. After yielding, it wouldn't 922 * be valid any more, so we'd have to clean up the old L2Metas 923 * and deal with requests depending on them before starting to 924 * gather new ones. Not worth the trouble. */ 925 if (bytes == 0 && *m) { 926 *cur_bytes = 0; 927 return 0; 928 } 929 930 if (bytes == 0) { 931 /* Wait for the dependency to complete. We need to recheck 932 * the free/allocated clusters when we continue. */ 933 qemu_co_mutex_unlock(&s->lock); 934 qemu_co_queue_wait(&old_alloc->dependent_requests); 935 qemu_co_mutex_lock(&s->lock); 936 return -EAGAIN; 937 } 938 } 939 } 940 941 /* Make sure that existing clusters and new allocations are only used up to 942 * the next dependency if we shortened the request above */ 943 *cur_bytes = bytes; 944 945 return 0; 946 } 947 948 /* 949 * Checks how many already allocated clusters that don't require a copy on 950 * write there are at the given guest_offset (up to *bytes). If 951 * *host_offset is not zero, only physically contiguous clusters beginning at 952 * this host offset are counted. 953 * 954 * Note that guest_offset may not be cluster aligned. In this case, the 955 * returned *host_offset points to exact byte referenced by guest_offset and 956 * therefore isn't cluster aligned as well. 957 * 958 * Returns: 959 * 0: if no allocated clusters are available at the given offset. 960 * *bytes is normally unchanged. It is set to 0 if the cluster 961 * is allocated and doesn't need COW, but doesn't have the right 962 * physical offset. 963 * 964 * 1: if allocated clusters that don't require a COW are available at 965 * the requested offset. *bytes may have decreased and describes 966 * the length of the area that can be written to. 967 * 968 * -errno: in error cases 969 */ 970 static int handle_copied(BlockDriverState *bs, uint64_t guest_offset, 971 uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m) 972 { 973 BDRVQcow2State *s = bs->opaque; 974 int l2_index; 975 uint64_t cluster_offset; 976 uint64_t *l2_table; 977 uint64_t nb_clusters; 978 unsigned int keep_clusters; 979 int ret; 980 981 trace_qcow2_handle_copied(qemu_coroutine_self(), guest_offset, *host_offset, 982 *bytes); 983 984 assert(*host_offset == 0 || offset_into_cluster(s, guest_offset) 985 == offset_into_cluster(s, *host_offset)); 986 987 /* 988 * Calculate the number of clusters to look for. We stop at L2 table 989 * boundaries to keep things simple. 990 */ 991 nb_clusters = 992 size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes); 993 994 l2_index = offset_to_l2_index(s, guest_offset); 995 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index); 996 assert(nb_clusters <= INT_MAX); 997 998 /* Find L2 entry for the first involved cluster */ 999 ret = get_cluster_table(bs, guest_offset, &l2_table, &l2_index); 1000 if (ret < 0) { 1001 return ret; 1002 } 1003 1004 cluster_offset = be64_to_cpu(l2_table[l2_index]); 1005 1006 /* Check how many clusters are already allocated and don't need COW */ 1007 if (qcow2_get_cluster_type(cluster_offset) == QCOW2_CLUSTER_NORMAL 1008 && (cluster_offset & QCOW_OFLAG_COPIED)) 1009 { 1010 /* If a specific host_offset is required, check it */ 1011 bool offset_matches = 1012 (cluster_offset & L2E_OFFSET_MASK) == *host_offset; 1013 1014 if (offset_into_cluster(s, cluster_offset & L2E_OFFSET_MASK)) { 1015 qcow2_signal_corruption(bs, true, -1, -1, "Data cluster offset " 1016 "%#llx unaligned (guest offset: %#" PRIx64 1017 ")", cluster_offset & L2E_OFFSET_MASK, 1018 guest_offset); 1019 ret = -EIO; 1020 goto out; 1021 } 1022 1023 if (*host_offset != 0 && !offset_matches) { 1024 *bytes = 0; 1025 ret = 0; 1026 goto out; 1027 } 1028 1029 /* We keep all QCOW_OFLAG_COPIED clusters */ 1030 keep_clusters = 1031 count_contiguous_clusters(nb_clusters, s->cluster_size, 1032 &l2_table[l2_index], 1033 QCOW_OFLAG_COPIED | QCOW_OFLAG_ZERO); 1034 assert(keep_clusters <= nb_clusters); 1035 1036 *bytes = MIN(*bytes, 1037 keep_clusters * s->cluster_size 1038 - offset_into_cluster(s, guest_offset)); 1039 1040 ret = 1; 1041 } else { 1042 ret = 0; 1043 } 1044 1045 /* Cleanup */ 1046 out: 1047 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 1048 1049 /* Only return a host offset if we actually made progress. Otherwise we 1050 * would make requirements for handle_alloc() that it can't fulfill */ 1051 if (ret > 0) { 1052 *host_offset = (cluster_offset & L2E_OFFSET_MASK) 1053 + offset_into_cluster(s, guest_offset); 1054 } 1055 1056 return ret; 1057 } 1058 1059 /* 1060 * Allocates new clusters for the given guest_offset. 1061 * 1062 * At most *nb_clusters are allocated, and on return *nb_clusters is updated to 1063 * contain the number of clusters that have been allocated and are contiguous 1064 * in the image file. 1065 * 1066 * If *host_offset is non-zero, it specifies the offset in the image file at 1067 * which the new clusters must start. *nb_clusters can be 0 on return in this 1068 * case if the cluster at host_offset is already in use. If *host_offset is 1069 * zero, the clusters can be allocated anywhere in the image file. 1070 * 1071 * *host_offset is updated to contain the offset into the image file at which 1072 * the first allocated cluster starts. 1073 * 1074 * Return 0 on success and -errno in error cases. -EAGAIN means that the 1075 * function has been waiting for another request and the allocation must be 1076 * restarted, but the whole request should not be failed. 1077 */ 1078 static int do_alloc_cluster_offset(BlockDriverState *bs, uint64_t guest_offset, 1079 uint64_t *host_offset, uint64_t *nb_clusters) 1080 { 1081 BDRVQcow2State *s = bs->opaque; 1082 1083 trace_qcow2_do_alloc_clusters_offset(qemu_coroutine_self(), guest_offset, 1084 *host_offset, *nb_clusters); 1085 1086 /* Allocate new clusters */ 1087 trace_qcow2_cluster_alloc_phys(qemu_coroutine_self()); 1088 if (*host_offset == 0) { 1089 int64_t cluster_offset = 1090 qcow2_alloc_clusters(bs, *nb_clusters * s->cluster_size); 1091 if (cluster_offset < 0) { 1092 return cluster_offset; 1093 } 1094 *host_offset = cluster_offset; 1095 return 0; 1096 } else { 1097 int64_t ret = qcow2_alloc_clusters_at(bs, *host_offset, *nb_clusters); 1098 if (ret < 0) { 1099 return ret; 1100 } 1101 *nb_clusters = ret; 1102 return 0; 1103 } 1104 } 1105 1106 /* 1107 * Allocates new clusters for an area that either is yet unallocated or needs a 1108 * copy on write. If *host_offset is non-zero, clusters are only allocated if 1109 * the new allocation can match the specified host offset. 1110 * 1111 * Note that guest_offset may not be cluster aligned. In this case, the 1112 * returned *host_offset points to exact byte referenced by guest_offset and 1113 * therefore isn't cluster aligned as well. 1114 * 1115 * Returns: 1116 * 0: if no clusters could be allocated. *bytes is set to 0, 1117 * *host_offset is left unchanged. 1118 * 1119 * 1: if new clusters were allocated. *bytes may be decreased if the 1120 * new allocation doesn't cover all of the requested area. 1121 * *host_offset is updated to contain the host offset of the first 1122 * newly allocated cluster. 1123 * 1124 * -errno: in error cases 1125 */ 1126 static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset, 1127 uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m) 1128 { 1129 BDRVQcow2State *s = bs->opaque; 1130 int l2_index; 1131 uint64_t *l2_table; 1132 uint64_t entry; 1133 uint64_t nb_clusters; 1134 int ret; 1135 1136 uint64_t alloc_cluster_offset; 1137 1138 trace_qcow2_handle_alloc(qemu_coroutine_self(), guest_offset, *host_offset, 1139 *bytes); 1140 assert(*bytes > 0); 1141 1142 /* 1143 * Calculate the number of clusters to look for. We stop at L2 table 1144 * boundaries to keep things simple. 1145 */ 1146 nb_clusters = 1147 size_to_clusters(s, offset_into_cluster(s, guest_offset) + *bytes); 1148 1149 l2_index = offset_to_l2_index(s, guest_offset); 1150 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index); 1151 assert(nb_clusters <= INT_MAX); 1152 1153 /* Find L2 entry for the first involved cluster */ 1154 ret = get_cluster_table(bs, guest_offset, &l2_table, &l2_index); 1155 if (ret < 0) { 1156 return ret; 1157 } 1158 1159 entry = be64_to_cpu(l2_table[l2_index]); 1160 1161 /* For the moment, overwrite compressed clusters one by one */ 1162 if (entry & QCOW_OFLAG_COMPRESSED) { 1163 nb_clusters = 1; 1164 } else { 1165 nb_clusters = count_cow_clusters(s, nb_clusters, l2_table, l2_index); 1166 } 1167 1168 /* This function is only called when there were no non-COW clusters, so if 1169 * we can't find any unallocated or COW clusters either, something is 1170 * wrong with our code. */ 1171 assert(nb_clusters > 0); 1172 1173 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 1174 1175 /* Allocate, if necessary at a given offset in the image file */ 1176 alloc_cluster_offset = start_of_cluster(s, *host_offset); 1177 ret = do_alloc_cluster_offset(bs, guest_offset, &alloc_cluster_offset, 1178 &nb_clusters); 1179 if (ret < 0) { 1180 goto fail; 1181 } 1182 1183 /* Can't extend contiguous allocation */ 1184 if (nb_clusters == 0) { 1185 *bytes = 0; 1186 return 0; 1187 } 1188 1189 /* !*host_offset would overwrite the image header and is reserved for "no 1190 * host offset preferred". If 0 was a valid host offset, it'd trigger the 1191 * following overlap check; do that now to avoid having an invalid value in 1192 * *host_offset. */ 1193 if (!alloc_cluster_offset) { 1194 ret = qcow2_pre_write_overlap_check(bs, 0, alloc_cluster_offset, 1195 nb_clusters * s->cluster_size); 1196 assert(ret < 0); 1197 goto fail; 1198 } 1199 1200 /* 1201 * Save info needed for meta data update. 1202 * 1203 * requested_bytes: Number of bytes from the start of the first 1204 * newly allocated cluster to the end of the (possibly shortened 1205 * before) write request. 1206 * 1207 * avail_bytes: Number of bytes from the start of the first 1208 * newly allocated to the end of the last newly allocated cluster. 1209 * 1210 * nb_bytes: The number of bytes from the start of the first 1211 * newly allocated cluster to the end of the area that the write 1212 * request actually writes to (excluding COW at the end) 1213 */ 1214 uint64_t requested_bytes = *bytes + offset_into_cluster(s, guest_offset); 1215 int avail_bytes = MIN(INT_MAX, nb_clusters << s->cluster_bits); 1216 int nb_bytes = MIN(requested_bytes, avail_bytes); 1217 QCowL2Meta *old_m = *m; 1218 1219 *m = g_malloc0(sizeof(**m)); 1220 1221 **m = (QCowL2Meta) { 1222 .next = old_m, 1223 1224 .alloc_offset = alloc_cluster_offset, 1225 .offset = start_of_cluster(s, guest_offset), 1226 .nb_clusters = nb_clusters, 1227 1228 .cow_start = { 1229 .offset = 0, 1230 .nb_bytes = offset_into_cluster(s, guest_offset), 1231 }, 1232 .cow_end = { 1233 .offset = nb_bytes, 1234 .nb_bytes = avail_bytes - nb_bytes, 1235 }, 1236 }; 1237 qemu_co_queue_init(&(*m)->dependent_requests); 1238 QLIST_INSERT_HEAD(&s->cluster_allocs, *m, next_in_flight); 1239 1240 *host_offset = alloc_cluster_offset + offset_into_cluster(s, guest_offset); 1241 *bytes = MIN(*bytes, nb_bytes - offset_into_cluster(s, guest_offset)); 1242 assert(*bytes != 0); 1243 1244 return 1; 1245 1246 fail: 1247 if (*m && (*m)->nb_clusters > 0) { 1248 QLIST_REMOVE(*m, next_in_flight); 1249 } 1250 return ret; 1251 } 1252 1253 /* 1254 * alloc_cluster_offset 1255 * 1256 * For a given offset on the virtual disk, find the cluster offset in qcow2 1257 * file. If the offset is not found, allocate a new cluster. 1258 * 1259 * If the cluster was already allocated, m->nb_clusters is set to 0 and 1260 * other fields in m are meaningless. 1261 * 1262 * If the cluster is newly allocated, m->nb_clusters is set to the number of 1263 * contiguous clusters that have been allocated. In this case, the other 1264 * fields of m are valid and contain information about the first allocated 1265 * cluster. 1266 * 1267 * If the request conflicts with another write request in flight, the coroutine 1268 * is queued and will be reentered when the dependency has completed. 1269 * 1270 * Return 0 on success and -errno in error cases 1271 */ 1272 int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, 1273 unsigned int *bytes, uint64_t *host_offset, 1274 QCowL2Meta **m) 1275 { 1276 BDRVQcow2State *s = bs->opaque; 1277 uint64_t start, remaining; 1278 uint64_t cluster_offset; 1279 uint64_t cur_bytes; 1280 int ret; 1281 1282 trace_qcow2_alloc_clusters_offset(qemu_coroutine_self(), offset, *bytes); 1283 1284 again: 1285 start = offset; 1286 remaining = *bytes; 1287 cluster_offset = 0; 1288 *host_offset = 0; 1289 cur_bytes = 0; 1290 *m = NULL; 1291 1292 while (true) { 1293 1294 if (!*host_offset) { 1295 *host_offset = start_of_cluster(s, cluster_offset); 1296 } 1297 1298 assert(remaining >= cur_bytes); 1299 1300 start += cur_bytes; 1301 remaining -= cur_bytes; 1302 cluster_offset += cur_bytes; 1303 1304 if (remaining == 0) { 1305 break; 1306 } 1307 1308 cur_bytes = remaining; 1309 1310 /* 1311 * Now start gathering as many contiguous clusters as possible: 1312 * 1313 * 1. Check for overlaps with in-flight allocations 1314 * 1315 * a) Overlap not in the first cluster -> shorten this request and 1316 * let the caller handle the rest in its next loop iteration. 1317 * 1318 * b) Real overlaps of two requests. Yield and restart the search 1319 * for contiguous clusters (the situation could have changed 1320 * while we were sleeping) 1321 * 1322 * c) TODO: Request starts in the same cluster as the in-flight 1323 * allocation ends. Shorten the COW of the in-fight allocation, 1324 * set cluster_offset to write to the same cluster and set up 1325 * the right synchronisation between the in-flight request and 1326 * the new one. 1327 */ 1328 ret = handle_dependencies(bs, start, &cur_bytes, m); 1329 if (ret == -EAGAIN) { 1330 /* Currently handle_dependencies() doesn't yield if we already had 1331 * an allocation. If it did, we would have to clean up the L2Meta 1332 * structs before starting over. */ 1333 assert(*m == NULL); 1334 goto again; 1335 } else if (ret < 0) { 1336 return ret; 1337 } else if (cur_bytes == 0) { 1338 break; 1339 } else { 1340 /* handle_dependencies() may have decreased cur_bytes (shortened 1341 * the allocations below) so that the next dependency is processed 1342 * correctly during the next loop iteration. */ 1343 } 1344 1345 /* 1346 * 2. Count contiguous COPIED clusters. 1347 */ 1348 ret = handle_copied(bs, start, &cluster_offset, &cur_bytes, m); 1349 if (ret < 0) { 1350 return ret; 1351 } else if (ret) { 1352 continue; 1353 } else if (cur_bytes == 0) { 1354 break; 1355 } 1356 1357 /* 1358 * 3. If the request still hasn't completed, allocate new clusters, 1359 * considering any cluster_offset of steps 1c or 2. 1360 */ 1361 ret = handle_alloc(bs, start, &cluster_offset, &cur_bytes, m); 1362 if (ret < 0) { 1363 return ret; 1364 } else if (ret) { 1365 continue; 1366 } else { 1367 assert(cur_bytes == 0); 1368 break; 1369 } 1370 } 1371 1372 *bytes -= remaining; 1373 assert(*bytes > 0); 1374 assert(*host_offset != 0); 1375 1376 return 0; 1377 } 1378 1379 static int decompress_buffer(uint8_t *out_buf, int out_buf_size, 1380 const uint8_t *buf, int buf_size) 1381 { 1382 z_stream strm1, *strm = &strm1; 1383 int ret, out_len; 1384 1385 memset(strm, 0, sizeof(*strm)); 1386 1387 strm->next_in = (uint8_t *)buf; 1388 strm->avail_in = buf_size; 1389 strm->next_out = out_buf; 1390 strm->avail_out = out_buf_size; 1391 1392 ret = inflateInit2(strm, -12); 1393 if (ret != Z_OK) 1394 return -1; 1395 ret = inflate(strm, Z_FINISH); 1396 out_len = strm->next_out - out_buf; 1397 if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) || 1398 out_len != out_buf_size) { 1399 inflateEnd(strm); 1400 return -1; 1401 } 1402 inflateEnd(strm); 1403 return 0; 1404 } 1405 1406 int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset) 1407 { 1408 BDRVQcow2State *s = bs->opaque; 1409 int ret, csize, nb_csectors, sector_offset; 1410 uint64_t coffset; 1411 1412 coffset = cluster_offset & s->cluster_offset_mask; 1413 if (s->cluster_cache_offset != coffset) { 1414 nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1; 1415 sector_offset = coffset & 511; 1416 csize = nb_csectors * 512 - sector_offset; 1417 BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED); 1418 ret = bdrv_read(bs->file, coffset >> 9, s->cluster_data, 1419 nb_csectors); 1420 if (ret < 0) { 1421 return ret; 1422 } 1423 if (decompress_buffer(s->cluster_cache, s->cluster_size, 1424 s->cluster_data + sector_offset, csize) < 0) { 1425 return -EIO; 1426 } 1427 s->cluster_cache_offset = coffset; 1428 } 1429 return 0; 1430 } 1431 1432 /* 1433 * This discards as many clusters of nb_clusters as possible at once (i.e. 1434 * all clusters in the same L2 table) and returns the number of discarded 1435 * clusters. 1436 */ 1437 static int discard_single_l2(BlockDriverState *bs, uint64_t offset, 1438 uint64_t nb_clusters, enum qcow2_discard_type type, 1439 bool full_discard) 1440 { 1441 BDRVQcow2State *s = bs->opaque; 1442 uint64_t *l2_table; 1443 int l2_index; 1444 int ret; 1445 int i; 1446 1447 ret = get_cluster_table(bs, offset, &l2_table, &l2_index); 1448 if (ret < 0) { 1449 return ret; 1450 } 1451 1452 /* Limit nb_clusters to one L2 table */ 1453 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index); 1454 assert(nb_clusters <= INT_MAX); 1455 1456 for (i = 0; i < nb_clusters; i++) { 1457 uint64_t old_l2_entry; 1458 1459 old_l2_entry = be64_to_cpu(l2_table[l2_index + i]); 1460 1461 /* 1462 * If full_discard is false, make sure that a discarded area reads back 1463 * as zeroes for v3 images (we cannot do it for v2 without actually 1464 * writing a zero-filled buffer). We can skip the operation if the 1465 * cluster is already marked as zero, or if it's unallocated and we 1466 * don't have a backing file. 1467 * 1468 * TODO We might want to use bdrv_get_block_status(bs) here, but we're 1469 * holding s->lock, so that doesn't work today. 1470 * 1471 * If full_discard is true, the sector should not read back as zeroes, 1472 * but rather fall through to the backing file. 1473 */ 1474 switch (qcow2_get_cluster_type(old_l2_entry)) { 1475 case QCOW2_CLUSTER_UNALLOCATED: 1476 if (full_discard || !bs->backing) { 1477 continue; 1478 } 1479 break; 1480 1481 case QCOW2_CLUSTER_ZERO: 1482 if (!full_discard) { 1483 continue; 1484 } 1485 break; 1486 1487 case QCOW2_CLUSTER_NORMAL: 1488 case QCOW2_CLUSTER_COMPRESSED: 1489 break; 1490 1491 default: 1492 abort(); 1493 } 1494 1495 /* First remove L2 entries */ 1496 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table); 1497 if (!full_discard && s->qcow_version >= 3) { 1498 l2_table[l2_index + i] = cpu_to_be64(QCOW_OFLAG_ZERO); 1499 } else { 1500 l2_table[l2_index + i] = cpu_to_be64(0); 1501 } 1502 1503 /* Then decrease the refcount */ 1504 qcow2_free_any_clusters(bs, old_l2_entry, 1, type); 1505 } 1506 1507 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 1508 1509 return nb_clusters; 1510 } 1511 1512 int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset, 1513 int nb_sectors, enum qcow2_discard_type type, bool full_discard) 1514 { 1515 BDRVQcow2State *s = bs->opaque; 1516 uint64_t end_offset; 1517 uint64_t nb_clusters; 1518 int ret; 1519 1520 end_offset = offset + (nb_sectors << BDRV_SECTOR_BITS); 1521 1522 /* Round start up and end down */ 1523 offset = align_offset(offset, s->cluster_size); 1524 end_offset = start_of_cluster(s, end_offset); 1525 1526 if (offset > end_offset) { 1527 return 0; 1528 } 1529 1530 nb_clusters = size_to_clusters(s, end_offset - offset); 1531 1532 s->cache_discards = true; 1533 1534 /* Each L2 table is handled by its own loop iteration */ 1535 while (nb_clusters > 0) { 1536 ret = discard_single_l2(bs, offset, nb_clusters, type, full_discard); 1537 if (ret < 0) { 1538 goto fail; 1539 } 1540 1541 nb_clusters -= ret; 1542 offset += (ret * s->cluster_size); 1543 } 1544 1545 ret = 0; 1546 fail: 1547 s->cache_discards = false; 1548 qcow2_process_discards(bs, ret); 1549 1550 return ret; 1551 } 1552 1553 /* 1554 * This zeroes as many clusters of nb_clusters as possible at once (i.e. 1555 * all clusters in the same L2 table) and returns the number of zeroed 1556 * clusters. 1557 */ 1558 static int zero_single_l2(BlockDriverState *bs, uint64_t offset, 1559 uint64_t nb_clusters) 1560 { 1561 BDRVQcow2State *s = bs->opaque; 1562 uint64_t *l2_table; 1563 int l2_index; 1564 int ret; 1565 int i; 1566 1567 ret = get_cluster_table(bs, offset, &l2_table, &l2_index); 1568 if (ret < 0) { 1569 return ret; 1570 } 1571 1572 /* Limit nb_clusters to one L2 table */ 1573 nb_clusters = MIN(nb_clusters, s->l2_size - l2_index); 1574 assert(nb_clusters <= INT_MAX); 1575 1576 for (i = 0; i < nb_clusters; i++) { 1577 uint64_t old_offset; 1578 1579 old_offset = be64_to_cpu(l2_table[l2_index + i]); 1580 1581 /* Update L2 entries */ 1582 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table); 1583 if (old_offset & QCOW_OFLAG_COMPRESSED) { 1584 l2_table[l2_index + i] = cpu_to_be64(QCOW_OFLAG_ZERO); 1585 qcow2_free_any_clusters(bs, old_offset, 1, QCOW2_DISCARD_REQUEST); 1586 } else { 1587 l2_table[l2_index + i] |= cpu_to_be64(QCOW_OFLAG_ZERO); 1588 } 1589 } 1590 1591 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 1592 1593 return nb_clusters; 1594 } 1595 1596 int qcow2_zero_clusters(BlockDriverState *bs, uint64_t offset, int nb_sectors) 1597 { 1598 BDRVQcow2State *s = bs->opaque; 1599 uint64_t nb_clusters; 1600 int ret; 1601 1602 /* The zero flag is only supported by version 3 and newer */ 1603 if (s->qcow_version < 3) { 1604 return -ENOTSUP; 1605 } 1606 1607 /* Each L2 table is handled by its own loop iteration */ 1608 nb_clusters = size_to_clusters(s, nb_sectors << BDRV_SECTOR_BITS); 1609 1610 s->cache_discards = true; 1611 1612 while (nb_clusters > 0) { 1613 ret = zero_single_l2(bs, offset, nb_clusters); 1614 if (ret < 0) { 1615 goto fail; 1616 } 1617 1618 nb_clusters -= ret; 1619 offset += (ret * s->cluster_size); 1620 } 1621 1622 ret = 0; 1623 fail: 1624 s->cache_discards = false; 1625 qcow2_process_discards(bs, ret); 1626 1627 return ret; 1628 } 1629 1630 /* 1631 * Expands all zero clusters in a specific L1 table (or deallocates them, for 1632 * non-backed non-pre-allocated zero clusters). 1633 * 1634 * l1_entries and *visited_l1_entries are used to keep track of progress for 1635 * status_cb(). l1_entries contains the total number of L1 entries and 1636 * *visited_l1_entries counts all visited L1 entries. 1637 */ 1638 static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, 1639 int l1_size, int64_t *visited_l1_entries, 1640 int64_t l1_entries, 1641 BlockDriverAmendStatusCB *status_cb, 1642 void *cb_opaque) 1643 { 1644 BDRVQcow2State *s = bs->opaque; 1645 bool is_active_l1 = (l1_table == s->l1_table); 1646 uint64_t *l2_table = NULL; 1647 int ret; 1648 int i, j; 1649 1650 if (!is_active_l1) { 1651 /* inactive L2 tables require a buffer to be stored in when loading 1652 * them from disk */ 1653 l2_table = qemu_try_blockalign(bs->file->bs, s->cluster_size); 1654 if (l2_table == NULL) { 1655 return -ENOMEM; 1656 } 1657 } 1658 1659 for (i = 0; i < l1_size; i++) { 1660 uint64_t l2_offset = l1_table[i] & L1E_OFFSET_MASK; 1661 bool l2_dirty = false; 1662 uint64_t l2_refcount; 1663 1664 if (!l2_offset) { 1665 /* unallocated */ 1666 (*visited_l1_entries)++; 1667 if (status_cb) { 1668 status_cb(bs, *visited_l1_entries, l1_entries, cb_opaque); 1669 } 1670 continue; 1671 } 1672 1673 if (offset_into_cluster(s, l2_offset)) { 1674 qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" 1675 PRIx64 " unaligned (L1 index: %#x)", 1676 l2_offset, i); 1677 ret = -EIO; 1678 goto fail; 1679 } 1680 1681 if (is_active_l1) { 1682 /* get active L2 tables from cache */ 1683 ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset, 1684 (void **)&l2_table); 1685 } else { 1686 /* load inactive L2 tables from disk */ 1687 ret = bdrv_read(bs->file, l2_offset / BDRV_SECTOR_SIZE, 1688 (void *)l2_table, s->cluster_sectors); 1689 } 1690 if (ret < 0) { 1691 goto fail; 1692 } 1693 1694 ret = qcow2_get_refcount(bs, l2_offset >> s->cluster_bits, 1695 &l2_refcount); 1696 if (ret < 0) { 1697 goto fail; 1698 } 1699 1700 for (j = 0; j < s->l2_size; j++) { 1701 uint64_t l2_entry = be64_to_cpu(l2_table[j]); 1702 int64_t offset = l2_entry & L2E_OFFSET_MASK; 1703 int cluster_type = qcow2_get_cluster_type(l2_entry); 1704 bool preallocated = offset != 0; 1705 1706 if (cluster_type != QCOW2_CLUSTER_ZERO) { 1707 continue; 1708 } 1709 1710 if (!preallocated) { 1711 if (!bs->backing) { 1712 /* not backed; therefore we can simply deallocate the 1713 * cluster */ 1714 l2_table[j] = 0; 1715 l2_dirty = true; 1716 continue; 1717 } 1718 1719 offset = qcow2_alloc_clusters(bs, s->cluster_size); 1720 if (offset < 0) { 1721 ret = offset; 1722 goto fail; 1723 } 1724 1725 if (l2_refcount > 1) { 1726 /* For shared L2 tables, set the refcount accordingly (it is 1727 * already 1 and needs to be l2_refcount) */ 1728 ret = qcow2_update_cluster_refcount(bs, 1729 offset >> s->cluster_bits, 1730 refcount_diff(1, l2_refcount), false, 1731 QCOW2_DISCARD_OTHER); 1732 if (ret < 0) { 1733 qcow2_free_clusters(bs, offset, s->cluster_size, 1734 QCOW2_DISCARD_OTHER); 1735 goto fail; 1736 } 1737 } 1738 } 1739 1740 if (offset_into_cluster(s, offset)) { 1741 qcow2_signal_corruption(bs, true, -1, -1, "Data cluster offset " 1742 "%#" PRIx64 " unaligned (L2 offset: %#" 1743 PRIx64 ", L2 index: %#x)", offset, 1744 l2_offset, j); 1745 if (!preallocated) { 1746 qcow2_free_clusters(bs, offset, s->cluster_size, 1747 QCOW2_DISCARD_ALWAYS); 1748 } 1749 ret = -EIO; 1750 goto fail; 1751 } 1752 1753 ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size); 1754 if (ret < 0) { 1755 if (!preallocated) { 1756 qcow2_free_clusters(bs, offset, s->cluster_size, 1757 QCOW2_DISCARD_ALWAYS); 1758 } 1759 goto fail; 1760 } 1761 1762 ret = bdrv_pwrite_zeroes(bs->file, offset, s->cluster_size, 0); 1763 if (ret < 0) { 1764 if (!preallocated) { 1765 qcow2_free_clusters(bs, offset, s->cluster_size, 1766 QCOW2_DISCARD_ALWAYS); 1767 } 1768 goto fail; 1769 } 1770 1771 if (l2_refcount == 1) { 1772 l2_table[j] = cpu_to_be64(offset | QCOW_OFLAG_COPIED); 1773 } else { 1774 l2_table[j] = cpu_to_be64(offset); 1775 } 1776 l2_dirty = true; 1777 } 1778 1779 if (is_active_l1) { 1780 if (l2_dirty) { 1781 qcow2_cache_entry_mark_dirty(bs, s->l2_table_cache, l2_table); 1782 qcow2_cache_depends_on_flush(s->l2_table_cache); 1783 } 1784 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 1785 } else { 1786 if (l2_dirty) { 1787 ret = qcow2_pre_write_overlap_check(bs, 1788 QCOW2_OL_INACTIVE_L2 | QCOW2_OL_ACTIVE_L2, l2_offset, 1789 s->cluster_size); 1790 if (ret < 0) { 1791 goto fail; 1792 } 1793 1794 ret = bdrv_write(bs->file, l2_offset / BDRV_SECTOR_SIZE, 1795 (void *)l2_table, s->cluster_sectors); 1796 if (ret < 0) { 1797 goto fail; 1798 } 1799 } 1800 } 1801 1802 (*visited_l1_entries)++; 1803 if (status_cb) { 1804 status_cb(bs, *visited_l1_entries, l1_entries, cb_opaque); 1805 } 1806 } 1807 1808 ret = 0; 1809 1810 fail: 1811 if (l2_table) { 1812 if (!is_active_l1) { 1813 qemu_vfree(l2_table); 1814 } else { 1815 qcow2_cache_put(bs, s->l2_table_cache, (void **) &l2_table); 1816 } 1817 } 1818 return ret; 1819 } 1820 1821 /* 1822 * For backed images, expands all zero clusters on the image. For non-backed 1823 * images, deallocates all non-pre-allocated zero clusters (and claims the 1824 * allocation for pre-allocated ones). This is important for downgrading to a 1825 * qcow2 version which doesn't yet support metadata zero clusters. 1826 */ 1827 int qcow2_expand_zero_clusters(BlockDriverState *bs, 1828 BlockDriverAmendStatusCB *status_cb, 1829 void *cb_opaque) 1830 { 1831 BDRVQcow2State *s = bs->opaque; 1832 uint64_t *l1_table = NULL; 1833 int64_t l1_entries = 0, visited_l1_entries = 0; 1834 int ret; 1835 int i, j; 1836 1837 if (status_cb) { 1838 l1_entries = s->l1_size; 1839 for (i = 0; i < s->nb_snapshots; i++) { 1840 l1_entries += s->snapshots[i].l1_size; 1841 } 1842 } 1843 1844 ret = expand_zero_clusters_in_l1(bs, s->l1_table, s->l1_size, 1845 &visited_l1_entries, l1_entries, 1846 status_cb, cb_opaque); 1847 if (ret < 0) { 1848 goto fail; 1849 } 1850 1851 /* Inactive L1 tables may point to active L2 tables - therefore it is 1852 * necessary to flush the L2 table cache before trying to access the L2 1853 * tables pointed to by inactive L1 entries (else we might try to expand 1854 * zero clusters that have already been expanded); furthermore, it is also 1855 * necessary to empty the L2 table cache, since it may contain tables which 1856 * are now going to be modified directly on disk, bypassing the cache. 1857 * qcow2_cache_empty() does both for us. */ 1858 ret = qcow2_cache_empty(bs, s->l2_table_cache); 1859 if (ret < 0) { 1860 goto fail; 1861 } 1862 1863 for (i = 0; i < s->nb_snapshots; i++) { 1864 int l1_sectors = DIV_ROUND_UP(s->snapshots[i].l1_size * 1865 sizeof(uint64_t), BDRV_SECTOR_SIZE); 1866 1867 l1_table = g_realloc(l1_table, l1_sectors * BDRV_SECTOR_SIZE); 1868 1869 ret = bdrv_read(bs->file, 1870 s->snapshots[i].l1_table_offset / BDRV_SECTOR_SIZE, 1871 (void *)l1_table, l1_sectors); 1872 if (ret < 0) { 1873 goto fail; 1874 } 1875 1876 for (j = 0; j < s->snapshots[i].l1_size; j++) { 1877 be64_to_cpus(&l1_table[j]); 1878 } 1879 1880 ret = expand_zero_clusters_in_l1(bs, l1_table, s->snapshots[i].l1_size, 1881 &visited_l1_entries, l1_entries, 1882 status_cb, cb_opaque); 1883 if (ret < 0) { 1884 goto fail; 1885 } 1886 } 1887 1888 ret = 0; 1889 1890 fail: 1891 g_free(l1_table); 1892 return ret; 1893 } 1894