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_int.h" 26 #include "module.h" 27 #include <zlib.h> 28 #include "aes.h" 29 #include "block/qcow2.h" 30 #include "qemu-error.h" 31 #include "qerror.h" 32 #include "trace.h" 33 34 /* 35 Differences with QCOW: 36 37 - Support for multiple incremental snapshots. 38 - Memory management by reference counts. 39 - Clusters which have a reference count of one have the bit 40 QCOW_OFLAG_COPIED to optimize write performance. 41 - Size of compressed clusters is stored in sectors to reduce bit usage 42 in the cluster offsets. 43 - Support for storing additional data (such as the VM state) in the 44 snapshots. 45 - If a backing store is used, the cluster size is not constrained 46 (could be backported to QCOW). 47 - L2 tables have always a size of one cluster. 48 */ 49 50 51 typedef struct { 52 uint32_t magic; 53 uint32_t len; 54 } QCowExtension; 55 #define QCOW2_EXT_MAGIC_END 0 56 #define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA 57 #define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857 58 59 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename) 60 { 61 const QCowHeader *cow_header = (const void *)buf; 62 63 if (buf_size >= sizeof(QCowHeader) && 64 be32_to_cpu(cow_header->magic) == QCOW_MAGIC && 65 be32_to_cpu(cow_header->version) >= 2) 66 return 100; 67 else 68 return 0; 69 } 70 71 72 /* 73 * read qcow2 extension and fill bs 74 * start reading from start_offset 75 * finish reading upon magic of value 0 or when end_offset reached 76 * unknown magic is skipped (future extension this version knows nothing about) 77 * return 0 upon success, non-0 otherwise 78 */ 79 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, 80 uint64_t end_offset, void **p_feature_table) 81 { 82 BDRVQcowState *s = bs->opaque; 83 QCowExtension ext; 84 uint64_t offset; 85 int ret; 86 87 #ifdef DEBUG_EXT 88 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset); 89 #endif 90 offset = start_offset; 91 while (offset < end_offset) { 92 93 #ifdef DEBUG_EXT 94 /* Sanity check */ 95 if (offset > s->cluster_size) 96 printf("qcow2_read_extension: suspicious offset %lu\n", offset); 97 98 printf("attempting to read extended header in offset %lu\n", offset); 99 #endif 100 101 if (bdrv_pread(bs->file, offset, &ext, sizeof(ext)) != sizeof(ext)) { 102 fprintf(stderr, "qcow2_read_extension: ERROR: " 103 "pread fail from offset %" PRIu64 "\n", 104 offset); 105 return 1; 106 } 107 be32_to_cpus(&ext.magic); 108 be32_to_cpus(&ext.len); 109 offset += sizeof(ext); 110 #ifdef DEBUG_EXT 111 printf("ext.magic = 0x%x\n", ext.magic); 112 #endif 113 if (ext.len > end_offset - offset) { 114 error_report("Header extension too large"); 115 return -EINVAL; 116 } 117 118 switch (ext.magic) { 119 case QCOW2_EXT_MAGIC_END: 120 return 0; 121 122 case QCOW2_EXT_MAGIC_BACKING_FORMAT: 123 if (ext.len >= sizeof(bs->backing_format)) { 124 fprintf(stderr, "ERROR: ext_backing_format: len=%u too large" 125 " (>=%zu)\n", 126 ext.len, sizeof(bs->backing_format)); 127 return 2; 128 } 129 if (bdrv_pread(bs->file, offset , bs->backing_format, 130 ext.len) != ext.len) 131 return 3; 132 bs->backing_format[ext.len] = '\0'; 133 #ifdef DEBUG_EXT 134 printf("Qcow2: Got format extension %s\n", bs->backing_format); 135 #endif 136 break; 137 138 case QCOW2_EXT_MAGIC_FEATURE_TABLE: 139 if (p_feature_table != NULL) { 140 void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature)); 141 ret = bdrv_pread(bs->file, offset , feature_table, ext.len); 142 if (ret < 0) { 143 return ret; 144 } 145 146 *p_feature_table = feature_table; 147 } 148 break; 149 150 default: 151 /* unknown magic - save it in case we need to rewrite the header */ 152 { 153 Qcow2UnknownHeaderExtension *uext; 154 155 uext = g_malloc0(sizeof(*uext) + ext.len); 156 uext->magic = ext.magic; 157 uext->len = ext.len; 158 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next); 159 160 ret = bdrv_pread(bs->file, offset , uext->data, uext->len); 161 if (ret < 0) { 162 return ret; 163 } 164 } 165 break; 166 } 167 168 offset += ((ext.len + 7) & ~7); 169 } 170 171 return 0; 172 } 173 174 static void cleanup_unknown_header_ext(BlockDriverState *bs) 175 { 176 BDRVQcowState *s = bs->opaque; 177 Qcow2UnknownHeaderExtension *uext, *next; 178 179 QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) { 180 QLIST_REMOVE(uext, next); 181 g_free(uext); 182 } 183 } 184 185 static void GCC_FMT_ATTR(2, 3) report_unsupported(BlockDriverState *bs, 186 const char *fmt, ...) 187 { 188 char msg[64]; 189 va_list ap; 190 191 va_start(ap, fmt); 192 vsnprintf(msg, sizeof(msg), fmt, ap); 193 va_end(ap); 194 195 qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, 196 bs->device_name, "qcow2", msg); 197 } 198 199 static void report_unsupported_feature(BlockDriverState *bs, 200 Qcow2Feature *table, uint64_t mask) 201 { 202 while (table && table->name[0] != '\0') { 203 if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) { 204 if (mask & (1 << table->bit)) { 205 report_unsupported(bs, "%.46s",table->name); 206 mask &= ~(1 << table->bit); 207 } 208 } 209 table++; 210 } 211 212 if (mask) { 213 report_unsupported(bs, "Unknown incompatible feature: %" PRIx64, mask); 214 } 215 } 216 217 static int qcow2_open(BlockDriverState *bs, int flags) 218 { 219 BDRVQcowState *s = bs->opaque; 220 int len, i, ret = 0; 221 QCowHeader header; 222 uint64_t ext_end; 223 bool writethrough; 224 225 ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); 226 if (ret < 0) { 227 goto fail; 228 } 229 be32_to_cpus(&header.magic); 230 be32_to_cpus(&header.version); 231 be64_to_cpus(&header.backing_file_offset); 232 be32_to_cpus(&header.backing_file_size); 233 be64_to_cpus(&header.size); 234 be32_to_cpus(&header.cluster_bits); 235 be32_to_cpus(&header.crypt_method); 236 be64_to_cpus(&header.l1_table_offset); 237 be32_to_cpus(&header.l1_size); 238 be64_to_cpus(&header.refcount_table_offset); 239 be32_to_cpus(&header.refcount_table_clusters); 240 be64_to_cpus(&header.snapshots_offset); 241 be32_to_cpus(&header.nb_snapshots); 242 243 if (header.magic != QCOW_MAGIC) { 244 ret = -EINVAL; 245 goto fail; 246 } 247 if (header.version < 2 || header.version > 3) { 248 report_unsupported(bs, "QCOW version %d", header.version); 249 ret = -ENOTSUP; 250 goto fail; 251 } 252 253 s->qcow_version = header.version; 254 255 /* Initialise version 3 header fields */ 256 if (header.version == 2) { 257 header.incompatible_features = 0; 258 header.compatible_features = 0; 259 header.autoclear_features = 0; 260 header.refcount_order = 4; 261 header.header_length = 72; 262 } else { 263 be64_to_cpus(&header.incompatible_features); 264 be64_to_cpus(&header.compatible_features); 265 be64_to_cpus(&header.autoclear_features); 266 be32_to_cpus(&header.refcount_order); 267 be32_to_cpus(&header.header_length); 268 } 269 270 if (header.header_length > sizeof(header)) { 271 s->unknown_header_fields_size = header.header_length - sizeof(header); 272 s->unknown_header_fields = g_malloc(s->unknown_header_fields_size); 273 ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields, 274 s->unknown_header_fields_size); 275 if (ret < 0) { 276 goto fail; 277 } 278 } 279 280 if (header.backing_file_offset) { 281 ext_end = header.backing_file_offset; 282 } else { 283 ext_end = 1 << header.cluster_bits; 284 } 285 286 /* Handle feature bits */ 287 s->incompatible_features = header.incompatible_features; 288 s->compatible_features = header.compatible_features; 289 s->autoclear_features = header.autoclear_features; 290 291 if (s->incompatible_features != 0) { 292 void *feature_table = NULL; 293 qcow2_read_extensions(bs, header.header_length, ext_end, 294 &feature_table); 295 report_unsupported_feature(bs, feature_table, 296 s->incompatible_features); 297 ret = -ENOTSUP; 298 goto fail; 299 } 300 301 if (!bs->read_only && s->autoclear_features != 0) { 302 s->autoclear_features = 0; 303 qcow2_update_header(bs); 304 } 305 306 /* Check support for various header values */ 307 if (header.refcount_order != 4) { 308 report_unsupported(bs, "%d bit reference counts", 309 1 << header.refcount_order); 310 ret = -ENOTSUP; 311 goto fail; 312 } 313 314 if (header.cluster_bits < MIN_CLUSTER_BITS || 315 header.cluster_bits > MAX_CLUSTER_BITS) { 316 ret = -EINVAL; 317 goto fail; 318 } 319 if (header.crypt_method > QCOW_CRYPT_AES) { 320 ret = -EINVAL; 321 goto fail; 322 } 323 s->crypt_method_header = header.crypt_method; 324 if (s->crypt_method_header) { 325 bs->encrypted = 1; 326 } 327 s->cluster_bits = header.cluster_bits; 328 s->cluster_size = 1 << s->cluster_bits; 329 s->cluster_sectors = 1 << (s->cluster_bits - 9); 330 s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */ 331 s->l2_size = 1 << s->l2_bits; 332 bs->total_sectors = header.size / 512; 333 s->csize_shift = (62 - (s->cluster_bits - 8)); 334 s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; 335 s->cluster_offset_mask = (1LL << s->csize_shift) - 1; 336 s->refcount_table_offset = header.refcount_table_offset; 337 s->refcount_table_size = 338 header.refcount_table_clusters << (s->cluster_bits - 3); 339 340 s->snapshots_offset = header.snapshots_offset; 341 s->nb_snapshots = header.nb_snapshots; 342 343 /* read the level 1 table */ 344 s->l1_size = header.l1_size; 345 s->l1_vm_state_index = size_to_l1(s, header.size); 346 /* the L1 table must contain at least enough entries to put 347 header.size bytes */ 348 if (s->l1_size < s->l1_vm_state_index) { 349 ret = -EINVAL; 350 goto fail; 351 } 352 s->l1_table_offset = header.l1_table_offset; 353 if (s->l1_size > 0) { 354 s->l1_table = g_malloc0( 355 align_offset(s->l1_size * sizeof(uint64_t), 512)); 356 ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, 357 s->l1_size * sizeof(uint64_t)); 358 if (ret < 0) { 359 goto fail; 360 } 361 for(i = 0;i < s->l1_size; i++) { 362 be64_to_cpus(&s->l1_table[i]); 363 } 364 } 365 366 /* alloc L2 table/refcount block cache */ 367 writethrough = ((flags & BDRV_O_CACHE_WB) == 0); 368 s->l2_table_cache = qcow2_cache_create(bs, L2_CACHE_SIZE, writethrough); 369 s->refcount_block_cache = qcow2_cache_create(bs, REFCOUNT_CACHE_SIZE, 370 writethrough); 371 372 s->cluster_cache = g_malloc(s->cluster_size); 373 /* one more sector for decompressed data alignment */ 374 s->cluster_data = qemu_blockalign(bs, QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size 375 + 512); 376 s->cluster_cache_offset = -1; 377 s->flags = flags; 378 379 ret = qcow2_refcount_init(bs); 380 if (ret != 0) { 381 goto fail; 382 } 383 384 QLIST_INIT(&s->cluster_allocs); 385 386 /* read qcow2 extensions */ 387 if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL)) { 388 ret = -EINVAL; 389 goto fail; 390 } 391 392 /* read the backing file name */ 393 if (header.backing_file_offset != 0) { 394 len = header.backing_file_size; 395 if (len > 1023) { 396 len = 1023; 397 } 398 ret = bdrv_pread(bs->file, header.backing_file_offset, 399 bs->backing_file, len); 400 if (ret < 0) { 401 goto fail; 402 } 403 bs->backing_file[len] = '\0'; 404 } 405 406 ret = qcow2_read_snapshots(bs); 407 if (ret < 0) { 408 goto fail; 409 } 410 411 /* Initialise locks */ 412 qemu_co_mutex_init(&s->lock); 413 414 #ifdef DEBUG_ALLOC 415 { 416 BdrvCheckResult result = {0}; 417 qcow2_check_refcounts(bs, &result); 418 } 419 #endif 420 return ret; 421 422 fail: 423 g_free(s->unknown_header_fields); 424 cleanup_unknown_header_ext(bs); 425 qcow2_free_snapshots(bs); 426 qcow2_refcount_close(bs); 427 g_free(s->l1_table); 428 if (s->l2_table_cache) { 429 qcow2_cache_destroy(bs, s->l2_table_cache); 430 } 431 g_free(s->cluster_cache); 432 qemu_vfree(s->cluster_data); 433 return ret; 434 } 435 436 static int qcow2_set_key(BlockDriverState *bs, const char *key) 437 { 438 BDRVQcowState *s = bs->opaque; 439 uint8_t keybuf[16]; 440 int len, i; 441 442 memset(keybuf, 0, 16); 443 len = strlen(key); 444 if (len > 16) 445 len = 16; 446 /* XXX: we could compress the chars to 7 bits to increase 447 entropy */ 448 for(i = 0;i < len;i++) { 449 keybuf[i] = key[i]; 450 } 451 s->crypt_method = s->crypt_method_header; 452 453 if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0) 454 return -1; 455 if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0) 456 return -1; 457 #if 0 458 /* test */ 459 { 460 uint8_t in[16]; 461 uint8_t out[16]; 462 uint8_t tmp[16]; 463 for(i=0;i<16;i++) 464 in[i] = i; 465 AES_encrypt(in, tmp, &s->aes_encrypt_key); 466 AES_decrypt(tmp, out, &s->aes_decrypt_key); 467 for(i = 0; i < 16; i++) 468 printf(" %02x", tmp[i]); 469 printf("\n"); 470 for(i = 0; i < 16; i++) 471 printf(" %02x", out[i]); 472 printf("\n"); 473 } 474 #endif 475 return 0; 476 } 477 478 static int coroutine_fn qcow2_co_is_allocated(BlockDriverState *bs, 479 int64_t sector_num, int nb_sectors, int *pnum) 480 { 481 BDRVQcowState *s = bs->opaque; 482 uint64_t cluster_offset; 483 int ret; 484 485 *pnum = nb_sectors; 486 /* FIXME We can get errors here, but the bdrv_co_is_allocated interface 487 * can't pass them on today */ 488 qemu_co_mutex_lock(&s->lock); 489 ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset); 490 qemu_co_mutex_unlock(&s->lock); 491 if (ret < 0) { 492 *pnum = 0; 493 } 494 495 return (cluster_offset != 0); 496 } 497 498 /* handle reading after the end of the backing file */ 499 int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov, 500 int64_t sector_num, int nb_sectors) 501 { 502 int n1; 503 if ((sector_num + nb_sectors) <= bs->total_sectors) 504 return nb_sectors; 505 if (sector_num >= bs->total_sectors) 506 n1 = 0; 507 else 508 n1 = bs->total_sectors - sector_num; 509 510 qemu_iovec_memset_skip(qiov, 0, 512 * (nb_sectors - n1), 512 * n1); 511 512 return n1; 513 } 514 515 static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num, 516 int remaining_sectors, QEMUIOVector *qiov) 517 { 518 BDRVQcowState *s = bs->opaque; 519 int index_in_cluster, n1; 520 int ret; 521 int cur_nr_sectors; /* number of sectors in current iteration */ 522 uint64_t cluster_offset = 0; 523 uint64_t bytes_done = 0; 524 QEMUIOVector hd_qiov; 525 uint8_t *cluster_data = NULL; 526 527 qemu_iovec_init(&hd_qiov, qiov->niov); 528 529 qemu_co_mutex_lock(&s->lock); 530 531 while (remaining_sectors != 0) { 532 533 /* prepare next request */ 534 cur_nr_sectors = remaining_sectors; 535 if (s->crypt_method) { 536 cur_nr_sectors = MIN(cur_nr_sectors, 537 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors); 538 } 539 540 ret = qcow2_get_cluster_offset(bs, sector_num << 9, 541 &cur_nr_sectors, &cluster_offset); 542 if (ret < 0) { 543 goto fail; 544 } 545 546 index_in_cluster = sector_num & (s->cluster_sectors - 1); 547 548 qemu_iovec_reset(&hd_qiov); 549 qemu_iovec_copy(&hd_qiov, qiov, bytes_done, 550 cur_nr_sectors * 512); 551 552 switch (ret) { 553 case QCOW2_CLUSTER_UNALLOCATED: 554 555 if (bs->backing_hd) { 556 /* read from the base image */ 557 n1 = qcow2_backing_read1(bs->backing_hd, &hd_qiov, 558 sector_num, cur_nr_sectors); 559 if (n1 > 0) { 560 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); 561 qemu_co_mutex_unlock(&s->lock); 562 ret = bdrv_co_readv(bs->backing_hd, sector_num, 563 n1, &hd_qiov); 564 qemu_co_mutex_lock(&s->lock); 565 if (ret < 0) { 566 goto fail; 567 } 568 } 569 } else { 570 /* Note: in this case, no need to wait */ 571 qemu_iovec_memset(&hd_qiov, 0, 512 * cur_nr_sectors); 572 } 573 break; 574 575 case QCOW2_CLUSTER_ZERO: 576 if (s->qcow_version < 3) { 577 ret = -EIO; 578 goto fail; 579 } 580 qemu_iovec_memset(&hd_qiov, 0, 512 * cur_nr_sectors); 581 break; 582 583 case QCOW2_CLUSTER_COMPRESSED: 584 /* add AIO support for compressed blocks ? */ 585 ret = qcow2_decompress_cluster(bs, cluster_offset); 586 if (ret < 0) { 587 goto fail; 588 } 589 590 qemu_iovec_from_buffer(&hd_qiov, 591 s->cluster_cache + index_in_cluster * 512, 592 512 * cur_nr_sectors); 593 break; 594 595 case QCOW2_CLUSTER_NORMAL: 596 if ((cluster_offset & 511) != 0) { 597 ret = -EIO; 598 goto fail; 599 } 600 601 if (s->crypt_method) { 602 /* 603 * For encrypted images, read everything into a temporary 604 * contiguous buffer on which the AES functions can work. 605 */ 606 if (!cluster_data) { 607 cluster_data = 608 qemu_blockalign(bs, QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 609 } 610 611 assert(cur_nr_sectors <= 612 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors); 613 qemu_iovec_reset(&hd_qiov); 614 qemu_iovec_add(&hd_qiov, cluster_data, 615 512 * cur_nr_sectors); 616 } 617 618 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); 619 qemu_co_mutex_unlock(&s->lock); 620 ret = bdrv_co_readv(bs->file, 621 (cluster_offset >> 9) + index_in_cluster, 622 cur_nr_sectors, &hd_qiov); 623 qemu_co_mutex_lock(&s->lock); 624 if (ret < 0) { 625 goto fail; 626 } 627 if (s->crypt_method) { 628 qcow2_encrypt_sectors(s, sector_num, cluster_data, 629 cluster_data, cur_nr_sectors, 0, &s->aes_decrypt_key); 630 qemu_iovec_reset(&hd_qiov); 631 qemu_iovec_copy(&hd_qiov, qiov, bytes_done, 632 cur_nr_sectors * 512); 633 qemu_iovec_from_buffer(&hd_qiov, cluster_data, 634 512 * cur_nr_sectors); 635 } 636 break; 637 638 default: 639 g_assert_not_reached(); 640 ret = -EIO; 641 goto fail; 642 } 643 644 remaining_sectors -= cur_nr_sectors; 645 sector_num += cur_nr_sectors; 646 bytes_done += cur_nr_sectors * 512; 647 } 648 ret = 0; 649 650 fail: 651 qemu_co_mutex_unlock(&s->lock); 652 653 qemu_iovec_destroy(&hd_qiov); 654 qemu_vfree(cluster_data); 655 656 return ret; 657 } 658 659 static void run_dependent_requests(BDRVQcowState *s, QCowL2Meta *m) 660 { 661 /* Take the request off the list of running requests */ 662 if (m->nb_clusters != 0) { 663 QLIST_REMOVE(m, next_in_flight); 664 } 665 666 /* Restart all dependent requests */ 667 if (!qemu_co_queue_empty(&m->dependent_requests)) { 668 qemu_co_mutex_unlock(&s->lock); 669 qemu_co_queue_restart_all(&m->dependent_requests); 670 qemu_co_mutex_lock(&s->lock); 671 } 672 } 673 674 static coroutine_fn int qcow2_co_writev(BlockDriverState *bs, 675 int64_t sector_num, 676 int remaining_sectors, 677 QEMUIOVector *qiov) 678 { 679 BDRVQcowState *s = bs->opaque; 680 int index_in_cluster; 681 int n_end; 682 int ret; 683 int cur_nr_sectors; /* number of sectors in current iteration */ 684 uint64_t cluster_offset; 685 QEMUIOVector hd_qiov; 686 uint64_t bytes_done = 0; 687 uint8_t *cluster_data = NULL; 688 QCowL2Meta l2meta = { 689 .nb_clusters = 0, 690 }; 691 692 trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num, 693 remaining_sectors); 694 695 qemu_co_queue_init(&l2meta.dependent_requests); 696 697 qemu_iovec_init(&hd_qiov, qiov->niov); 698 699 s->cluster_cache_offset = -1; /* disable compressed cache */ 700 701 qemu_co_mutex_lock(&s->lock); 702 703 while (remaining_sectors != 0) { 704 705 trace_qcow2_writev_start_part(qemu_coroutine_self()); 706 index_in_cluster = sector_num & (s->cluster_sectors - 1); 707 n_end = index_in_cluster + remaining_sectors; 708 if (s->crypt_method && 709 n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) { 710 n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; 711 } 712 713 ret = qcow2_alloc_cluster_offset(bs, sector_num << 9, 714 index_in_cluster, n_end, &cur_nr_sectors, &l2meta); 715 if (ret < 0) { 716 goto fail; 717 } 718 719 cluster_offset = l2meta.cluster_offset; 720 assert((cluster_offset & 511) == 0); 721 722 qemu_iovec_reset(&hd_qiov); 723 qemu_iovec_copy(&hd_qiov, qiov, bytes_done, 724 cur_nr_sectors * 512); 725 726 if (s->crypt_method) { 727 if (!cluster_data) { 728 cluster_data = qemu_blockalign(bs, QCOW_MAX_CRYPT_CLUSTERS * 729 s->cluster_size); 730 } 731 732 assert(hd_qiov.size <= 733 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); 734 qemu_iovec_to_buffer(&hd_qiov, cluster_data); 735 736 qcow2_encrypt_sectors(s, sector_num, cluster_data, 737 cluster_data, cur_nr_sectors, 1, &s->aes_encrypt_key); 738 739 qemu_iovec_reset(&hd_qiov); 740 qemu_iovec_add(&hd_qiov, cluster_data, 741 cur_nr_sectors * 512); 742 } 743 744 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); 745 qemu_co_mutex_unlock(&s->lock); 746 trace_qcow2_writev_data(qemu_coroutine_self(), 747 (cluster_offset >> 9) + index_in_cluster); 748 ret = bdrv_co_writev(bs->file, 749 (cluster_offset >> 9) + index_in_cluster, 750 cur_nr_sectors, &hd_qiov); 751 qemu_co_mutex_lock(&s->lock); 752 if (ret < 0) { 753 goto fail; 754 } 755 756 ret = qcow2_alloc_cluster_link_l2(bs, &l2meta); 757 if (ret < 0) { 758 goto fail; 759 } 760 761 run_dependent_requests(s, &l2meta); 762 763 remaining_sectors -= cur_nr_sectors; 764 sector_num += cur_nr_sectors; 765 bytes_done += cur_nr_sectors * 512; 766 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors); 767 } 768 ret = 0; 769 770 fail: 771 run_dependent_requests(s, &l2meta); 772 773 qemu_co_mutex_unlock(&s->lock); 774 775 qemu_iovec_destroy(&hd_qiov); 776 qemu_vfree(cluster_data); 777 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret); 778 779 return ret; 780 } 781 782 static void qcow2_close(BlockDriverState *bs) 783 { 784 BDRVQcowState *s = bs->opaque; 785 g_free(s->l1_table); 786 787 qcow2_cache_flush(bs, s->l2_table_cache); 788 qcow2_cache_flush(bs, s->refcount_block_cache); 789 790 qcow2_cache_destroy(bs, s->l2_table_cache); 791 qcow2_cache_destroy(bs, s->refcount_block_cache); 792 793 g_free(s->unknown_header_fields); 794 cleanup_unknown_header_ext(bs); 795 796 g_free(s->cluster_cache); 797 qemu_vfree(s->cluster_data); 798 qcow2_refcount_close(bs); 799 qcow2_free_snapshots(bs); 800 } 801 802 static void qcow2_invalidate_cache(BlockDriverState *bs) 803 { 804 BDRVQcowState *s = bs->opaque; 805 int flags = s->flags; 806 AES_KEY aes_encrypt_key; 807 AES_KEY aes_decrypt_key; 808 uint32_t crypt_method = 0; 809 810 /* 811 * Backing files are read-only which makes all of their metadata immutable, 812 * that means we don't have to worry about reopening them here. 813 */ 814 815 if (s->crypt_method) { 816 crypt_method = s->crypt_method; 817 memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key)); 818 memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key)); 819 } 820 821 qcow2_close(bs); 822 823 memset(s, 0, sizeof(BDRVQcowState)); 824 qcow2_open(bs, flags); 825 826 if (crypt_method) { 827 s->crypt_method = crypt_method; 828 memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key)); 829 memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key)); 830 } 831 } 832 833 static size_t header_ext_add(char *buf, uint32_t magic, const void *s, 834 size_t len, size_t buflen) 835 { 836 QCowExtension *ext_backing_fmt = (QCowExtension*) buf; 837 size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7); 838 839 if (buflen < ext_len) { 840 return -ENOSPC; 841 } 842 843 *ext_backing_fmt = (QCowExtension) { 844 .magic = cpu_to_be32(magic), 845 .len = cpu_to_be32(len), 846 }; 847 memcpy(buf + sizeof(QCowExtension), s, len); 848 849 return ext_len; 850 } 851 852 /* 853 * Updates the qcow2 header, including the variable length parts of it, i.e. 854 * the backing file name and all extensions. qcow2 was not designed to allow 855 * such changes, so if we run out of space (we can only use the first cluster) 856 * this function may fail. 857 * 858 * Returns 0 on success, -errno in error cases. 859 */ 860 int qcow2_update_header(BlockDriverState *bs) 861 { 862 BDRVQcowState *s = bs->opaque; 863 QCowHeader *header; 864 char *buf; 865 size_t buflen = s->cluster_size; 866 int ret; 867 uint64_t total_size; 868 uint32_t refcount_table_clusters; 869 size_t header_length; 870 Qcow2UnknownHeaderExtension *uext; 871 872 buf = qemu_blockalign(bs, buflen); 873 874 /* Header structure */ 875 header = (QCowHeader*) buf; 876 877 if (buflen < sizeof(*header)) { 878 ret = -ENOSPC; 879 goto fail; 880 } 881 882 header_length = sizeof(*header) + s->unknown_header_fields_size; 883 total_size = bs->total_sectors * BDRV_SECTOR_SIZE; 884 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3); 885 886 *header = (QCowHeader) { 887 /* Version 2 fields */ 888 .magic = cpu_to_be32(QCOW_MAGIC), 889 .version = cpu_to_be32(s->qcow_version), 890 .backing_file_offset = 0, 891 .backing_file_size = 0, 892 .cluster_bits = cpu_to_be32(s->cluster_bits), 893 .size = cpu_to_be64(total_size), 894 .crypt_method = cpu_to_be32(s->crypt_method_header), 895 .l1_size = cpu_to_be32(s->l1_size), 896 .l1_table_offset = cpu_to_be64(s->l1_table_offset), 897 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset), 898 .refcount_table_clusters = cpu_to_be32(refcount_table_clusters), 899 .nb_snapshots = cpu_to_be32(s->nb_snapshots), 900 .snapshots_offset = cpu_to_be64(s->snapshots_offset), 901 902 /* Version 3 fields */ 903 .incompatible_features = cpu_to_be64(s->incompatible_features), 904 .compatible_features = cpu_to_be64(s->compatible_features), 905 .autoclear_features = cpu_to_be64(s->autoclear_features), 906 .refcount_order = cpu_to_be32(3 + REFCOUNT_SHIFT), 907 .header_length = cpu_to_be32(header_length), 908 }; 909 910 /* For older versions, write a shorter header */ 911 switch (s->qcow_version) { 912 case 2: 913 ret = offsetof(QCowHeader, incompatible_features); 914 break; 915 case 3: 916 ret = sizeof(*header); 917 break; 918 default: 919 return -EINVAL; 920 } 921 922 buf += ret; 923 buflen -= ret; 924 memset(buf, 0, buflen); 925 926 /* Preserve any unknown field in the header */ 927 if (s->unknown_header_fields_size) { 928 if (buflen < s->unknown_header_fields_size) { 929 ret = -ENOSPC; 930 goto fail; 931 } 932 933 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size); 934 buf += s->unknown_header_fields_size; 935 buflen -= s->unknown_header_fields_size; 936 } 937 938 /* Backing file format header extension */ 939 if (*bs->backing_format) { 940 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT, 941 bs->backing_format, strlen(bs->backing_format), 942 buflen); 943 if (ret < 0) { 944 goto fail; 945 } 946 947 buf += ret; 948 buflen -= ret; 949 } 950 951 /* Feature table */ 952 Qcow2Feature features[] = { 953 /* no feature defined yet */ 954 }; 955 956 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE, 957 features, sizeof(features), buflen); 958 if (ret < 0) { 959 goto fail; 960 } 961 buf += ret; 962 buflen -= ret; 963 964 /* Keep unknown header extensions */ 965 QLIST_FOREACH(uext, &s->unknown_header_ext, next) { 966 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen); 967 if (ret < 0) { 968 goto fail; 969 } 970 971 buf += ret; 972 buflen -= ret; 973 } 974 975 /* End of header extensions */ 976 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen); 977 if (ret < 0) { 978 goto fail; 979 } 980 981 buf += ret; 982 buflen -= ret; 983 984 /* Backing file name */ 985 if (*bs->backing_file) { 986 size_t backing_file_len = strlen(bs->backing_file); 987 988 if (buflen < backing_file_len) { 989 ret = -ENOSPC; 990 goto fail; 991 } 992 993 strncpy(buf, bs->backing_file, buflen); 994 995 header->backing_file_offset = cpu_to_be64(buf - ((char*) header)); 996 header->backing_file_size = cpu_to_be32(backing_file_len); 997 } 998 999 /* Write the new header */ 1000 ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size); 1001 if (ret < 0) { 1002 goto fail; 1003 } 1004 1005 ret = 0; 1006 fail: 1007 qemu_vfree(header); 1008 return ret; 1009 } 1010 1011 static int qcow2_change_backing_file(BlockDriverState *bs, 1012 const char *backing_file, const char *backing_fmt) 1013 { 1014 /* Backing file format doesn't make sense without a backing file */ 1015 if (backing_fmt && !backing_file) { 1016 return -EINVAL; 1017 } 1018 1019 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 1020 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 1021 1022 return qcow2_update_header(bs); 1023 } 1024 1025 static int preallocate(BlockDriverState *bs) 1026 { 1027 uint64_t nb_sectors; 1028 uint64_t offset; 1029 int num; 1030 int ret; 1031 QCowL2Meta meta; 1032 1033 nb_sectors = bdrv_getlength(bs) >> 9; 1034 offset = 0; 1035 qemu_co_queue_init(&meta.dependent_requests); 1036 meta.cluster_offset = 0; 1037 1038 while (nb_sectors) { 1039 num = MIN(nb_sectors, INT_MAX >> 9); 1040 ret = qcow2_alloc_cluster_offset(bs, offset, 0, num, &num, &meta); 1041 if (ret < 0) { 1042 return ret; 1043 } 1044 1045 ret = qcow2_alloc_cluster_link_l2(bs, &meta); 1046 if (ret < 0) { 1047 qcow2_free_any_clusters(bs, meta.cluster_offset, meta.nb_clusters); 1048 return ret; 1049 } 1050 1051 /* There are no dependent requests, but we need to remove our request 1052 * from the list of in-flight requests */ 1053 run_dependent_requests(bs->opaque, &meta); 1054 1055 /* TODO Preallocate data if requested */ 1056 1057 nb_sectors -= num; 1058 offset += num << 9; 1059 } 1060 1061 /* 1062 * It is expected that the image file is large enough to actually contain 1063 * all of the allocated clusters (otherwise we get failing reads after 1064 * EOF). Extend the image to the last allocated sector. 1065 */ 1066 if (meta.cluster_offset != 0) { 1067 uint8_t buf[512]; 1068 memset(buf, 0, 512); 1069 ret = bdrv_write(bs->file, (meta.cluster_offset >> 9) + num - 1, buf, 1); 1070 if (ret < 0) { 1071 return ret; 1072 } 1073 } 1074 1075 return 0; 1076 } 1077 1078 static int qcow2_create2(const char *filename, int64_t total_size, 1079 const char *backing_file, const char *backing_format, 1080 int flags, size_t cluster_size, int prealloc, 1081 QEMUOptionParameter *options, int version) 1082 { 1083 /* Calculate cluster_bits */ 1084 int cluster_bits; 1085 cluster_bits = ffs(cluster_size) - 1; 1086 if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS || 1087 (1 << cluster_bits) != cluster_size) 1088 { 1089 error_report( 1090 "Cluster size must be a power of two between %d and %dk", 1091 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); 1092 return -EINVAL; 1093 } 1094 1095 /* 1096 * Open the image file and write a minimal qcow2 header. 1097 * 1098 * We keep things simple and start with a zero-sized image. We also 1099 * do without refcount blocks or a L1 table for now. We'll fix the 1100 * inconsistency later. 1101 * 1102 * We do need a refcount table because growing the refcount table means 1103 * allocating two new refcount blocks - the seconds of which would be at 1104 * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file 1105 * size for any qcow2 image. 1106 */ 1107 BlockDriverState* bs; 1108 QCowHeader header; 1109 uint8_t* refcount_table; 1110 int ret; 1111 1112 ret = bdrv_create_file(filename, options); 1113 if (ret < 0) { 1114 return ret; 1115 } 1116 1117 ret = bdrv_file_open(&bs, filename, BDRV_O_RDWR); 1118 if (ret < 0) { 1119 return ret; 1120 } 1121 1122 /* Write the header */ 1123 memset(&header, 0, sizeof(header)); 1124 header.magic = cpu_to_be32(QCOW_MAGIC); 1125 header.version = cpu_to_be32(version); 1126 header.cluster_bits = cpu_to_be32(cluster_bits); 1127 header.size = cpu_to_be64(0); 1128 header.l1_table_offset = cpu_to_be64(0); 1129 header.l1_size = cpu_to_be32(0); 1130 header.refcount_table_offset = cpu_to_be64(cluster_size); 1131 header.refcount_table_clusters = cpu_to_be32(1); 1132 header.refcount_order = cpu_to_be32(3 + REFCOUNT_SHIFT); 1133 header.header_length = cpu_to_be32(sizeof(header)); 1134 1135 if (flags & BLOCK_FLAG_ENCRYPT) { 1136 header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES); 1137 } else { 1138 header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); 1139 } 1140 1141 ret = bdrv_pwrite(bs, 0, &header, sizeof(header)); 1142 if (ret < 0) { 1143 goto out; 1144 } 1145 1146 /* Write an empty refcount table */ 1147 refcount_table = g_malloc0(cluster_size); 1148 ret = bdrv_pwrite(bs, cluster_size, refcount_table, cluster_size); 1149 g_free(refcount_table); 1150 1151 if (ret < 0) { 1152 goto out; 1153 } 1154 1155 bdrv_close(bs); 1156 1157 /* 1158 * And now open the image and make it consistent first (i.e. increase the 1159 * refcount of the cluster that is occupied by the header and the refcount 1160 * table) 1161 */ 1162 BlockDriver* drv = bdrv_find_format("qcow2"); 1163 assert(drv != NULL); 1164 ret = bdrv_open(bs, filename, 1165 BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, drv); 1166 if (ret < 0) { 1167 goto out; 1168 } 1169 1170 ret = qcow2_alloc_clusters(bs, 2 * cluster_size); 1171 if (ret < 0) { 1172 goto out; 1173 1174 } else if (ret != 0) { 1175 error_report("Huh, first cluster in empty image is already in use?"); 1176 abort(); 1177 } 1178 1179 /* Okay, now that we have a valid image, let's give it the right size */ 1180 ret = bdrv_truncate(bs, total_size * BDRV_SECTOR_SIZE); 1181 if (ret < 0) { 1182 goto out; 1183 } 1184 1185 /* Want a backing file? There you go.*/ 1186 if (backing_file) { 1187 ret = bdrv_change_backing_file(bs, backing_file, backing_format); 1188 if (ret < 0) { 1189 goto out; 1190 } 1191 } 1192 1193 /* And if we're supposed to preallocate metadata, do that now */ 1194 if (prealloc) { 1195 ret = preallocate(bs); 1196 if (ret < 0) { 1197 goto out; 1198 } 1199 } 1200 1201 ret = 0; 1202 out: 1203 bdrv_delete(bs); 1204 return ret; 1205 } 1206 1207 static int qcow2_create(const char *filename, QEMUOptionParameter *options) 1208 { 1209 const char *backing_file = NULL; 1210 const char *backing_fmt = NULL; 1211 uint64_t sectors = 0; 1212 int flags = 0; 1213 size_t cluster_size = DEFAULT_CLUSTER_SIZE; 1214 int prealloc = 0; 1215 int version = 2; 1216 1217 /* Read out options */ 1218 while (options && options->name) { 1219 if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 1220 sectors = options->value.n / 512; 1221 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { 1222 backing_file = options->value.s; 1223 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) { 1224 backing_fmt = options->value.s; 1225 } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) { 1226 flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0; 1227 } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { 1228 if (options->value.n) { 1229 cluster_size = options->value.n; 1230 } 1231 } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) { 1232 if (!options->value.s || !strcmp(options->value.s, "off")) { 1233 prealloc = 0; 1234 } else if (!strcmp(options->value.s, "metadata")) { 1235 prealloc = 1; 1236 } else { 1237 fprintf(stderr, "Invalid preallocation mode: '%s'\n", 1238 options->value.s); 1239 return -EINVAL; 1240 } 1241 } else if (!strcmp(options->name, BLOCK_OPT_COMPAT_LEVEL)) { 1242 if (!options->value.s || !strcmp(options->value.s, "0.10")) { 1243 version = 2; 1244 } else if (!strcmp(options->value.s, "1.1")) { 1245 version = 3; 1246 } else { 1247 fprintf(stderr, "Invalid compatibility level: '%s'\n", 1248 options->value.s); 1249 return -EINVAL; 1250 } 1251 } 1252 options++; 1253 } 1254 1255 if (backing_file && prealloc) { 1256 fprintf(stderr, "Backing file and preallocation cannot be used at " 1257 "the same time\n"); 1258 return -EINVAL; 1259 } 1260 1261 return qcow2_create2(filename, sectors, backing_file, backing_fmt, flags, 1262 cluster_size, prealloc, options, version); 1263 } 1264 1265 static int qcow2_make_empty(BlockDriverState *bs) 1266 { 1267 #if 0 1268 /* XXX: not correct */ 1269 BDRVQcowState *s = bs->opaque; 1270 uint32_t l1_length = s->l1_size * sizeof(uint64_t); 1271 int ret; 1272 1273 memset(s->l1_table, 0, l1_length); 1274 if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0) 1275 return -1; 1276 ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length); 1277 if (ret < 0) 1278 return ret; 1279 1280 l2_cache_reset(bs); 1281 #endif 1282 return 0; 1283 } 1284 1285 static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs, 1286 int64_t sector_num, int nb_sectors) 1287 { 1288 int ret; 1289 BDRVQcowState *s = bs->opaque; 1290 1291 /* Emulate misaligned zero writes */ 1292 if (sector_num % s->cluster_sectors || nb_sectors % s->cluster_sectors) { 1293 return -ENOTSUP; 1294 } 1295 1296 /* Whatever is left can use real zero clusters */ 1297 qemu_co_mutex_lock(&s->lock); 1298 ret = qcow2_zero_clusters(bs, sector_num << BDRV_SECTOR_BITS, 1299 nb_sectors); 1300 qemu_co_mutex_unlock(&s->lock); 1301 1302 return ret; 1303 } 1304 1305 static coroutine_fn int qcow2_co_discard(BlockDriverState *bs, 1306 int64_t sector_num, int nb_sectors) 1307 { 1308 int ret; 1309 BDRVQcowState *s = bs->opaque; 1310 1311 qemu_co_mutex_lock(&s->lock); 1312 ret = qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS, 1313 nb_sectors); 1314 qemu_co_mutex_unlock(&s->lock); 1315 return ret; 1316 } 1317 1318 static int qcow2_truncate(BlockDriverState *bs, int64_t offset) 1319 { 1320 BDRVQcowState *s = bs->opaque; 1321 int ret, new_l1_size; 1322 1323 if (offset & 511) { 1324 error_report("The new size must be a multiple of 512"); 1325 return -EINVAL; 1326 } 1327 1328 /* cannot proceed if image has snapshots */ 1329 if (s->nb_snapshots) { 1330 error_report("Can't resize an image which has snapshots"); 1331 return -ENOTSUP; 1332 } 1333 1334 /* shrinking is currently not supported */ 1335 if (offset < bs->total_sectors * 512) { 1336 error_report("qcow2 doesn't support shrinking images yet"); 1337 return -ENOTSUP; 1338 } 1339 1340 new_l1_size = size_to_l1(s, offset); 1341 ret = qcow2_grow_l1_table(bs, new_l1_size, true); 1342 if (ret < 0) { 1343 return ret; 1344 } 1345 1346 /* write updated header.size */ 1347 offset = cpu_to_be64(offset); 1348 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), 1349 &offset, sizeof(uint64_t)); 1350 if (ret < 0) { 1351 return ret; 1352 } 1353 1354 s->l1_vm_state_index = new_l1_size; 1355 return 0; 1356 } 1357 1358 /* XXX: put compressed sectors first, then all the cluster aligned 1359 tables to avoid losing bytes in alignment */ 1360 static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num, 1361 const uint8_t *buf, int nb_sectors) 1362 { 1363 BDRVQcowState *s = bs->opaque; 1364 z_stream strm; 1365 int ret, out_len; 1366 uint8_t *out_buf; 1367 uint64_t cluster_offset; 1368 1369 if (nb_sectors == 0) { 1370 /* align end of file to a sector boundary to ease reading with 1371 sector based I/Os */ 1372 cluster_offset = bdrv_getlength(bs->file); 1373 cluster_offset = (cluster_offset + 511) & ~511; 1374 bdrv_truncate(bs->file, cluster_offset); 1375 return 0; 1376 } 1377 1378 if (nb_sectors != s->cluster_sectors) 1379 return -EINVAL; 1380 1381 out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128); 1382 1383 /* best compression, small window, no zlib header */ 1384 memset(&strm, 0, sizeof(strm)); 1385 ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, 1386 Z_DEFLATED, -12, 1387 9, Z_DEFAULT_STRATEGY); 1388 if (ret != 0) { 1389 ret = -EINVAL; 1390 goto fail; 1391 } 1392 1393 strm.avail_in = s->cluster_size; 1394 strm.next_in = (uint8_t *)buf; 1395 strm.avail_out = s->cluster_size; 1396 strm.next_out = out_buf; 1397 1398 ret = deflate(&strm, Z_FINISH); 1399 if (ret != Z_STREAM_END && ret != Z_OK) { 1400 deflateEnd(&strm); 1401 ret = -EINVAL; 1402 goto fail; 1403 } 1404 out_len = strm.next_out - out_buf; 1405 1406 deflateEnd(&strm); 1407 1408 if (ret != Z_STREAM_END || out_len >= s->cluster_size) { 1409 /* could not compress: write normal cluster */ 1410 ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors); 1411 if (ret < 0) { 1412 goto fail; 1413 } 1414 } else { 1415 cluster_offset = qcow2_alloc_compressed_cluster_offset(bs, 1416 sector_num << 9, out_len); 1417 if (!cluster_offset) { 1418 ret = -EIO; 1419 goto fail; 1420 } 1421 cluster_offset &= s->cluster_offset_mask; 1422 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED); 1423 ret = bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len); 1424 if (ret < 0) { 1425 goto fail; 1426 } 1427 } 1428 1429 ret = 0; 1430 fail: 1431 g_free(out_buf); 1432 return ret; 1433 } 1434 1435 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs) 1436 { 1437 BDRVQcowState *s = bs->opaque; 1438 int ret; 1439 1440 qemu_co_mutex_lock(&s->lock); 1441 ret = qcow2_cache_flush(bs, s->l2_table_cache); 1442 if (ret < 0) { 1443 qemu_co_mutex_unlock(&s->lock); 1444 return ret; 1445 } 1446 1447 ret = qcow2_cache_flush(bs, s->refcount_block_cache); 1448 if (ret < 0) { 1449 qemu_co_mutex_unlock(&s->lock); 1450 return ret; 1451 } 1452 qemu_co_mutex_unlock(&s->lock); 1453 1454 return 0; 1455 } 1456 1457 static int64_t qcow2_vm_state_offset(BDRVQcowState *s) 1458 { 1459 return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits); 1460 } 1461 1462 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 1463 { 1464 BDRVQcowState *s = bs->opaque; 1465 bdi->cluster_size = s->cluster_size; 1466 bdi->vm_state_offset = qcow2_vm_state_offset(s); 1467 return 0; 1468 } 1469 1470 1471 static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result) 1472 { 1473 return qcow2_check_refcounts(bs, result); 1474 } 1475 1476 #if 0 1477 static void dump_refcounts(BlockDriverState *bs) 1478 { 1479 BDRVQcowState *s = bs->opaque; 1480 int64_t nb_clusters, k, k1, size; 1481 int refcount; 1482 1483 size = bdrv_getlength(bs->file); 1484 nb_clusters = size_to_clusters(s, size); 1485 for(k = 0; k < nb_clusters;) { 1486 k1 = k; 1487 refcount = get_refcount(bs, k); 1488 k++; 1489 while (k < nb_clusters && get_refcount(bs, k) == refcount) 1490 k++; 1491 printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount, 1492 k - k1); 1493 } 1494 } 1495 #endif 1496 1497 static int qcow2_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 1498 int64_t pos, int size) 1499 { 1500 BDRVQcowState *s = bs->opaque; 1501 int growable = bs->growable; 1502 int ret; 1503 1504 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); 1505 bs->growable = 1; 1506 ret = bdrv_pwrite(bs, qcow2_vm_state_offset(s) + pos, buf, size); 1507 bs->growable = growable; 1508 1509 return ret; 1510 } 1511 1512 static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf, 1513 int64_t pos, int size) 1514 { 1515 BDRVQcowState *s = bs->opaque; 1516 int growable = bs->growable; 1517 int ret; 1518 1519 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); 1520 bs->growable = 1; 1521 ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size); 1522 bs->growable = growable; 1523 1524 return ret; 1525 } 1526 1527 static QEMUOptionParameter qcow2_create_options[] = { 1528 { 1529 .name = BLOCK_OPT_SIZE, 1530 .type = OPT_SIZE, 1531 .help = "Virtual disk size" 1532 }, 1533 { 1534 .name = BLOCK_OPT_COMPAT_LEVEL, 1535 .type = OPT_STRING, 1536 .help = "Compatibility level (0.10 or 1.1)" 1537 }, 1538 { 1539 .name = BLOCK_OPT_BACKING_FILE, 1540 .type = OPT_STRING, 1541 .help = "File name of a base image" 1542 }, 1543 { 1544 .name = BLOCK_OPT_BACKING_FMT, 1545 .type = OPT_STRING, 1546 .help = "Image format of the base image" 1547 }, 1548 { 1549 .name = BLOCK_OPT_ENCRYPT, 1550 .type = OPT_FLAG, 1551 .help = "Encrypt the image" 1552 }, 1553 { 1554 .name = BLOCK_OPT_CLUSTER_SIZE, 1555 .type = OPT_SIZE, 1556 .help = "qcow2 cluster size", 1557 .value = { .n = DEFAULT_CLUSTER_SIZE }, 1558 }, 1559 { 1560 .name = BLOCK_OPT_PREALLOC, 1561 .type = OPT_STRING, 1562 .help = "Preallocation mode (allowed values: off, metadata)" 1563 }, 1564 { NULL } 1565 }; 1566 1567 static BlockDriver bdrv_qcow2 = { 1568 .format_name = "qcow2", 1569 .instance_size = sizeof(BDRVQcowState), 1570 .bdrv_probe = qcow2_probe, 1571 .bdrv_open = qcow2_open, 1572 .bdrv_close = qcow2_close, 1573 .bdrv_create = qcow2_create, 1574 .bdrv_co_is_allocated = qcow2_co_is_allocated, 1575 .bdrv_set_key = qcow2_set_key, 1576 .bdrv_make_empty = qcow2_make_empty, 1577 1578 .bdrv_co_readv = qcow2_co_readv, 1579 .bdrv_co_writev = qcow2_co_writev, 1580 .bdrv_co_flush_to_os = qcow2_co_flush_to_os, 1581 1582 .bdrv_co_write_zeroes = qcow2_co_write_zeroes, 1583 .bdrv_co_discard = qcow2_co_discard, 1584 .bdrv_truncate = qcow2_truncate, 1585 .bdrv_write_compressed = qcow2_write_compressed, 1586 1587 .bdrv_snapshot_create = qcow2_snapshot_create, 1588 .bdrv_snapshot_goto = qcow2_snapshot_goto, 1589 .bdrv_snapshot_delete = qcow2_snapshot_delete, 1590 .bdrv_snapshot_list = qcow2_snapshot_list, 1591 .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp, 1592 .bdrv_get_info = qcow2_get_info, 1593 1594 .bdrv_save_vmstate = qcow2_save_vmstate, 1595 .bdrv_load_vmstate = qcow2_load_vmstate, 1596 1597 .bdrv_change_backing_file = qcow2_change_backing_file, 1598 1599 .bdrv_invalidate_cache = qcow2_invalidate_cache, 1600 1601 .create_options = qcow2_create_options, 1602 .bdrv_check = qcow2_check, 1603 }; 1604 1605 static void bdrv_qcow2_init(void) 1606 { 1607 bdrv_register(&bdrv_qcow2); 1608 } 1609 1610 block_init(bdrv_qcow2_init); 1611