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