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 #include "qemu-common.h" 25 #include "block/block_int.h" 26 #include "qemu/module.h" 27 #include <zlib.h> 28 #include "qemu/aes.h" 29 #include "block/qcow2.h" 30 #include "qemu/error-report.h" 31 #include "qapi/qmp/qerror.h" 32 #include "qapi/qmp/qbool.h" 33 #include "trace.h" 34 35 /* 36 Differences with QCOW: 37 38 - Support for multiple incremental snapshots. 39 - Memory management by reference counts. 40 - Clusters which have a reference count of one have the bit 41 QCOW_OFLAG_COPIED to optimize write performance. 42 - Size of compressed clusters is stored in sectors to reduce bit usage 43 in the cluster offsets. 44 - Support for storing additional data (such as the VM state) in the 45 snapshots. 46 - If a backing store is used, the cluster size is not constrained 47 (could be backported to QCOW). 48 - L2 tables have always a size of one cluster. 49 */ 50 51 52 typedef struct { 53 uint32_t magic; 54 uint32_t len; 55 } QEMU_PACKED QCowExtension; 56 57 #define QCOW2_EXT_MAGIC_END 0 58 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA 59 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857 60 61 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename) 62 { 63 const QCowHeader *cow_header = (const void *)buf; 64 65 if (buf_size >= sizeof(QCowHeader) && 66 be32_to_cpu(cow_header->magic) == QCOW_MAGIC && 67 be32_to_cpu(cow_header->version) >= 2) 68 return 100; 69 else 70 return 0; 71 } 72 73 74 /* 75 * read qcow2 extension and fill bs 76 * start reading from start_offset 77 * finish reading upon magic of value 0 or when end_offset reached 78 * unknown magic is skipped (future extension this version knows nothing about) 79 * return 0 upon success, non-0 otherwise 80 */ 81 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, 82 uint64_t end_offset, void **p_feature_table, 83 Error **errp) 84 { 85 BDRVQcowState *s = bs->opaque; 86 QCowExtension ext; 87 uint64_t offset; 88 int ret; 89 90 #ifdef DEBUG_EXT 91 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset); 92 #endif 93 offset = start_offset; 94 while (offset < end_offset) { 95 96 #ifdef DEBUG_EXT 97 /* Sanity check */ 98 if (offset > s->cluster_size) 99 printf("qcow2_read_extension: suspicious offset %lu\n", offset); 100 101 printf("attempting to read extended header in offset %lu\n", offset); 102 #endif 103 104 ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext)); 105 if (ret < 0) { 106 error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: " 107 "pread fail from offset %" PRIu64, offset); 108 return 1; 109 } 110 be32_to_cpus(&ext.magic); 111 be32_to_cpus(&ext.len); 112 offset += sizeof(ext); 113 #ifdef DEBUG_EXT 114 printf("ext.magic = 0x%x\n", ext.magic); 115 #endif 116 if (ext.len > end_offset - offset) { 117 error_setg(errp, "Header extension too large"); 118 return -EINVAL; 119 } 120 121 switch (ext.magic) { 122 case QCOW2_EXT_MAGIC_END: 123 return 0; 124 125 case QCOW2_EXT_MAGIC_BACKING_FORMAT: 126 if (ext.len >= sizeof(bs->backing_format)) { 127 error_setg(errp, "ERROR: ext_backing_format: len=%u too large" 128 " (>=%zu)", ext.len, sizeof(bs->backing_format)); 129 return 2; 130 } 131 ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len); 132 if (ret < 0) { 133 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: " 134 "Could not read format name"); 135 return 3; 136 } 137 bs->backing_format[ext.len] = '\0'; 138 #ifdef DEBUG_EXT 139 printf("Qcow2: Got format extension %s\n", bs->backing_format); 140 #endif 141 break; 142 143 case QCOW2_EXT_MAGIC_FEATURE_TABLE: 144 if (p_feature_table != NULL) { 145 void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature)); 146 ret = bdrv_pread(bs->file, offset , feature_table, ext.len); 147 if (ret < 0) { 148 error_setg_errno(errp, -ret, "ERROR: ext_feature_table: " 149 "Could not read table"); 150 return ret; 151 } 152 153 *p_feature_table = feature_table; 154 } 155 break; 156 157 default: 158 /* unknown magic - save it in case we need to rewrite the header */ 159 { 160 Qcow2UnknownHeaderExtension *uext; 161 162 uext = g_malloc0(sizeof(*uext) + ext.len); 163 uext->magic = ext.magic; 164 uext->len = ext.len; 165 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next); 166 167 ret = bdrv_pread(bs->file, offset , uext->data, uext->len); 168 if (ret < 0) { 169 error_setg_errno(errp, -ret, "ERROR: unknown extension: " 170 "Could not read data"); 171 return ret; 172 } 173 } 174 break; 175 } 176 177 offset += ((ext.len + 7) & ~7); 178 } 179 180 return 0; 181 } 182 183 static void cleanup_unknown_header_ext(BlockDriverState *bs) 184 { 185 BDRVQcowState *s = bs->opaque; 186 Qcow2UnknownHeaderExtension *uext, *next; 187 188 QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) { 189 QLIST_REMOVE(uext, next); 190 g_free(uext); 191 } 192 } 193 194 static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState *bs, 195 Error **errp, const char *fmt, ...) 196 { 197 char msg[64]; 198 va_list ap; 199 200 va_start(ap, fmt); 201 vsnprintf(msg, sizeof(msg), fmt, ap); 202 va_end(ap); 203 204 error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, bs->device_name, "qcow2", 205 msg); 206 } 207 208 static void report_unsupported_feature(BlockDriverState *bs, 209 Error **errp, Qcow2Feature *table, uint64_t mask) 210 { 211 while (table && table->name[0] != '\0') { 212 if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) { 213 if (mask & (1 << table->bit)) { 214 report_unsupported(bs, errp, "%.46s", table->name); 215 mask &= ~(1 << table->bit); 216 } 217 } 218 table++; 219 } 220 221 if (mask) { 222 report_unsupported(bs, errp, "Unknown incompatible feature: %" PRIx64, 223 mask); 224 } 225 } 226 227 /* 228 * Sets the dirty bit and flushes afterwards if necessary. 229 * 230 * The incompatible_features bit is only set if the image file header was 231 * updated successfully. Therefore it is not required to check the return 232 * value of this function. 233 */ 234 int qcow2_mark_dirty(BlockDriverState *bs) 235 { 236 BDRVQcowState *s = bs->opaque; 237 uint64_t val; 238 int ret; 239 240 assert(s->qcow_version >= 3); 241 242 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 243 return 0; /* already dirty */ 244 } 245 246 val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY); 247 ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features), 248 &val, sizeof(val)); 249 if (ret < 0) { 250 return ret; 251 } 252 ret = bdrv_flush(bs->file); 253 if (ret < 0) { 254 return ret; 255 } 256 257 /* Only treat image as dirty if the header was updated successfully */ 258 s->incompatible_features |= QCOW2_INCOMPAT_DIRTY; 259 return 0; 260 } 261 262 /* 263 * Clears the dirty bit and flushes before if necessary. Only call this 264 * function when there are no pending requests, it does not guard against 265 * concurrent requests dirtying the image. 266 */ 267 static int qcow2_mark_clean(BlockDriverState *bs) 268 { 269 BDRVQcowState *s = bs->opaque; 270 271 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 272 int ret = bdrv_flush(bs); 273 if (ret < 0) { 274 return ret; 275 } 276 277 s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY; 278 return qcow2_update_header(bs); 279 } 280 return 0; 281 } 282 283 /* 284 * Marks the image as corrupt. 285 */ 286 int qcow2_mark_corrupt(BlockDriverState *bs) 287 { 288 BDRVQcowState *s = bs->opaque; 289 290 s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT; 291 return qcow2_update_header(bs); 292 } 293 294 /* 295 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes 296 * before if necessary. 297 */ 298 int qcow2_mark_consistent(BlockDriverState *bs) 299 { 300 BDRVQcowState *s = bs->opaque; 301 302 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { 303 int ret = bdrv_flush(bs); 304 if (ret < 0) { 305 return ret; 306 } 307 308 s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT; 309 return qcow2_update_header(bs); 310 } 311 return 0; 312 } 313 314 static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result, 315 BdrvCheckMode fix) 316 { 317 int ret = qcow2_check_refcounts(bs, result, fix); 318 if (ret < 0) { 319 return ret; 320 } 321 322 if (fix && result->check_errors == 0 && result->corruptions == 0) { 323 ret = qcow2_mark_clean(bs); 324 if (ret < 0) { 325 return ret; 326 } 327 return qcow2_mark_consistent(bs); 328 } 329 return ret; 330 } 331 332 static QemuOptsList qcow2_runtime_opts = { 333 .name = "qcow2", 334 .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head), 335 .desc = { 336 { 337 .name = QCOW2_OPT_LAZY_REFCOUNTS, 338 .type = QEMU_OPT_BOOL, 339 .help = "Postpone refcount updates", 340 }, 341 { 342 .name = QCOW2_OPT_DISCARD_REQUEST, 343 .type = QEMU_OPT_BOOL, 344 .help = "Pass guest discard requests to the layer below", 345 }, 346 { 347 .name = QCOW2_OPT_DISCARD_SNAPSHOT, 348 .type = QEMU_OPT_BOOL, 349 .help = "Generate discard requests when snapshot related space " 350 "is freed", 351 }, 352 { 353 .name = QCOW2_OPT_DISCARD_OTHER, 354 .type = QEMU_OPT_BOOL, 355 .help = "Generate discard requests when other clusters are freed", 356 }, 357 { 358 .name = QCOW2_OPT_OVERLAP, 359 .type = QEMU_OPT_STRING, 360 .help = "Selects which overlap checks to perform from a range of " 361 "templates (none, constant, cached, all)", 362 }, 363 { 364 .name = QCOW2_OPT_OVERLAP_MAIN_HEADER, 365 .type = QEMU_OPT_BOOL, 366 .help = "Check for unintended writes into the main qcow2 header", 367 }, 368 { 369 .name = QCOW2_OPT_OVERLAP_ACTIVE_L1, 370 .type = QEMU_OPT_BOOL, 371 .help = "Check for unintended writes into the active L1 table", 372 }, 373 { 374 .name = QCOW2_OPT_OVERLAP_ACTIVE_L2, 375 .type = QEMU_OPT_BOOL, 376 .help = "Check for unintended writes into an active L2 table", 377 }, 378 { 379 .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE, 380 .type = QEMU_OPT_BOOL, 381 .help = "Check for unintended writes into the refcount table", 382 }, 383 { 384 .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK, 385 .type = QEMU_OPT_BOOL, 386 .help = "Check for unintended writes into a refcount block", 387 }, 388 { 389 .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE, 390 .type = QEMU_OPT_BOOL, 391 .help = "Check for unintended writes into the snapshot table", 392 }, 393 { 394 .name = QCOW2_OPT_OVERLAP_INACTIVE_L1, 395 .type = QEMU_OPT_BOOL, 396 .help = "Check for unintended writes into an inactive L1 table", 397 }, 398 { 399 .name = QCOW2_OPT_OVERLAP_INACTIVE_L2, 400 .type = QEMU_OPT_BOOL, 401 .help = "Check for unintended writes into an inactive L2 table", 402 }, 403 { /* end of list */ } 404 }, 405 }; 406 407 static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = { 408 [QCOW2_OL_MAIN_HEADER_BITNR] = QCOW2_OPT_OVERLAP_MAIN_HEADER, 409 [QCOW2_OL_ACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L1, 410 [QCOW2_OL_ACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L2, 411 [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE, 412 [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK, 413 [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE, 414 [QCOW2_OL_INACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L1, 415 [QCOW2_OL_INACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L2, 416 }; 417 418 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, 419 Error **errp) 420 { 421 BDRVQcowState *s = bs->opaque; 422 int len, i, ret = 0; 423 QCowHeader header; 424 QemuOpts *opts; 425 Error *local_err = NULL; 426 uint64_t ext_end; 427 uint64_t l1_vm_state_index; 428 const char *opt_overlap_check; 429 int overlap_check_template = 0; 430 431 ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); 432 if (ret < 0) { 433 error_setg_errno(errp, -ret, "Could not read qcow2 header"); 434 goto fail; 435 } 436 be32_to_cpus(&header.magic); 437 be32_to_cpus(&header.version); 438 be64_to_cpus(&header.backing_file_offset); 439 be32_to_cpus(&header.backing_file_size); 440 be64_to_cpus(&header.size); 441 be32_to_cpus(&header.cluster_bits); 442 be32_to_cpus(&header.crypt_method); 443 be64_to_cpus(&header.l1_table_offset); 444 be32_to_cpus(&header.l1_size); 445 be64_to_cpus(&header.refcount_table_offset); 446 be32_to_cpus(&header.refcount_table_clusters); 447 be64_to_cpus(&header.snapshots_offset); 448 be32_to_cpus(&header.nb_snapshots); 449 450 if (header.magic != QCOW_MAGIC) { 451 error_setg(errp, "Image is not in qcow2 format"); 452 ret = -EMEDIUMTYPE; 453 goto fail; 454 } 455 if (header.version < 2 || header.version > 3) { 456 report_unsupported(bs, errp, "QCOW version %d", header.version); 457 ret = -ENOTSUP; 458 goto fail; 459 } 460 461 s->qcow_version = header.version; 462 463 /* Initialise version 3 header fields */ 464 if (header.version == 2) { 465 header.incompatible_features = 0; 466 header.compatible_features = 0; 467 header.autoclear_features = 0; 468 header.refcount_order = 4; 469 header.header_length = 72; 470 } else { 471 be64_to_cpus(&header.incompatible_features); 472 be64_to_cpus(&header.compatible_features); 473 be64_to_cpus(&header.autoclear_features); 474 be32_to_cpus(&header.refcount_order); 475 be32_to_cpus(&header.header_length); 476 } 477 478 if (header.header_length > sizeof(header)) { 479 s->unknown_header_fields_size = header.header_length - sizeof(header); 480 s->unknown_header_fields = g_malloc(s->unknown_header_fields_size); 481 ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields, 482 s->unknown_header_fields_size); 483 if (ret < 0) { 484 error_setg_errno(errp, -ret, "Could not read unknown qcow2 header " 485 "fields"); 486 goto fail; 487 } 488 } 489 490 if (header.backing_file_offset) { 491 ext_end = header.backing_file_offset; 492 } else { 493 ext_end = 1 << header.cluster_bits; 494 } 495 496 /* Handle feature bits */ 497 s->incompatible_features = header.incompatible_features; 498 s->compatible_features = header.compatible_features; 499 s->autoclear_features = header.autoclear_features; 500 501 if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) { 502 void *feature_table = NULL; 503 qcow2_read_extensions(bs, header.header_length, ext_end, 504 &feature_table, NULL); 505 report_unsupported_feature(bs, errp, feature_table, 506 s->incompatible_features & 507 ~QCOW2_INCOMPAT_MASK); 508 ret = -ENOTSUP; 509 goto fail; 510 } 511 512 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { 513 /* Corrupt images may not be written to unless they are being repaired 514 */ 515 if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) { 516 error_setg(errp, "qcow2: Image is corrupt; cannot be opened " 517 "read/write"); 518 ret = -EACCES; 519 goto fail; 520 } 521 } 522 523 /* Check support for various header values */ 524 if (header.refcount_order != 4) { 525 report_unsupported(bs, errp, "%d bit reference counts", 526 1 << header.refcount_order); 527 ret = -ENOTSUP; 528 goto fail; 529 } 530 s->refcount_order = header.refcount_order; 531 532 if (header.cluster_bits < MIN_CLUSTER_BITS || 533 header.cluster_bits > MAX_CLUSTER_BITS) { 534 error_setg(errp, "Unsupported cluster size: 2^%i", header.cluster_bits); 535 ret = -EINVAL; 536 goto fail; 537 } 538 if (header.crypt_method > QCOW_CRYPT_AES) { 539 error_setg(errp, "Unsupported encryption method: %i", 540 header.crypt_method); 541 ret = -EINVAL; 542 goto fail; 543 } 544 s->crypt_method_header = header.crypt_method; 545 if (s->crypt_method_header) { 546 bs->encrypted = 1; 547 } 548 s->cluster_bits = header.cluster_bits; 549 s->cluster_size = 1 << s->cluster_bits; 550 s->cluster_sectors = 1 << (s->cluster_bits - 9); 551 s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */ 552 s->l2_size = 1 << s->l2_bits; 553 bs->total_sectors = header.size / 512; 554 s->csize_shift = (62 - (s->cluster_bits - 8)); 555 s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; 556 s->cluster_offset_mask = (1LL << s->csize_shift) - 1; 557 s->refcount_table_offset = header.refcount_table_offset; 558 s->refcount_table_size = 559 header.refcount_table_clusters << (s->cluster_bits - 3); 560 561 s->snapshots_offset = header.snapshots_offset; 562 s->nb_snapshots = header.nb_snapshots; 563 564 /* read the level 1 table */ 565 s->l1_size = header.l1_size; 566 567 l1_vm_state_index = size_to_l1(s, header.size); 568 if (l1_vm_state_index > INT_MAX) { 569 error_setg(errp, "Image is too big"); 570 ret = -EFBIG; 571 goto fail; 572 } 573 s->l1_vm_state_index = l1_vm_state_index; 574 575 /* the L1 table must contain at least enough entries to put 576 header.size bytes */ 577 if (s->l1_size < s->l1_vm_state_index) { 578 error_setg(errp, "L1 table is too small"); 579 ret = -EINVAL; 580 goto fail; 581 } 582 s->l1_table_offset = header.l1_table_offset; 583 if (s->l1_size > 0) { 584 s->l1_table = g_malloc0( 585 align_offset(s->l1_size * sizeof(uint64_t), 512)); 586 ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, 587 s->l1_size * sizeof(uint64_t)); 588 if (ret < 0) { 589 error_setg_errno(errp, -ret, "Could not read L1 table"); 590 goto fail; 591 } 592 for(i = 0;i < s->l1_size; i++) { 593 be64_to_cpus(&s->l1_table[i]); 594 } 595 } 596 597 /* alloc L2 table/refcount block cache */ 598 s->l2_table_cache = qcow2_cache_create(bs, L2_CACHE_SIZE); 599 s->refcount_block_cache = qcow2_cache_create(bs, REFCOUNT_CACHE_SIZE); 600 601 s->cluster_cache = g_malloc(s->cluster_size); 602 /* one more sector for decompressed data alignment */ 603 s->cluster_data = qemu_blockalign(bs, QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size 604 + 512); 605 s->cluster_cache_offset = -1; 606 s->flags = flags; 607 608 ret = qcow2_refcount_init(bs); 609 if (ret != 0) { 610 error_setg_errno(errp, -ret, "Could not initialize refcount handling"); 611 goto fail; 612 } 613 614 QLIST_INIT(&s->cluster_allocs); 615 QTAILQ_INIT(&s->discards); 616 617 /* read qcow2 extensions */ 618 if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL, 619 &local_err)) { 620 error_propagate(errp, local_err); 621 ret = -EINVAL; 622 goto fail; 623 } 624 625 /* read the backing file name */ 626 if (header.backing_file_offset != 0) { 627 len = header.backing_file_size; 628 if (len > 1023) { 629 len = 1023; 630 } 631 ret = bdrv_pread(bs->file, header.backing_file_offset, 632 bs->backing_file, len); 633 if (ret < 0) { 634 error_setg_errno(errp, -ret, "Could not read backing file name"); 635 goto fail; 636 } 637 bs->backing_file[len] = '\0'; 638 } 639 640 ret = qcow2_read_snapshots(bs); 641 if (ret < 0) { 642 error_setg_errno(errp, -ret, "Could not read snapshots"); 643 goto fail; 644 } 645 646 /* Clear unknown autoclear feature bits */ 647 if (!bs->read_only && s->autoclear_features != 0) { 648 s->autoclear_features = 0; 649 ret = qcow2_update_header(bs); 650 if (ret < 0) { 651 error_setg_errno(errp, -ret, "Could not update qcow2 header"); 652 goto fail; 653 } 654 } 655 656 /* Initialise locks */ 657 qemu_co_mutex_init(&s->lock); 658 659 /* Repair image if dirty */ 660 if (!(flags & BDRV_O_CHECK) && !bs->read_only && 661 (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) { 662 BdrvCheckResult result = {0}; 663 664 ret = qcow2_check(bs, &result, BDRV_FIX_ERRORS); 665 if (ret < 0) { 666 error_setg_errno(errp, -ret, "Could not repair dirty image"); 667 goto fail; 668 } 669 } 670 671 /* Enable lazy_refcounts according to image and command line options */ 672 opts = qemu_opts_create_nofail(&qcow2_runtime_opts); 673 qemu_opts_absorb_qdict(opts, options, &local_err); 674 if (error_is_set(&local_err)) { 675 error_propagate(errp, local_err); 676 ret = -EINVAL; 677 goto fail; 678 } 679 680 s->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS, 681 (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS)); 682 683 s->discard_passthrough[QCOW2_DISCARD_NEVER] = false; 684 s->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true; 685 s->discard_passthrough[QCOW2_DISCARD_REQUEST] = 686 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST, 687 flags & BDRV_O_UNMAP); 688 s->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] = 689 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true); 690 s->discard_passthrough[QCOW2_DISCARD_OTHER] = 691 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false); 692 693 opt_overlap_check = qemu_opt_get(opts, "overlap-check") ?: "cached"; 694 if (!strcmp(opt_overlap_check, "none")) { 695 overlap_check_template = 0; 696 } else if (!strcmp(opt_overlap_check, "constant")) { 697 overlap_check_template = QCOW2_OL_CONSTANT; 698 } else if (!strcmp(opt_overlap_check, "cached")) { 699 overlap_check_template = QCOW2_OL_CACHED; 700 } else if (!strcmp(opt_overlap_check, "all")) { 701 overlap_check_template = QCOW2_OL_ALL; 702 } else { 703 error_setg(errp, "Unsupported value '%s' for qcow2 option " 704 "'overlap-check'. Allowed are either of the following: " 705 "none, constant, cached, all", opt_overlap_check); 706 qemu_opts_del(opts); 707 ret = -EINVAL; 708 goto fail; 709 } 710 711 s->overlap_check = 0; 712 for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) { 713 /* overlap-check defines a template bitmask, but every flag may be 714 * overwritten through the associated boolean option */ 715 s->overlap_check |= 716 qemu_opt_get_bool(opts, overlap_bool_option_names[i], 717 overlap_check_template & (1 << i)) << i; 718 } 719 720 qemu_opts_del(opts); 721 722 if (s->use_lazy_refcounts && s->qcow_version < 3) { 723 error_setg(errp, "Lazy refcounts require a qcow2 image with at least " 724 "qemu 1.1 compatibility level"); 725 ret = -EINVAL; 726 goto fail; 727 } 728 729 #ifdef DEBUG_ALLOC 730 { 731 BdrvCheckResult result = {0}; 732 qcow2_check_refcounts(bs, &result, 0); 733 } 734 #endif 735 return ret; 736 737 fail: 738 g_free(s->unknown_header_fields); 739 cleanup_unknown_header_ext(bs); 740 qcow2_free_snapshots(bs); 741 qcow2_refcount_close(bs); 742 g_free(s->l1_table); 743 /* else pre-write overlap checks in cache_destroy may crash */ 744 s->l1_table = NULL; 745 if (s->l2_table_cache) { 746 qcow2_cache_destroy(bs, s->l2_table_cache); 747 } 748 g_free(s->cluster_cache); 749 qemu_vfree(s->cluster_data); 750 return ret; 751 } 752 753 static int qcow2_set_key(BlockDriverState *bs, const char *key) 754 { 755 BDRVQcowState *s = bs->opaque; 756 uint8_t keybuf[16]; 757 int len, i; 758 759 memset(keybuf, 0, 16); 760 len = strlen(key); 761 if (len > 16) 762 len = 16; 763 /* XXX: we could compress the chars to 7 bits to increase 764 entropy */ 765 for(i = 0;i < len;i++) { 766 keybuf[i] = key[i]; 767 } 768 s->crypt_method = s->crypt_method_header; 769 770 if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0) 771 return -1; 772 if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0) 773 return -1; 774 #if 0 775 /* test */ 776 { 777 uint8_t in[16]; 778 uint8_t out[16]; 779 uint8_t tmp[16]; 780 for(i=0;i<16;i++) 781 in[i] = i; 782 AES_encrypt(in, tmp, &s->aes_encrypt_key); 783 AES_decrypt(tmp, out, &s->aes_decrypt_key); 784 for(i = 0; i < 16; i++) 785 printf(" %02x", tmp[i]); 786 printf("\n"); 787 for(i = 0; i < 16; i++) 788 printf(" %02x", out[i]); 789 printf("\n"); 790 } 791 #endif 792 return 0; 793 } 794 795 /* We have nothing to do for QCOW2 reopen, stubs just return 796 * success */ 797 static int qcow2_reopen_prepare(BDRVReopenState *state, 798 BlockReopenQueue *queue, Error **errp) 799 { 800 return 0; 801 } 802 803 static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs, 804 int64_t sector_num, int nb_sectors, int *pnum) 805 { 806 BDRVQcowState *s = bs->opaque; 807 uint64_t cluster_offset; 808 int index_in_cluster, ret; 809 int64_t status = 0; 810 811 *pnum = nb_sectors; 812 qemu_co_mutex_lock(&s->lock); 813 ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset); 814 qemu_co_mutex_unlock(&s->lock); 815 if (ret < 0) { 816 return ret; 817 } 818 819 if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED && 820 !s->crypt_method) { 821 index_in_cluster = sector_num & (s->cluster_sectors - 1); 822 cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS); 823 status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset; 824 } 825 if (ret == QCOW2_CLUSTER_ZERO) { 826 status |= BDRV_BLOCK_ZERO; 827 } else if (ret != QCOW2_CLUSTER_UNALLOCATED) { 828 status |= BDRV_BLOCK_DATA; 829 } 830 return status; 831 } 832 833 /* handle reading after the end of the backing file */ 834 int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov, 835 int64_t sector_num, int nb_sectors) 836 { 837 int n1; 838 if ((sector_num + nb_sectors) <= bs->total_sectors) 839 return nb_sectors; 840 if (sector_num >= bs->total_sectors) 841 n1 = 0; 842 else 843 n1 = bs->total_sectors - sector_num; 844 845 qemu_iovec_memset(qiov, 512 * n1, 0, 512 * (nb_sectors - n1)); 846 847 return n1; 848 } 849 850 static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num, 851 int remaining_sectors, QEMUIOVector *qiov) 852 { 853 BDRVQcowState *s = bs->opaque; 854 int index_in_cluster, n1; 855 int ret; 856 int cur_nr_sectors; /* number of sectors in current iteration */ 857 uint64_t cluster_offset = 0; 858 uint64_t bytes_done = 0; 859 QEMUIOVector hd_qiov; 860 uint8_t *cluster_data = NULL; 861 862 qemu_iovec_init(&hd_qiov, qiov->niov); 863 864 qemu_co_mutex_lock(&s->lock); 865 866 while (remaining_sectors != 0) { 867 868 /* prepare next request */ 869 cur_nr_sectors = remaining_sectors; 870 if (s->crypt_method) { 871 cur_nr_sectors = MIN(cur_nr_sectors, 872 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors); 873 } 874 875 ret = qcow2_get_cluster_offset(bs, sector_num << 9, 876 &cur_nr_sectors, &cluster_offset); 877 if (ret < 0) { 878 goto fail; 879 } 880 881 index_in_cluster = sector_num & (s->cluster_sectors - 1); 882 883 qemu_iovec_reset(&hd_qiov); 884 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, 885 cur_nr_sectors * 512); 886 887 switch (ret) { 888 case QCOW2_CLUSTER_UNALLOCATED: 889 890 if (bs->backing_hd) { 891 /* read from the base image */ 892 n1 = qcow2_backing_read1(bs->backing_hd, &hd_qiov, 893 sector_num, cur_nr_sectors); 894 if (n1 > 0) { 895 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 896 qemu_co_mutex_unlock(&s->lock); 897 ret = bdrv_co_readv(bs->backing_hd, sector_num, 898 n1, &hd_qiov); 899 qemu_co_mutex_lock(&s->lock); 900 if (ret < 0) { 901 goto fail; 902 } 903 } 904 } else { 905 /* Note: in this case, no need to wait */ 906 qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors); 907 } 908 break; 909 910 case QCOW2_CLUSTER_ZERO: 911 qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors); 912 break; 913 914 case QCOW2_CLUSTER_COMPRESSED: 915 /* add AIO support for compressed blocks ? */ 916 ret = qcow2_decompress_cluster(bs, cluster_offset); 917 if (ret < 0) { 918 goto fail; 919 } 920 921 qemu_iovec_from_buf(&hd_qiov, 0, 922 s->cluster_cache + index_in_cluster * 512, 923 512 * cur_nr_sectors); 924 break; 925 926 case QCOW2_CLUSTER_NORMAL: 927 if ((cluster_offset & 511) != 0) { 928 ret = -EIO; 929 goto fail; 930 } 931 932 if (s->crypt_method) { 933 /* 934 * For encrypted images, read everything into a temporary 935 * contiguous buffer on which the AES functions can work. 936 */ 937 if (!cluster_data) { 938 cluster_data = 939 qemu_blockalign(bs, QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 940 } 941 942 assert(cur_nr_sectors <= 943 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors); 944 qemu_iovec_reset(&hd_qiov); 945 qemu_iovec_add(&hd_qiov, cluster_data, 946 512 * cur_nr_sectors); 947 } 948 949 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 950 qemu_co_mutex_unlock(&s->lock); 951 ret = bdrv_co_readv(bs->file, 952 (cluster_offset >> 9) + index_in_cluster, 953 cur_nr_sectors, &hd_qiov); 954 qemu_co_mutex_lock(&s->lock); 955 if (ret < 0) { 956 goto fail; 957 } 958 if (s->crypt_method) { 959 qcow2_encrypt_sectors(s, sector_num, cluster_data, 960 cluster_data, cur_nr_sectors, 0, &s->aes_decrypt_key); 961 qemu_iovec_from_buf(qiov, bytes_done, 962 cluster_data, 512 * cur_nr_sectors); 963 } 964 break; 965 966 default: 967 g_assert_not_reached(); 968 ret = -EIO; 969 goto fail; 970 } 971 972 remaining_sectors -= cur_nr_sectors; 973 sector_num += cur_nr_sectors; 974 bytes_done += cur_nr_sectors * 512; 975 } 976 ret = 0; 977 978 fail: 979 qemu_co_mutex_unlock(&s->lock); 980 981 qemu_iovec_destroy(&hd_qiov); 982 qemu_vfree(cluster_data); 983 984 return ret; 985 } 986 987 static coroutine_fn int qcow2_co_writev(BlockDriverState *bs, 988 int64_t sector_num, 989 int remaining_sectors, 990 QEMUIOVector *qiov) 991 { 992 BDRVQcowState *s = bs->opaque; 993 int index_in_cluster; 994 int n_end; 995 int ret; 996 int cur_nr_sectors; /* number of sectors in current iteration */ 997 uint64_t cluster_offset; 998 QEMUIOVector hd_qiov; 999 uint64_t bytes_done = 0; 1000 uint8_t *cluster_data = NULL; 1001 QCowL2Meta *l2meta = NULL; 1002 1003 trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num, 1004 remaining_sectors); 1005 1006 qemu_iovec_init(&hd_qiov, qiov->niov); 1007 1008 s->cluster_cache_offset = -1; /* disable compressed cache */ 1009 1010 qemu_co_mutex_lock(&s->lock); 1011 1012 while (remaining_sectors != 0) { 1013 1014 l2meta = NULL; 1015 1016 trace_qcow2_writev_start_part(qemu_coroutine_self()); 1017 index_in_cluster = sector_num & (s->cluster_sectors - 1); 1018 n_end = index_in_cluster + remaining_sectors; 1019 if (s->crypt_method && 1020 n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) { 1021 n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; 1022 } 1023 1024 ret = qcow2_alloc_cluster_offset(bs, sector_num << 9, 1025 index_in_cluster, n_end, &cur_nr_sectors, &cluster_offset, &l2meta); 1026 if (ret < 0) { 1027 goto fail; 1028 } 1029 1030 assert((cluster_offset & 511) == 0); 1031 1032 qemu_iovec_reset(&hd_qiov); 1033 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, 1034 cur_nr_sectors * 512); 1035 1036 if (s->crypt_method) { 1037 if (!cluster_data) { 1038 cluster_data = qemu_blockalign(bs, QCOW_MAX_CRYPT_CLUSTERS * 1039 s->cluster_size); 1040 } 1041 1042 assert(hd_qiov.size <= 1043 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 1044 qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size); 1045 1046 qcow2_encrypt_sectors(s, sector_num, cluster_data, 1047 cluster_data, cur_nr_sectors, 1, &s->aes_encrypt_key); 1048 1049 qemu_iovec_reset(&hd_qiov); 1050 qemu_iovec_add(&hd_qiov, cluster_data, 1051 cur_nr_sectors * 512); 1052 } 1053 1054 ret = qcow2_pre_write_overlap_check(bs, 0, 1055 cluster_offset + index_in_cluster * BDRV_SECTOR_SIZE, 1056 cur_nr_sectors * BDRV_SECTOR_SIZE); 1057 if (ret < 0) { 1058 goto fail; 1059 } 1060 1061 qemu_co_mutex_unlock(&s->lock); 1062 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 1063 trace_qcow2_writev_data(qemu_coroutine_self(), 1064 (cluster_offset >> 9) + index_in_cluster); 1065 ret = bdrv_co_writev(bs->file, 1066 (cluster_offset >> 9) + index_in_cluster, 1067 cur_nr_sectors, &hd_qiov); 1068 qemu_co_mutex_lock(&s->lock); 1069 if (ret < 0) { 1070 goto fail; 1071 } 1072 1073 while (l2meta != NULL) { 1074 QCowL2Meta *next; 1075 1076 ret = qcow2_alloc_cluster_link_l2(bs, l2meta); 1077 if (ret < 0) { 1078 goto fail; 1079 } 1080 1081 /* Take the request off the list of running requests */ 1082 if (l2meta->nb_clusters != 0) { 1083 QLIST_REMOVE(l2meta, next_in_flight); 1084 } 1085 1086 qemu_co_queue_restart_all(&l2meta->dependent_requests); 1087 1088 next = l2meta->next; 1089 g_free(l2meta); 1090 l2meta = next; 1091 } 1092 1093 remaining_sectors -= cur_nr_sectors; 1094 sector_num += cur_nr_sectors; 1095 bytes_done += cur_nr_sectors * 512; 1096 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors); 1097 } 1098 ret = 0; 1099 1100 fail: 1101 qemu_co_mutex_unlock(&s->lock); 1102 1103 while (l2meta != NULL) { 1104 QCowL2Meta *next; 1105 1106 if (l2meta->nb_clusters != 0) { 1107 QLIST_REMOVE(l2meta, next_in_flight); 1108 } 1109 qemu_co_queue_restart_all(&l2meta->dependent_requests); 1110 1111 next = l2meta->next; 1112 g_free(l2meta); 1113 l2meta = next; 1114 } 1115 1116 qemu_iovec_destroy(&hd_qiov); 1117 qemu_vfree(cluster_data); 1118 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret); 1119 1120 return ret; 1121 } 1122 1123 static void qcow2_close(BlockDriverState *bs) 1124 { 1125 BDRVQcowState *s = bs->opaque; 1126 g_free(s->l1_table); 1127 /* else pre-write overlap checks in cache_destroy may crash */ 1128 s->l1_table = NULL; 1129 1130 qcow2_cache_flush(bs, s->l2_table_cache); 1131 qcow2_cache_flush(bs, s->refcount_block_cache); 1132 1133 qcow2_mark_clean(bs); 1134 1135 qcow2_cache_destroy(bs, s->l2_table_cache); 1136 qcow2_cache_destroy(bs, s->refcount_block_cache); 1137 1138 g_free(s->unknown_header_fields); 1139 cleanup_unknown_header_ext(bs); 1140 1141 g_free(s->cluster_cache); 1142 qemu_vfree(s->cluster_data); 1143 qcow2_refcount_close(bs); 1144 qcow2_free_snapshots(bs); 1145 } 1146 1147 static void qcow2_invalidate_cache(BlockDriverState *bs) 1148 { 1149 BDRVQcowState *s = bs->opaque; 1150 int flags = s->flags; 1151 AES_KEY aes_encrypt_key; 1152 AES_KEY aes_decrypt_key; 1153 uint32_t crypt_method = 0; 1154 QDict *options; 1155 1156 /* 1157 * Backing files are read-only which makes all of their metadata immutable, 1158 * that means we don't have to worry about reopening them here. 1159 */ 1160 1161 if (s->crypt_method) { 1162 crypt_method = s->crypt_method; 1163 memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key)); 1164 memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key)); 1165 } 1166 1167 qcow2_close(bs); 1168 1169 options = qdict_new(); 1170 qdict_put(options, QCOW2_OPT_LAZY_REFCOUNTS, 1171 qbool_from_int(s->use_lazy_refcounts)); 1172 1173 memset(s, 0, sizeof(BDRVQcowState)); 1174 qcow2_open(bs, options, flags, NULL); 1175 1176 QDECREF(options); 1177 1178 if (crypt_method) { 1179 s->crypt_method = crypt_method; 1180 memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key)); 1181 memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key)); 1182 } 1183 } 1184 1185 static size_t header_ext_add(char *buf, uint32_t magic, const void *s, 1186 size_t len, size_t buflen) 1187 { 1188 QCowExtension *ext_backing_fmt = (QCowExtension*) buf; 1189 size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7); 1190 1191 if (buflen < ext_len) { 1192 return -ENOSPC; 1193 } 1194 1195 *ext_backing_fmt = (QCowExtension) { 1196 .magic = cpu_to_be32(magic), 1197 .len = cpu_to_be32(len), 1198 }; 1199 memcpy(buf + sizeof(QCowExtension), s, len); 1200 1201 return ext_len; 1202 } 1203 1204 /* 1205 * Updates the qcow2 header, including the variable length parts of it, i.e. 1206 * the backing file name and all extensions. qcow2 was not designed to allow 1207 * such changes, so if we run out of space (we can only use the first cluster) 1208 * this function may fail. 1209 * 1210 * Returns 0 on success, -errno in error cases. 1211 */ 1212 int qcow2_update_header(BlockDriverState *bs) 1213 { 1214 BDRVQcowState *s = bs->opaque; 1215 QCowHeader *header; 1216 char *buf; 1217 size_t buflen = s->cluster_size; 1218 int ret; 1219 uint64_t total_size; 1220 uint32_t refcount_table_clusters; 1221 size_t header_length; 1222 Qcow2UnknownHeaderExtension *uext; 1223 1224 buf = qemu_blockalign(bs, buflen); 1225 1226 /* Header structure */ 1227 header = (QCowHeader*) buf; 1228 1229 if (buflen < sizeof(*header)) { 1230 ret = -ENOSPC; 1231 goto fail; 1232 } 1233 1234 header_length = sizeof(*header) + s->unknown_header_fields_size; 1235 total_size = bs->total_sectors * BDRV_SECTOR_SIZE; 1236 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3); 1237 1238 *header = (QCowHeader) { 1239 /* Version 2 fields */ 1240 .magic = cpu_to_be32(QCOW_MAGIC), 1241 .version = cpu_to_be32(s->qcow_version), 1242 .backing_file_offset = 0, 1243 .backing_file_size = 0, 1244 .cluster_bits = cpu_to_be32(s->cluster_bits), 1245 .size = cpu_to_be64(total_size), 1246 .crypt_method = cpu_to_be32(s->crypt_method_header), 1247 .l1_size = cpu_to_be32(s->l1_size), 1248 .l1_table_offset = cpu_to_be64(s->l1_table_offset), 1249 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset), 1250 .refcount_table_clusters = cpu_to_be32(refcount_table_clusters), 1251 .nb_snapshots = cpu_to_be32(s->nb_snapshots), 1252 .snapshots_offset = cpu_to_be64(s->snapshots_offset), 1253 1254 /* Version 3 fields */ 1255 .incompatible_features = cpu_to_be64(s->incompatible_features), 1256 .compatible_features = cpu_to_be64(s->compatible_features), 1257 .autoclear_features = cpu_to_be64(s->autoclear_features), 1258 .refcount_order = cpu_to_be32(s->refcount_order), 1259 .header_length = cpu_to_be32(header_length), 1260 }; 1261 1262 /* For older versions, write a shorter header */ 1263 switch (s->qcow_version) { 1264 case 2: 1265 ret = offsetof(QCowHeader, incompatible_features); 1266 break; 1267 case 3: 1268 ret = sizeof(*header); 1269 break; 1270 default: 1271 ret = -EINVAL; 1272 goto fail; 1273 } 1274 1275 buf += ret; 1276 buflen -= ret; 1277 memset(buf, 0, buflen); 1278 1279 /* Preserve any unknown field in the header */ 1280 if (s->unknown_header_fields_size) { 1281 if (buflen < s->unknown_header_fields_size) { 1282 ret = -ENOSPC; 1283 goto fail; 1284 } 1285 1286 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size); 1287 buf += s->unknown_header_fields_size; 1288 buflen -= s->unknown_header_fields_size; 1289 } 1290 1291 /* Backing file format header extension */ 1292 if (*bs->backing_format) { 1293 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT, 1294 bs->backing_format, strlen(bs->backing_format), 1295 buflen); 1296 if (ret < 0) { 1297 goto fail; 1298 } 1299 1300 buf += ret; 1301 buflen -= ret; 1302 } 1303 1304 /* Feature table */ 1305 Qcow2Feature features[] = { 1306 { 1307 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 1308 .bit = QCOW2_INCOMPAT_DIRTY_BITNR, 1309 .name = "dirty bit", 1310 }, 1311 { 1312 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE, 1313 .bit = QCOW2_INCOMPAT_CORRUPT_BITNR, 1314 .name = "corrupt bit", 1315 }, 1316 { 1317 .type = QCOW2_FEAT_TYPE_COMPATIBLE, 1318 .bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR, 1319 .name = "lazy refcounts", 1320 }, 1321 }; 1322 1323 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE, 1324 features, sizeof(features), buflen); 1325 if (ret < 0) { 1326 goto fail; 1327 } 1328 buf += ret; 1329 buflen -= ret; 1330 1331 /* Keep unknown header extensions */ 1332 QLIST_FOREACH(uext, &s->unknown_header_ext, next) { 1333 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen); 1334 if (ret < 0) { 1335 goto fail; 1336 } 1337 1338 buf += ret; 1339 buflen -= ret; 1340 } 1341 1342 /* End of header extensions */ 1343 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen); 1344 if (ret < 0) { 1345 goto fail; 1346 } 1347 1348 buf += ret; 1349 buflen -= ret; 1350 1351 /* Backing file name */ 1352 if (*bs->backing_file) { 1353 size_t backing_file_len = strlen(bs->backing_file); 1354 1355 if (buflen < backing_file_len) { 1356 ret = -ENOSPC; 1357 goto fail; 1358 } 1359 1360 /* Using strncpy is ok here, since buf is not NUL-terminated. */ 1361 strncpy(buf, bs->backing_file, buflen); 1362 1363 header->backing_file_offset = cpu_to_be64(buf - ((char*) header)); 1364 header->backing_file_size = cpu_to_be32(backing_file_len); 1365 } 1366 1367 /* Write the new header */ 1368 ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size); 1369 if (ret < 0) { 1370 goto fail; 1371 } 1372 1373 ret = 0; 1374 fail: 1375 qemu_vfree(header); 1376 return ret; 1377 } 1378 1379 static int qcow2_change_backing_file(BlockDriverState *bs, 1380 const char *backing_file, const char *backing_fmt) 1381 { 1382 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 1383 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 1384 1385 return qcow2_update_header(bs); 1386 } 1387 1388 static int preallocate(BlockDriverState *bs) 1389 { 1390 uint64_t nb_sectors; 1391 uint64_t offset; 1392 uint64_t host_offset = 0; 1393 int num; 1394 int ret; 1395 QCowL2Meta *meta; 1396 1397 nb_sectors = bdrv_getlength(bs) >> 9; 1398 offset = 0; 1399 1400 while (nb_sectors) { 1401 num = MIN(nb_sectors, INT_MAX >> 9); 1402 ret = qcow2_alloc_cluster_offset(bs, offset, 0, num, &num, 1403 &host_offset, &meta); 1404 if (ret < 0) { 1405 return ret; 1406 } 1407 1408 ret = qcow2_alloc_cluster_link_l2(bs, meta); 1409 if (ret < 0) { 1410 qcow2_free_any_clusters(bs, meta->alloc_offset, meta->nb_clusters, 1411 QCOW2_DISCARD_NEVER); 1412 return ret; 1413 } 1414 1415 /* There are no dependent requests, but we need to remove our request 1416 * from the list of in-flight requests */ 1417 if (meta != NULL) { 1418 QLIST_REMOVE(meta, next_in_flight); 1419 } 1420 1421 /* TODO Preallocate data if requested */ 1422 1423 nb_sectors -= num; 1424 offset += num << 9; 1425 } 1426 1427 /* 1428 * It is expected that the image file is large enough to actually contain 1429 * all of the allocated clusters (otherwise we get failing reads after 1430 * EOF). Extend the image to the last allocated sector. 1431 */ 1432 if (host_offset != 0) { 1433 uint8_t buf[512]; 1434 memset(buf, 0, 512); 1435 ret = bdrv_write(bs->file, (host_offset >> 9) + num - 1, buf, 1); 1436 if (ret < 0) { 1437 return ret; 1438 } 1439 } 1440 1441 return 0; 1442 } 1443 1444 static int qcow2_create2(const char *filename, int64_t total_size, 1445 const char *backing_file, const char *backing_format, 1446 int flags, size_t cluster_size, int prealloc, 1447 QEMUOptionParameter *options, int version, 1448 Error **errp) 1449 { 1450 /* Calculate cluster_bits */ 1451 int cluster_bits; 1452 cluster_bits = ffs(cluster_size) - 1; 1453 if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS || 1454 (1 << cluster_bits) != cluster_size) 1455 { 1456 error_setg(errp, "Cluster size must be a power of two between %d and " 1457 "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); 1458 return -EINVAL; 1459 } 1460 1461 /* 1462 * Open the image file and write a minimal qcow2 header. 1463 * 1464 * We keep things simple and start with a zero-sized image. We also 1465 * do without refcount blocks or a L1 table for now. We'll fix the 1466 * inconsistency later. 1467 * 1468 * We do need a refcount table because growing the refcount table means 1469 * allocating two new refcount blocks - the seconds of which would be at 1470 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file 1471 * size for any qcow2 image. 1472 */ 1473 BlockDriverState* bs; 1474 QCowHeader header; 1475 uint8_t* refcount_table; 1476 Error *local_err = NULL; 1477 int ret; 1478 1479 ret = bdrv_create_file(filename, options, &local_err); 1480 if (ret < 0) { 1481 error_propagate(errp, local_err); 1482 return ret; 1483 } 1484 1485 ret = bdrv_file_open(&bs, filename, NULL, BDRV_O_RDWR, &local_err); 1486 if (ret < 0) { 1487 error_propagate(errp, local_err); 1488 return ret; 1489 } 1490 1491 /* Write the header */ 1492 memset(&header, 0, sizeof(header)); 1493 header.magic = cpu_to_be32(QCOW_MAGIC); 1494 header.version = cpu_to_be32(version); 1495 header.cluster_bits = cpu_to_be32(cluster_bits); 1496 header.size = cpu_to_be64(0); 1497 header.l1_table_offset = cpu_to_be64(0); 1498 header.l1_size = cpu_to_be32(0); 1499 header.refcount_table_offset = cpu_to_be64(cluster_size); 1500 header.refcount_table_clusters = cpu_to_be32(1); 1501 header.refcount_order = cpu_to_be32(3 + REFCOUNT_SHIFT); 1502 header.header_length = cpu_to_be32(sizeof(header)); 1503 1504 if (flags & BLOCK_FLAG_ENCRYPT) { 1505 header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES); 1506 } else { 1507 header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); 1508 } 1509 1510 if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) { 1511 header.compatible_features |= 1512 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS); 1513 } 1514 1515 ret = bdrv_pwrite(bs, 0, &header, sizeof(header)); 1516 if (ret < 0) { 1517 error_setg_errno(errp, -ret, "Could not write qcow2 header"); 1518 goto out; 1519 } 1520 1521 /* Write an empty refcount table */ 1522 refcount_table = g_malloc0(cluster_size); 1523 ret = bdrv_pwrite(bs, cluster_size, refcount_table, cluster_size); 1524 g_free(refcount_table); 1525 1526 if (ret < 0) { 1527 error_setg_errno(errp, -ret, "Could not write refcount table"); 1528 goto out; 1529 } 1530 1531 bdrv_close(bs); 1532 1533 /* 1534 * And now open the image and make it consistent first (i.e. increase the 1535 * refcount of the cluster that is occupied by the header and the refcount 1536 * table) 1537 */ 1538 BlockDriver* drv = bdrv_find_format("qcow2"); 1539 assert(drv != NULL); 1540 ret = bdrv_open(bs, filename, NULL, 1541 BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, drv, &local_err); 1542 if (ret < 0) { 1543 error_propagate(errp, local_err); 1544 goto out; 1545 } 1546 1547 ret = qcow2_alloc_clusters(bs, 2 * cluster_size); 1548 if (ret < 0) { 1549 error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 " 1550 "header and refcount table"); 1551 goto out; 1552 1553 } else if (ret != 0) { 1554 error_report("Huh, first cluster in empty image is already in use?"); 1555 abort(); 1556 } 1557 1558 /* Okay, now that we have a valid image, let's give it the right size */ 1559 ret = bdrv_truncate(bs, total_size * BDRV_SECTOR_SIZE); 1560 if (ret < 0) { 1561 error_setg_errno(errp, -ret, "Could not resize image"); 1562 goto out; 1563 } 1564 1565 /* Want a backing file? There you go.*/ 1566 if (backing_file) { 1567 ret = bdrv_change_backing_file(bs, backing_file, backing_format); 1568 if (ret < 0) { 1569 error_setg_errno(errp, -ret, "Could not assign backing file '%s' " 1570 "with format '%s'", backing_file, backing_format); 1571 goto out; 1572 } 1573 } 1574 1575 /* And if we're supposed to preallocate metadata, do that now */ 1576 if (prealloc) { 1577 BDRVQcowState *s = bs->opaque; 1578 qemu_co_mutex_lock(&s->lock); 1579 ret = preallocate(bs); 1580 qemu_co_mutex_unlock(&s->lock); 1581 if (ret < 0) { 1582 error_setg_errno(errp, -ret, "Could not preallocate metadata"); 1583 goto out; 1584 } 1585 } 1586 1587 bdrv_close(bs); 1588 1589 /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */ 1590 ret = bdrv_open(bs, filename, NULL, 1591 BDRV_O_RDWR | BDRV_O_CACHE_WB, drv, &local_err); 1592 if (error_is_set(&local_err)) { 1593 error_propagate(errp, local_err); 1594 goto out; 1595 } 1596 1597 ret = 0; 1598 out: 1599 bdrv_unref(bs); 1600 return ret; 1601 } 1602 1603 static int qcow2_create(const char *filename, QEMUOptionParameter *options, 1604 Error **errp) 1605 { 1606 const char *backing_file = NULL; 1607 const char *backing_fmt = NULL; 1608 uint64_t sectors = 0; 1609 int flags = 0; 1610 size_t cluster_size = DEFAULT_CLUSTER_SIZE; 1611 int prealloc = 0; 1612 int version = 3; 1613 Error *local_err = NULL; 1614 int ret; 1615 1616 /* Read out options */ 1617 while (options && options->name) { 1618 if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 1619 sectors = options->value.n / 512; 1620 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { 1621 backing_file = options->value.s; 1622 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) { 1623 backing_fmt = options->value.s; 1624 } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) { 1625 flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0; 1626 } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { 1627 if (options->value.n) { 1628 cluster_size = options->value.n; 1629 } 1630 } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) { 1631 if (!options->value.s || !strcmp(options->value.s, "off")) { 1632 prealloc = 0; 1633 } else if (!strcmp(options->value.s, "metadata")) { 1634 prealloc = 1; 1635 } else { 1636 error_setg(errp, "Invalid preallocation mode: '%s'", 1637 options->value.s); 1638 return -EINVAL; 1639 } 1640 } else if (!strcmp(options->name, BLOCK_OPT_COMPAT_LEVEL)) { 1641 if (!options->value.s) { 1642 /* keep the default */ 1643 } else if (!strcmp(options->value.s, "0.10")) { 1644 version = 2; 1645 } else if (!strcmp(options->value.s, "1.1")) { 1646 version = 3; 1647 } else { 1648 error_setg(errp, "Invalid compatibility level: '%s'", 1649 options->value.s); 1650 return -EINVAL; 1651 } 1652 } else if (!strcmp(options->name, BLOCK_OPT_LAZY_REFCOUNTS)) { 1653 flags |= options->value.n ? BLOCK_FLAG_LAZY_REFCOUNTS : 0; 1654 } 1655 options++; 1656 } 1657 1658 if (backing_file && prealloc) { 1659 error_setg(errp, "Backing file and preallocation cannot be used at " 1660 "the same time"); 1661 return -EINVAL; 1662 } 1663 1664 if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) { 1665 error_setg(errp, "Lazy refcounts only supported with compatibility " 1666 "level 1.1 and above (use compat=1.1 or greater)"); 1667 return -EINVAL; 1668 } 1669 1670 ret = qcow2_create2(filename, sectors, backing_file, backing_fmt, flags, 1671 cluster_size, prealloc, options, version, &local_err); 1672 if (error_is_set(&local_err)) { 1673 error_propagate(errp, local_err); 1674 } 1675 return ret; 1676 } 1677 1678 static int qcow2_make_empty(BlockDriverState *bs) 1679 { 1680 #if 0 1681 /* XXX: not correct */ 1682 BDRVQcowState *s = bs->opaque; 1683 uint32_t l1_length = s->l1_size * sizeof(uint64_t); 1684 int ret; 1685 1686 memset(s->l1_table, 0, l1_length); 1687 if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0) 1688 return -1; 1689 ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length); 1690 if (ret < 0) 1691 return ret; 1692 1693 l2_cache_reset(bs); 1694 #endif 1695 return 0; 1696 } 1697 1698 static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs, 1699 int64_t sector_num, int nb_sectors) 1700 { 1701 int ret; 1702 BDRVQcowState *s = bs->opaque; 1703 1704 /* Emulate misaligned zero writes */ 1705 if (sector_num % s->cluster_sectors || nb_sectors % s->cluster_sectors) { 1706 return -ENOTSUP; 1707 } 1708 1709 /* Whatever is left can use real zero clusters */ 1710 qemu_co_mutex_lock(&s->lock); 1711 ret = qcow2_zero_clusters(bs, sector_num << BDRV_SECTOR_BITS, 1712 nb_sectors); 1713 qemu_co_mutex_unlock(&s->lock); 1714 1715 return ret; 1716 } 1717 1718 static coroutine_fn int qcow2_co_discard(BlockDriverState *bs, 1719 int64_t sector_num, int nb_sectors) 1720 { 1721 int ret; 1722 BDRVQcowState *s = bs->opaque; 1723 1724 qemu_co_mutex_lock(&s->lock); 1725 ret = qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS, 1726 nb_sectors, QCOW2_DISCARD_REQUEST); 1727 qemu_co_mutex_unlock(&s->lock); 1728 return ret; 1729 } 1730 1731 static int qcow2_truncate(BlockDriverState *bs, int64_t offset) 1732 { 1733 BDRVQcowState *s = bs->opaque; 1734 int64_t new_l1_size; 1735 int ret; 1736 1737 if (offset & 511) { 1738 error_report("The new size must be a multiple of 512"); 1739 return -EINVAL; 1740 } 1741 1742 /* cannot proceed if image has snapshots */ 1743 if (s->nb_snapshots) { 1744 error_report("Can't resize an image which has snapshots"); 1745 return -ENOTSUP; 1746 } 1747 1748 /* shrinking is currently not supported */ 1749 if (offset < bs->total_sectors * 512) { 1750 error_report("qcow2 doesn't support shrinking images yet"); 1751 return -ENOTSUP; 1752 } 1753 1754 new_l1_size = size_to_l1(s, offset); 1755 ret = qcow2_grow_l1_table(bs, new_l1_size, true); 1756 if (ret < 0) { 1757 return ret; 1758 } 1759 1760 /* write updated header.size */ 1761 offset = cpu_to_be64(offset); 1762 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), 1763 &offset, sizeof(uint64_t)); 1764 if (ret < 0) { 1765 return ret; 1766 } 1767 1768 s->l1_vm_state_index = new_l1_size; 1769 return 0; 1770 } 1771 1772 /* XXX: put compressed sectors first, then all the cluster aligned 1773 tables to avoid losing bytes in alignment */ 1774 static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num, 1775 const uint8_t *buf, int nb_sectors) 1776 { 1777 BDRVQcowState *s = bs->opaque; 1778 z_stream strm; 1779 int ret, out_len; 1780 uint8_t *out_buf; 1781 uint64_t cluster_offset; 1782 1783 if (nb_sectors == 0) { 1784 /* align end of file to a sector boundary to ease reading with 1785 sector based I/Os */ 1786 cluster_offset = bdrv_getlength(bs->file); 1787 cluster_offset = (cluster_offset + 511) & ~511; 1788 bdrv_truncate(bs->file, cluster_offset); 1789 return 0; 1790 } 1791 1792 if (nb_sectors != s->cluster_sectors) { 1793 ret = -EINVAL; 1794 1795 /* Zero-pad last write if image size is not cluster aligned */ 1796 if (sector_num + nb_sectors == bs->total_sectors && 1797 nb_sectors < s->cluster_sectors) { 1798 uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size); 1799 memset(pad_buf, 0, s->cluster_size); 1800 memcpy(pad_buf, buf, nb_sectors * BDRV_SECTOR_SIZE); 1801 ret = qcow2_write_compressed(bs, sector_num, 1802 pad_buf, s->cluster_sectors); 1803 qemu_vfree(pad_buf); 1804 } 1805 return ret; 1806 } 1807 1808 out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128); 1809 1810 /* best compression, small window, no zlib header */ 1811 memset(&strm, 0, sizeof(strm)); 1812 ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, 1813 Z_DEFLATED, -12, 1814 9, Z_DEFAULT_STRATEGY); 1815 if (ret != 0) { 1816 ret = -EINVAL; 1817 goto fail; 1818 } 1819 1820 strm.avail_in = s->cluster_size; 1821 strm.next_in = (uint8_t *)buf; 1822 strm.avail_out = s->cluster_size; 1823 strm.next_out = out_buf; 1824 1825 ret = deflate(&strm, Z_FINISH); 1826 if (ret != Z_STREAM_END && ret != Z_OK) { 1827 deflateEnd(&strm); 1828 ret = -EINVAL; 1829 goto fail; 1830 } 1831 out_len = strm.next_out - out_buf; 1832 1833 deflateEnd(&strm); 1834 1835 if (ret != Z_STREAM_END || out_len >= s->cluster_size) { 1836 /* could not compress: write normal cluster */ 1837 ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors); 1838 if (ret < 0) { 1839 goto fail; 1840 } 1841 } else { 1842 cluster_offset = qcow2_alloc_compressed_cluster_offset(bs, 1843 sector_num << 9, out_len); 1844 if (!cluster_offset) { 1845 ret = -EIO; 1846 goto fail; 1847 } 1848 cluster_offset &= s->cluster_offset_mask; 1849 1850 ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len); 1851 if (ret < 0) { 1852 goto fail; 1853 } 1854 1855 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); 1856 ret = bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len); 1857 if (ret < 0) { 1858 goto fail; 1859 } 1860 } 1861 1862 ret = 0; 1863 fail: 1864 g_free(out_buf); 1865 return ret; 1866 } 1867 1868 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs) 1869 { 1870 BDRVQcowState *s = bs->opaque; 1871 int ret; 1872 1873 qemu_co_mutex_lock(&s->lock); 1874 ret = qcow2_cache_flush(bs, s->l2_table_cache); 1875 if (ret < 0) { 1876 qemu_co_mutex_unlock(&s->lock); 1877 return ret; 1878 } 1879 1880 if (qcow2_need_accurate_refcounts(s)) { 1881 ret = qcow2_cache_flush(bs, s->refcount_block_cache); 1882 if (ret < 0) { 1883 qemu_co_mutex_unlock(&s->lock); 1884 return ret; 1885 } 1886 } 1887 qemu_co_mutex_unlock(&s->lock); 1888 1889 return 0; 1890 } 1891 1892 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 1893 { 1894 BDRVQcowState *s = bs->opaque; 1895 bdi->cluster_size = s->cluster_size; 1896 bdi->vm_state_offset = qcow2_vm_state_offset(s); 1897 return 0; 1898 } 1899 1900 static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs) 1901 { 1902 BDRVQcowState *s = bs->opaque; 1903 ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1); 1904 1905 *spec_info = (ImageInfoSpecific){ 1906 .kind = IMAGE_INFO_SPECIFIC_KIND_QCOW2, 1907 { 1908 .qcow2 = g_new(ImageInfoSpecificQCow2, 1), 1909 }, 1910 }; 1911 if (s->qcow_version == 2) { 1912 *spec_info->qcow2 = (ImageInfoSpecificQCow2){ 1913 .compat = g_strdup("0.10"), 1914 }; 1915 } else if (s->qcow_version == 3) { 1916 *spec_info->qcow2 = (ImageInfoSpecificQCow2){ 1917 .compat = g_strdup("1.1"), 1918 .lazy_refcounts = s->compatible_features & 1919 QCOW2_COMPAT_LAZY_REFCOUNTS, 1920 .has_lazy_refcounts = true, 1921 }; 1922 } 1923 1924 return spec_info; 1925 } 1926 1927 #if 0 1928 static void dump_refcounts(BlockDriverState *bs) 1929 { 1930 BDRVQcowState *s = bs->opaque; 1931 int64_t nb_clusters, k, k1, size; 1932 int refcount; 1933 1934 size = bdrv_getlength(bs->file); 1935 nb_clusters = size_to_clusters(s, size); 1936 for(k = 0; k < nb_clusters;) { 1937 k1 = k; 1938 refcount = get_refcount(bs, k); 1939 k++; 1940 while (k < nb_clusters && get_refcount(bs, k) == refcount) 1941 k++; 1942 printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount, 1943 k - k1); 1944 } 1945 } 1946 #endif 1947 1948 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, 1949 int64_t pos) 1950 { 1951 BDRVQcowState *s = bs->opaque; 1952 int64_t total_sectors = bs->total_sectors; 1953 int growable = bs->growable; 1954 bool zero_beyond_eof = bs->zero_beyond_eof; 1955 int ret; 1956 1957 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); 1958 bs->growable = 1; 1959 bs->zero_beyond_eof = false; 1960 ret = bdrv_pwritev(bs, qcow2_vm_state_offset(s) + pos, qiov); 1961 bs->growable = growable; 1962 bs->zero_beyond_eof = zero_beyond_eof; 1963 1964 /* bdrv_co_do_writev will have increased the total_sectors value to include 1965 * the VM state - the VM state is however not an actual part of the block 1966 * device, therefore, we need to restore the old value. */ 1967 bs->total_sectors = total_sectors; 1968 1969 return ret; 1970 } 1971 1972 static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf, 1973 int64_t pos, int size) 1974 { 1975 BDRVQcowState *s = bs->opaque; 1976 int growable = bs->growable; 1977 bool zero_beyond_eof = bs->zero_beyond_eof; 1978 int ret; 1979 1980 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); 1981 bs->growable = 1; 1982 bs->zero_beyond_eof = false; 1983 ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size); 1984 bs->growable = growable; 1985 bs->zero_beyond_eof = zero_beyond_eof; 1986 1987 return ret; 1988 } 1989 1990 /* 1991 * Downgrades an image's version. To achieve this, any incompatible features 1992 * have to be removed. 1993 */ 1994 static int qcow2_downgrade(BlockDriverState *bs, int target_version) 1995 { 1996 BDRVQcowState *s = bs->opaque; 1997 int current_version = s->qcow_version; 1998 int ret; 1999 2000 if (target_version == current_version) { 2001 return 0; 2002 } else if (target_version > current_version) { 2003 return -EINVAL; 2004 } else if (target_version != 2) { 2005 return -EINVAL; 2006 } 2007 2008 if (s->refcount_order != 4) { 2009 /* we would have to convert the image to a refcount_order == 4 image 2010 * here; however, since qemu (at the time of writing this) does not 2011 * support anything different than 4 anyway, there is no point in doing 2012 * so right now; however, we should error out (if qemu supports this in 2013 * the future and this code has not been adapted) */ 2014 error_report("qcow2_downgrade: Image refcount orders other than 4 are " 2015 "currently not supported."); 2016 return -ENOTSUP; 2017 } 2018 2019 /* clear incompatible features */ 2020 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { 2021 ret = qcow2_mark_clean(bs); 2022 if (ret < 0) { 2023 return ret; 2024 } 2025 } 2026 2027 /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in 2028 * the first place; if that happens nonetheless, returning -ENOTSUP is the 2029 * best thing to do anyway */ 2030 2031 if (s->incompatible_features) { 2032 return -ENOTSUP; 2033 } 2034 2035 /* since we can ignore compatible features, we can set them to 0 as well */ 2036 s->compatible_features = 0; 2037 /* if lazy refcounts have been used, they have already been fixed through 2038 * clearing the dirty flag */ 2039 2040 /* clearing autoclear features is trivial */ 2041 s->autoclear_features = 0; 2042 2043 ret = qcow2_expand_zero_clusters(bs); 2044 if (ret < 0) { 2045 return ret; 2046 } 2047 2048 s->qcow_version = target_version; 2049 ret = qcow2_update_header(bs); 2050 if (ret < 0) { 2051 s->qcow_version = current_version; 2052 return ret; 2053 } 2054 return 0; 2055 } 2056 2057 static int qcow2_amend_options(BlockDriverState *bs, 2058 QEMUOptionParameter *options) 2059 { 2060 BDRVQcowState *s = bs->opaque; 2061 int old_version = s->qcow_version, new_version = old_version; 2062 uint64_t new_size = 0; 2063 const char *backing_file = NULL, *backing_format = NULL; 2064 bool lazy_refcounts = s->use_lazy_refcounts; 2065 int ret; 2066 int i; 2067 2068 for (i = 0; options[i].name; i++) 2069 { 2070 if (!options[i].assigned) { 2071 /* only change explicitly defined options */ 2072 continue; 2073 } 2074 2075 if (!strcmp(options[i].name, "compat")) { 2076 if (!options[i].value.s) { 2077 /* preserve default */ 2078 } else if (!strcmp(options[i].value.s, "0.10")) { 2079 new_version = 2; 2080 } else if (!strcmp(options[i].value.s, "1.1")) { 2081 new_version = 3; 2082 } else { 2083 fprintf(stderr, "Unknown compatibility level %s.\n", 2084 options[i].value.s); 2085 return -EINVAL; 2086 } 2087 } else if (!strcmp(options[i].name, "preallocation")) { 2088 fprintf(stderr, "Cannot change preallocation mode.\n"); 2089 return -ENOTSUP; 2090 } else if (!strcmp(options[i].name, "size")) { 2091 new_size = options[i].value.n; 2092 } else if (!strcmp(options[i].name, "backing_file")) { 2093 backing_file = options[i].value.s; 2094 } else if (!strcmp(options[i].name, "backing_fmt")) { 2095 backing_format = options[i].value.s; 2096 } else if (!strcmp(options[i].name, "encryption")) { 2097 if ((options[i].value.n != !!s->crypt_method)) { 2098 fprintf(stderr, "Changing the encryption flag is not " 2099 "supported.\n"); 2100 return -ENOTSUP; 2101 } 2102 } else if (!strcmp(options[i].name, "cluster_size")) { 2103 if (options[i].value.n != s->cluster_size) { 2104 fprintf(stderr, "Changing the cluster size is not " 2105 "supported.\n"); 2106 return -ENOTSUP; 2107 } 2108 } else if (!strcmp(options[i].name, "lazy_refcounts")) { 2109 lazy_refcounts = options[i].value.n; 2110 } else { 2111 /* if this assertion fails, this probably means a new option was 2112 * added without having it covered here */ 2113 assert(false); 2114 } 2115 } 2116 2117 if (new_version != old_version) { 2118 if (new_version > old_version) { 2119 /* Upgrade */ 2120 s->qcow_version = new_version; 2121 ret = qcow2_update_header(bs); 2122 if (ret < 0) { 2123 s->qcow_version = old_version; 2124 return ret; 2125 } 2126 } else { 2127 ret = qcow2_downgrade(bs, new_version); 2128 if (ret < 0) { 2129 return ret; 2130 } 2131 } 2132 } 2133 2134 if (backing_file || backing_format) { 2135 ret = qcow2_change_backing_file(bs, backing_file ?: bs->backing_file, 2136 backing_format ?: bs->backing_format); 2137 if (ret < 0) { 2138 return ret; 2139 } 2140 } 2141 2142 if (s->use_lazy_refcounts != lazy_refcounts) { 2143 if (lazy_refcounts) { 2144 if (s->qcow_version < 3) { 2145 fprintf(stderr, "Lazy refcounts only supported with compatibility " 2146 "level 1.1 and above (use compat=1.1 or greater)\n"); 2147 return -EINVAL; 2148 } 2149 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 2150 ret = qcow2_update_header(bs); 2151 if (ret < 0) { 2152 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 2153 return ret; 2154 } 2155 s->use_lazy_refcounts = true; 2156 } else { 2157 /* make image clean first */ 2158 ret = qcow2_mark_clean(bs); 2159 if (ret < 0) { 2160 return ret; 2161 } 2162 /* now disallow lazy refcounts */ 2163 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; 2164 ret = qcow2_update_header(bs); 2165 if (ret < 0) { 2166 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; 2167 return ret; 2168 } 2169 s->use_lazy_refcounts = false; 2170 } 2171 } 2172 2173 if (new_size) { 2174 ret = bdrv_truncate(bs, new_size); 2175 if (ret < 0) { 2176 return ret; 2177 } 2178 } 2179 2180 return 0; 2181 } 2182 2183 static QEMUOptionParameter qcow2_create_options[] = { 2184 { 2185 .name = BLOCK_OPT_SIZE, 2186 .type = OPT_SIZE, 2187 .help = "Virtual disk size" 2188 }, 2189 { 2190 .name = BLOCK_OPT_COMPAT_LEVEL, 2191 .type = OPT_STRING, 2192 .help = "Compatibility level (0.10 or 1.1)" 2193 }, 2194 { 2195 .name = BLOCK_OPT_BACKING_FILE, 2196 .type = OPT_STRING, 2197 .help = "File name of a base image" 2198 }, 2199 { 2200 .name = BLOCK_OPT_BACKING_FMT, 2201 .type = OPT_STRING, 2202 .help = "Image format of the base image" 2203 }, 2204 { 2205 .name = BLOCK_OPT_ENCRYPT, 2206 .type = OPT_FLAG, 2207 .help = "Encrypt the image" 2208 }, 2209 { 2210 .name = BLOCK_OPT_CLUSTER_SIZE, 2211 .type = OPT_SIZE, 2212 .help = "qcow2 cluster size", 2213 .value = { .n = DEFAULT_CLUSTER_SIZE }, 2214 }, 2215 { 2216 .name = BLOCK_OPT_PREALLOC, 2217 .type = OPT_STRING, 2218 .help = "Preallocation mode (allowed values: off, metadata)" 2219 }, 2220 { 2221 .name = BLOCK_OPT_LAZY_REFCOUNTS, 2222 .type = OPT_FLAG, 2223 .help = "Postpone refcount updates", 2224 }, 2225 { NULL } 2226 }; 2227 2228 static BlockDriver bdrv_qcow2 = { 2229 .format_name = "qcow2", 2230 .instance_size = sizeof(BDRVQcowState), 2231 .bdrv_probe = qcow2_probe, 2232 .bdrv_open = qcow2_open, 2233 .bdrv_close = qcow2_close, 2234 .bdrv_reopen_prepare = qcow2_reopen_prepare, 2235 .bdrv_create = qcow2_create, 2236 .bdrv_has_zero_init = bdrv_has_zero_init_1, 2237 .bdrv_co_get_block_status = qcow2_co_get_block_status, 2238 .bdrv_set_key = qcow2_set_key, 2239 .bdrv_make_empty = qcow2_make_empty, 2240 2241 .bdrv_co_readv = qcow2_co_readv, 2242 .bdrv_co_writev = qcow2_co_writev, 2243 .bdrv_co_flush_to_os = qcow2_co_flush_to_os, 2244 2245 .bdrv_co_write_zeroes = qcow2_co_write_zeroes, 2246 .bdrv_co_discard = qcow2_co_discard, 2247 .bdrv_truncate = qcow2_truncate, 2248 .bdrv_write_compressed = qcow2_write_compressed, 2249 2250 .bdrv_snapshot_create = qcow2_snapshot_create, 2251 .bdrv_snapshot_goto = qcow2_snapshot_goto, 2252 .bdrv_snapshot_delete = qcow2_snapshot_delete, 2253 .bdrv_snapshot_list = qcow2_snapshot_list, 2254 .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp, 2255 .bdrv_get_info = qcow2_get_info, 2256 .bdrv_get_specific_info = qcow2_get_specific_info, 2257 2258 .bdrv_save_vmstate = qcow2_save_vmstate, 2259 .bdrv_load_vmstate = qcow2_load_vmstate, 2260 2261 .bdrv_change_backing_file = qcow2_change_backing_file, 2262 2263 .bdrv_invalidate_cache = qcow2_invalidate_cache, 2264 2265 .create_options = qcow2_create_options, 2266 .bdrv_check = qcow2_check, 2267 .bdrv_amend_options = qcow2_amend_options, 2268 }; 2269 2270 static void bdrv_qcow2_init(void) 2271 { 2272 bdrv_register(&bdrv_qcow2); 2273 } 2274 2275 block_init(bdrv_qcow2_init); 2276