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 27 #include "block/qdict.h" 28 #include "sysemu/block-backend.h" 29 #include "qemu/main-loop.h" 30 #include "qemu/module.h" 31 #include "qcow2.h" 32 #include "qemu/error-report.h" 33 #include "qapi/error.h" 34 #include "qapi/qapi-events-block-core.h" 35 #include "qapi/qmp/qdict.h" 36 #include "qapi/qmp/qstring.h" 37 #include "trace.h" 38 #include "qemu/option_int.h" 39 #include "qemu/cutils.h" 40 #include "qemu/bswap.h" 41 #include "qapi/qobject-input-visitor.h" 42 #include "qapi/qapi-visit-block-core.h" 43 #include "crypto.h" 44 #include "block/aio_task.h" 45 46 /* 47 Differences with QCOW: 48 49 - Support for multiple incremental snapshots. 50 - Memory management by reference counts. 51 - Clusters which have a reference count of one have the bit 52 QCOW_OFLAG_COPIED to optimize write performance. 53 - Size of compressed clusters is stored in sectors to reduce bit usage 54 in the cluster offsets. 55 - Support for storing additional data (such as the VM state) in the 56 snapshots. 57 - If a backing store is used, the cluster size is not constrained 58 (could be backported to QCOW). 59 - L2 tables have always a size of one cluster. 60 */ 61 62 63 typedef struct { 64 uint32_t magic; 65 uint32_t len; 66 } QEMU_PACKED QCowExtension; 67 68 #define QCOW2_EXT_MAGIC_END 0 69 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA 70 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857 71 #define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77 72 #define QCOW2_EXT_MAGIC_BITMAPS 0x23852875 73 #define QCOW2_EXT_MAGIC_DATA_FILE 0x44415441 74 75 static int coroutine_fn 76 qcow2_co_preadv_compressed(BlockDriverState *bs, 77 uint64_t file_cluster_offset, 78 uint64_t offset, 79 uint64_t bytes, 80 QEMUIOVector *qiov, 81 size_t qiov_offset); 82 83 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename) 84 { 85 const QCowHeader *cow_header = (const void *)buf; 86 87 if (buf_size >= sizeof(QCowHeader) && 88 be32_to_cpu(cow_header->magic) == QCOW_MAGIC && 89 be32_to_cpu(cow_header->version) >= 2) 90 return 100; 91 else 92 return 0; 93 } 94 95 96 static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset, 97 uint8_t *buf, size_t buflen, 98 void *opaque, Error **errp) 99 { 100 BlockDriverState *bs = opaque; 101 BDRVQcow2State *s = bs->opaque; 102 ssize_t ret; 103 104 if ((offset + buflen) > s->crypto_header.length) { 105 error_setg(errp, "Request for data outside of extension header"); 106 return -1; 107 } 108 109 ret = bdrv_pread(bs->file, 110 s->crypto_header.offset + offset, buf, buflen); 111 if (ret < 0) { 112 error_setg_errno(errp, -ret, "Could not read encryption header"); 113 return -1; 114 } 115 return ret; 116 } 117 118 119 static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen, 120 void *opaque, Error **errp) 121 { 122 BlockDriverState *bs = opaque; 123 BDRVQcow2State *s = bs->opaque; 124 int64_t ret; 125 int64_t clusterlen; 126 127 ret = qcow2_alloc_clusters(bs, headerlen); 128 if (ret < 0) { 129 error_setg_errno(errp, -ret, 130 "Cannot allocate cluster for LUKS header size %zu", 131 headerlen); 132 return -1; 133 } 134 135 s->crypto_header.length = headerlen; 136 s->crypto_header.offset = ret; 137 138 /* 139 * Zero fill all space in cluster so it has predictable 140 * content, as we may not initialize some regions of the 141 * header (eg only 1 out of 8 key slots will be initialized) 142 */ 143 clusterlen = size_to_clusters(s, headerlen) * s->cluster_size; 144 assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0); 145 ret = bdrv_pwrite_zeroes(bs->file, 146 ret, 147 clusterlen, 0); 148 if (ret < 0) { 149 error_setg_errno(errp, -ret, "Could not zero fill encryption header"); 150 return -1; 151 } 152 153 return ret; 154 } 155 156 157 static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset, 158 const uint8_t *buf, size_t buflen, 159 void *opaque, Error **errp) 160 { 161 BlockDriverState *bs = opaque; 162 BDRVQcow2State *s = bs->opaque; 163 ssize_t ret; 164 165 if ((offset + buflen) > s->crypto_header.length) { 166 error_setg(errp, "Request for data outside of extension header"); 167 return -1; 168 } 169 170 ret = bdrv_pwrite(bs->file, 171 s->crypto_header.offset + offset, buf, buflen); 172 if (ret < 0) { 173 error_setg_errno(errp, -ret, "Could not read encryption header"); 174 return -1; 175 } 176 return ret; 177 } 178 179 180 /* 181 * read qcow2 extension and fill bs 182 * start reading from start_offset 183 * finish reading upon magic of value 0 or when end_offset reached 184 * unknown magic is skipped (future extension this version knows nothing about) 185 * return 0 upon success, non-0 otherwise 186 */ 187 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, 188 uint64_t end_offset, void **p_feature_table, 189 int flags, bool *need_update_header, 190 Error **errp) 191 { 192 BDRVQcow2State *s = bs->opaque; 193 QCowExtension ext; 194 uint64_t offset; 195 int ret; 196 Qcow2BitmapHeaderExt bitmaps_ext; 197 198 if (need_update_header != NULL) { 199 *need_update_header = false; 200 } 201 202 #ifdef DEBUG_EXT 203 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset); 204 #endif 205 offset = start_offset; 206 while (offset < end_offset) { 207 208 #ifdef DEBUG_EXT 209 /* Sanity check */ 210 if (offset > s->cluster_size) 211 printf("qcow2_read_extension: suspicious offset %lu\n", offset); 212 213 printf("attempting to read extended header in offset %lu\n", offset); 214 #endif 215 216 ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext)); 217 if (ret < 0) { 218 error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: " 219 "pread fail from offset %" PRIu64, offset); 220 return 1; 221 } 222 ext.magic = be32_to_cpu(ext.magic); 223 ext.len = be32_to_cpu(ext.len); 224 offset += sizeof(ext); 225 #ifdef DEBUG_EXT 226 printf("ext.magic = 0x%x\n", ext.magic); 227 #endif 228 if (offset > end_offset || ext.len > end_offset - offset) { 229 error_setg(errp, "Header extension too large"); 230 return -EINVAL; 231 } 232 233 switch (ext.magic) { 234 case QCOW2_EXT_MAGIC_END: 235 return 0; 236 237 case QCOW2_EXT_MAGIC_BACKING_FORMAT: 238 if (ext.len >= sizeof(bs->backing_format)) { 239 error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32 240 " too large (>=%zu)", ext.len, 241 sizeof(bs->backing_format)); 242 return 2; 243 } 244 ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len); 245 if (ret < 0) { 246 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: " 247 "Could not read format name"); 248 return 3; 249 } 250 bs->backing_format[ext.len] = '\0'; 251 s->image_backing_format = g_strdup(bs->backing_format); 252 #ifdef DEBUG_EXT 253 printf("Qcow2: Got format extension %s\n", bs->backing_format); 254 #endif 255 break; 256 257 case QCOW2_EXT_MAGIC_FEATURE_TABLE: 258 if (p_feature_table != NULL) { 259 void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature)); 260 ret = bdrv_pread(bs->file, offset , feature_table, ext.len); 261 if (ret < 0) { 262 error_setg_errno(errp, -ret, "ERROR: ext_feature_table: " 263 "Could not read table"); 264 return ret; 265 } 266 267 *p_feature_table = feature_table; 268 } 269 break; 270 271 case QCOW2_EXT_MAGIC_CRYPTO_HEADER: { 272 unsigned int cflags = 0; 273 if (s->crypt_method_header != QCOW_CRYPT_LUKS) { 274 error_setg(errp, "CRYPTO header extension only " 275 "expected with LUKS encryption method"); 276 return -EINVAL; 277 } 278 if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) { 279 error_setg(errp, "CRYPTO header extension size %u, " 280 "but expected size %zu", ext.len, 281 sizeof(Qcow2CryptoHeaderExtension)); 282 return -EINVAL; 283 } 284 285 ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len); 286 if (ret < 0) { 287 error_setg_errno(errp, -ret, 288 "Unable to read CRYPTO header extension"); 289 return ret; 290 } 291 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset); 292 s->crypto_header.length = be64_to_cpu(s->crypto_header.length); 293 294 if ((s->crypto_header.offset % s->cluster_size) != 0) { 295 error_setg(errp, "Encryption header offset '%" PRIu64 "' is " 296 "not a multiple of cluster size '%u'", 297 s->crypto_header.offset, s->cluster_size); 298 return -EINVAL; 299 } 300 301 if (flags & BDRV_O_NO_IO) { 302 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; 303 } 304 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", 305 qcow2_crypto_hdr_read_func, 306 bs, cflags, QCOW2_MAX_THREADS, errp); 307 if (!s->crypto) { 308 return -EINVAL; 309 } 310 } break; 311 312 case QCOW2_EXT_MAGIC_BITMAPS: 313 if (ext.len != sizeof(bitmaps_ext)) { 314 error_setg_errno(errp, -ret, "bitmaps_ext: " 315 "Invalid extension length"); 316 return -EINVAL; 317 } 318 319 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) { 320 if (s->qcow_version < 3) { 321 /* Let's be a bit more specific */ 322 warn_report("This qcow2 v2 image contains bitmaps, but " 323 "they may have been modified by a program " 324 "without persistent bitmap support; so now " 325 "they must all be considered inconsistent"); 326 } else { 327 warn_report("a program lacking bitmap support " 328 "modified this file, so all bitmaps are now " 329 "considered inconsistent"); 330 } 331 error_printf("Some clusters may be leaked, " 332 "run 'qemu-img check -r' on the image " 333 "file to fix."); 334 if (need_update_header != NULL) { 335 /* Updating is needed to drop invalid bitmap extension. */ 336 *need_update_header = true; 337 } 338 break; 339 } 340 341 ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len); 342 if (ret < 0) { 343 error_setg_errno(errp, -ret, "bitmaps_ext: " 344 "Could not read ext header"); 345 return ret; 346 } 347 348 if (bitmaps_ext.reserved32 != 0) { 349 error_setg_errno(errp, -ret, "bitmaps_ext: " 350 "Reserved field is not zero"); 351 return -EINVAL; 352 } 353 354 bitmaps_ext.nb_bitmaps = be32_to_cpu(bitmaps_ext.nb_bitmaps); 355 bitmaps_ext.bitmap_directory_size = 356 be64_to_cpu(bitmaps_ext.bitmap_directory_size); 357 bitmaps_ext.bitmap_directory_offset = 358 be64_to_cpu(bitmaps_ext.bitmap_directory_offset); 359 360 if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) { 361 error_setg(errp, 362 "bitmaps_ext: Image has %" PRIu32 " bitmaps, " 363 "exceeding the QEMU supported maximum of %d", 364 bitmaps_ext.nb_bitmaps, QCOW2_MAX_BITMAPS); 365 return -EINVAL; 366 } 367 368 if (bitmaps_ext.nb_bitmaps == 0) { 369 error_setg(errp, "found bitmaps extension with zero bitmaps"); 370 return -EINVAL; 371 } 372 373 if (offset_into_cluster(s, bitmaps_ext.bitmap_directory_offset)) { 374 error_setg(errp, "bitmaps_ext: " 375 "invalid bitmap directory offset"); 376 return -EINVAL; 377 } 378 379 if (bitmaps_ext.bitmap_directory_size > 380 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 381 error_setg(errp, "bitmaps_ext: " 382 "bitmap directory size (%" PRIu64 ") exceeds " 383 "the maximum supported size (%d)", 384 bitmaps_ext.bitmap_directory_size, 385 QCOW2_MAX_BITMAP_DIRECTORY_SIZE); 386 return -EINVAL; 387 } 388 389 s->nb_bitmaps = bitmaps_ext.nb_bitmaps; 390 s->bitmap_directory_offset = 391 bitmaps_ext.bitmap_directory_offset; 392 s->bitmap_directory_size = 393 bitmaps_ext.bitmap_directory_size; 394 395 #ifdef DEBUG_EXT 396 printf("Qcow2: Got bitmaps extension: " 397 "offset=%" PRIu64 " nb_bitmaps=%" PRIu32 "\n", 398 s->bitmap_directory_offset, s->nb_bitmaps); 399 #endif 400 break; 401 402 case QCOW2_EXT_MAGIC_DATA_FILE: 403 { 404 s->image_data_file = g_malloc0(ext.len + 1); 405 ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len); 406 if (ret < 0) { 407 error_setg_errno(errp, -ret, 408 "ERROR: Could not read data file name"); 409 return ret; 410 } 411 #ifdef DEBUG_EXT 412 printf("Qcow2: Got external data file %s\n", s->image_data_file); 413 #endif 414 break; 415 } 416 417 default: 418 /* unknown magic - save it in case we need to rewrite the header */ 419 /* If you add a new feature, make sure to also update the fast 420 * path of qcow2_make_empty() to deal with it. */ 421 { 422 Qcow2UnknownHeaderExtension *uext; 423 424 uext = g_malloc0(sizeof(*uext) + ext.len); 425 uext->magic = ext.magic; 426 uext->len = ext.len; 427 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next); 428 429 ret = bdrv_pread(bs->file, offset , uext->data, uext->len); 430 if (ret < 0) { 431 error_setg_errno(errp, -ret, "ERROR: unknown extension: " 432 "Could not read data"); 433 return ret; 434 } 435 } 436 break; 437 } 438 439 offset += ((ext.len + 7) & ~7); 440 } 441 442 return 0; 443 } 444 445 static void cleanup_unknown_header_ext(BlockDriverState *bs) 446 { 447 BDRVQcow2State *s = bs->opaque; 448 Qcow2UnknownHeaderExtension *uext, *next; 449 450 QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) { 451 QLIST_REMOVE(uext, next); 452 g_free(uext); 453 } 454 } 455 456 static void report_unsupported_feature(Error **errp, Qcow2Feature *table, 457 uint64_t mask) 458 { 459 g_autoptr(GString) features = g_string_sized_new(60); 460 461 while (table && table->name[0] != '\0') { 462 if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) { 463 if (mask & (1ULL << table->bit)) { 464 if (features->len > 0) { 465 g_string_append(features, ", "); 466 } 467 g_string_append_printf(features, "%.46s", table->name); 468 mask &= ~(1ULL << table->bit); 469 } 470 } 471 table++; 472 } 473 474 if (mask) { 475 if (features->len > 0) { 476 g_string_append(features, ", "); 477 } 478 g_string_append_printf(features, 479 "Unknown incompatible feature: %" PRIx64, mask); 480 } 481 482 error_setg(errp, "Unsupported qcow2 feature(s): %s", features->str); 483 } 484 485 /* 486 * Sets the dirty bit and flushes afterwards if necessary. 487 * 488 * The incompatible_features bit is only set if the image file header was 489 * updated successfully. Therefore it is not required to check the return 490 * value of this function. 491 */ 492 int qcow2_mark_dirty(BlockDriverState *bs) 493 { 494 BDRVQcow2State *s = bs->opaque; 495 uint64_t val; 496 int ret; 497 498 assert(s->qcow_version >= 3); 499 500 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 501 return 0; /* already dirty */ 502 } 503 504 val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY); 505 ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features), 506 &val, sizeof(val)); 507 if (ret < 0) { 508 return ret; 509 } 510 ret = bdrv_flush(bs->file->bs); 511 if (ret < 0) { 512 return ret; 513 } 514 515 /* Only treat image as dirty if the header was updated successfully */ 516 s->incompatible_features |= QCOW2_INCOMPAT_DIRTY; 517 return 0; 518 } 519 520 /* 521 * Clears the dirty bit and flushes before if necessary. Only call this 522 * function when there are no pending requests, it does not guard against 523 * concurrent requests dirtying the image. 524 */ 525 static int qcow2_mark_clean(BlockDriverState *bs) 526 { 527 BDRVQcow2State *s = bs->opaque; 528 529 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 530 int ret; 531 532 s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY; 533 534 ret = qcow2_flush_caches(bs); 535 if (ret < 0) { 536 return ret; 537 } 538 539 return qcow2_update_header(bs); 540 } 541 return 0; 542 } 543 544 /* 545 * Marks the image as corrupt. 546 */ 547 int qcow2_mark_corrupt(BlockDriverState *bs) 548 { 549 BDRVQcow2State *s = bs->opaque; 550 551 s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT; 552 return qcow2_update_header(bs); 553 } 554 555 /* 556 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes 557 * before if necessary. 558 */ 559 int qcow2_mark_consistent(BlockDriverState *bs) 560 { 561 BDRVQcow2State *s = bs->opaque; 562 563 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { 564 int ret = qcow2_flush_caches(bs); 565 if (ret < 0) { 566 return ret; 567 } 568 569 s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT; 570 return qcow2_update_header(bs); 571 } 572 return 0; 573 } 574 575 static void qcow2_add_check_result(BdrvCheckResult *out, 576 const BdrvCheckResult *src, 577 bool set_allocation_info) 578 { 579 out->corruptions += src->corruptions; 580 out->leaks += src->leaks; 581 out->check_errors += src->check_errors; 582 out->corruptions_fixed += src->corruptions_fixed; 583 out->leaks_fixed += src->leaks_fixed; 584 585 if (set_allocation_info) { 586 out->image_end_offset = src->image_end_offset; 587 out->bfi = src->bfi; 588 } 589 } 590 591 static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs, 592 BdrvCheckResult *result, 593 BdrvCheckMode fix) 594 { 595 BdrvCheckResult snapshot_res = {}; 596 BdrvCheckResult refcount_res = {}; 597 int ret; 598 599 memset(result, 0, sizeof(*result)); 600 601 ret = qcow2_check_read_snapshot_table(bs, &snapshot_res, fix); 602 if (ret < 0) { 603 qcow2_add_check_result(result, &snapshot_res, false); 604 return ret; 605 } 606 607 ret = qcow2_check_refcounts(bs, &refcount_res, fix); 608 qcow2_add_check_result(result, &refcount_res, true); 609 if (ret < 0) { 610 qcow2_add_check_result(result, &snapshot_res, false); 611 return ret; 612 } 613 614 ret = qcow2_check_fix_snapshot_table(bs, &snapshot_res, fix); 615 qcow2_add_check_result(result, &snapshot_res, false); 616 if (ret < 0) { 617 return ret; 618 } 619 620 if (fix && result->check_errors == 0 && result->corruptions == 0) { 621 ret = qcow2_mark_clean(bs); 622 if (ret < 0) { 623 return ret; 624 } 625 return qcow2_mark_consistent(bs); 626 } 627 return ret; 628 } 629 630 static int coroutine_fn qcow2_co_check(BlockDriverState *bs, 631 BdrvCheckResult *result, 632 BdrvCheckMode fix) 633 { 634 BDRVQcow2State *s = bs->opaque; 635 int ret; 636 637 qemu_co_mutex_lock(&s->lock); 638 ret = qcow2_co_check_locked(bs, result, fix); 639 qemu_co_mutex_unlock(&s->lock); 640 return ret; 641 } 642 643 int qcow2_validate_table(BlockDriverState *bs, uint64_t offset, 644 uint64_t entries, size_t entry_len, 645 int64_t max_size_bytes, const char *table_name, 646 Error **errp) 647 { 648 BDRVQcow2State *s = bs->opaque; 649 650 if (entries > max_size_bytes / entry_len) { 651 error_setg(errp, "%s too large", table_name); 652 return -EFBIG; 653 } 654 655 /* Use signed INT64_MAX as the maximum even for uint64_t header fields, 656 * because values will be passed to qemu functions taking int64_t. */ 657 if ((INT64_MAX - entries * entry_len < offset) || 658 (offset_into_cluster(s, offset) != 0)) { 659 error_setg(errp, "%s offset invalid", table_name); 660 return -EINVAL; 661 } 662 663 return 0; 664 } 665 666 static const char *const mutable_opts[] = { 667 QCOW2_OPT_LAZY_REFCOUNTS, 668 QCOW2_OPT_DISCARD_REQUEST, 669 QCOW2_OPT_DISCARD_SNAPSHOT, 670 QCOW2_OPT_DISCARD_OTHER, 671 QCOW2_OPT_OVERLAP, 672 QCOW2_OPT_OVERLAP_TEMPLATE, 673 QCOW2_OPT_OVERLAP_MAIN_HEADER, 674 QCOW2_OPT_OVERLAP_ACTIVE_L1, 675 QCOW2_OPT_OVERLAP_ACTIVE_L2, 676 QCOW2_OPT_OVERLAP_REFCOUNT_TABLE, 677 QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK, 678 QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE, 679 QCOW2_OPT_OVERLAP_INACTIVE_L1, 680 QCOW2_OPT_OVERLAP_INACTIVE_L2, 681 QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY, 682 QCOW2_OPT_CACHE_SIZE, 683 QCOW2_OPT_L2_CACHE_SIZE, 684 QCOW2_OPT_L2_CACHE_ENTRY_SIZE, 685 QCOW2_OPT_REFCOUNT_CACHE_SIZE, 686 QCOW2_OPT_CACHE_CLEAN_INTERVAL, 687 NULL 688 }; 689 690 static QemuOptsList qcow2_runtime_opts = { 691 .name = "qcow2", 692 .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head), 693 .desc = { 694 { 695 .name = QCOW2_OPT_LAZY_REFCOUNTS, 696 .type = QEMU_OPT_BOOL, 697 .help = "Postpone refcount updates", 698 }, 699 { 700 .name = QCOW2_OPT_DISCARD_REQUEST, 701 .type = QEMU_OPT_BOOL, 702 .help = "Pass guest discard requests to the layer below", 703 }, 704 { 705 .name = QCOW2_OPT_DISCARD_SNAPSHOT, 706 .type = QEMU_OPT_BOOL, 707 .help = "Generate discard requests when snapshot related space " 708 "is freed", 709 }, 710 { 711 .name = QCOW2_OPT_DISCARD_OTHER, 712 .type = QEMU_OPT_BOOL, 713 .help = "Generate discard requests when other clusters are freed", 714 }, 715 { 716 .name = QCOW2_OPT_OVERLAP, 717 .type = QEMU_OPT_STRING, 718 .help = "Selects which overlap checks to perform from a range of " 719 "templates (none, constant, cached, all)", 720 }, 721 { 722 .name = QCOW2_OPT_OVERLAP_TEMPLATE, 723 .type = QEMU_OPT_STRING, 724 .help = "Selects which overlap checks to perform from a range of " 725 "templates (none, constant, cached, all)", 726 }, 727 { 728 .name = QCOW2_OPT_OVERLAP_MAIN_HEADER, 729 .type = QEMU_OPT_BOOL, 730 .help = "Check for unintended writes into the main qcow2 header", 731 }, 732 { 733 .name = QCOW2_OPT_OVERLAP_ACTIVE_L1, 734 .type = QEMU_OPT_BOOL, 735 .help = "Check for unintended writes into the active L1 table", 736 }, 737 { 738 .name = QCOW2_OPT_OVERLAP_ACTIVE_L2, 739 .type = QEMU_OPT_BOOL, 740 .help = "Check for unintended writes into an active L2 table", 741 }, 742 { 743 .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE, 744 .type = QEMU_OPT_BOOL, 745 .help = "Check for unintended writes into the refcount table", 746 }, 747 { 748 .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK, 749 .type = QEMU_OPT_BOOL, 750 .help = "Check for unintended writes into a refcount block", 751 }, 752 { 753 .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE, 754 .type = QEMU_OPT_BOOL, 755 .help = "Check for unintended writes into the snapshot table", 756 }, 757 { 758 .name = QCOW2_OPT_OVERLAP_INACTIVE_L1, 759 .type = QEMU_OPT_BOOL, 760 .help = "Check for unintended writes into an inactive L1 table", 761 }, 762 { 763 .name = QCOW2_OPT_OVERLAP_INACTIVE_L2, 764 .type = QEMU_OPT_BOOL, 765 .help = "Check for unintended writes into an inactive L2 table", 766 }, 767 { 768 .name = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY, 769 .type = QEMU_OPT_BOOL, 770 .help = "Check for unintended writes into the bitmap directory", 771 }, 772 { 773 .name = QCOW2_OPT_CACHE_SIZE, 774 .type = QEMU_OPT_SIZE, 775 .help = "Maximum combined metadata (L2 tables and refcount blocks) " 776 "cache size", 777 }, 778 { 779 .name = QCOW2_OPT_L2_CACHE_SIZE, 780 .type = QEMU_OPT_SIZE, 781 .help = "Maximum L2 table cache size", 782 }, 783 { 784 .name = QCOW2_OPT_L2_CACHE_ENTRY_SIZE, 785 .type = QEMU_OPT_SIZE, 786 .help = "Size of each entry in the L2 cache", 787 }, 788 { 789 .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE, 790 .type = QEMU_OPT_SIZE, 791 .help = "Maximum refcount block cache size", 792 }, 793 { 794 .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL, 795 .type = QEMU_OPT_NUMBER, 796 .help = "Clean unused cache entries after this time (in seconds)", 797 }, 798 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", 799 "ID of secret providing qcow2 AES key or LUKS passphrase"), 800 { /* end of list */ } 801 }, 802 }; 803 804 static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = { 805 [QCOW2_OL_MAIN_HEADER_BITNR] = QCOW2_OPT_OVERLAP_MAIN_HEADER, 806 [QCOW2_OL_ACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L1, 807 [QCOW2_OL_ACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L2, 808 [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE, 809 [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK, 810 [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE, 811 [QCOW2_OL_INACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L1, 812 [QCOW2_OL_INACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L2, 813 [QCOW2_OL_BITMAP_DIRECTORY_BITNR] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY, 814 }; 815 816 static void cache_clean_timer_cb(void *opaque) 817 { 818 BlockDriverState *bs = opaque; 819 BDRVQcow2State *s = bs->opaque; 820 qcow2_cache_clean_unused(s->l2_table_cache); 821 qcow2_cache_clean_unused(s->refcount_block_cache); 822 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 823 (int64_t) s->cache_clean_interval * 1000); 824 } 825 826 static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context) 827 { 828 BDRVQcow2State *s = bs->opaque; 829 if (s->cache_clean_interval > 0) { 830 s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL, 831 SCALE_MS, cache_clean_timer_cb, 832 bs); 833 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 834 (int64_t) s->cache_clean_interval * 1000); 835 } 836 } 837 838 static void cache_clean_timer_del(BlockDriverState *bs) 839 { 840 BDRVQcow2State *s = bs->opaque; 841 if (s->cache_clean_timer) { 842 timer_del(s->cache_clean_timer); 843 timer_free(s->cache_clean_timer); 844 s->cache_clean_timer = NULL; 845 } 846 } 847 848 static void qcow2_detach_aio_context(BlockDriverState *bs) 849 { 850 cache_clean_timer_del(bs); 851 } 852 853 static void qcow2_attach_aio_context(BlockDriverState *bs, 854 AioContext *new_context) 855 { 856 cache_clean_timer_init(bs, new_context); 857 } 858 859 static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts, 860 uint64_t *l2_cache_size, 861 uint64_t *l2_cache_entry_size, 862 uint64_t *refcount_cache_size, Error **errp) 863 { 864 BDRVQcow2State *s = bs->opaque; 865 uint64_t combined_cache_size, l2_cache_max_setting; 866 bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set; 867 bool l2_cache_entry_size_set; 868 int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size; 869 uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE; 870 uint64_t max_l2_entries = DIV_ROUND_UP(virtual_disk_size, s->cluster_size); 871 /* An L2 table is always one cluster in size so the max cache size 872 * should be a multiple of the cluster size. */ 873 uint64_t max_l2_cache = ROUND_UP(max_l2_entries * sizeof(uint64_t), 874 s->cluster_size); 875 876 combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE); 877 l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE); 878 refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 879 l2_cache_entry_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE); 880 881 combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0); 882 l2_cache_max_setting = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE, 883 DEFAULT_L2_CACHE_MAX_SIZE); 884 *refcount_cache_size = qemu_opt_get_size(opts, 885 QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0); 886 887 *l2_cache_entry_size = qemu_opt_get_size( 888 opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE, s->cluster_size); 889 890 *l2_cache_size = MIN(max_l2_cache, l2_cache_max_setting); 891 892 if (combined_cache_size_set) { 893 if (l2_cache_size_set && refcount_cache_size_set) { 894 error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE 895 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set " 896 "at the same time"); 897 return; 898 } else if (l2_cache_size_set && 899 (l2_cache_max_setting > combined_cache_size)) { 900 error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed " 901 QCOW2_OPT_CACHE_SIZE); 902 return; 903 } else if (*refcount_cache_size > combined_cache_size) { 904 error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed " 905 QCOW2_OPT_CACHE_SIZE); 906 return; 907 } 908 909 if (l2_cache_size_set) { 910 *refcount_cache_size = combined_cache_size - *l2_cache_size; 911 } else if (refcount_cache_size_set) { 912 *l2_cache_size = combined_cache_size - *refcount_cache_size; 913 } else { 914 /* Assign as much memory as possible to the L2 cache, and 915 * use the remainder for the refcount cache */ 916 if (combined_cache_size >= max_l2_cache + min_refcount_cache) { 917 *l2_cache_size = max_l2_cache; 918 *refcount_cache_size = combined_cache_size - *l2_cache_size; 919 } else { 920 *refcount_cache_size = 921 MIN(combined_cache_size, min_refcount_cache); 922 *l2_cache_size = combined_cache_size - *refcount_cache_size; 923 } 924 } 925 } 926 927 /* 928 * If the L2 cache is not enough to cover the whole disk then 929 * default to 4KB entries. Smaller entries reduce the cost of 930 * loads and evictions and increase I/O performance. 931 */ 932 if (*l2_cache_size < max_l2_cache && !l2_cache_entry_size_set) { 933 *l2_cache_entry_size = MIN(s->cluster_size, 4096); 934 } 935 936 /* l2_cache_size and refcount_cache_size are ensured to have at least 937 * their minimum values in qcow2_update_options_prepare() */ 938 939 if (*l2_cache_entry_size < (1 << MIN_CLUSTER_BITS) || 940 *l2_cache_entry_size > s->cluster_size || 941 !is_power_of_2(*l2_cache_entry_size)) { 942 error_setg(errp, "L2 cache entry size must be a power of two " 943 "between %d and the cluster size (%d)", 944 1 << MIN_CLUSTER_BITS, s->cluster_size); 945 return; 946 } 947 } 948 949 typedef struct Qcow2ReopenState { 950 Qcow2Cache *l2_table_cache; 951 Qcow2Cache *refcount_block_cache; 952 int l2_slice_size; /* Number of entries in a slice of the L2 table */ 953 bool use_lazy_refcounts; 954 int overlap_check; 955 bool discard_passthrough[QCOW2_DISCARD_MAX]; 956 uint64_t cache_clean_interval; 957 QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */ 958 } Qcow2ReopenState; 959 960 static int qcow2_update_options_prepare(BlockDriverState *bs, 961 Qcow2ReopenState *r, 962 QDict *options, int flags, 963 Error **errp) 964 { 965 BDRVQcow2State *s = bs->opaque; 966 QemuOpts *opts = NULL; 967 const char *opt_overlap_check, *opt_overlap_check_template; 968 int overlap_check_template = 0; 969 uint64_t l2_cache_size, l2_cache_entry_size, refcount_cache_size; 970 int i; 971 const char *encryptfmt; 972 QDict *encryptopts = NULL; 973 Error *local_err = NULL; 974 int ret; 975 976 qdict_extract_subqdict(options, &encryptopts, "encrypt."); 977 encryptfmt = qdict_get_try_str(encryptopts, "format"); 978 979 opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort); 980 qemu_opts_absorb_qdict(opts, options, &local_err); 981 if (local_err) { 982 error_propagate(errp, local_err); 983 ret = -EINVAL; 984 goto fail; 985 } 986 987 /* get L2 table/refcount block cache size from command line options */ 988 read_cache_sizes(bs, opts, &l2_cache_size, &l2_cache_entry_size, 989 &refcount_cache_size, &local_err); 990 if (local_err) { 991 error_propagate(errp, local_err); 992 ret = -EINVAL; 993 goto fail; 994 } 995 996 l2_cache_size /= l2_cache_entry_size; 997 if (l2_cache_size < MIN_L2_CACHE_SIZE) { 998 l2_cache_size = MIN_L2_CACHE_SIZE; 999 } 1000 if (l2_cache_size > INT_MAX) { 1001 error_setg(errp, "L2 cache size too big"); 1002 ret = -EINVAL; 1003 goto fail; 1004 } 1005 1006 refcount_cache_size /= s->cluster_size; 1007 if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) { 1008 refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE; 1009 } 1010 if (refcount_cache_size > INT_MAX) { 1011 error_setg(errp, "Refcount cache size too big"); 1012 ret = -EINVAL; 1013 goto fail; 1014 } 1015 1016 /* alloc new L2 table/refcount block cache, flush old one */ 1017 if (s->l2_table_cache) { 1018 ret = qcow2_cache_flush(bs, s->l2_table_cache); 1019 if (ret) { 1020 error_setg_errno(errp, -ret, "Failed to flush the L2 table cache"); 1021 goto fail; 1022 } 1023 } 1024 1025 if (s->refcount_block_cache) { 1026 ret = qcow2_cache_flush(bs, s->refcount_block_cache); 1027 if (ret) { 1028 error_setg_errno(errp, -ret, 1029 "Failed to flush the refcount block cache"); 1030 goto fail; 1031 } 1032 } 1033 1034 r->l2_slice_size = l2_cache_entry_size / sizeof(uint64_t); 1035 r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size, 1036 l2_cache_entry_size); 1037 r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size, 1038 s->cluster_size); 1039 if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) { 1040 error_setg(errp, "Could not allocate metadata caches"); 1041 ret = -ENOMEM; 1042 goto fail; 1043 } 1044 1045 /* New interval for cache cleanup timer */ 1046 r->cache_clean_interval = 1047 qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL, 1048 DEFAULT_CACHE_CLEAN_INTERVAL); 1049 #ifndef CONFIG_LINUX 1050 if (r->cache_clean_interval != 0) { 1051 error_setg(errp, QCOW2_OPT_CACHE_CLEAN_INTERVAL 1052 " not supported on this host"); 1053 ret = -EINVAL; 1054 goto fail; 1055 } 1056 #endif 1057 if (r->cache_clean_interval > UINT_MAX) { 1058 error_setg(errp, "Cache clean interval too big"); 1059 ret = -EINVAL; 1060 goto fail; 1061 } 1062 1063 /* lazy-refcounts; flush if going from enabled to disabled */ 1064 r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS, 1065 (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS)); 1066 if (r->use_lazy_refcounts && s->qcow_version < 3) { 1067 error_setg(errp, "Lazy refcounts require a qcow2 image with at least " 1068 "qemu 1.1 compatibility level"); 1069 ret = -EINVAL; 1070 goto fail; 1071 } 1072 1073 if (s->use_lazy_refcounts && !r->use_lazy_refcounts) { 1074 ret = qcow2_mark_clean(bs); 1075 if (ret < 0) { 1076 error_setg_errno(errp, -ret, "Failed to disable lazy refcounts"); 1077 goto fail; 1078 } 1079 } 1080 1081 /* Overlap check options */ 1082 opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP); 1083 opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE); 1084 if (opt_overlap_check_template && opt_overlap_check && 1085 strcmp(opt_overlap_check_template, opt_overlap_check)) 1086 { 1087 error_setg(errp, "Conflicting values for qcow2 options '" 1088 QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE 1089 "' ('%s')", opt_overlap_check, opt_overlap_check_template); 1090 ret = -EINVAL; 1091 goto fail; 1092 } 1093 if (!opt_overlap_check) { 1094 opt_overlap_check = opt_overlap_check_template ?: "cached"; 1095 } 1096 1097 if (!strcmp(opt_overlap_check, "none")) { 1098 overlap_check_template = 0; 1099 } else if (!strcmp(opt_overlap_check, "constant")) { 1100 overlap_check_template = QCOW2_OL_CONSTANT; 1101 } else if (!strcmp(opt_overlap_check, "cached")) { 1102 overlap_check_template = QCOW2_OL_CACHED; 1103 } else if (!strcmp(opt_overlap_check, "all")) { 1104 overlap_check_template = QCOW2_OL_ALL; 1105 } else { 1106 error_setg(errp, "Unsupported value '%s' for qcow2 option " 1107 "'overlap-check'. Allowed are any of the following: " 1108 "none, constant, cached, all", opt_overlap_check); 1109 ret = -EINVAL; 1110 goto fail; 1111 } 1112 1113 r->overlap_check = 0; 1114 for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) { 1115 /* overlap-check defines a template bitmask, but every flag may be 1116 * overwritten through the associated boolean option */ 1117 r->overlap_check |= 1118 qemu_opt_get_bool(opts, overlap_bool_option_names[i], 1119 overlap_check_template & (1 << i)) << i; 1120 } 1121 1122 r->discard_passthrough[QCOW2_DISCARD_NEVER] = false; 1123 r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true; 1124 r->discard_passthrough[QCOW2_DISCARD_REQUEST] = 1125 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST, 1126 flags & BDRV_O_UNMAP); 1127 r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] = 1128 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true); 1129 r->discard_passthrough[QCOW2_DISCARD_OTHER] = 1130 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false); 1131 1132 switch (s->crypt_method_header) { 1133 case QCOW_CRYPT_NONE: 1134 if (encryptfmt) { 1135 error_setg(errp, "No encryption in image header, but options " 1136 "specified format '%s'", encryptfmt); 1137 ret = -EINVAL; 1138 goto fail; 1139 } 1140 break; 1141 1142 case QCOW_CRYPT_AES: 1143 if (encryptfmt && !g_str_equal(encryptfmt, "aes")) { 1144 error_setg(errp, 1145 "Header reported 'aes' encryption format but " 1146 "options specify '%s'", encryptfmt); 1147 ret = -EINVAL; 1148 goto fail; 1149 } 1150 qdict_put_str(encryptopts, "format", "qcow"); 1151 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp); 1152 break; 1153 1154 case QCOW_CRYPT_LUKS: 1155 if (encryptfmt && !g_str_equal(encryptfmt, "luks")) { 1156 error_setg(errp, 1157 "Header reported 'luks' encryption format but " 1158 "options specify '%s'", encryptfmt); 1159 ret = -EINVAL; 1160 goto fail; 1161 } 1162 qdict_put_str(encryptopts, "format", "luks"); 1163 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp); 1164 break; 1165 1166 default: 1167 error_setg(errp, "Unsupported encryption method %d", 1168 s->crypt_method_header); 1169 break; 1170 } 1171 if (s->crypt_method_header != QCOW_CRYPT_NONE && !r->crypto_opts) { 1172 ret = -EINVAL; 1173 goto fail; 1174 } 1175 1176 ret = 0; 1177 fail: 1178 qobject_unref(encryptopts); 1179 qemu_opts_del(opts); 1180 opts = NULL; 1181 return ret; 1182 } 1183 1184 static void qcow2_update_options_commit(BlockDriverState *bs, 1185 Qcow2ReopenState *r) 1186 { 1187 BDRVQcow2State *s = bs->opaque; 1188 int i; 1189 1190 if (s->l2_table_cache) { 1191 qcow2_cache_destroy(s->l2_table_cache); 1192 } 1193 if (s->refcount_block_cache) { 1194 qcow2_cache_destroy(s->refcount_block_cache); 1195 } 1196 s->l2_table_cache = r->l2_table_cache; 1197 s->refcount_block_cache = r->refcount_block_cache; 1198 s->l2_slice_size = r->l2_slice_size; 1199 1200 s->overlap_check = r->overlap_check; 1201 s->use_lazy_refcounts = r->use_lazy_refcounts; 1202 1203 for (i = 0; i < QCOW2_DISCARD_MAX; i++) { 1204 s->discard_passthrough[i] = r->discard_passthrough[i]; 1205 } 1206 1207 if (s->cache_clean_interval != r->cache_clean_interval) { 1208 cache_clean_timer_del(bs); 1209 s->cache_clean_interval = r->cache_clean_interval; 1210 cache_clean_timer_init(bs, bdrv_get_aio_context(bs)); 1211 } 1212 1213 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); 1214 s->crypto_opts = r->crypto_opts; 1215 } 1216 1217 static void qcow2_update_options_abort(BlockDriverState *bs, 1218 Qcow2ReopenState *r) 1219 { 1220 if (r->l2_table_cache) { 1221 qcow2_cache_destroy(r->l2_table_cache); 1222 } 1223 if (r->refcount_block_cache) { 1224 qcow2_cache_destroy(r->refcount_block_cache); 1225 } 1226 qapi_free_QCryptoBlockOpenOptions(r->crypto_opts); 1227 } 1228 1229 static int qcow2_update_options(BlockDriverState *bs, QDict *options, 1230 int flags, Error **errp) 1231 { 1232 Qcow2ReopenState r = {}; 1233 int ret; 1234 1235 ret = qcow2_update_options_prepare(bs, &r, options, flags, errp); 1236 if (ret >= 0) { 1237 qcow2_update_options_commit(bs, &r); 1238 } else { 1239 qcow2_update_options_abort(bs, &r); 1240 } 1241 1242 return ret; 1243 } 1244 1245 /* Called with s->lock held. */ 1246 static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, 1247 int flags, Error **errp) 1248 { 1249 BDRVQcow2State *s = bs->opaque; 1250 unsigned int len, i; 1251 int ret = 0; 1252 QCowHeader header; 1253 Error *local_err = NULL; 1254 uint64_t ext_end; 1255 uint64_t l1_vm_state_index; 1256 bool update_header = false; 1257 1258 ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); 1259 if (ret < 0) { 1260 error_setg_errno(errp, -ret, "Could not read qcow2 header"); 1261 goto fail; 1262 } 1263 header.magic = be32_to_cpu(header.magic); 1264 header.version = be32_to_cpu(header.version); 1265 header.backing_file_offset = be64_to_cpu(header.backing_file_offset); 1266 header.backing_file_size = be32_to_cpu(header.backing_file_size); 1267 header.size = be64_to_cpu(header.size); 1268 header.cluster_bits = be32_to_cpu(header.cluster_bits); 1269 header.crypt_method = be32_to_cpu(header.crypt_method); 1270 header.l1_table_offset = be64_to_cpu(header.l1_table_offset); 1271 header.l1_size = be32_to_cpu(header.l1_size); 1272 header.refcount_table_offset = be64_to_cpu(header.refcount_table_offset); 1273 header.refcount_table_clusters = 1274 be32_to_cpu(header.refcount_table_clusters); 1275 header.snapshots_offset = be64_to_cpu(header.snapshots_offset); 1276 header.nb_snapshots = be32_to_cpu(header.nb_snapshots); 1277 1278 if (header.magic != QCOW_MAGIC) { 1279 error_setg(errp, "Image is not in qcow2 format"); 1280 ret = -EINVAL; 1281 goto fail; 1282 } 1283 if (header.version < 2 || header.version > 3) { 1284 error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version); 1285 ret = -ENOTSUP; 1286 goto fail; 1287 } 1288 1289 s->qcow_version = header.version; 1290 1291 /* Initialise cluster size */ 1292 if (header.cluster_bits < MIN_CLUSTER_BITS || 1293 header.cluster_bits > MAX_CLUSTER_BITS) { 1294 error_setg(errp, "Unsupported cluster size: 2^%" PRIu32, 1295 header.cluster_bits); 1296 ret = -EINVAL; 1297 goto fail; 1298 } 1299 1300 s->cluster_bits = header.cluster_bits; 1301 s->cluster_size = 1 << s->cluster_bits; 1302 1303 /* Initialise version 3 header fields */ 1304 if (header.version == 2) { 1305 header.incompatible_features = 0; 1306 header.compatible_features = 0; 1307 header.autoclear_features = 0; 1308 header.refcount_order = 4; 1309 header.header_length = 72; 1310 } else { 1311 header.incompatible_features = 1312 be64_to_cpu(header.incompatible_features); 1313 header.compatible_features = be64_to_cpu(header.compatible_features); 1314 header.autoclear_features = be64_to_cpu(header.autoclear_features); 1315 header.refcount_order = be32_to_cpu(header.refcount_order); 1316 header.header_length = be32_to_cpu(header.header_length); 1317 1318 if (header.header_length < 104) { 1319 error_setg(errp, "qcow2 header too short"); 1320 ret = -EINVAL; 1321 goto fail; 1322 } 1323 } 1324 1325 if (header.header_length > s->cluster_size) { 1326 error_setg(errp, "qcow2 header exceeds cluster size"); 1327 ret = -EINVAL; 1328 goto fail; 1329 } 1330 1331 if (header.header_length > sizeof(header)) { 1332 s->unknown_header_fields_size = header.header_length - sizeof(header); 1333 s->unknown_header_fields = g_malloc(s->unknown_header_fields_size); 1334 ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields, 1335 s->unknown_header_fields_size); 1336 if (ret < 0) { 1337 error_setg_errno(errp, -ret, "Could not read unknown qcow2 header " 1338 "fields"); 1339 goto fail; 1340 } 1341 } 1342 1343 if (header.backing_file_offset > s->cluster_size) { 1344 error_setg(errp, "Invalid backing file offset"); 1345 ret = -EINVAL; 1346 goto fail; 1347 } 1348 1349 if (header.backing_file_offset) { 1350 ext_end = header.backing_file_offset; 1351 } else { 1352 ext_end = 1 << header.cluster_bits; 1353 } 1354 1355 /* Handle feature bits */ 1356 s->incompatible_features = header.incompatible_features; 1357 s->compatible_features = header.compatible_features; 1358 s->autoclear_features = header.autoclear_features; 1359 1360 if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) { 1361 void *feature_table = NULL; 1362 qcow2_read_extensions(bs, header.header_length, ext_end, 1363 &feature_table, flags, NULL, NULL); 1364 report_unsupported_feature(errp, feature_table, 1365 s->incompatible_features & 1366 ~QCOW2_INCOMPAT_MASK); 1367 ret = -ENOTSUP; 1368 g_free(feature_table); 1369 goto fail; 1370 } 1371 1372 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { 1373 /* Corrupt images may not be written to unless they are being repaired 1374 */ 1375 if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) { 1376 error_setg(errp, "qcow2: Image is corrupt; cannot be opened " 1377 "read/write"); 1378 ret = -EACCES; 1379 goto fail; 1380 } 1381 } 1382 1383 /* Check support for various header values */ 1384 if (header.refcount_order > 6) { 1385 error_setg(errp, "Reference count entry width too large; may not " 1386 "exceed 64 bits"); 1387 ret = -EINVAL; 1388 goto fail; 1389 } 1390 s->refcount_order = header.refcount_order; 1391 s->refcount_bits = 1 << s->refcount_order; 1392 s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1); 1393 s->refcount_max += s->refcount_max - 1; 1394 1395 s->crypt_method_header = header.crypt_method; 1396 if (s->crypt_method_header) { 1397 if (bdrv_uses_whitelist() && 1398 s->crypt_method_header == QCOW_CRYPT_AES) { 1399 error_setg(errp, 1400 "Use of AES-CBC encrypted qcow2 images is no longer " 1401 "supported in system emulators"); 1402 error_append_hint(errp, 1403 "You can use 'qemu-img convert' to convert your " 1404 "image to an alternative supported format, such " 1405 "as unencrypted qcow2, or raw with the LUKS " 1406 "format instead.\n"); 1407 ret = -ENOSYS; 1408 goto fail; 1409 } 1410 1411 if (s->crypt_method_header == QCOW_CRYPT_AES) { 1412 s->crypt_physical_offset = false; 1413 } else { 1414 /* Assuming LUKS and any future crypt methods we 1415 * add will all use physical offsets, due to the 1416 * fact that the alternative is insecure... */ 1417 s->crypt_physical_offset = true; 1418 } 1419 1420 bs->encrypted = true; 1421 } 1422 1423 s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */ 1424 s->l2_size = 1 << s->l2_bits; 1425 /* 2^(s->refcount_order - 3) is the refcount width in bytes */ 1426 s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3); 1427 s->refcount_block_size = 1 << s->refcount_block_bits; 1428 bs->total_sectors = header.size / BDRV_SECTOR_SIZE; 1429 s->csize_shift = (62 - (s->cluster_bits - 8)); 1430 s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; 1431 s->cluster_offset_mask = (1LL << s->csize_shift) - 1; 1432 1433 s->refcount_table_offset = header.refcount_table_offset; 1434 s->refcount_table_size = 1435 header.refcount_table_clusters << (s->cluster_bits - 3); 1436 1437 if (header.refcount_table_clusters == 0 && !(flags & BDRV_O_CHECK)) { 1438 error_setg(errp, "Image does not contain a reference count table"); 1439 ret = -EINVAL; 1440 goto fail; 1441 } 1442 1443 ret = qcow2_validate_table(bs, s->refcount_table_offset, 1444 header.refcount_table_clusters, 1445 s->cluster_size, QCOW_MAX_REFTABLE_SIZE, 1446 "Reference count table", errp); 1447 if (ret < 0) { 1448 goto fail; 1449 } 1450 1451 if (!(flags & BDRV_O_CHECK)) { 1452 /* 1453 * The total size in bytes of the snapshot table is checked in 1454 * qcow2_read_snapshots() because the size of each snapshot is 1455 * variable and we don't know it yet. 1456 * Here we only check the offset and number of snapshots. 1457 */ 1458 ret = qcow2_validate_table(bs, header.snapshots_offset, 1459 header.nb_snapshots, 1460 sizeof(QCowSnapshotHeader), 1461 sizeof(QCowSnapshotHeader) * 1462 QCOW_MAX_SNAPSHOTS, 1463 "Snapshot table", errp); 1464 if (ret < 0) { 1465 goto fail; 1466 } 1467 } 1468 1469 /* read the level 1 table */ 1470 ret = qcow2_validate_table(bs, header.l1_table_offset, 1471 header.l1_size, sizeof(uint64_t), 1472 QCOW_MAX_L1_SIZE, "Active L1 table", errp); 1473 if (ret < 0) { 1474 goto fail; 1475 } 1476 s->l1_size = header.l1_size; 1477 s->l1_table_offset = header.l1_table_offset; 1478 1479 l1_vm_state_index = size_to_l1(s, header.size); 1480 if (l1_vm_state_index > INT_MAX) { 1481 error_setg(errp, "Image is too big"); 1482 ret = -EFBIG; 1483 goto fail; 1484 } 1485 s->l1_vm_state_index = l1_vm_state_index; 1486 1487 /* the L1 table must contain at least enough entries to put 1488 header.size bytes */ 1489 if (s->l1_size < s->l1_vm_state_index) { 1490 error_setg(errp, "L1 table is too small"); 1491 ret = -EINVAL; 1492 goto fail; 1493 } 1494 1495 if (s->l1_size > 0) { 1496 s->l1_table = qemu_try_blockalign(bs->file->bs, 1497 s->l1_size * sizeof(uint64_t)); 1498 if (s->l1_table == NULL) { 1499 error_setg(errp, "Could not allocate L1 table"); 1500 ret = -ENOMEM; 1501 goto fail; 1502 } 1503 ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, 1504 s->l1_size * sizeof(uint64_t)); 1505 if (ret < 0) { 1506 error_setg_errno(errp, -ret, "Could not read L1 table"); 1507 goto fail; 1508 } 1509 for(i = 0;i < s->l1_size; i++) { 1510 s->l1_table[i] = be64_to_cpu(s->l1_table[i]); 1511 } 1512 } 1513 1514 /* Parse driver-specific options */ 1515 ret = qcow2_update_options(bs, options, flags, errp); 1516 if (ret < 0) { 1517 goto fail; 1518 } 1519 1520 s->flags = flags; 1521 1522 ret = qcow2_refcount_init(bs); 1523 if (ret != 0) { 1524 error_setg_errno(errp, -ret, "Could not initialize refcount handling"); 1525 goto fail; 1526 } 1527 1528 QLIST_INIT(&s->cluster_allocs); 1529 QTAILQ_INIT(&s->discards); 1530 1531 /* read qcow2 extensions */ 1532 if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL, 1533 flags, &update_header, &local_err)) { 1534 error_propagate(errp, local_err); 1535 ret = -EINVAL; 1536 goto fail; 1537 } 1538 1539 /* Open external data file */ 1540 s->data_file = bdrv_open_child(NULL, options, "data-file", bs, &child_file, 1541 true, &local_err); 1542 if (local_err) { 1543 error_propagate(errp, local_err); 1544 ret = -EINVAL; 1545 goto fail; 1546 } 1547 1548 if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) { 1549 if (!s->data_file && s->image_data_file) { 1550 s->data_file = bdrv_open_child(s->image_data_file, options, 1551 "data-file", bs, &child_file, 1552 false, errp); 1553 if (!s->data_file) { 1554 ret = -EINVAL; 1555 goto fail; 1556 } 1557 } 1558 if (!s->data_file) { 1559 error_setg(errp, "'data-file' is required for this image"); 1560 ret = -EINVAL; 1561 goto fail; 1562 } 1563 } else { 1564 if (s->data_file) { 1565 error_setg(errp, "'data-file' can only be set for images with an " 1566 "external data file"); 1567 ret = -EINVAL; 1568 goto fail; 1569 } 1570 1571 s->data_file = bs->file; 1572 1573 if (data_file_is_raw(bs)) { 1574 error_setg(errp, "data-file-raw requires a data file"); 1575 ret = -EINVAL; 1576 goto fail; 1577 } 1578 } 1579 1580 /* qcow2_read_extension may have set up the crypto context 1581 * if the crypt method needs a header region, some methods 1582 * don't need header extensions, so must check here 1583 */ 1584 if (s->crypt_method_header && !s->crypto) { 1585 if (s->crypt_method_header == QCOW_CRYPT_AES) { 1586 unsigned int cflags = 0; 1587 if (flags & BDRV_O_NO_IO) { 1588 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; 1589 } 1590 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", 1591 NULL, NULL, cflags, 1592 QCOW2_MAX_THREADS, errp); 1593 if (!s->crypto) { 1594 ret = -EINVAL; 1595 goto fail; 1596 } 1597 } else if (!(flags & BDRV_O_NO_IO)) { 1598 error_setg(errp, "Missing CRYPTO header for crypt method %d", 1599 s->crypt_method_header); 1600 ret = -EINVAL; 1601 goto fail; 1602 } 1603 } 1604 1605 /* read the backing file name */ 1606 if (header.backing_file_offset != 0) { 1607 len = header.backing_file_size; 1608 if (len > MIN(1023, s->cluster_size - header.backing_file_offset) || 1609 len >= sizeof(bs->backing_file)) { 1610 error_setg(errp, "Backing file name too long"); 1611 ret = -EINVAL; 1612 goto fail; 1613 } 1614 ret = bdrv_pread(bs->file, header.backing_file_offset, 1615 bs->auto_backing_file, len); 1616 if (ret < 0) { 1617 error_setg_errno(errp, -ret, "Could not read backing file name"); 1618 goto fail; 1619 } 1620 bs->auto_backing_file[len] = '\0'; 1621 pstrcpy(bs->backing_file, sizeof(bs->backing_file), 1622 bs->auto_backing_file); 1623 s->image_backing_file = g_strdup(bs->auto_backing_file); 1624 } 1625 1626 /* 1627 * Internal snapshots; skip reading them in check mode, because 1628 * we do not need them then, and we do not want to abort because 1629 * of a broken table. 1630 */ 1631 if (!(flags & BDRV_O_CHECK)) { 1632 s->snapshots_offset = header.snapshots_offset; 1633 s->nb_snapshots = header.nb_snapshots; 1634 1635 ret = qcow2_read_snapshots(bs, errp); 1636 if (ret < 0) { 1637 goto fail; 1638 } 1639 } 1640 1641 /* Clear unknown autoclear feature bits */ 1642 update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK; 1643 update_header = 1644 update_header && !bs->read_only && !(flags & BDRV_O_INACTIVE); 1645 if (update_header) { 1646 s->autoclear_features &= QCOW2_AUTOCLEAR_MASK; 1647 } 1648 1649 /* == Handle persistent dirty bitmaps == 1650 * 1651 * We want load dirty bitmaps in three cases: 1652 * 1653 * 1. Normal open of the disk in active mode, not related to invalidation 1654 * after migration. 1655 * 1656 * 2. Invalidation of the target vm after pre-copy phase of migration, if 1657 * bitmaps are _not_ migrating through migration channel, i.e. 1658 * 'dirty-bitmaps' capability is disabled. 1659 * 1660 * 3. Invalidation of source vm after failed or canceled migration. 1661 * This is a very interesting case. There are two possible types of 1662 * bitmaps: 1663 * 1664 * A. Stored on inactivation and removed. They should be loaded from the 1665 * image. 1666 * 1667 * B. Not stored: not-persistent bitmaps and bitmaps, migrated through 1668 * the migration channel (with dirty-bitmaps capability). 1669 * 1670 * On the other hand, there are two possible sub-cases: 1671 * 1672 * 3.1 disk was changed by somebody else while were inactive. In this 1673 * case all in-RAM dirty bitmaps (both persistent and not) are 1674 * definitely invalid. And we don't have any method to determine 1675 * this. 1676 * 1677 * Simple and safe thing is to just drop all the bitmaps of type B on 1678 * inactivation. But in this case we lose bitmaps in valid 4.2 case. 1679 * 1680 * On the other hand, resuming source vm, if disk was already changed 1681 * is a bad thing anyway: not only bitmaps, the whole vm state is 1682 * out of sync with disk. 1683 * 1684 * This means, that user or management tool, who for some reason 1685 * decided to resume source vm, after disk was already changed by 1686 * target vm, should at least drop all dirty bitmaps by hand. 1687 * 1688 * So, we can ignore this case for now, but TODO: "generation" 1689 * extension for qcow2, to determine, that image was changed after 1690 * last inactivation. And if it is changed, we will drop (or at least 1691 * mark as 'invalid' all the bitmaps of type B, both persistent 1692 * and not). 1693 * 1694 * 3.2 disk was _not_ changed while were inactive. Bitmaps may be saved 1695 * to disk ('dirty-bitmaps' capability disabled), or not saved 1696 * ('dirty-bitmaps' capability enabled), but we don't need to care 1697 * of: let's load bitmaps as always: stored bitmaps will be loaded, 1698 * and not stored has flag IN_USE=1 in the image and will be skipped 1699 * on loading. 1700 * 1701 * One remaining possible case when we don't want load bitmaps: 1702 * 1703 * 4. Open disk in inactive mode in target vm (bitmaps are migrating or 1704 * will be loaded on invalidation, no needs try loading them before) 1705 */ 1706 1707 if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) { 1708 /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */ 1709 bool header_updated = qcow2_load_dirty_bitmaps(bs, &local_err); 1710 if (local_err != NULL) { 1711 error_propagate(errp, local_err); 1712 ret = -EINVAL; 1713 goto fail; 1714 } 1715 1716 update_header = update_header && !header_updated; 1717 } 1718 1719 if (update_header) { 1720 ret = qcow2_update_header(bs); 1721 if (ret < 0) { 1722 error_setg_errno(errp, -ret, "Could not update qcow2 header"); 1723 goto fail; 1724 } 1725 } 1726 1727 bs->supported_zero_flags = header.version >= 3 ? 1728 BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0; 1729 1730 /* Repair image if dirty */ 1731 if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only && 1732 (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) { 1733 BdrvCheckResult result = {0}; 1734 1735 ret = qcow2_co_check_locked(bs, &result, 1736 BDRV_FIX_ERRORS | BDRV_FIX_LEAKS); 1737 if (ret < 0 || result.check_errors) { 1738 if (ret >= 0) { 1739 ret = -EIO; 1740 } 1741 error_setg_errno(errp, -ret, "Could not repair dirty image"); 1742 goto fail; 1743 } 1744 } 1745 1746 #ifdef DEBUG_ALLOC 1747 { 1748 BdrvCheckResult result = {0}; 1749 qcow2_check_refcounts(bs, &result, 0); 1750 } 1751 #endif 1752 1753 qemu_co_queue_init(&s->thread_task_queue); 1754 1755 return ret; 1756 1757 fail: 1758 g_free(s->image_data_file); 1759 if (has_data_file(bs)) { 1760 bdrv_unref_child(bs, s->data_file); 1761 } 1762 g_free(s->unknown_header_fields); 1763 cleanup_unknown_header_ext(bs); 1764 qcow2_free_snapshots(bs); 1765 qcow2_refcount_close(bs); 1766 qemu_vfree(s->l1_table); 1767 /* else pre-write overlap checks in cache_destroy may crash */ 1768 s->l1_table = NULL; 1769 cache_clean_timer_del(bs); 1770 if (s->l2_table_cache) { 1771 qcow2_cache_destroy(s->l2_table_cache); 1772 } 1773 if (s->refcount_block_cache) { 1774 qcow2_cache_destroy(s->refcount_block_cache); 1775 } 1776 qcrypto_block_free(s->crypto); 1777 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); 1778 return ret; 1779 } 1780 1781 typedef struct QCow2OpenCo { 1782 BlockDriverState *bs; 1783 QDict *options; 1784 int flags; 1785 Error **errp; 1786 int ret; 1787 } QCow2OpenCo; 1788 1789 static void coroutine_fn qcow2_open_entry(void *opaque) 1790 { 1791 QCow2OpenCo *qoc = opaque; 1792 BDRVQcow2State *s = qoc->bs->opaque; 1793 1794 qemu_co_mutex_lock(&s->lock); 1795 qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, qoc->errp); 1796 qemu_co_mutex_unlock(&s->lock); 1797 } 1798 1799 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, 1800 Error **errp) 1801 { 1802 BDRVQcow2State *s = bs->opaque; 1803 QCow2OpenCo qoc = { 1804 .bs = bs, 1805 .options = options, 1806 .flags = flags, 1807 .errp = errp, 1808 .ret = -EINPROGRESS 1809 }; 1810 1811 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 1812 false, errp); 1813 if (!bs->file) { 1814 return -EINVAL; 1815 } 1816 1817 /* Initialise locks */ 1818 qemu_co_mutex_init(&s->lock); 1819 1820 if (qemu_in_coroutine()) { 1821 /* From bdrv_co_create. */ 1822 qcow2_open_entry(&qoc); 1823 } else { 1824 assert(qemu_get_current_aio_context() == qemu_get_aio_context()); 1825 qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry, &qoc)); 1826 BDRV_POLL_WHILE(bs, qoc.ret == -EINPROGRESS); 1827 } 1828 return qoc.ret; 1829 } 1830 1831 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp) 1832 { 1833 BDRVQcow2State *s = bs->opaque; 1834 1835 if (bs->encrypted) { 1836 /* Encryption works on a sector granularity */ 1837 bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto); 1838 } 1839 bs->bl.pwrite_zeroes_alignment = s->cluster_size; 1840 bs->bl.pdiscard_alignment = s->cluster_size; 1841 } 1842 1843 static int qcow2_reopen_prepare(BDRVReopenState *state, 1844 BlockReopenQueue *queue, Error **errp) 1845 { 1846 Qcow2ReopenState *r; 1847 int ret; 1848 1849 r = g_new0(Qcow2ReopenState, 1); 1850 state->opaque = r; 1851 1852 ret = qcow2_update_options_prepare(state->bs, r, state->options, 1853 state->flags, errp); 1854 if (ret < 0) { 1855 goto fail; 1856 } 1857 1858 /* We need to write out any unwritten data if we reopen read-only. */ 1859 if ((state->flags & BDRV_O_RDWR) == 0) { 1860 ret = qcow2_reopen_bitmaps_ro(state->bs, errp); 1861 if (ret < 0) { 1862 goto fail; 1863 } 1864 1865 ret = bdrv_flush(state->bs); 1866 if (ret < 0) { 1867 goto fail; 1868 } 1869 1870 ret = qcow2_mark_clean(state->bs); 1871 if (ret < 0) { 1872 goto fail; 1873 } 1874 } 1875 1876 return 0; 1877 1878 fail: 1879 qcow2_update_options_abort(state->bs, r); 1880 g_free(r); 1881 return ret; 1882 } 1883 1884 static void qcow2_reopen_commit(BDRVReopenState *state) 1885 { 1886 qcow2_update_options_commit(state->bs, state->opaque); 1887 g_free(state->opaque); 1888 } 1889 1890 static void qcow2_reopen_commit_post(BDRVReopenState *state) 1891 { 1892 if (state->flags & BDRV_O_RDWR) { 1893 Error *local_err = NULL; 1894 1895 if (qcow2_reopen_bitmaps_rw(state->bs, &local_err) < 0) { 1896 /* 1897 * This is not fatal, bitmaps just left read-only, so all following 1898 * writes will fail. User can remove read-only bitmaps to unblock 1899 * writes or retry reopen. 1900 */ 1901 error_reportf_err(local_err, 1902 "%s: Failed to make dirty bitmaps writable: ", 1903 bdrv_get_node_name(state->bs)); 1904 } 1905 } 1906 } 1907 1908 static void qcow2_reopen_abort(BDRVReopenState *state) 1909 { 1910 qcow2_update_options_abort(state->bs, state->opaque); 1911 g_free(state->opaque); 1912 } 1913 1914 static void qcow2_join_options(QDict *options, QDict *old_options) 1915 { 1916 bool has_new_overlap_template = 1917 qdict_haskey(options, QCOW2_OPT_OVERLAP) || 1918 qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE); 1919 bool has_new_total_cache_size = 1920 qdict_haskey(options, QCOW2_OPT_CACHE_SIZE); 1921 bool has_all_cache_options; 1922 1923 /* New overlap template overrides all old overlap options */ 1924 if (has_new_overlap_template) { 1925 qdict_del(old_options, QCOW2_OPT_OVERLAP); 1926 qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE); 1927 qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER); 1928 qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1); 1929 qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2); 1930 qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE); 1931 qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK); 1932 qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE); 1933 qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1); 1934 qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2); 1935 } 1936 1937 /* New total cache size overrides all old options */ 1938 if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) { 1939 qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE); 1940 qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 1941 } 1942 1943 qdict_join(options, old_options, false); 1944 1945 /* 1946 * If after merging all cache size options are set, an old total size is 1947 * overwritten. Do keep all options, however, if all three are new. The 1948 * resulting error message is what we want to happen. 1949 */ 1950 has_all_cache_options = 1951 qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) || 1952 qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) || 1953 qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE); 1954 1955 if (has_all_cache_options && !has_new_total_cache_size) { 1956 qdict_del(options, QCOW2_OPT_CACHE_SIZE); 1957 } 1958 } 1959 1960 static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs, 1961 bool want_zero, 1962 int64_t offset, int64_t count, 1963 int64_t *pnum, int64_t *map, 1964 BlockDriverState **file) 1965 { 1966 BDRVQcow2State *s = bs->opaque; 1967 uint64_t cluster_offset; 1968 unsigned int bytes; 1969 int ret, status = 0; 1970 1971 qemu_co_mutex_lock(&s->lock); 1972 1973 if (!s->metadata_preallocation_checked) { 1974 ret = qcow2_detect_metadata_preallocation(bs); 1975 s->metadata_preallocation = (ret == 1); 1976 s->metadata_preallocation_checked = true; 1977 } 1978 1979 bytes = MIN(INT_MAX, count); 1980 ret = qcow2_get_cluster_offset(bs, offset, &bytes, &cluster_offset); 1981 qemu_co_mutex_unlock(&s->lock); 1982 if (ret < 0) { 1983 return ret; 1984 } 1985 1986 *pnum = bytes; 1987 1988 if ((ret == QCOW2_CLUSTER_NORMAL || ret == QCOW2_CLUSTER_ZERO_ALLOC) && 1989 !s->crypto) { 1990 *map = cluster_offset | offset_into_cluster(s, offset); 1991 *file = s->data_file->bs; 1992 status |= BDRV_BLOCK_OFFSET_VALID; 1993 } 1994 if (ret == QCOW2_CLUSTER_ZERO_PLAIN || ret == QCOW2_CLUSTER_ZERO_ALLOC) { 1995 status |= BDRV_BLOCK_ZERO; 1996 } else if (ret != QCOW2_CLUSTER_UNALLOCATED) { 1997 status |= BDRV_BLOCK_DATA; 1998 } 1999 if (s->metadata_preallocation && (status & BDRV_BLOCK_DATA) && 2000 (status & BDRV_BLOCK_OFFSET_VALID)) 2001 { 2002 status |= BDRV_BLOCK_RECURSE; 2003 } 2004 return status; 2005 } 2006 2007 static coroutine_fn int qcow2_handle_l2meta(BlockDriverState *bs, 2008 QCowL2Meta **pl2meta, 2009 bool link_l2) 2010 { 2011 int ret = 0; 2012 QCowL2Meta *l2meta = *pl2meta; 2013 2014 while (l2meta != NULL) { 2015 QCowL2Meta *next; 2016 2017 if (link_l2) { 2018 ret = qcow2_alloc_cluster_link_l2(bs, l2meta); 2019 if (ret) { 2020 goto out; 2021 } 2022 } else { 2023 qcow2_alloc_cluster_abort(bs, l2meta); 2024 } 2025 2026 /* Take the request off the list of running requests */ 2027 if (l2meta->nb_clusters != 0) { 2028 QLIST_REMOVE(l2meta, next_in_flight); 2029 } 2030 2031 qemu_co_queue_restart_all(&l2meta->dependent_requests); 2032 2033 next = l2meta->next; 2034 g_free(l2meta); 2035 l2meta = next; 2036 } 2037 out: 2038 *pl2meta = l2meta; 2039 return ret; 2040 } 2041 2042 static coroutine_fn int 2043 qcow2_co_preadv_encrypted(BlockDriverState *bs, 2044 uint64_t file_cluster_offset, 2045 uint64_t offset, 2046 uint64_t bytes, 2047 QEMUIOVector *qiov, 2048 uint64_t qiov_offset) 2049 { 2050 int ret; 2051 BDRVQcow2State *s = bs->opaque; 2052 uint8_t *buf; 2053 2054 assert(bs->encrypted && s->crypto); 2055 assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 2056 2057 /* 2058 * For encrypted images, read everything into a temporary 2059 * contiguous buffer on which the AES functions can work. 2060 * Also, decryption in a separate buffer is better as it 2061 * prevents the guest from learning information about the 2062 * encrypted nature of the virtual disk. 2063 */ 2064 2065 buf = qemu_try_blockalign(s->data_file->bs, bytes); 2066 if (buf == NULL) { 2067 return -ENOMEM; 2068 } 2069 2070 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 2071 ret = bdrv_co_pread(s->data_file, 2072 file_cluster_offset + offset_into_cluster(s, offset), 2073 bytes, buf, 0); 2074 if (ret < 0) { 2075 goto fail; 2076 } 2077 2078 if (qcow2_co_decrypt(bs, 2079 file_cluster_offset + offset_into_cluster(s, offset), 2080 offset, buf, bytes) < 0) 2081 { 2082 ret = -EIO; 2083 goto fail; 2084 } 2085 qemu_iovec_from_buf(qiov, qiov_offset, buf, bytes); 2086 2087 fail: 2088 qemu_vfree(buf); 2089 2090 return ret; 2091 } 2092 2093 typedef struct Qcow2AioTask { 2094 AioTask task; 2095 2096 BlockDriverState *bs; 2097 QCow2ClusterType cluster_type; /* only for read */ 2098 uint64_t file_cluster_offset; 2099 uint64_t offset; 2100 uint64_t bytes; 2101 QEMUIOVector *qiov; 2102 uint64_t qiov_offset; 2103 QCowL2Meta *l2meta; /* only for write */ 2104 } Qcow2AioTask; 2105 2106 static coroutine_fn int qcow2_co_preadv_task_entry(AioTask *task); 2107 static coroutine_fn int qcow2_add_task(BlockDriverState *bs, 2108 AioTaskPool *pool, 2109 AioTaskFunc func, 2110 QCow2ClusterType cluster_type, 2111 uint64_t file_cluster_offset, 2112 uint64_t offset, 2113 uint64_t bytes, 2114 QEMUIOVector *qiov, 2115 size_t qiov_offset, 2116 QCowL2Meta *l2meta) 2117 { 2118 Qcow2AioTask local_task; 2119 Qcow2AioTask *task = pool ? g_new(Qcow2AioTask, 1) : &local_task; 2120 2121 *task = (Qcow2AioTask) { 2122 .task.func = func, 2123 .bs = bs, 2124 .cluster_type = cluster_type, 2125 .qiov = qiov, 2126 .file_cluster_offset = file_cluster_offset, 2127 .offset = offset, 2128 .bytes = bytes, 2129 .qiov_offset = qiov_offset, 2130 .l2meta = l2meta, 2131 }; 2132 2133 trace_qcow2_add_task(qemu_coroutine_self(), bs, pool, 2134 func == qcow2_co_preadv_task_entry ? "read" : "write", 2135 cluster_type, file_cluster_offset, offset, bytes, 2136 qiov, qiov_offset); 2137 2138 if (!pool) { 2139 return func(&task->task); 2140 } 2141 2142 aio_task_pool_start_task(pool, &task->task); 2143 2144 return 0; 2145 } 2146 2147 static coroutine_fn int qcow2_co_preadv_task(BlockDriverState *bs, 2148 QCow2ClusterType cluster_type, 2149 uint64_t file_cluster_offset, 2150 uint64_t offset, uint64_t bytes, 2151 QEMUIOVector *qiov, 2152 size_t qiov_offset) 2153 { 2154 BDRVQcow2State *s = bs->opaque; 2155 int offset_in_cluster = offset_into_cluster(s, offset); 2156 2157 switch (cluster_type) { 2158 case QCOW2_CLUSTER_ZERO_PLAIN: 2159 case QCOW2_CLUSTER_ZERO_ALLOC: 2160 /* Both zero types are handled in qcow2_co_preadv_part */ 2161 g_assert_not_reached(); 2162 2163 case QCOW2_CLUSTER_UNALLOCATED: 2164 assert(bs->backing); /* otherwise handled in qcow2_co_preadv_part */ 2165 2166 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 2167 return bdrv_co_preadv_part(bs->backing, offset, bytes, 2168 qiov, qiov_offset, 0); 2169 2170 case QCOW2_CLUSTER_COMPRESSED: 2171 return qcow2_co_preadv_compressed(bs, file_cluster_offset, 2172 offset, bytes, qiov, qiov_offset); 2173 2174 case QCOW2_CLUSTER_NORMAL: 2175 assert(offset_into_cluster(s, file_cluster_offset) == 0); 2176 if (bs->encrypted) { 2177 return qcow2_co_preadv_encrypted(bs, file_cluster_offset, 2178 offset, bytes, qiov, qiov_offset); 2179 } 2180 2181 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 2182 return bdrv_co_preadv_part(s->data_file, 2183 file_cluster_offset + offset_in_cluster, 2184 bytes, qiov, qiov_offset, 0); 2185 2186 default: 2187 g_assert_not_reached(); 2188 } 2189 2190 g_assert_not_reached(); 2191 } 2192 2193 static coroutine_fn int qcow2_co_preadv_task_entry(AioTask *task) 2194 { 2195 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task); 2196 2197 assert(!t->l2meta); 2198 2199 return qcow2_co_preadv_task(t->bs, t->cluster_type, t->file_cluster_offset, 2200 t->offset, t->bytes, t->qiov, t->qiov_offset); 2201 } 2202 2203 static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs, 2204 uint64_t offset, uint64_t bytes, 2205 QEMUIOVector *qiov, 2206 size_t qiov_offset, int flags) 2207 { 2208 BDRVQcow2State *s = bs->opaque; 2209 int ret = 0; 2210 unsigned int cur_bytes; /* number of bytes in current iteration */ 2211 uint64_t cluster_offset = 0; 2212 AioTaskPool *aio = NULL; 2213 2214 while (bytes != 0 && aio_task_pool_status(aio) == 0) { 2215 /* prepare next request */ 2216 cur_bytes = MIN(bytes, INT_MAX); 2217 if (s->crypto) { 2218 cur_bytes = MIN(cur_bytes, 2219 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 2220 } 2221 2222 qemu_co_mutex_lock(&s->lock); 2223 ret = qcow2_get_cluster_offset(bs, offset, &cur_bytes, &cluster_offset); 2224 qemu_co_mutex_unlock(&s->lock); 2225 if (ret < 0) { 2226 goto out; 2227 } 2228 2229 if (ret == QCOW2_CLUSTER_ZERO_PLAIN || 2230 ret == QCOW2_CLUSTER_ZERO_ALLOC || 2231 (ret == QCOW2_CLUSTER_UNALLOCATED && !bs->backing)) 2232 { 2233 qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes); 2234 } else { 2235 if (!aio && cur_bytes != bytes) { 2236 aio = aio_task_pool_new(QCOW2_MAX_WORKERS); 2237 } 2238 ret = qcow2_add_task(bs, aio, qcow2_co_preadv_task_entry, ret, 2239 cluster_offset, offset, cur_bytes, 2240 qiov, qiov_offset, NULL); 2241 if (ret < 0) { 2242 goto out; 2243 } 2244 } 2245 2246 bytes -= cur_bytes; 2247 offset += cur_bytes; 2248 qiov_offset += cur_bytes; 2249 } 2250 2251 out: 2252 if (aio) { 2253 aio_task_pool_wait_all(aio); 2254 if (ret == 0) { 2255 ret = aio_task_pool_status(aio); 2256 } 2257 g_free(aio); 2258 } 2259 2260 return ret; 2261 } 2262 2263 /* Check if it's possible to merge a write request with the writing of 2264 * the data from the COW regions */ 2265 static bool merge_cow(uint64_t offset, unsigned bytes, 2266 QEMUIOVector *qiov, size_t qiov_offset, 2267 QCowL2Meta *l2meta) 2268 { 2269 QCowL2Meta *m; 2270 2271 for (m = l2meta; m != NULL; m = m->next) { 2272 /* If both COW regions are empty then there's nothing to merge */ 2273 if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) { 2274 continue; 2275 } 2276 2277 /* If COW regions are handled already, skip this too */ 2278 if (m->skip_cow) { 2279 continue; 2280 } 2281 2282 /* The data (middle) region must be immediately after the 2283 * start region */ 2284 if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) { 2285 continue; 2286 } 2287 2288 /* The end region must be immediately after the data (middle) 2289 * region */ 2290 if (m->offset + m->cow_end.offset != offset + bytes) { 2291 continue; 2292 } 2293 2294 /* Make sure that adding both COW regions to the QEMUIOVector 2295 * does not exceed IOV_MAX */ 2296 if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) { 2297 continue; 2298 } 2299 2300 m->data_qiov = qiov; 2301 m->data_qiov_offset = qiov_offset; 2302 return true; 2303 } 2304 2305 return false; 2306 } 2307 2308 static bool is_unallocated(BlockDriverState *bs, int64_t offset, int64_t bytes) 2309 { 2310 int64_t nr; 2311 return !bytes || 2312 (!bdrv_is_allocated_above(bs, NULL, false, offset, bytes, &nr) && 2313 nr == bytes); 2314 } 2315 2316 static bool is_zero_cow(BlockDriverState *bs, QCowL2Meta *m) 2317 { 2318 /* 2319 * This check is designed for optimization shortcut so it must be 2320 * efficient. 2321 * Instead of is_zero(), use is_unallocated() as it is faster (but not 2322 * as accurate and can result in false negatives). 2323 */ 2324 return is_unallocated(bs, m->offset + m->cow_start.offset, 2325 m->cow_start.nb_bytes) && 2326 is_unallocated(bs, m->offset + m->cow_end.offset, 2327 m->cow_end.nb_bytes); 2328 } 2329 2330 static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta) 2331 { 2332 BDRVQcow2State *s = bs->opaque; 2333 QCowL2Meta *m; 2334 2335 if (!(s->data_file->bs->supported_zero_flags & BDRV_REQ_NO_FALLBACK)) { 2336 return 0; 2337 } 2338 2339 if (bs->encrypted) { 2340 return 0; 2341 } 2342 2343 for (m = l2meta; m != NULL; m = m->next) { 2344 int ret; 2345 2346 if (!m->cow_start.nb_bytes && !m->cow_end.nb_bytes) { 2347 continue; 2348 } 2349 2350 if (!is_zero_cow(bs, m)) { 2351 continue; 2352 } 2353 2354 /* 2355 * instead of writing zero COW buffers, 2356 * efficiently zero out the whole clusters 2357 */ 2358 2359 ret = qcow2_pre_write_overlap_check(bs, 0, m->alloc_offset, 2360 m->nb_clusters * s->cluster_size, 2361 true); 2362 if (ret < 0) { 2363 return ret; 2364 } 2365 2366 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE); 2367 ret = bdrv_co_pwrite_zeroes(s->data_file, m->alloc_offset, 2368 m->nb_clusters * s->cluster_size, 2369 BDRV_REQ_NO_FALLBACK); 2370 if (ret < 0) { 2371 if (ret != -ENOTSUP && ret != -EAGAIN) { 2372 return ret; 2373 } 2374 continue; 2375 } 2376 2377 trace_qcow2_skip_cow(qemu_coroutine_self(), m->offset, m->nb_clusters); 2378 m->skip_cow = true; 2379 } 2380 return 0; 2381 } 2382 2383 /* 2384 * qcow2_co_pwritev_task 2385 * Called with s->lock unlocked 2386 * l2meta - if not NULL, qcow2_co_pwritev_task() will consume it. Caller must 2387 * not use it somehow after qcow2_co_pwritev_task() call 2388 */ 2389 static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs, 2390 uint64_t file_cluster_offset, 2391 uint64_t offset, uint64_t bytes, 2392 QEMUIOVector *qiov, 2393 uint64_t qiov_offset, 2394 QCowL2Meta *l2meta) 2395 { 2396 int ret; 2397 BDRVQcow2State *s = bs->opaque; 2398 void *crypt_buf = NULL; 2399 int offset_in_cluster = offset_into_cluster(s, offset); 2400 QEMUIOVector encrypted_qiov; 2401 2402 if (bs->encrypted) { 2403 assert(s->crypto); 2404 assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 2405 crypt_buf = qemu_try_blockalign(bs->file->bs, bytes); 2406 if (crypt_buf == NULL) { 2407 ret = -ENOMEM; 2408 goto out_unlocked; 2409 } 2410 qemu_iovec_to_buf(qiov, qiov_offset, crypt_buf, bytes); 2411 2412 if (qcow2_co_encrypt(bs, file_cluster_offset + offset_in_cluster, 2413 offset, crypt_buf, bytes) < 0) 2414 { 2415 ret = -EIO; 2416 goto out_unlocked; 2417 } 2418 2419 qemu_iovec_init_buf(&encrypted_qiov, crypt_buf, bytes); 2420 qiov = &encrypted_qiov; 2421 qiov_offset = 0; 2422 } 2423 2424 /* Try to efficiently initialize the physical space with zeroes */ 2425 ret = handle_alloc_space(bs, l2meta); 2426 if (ret < 0) { 2427 goto out_unlocked; 2428 } 2429 2430 /* 2431 * If we need to do COW, check if it's possible to merge the 2432 * writing of the guest data together with that of the COW regions. 2433 * If it's not possible (or not necessary) then write the 2434 * guest data now. 2435 */ 2436 if (!merge_cow(offset, bytes, qiov, qiov_offset, l2meta)) { 2437 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 2438 trace_qcow2_writev_data(qemu_coroutine_self(), 2439 file_cluster_offset + offset_in_cluster); 2440 ret = bdrv_co_pwritev_part(s->data_file, 2441 file_cluster_offset + offset_in_cluster, 2442 bytes, qiov, qiov_offset, 0); 2443 if (ret < 0) { 2444 goto out_unlocked; 2445 } 2446 } 2447 2448 qemu_co_mutex_lock(&s->lock); 2449 2450 ret = qcow2_handle_l2meta(bs, &l2meta, true); 2451 goto out_locked; 2452 2453 out_unlocked: 2454 qemu_co_mutex_lock(&s->lock); 2455 2456 out_locked: 2457 qcow2_handle_l2meta(bs, &l2meta, false); 2458 qemu_co_mutex_unlock(&s->lock); 2459 2460 qemu_vfree(crypt_buf); 2461 2462 return ret; 2463 } 2464 2465 static coroutine_fn int qcow2_co_pwritev_task_entry(AioTask *task) 2466 { 2467 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task); 2468 2469 assert(!t->cluster_type); 2470 2471 return qcow2_co_pwritev_task(t->bs, t->file_cluster_offset, 2472 t->offset, t->bytes, t->qiov, t->qiov_offset, 2473 t->l2meta); 2474 } 2475 2476 static coroutine_fn int qcow2_co_pwritev_part( 2477 BlockDriverState *bs, uint64_t offset, uint64_t bytes, 2478 QEMUIOVector *qiov, size_t qiov_offset, int flags) 2479 { 2480 BDRVQcow2State *s = bs->opaque; 2481 int offset_in_cluster; 2482 int ret; 2483 unsigned int cur_bytes; /* number of sectors in current iteration */ 2484 uint64_t cluster_offset; 2485 QCowL2Meta *l2meta = NULL; 2486 AioTaskPool *aio = NULL; 2487 2488 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes); 2489 2490 while (bytes != 0 && aio_task_pool_status(aio) == 0) { 2491 2492 l2meta = NULL; 2493 2494 trace_qcow2_writev_start_part(qemu_coroutine_self()); 2495 offset_in_cluster = offset_into_cluster(s, offset); 2496 cur_bytes = MIN(bytes, INT_MAX); 2497 if (bs->encrypted) { 2498 cur_bytes = MIN(cur_bytes, 2499 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size 2500 - offset_in_cluster); 2501 } 2502 2503 qemu_co_mutex_lock(&s->lock); 2504 2505 ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes, 2506 &cluster_offset, &l2meta); 2507 if (ret < 0) { 2508 goto out_locked; 2509 } 2510 2511 assert(offset_into_cluster(s, cluster_offset) == 0); 2512 2513 ret = qcow2_pre_write_overlap_check(bs, 0, 2514 cluster_offset + offset_in_cluster, 2515 cur_bytes, true); 2516 if (ret < 0) { 2517 goto out_locked; 2518 } 2519 2520 qemu_co_mutex_unlock(&s->lock); 2521 2522 if (!aio && cur_bytes != bytes) { 2523 aio = aio_task_pool_new(QCOW2_MAX_WORKERS); 2524 } 2525 ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_task_entry, 0, 2526 cluster_offset, offset, cur_bytes, 2527 qiov, qiov_offset, l2meta); 2528 l2meta = NULL; /* l2meta is consumed by qcow2_co_pwritev_task() */ 2529 if (ret < 0) { 2530 goto fail_nometa; 2531 } 2532 2533 bytes -= cur_bytes; 2534 offset += cur_bytes; 2535 qiov_offset += cur_bytes; 2536 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes); 2537 } 2538 ret = 0; 2539 2540 qemu_co_mutex_lock(&s->lock); 2541 2542 out_locked: 2543 qcow2_handle_l2meta(bs, &l2meta, false); 2544 2545 qemu_co_mutex_unlock(&s->lock); 2546 2547 fail_nometa: 2548 if (aio) { 2549 aio_task_pool_wait_all(aio); 2550 if (ret == 0) { 2551 ret = aio_task_pool_status(aio); 2552 } 2553 g_free(aio); 2554 } 2555 2556 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret); 2557 2558 return ret; 2559 } 2560 2561 static int qcow2_inactivate(BlockDriverState *bs) 2562 { 2563 BDRVQcow2State *s = bs->opaque; 2564 int ret, result = 0; 2565 Error *local_err = NULL; 2566 2567 qcow2_store_persistent_dirty_bitmaps(bs, true, &local_err); 2568 if (local_err != NULL) { 2569 result = -EINVAL; 2570 error_reportf_err(local_err, "Lost persistent bitmaps during " 2571 "inactivation of node '%s': ", 2572 bdrv_get_device_or_node_name(bs)); 2573 } 2574 2575 ret = qcow2_cache_flush(bs, s->l2_table_cache); 2576 if (ret) { 2577 result = ret; 2578 error_report("Failed to flush the L2 table cache: %s", 2579 strerror(-ret)); 2580 } 2581 2582 ret = qcow2_cache_flush(bs, s->refcount_block_cache); 2583 if (ret) { 2584 result = ret; 2585 error_report("Failed to flush the refcount block cache: %s", 2586 strerror(-ret)); 2587 } 2588 2589 if (result == 0) { 2590 qcow2_mark_clean(bs); 2591 } 2592 2593 return result; 2594 } 2595 2596 static void qcow2_close(BlockDriverState *bs) 2597 { 2598 BDRVQcow2State *s = bs->opaque; 2599 qemu_vfree(s->l1_table); 2600 /* else pre-write overlap checks in cache_destroy may crash */ 2601 s->l1_table = NULL; 2602 2603 if (!(s->flags & BDRV_O_INACTIVE)) { 2604 qcow2_inactivate(bs); 2605 } 2606 2607 cache_clean_timer_del(bs); 2608 qcow2_cache_destroy(s->l2_table_cache); 2609 qcow2_cache_destroy(s->refcount_block_cache); 2610 2611 qcrypto_block_free(s->crypto); 2612 s->crypto = NULL; 2613 2614 g_free(s->unknown_header_fields); 2615 cleanup_unknown_header_ext(bs); 2616 2617 g_free(s->image_data_file); 2618 g_free(s->image_backing_file); 2619 g_free(s->image_backing_format); 2620 2621 if (has_data_file(bs)) { 2622 bdrv_unref_child(bs, s->data_file); 2623 } 2624 2625 qcow2_refcount_close(bs); 2626 qcow2_free_snapshots(bs); 2627 } 2628 2629 static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs, 2630 Error **errp) 2631 { 2632 BDRVQcow2State *s = bs->opaque; 2633 int flags = s->flags; 2634 QCryptoBlock *crypto = NULL; 2635 QDict *options; 2636 Error *local_err = NULL; 2637 int ret; 2638 2639 /* 2640 * Backing files are read-only which makes all of their metadata immutable, 2641 * that means we don't have to worry about reopening them here. 2642 */ 2643 2644 crypto = s->crypto; 2645 s->crypto = NULL; 2646 2647 qcow2_close(bs); 2648 2649 memset(s, 0, sizeof(BDRVQcow2State)); 2650 options = qdict_clone_shallow(bs->options); 2651 2652 flags &= ~BDRV_O_INACTIVE; 2653 qemu_co_mutex_lock(&s->lock); 2654 ret = qcow2_do_open(bs, options, flags, &local_err); 2655 qemu_co_mutex_unlock(&s->lock); 2656 qobject_unref(options); 2657 if (local_err) { 2658 error_propagate_prepend(errp, local_err, 2659 "Could not reopen qcow2 layer: "); 2660 bs->drv = NULL; 2661 return; 2662 } else if (ret < 0) { 2663 error_setg_errno(errp, -ret, "Could not reopen qcow2 layer"); 2664 bs->drv = NULL; 2665 return; 2666 } 2667 2668 s->crypto = crypto; 2669 } 2670 2671 static size_t header_ext_add(char *buf, uint32_t magic, const void *s, 2672 size_t len, size_t buflen) 2673 { 2674 QCowExtension *ext_backing_fmt = (QCowExtension*) buf; 2675 size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7); 2676 2677 if (buflen < ext_len) { 2678 return -ENOSPC; 2679 } 2680 2681 *ext_backing_fmt = (QCowExtension) { 2682 .magic = cpu_to_be32(magic), 2683 .len = cpu_to_be32(len), 2684 }; 2685 2686 if (len) { 2687 memcpy(buf + sizeof(QCowExtension), s, len); 2688 } 2689 2690 return ext_len; 2691 } 2692 2693 /* 2694 * Updates the qcow2 header, including the variable length parts of it, i.e. 2695 * the backing file name and all extensions. qcow2 was not designed to allow 2696 * such changes, so if we run out of space (we can only use the first cluster) 2697 * this function may fail. 2698 * 2699 * Returns 0 on success, -errno in error cases. 2700 */ 2701 int qcow2_update_header(BlockDriverState *bs) 2702 { 2703 BDRVQcow2State *s = bs->opaque; 2704 QCowHeader *header; 2705 char *buf; 2706 size_t buflen = s->cluster_size; 2707 int ret; 2708 uint64_t total_size; 2709 uint32_t refcount_table_clusters; 2710 size_t header_length; 2711 Qcow2UnknownHeaderExtension *uext; 2712 2713 buf = qemu_blockalign(bs, buflen); 2714 2715 /* Header structure */ 2716 header = (QCowHeader*) buf; 2717 2718 if (buflen < sizeof(*header)) { 2719 ret = -ENOSPC; 2720 goto fail; 2721 } 2722 2723 header_length = sizeof(*header) + s->unknown_header_fields_size; 2724 total_size = bs->total_sectors * BDRV_SECTOR_SIZE; 2725 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3); 2726 2727 *header = (QCowHeader) { 2728 /* Version 2 fields */ 2729 .magic = cpu_to_be32(QCOW_MAGIC), 2730 .version = cpu_to_be32(s->qcow_version), 2731 .backing_file_offset = 0, 2732 .backing_file_size = 0, 2733 .cluster_bits = cpu_to_be32(s->cluster_bits), 2734 .size = cpu_to_be64(total_size), 2735 .crypt_method = cpu_to_be32(s->crypt_method_header), 2736 .l1_size = cpu_to_be32(s->l1_size), 2737 .l1_table_offset = cpu_to_be64(s->l1_table_offset), 2738 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset), 2739 .refcount_table_clusters = cpu_to_be32(refcount_table_clusters), 2740 .nb_snapshots = cpu_to_be32(s->nb_snapshots), 2741 .snapshots_offset = cpu_to_be64(s->snapshots_offset), 2742 2743 /* Version 3 fields */ 2744 .incompatible_features = cpu_to_be64(s->incompatible_features), 2745 .compatible_features = cpu_to_be64(s->compatible_features), 2746 .autoclear_features = cpu_to_be64(s->autoclear_features), 2747 .refcount_order = cpu_to_be32(s->refcount_order), 2748 .header_length = cpu_to_be32(header_length), 2749 }; 2750 2751 /* For older versions, write a shorter header */ 2752 switch (s->qcow_version) { 2753 case 2: 2754 ret = offsetof(QCowHeader, incompatible_features); 2755 break; 2756 case 3: 2757 ret = sizeof(*header); 2758 break; 2759 default: 2760 ret = -EINVAL; 2761 goto fail; 2762 } 2763 2764 buf += ret; 2765 buflen -= ret; 2766 memset(buf, 0, buflen); 2767 2768 /* Preserve any unknown field in the header */ 2769 if (s->unknown_header_fields_size) { 2770 if (buflen < s->unknown_header_fields_size) { 2771 ret = -ENOSPC; 2772 goto fail; 2773 } 2774 2775 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size); 2776 buf += s->unknown_header_fields_size; 2777 buflen -= s->unknown_header_fields_size; 2778 } 2779 2780 /* Backing file format header extension */ 2781 if (s->image_backing_format) { 2782 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT, 2783 s->image_backing_format, 2784 strlen(s->image_backing_format), 2785 buflen); 2786 if (ret < 0) { 2787 goto fail; 2788 } 2789 2790 buf += ret; 2791 buflen -= ret; 2792 } 2793 2794 /* External data file header extension */ 2795 if (has_data_file(bs) && s->image_data_file) { 2796 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_DATA_FILE, 2797 s->image_data_file, strlen(s->image_data_file), 2798 buflen); 2799 if (ret < 0) { 2800 goto fail; 2801 } 2802 2803 buf += ret; 2804 buflen -= ret; 2805 } 2806 2807 /* Full disk encryption header pointer extension */ 2808 if (s->crypto_header.offset != 0) { 2809 s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset); 2810 s->crypto_header.length = cpu_to_be64(s->crypto_header.length); 2811 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER, 2812 &s->crypto_header, sizeof(s->crypto_header), 2813 buflen); 2814 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset); 2815 s->crypto_header.length = be64_to_cpu(s->crypto_header.length); 2816 if (ret < 0) { 2817 goto fail; 2818 } 2819 buf += ret; 2820 buflen -= ret; 2821 } 2822 2823 /* Feature table */ 2824 if (s->qcow_version >= 3) { 2825 Qcow2Feature features[] = { 2826 { 2827 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 2828 .bit = QCOW2_INCOMPAT_DIRTY_BITNR, 2829 .name = "dirty bit", 2830 }, 2831 { 2832 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 2833 .bit = QCOW2_INCOMPAT_CORRUPT_BITNR, 2834 .name = "corrupt bit", 2835 }, 2836 { 2837 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 2838 .bit = QCOW2_INCOMPAT_DATA_FILE_BITNR, 2839 .name = "external data file", 2840 }, 2841 { 2842 .type = QCOW2_FEAT_TYPE_COMPATIBLE, 2843 .bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR, 2844 .name = "lazy refcounts", 2845 }, 2846 }; 2847 2848 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE, 2849 features, sizeof(features), buflen); 2850 if (ret < 0) { 2851 goto fail; 2852 } 2853 buf += ret; 2854 buflen -= ret; 2855 } 2856 2857 /* Bitmap extension */ 2858 if (s->nb_bitmaps > 0) { 2859 Qcow2BitmapHeaderExt bitmaps_header = { 2860 .nb_bitmaps = cpu_to_be32(s->nb_bitmaps), 2861 .bitmap_directory_size = 2862 cpu_to_be64(s->bitmap_directory_size), 2863 .bitmap_directory_offset = 2864 cpu_to_be64(s->bitmap_directory_offset) 2865 }; 2866 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS, 2867 &bitmaps_header, sizeof(bitmaps_header), 2868 buflen); 2869 if (ret < 0) { 2870 goto fail; 2871 } 2872 buf += ret; 2873 buflen -= ret; 2874 } 2875 2876 /* Keep unknown header extensions */ 2877 QLIST_FOREACH(uext, &s->unknown_header_ext, next) { 2878 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen); 2879 if (ret < 0) { 2880 goto fail; 2881 } 2882 2883 buf += ret; 2884 buflen -= ret; 2885 } 2886 2887 /* End of header extensions */ 2888 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen); 2889 if (ret < 0) { 2890 goto fail; 2891 } 2892 2893 buf += ret; 2894 buflen -= ret; 2895 2896 /* Backing file name */ 2897 if (s->image_backing_file) { 2898 size_t backing_file_len = strlen(s->image_backing_file); 2899 2900 if (buflen < backing_file_len) { 2901 ret = -ENOSPC; 2902 goto fail; 2903 } 2904 2905 /* Using strncpy is ok here, since buf is not NUL-terminated. */ 2906 strncpy(buf, s->image_backing_file, buflen); 2907 2908 header->backing_file_offset = cpu_to_be64(buf - ((char*) header)); 2909 header->backing_file_size = cpu_to_be32(backing_file_len); 2910 } 2911 2912 /* Write the new header */ 2913 ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size); 2914 if (ret < 0) { 2915 goto fail; 2916 } 2917 2918 ret = 0; 2919 fail: 2920 qemu_vfree(header); 2921 return ret; 2922 } 2923 2924 static int qcow2_change_backing_file(BlockDriverState *bs, 2925 const char *backing_file, const char *backing_fmt) 2926 { 2927 BDRVQcow2State *s = bs->opaque; 2928 2929 /* Adding a backing file means that the external data file alone won't be 2930 * enough to make sense of the content */ 2931 if (backing_file && data_file_is_raw(bs)) { 2932 return -EINVAL; 2933 } 2934 2935 if (backing_file && strlen(backing_file) > 1023) { 2936 return -EINVAL; 2937 } 2938 2939 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), 2940 backing_file ?: ""); 2941 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 2942 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 2943 2944 g_free(s->image_backing_file); 2945 g_free(s->image_backing_format); 2946 2947 s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL; 2948 s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL; 2949 2950 return qcow2_update_header(bs); 2951 } 2952 2953 static int qcow2_crypt_method_from_format(const char *encryptfmt) 2954 { 2955 if (g_str_equal(encryptfmt, "luks")) { 2956 return QCOW_CRYPT_LUKS; 2957 } else if (g_str_equal(encryptfmt, "aes")) { 2958 return QCOW_CRYPT_AES; 2959 } else { 2960 return -EINVAL; 2961 } 2962 } 2963 2964 static int qcow2_set_up_encryption(BlockDriverState *bs, 2965 QCryptoBlockCreateOptions *cryptoopts, 2966 Error **errp) 2967 { 2968 BDRVQcow2State *s = bs->opaque; 2969 QCryptoBlock *crypto = NULL; 2970 int fmt, ret; 2971 2972 switch (cryptoopts->format) { 2973 case Q_CRYPTO_BLOCK_FORMAT_LUKS: 2974 fmt = QCOW_CRYPT_LUKS; 2975 break; 2976 case Q_CRYPTO_BLOCK_FORMAT_QCOW: 2977 fmt = QCOW_CRYPT_AES; 2978 break; 2979 default: 2980 error_setg(errp, "Crypto format not supported in qcow2"); 2981 return -EINVAL; 2982 } 2983 2984 s->crypt_method_header = fmt; 2985 2986 crypto = qcrypto_block_create(cryptoopts, "encrypt.", 2987 qcow2_crypto_hdr_init_func, 2988 qcow2_crypto_hdr_write_func, 2989 bs, errp); 2990 if (!crypto) { 2991 return -EINVAL; 2992 } 2993 2994 ret = qcow2_update_header(bs); 2995 if (ret < 0) { 2996 error_setg_errno(errp, -ret, "Could not write encryption header"); 2997 goto out; 2998 } 2999 3000 ret = 0; 3001 out: 3002 qcrypto_block_free(crypto); 3003 return ret; 3004 } 3005 3006 /** 3007 * Preallocates metadata structures for data clusters between @offset (in the 3008 * guest disk) and @new_length (which is thus generally the new guest disk 3009 * size). 3010 * 3011 * Returns: 0 on success, -errno on failure. 3012 */ 3013 static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset, 3014 uint64_t new_length, PreallocMode mode, 3015 Error **errp) 3016 { 3017 BDRVQcow2State *s = bs->opaque; 3018 uint64_t bytes; 3019 uint64_t host_offset = 0; 3020 int64_t file_length; 3021 unsigned int cur_bytes; 3022 int ret; 3023 QCowL2Meta *meta; 3024 3025 assert(offset <= new_length); 3026 bytes = new_length - offset; 3027 3028 while (bytes) { 3029 cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size)); 3030 ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes, 3031 &host_offset, &meta); 3032 if (ret < 0) { 3033 error_setg_errno(errp, -ret, "Allocating clusters failed"); 3034 return ret; 3035 } 3036 3037 while (meta) { 3038 QCowL2Meta *next = meta->next; 3039 3040 ret = qcow2_alloc_cluster_link_l2(bs, meta); 3041 if (ret < 0) { 3042 error_setg_errno(errp, -ret, "Mapping clusters failed"); 3043 qcow2_free_any_clusters(bs, meta->alloc_offset, 3044 meta->nb_clusters, QCOW2_DISCARD_NEVER); 3045 return ret; 3046 } 3047 3048 /* There are no dependent requests, but we need to remove our 3049 * request from the list of in-flight requests */ 3050 QLIST_REMOVE(meta, next_in_flight); 3051 3052 g_free(meta); 3053 meta = next; 3054 } 3055 3056 /* TODO Preallocate data if requested */ 3057 3058 bytes -= cur_bytes; 3059 offset += cur_bytes; 3060 } 3061 3062 /* 3063 * It is expected that the image file is large enough to actually contain 3064 * all of the allocated clusters (otherwise we get failing reads after 3065 * EOF). Extend the image to the last allocated sector. 3066 */ 3067 file_length = bdrv_getlength(s->data_file->bs); 3068 if (file_length < 0) { 3069 error_setg_errno(errp, -file_length, "Could not get file size"); 3070 return file_length; 3071 } 3072 3073 if (host_offset + cur_bytes > file_length) { 3074 if (mode == PREALLOC_MODE_METADATA) { 3075 mode = PREALLOC_MODE_OFF; 3076 } 3077 ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false, 3078 mode, errp); 3079 if (ret < 0) { 3080 return ret; 3081 } 3082 } 3083 3084 return 0; 3085 } 3086 3087 /* qcow2_refcount_metadata_size: 3088 * @clusters: number of clusters to refcount (including data and L1/L2 tables) 3089 * @cluster_size: size of a cluster, in bytes 3090 * @refcount_order: refcount bits power-of-2 exponent 3091 * @generous_increase: allow for the refcount table to be 1.5x as large as it 3092 * needs to be 3093 * 3094 * Returns: Number of bytes required for refcount blocks and table metadata. 3095 */ 3096 int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size, 3097 int refcount_order, bool generous_increase, 3098 uint64_t *refblock_count) 3099 { 3100 /* 3101 * Every host cluster is reference-counted, including metadata (even 3102 * refcount metadata is recursively included). 3103 * 3104 * An accurate formula for the size of refcount metadata size is difficult 3105 * to derive. An easier method of calculation is finding the fixed point 3106 * where no further refcount blocks or table clusters are required to 3107 * reference count every cluster. 3108 */ 3109 int64_t blocks_per_table_cluster = cluster_size / sizeof(uint64_t); 3110 int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order); 3111 int64_t table = 0; /* number of refcount table clusters */ 3112 int64_t blocks = 0; /* number of refcount block clusters */ 3113 int64_t last; 3114 int64_t n = 0; 3115 3116 do { 3117 last = n; 3118 blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block); 3119 table = DIV_ROUND_UP(blocks, blocks_per_table_cluster); 3120 n = clusters + blocks + table; 3121 3122 if (n == last && generous_increase) { 3123 clusters += DIV_ROUND_UP(table, 2); 3124 n = 0; /* force another loop */ 3125 generous_increase = false; 3126 } 3127 } while (n != last); 3128 3129 if (refblock_count) { 3130 *refblock_count = blocks; 3131 } 3132 3133 return (blocks + table) * cluster_size; 3134 } 3135 3136 /** 3137 * qcow2_calc_prealloc_size: 3138 * @total_size: virtual disk size in bytes 3139 * @cluster_size: cluster size in bytes 3140 * @refcount_order: refcount bits power-of-2 exponent 3141 * 3142 * Returns: Total number of bytes required for the fully allocated image 3143 * (including metadata). 3144 */ 3145 static int64_t qcow2_calc_prealloc_size(int64_t total_size, 3146 size_t cluster_size, 3147 int refcount_order) 3148 { 3149 int64_t meta_size = 0; 3150 uint64_t nl1e, nl2e; 3151 int64_t aligned_total_size = ROUND_UP(total_size, cluster_size); 3152 3153 /* header: 1 cluster */ 3154 meta_size += cluster_size; 3155 3156 /* total size of L2 tables */ 3157 nl2e = aligned_total_size / cluster_size; 3158 nl2e = ROUND_UP(nl2e, cluster_size / sizeof(uint64_t)); 3159 meta_size += nl2e * sizeof(uint64_t); 3160 3161 /* total size of L1 tables */ 3162 nl1e = nl2e * sizeof(uint64_t) / cluster_size; 3163 nl1e = ROUND_UP(nl1e, cluster_size / sizeof(uint64_t)); 3164 meta_size += nl1e * sizeof(uint64_t); 3165 3166 /* total size of refcount table and blocks */ 3167 meta_size += qcow2_refcount_metadata_size( 3168 (meta_size + aligned_total_size) / cluster_size, 3169 cluster_size, refcount_order, false, NULL); 3170 3171 return meta_size + aligned_total_size; 3172 } 3173 3174 static bool validate_cluster_size(size_t cluster_size, Error **errp) 3175 { 3176 int cluster_bits = ctz32(cluster_size); 3177 if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS || 3178 (1 << cluster_bits) != cluster_size) 3179 { 3180 error_setg(errp, "Cluster size must be a power of two between %d and " 3181 "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); 3182 return false; 3183 } 3184 return true; 3185 } 3186 3187 static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, Error **errp) 3188 { 3189 size_t cluster_size; 3190 3191 cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 3192 DEFAULT_CLUSTER_SIZE); 3193 if (!validate_cluster_size(cluster_size, errp)) { 3194 return 0; 3195 } 3196 return cluster_size; 3197 } 3198 3199 static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp) 3200 { 3201 char *buf; 3202 int ret; 3203 3204 buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL); 3205 if (!buf) { 3206 ret = 3; /* default */ 3207 } else if (!strcmp(buf, "0.10")) { 3208 ret = 2; 3209 } else if (!strcmp(buf, "1.1")) { 3210 ret = 3; 3211 } else { 3212 error_setg(errp, "Invalid compatibility level: '%s'", buf); 3213 ret = -EINVAL; 3214 } 3215 g_free(buf); 3216 return ret; 3217 } 3218 3219 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version, 3220 Error **errp) 3221 { 3222 uint64_t refcount_bits; 3223 3224 refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16); 3225 if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) { 3226 error_setg(errp, "Refcount width must be a power of two and may not " 3227 "exceed 64 bits"); 3228 return 0; 3229 } 3230 3231 if (version < 3 && refcount_bits != 16) { 3232 error_setg(errp, "Different refcount widths than 16 bits require " 3233 "compatibility level 1.1 or above (use compat=1.1 or " 3234 "greater)"); 3235 return 0; 3236 } 3237 3238 return refcount_bits; 3239 } 3240 3241 static int coroutine_fn 3242 qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp) 3243 { 3244 BlockdevCreateOptionsQcow2 *qcow2_opts; 3245 QDict *options; 3246 3247 /* 3248 * Open the image file and write a minimal qcow2 header. 3249 * 3250 * We keep things simple and start with a zero-sized image. We also 3251 * do without refcount blocks or a L1 table for now. We'll fix the 3252 * inconsistency later. 3253 * 3254 * We do need a refcount table because growing the refcount table means 3255 * allocating two new refcount blocks - the seconds of which would be at 3256 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file 3257 * size for any qcow2 image. 3258 */ 3259 BlockBackend *blk = NULL; 3260 BlockDriverState *bs = NULL; 3261 BlockDriverState *data_bs = NULL; 3262 QCowHeader *header; 3263 size_t cluster_size; 3264 int version; 3265 int refcount_order; 3266 uint64_t* refcount_table; 3267 Error *local_err = NULL; 3268 int ret; 3269 3270 assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2); 3271 qcow2_opts = &create_options->u.qcow2; 3272 3273 bs = bdrv_open_blockdev_ref(qcow2_opts->file, errp); 3274 if (bs == NULL) { 3275 return -EIO; 3276 } 3277 3278 /* Validate options and set default values */ 3279 if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) { 3280 error_setg(errp, "Image size must be a multiple of %u bytes", 3281 (unsigned) BDRV_SECTOR_SIZE); 3282 ret = -EINVAL; 3283 goto out; 3284 } 3285 3286 if (qcow2_opts->has_version) { 3287 switch (qcow2_opts->version) { 3288 case BLOCKDEV_QCOW2_VERSION_V2: 3289 version = 2; 3290 break; 3291 case BLOCKDEV_QCOW2_VERSION_V3: 3292 version = 3; 3293 break; 3294 default: 3295 g_assert_not_reached(); 3296 } 3297 } else { 3298 version = 3; 3299 } 3300 3301 if (qcow2_opts->has_cluster_size) { 3302 cluster_size = qcow2_opts->cluster_size; 3303 } else { 3304 cluster_size = DEFAULT_CLUSTER_SIZE; 3305 } 3306 3307 if (!validate_cluster_size(cluster_size, errp)) { 3308 ret = -EINVAL; 3309 goto out; 3310 } 3311 3312 if (!qcow2_opts->has_preallocation) { 3313 qcow2_opts->preallocation = PREALLOC_MODE_OFF; 3314 } 3315 if (qcow2_opts->has_backing_file && 3316 qcow2_opts->preallocation != PREALLOC_MODE_OFF) 3317 { 3318 error_setg(errp, "Backing file and preallocation cannot be used at " 3319 "the same time"); 3320 ret = -EINVAL; 3321 goto out; 3322 } 3323 if (qcow2_opts->has_backing_fmt && !qcow2_opts->has_backing_file) { 3324 error_setg(errp, "Backing format cannot be used without backing file"); 3325 ret = -EINVAL; 3326 goto out; 3327 } 3328 3329 if (!qcow2_opts->has_lazy_refcounts) { 3330 qcow2_opts->lazy_refcounts = false; 3331 } 3332 if (version < 3 && qcow2_opts->lazy_refcounts) { 3333 error_setg(errp, "Lazy refcounts only supported with compatibility " 3334 "level 1.1 and above (use version=v3 or greater)"); 3335 ret = -EINVAL; 3336 goto out; 3337 } 3338 3339 if (!qcow2_opts->has_refcount_bits) { 3340 qcow2_opts->refcount_bits = 16; 3341 } 3342 if (qcow2_opts->refcount_bits > 64 || 3343 !is_power_of_2(qcow2_opts->refcount_bits)) 3344 { 3345 error_setg(errp, "Refcount width must be a power of two and may not " 3346 "exceed 64 bits"); 3347 ret = -EINVAL; 3348 goto out; 3349 } 3350 if (version < 3 && qcow2_opts->refcount_bits != 16) { 3351 error_setg(errp, "Different refcount widths than 16 bits require " 3352 "compatibility level 1.1 or above (use version=v3 or " 3353 "greater)"); 3354 ret = -EINVAL; 3355 goto out; 3356 } 3357 refcount_order = ctz32(qcow2_opts->refcount_bits); 3358 3359 if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) { 3360 error_setg(errp, "data-file-raw requires data-file"); 3361 ret = -EINVAL; 3362 goto out; 3363 } 3364 if (qcow2_opts->data_file_raw && qcow2_opts->has_backing_file) { 3365 error_setg(errp, "Backing file and data-file-raw cannot be used at " 3366 "the same time"); 3367 ret = -EINVAL; 3368 goto out; 3369 } 3370 3371 if (qcow2_opts->data_file) { 3372 if (version < 3) { 3373 error_setg(errp, "External data files are only supported with " 3374 "compatibility level 1.1 and above (use version=v3 or " 3375 "greater)"); 3376 ret = -EINVAL; 3377 goto out; 3378 } 3379 data_bs = bdrv_open_blockdev_ref(qcow2_opts->data_file, errp); 3380 if (data_bs == NULL) { 3381 ret = -EIO; 3382 goto out; 3383 } 3384 } 3385 3386 /* Create BlockBackend to write to the image */ 3387 blk = blk_new(bdrv_get_aio_context(bs), 3388 BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL); 3389 ret = blk_insert_bs(blk, bs, errp); 3390 if (ret < 0) { 3391 goto out; 3392 } 3393 blk_set_allow_write_beyond_eof(blk, true); 3394 3395 /* Write the header */ 3396 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header)); 3397 header = g_malloc0(cluster_size); 3398 *header = (QCowHeader) { 3399 .magic = cpu_to_be32(QCOW_MAGIC), 3400 .version = cpu_to_be32(version), 3401 .cluster_bits = cpu_to_be32(ctz32(cluster_size)), 3402 .size = cpu_to_be64(0), 3403 .l1_table_offset = cpu_to_be64(0), 3404 .l1_size = cpu_to_be32(0), 3405 .refcount_table_offset = cpu_to_be64(cluster_size), 3406 .refcount_table_clusters = cpu_to_be32(1), 3407 .refcount_order = cpu_to_be32(refcount_order), 3408 .header_length = cpu_to_be32(sizeof(*header)), 3409 }; 3410 3411 /* We'll update this to correct value later */ 3412 header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); 3413 3414 if (qcow2_opts->lazy_refcounts) { 3415 header->compatible_features |= 3416 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS); 3417 } 3418 if (data_bs) { 3419 header->incompatible_features |= 3420 cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE); 3421 } 3422 if (qcow2_opts->data_file_raw) { 3423 header->autoclear_features |= 3424 cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW); 3425 } 3426 3427 ret = blk_pwrite(blk, 0, header, cluster_size, 0); 3428 g_free(header); 3429 if (ret < 0) { 3430 error_setg_errno(errp, -ret, "Could not write qcow2 header"); 3431 goto out; 3432 } 3433 3434 /* Write a refcount table with one refcount block */ 3435 refcount_table = g_malloc0(2 * cluster_size); 3436 refcount_table[0] = cpu_to_be64(2 * cluster_size); 3437 ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0); 3438 g_free(refcount_table); 3439 3440 if (ret < 0) { 3441 error_setg_errno(errp, -ret, "Could not write refcount table"); 3442 goto out; 3443 } 3444 3445 blk_unref(blk); 3446 blk = NULL; 3447 3448 /* 3449 * And now open the image and make it consistent first (i.e. increase the 3450 * refcount of the cluster that is occupied by the header and the refcount 3451 * table) 3452 */ 3453 options = qdict_new(); 3454 qdict_put_str(options, "driver", "qcow2"); 3455 qdict_put_str(options, "file", bs->node_name); 3456 if (data_bs) { 3457 qdict_put_str(options, "data-file", data_bs->node_name); 3458 } 3459 blk = blk_new_open(NULL, NULL, options, 3460 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH, 3461 &local_err); 3462 if (blk == NULL) { 3463 error_propagate(errp, local_err); 3464 ret = -EIO; 3465 goto out; 3466 } 3467 3468 ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size); 3469 if (ret < 0) { 3470 error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 " 3471 "header and refcount table"); 3472 goto out; 3473 3474 } else if (ret != 0) { 3475 error_report("Huh, first cluster in empty image is already in use?"); 3476 abort(); 3477 } 3478 3479 /* Set the external data file if necessary */ 3480 if (data_bs) { 3481 BDRVQcow2State *s = blk_bs(blk)->opaque; 3482 s->image_data_file = g_strdup(data_bs->filename); 3483 } 3484 3485 /* Create a full header (including things like feature table) */ 3486 ret = qcow2_update_header(blk_bs(blk)); 3487 if (ret < 0) { 3488 error_setg_errno(errp, -ret, "Could not update qcow2 header"); 3489 goto out; 3490 } 3491 3492 /* Okay, now that we have a valid image, let's give it the right size */ 3493 ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation, 3494 errp); 3495 if (ret < 0) { 3496 error_prepend(errp, "Could not resize image: "); 3497 goto out; 3498 } 3499 3500 /* Want a backing file? There you go.*/ 3501 if (qcow2_opts->has_backing_file) { 3502 const char *backing_format = NULL; 3503 3504 if (qcow2_opts->has_backing_fmt) { 3505 backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt); 3506 } 3507 3508 ret = bdrv_change_backing_file(blk_bs(blk), qcow2_opts->backing_file, 3509 backing_format); 3510 if (ret < 0) { 3511 error_setg_errno(errp, -ret, "Could not assign backing file '%s' " 3512 "with format '%s'", qcow2_opts->backing_file, 3513 backing_format); 3514 goto out; 3515 } 3516 } 3517 3518 /* Want encryption? There you go. */ 3519 if (qcow2_opts->has_encrypt) { 3520 ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp); 3521 if (ret < 0) { 3522 goto out; 3523 } 3524 } 3525 3526 blk_unref(blk); 3527 blk = NULL; 3528 3529 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning. 3530 * Using BDRV_O_NO_IO, since encryption is now setup we don't want to 3531 * have to setup decryption context. We're not doing any I/O on the top 3532 * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does 3533 * not have effect. 3534 */ 3535 options = qdict_new(); 3536 qdict_put_str(options, "driver", "qcow2"); 3537 qdict_put_str(options, "file", bs->node_name); 3538 if (data_bs) { 3539 qdict_put_str(options, "data-file", data_bs->node_name); 3540 } 3541 blk = blk_new_open(NULL, NULL, options, 3542 BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO, 3543 &local_err); 3544 if (blk == NULL) { 3545 error_propagate(errp, local_err); 3546 ret = -EIO; 3547 goto out; 3548 } 3549 3550 ret = 0; 3551 out: 3552 blk_unref(blk); 3553 bdrv_unref(bs); 3554 bdrv_unref(data_bs); 3555 return ret; 3556 } 3557 3558 static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opts, 3559 Error **errp) 3560 { 3561 BlockdevCreateOptions *create_options = NULL; 3562 QDict *qdict; 3563 Visitor *v; 3564 BlockDriverState *bs = NULL; 3565 BlockDriverState *data_bs = NULL; 3566 Error *local_err = NULL; 3567 const char *val; 3568 int ret; 3569 3570 /* Only the keyval visitor supports the dotted syntax needed for 3571 * encryption, so go through a QDict before getting a QAPI type. Ignore 3572 * options meant for the protocol layer so that the visitor doesn't 3573 * complain. */ 3574 qdict = qemu_opts_to_qdict_filtered(opts, NULL, bdrv_qcow2.create_opts, 3575 true); 3576 3577 /* Handle encryption options */ 3578 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT); 3579 if (val && !strcmp(val, "on")) { 3580 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow"); 3581 } else if (val && !strcmp(val, "off")) { 3582 qdict_del(qdict, BLOCK_OPT_ENCRYPT); 3583 } 3584 3585 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT); 3586 if (val && !strcmp(val, "aes")) { 3587 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow"); 3588 } 3589 3590 /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into 3591 * version=v2/v3 below. */ 3592 val = qdict_get_try_str(qdict, BLOCK_OPT_COMPAT_LEVEL); 3593 if (val && !strcmp(val, "0.10")) { 3594 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v2"); 3595 } else if (val && !strcmp(val, "1.1")) { 3596 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v3"); 3597 } 3598 3599 /* Change legacy command line options into QMP ones */ 3600 static const QDictRenames opt_renames[] = { 3601 { BLOCK_OPT_BACKING_FILE, "backing-file" }, 3602 { BLOCK_OPT_BACKING_FMT, "backing-fmt" }, 3603 { BLOCK_OPT_CLUSTER_SIZE, "cluster-size" }, 3604 { BLOCK_OPT_LAZY_REFCOUNTS, "lazy-refcounts" }, 3605 { BLOCK_OPT_REFCOUNT_BITS, "refcount-bits" }, 3606 { BLOCK_OPT_ENCRYPT, BLOCK_OPT_ENCRYPT_FORMAT }, 3607 { BLOCK_OPT_COMPAT_LEVEL, "version" }, 3608 { BLOCK_OPT_DATA_FILE_RAW, "data-file-raw" }, 3609 { NULL, NULL }, 3610 }; 3611 3612 if (!qdict_rename_keys(qdict, opt_renames, errp)) { 3613 ret = -EINVAL; 3614 goto finish; 3615 } 3616 3617 /* Create and open the file (protocol layer) */ 3618 ret = bdrv_create_file(filename, opts, errp); 3619 if (ret < 0) { 3620 goto finish; 3621 } 3622 3623 bs = bdrv_open(filename, NULL, NULL, 3624 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp); 3625 if (bs == NULL) { 3626 ret = -EIO; 3627 goto finish; 3628 } 3629 3630 /* Create and open an external data file (protocol layer) */ 3631 val = qdict_get_try_str(qdict, BLOCK_OPT_DATA_FILE); 3632 if (val) { 3633 ret = bdrv_create_file(val, opts, errp); 3634 if (ret < 0) { 3635 goto finish; 3636 } 3637 3638 data_bs = bdrv_open(val, NULL, NULL, 3639 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, 3640 errp); 3641 if (data_bs == NULL) { 3642 ret = -EIO; 3643 goto finish; 3644 } 3645 3646 qdict_del(qdict, BLOCK_OPT_DATA_FILE); 3647 qdict_put_str(qdict, "data-file", data_bs->node_name); 3648 } 3649 3650 /* Set 'driver' and 'node' options */ 3651 qdict_put_str(qdict, "driver", "qcow2"); 3652 qdict_put_str(qdict, "file", bs->node_name); 3653 3654 /* Now get the QAPI type BlockdevCreateOptions */ 3655 v = qobject_input_visitor_new_flat_confused(qdict, errp); 3656 if (!v) { 3657 ret = -EINVAL; 3658 goto finish; 3659 } 3660 3661 visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err); 3662 visit_free(v); 3663 3664 if (local_err) { 3665 error_propagate(errp, local_err); 3666 ret = -EINVAL; 3667 goto finish; 3668 } 3669 3670 /* Silently round up size */ 3671 create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size, 3672 BDRV_SECTOR_SIZE); 3673 3674 /* Create the qcow2 image (format layer) */ 3675 ret = qcow2_co_create(create_options, errp); 3676 if (ret < 0) { 3677 goto finish; 3678 } 3679 3680 ret = 0; 3681 finish: 3682 qobject_unref(qdict); 3683 bdrv_unref(bs); 3684 bdrv_unref(data_bs); 3685 qapi_free_BlockdevCreateOptions(create_options); 3686 return ret; 3687 } 3688 3689 3690 static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes) 3691 { 3692 int64_t nr; 3693 int res; 3694 3695 /* Clamp to image length, before checking status of underlying sectors */ 3696 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) { 3697 bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset; 3698 } 3699 3700 if (!bytes) { 3701 return true; 3702 } 3703 res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL); 3704 return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes; 3705 } 3706 3707 static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs, 3708 int64_t offset, int bytes, BdrvRequestFlags flags) 3709 { 3710 int ret; 3711 BDRVQcow2State *s = bs->opaque; 3712 3713 uint32_t head = offset % s->cluster_size; 3714 uint32_t tail = (offset + bytes) % s->cluster_size; 3715 3716 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes); 3717 if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) { 3718 tail = 0; 3719 } 3720 3721 if (head || tail) { 3722 uint64_t off; 3723 unsigned int nr; 3724 3725 assert(head + bytes <= s->cluster_size); 3726 3727 /* check whether remainder of cluster already reads as zero */ 3728 if (!(is_zero(bs, offset - head, head) && 3729 is_zero(bs, offset + bytes, 3730 tail ? s->cluster_size - tail : 0))) { 3731 return -ENOTSUP; 3732 } 3733 3734 qemu_co_mutex_lock(&s->lock); 3735 /* We can have new write after previous check */ 3736 offset = QEMU_ALIGN_DOWN(offset, s->cluster_size); 3737 bytes = s->cluster_size; 3738 nr = s->cluster_size; 3739 ret = qcow2_get_cluster_offset(bs, offset, &nr, &off); 3740 if (ret != QCOW2_CLUSTER_UNALLOCATED && 3741 ret != QCOW2_CLUSTER_ZERO_PLAIN && 3742 ret != QCOW2_CLUSTER_ZERO_ALLOC) { 3743 qemu_co_mutex_unlock(&s->lock); 3744 return -ENOTSUP; 3745 } 3746 } else { 3747 qemu_co_mutex_lock(&s->lock); 3748 } 3749 3750 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes); 3751 3752 /* Whatever is left can use real zero clusters */ 3753 ret = qcow2_cluster_zeroize(bs, offset, bytes, flags); 3754 qemu_co_mutex_unlock(&s->lock); 3755 3756 return ret; 3757 } 3758 3759 static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs, 3760 int64_t offset, int bytes) 3761 { 3762 int ret; 3763 BDRVQcow2State *s = bs->opaque; 3764 3765 if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) { 3766 assert(bytes < s->cluster_size); 3767 /* Ignore partial clusters, except for the special case of the 3768 * complete partial cluster at the end of an unaligned file */ 3769 if (!QEMU_IS_ALIGNED(offset, s->cluster_size) || 3770 offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) { 3771 return -ENOTSUP; 3772 } 3773 } 3774 3775 qemu_co_mutex_lock(&s->lock); 3776 ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST, 3777 false); 3778 qemu_co_mutex_unlock(&s->lock); 3779 return ret; 3780 } 3781 3782 static int coroutine_fn 3783 qcow2_co_copy_range_from(BlockDriverState *bs, 3784 BdrvChild *src, uint64_t src_offset, 3785 BdrvChild *dst, uint64_t dst_offset, 3786 uint64_t bytes, BdrvRequestFlags read_flags, 3787 BdrvRequestFlags write_flags) 3788 { 3789 BDRVQcow2State *s = bs->opaque; 3790 int ret; 3791 unsigned int cur_bytes; /* number of bytes in current iteration */ 3792 BdrvChild *child = NULL; 3793 BdrvRequestFlags cur_write_flags; 3794 3795 assert(!bs->encrypted); 3796 qemu_co_mutex_lock(&s->lock); 3797 3798 while (bytes != 0) { 3799 uint64_t copy_offset = 0; 3800 /* prepare next request */ 3801 cur_bytes = MIN(bytes, INT_MAX); 3802 cur_write_flags = write_flags; 3803 3804 ret = qcow2_get_cluster_offset(bs, src_offset, &cur_bytes, ©_offset); 3805 if (ret < 0) { 3806 goto out; 3807 } 3808 3809 switch (ret) { 3810 case QCOW2_CLUSTER_UNALLOCATED: 3811 if (bs->backing && bs->backing->bs) { 3812 int64_t backing_length = bdrv_getlength(bs->backing->bs); 3813 if (src_offset >= backing_length) { 3814 cur_write_flags |= BDRV_REQ_ZERO_WRITE; 3815 } else { 3816 child = bs->backing; 3817 cur_bytes = MIN(cur_bytes, backing_length - src_offset); 3818 copy_offset = src_offset; 3819 } 3820 } else { 3821 cur_write_flags |= BDRV_REQ_ZERO_WRITE; 3822 } 3823 break; 3824 3825 case QCOW2_CLUSTER_ZERO_PLAIN: 3826 case QCOW2_CLUSTER_ZERO_ALLOC: 3827 cur_write_flags |= BDRV_REQ_ZERO_WRITE; 3828 break; 3829 3830 case QCOW2_CLUSTER_COMPRESSED: 3831 ret = -ENOTSUP; 3832 goto out; 3833 3834 case QCOW2_CLUSTER_NORMAL: 3835 child = s->data_file; 3836 copy_offset += offset_into_cluster(s, src_offset); 3837 break; 3838 3839 default: 3840 abort(); 3841 } 3842 qemu_co_mutex_unlock(&s->lock); 3843 ret = bdrv_co_copy_range_from(child, 3844 copy_offset, 3845 dst, dst_offset, 3846 cur_bytes, read_flags, cur_write_flags); 3847 qemu_co_mutex_lock(&s->lock); 3848 if (ret < 0) { 3849 goto out; 3850 } 3851 3852 bytes -= cur_bytes; 3853 src_offset += cur_bytes; 3854 dst_offset += cur_bytes; 3855 } 3856 ret = 0; 3857 3858 out: 3859 qemu_co_mutex_unlock(&s->lock); 3860 return ret; 3861 } 3862 3863 static int coroutine_fn 3864 qcow2_co_copy_range_to(BlockDriverState *bs, 3865 BdrvChild *src, uint64_t src_offset, 3866 BdrvChild *dst, uint64_t dst_offset, 3867 uint64_t bytes, BdrvRequestFlags read_flags, 3868 BdrvRequestFlags write_flags) 3869 { 3870 BDRVQcow2State *s = bs->opaque; 3871 int offset_in_cluster; 3872 int ret; 3873 unsigned int cur_bytes; /* number of sectors in current iteration */ 3874 uint64_t cluster_offset; 3875 QCowL2Meta *l2meta = NULL; 3876 3877 assert(!bs->encrypted); 3878 3879 qemu_co_mutex_lock(&s->lock); 3880 3881 while (bytes != 0) { 3882 3883 l2meta = NULL; 3884 3885 offset_in_cluster = offset_into_cluster(s, dst_offset); 3886 cur_bytes = MIN(bytes, INT_MAX); 3887 3888 /* TODO: 3889 * If src->bs == dst->bs, we could simply copy by incrementing 3890 * the refcnt, without copying user data. 3891 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */ 3892 ret = qcow2_alloc_cluster_offset(bs, dst_offset, &cur_bytes, 3893 &cluster_offset, &l2meta); 3894 if (ret < 0) { 3895 goto fail; 3896 } 3897 3898 assert(offset_into_cluster(s, cluster_offset) == 0); 3899 3900 ret = qcow2_pre_write_overlap_check(bs, 0, 3901 cluster_offset + offset_in_cluster, cur_bytes, true); 3902 if (ret < 0) { 3903 goto fail; 3904 } 3905 3906 qemu_co_mutex_unlock(&s->lock); 3907 ret = bdrv_co_copy_range_to(src, src_offset, 3908 s->data_file, 3909 cluster_offset + offset_in_cluster, 3910 cur_bytes, read_flags, write_flags); 3911 qemu_co_mutex_lock(&s->lock); 3912 if (ret < 0) { 3913 goto fail; 3914 } 3915 3916 ret = qcow2_handle_l2meta(bs, &l2meta, true); 3917 if (ret) { 3918 goto fail; 3919 } 3920 3921 bytes -= cur_bytes; 3922 src_offset += cur_bytes; 3923 dst_offset += cur_bytes; 3924 } 3925 ret = 0; 3926 3927 fail: 3928 qcow2_handle_l2meta(bs, &l2meta, false); 3929 3930 qemu_co_mutex_unlock(&s->lock); 3931 3932 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret); 3933 3934 return ret; 3935 } 3936 3937 static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, 3938 bool exact, PreallocMode prealloc, 3939 Error **errp) 3940 { 3941 BDRVQcow2State *s = bs->opaque; 3942 uint64_t old_length; 3943 int64_t new_l1_size; 3944 int ret; 3945 QDict *options; 3946 3947 if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA && 3948 prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL) 3949 { 3950 error_setg(errp, "Unsupported preallocation mode '%s'", 3951 PreallocMode_str(prealloc)); 3952 return -ENOTSUP; 3953 } 3954 3955 if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) { 3956 error_setg(errp, "The new size must be a multiple of %u", 3957 (unsigned) BDRV_SECTOR_SIZE); 3958 return -EINVAL; 3959 } 3960 3961 qemu_co_mutex_lock(&s->lock); 3962 3963 /* cannot proceed if image has snapshots */ 3964 if (s->nb_snapshots) { 3965 error_setg(errp, "Can't resize an image which has snapshots"); 3966 ret = -ENOTSUP; 3967 goto fail; 3968 } 3969 3970 /* cannot proceed if image has bitmaps */ 3971 if (qcow2_truncate_bitmaps_check(bs, errp)) { 3972 ret = -ENOTSUP; 3973 goto fail; 3974 } 3975 3976 old_length = bs->total_sectors * BDRV_SECTOR_SIZE; 3977 new_l1_size = size_to_l1(s, offset); 3978 3979 if (offset < old_length) { 3980 int64_t last_cluster, old_file_size; 3981 if (prealloc != PREALLOC_MODE_OFF) { 3982 error_setg(errp, 3983 "Preallocation can't be used for shrinking an image"); 3984 ret = -EINVAL; 3985 goto fail; 3986 } 3987 3988 ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size), 3989 old_length - ROUND_UP(offset, 3990 s->cluster_size), 3991 QCOW2_DISCARD_ALWAYS, true); 3992 if (ret < 0) { 3993 error_setg_errno(errp, -ret, "Failed to discard cropped clusters"); 3994 goto fail; 3995 } 3996 3997 ret = qcow2_shrink_l1_table(bs, new_l1_size); 3998 if (ret < 0) { 3999 error_setg_errno(errp, -ret, 4000 "Failed to reduce the number of L2 tables"); 4001 goto fail; 4002 } 4003 4004 ret = qcow2_shrink_reftable(bs); 4005 if (ret < 0) { 4006 error_setg_errno(errp, -ret, 4007 "Failed to discard unused refblocks"); 4008 goto fail; 4009 } 4010 4011 old_file_size = bdrv_getlength(bs->file->bs); 4012 if (old_file_size < 0) { 4013 error_setg_errno(errp, -old_file_size, 4014 "Failed to inquire current file length"); 4015 ret = old_file_size; 4016 goto fail; 4017 } 4018 last_cluster = qcow2_get_last_cluster(bs, old_file_size); 4019 if (last_cluster < 0) { 4020 error_setg_errno(errp, -last_cluster, 4021 "Failed to find the last cluster"); 4022 ret = last_cluster; 4023 goto fail; 4024 } 4025 if ((last_cluster + 1) * s->cluster_size < old_file_size) { 4026 Error *local_err = NULL; 4027 4028 /* 4029 * Do not pass @exact here: It will not help the user if 4030 * we get an error here just because they wanted to shrink 4031 * their qcow2 image (on a block device) with qemu-img. 4032 * (And on the qcow2 layer, the @exact requirement is 4033 * always fulfilled, so there is no need to pass it on.) 4034 */ 4035 bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size, 4036 false, PREALLOC_MODE_OFF, &local_err); 4037 if (local_err) { 4038 warn_reportf_err(local_err, 4039 "Failed to truncate the tail of the image: "); 4040 } 4041 } 4042 } else { 4043 ret = qcow2_grow_l1_table(bs, new_l1_size, true); 4044 if (ret < 0) { 4045 error_setg_errno(errp, -ret, "Failed to grow the L1 table"); 4046 goto fail; 4047 } 4048 } 4049 4050 switch (prealloc) { 4051 case PREALLOC_MODE_OFF: 4052 if (has_data_file(bs)) { 4053 /* 4054 * If the caller wants an exact resize, the external data 4055 * file should be resized to the exact target size, too, 4056 * so we pass @exact here. 4057 */ 4058 ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp); 4059 if (ret < 0) { 4060 goto fail; 4061 } 4062 } 4063 break; 4064 4065 case PREALLOC_MODE_METADATA: 4066 ret = preallocate_co(bs, old_length, offset, prealloc, errp); 4067 if (ret < 0) { 4068 goto fail; 4069 } 4070 break; 4071 4072 case PREALLOC_MODE_FALLOC: 4073 case PREALLOC_MODE_FULL: 4074 { 4075 int64_t allocation_start, host_offset, guest_offset; 4076 int64_t clusters_allocated; 4077 int64_t old_file_size, new_file_size; 4078 uint64_t nb_new_data_clusters, nb_new_l2_tables; 4079 4080 /* With a data file, preallocation means just allocating the metadata 4081 * and forwarding the truncate request to the data file */ 4082 if (has_data_file(bs)) { 4083 ret = preallocate_co(bs, old_length, offset, prealloc, errp); 4084 if (ret < 0) { 4085 goto fail; 4086 } 4087 break; 4088 } 4089 4090 old_file_size = bdrv_getlength(bs->file->bs); 4091 if (old_file_size < 0) { 4092 error_setg_errno(errp, -old_file_size, 4093 "Failed to inquire current file length"); 4094 ret = old_file_size; 4095 goto fail; 4096 } 4097 old_file_size = ROUND_UP(old_file_size, s->cluster_size); 4098 4099 nb_new_data_clusters = DIV_ROUND_UP(offset - old_length, 4100 s->cluster_size); 4101 4102 /* This is an overestimation; we will not actually allocate space for 4103 * these in the file but just make sure the new refcount structures are 4104 * able to cover them so we will not have to allocate new refblocks 4105 * while entering the data blocks in the potentially new L2 tables. 4106 * (We do not actually care where the L2 tables are placed. Maybe they 4107 * are already allocated or they can be placed somewhere before 4108 * @old_file_size. It does not matter because they will be fully 4109 * allocated automatically, so they do not need to be covered by the 4110 * preallocation. All that matters is that we will not have to allocate 4111 * new refcount structures for them.) */ 4112 nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters, 4113 s->cluster_size / sizeof(uint64_t)); 4114 /* The cluster range may not be aligned to L2 boundaries, so add one L2 4115 * table for a potential head/tail */ 4116 nb_new_l2_tables++; 4117 4118 allocation_start = qcow2_refcount_area(bs, old_file_size, 4119 nb_new_data_clusters + 4120 nb_new_l2_tables, 4121 true, 0, 0); 4122 if (allocation_start < 0) { 4123 error_setg_errno(errp, -allocation_start, 4124 "Failed to resize refcount structures"); 4125 ret = allocation_start; 4126 goto fail; 4127 } 4128 4129 clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start, 4130 nb_new_data_clusters); 4131 if (clusters_allocated < 0) { 4132 error_setg_errno(errp, -clusters_allocated, 4133 "Failed to allocate data clusters"); 4134 ret = clusters_allocated; 4135 goto fail; 4136 } 4137 4138 assert(clusters_allocated == nb_new_data_clusters); 4139 4140 /* Allocate the data area */ 4141 new_file_size = allocation_start + 4142 nb_new_data_clusters * s->cluster_size; 4143 /* Image file grows, so @exact does not matter */ 4144 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp); 4145 if (ret < 0) { 4146 error_prepend(errp, "Failed to resize underlying file: "); 4147 qcow2_free_clusters(bs, allocation_start, 4148 nb_new_data_clusters * s->cluster_size, 4149 QCOW2_DISCARD_OTHER); 4150 goto fail; 4151 } 4152 4153 /* Create the necessary L2 entries */ 4154 host_offset = allocation_start; 4155 guest_offset = old_length; 4156 while (nb_new_data_clusters) { 4157 int64_t nb_clusters = MIN( 4158 nb_new_data_clusters, 4159 s->l2_slice_size - offset_to_l2_slice_index(s, guest_offset)); 4160 QCowL2Meta allocation = { 4161 .offset = guest_offset, 4162 .alloc_offset = host_offset, 4163 .nb_clusters = nb_clusters, 4164 }; 4165 qemu_co_queue_init(&allocation.dependent_requests); 4166 4167 ret = qcow2_alloc_cluster_link_l2(bs, &allocation); 4168 if (ret < 0) { 4169 error_setg_errno(errp, -ret, "Failed to update L2 tables"); 4170 qcow2_free_clusters(bs, host_offset, 4171 nb_new_data_clusters * s->cluster_size, 4172 QCOW2_DISCARD_OTHER); 4173 goto fail; 4174 } 4175 4176 guest_offset += nb_clusters * s->cluster_size; 4177 host_offset += nb_clusters * s->cluster_size; 4178 nb_new_data_clusters -= nb_clusters; 4179 } 4180 break; 4181 } 4182 4183 default: 4184 g_assert_not_reached(); 4185 } 4186 4187 if (prealloc != PREALLOC_MODE_OFF) { 4188 /* Flush metadata before actually changing the image size */ 4189 ret = qcow2_write_caches(bs); 4190 if (ret < 0) { 4191 error_setg_errno(errp, -ret, 4192 "Failed to flush the preallocated area to disk"); 4193 goto fail; 4194 } 4195 } 4196 4197 bs->total_sectors = offset / BDRV_SECTOR_SIZE; 4198 4199 /* write updated header.size */ 4200 offset = cpu_to_be64(offset); 4201 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), 4202 &offset, sizeof(uint64_t)); 4203 if (ret < 0) { 4204 error_setg_errno(errp, -ret, "Failed to update the image size"); 4205 goto fail; 4206 } 4207 4208 s->l1_vm_state_index = new_l1_size; 4209 4210 /* Update cache sizes */ 4211 options = qdict_clone_shallow(bs->options); 4212 ret = qcow2_update_options(bs, options, s->flags, errp); 4213 qobject_unref(options); 4214 if (ret < 0) { 4215 goto fail; 4216 } 4217 ret = 0; 4218 fail: 4219 qemu_co_mutex_unlock(&s->lock); 4220 return ret; 4221 } 4222 4223 static coroutine_fn int 4224 qcow2_co_pwritev_compressed_task(BlockDriverState *bs, 4225 uint64_t offset, uint64_t bytes, 4226 QEMUIOVector *qiov, size_t qiov_offset) 4227 { 4228 BDRVQcow2State *s = bs->opaque; 4229 int ret; 4230 ssize_t out_len; 4231 uint8_t *buf, *out_buf; 4232 uint64_t cluster_offset; 4233 4234 assert(bytes == s->cluster_size || (bytes < s->cluster_size && 4235 (offset + bytes == bs->total_sectors << BDRV_SECTOR_BITS))); 4236 4237 buf = qemu_blockalign(bs, s->cluster_size); 4238 if (bytes < s->cluster_size) { 4239 /* Zero-pad last write if image size is not cluster aligned */ 4240 memset(buf + bytes, 0, s->cluster_size - bytes); 4241 } 4242 qemu_iovec_to_buf(qiov, qiov_offset, buf, bytes); 4243 4244 out_buf = g_malloc(s->cluster_size); 4245 4246 out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1, 4247 buf, s->cluster_size); 4248 if (out_len == -ENOMEM) { 4249 /* could not compress: write normal cluster */ 4250 ret = qcow2_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset, 0); 4251 if (ret < 0) { 4252 goto fail; 4253 } 4254 goto success; 4255 } else if (out_len < 0) { 4256 ret = -EINVAL; 4257 goto fail; 4258 } 4259 4260 qemu_co_mutex_lock(&s->lock); 4261 ret = qcow2_alloc_compressed_cluster_offset(bs, offset, out_len, 4262 &cluster_offset); 4263 if (ret < 0) { 4264 qemu_co_mutex_unlock(&s->lock); 4265 goto fail; 4266 } 4267 4268 ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len, true); 4269 qemu_co_mutex_unlock(&s->lock); 4270 if (ret < 0) { 4271 goto fail; 4272 } 4273 4274 BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED); 4275 ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0); 4276 if (ret < 0) { 4277 goto fail; 4278 } 4279 success: 4280 ret = 0; 4281 fail: 4282 qemu_vfree(buf); 4283 g_free(out_buf); 4284 return ret; 4285 } 4286 4287 static coroutine_fn int qcow2_co_pwritev_compressed_task_entry(AioTask *task) 4288 { 4289 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task); 4290 4291 assert(!t->cluster_type && !t->l2meta); 4292 4293 return qcow2_co_pwritev_compressed_task(t->bs, t->offset, t->bytes, t->qiov, 4294 t->qiov_offset); 4295 } 4296 4297 /* 4298 * XXX: put compressed sectors first, then all the cluster aligned 4299 * tables to avoid losing bytes in alignment 4300 */ 4301 static coroutine_fn int 4302 qcow2_co_pwritev_compressed_part(BlockDriverState *bs, 4303 uint64_t offset, uint64_t bytes, 4304 QEMUIOVector *qiov, size_t qiov_offset) 4305 { 4306 BDRVQcow2State *s = bs->opaque; 4307 AioTaskPool *aio = NULL; 4308 int ret = 0; 4309 4310 if (has_data_file(bs)) { 4311 return -ENOTSUP; 4312 } 4313 4314 if (bytes == 0) { 4315 /* 4316 * align end of file to a sector boundary to ease reading with 4317 * sector based I/Os 4318 */ 4319 int64_t len = bdrv_getlength(bs->file->bs); 4320 if (len < 0) { 4321 return len; 4322 } 4323 return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL); 4324 } 4325 4326 if (offset_into_cluster(s, offset)) { 4327 return -EINVAL; 4328 } 4329 4330 while (bytes && aio_task_pool_status(aio) == 0) { 4331 uint64_t chunk_size = MIN(bytes, s->cluster_size); 4332 4333 if (!aio && chunk_size != bytes) { 4334 aio = aio_task_pool_new(QCOW2_MAX_WORKERS); 4335 } 4336 4337 ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_compressed_task_entry, 4338 0, 0, offset, chunk_size, qiov, qiov_offset, NULL); 4339 if (ret < 0) { 4340 break; 4341 } 4342 qiov_offset += chunk_size; 4343 offset += chunk_size; 4344 bytes -= chunk_size; 4345 } 4346 4347 if (aio) { 4348 aio_task_pool_wait_all(aio); 4349 if (ret == 0) { 4350 ret = aio_task_pool_status(aio); 4351 } 4352 g_free(aio); 4353 } 4354 4355 return ret; 4356 } 4357 4358 static int coroutine_fn 4359 qcow2_co_preadv_compressed(BlockDriverState *bs, 4360 uint64_t file_cluster_offset, 4361 uint64_t offset, 4362 uint64_t bytes, 4363 QEMUIOVector *qiov, 4364 size_t qiov_offset) 4365 { 4366 BDRVQcow2State *s = bs->opaque; 4367 int ret = 0, csize, nb_csectors; 4368 uint64_t coffset; 4369 uint8_t *buf, *out_buf; 4370 int offset_in_cluster = offset_into_cluster(s, offset); 4371 4372 coffset = file_cluster_offset & s->cluster_offset_mask; 4373 nb_csectors = ((file_cluster_offset >> s->csize_shift) & s->csize_mask) + 1; 4374 csize = nb_csectors * QCOW2_COMPRESSED_SECTOR_SIZE - 4375 (coffset & ~QCOW2_COMPRESSED_SECTOR_MASK); 4376 4377 buf = g_try_malloc(csize); 4378 if (!buf) { 4379 return -ENOMEM; 4380 } 4381 4382 out_buf = qemu_blockalign(bs, s->cluster_size); 4383 4384 BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED); 4385 ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0); 4386 if (ret < 0) { 4387 goto fail; 4388 } 4389 4390 if (qcow2_co_decompress(bs, out_buf, s->cluster_size, buf, csize) < 0) { 4391 ret = -EIO; 4392 goto fail; 4393 } 4394 4395 qemu_iovec_from_buf(qiov, qiov_offset, out_buf + offset_in_cluster, bytes); 4396 4397 fail: 4398 qemu_vfree(out_buf); 4399 g_free(buf); 4400 4401 return ret; 4402 } 4403 4404 static int make_completely_empty(BlockDriverState *bs) 4405 { 4406 BDRVQcow2State *s = bs->opaque; 4407 Error *local_err = NULL; 4408 int ret, l1_clusters; 4409 int64_t offset; 4410 uint64_t *new_reftable = NULL; 4411 uint64_t rt_entry, l1_size2; 4412 struct { 4413 uint64_t l1_offset; 4414 uint64_t reftable_offset; 4415 uint32_t reftable_clusters; 4416 } QEMU_PACKED l1_ofs_rt_ofs_cls; 4417 4418 ret = qcow2_cache_empty(bs, s->l2_table_cache); 4419 if (ret < 0) { 4420 goto fail; 4421 } 4422 4423 ret = qcow2_cache_empty(bs, s->refcount_block_cache); 4424 if (ret < 0) { 4425 goto fail; 4426 } 4427 4428 /* Refcounts will be broken utterly */ 4429 ret = qcow2_mark_dirty(bs); 4430 if (ret < 0) { 4431 goto fail; 4432 } 4433 4434 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 4435 4436 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t)); 4437 l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t); 4438 4439 /* After this call, neither the in-memory nor the on-disk refcount 4440 * information accurately describe the actual references */ 4441 4442 ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset, 4443 l1_clusters * s->cluster_size, 0); 4444 if (ret < 0) { 4445 goto fail_broken_refcounts; 4446 } 4447 memset(s->l1_table, 0, l1_size2); 4448 4449 BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE); 4450 4451 /* Overwrite enough clusters at the beginning of the sectors to place 4452 * the refcount table, a refcount block and the L1 table in; this may 4453 * overwrite parts of the existing refcount and L1 table, which is not 4454 * an issue because the dirty flag is set, complete data loss is in fact 4455 * desired and partial data loss is consequently fine as well */ 4456 ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size, 4457 (2 + l1_clusters) * s->cluster_size, 0); 4458 /* This call (even if it failed overall) may have overwritten on-disk 4459 * refcount structures; in that case, the in-memory refcount information 4460 * will probably differ from the on-disk information which makes the BDS 4461 * unusable */ 4462 if (ret < 0) { 4463 goto fail_broken_refcounts; 4464 } 4465 4466 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); 4467 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE); 4468 4469 /* "Create" an empty reftable (one cluster) directly after the image 4470 * header and an empty L1 table three clusters after the image header; 4471 * the cluster between those two will be used as the first refblock */ 4472 l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size); 4473 l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size); 4474 l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1); 4475 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset), 4476 &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls)); 4477 if (ret < 0) { 4478 goto fail_broken_refcounts; 4479 } 4480 4481 s->l1_table_offset = 3 * s->cluster_size; 4482 4483 new_reftable = g_try_new0(uint64_t, s->cluster_size / sizeof(uint64_t)); 4484 if (!new_reftable) { 4485 ret = -ENOMEM; 4486 goto fail_broken_refcounts; 4487 } 4488 4489 s->refcount_table_offset = s->cluster_size; 4490 s->refcount_table_size = s->cluster_size / sizeof(uint64_t); 4491 s->max_refcount_table_index = 0; 4492 4493 g_free(s->refcount_table); 4494 s->refcount_table = new_reftable; 4495 new_reftable = NULL; 4496 4497 /* Now the in-memory refcount information again corresponds to the on-disk 4498 * information (reftable is empty and no refblocks (the refblock cache is 4499 * empty)); however, this means some clusters (e.g. the image header) are 4500 * referenced, but not refcounted, but the normal qcow2 code assumes that 4501 * the in-memory information is always correct */ 4502 4503 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); 4504 4505 /* Enter the first refblock into the reftable */ 4506 rt_entry = cpu_to_be64(2 * s->cluster_size); 4507 ret = bdrv_pwrite_sync(bs->file, s->cluster_size, 4508 &rt_entry, sizeof(rt_entry)); 4509 if (ret < 0) { 4510 goto fail_broken_refcounts; 4511 } 4512 s->refcount_table[0] = 2 * s->cluster_size; 4513 4514 s->free_cluster_index = 0; 4515 assert(3 + l1_clusters <= s->refcount_block_size); 4516 offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2); 4517 if (offset < 0) { 4518 ret = offset; 4519 goto fail_broken_refcounts; 4520 } else if (offset > 0) { 4521 error_report("First cluster in emptied image is in use"); 4522 abort(); 4523 } 4524 4525 /* Now finally the in-memory information corresponds to the on-disk 4526 * structures and is correct */ 4527 ret = qcow2_mark_clean(bs); 4528 if (ret < 0) { 4529 goto fail; 4530 } 4531 4532 ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false, 4533 PREALLOC_MODE_OFF, &local_err); 4534 if (ret < 0) { 4535 error_report_err(local_err); 4536 goto fail; 4537 } 4538 4539 return 0; 4540 4541 fail_broken_refcounts: 4542 /* The BDS is unusable at this point. If we wanted to make it usable, we 4543 * would have to call qcow2_refcount_close(), qcow2_refcount_init(), 4544 * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init() 4545 * again. However, because the functions which could have caused this error 4546 * path to be taken are used by those functions as well, it's very likely 4547 * that that sequence will fail as well. Therefore, just eject the BDS. */ 4548 bs->drv = NULL; 4549 4550 fail: 4551 g_free(new_reftable); 4552 return ret; 4553 } 4554 4555 static int qcow2_make_empty(BlockDriverState *bs) 4556 { 4557 BDRVQcow2State *s = bs->opaque; 4558 uint64_t offset, end_offset; 4559 int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size); 4560 int l1_clusters, ret = 0; 4561 4562 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t)); 4563 4564 if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps && 4565 3 + l1_clusters <= s->refcount_block_size && 4566 s->crypt_method_header != QCOW_CRYPT_LUKS && 4567 !has_data_file(bs)) { 4568 /* The following function only works for qcow2 v3 images (it 4569 * requires the dirty flag) and only as long as there are no 4570 * features that reserve extra clusters (such as snapshots, 4571 * LUKS header, or persistent bitmaps), because it completely 4572 * empties the image. Furthermore, the L1 table and three 4573 * additional clusters (image header, refcount table, one 4574 * refcount block) have to fit inside one refcount block. It 4575 * only resets the image file, i.e. does not work with an 4576 * external data file. */ 4577 return make_completely_empty(bs); 4578 } 4579 4580 /* This fallback code simply discards every active cluster; this is slow, 4581 * but works in all cases */ 4582 end_offset = bs->total_sectors * BDRV_SECTOR_SIZE; 4583 for (offset = 0; offset < end_offset; offset += step) { 4584 /* As this function is generally used after committing an external 4585 * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the 4586 * default action for this kind of discard is to pass the discard, 4587 * which will ideally result in an actually smaller image file, as 4588 * is probably desired. */ 4589 ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset), 4590 QCOW2_DISCARD_SNAPSHOT, true); 4591 if (ret < 0) { 4592 break; 4593 } 4594 } 4595 4596 return ret; 4597 } 4598 4599 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs) 4600 { 4601 BDRVQcow2State *s = bs->opaque; 4602 int ret; 4603 4604 qemu_co_mutex_lock(&s->lock); 4605 ret = qcow2_write_caches(bs); 4606 qemu_co_mutex_unlock(&s->lock); 4607 4608 return ret; 4609 } 4610 4611 static ssize_t qcow2_measure_crypto_hdr_init_func(QCryptoBlock *block, 4612 size_t headerlen, void *opaque, Error **errp) 4613 { 4614 size_t *headerlenp = opaque; 4615 4616 /* Stash away the payload size */ 4617 *headerlenp = headerlen; 4618 return 0; 4619 } 4620 4621 static ssize_t qcow2_measure_crypto_hdr_write_func(QCryptoBlock *block, 4622 size_t offset, const uint8_t *buf, size_t buflen, 4623 void *opaque, Error **errp) 4624 { 4625 /* Discard the bytes, we're not actually writing to an image */ 4626 return buflen; 4627 } 4628 4629 /* Determine the number of bytes for the LUKS payload */ 4630 static bool qcow2_measure_luks_headerlen(QemuOpts *opts, size_t *len, 4631 Error **errp) 4632 { 4633 QDict *opts_qdict; 4634 QDict *cryptoopts_qdict; 4635 QCryptoBlockCreateOptions *cryptoopts; 4636 QCryptoBlock *crypto; 4637 4638 /* Extract "encrypt." options into a qdict */ 4639 opts_qdict = qemu_opts_to_qdict(opts, NULL); 4640 qdict_extract_subqdict(opts_qdict, &cryptoopts_qdict, "encrypt."); 4641 qobject_unref(opts_qdict); 4642 4643 /* Build QCryptoBlockCreateOptions object from qdict */ 4644 qdict_put_str(cryptoopts_qdict, "format", "luks"); 4645 cryptoopts = block_crypto_create_opts_init(cryptoopts_qdict, errp); 4646 qobject_unref(cryptoopts_qdict); 4647 if (!cryptoopts) { 4648 return false; 4649 } 4650 4651 /* Fake LUKS creation in order to determine the payload size */ 4652 crypto = qcrypto_block_create(cryptoopts, "encrypt.", 4653 qcow2_measure_crypto_hdr_init_func, 4654 qcow2_measure_crypto_hdr_write_func, 4655 len, errp); 4656 qapi_free_QCryptoBlockCreateOptions(cryptoopts); 4657 if (!crypto) { 4658 return false; 4659 } 4660 4661 qcrypto_block_free(crypto); 4662 return true; 4663 } 4664 4665 static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, 4666 Error **errp) 4667 { 4668 Error *local_err = NULL; 4669 BlockMeasureInfo *info; 4670 uint64_t required = 0; /* bytes that contribute to required size */ 4671 uint64_t virtual_size; /* disk size as seen by guest */ 4672 uint64_t refcount_bits; 4673 uint64_t l2_tables; 4674 uint64_t luks_payload_size = 0; 4675 size_t cluster_size; 4676 int version; 4677 char *optstr; 4678 PreallocMode prealloc; 4679 bool has_backing_file; 4680 bool has_luks; 4681 4682 /* Parse image creation options */ 4683 cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err); 4684 if (local_err) { 4685 goto err; 4686 } 4687 4688 version = qcow2_opt_get_version_del(opts, &local_err); 4689 if (local_err) { 4690 goto err; 4691 } 4692 4693 refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err); 4694 if (local_err) { 4695 goto err; 4696 } 4697 4698 optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 4699 prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr, 4700 PREALLOC_MODE_OFF, &local_err); 4701 g_free(optstr); 4702 if (local_err) { 4703 goto err; 4704 } 4705 4706 optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE); 4707 has_backing_file = !!optstr; 4708 g_free(optstr); 4709 4710 optstr = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT); 4711 has_luks = optstr && strcmp(optstr, "luks") == 0; 4712 g_free(optstr); 4713 4714 if (has_luks) { 4715 size_t headerlen; 4716 4717 if (!qcow2_measure_luks_headerlen(opts, &headerlen, &local_err)) { 4718 goto err; 4719 } 4720 4721 luks_payload_size = ROUND_UP(headerlen, cluster_size); 4722 } 4723 4724 virtual_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0); 4725 virtual_size = ROUND_UP(virtual_size, cluster_size); 4726 4727 /* Check that virtual disk size is valid */ 4728 l2_tables = DIV_ROUND_UP(virtual_size / cluster_size, 4729 cluster_size / sizeof(uint64_t)); 4730 if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) { 4731 error_setg(&local_err, "The image size is too large " 4732 "(try using a larger cluster size)"); 4733 goto err; 4734 } 4735 4736 /* Account for input image */ 4737 if (in_bs) { 4738 int64_t ssize = bdrv_getlength(in_bs); 4739 if (ssize < 0) { 4740 error_setg_errno(&local_err, -ssize, 4741 "Unable to get image virtual_size"); 4742 goto err; 4743 } 4744 4745 virtual_size = ROUND_UP(ssize, cluster_size); 4746 4747 if (has_backing_file) { 4748 /* We don't how much of the backing chain is shared by the input 4749 * image and the new image file. In the worst case the new image's 4750 * backing file has nothing in common with the input image. Be 4751 * conservative and assume all clusters need to be written. 4752 */ 4753 required = virtual_size; 4754 } else { 4755 int64_t offset; 4756 int64_t pnum = 0; 4757 4758 for (offset = 0; offset < ssize; offset += pnum) { 4759 int ret; 4760 4761 ret = bdrv_block_status_above(in_bs, NULL, offset, 4762 ssize - offset, &pnum, NULL, 4763 NULL); 4764 if (ret < 0) { 4765 error_setg_errno(&local_err, -ret, 4766 "Unable to get block status"); 4767 goto err; 4768 } 4769 4770 if (ret & BDRV_BLOCK_ZERO) { 4771 /* Skip zero regions (safe with no backing file) */ 4772 } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) == 4773 (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) { 4774 /* Extend pnum to end of cluster for next iteration */ 4775 pnum = ROUND_UP(offset + pnum, cluster_size) - offset; 4776 4777 /* Count clusters we've seen */ 4778 required += offset % cluster_size + pnum; 4779 } 4780 } 4781 } 4782 } 4783 4784 /* Take into account preallocation. Nothing special is needed for 4785 * PREALLOC_MODE_METADATA since metadata is always counted. 4786 */ 4787 if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) { 4788 required = virtual_size; 4789 } 4790 4791 info = g_new(BlockMeasureInfo, 1); 4792 info->fully_allocated = 4793 qcow2_calc_prealloc_size(virtual_size, cluster_size, 4794 ctz32(refcount_bits)) + luks_payload_size; 4795 4796 /* Remove data clusters that are not required. This overestimates the 4797 * required size because metadata needed for the fully allocated file is 4798 * still counted. 4799 */ 4800 info->required = info->fully_allocated - virtual_size + required; 4801 return info; 4802 4803 err: 4804 error_propagate(errp, local_err); 4805 return NULL; 4806 } 4807 4808 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 4809 { 4810 BDRVQcow2State *s = bs->opaque; 4811 bdi->unallocated_blocks_are_zero = true; 4812 bdi->cluster_size = s->cluster_size; 4813 bdi->vm_state_offset = qcow2_vm_state_offset(s); 4814 return 0; 4815 } 4816 4817 static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs, 4818 Error **errp) 4819 { 4820 BDRVQcow2State *s = bs->opaque; 4821 ImageInfoSpecific *spec_info; 4822 QCryptoBlockInfo *encrypt_info = NULL; 4823 Error *local_err = NULL; 4824 4825 if (s->crypto != NULL) { 4826 encrypt_info = qcrypto_block_get_info(s->crypto, &local_err); 4827 if (local_err) { 4828 error_propagate(errp, local_err); 4829 return NULL; 4830 } 4831 } 4832 4833 spec_info = g_new(ImageInfoSpecific, 1); 4834 *spec_info = (ImageInfoSpecific){ 4835 .type = IMAGE_INFO_SPECIFIC_KIND_QCOW2, 4836 .u.qcow2.data = g_new0(ImageInfoSpecificQCow2, 1), 4837 }; 4838 if (s->qcow_version == 2) { 4839 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ 4840 .compat = g_strdup("0.10"), 4841 .refcount_bits = s->refcount_bits, 4842 }; 4843 } else if (s->qcow_version == 3) { 4844 Qcow2BitmapInfoList *bitmaps; 4845 bitmaps = qcow2_get_bitmap_info_list(bs, &local_err); 4846 if (local_err) { 4847 error_propagate(errp, local_err); 4848 qapi_free_ImageInfoSpecific(spec_info); 4849 return NULL; 4850 } 4851 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ 4852 .compat = g_strdup("1.1"), 4853 .lazy_refcounts = s->compatible_features & 4854 QCOW2_COMPAT_LAZY_REFCOUNTS, 4855 .has_lazy_refcounts = true, 4856 .corrupt = s->incompatible_features & 4857 QCOW2_INCOMPAT_CORRUPT, 4858 .has_corrupt = true, 4859 .refcount_bits = s->refcount_bits, 4860 .has_bitmaps = !!bitmaps, 4861 .bitmaps = bitmaps, 4862 .has_data_file = !!s->image_data_file, 4863 .data_file = g_strdup(s->image_data_file), 4864 .has_data_file_raw = has_data_file(bs), 4865 .data_file_raw = data_file_is_raw(bs), 4866 }; 4867 } else { 4868 /* if this assertion fails, this probably means a new version was 4869 * added without having it covered here */ 4870 assert(false); 4871 } 4872 4873 if (encrypt_info) { 4874 ImageInfoSpecificQCow2Encryption *qencrypt = 4875 g_new(ImageInfoSpecificQCow2Encryption, 1); 4876 switch (encrypt_info->format) { 4877 case Q_CRYPTO_BLOCK_FORMAT_QCOW: 4878 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES; 4879 break; 4880 case Q_CRYPTO_BLOCK_FORMAT_LUKS: 4881 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS; 4882 qencrypt->u.luks = encrypt_info->u.luks; 4883 break; 4884 default: 4885 abort(); 4886 } 4887 /* Since we did shallow copy above, erase any pointers 4888 * in the original info */ 4889 memset(&encrypt_info->u, 0, sizeof(encrypt_info->u)); 4890 qapi_free_QCryptoBlockInfo(encrypt_info); 4891 4892 spec_info->u.qcow2.data->has_encrypt = true; 4893 spec_info->u.qcow2.data->encrypt = qencrypt; 4894 } 4895 4896 return spec_info; 4897 } 4898 4899 static int qcow2_has_zero_init(BlockDriverState *bs) 4900 { 4901 BDRVQcow2State *s = bs->opaque; 4902 bool preallocated; 4903 4904 if (qemu_in_coroutine()) { 4905 qemu_co_mutex_lock(&s->lock); 4906 } 4907 /* 4908 * Check preallocation status: Preallocated images have all L2 4909 * tables allocated, nonpreallocated images have none. It is 4910 * therefore enough to check the first one. 4911 */ 4912 preallocated = s->l1_size > 0 && s->l1_table[0] != 0; 4913 if (qemu_in_coroutine()) { 4914 qemu_co_mutex_unlock(&s->lock); 4915 } 4916 4917 if (!preallocated) { 4918 return 1; 4919 } else if (bs->encrypted) { 4920 return 0; 4921 } else { 4922 return bdrv_has_zero_init(s->data_file->bs); 4923 } 4924 } 4925 4926 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, 4927 int64_t pos) 4928 { 4929 BDRVQcow2State *s = bs->opaque; 4930 4931 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); 4932 return bs->drv->bdrv_co_pwritev_part(bs, qcow2_vm_state_offset(s) + pos, 4933 qiov->size, qiov, 0, 0); 4934 } 4935 4936 static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, 4937 int64_t pos) 4938 { 4939 BDRVQcow2State *s = bs->opaque; 4940 4941 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); 4942 return bs->drv->bdrv_co_preadv_part(bs, qcow2_vm_state_offset(s) + pos, 4943 qiov->size, qiov, 0, 0); 4944 } 4945 4946 /* 4947 * Downgrades an image's version. To achieve this, any incompatible features 4948 * have to be removed. 4949 */ 4950 static int qcow2_downgrade(BlockDriverState *bs, int target_version, 4951 BlockDriverAmendStatusCB *status_cb, void *cb_opaque, 4952 Error **errp) 4953 { 4954 BDRVQcow2State *s = bs->opaque; 4955 int current_version = s->qcow_version; 4956 int ret; 4957 4958 /* This is qcow2_downgrade(), not qcow2_upgrade() */ 4959 assert(target_version < current_version); 4960 4961 /* There are no other versions (now) that you can downgrade to */ 4962 assert(target_version == 2); 4963 4964 if (s->refcount_order != 4) { 4965 error_setg(errp, "compat=0.10 requires refcount_bits=16"); 4966 return -ENOTSUP; 4967 } 4968 4969 if (has_data_file(bs)) { 4970 error_setg(errp, "Cannot downgrade an image with a data file"); 4971 return -ENOTSUP; 4972 } 4973 4974 /* clear incompatible features */ 4975 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 4976 ret = qcow2_mark_clean(bs); 4977 if (ret < 0) { 4978 error_setg_errno(errp, -ret, "Failed to make the image clean"); 4979 return ret; 4980 } 4981 } 4982 4983 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in 4984 * the first place; if that happens nonetheless, returning -ENOTSUP is the 4985 * best thing to do anyway */ 4986 4987 if (s->incompatible_features) { 4988 error_setg(errp, "Cannot downgrade an image with incompatible features " 4989 "%#" PRIx64 " set", s->incompatible_features); 4990 return -ENOTSUP; 4991 } 4992 4993 /* since we can ignore compatible features, we can set them to 0 as well */ 4994 s->compatible_features = 0; 4995 /* if lazy refcounts have been used, they have already been fixed through 4996 * clearing the dirty flag */ 4997 4998 /* clearing autoclear features is trivial */ 4999 s->autoclear_features = 0; 5000 5001 ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque); 5002 if (ret < 0) { 5003 error_setg_errno(errp, -ret, "Failed to turn zero into data clusters"); 5004 return ret; 5005 } 5006 5007 s->qcow_version = target_version; 5008 ret = qcow2_update_header(bs); 5009 if (ret < 0) { 5010 s->qcow_version = current_version; 5011 error_setg_errno(errp, -ret, "Failed to update the image header"); 5012 return ret; 5013 } 5014 return 0; 5015 } 5016 5017 /* 5018 * Upgrades an image's version. While newer versions encompass all 5019 * features of older versions, some things may have to be presented 5020 * differently. 5021 */ 5022 static int qcow2_upgrade(BlockDriverState *bs, int target_version, 5023 BlockDriverAmendStatusCB *status_cb, void *cb_opaque, 5024 Error **errp) 5025 { 5026 BDRVQcow2State *s = bs->opaque; 5027 bool need_snapshot_update; 5028 int current_version = s->qcow_version; 5029 int i; 5030 int ret; 5031 5032 /* This is qcow2_upgrade(), not qcow2_downgrade() */ 5033 assert(target_version > current_version); 5034 5035 /* There are no other versions (yet) that you can upgrade to */ 5036 assert(target_version == 3); 5037 5038 status_cb(bs, 0, 2, cb_opaque); 5039 5040 /* 5041 * In v2, snapshots do not need to have extra data. v3 requires 5042 * the 64-bit VM state size and the virtual disk size to be 5043 * present. 5044 * qcow2_write_snapshots() will always write the list in the 5045 * v3-compliant format. 5046 */ 5047 need_snapshot_update = false; 5048 for (i = 0; i < s->nb_snapshots; i++) { 5049 if (s->snapshots[i].extra_data_size < 5050 sizeof_field(QCowSnapshotExtraData, vm_state_size_large) + 5051 sizeof_field(QCowSnapshotExtraData, disk_size)) 5052 { 5053 need_snapshot_update = true; 5054 break; 5055 } 5056 } 5057 if (need_snapshot_update) { 5058 ret = qcow2_write_snapshots(bs); 5059 if (ret < 0) { 5060 error_setg_errno(errp, -ret, "Failed to update the snapshot table"); 5061 return ret; 5062 } 5063 } 5064 status_cb(bs, 1, 2, cb_opaque); 5065 5066 s->qcow_version = target_version; 5067 ret = qcow2_update_header(bs); 5068 if (ret < 0) { 5069 s->qcow_version = current_version; 5070 error_setg_errno(errp, -ret, "Failed to update the image header"); 5071 return ret; 5072 } 5073 status_cb(bs, 2, 2, cb_opaque); 5074 5075 return 0; 5076 } 5077 5078 typedef enum Qcow2AmendOperation { 5079 /* This is the value Qcow2AmendHelperCBInfo::last_operation will be 5080 * statically initialized to so that the helper CB can discern the first 5081 * invocation from an operation change */ 5082 QCOW2_NO_OPERATION = 0, 5083 5084 QCOW2_UPGRADING, 5085 QCOW2_CHANGING_REFCOUNT_ORDER, 5086 QCOW2_DOWNGRADING, 5087 } Qcow2AmendOperation; 5088 5089 typedef struct Qcow2AmendHelperCBInfo { 5090 /* The code coordinating the amend operations should only modify 5091 * these four fields; the rest will be managed by the CB */ 5092 BlockDriverAmendStatusCB *original_status_cb; 5093 void *original_cb_opaque; 5094 5095 Qcow2AmendOperation current_operation; 5096 5097 /* Total number of operations to perform (only set once) */ 5098 int total_operations; 5099 5100 /* The following fields are managed by the CB */ 5101 5102 /* Number of operations completed */ 5103 int operations_completed; 5104 5105 /* Cumulative offset of all completed operations */ 5106 int64_t offset_completed; 5107 5108 Qcow2AmendOperation last_operation; 5109 int64_t last_work_size; 5110 } Qcow2AmendHelperCBInfo; 5111 5112 static void qcow2_amend_helper_cb(BlockDriverState *bs, 5113 int64_t operation_offset, 5114 int64_t operation_work_size, void *opaque) 5115 { 5116 Qcow2AmendHelperCBInfo *info = opaque; 5117 int64_t current_work_size; 5118 int64_t projected_work_size; 5119 5120 if (info->current_operation != info->last_operation) { 5121 if (info->last_operation != QCOW2_NO_OPERATION) { 5122 info->offset_completed += info->last_work_size; 5123 info->operations_completed++; 5124 } 5125 5126 info->last_operation = info->current_operation; 5127 } 5128 5129 assert(info->total_operations > 0); 5130 assert(info->operations_completed < info->total_operations); 5131 5132 info->last_work_size = operation_work_size; 5133 5134 current_work_size = info->offset_completed + operation_work_size; 5135 5136 /* current_work_size is the total work size for (operations_completed + 1) 5137 * operations (which includes this one), so multiply it by the number of 5138 * operations not covered and divide it by the number of operations 5139 * covered to get a projection for the operations not covered */ 5140 projected_work_size = current_work_size * (info->total_operations - 5141 info->operations_completed - 1) 5142 / (info->operations_completed + 1); 5143 5144 info->original_status_cb(bs, info->offset_completed + operation_offset, 5145 current_work_size + projected_work_size, 5146 info->original_cb_opaque); 5147 } 5148 5149 static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, 5150 BlockDriverAmendStatusCB *status_cb, 5151 void *cb_opaque, 5152 Error **errp) 5153 { 5154 BDRVQcow2State *s = bs->opaque; 5155 int old_version = s->qcow_version, new_version = old_version; 5156 uint64_t new_size = 0; 5157 const char *backing_file = NULL, *backing_format = NULL, *data_file = NULL; 5158 bool lazy_refcounts = s->use_lazy_refcounts; 5159 bool data_file_raw = data_file_is_raw(bs); 5160 const char *compat = NULL; 5161 uint64_t cluster_size = s->cluster_size; 5162 bool encrypt; 5163 int encformat; 5164 int refcount_bits = s->refcount_bits; 5165 int ret; 5166 QemuOptDesc *desc = opts->list->desc; 5167 Qcow2AmendHelperCBInfo helper_cb_info; 5168 5169 while (desc && desc->name) { 5170 if (!qemu_opt_find(opts, desc->name)) { 5171 /* only change explicitly defined options */ 5172 desc++; 5173 continue; 5174 } 5175 5176 if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) { 5177 compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL); 5178 if (!compat) { 5179 /* preserve default */ 5180 } else if (!strcmp(compat, "0.10") || !strcmp(compat, "v2")) { 5181 new_version = 2; 5182 } else if (!strcmp(compat, "1.1") || !strcmp(compat, "v3")) { 5183 new_version = 3; 5184 } else { 5185 error_setg(errp, "Unknown compatibility level %s", compat); 5186 return -EINVAL; 5187 } 5188 } else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) { 5189 error_setg(errp, "Cannot change preallocation mode"); 5190 return -ENOTSUP; 5191 } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) { 5192 new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0); 5193 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) { 5194 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 5195 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) { 5196 backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT); 5197 } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) { 5198 encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, 5199 !!s->crypto); 5200 5201 if (encrypt != !!s->crypto) { 5202 error_setg(errp, 5203 "Changing the encryption flag is not supported"); 5204 return -ENOTSUP; 5205 } 5206 } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT_FORMAT)) { 5207 encformat = qcow2_crypt_method_from_format( 5208 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT)); 5209 5210 if (encformat != s->crypt_method_header) { 5211 error_setg(errp, 5212 "Changing the encryption format is not supported"); 5213 return -ENOTSUP; 5214 } 5215 } else if (g_str_has_prefix(desc->name, "encrypt.")) { 5216 error_setg(errp, 5217 "Changing the encryption parameters is not supported"); 5218 return -ENOTSUP; 5219 } else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) { 5220 cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 5221 cluster_size); 5222 if (cluster_size != s->cluster_size) { 5223 error_setg(errp, "Changing the cluster size is not supported"); 5224 return -ENOTSUP; 5225 } 5226 } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) { 5227 lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS, 5228 lazy_refcounts); 5229 } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) { 5230 refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS, 5231 refcount_bits); 5232 5233 if (refcount_bits <= 0 || refcount_bits > 64 || 5234 !is_power_of_2(refcount_bits)) 5235 { 5236 error_setg(errp, "Refcount width must be a power of two and " 5237 "may not exceed 64 bits"); 5238 return -EINVAL; 5239 } 5240 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE)) { 5241 data_file = qemu_opt_get(opts, BLOCK_OPT_DATA_FILE); 5242 if (data_file && !has_data_file(bs)) { 5243 error_setg(errp, "data-file can only be set for images that " 5244 "use an external data file"); 5245 return -EINVAL; 5246 } 5247 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE_RAW)) { 5248 data_file_raw = qemu_opt_get_bool(opts, BLOCK_OPT_DATA_FILE_RAW, 5249 data_file_raw); 5250 if (data_file_raw && !data_file_is_raw(bs)) { 5251 error_setg(errp, "data-file-raw cannot be set on existing " 5252 "images"); 5253 return -EINVAL; 5254 } 5255 } else { 5256 /* if this point is reached, this probably means a new option was 5257 * added without having it covered here */ 5258 abort(); 5259 } 5260 5261 desc++; 5262 } 5263 5264 helper_cb_info = (Qcow2AmendHelperCBInfo){ 5265 .original_status_cb = status_cb, 5266 .original_cb_opaque = cb_opaque, 5267 .total_operations = (new_version != old_version) 5268 + (s->refcount_bits != refcount_bits) 5269 }; 5270 5271 /* Upgrade first (some features may require compat=1.1) */ 5272 if (new_version > old_version) { 5273 helper_cb_info.current_operation = QCOW2_UPGRADING; 5274 ret = qcow2_upgrade(bs, new_version, &qcow2_amend_helper_cb, 5275 &helper_cb_info, errp); 5276 if (ret < 0) { 5277 return ret; 5278 } 5279 } 5280 5281 if (s->refcount_bits != refcount_bits) { 5282 int refcount_order = ctz32(refcount_bits); 5283 5284 if (new_version < 3 && refcount_bits != 16) { 5285 error_setg(errp, "Refcount widths other than 16 bits require " 5286 "compatibility level 1.1 or above (use compat=1.1 or " 5287 "greater)"); 5288 return -EINVAL; 5289 } 5290 5291 helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER; 5292 ret = qcow2_change_refcount_order(bs, refcount_order, 5293 &qcow2_amend_helper_cb, 5294 &helper_cb_info, errp); 5295 if (ret < 0) { 5296 return ret; 5297 } 5298 } 5299 5300 /* data-file-raw blocks backing files, so clear it first if requested */ 5301 if (data_file_raw) { 5302 s->autoclear_features |= QCOW2_AUTOCLEAR_DATA_FILE_RAW; 5303 } else { 5304 s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW; 5305 } 5306 5307 if (data_file) { 5308 g_free(s->image_data_file); 5309 s->image_data_file = *data_file ? g_strdup(data_file) : NULL; 5310 } 5311 5312 ret = qcow2_update_header(bs); 5313 if (ret < 0) { 5314 error_setg_errno(errp, -ret, "Failed to update the image header"); 5315 return ret; 5316 } 5317 5318 if (backing_file || backing_format) { 5319 ret = qcow2_change_backing_file(bs, 5320 backing_file ?: s->image_backing_file, 5321 backing_format ?: s->image_backing_format); 5322 if (ret < 0) { 5323 error_setg_errno(errp, -ret, "Failed to change the backing file"); 5324 return ret; 5325 } 5326 } 5327 5328 if (s->use_lazy_refcounts != lazy_refcounts) { 5329 if (lazy_refcounts) { 5330 if (new_version < 3) { 5331 error_setg(errp, "Lazy refcounts only supported with " 5332 "compatibility level 1.1 and above (use compat=1.1 " 5333 "or greater)"); 5334 return -EINVAL; 5335 } 5336 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 5337 ret = qcow2_update_header(bs); 5338 if (ret < 0) { 5339 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 5340 error_setg_errno(errp, -ret, "Failed to update the image header"); 5341 return ret; 5342 } 5343 s->use_lazy_refcounts = true; 5344 } else { 5345 /* make image clean first */ 5346 ret = qcow2_mark_clean(bs); 5347 if (ret < 0) { 5348 error_setg_errno(errp, -ret, "Failed to make the image clean"); 5349 return ret; 5350 } 5351 /* now disallow lazy refcounts */ 5352 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 5353 ret = qcow2_update_header(bs); 5354 if (ret < 0) { 5355 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 5356 error_setg_errno(errp, -ret, "Failed to update the image header"); 5357 return ret; 5358 } 5359 s->use_lazy_refcounts = false; 5360 } 5361 } 5362 5363 if (new_size) { 5364 BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), 5365 BLK_PERM_RESIZE, BLK_PERM_ALL); 5366 ret = blk_insert_bs(blk, bs, errp); 5367 if (ret < 0) { 5368 blk_unref(blk); 5369 return ret; 5370 } 5371 5372 /* 5373 * Amending image options should ensure that the image has 5374 * exactly the given new values, so pass exact=true here. 5375 */ 5376 ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp); 5377 blk_unref(blk); 5378 if (ret < 0) { 5379 return ret; 5380 } 5381 } 5382 5383 /* Downgrade last (so unsupported features can be removed before) */ 5384 if (new_version < old_version) { 5385 helper_cb_info.current_operation = QCOW2_DOWNGRADING; 5386 ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb, 5387 &helper_cb_info, errp); 5388 if (ret < 0) { 5389 return ret; 5390 } 5391 } 5392 5393 return 0; 5394 } 5395 5396 /* 5397 * If offset or size are negative, respectively, they will not be included in 5398 * the BLOCK_IMAGE_CORRUPTED event emitted. 5399 * fatal will be ignored for read-only BDS; corruptions found there will always 5400 * be considered non-fatal. 5401 */ 5402 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset, 5403 int64_t size, const char *message_format, ...) 5404 { 5405 BDRVQcow2State *s = bs->opaque; 5406 const char *node_name; 5407 char *message; 5408 va_list ap; 5409 5410 fatal = fatal && bdrv_is_writable(bs); 5411 5412 if (s->signaled_corruption && 5413 (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT))) 5414 { 5415 return; 5416 } 5417 5418 va_start(ap, message_format); 5419 message = g_strdup_vprintf(message_format, ap); 5420 va_end(ap); 5421 5422 if (fatal) { 5423 fprintf(stderr, "qcow2: Marking image as corrupt: %s; further " 5424 "corruption events will be suppressed\n", message); 5425 } else { 5426 fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal " 5427 "corruption events will be suppressed\n", message); 5428 } 5429 5430 node_name = bdrv_get_node_name(bs); 5431 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs), 5432 *node_name != '\0', node_name, 5433 message, offset >= 0, offset, 5434 size >= 0, size, 5435 fatal); 5436 g_free(message); 5437 5438 if (fatal) { 5439 qcow2_mark_corrupt(bs); 5440 bs->drv = NULL; /* make BDS unusable */ 5441 } 5442 5443 s->signaled_corruption = true; 5444 } 5445 5446 static QemuOptsList qcow2_create_opts = { 5447 .name = "qcow2-create-opts", 5448 .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head), 5449 .desc = { 5450 { 5451 .name = BLOCK_OPT_SIZE, 5452 .type = QEMU_OPT_SIZE, 5453 .help = "Virtual disk size" 5454 }, 5455 { 5456 .name = BLOCK_OPT_COMPAT_LEVEL, 5457 .type = QEMU_OPT_STRING, 5458 .help = "Compatibility level (v2 [0.10] or v3 [1.1])" 5459 }, 5460 { 5461 .name = BLOCK_OPT_BACKING_FILE, 5462 .type = QEMU_OPT_STRING, 5463 .help = "File name of a base image" 5464 }, 5465 { 5466 .name = BLOCK_OPT_BACKING_FMT, 5467 .type = QEMU_OPT_STRING, 5468 .help = "Image format of the base image" 5469 }, 5470 { 5471 .name = BLOCK_OPT_DATA_FILE, 5472 .type = QEMU_OPT_STRING, 5473 .help = "File name of an external data file" 5474 }, 5475 { 5476 .name = BLOCK_OPT_DATA_FILE_RAW, 5477 .type = QEMU_OPT_BOOL, 5478 .help = "The external data file must stay valid as a raw image" 5479 }, 5480 { 5481 .name = BLOCK_OPT_ENCRYPT, 5482 .type = QEMU_OPT_BOOL, 5483 .help = "Encrypt the image with format 'aes'. (Deprecated " 5484 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)", 5485 }, 5486 { 5487 .name = BLOCK_OPT_ENCRYPT_FORMAT, 5488 .type = QEMU_OPT_STRING, 5489 .help = "Encrypt the image, format choices: 'aes', 'luks'", 5490 }, 5491 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", 5492 "ID of secret providing qcow AES key or LUKS passphrase"), 5493 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."), 5494 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."), 5495 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."), 5496 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."), 5497 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."), 5498 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."), 5499 { 5500 .name = BLOCK_OPT_CLUSTER_SIZE, 5501 .type = QEMU_OPT_SIZE, 5502 .help = "qcow2 cluster size", 5503 .def_value_str = stringify(DEFAULT_CLUSTER_SIZE) 5504 }, 5505 { 5506 .name = BLOCK_OPT_PREALLOC, 5507 .type = QEMU_OPT_STRING, 5508 .help = "Preallocation mode (allowed values: off, metadata, " 5509 "falloc, full)" 5510 }, 5511 { 5512 .name = BLOCK_OPT_LAZY_REFCOUNTS, 5513 .type = QEMU_OPT_BOOL, 5514 .help = "Postpone refcount updates", 5515 .def_value_str = "off" 5516 }, 5517 { 5518 .name = BLOCK_OPT_REFCOUNT_BITS, 5519 .type = QEMU_OPT_NUMBER, 5520 .help = "Width of a reference count entry in bits", 5521 .def_value_str = "16" 5522 }, 5523 { /* end of list */ } 5524 } 5525 }; 5526 5527 static const char *const qcow2_strong_runtime_opts[] = { 5528 "encrypt." BLOCK_CRYPTO_OPT_QCOW_KEY_SECRET, 5529 5530 NULL 5531 }; 5532 5533 BlockDriver bdrv_qcow2 = { 5534 .format_name = "qcow2", 5535 .instance_size = sizeof(BDRVQcow2State), 5536 .bdrv_probe = qcow2_probe, 5537 .bdrv_open = qcow2_open, 5538 .bdrv_close = qcow2_close, 5539 .bdrv_reopen_prepare = qcow2_reopen_prepare, 5540 .bdrv_reopen_commit = qcow2_reopen_commit, 5541 .bdrv_reopen_commit_post = qcow2_reopen_commit_post, 5542 .bdrv_reopen_abort = qcow2_reopen_abort, 5543 .bdrv_join_options = qcow2_join_options, 5544 .bdrv_child_perm = bdrv_format_default_perms, 5545 .bdrv_co_create_opts = qcow2_co_create_opts, 5546 .bdrv_co_create = qcow2_co_create, 5547 .bdrv_has_zero_init = qcow2_has_zero_init, 5548 .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1, 5549 .bdrv_co_block_status = qcow2_co_block_status, 5550 5551 .bdrv_co_preadv_part = qcow2_co_preadv_part, 5552 .bdrv_co_pwritev_part = qcow2_co_pwritev_part, 5553 .bdrv_co_flush_to_os = qcow2_co_flush_to_os, 5554 5555 .bdrv_co_pwrite_zeroes = qcow2_co_pwrite_zeroes, 5556 .bdrv_co_pdiscard = qcow2_co_pdiscard, 5557 .bdrv_co_copy_range_from = qcow2_co_copy_range_from, 5558 .bdrv_co_copy_range_to = qcow2_co_copy_range_to, 5559 .bdrv_co_truncate = qcow2_co_truncate, 5560 .bdrv_co_pwritev_compressed_part = qcow2_co_pwritev_compressed_part, 5561 .bdrv_make_empty = qcow2_make_empty, 5562 5563 .bdrv_snapshot_create = qcow2_snapshot_create, 5564 .bdrv_snapshot_goto = qcow2_snapshot_goto, 5565 .bdrv_snapshot_delete = qcow2_snapshot_delete, 5566 .bdrv_snapshot_list = qcow2_snapshot_list, 5567 .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp, 5568 .bdrv_measure = qcow2_measure, 5569 .bdrv_get_info = qcow2_get_info, 5570 .bdrv_get_specific_info = qcow2_get_specific_info, 5571 5572 .bdrv_save_vmstate = qcow2_save_vmstate, 5573 .bdrv_load_vmstate = qcow2_load_vmstate, 5574 5575 .supports_backing = true, 5576 .bdrv_change_backing_file = qcow2_change_backing_file, 5577 5578 .bdrv_refresh_limits = qcow2_refresh_limits, 5579 .bdrv_co_invalidate_cache = qcow2_co_invalidate_cache, 5580 .bdrv_inactivate = qcow2_inactivate, 5581 5582 .create_opts = &qcow2_create_opts, 5583 .strong_runtime_opts = qcow2_strong_runtime_opts, 5584 .mutable_opts = mutable_opts, 5585 .bdrv_co_check = qcow2_co_check, 5586 .bdrv_amend_options = qcow2_amend_options, 5587 5588 .bdrv_detach_aio_context = qcow2_detach_aio_context, 5589 .bdrv_attach_aio_context = qcow2_attach_aio_context, 5590 5591 .bdrv_co_can_store_new_dirty_bitmap = qcow2_co_can_store_new_dirty_bitmap, 5592 .bdrv_co_remove_persistent_dirty_bitmap = 5593 qcow2_co_remove_persistent_dirty_bitmap, 5594 }; 5595 5596 static void bdrv_qcow2_init(void) 5597 { 5598 bdrv_register(&bdrv_qcow2); 5599 } 5600 5601 block_init(bdrv_qcow2_init); 5602