block/qcow2.c

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