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     BlockDriverState *bs;
 381     int64_t sector_num;
 382     QEMUIOVector *qiov;
 383     int remaining_sectors;
 384     uint64_t bytes_done;
 385     uint8_t *cluster_data;
 386     QEMUIOVector hd_qiov;
 387 } QCowAIOCB;
 388
 389 /*
 390  * Returns 0 when the request is completed successfully, 1 when there is still
 391  * a part left to do and -errno in error cases.
 392  */
 393 static int qcow2_aio_read_cb(QCowAIOCB *acb)
 394 {
 395     BlockDriverState *bs = acb->bs;
 396     BDRVQcowState *s = bs->opaque;
 397     int index_in_cluster, n1;
 398     int ret;
 399     int cur_nr_sectors; /* number of sectors in current iteration */
 400     uint64_t cluster_offset = 0;
 401
 402     if (acb->remaining_sectors == 0) {
 403         /* request completed */
 404         return 0;
 405     }
 406
 407     /* prepare next request */
 408     cur_nr_sectors = acb->remaining_sectors;
 409     if (s->crypt_method) {
 410         cur_nr_sectors = MIN(cur_nr_sectors,
 411             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
 412     }
 413
 414     ret = qcow2_get_cluster_offset(bs, acb->sector_num << 9,
 415         &cur_nr_sectors, &cluster_offset);
 416     if (ret < 0) {
 417         return ret;
 418     }
 419
 420     index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
 421
 422     qemu_iovec_reset(&acb->hd_qiov);
 423     qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done,
 424         cur_nr_sectors * 512);
 425
 426     if (!cluster_offset) {
 427
 428         if (bs->backing_hd) {
 429             /* read from the base image */
 430             n1 = qcow2_backing_read1(bs->backing_hd, &acb->hd_qiov,
 431                 acb->sector_num, cur_nr_sectors);
 432             if (n1 > 0) {
 433                 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
 434                 qemu_co_mutex_unlock(&s->lock);
 435                 ret = bdrv_co_readv(bs->backing_hd, acb->sector_num,
 436                                     n1, &acb->hd_qiov);
 437                 qemu_co_mutex_lock(&s->lock);
 438                 if (ret < 0) {
 439                     return ret;
 440                 }
 441             }
 442         } else {
 443             /* Note: in this case, no need to wait */
 444             qemu_iovec_memset(&acb->hd_qiov, 0, 512 * cur_nr_sectors);
 445         }
 446     } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
 447         /* add AIO support for compressed blocks ? */
 448         ret = qcow2_decompress_cluster(bs, cluster_offset);
 449         if (ret < 0) {
 450             return ret;
 451         }
 452
 453         qemu_iovec_from_buffer(&acb->hd_qiov,
 454             s->cluster_cache + index_in_cluster * 512,
 455             512 * cur_nr_sectors);
 456     } else {
 457         if ((cluster_offset & 511) != 0) {
 458             return -EIO;
 459         }
 460
 461         if (s->crypt_method) {
 462             /*
 463              * For encrypted images, read everything into a temporary
 464              * contiguous buffer on which the AES functions can work.
 465              */
 466             if (!acb->cluster_data) {
 467                 acb->cluster_data =
 468                     g_malloc0(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
 469             }
 470
 471             assert(cur_nr_sectors <=
 472                 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
 473             qemu_iovec_reset(&acb->hd_qiov);
 474             qemu_iovec_add(&acb->hd_qiov, acb->cluster_data,
 475                 512 * cur_nr_sectors);
 476         }
 477
 478         BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 479         qemu_co_mutex_unlock(&s->lock);
 480         ret = bdrv_co_readv(bs->file,
 481                             (cluster_offset >> 9) + index_in_cluster,
 482                             cur_nr_sectors, &acb->hd_qiov);
 483         qemu_co_mutex_lock(&s->lock);
 484         if (ret < 0) {
 485             return ret;
 486         }
 487         if (s->crypt_method) {
 488             qcow2_encrypt_sectors(s, acb->sector_num,  acb->cluster_data,
 489                 acb->cluster_data, cur_nr_sectors, 0, &s->aes_decrypt_key);
 490             qemu_iovec_reset(&acb->hd_qiov);
 491             qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done,
 492                 cur_nr_sectors * 512);
 493             qemu_iovec_from_buffer(&acb->hd_qiov, acb->cluster_data,
 494                 512 * cur_nr_sectors);
 495         }
 496     }
 497
 498     acb->remaining_sectors -= cur_nr_sectors;
 499     acb->sector_num += cur_nr_sectors;
 500     acb->bytes_done += cur_nr_sectors * 512;
 501
 502     return 1;
 503 }
 504
 505 static QCowAIOCB *qcow2_aio_setup(BlockDriverState *bs, int64_t sector_num,
 506                                   QEMUIOVector *qiov, int nb_sectors,
 507                                   BlockDriverCompletionFunc *cb,
 508                                   void *opaque, QCowAIOCB *acb)
 509 {
 510     memset(acb, 0, sizeof(*acb));
 511     acb->bs = bs;
 512     acb->sector_num = sector_num;
 513     acb->qiov = qiov;
 514
 515     qemu_iovec_init(&acb->hd_qiov, qiov->niov);
 516
 517     acb->bytes_done = 0;
 518     acb->remaining_sectors = nb_sectors;
 519     return acb;
 520 }
 521
 522 static int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
 523                           int nb_sectors, QEMUIOVector *qiov)
 524 {
 525     BDRVQcowState *s = bs->opaque;
 526     QCowAIOCB acb;
 527     int ret;
 528
 529     qcow2_aio_setup(bs, sector_num, qiov, nb_sectors, NULL, NULL, &acb);
 530
 531     qemu_co_mutex_lock(&s->lock);
 532     do {
 533         ret = qcow2_aio_read_cb(&acb);
 534     } while (ret > 0);
 535     qemu_co_mutex_unlock(&s->lock);
 536
 537     qemu_iovec_destroy(&acb.hd_qiov);
 538
 539     return ret;
 540 }
 541
 542 static void run_dependent_requests(BDRVQcowState *s, QCowL2Meta *m)
 543 {
 544     /* Take the request off the list of running requests */
 545     if (m->nb_clusters != 0) {
 546         QLIST_REMOVE(m, next_in_flight);
 547     }
 548
 549     /* Restart all dependent requests */
 550     if (!qemu_co_queue_empty(&m->dependent_requests)) {
 551         qemu_co_mutex_unlock(&s->lock);
 552         while(qemu_co_queue_next(&m->dependent_requests));
 553         qemu_co_mutex_lock(&s->lock);
 554     }
 555 }
 556
 557 /*
 558  * Returns 0 when the request is completed successfully, 1 when there is still
 559  * a part left to do and -errno in error cases.
 560  */
 561 static int qcow2_aio_write_cb(QCowAIOCB *acb)
 562 {
 563     BlockDriverState *bs = acb->bs;
 564     BDRVQcowState *s = bs->opaque;
 565     int index_in_cluster;
 566     int n_end;
 567     int ret;
 568     int cur_nr_sectors; /* number of sectors in current iteration */
 569     QCowL2Meta l2meta;
 570     uint64_t cluster_offset;
 571
 572     l2meta.nb_clusters = 0;
 573     qemu_co_queue_init(&l2meta.dependent_requests);
 574
 575     if (acb->remaining_sectors == 0) {
 576         /* request completed */
 577         return 0;
 578     }
 579
 580     index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
 581     n_end = index_in_cluster + acb->remaining_sectors;
 582     if (s->crypt_method &&
 583         n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors)
 584         n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors;
 585
 586     ret = qcow2_alloc_cluster_offset(bs, acb->sector_num << 9,
 587         index_in_cluster, n_end, &cur_nr_sectors, &l2meta);
 588     if (ret < 0) {
 589         return ret;
 590     }
 591
 592     cluster_offset = l2meta.cluster_offset;
 593     assert((cluster_offset & 511) == 0);
 594
 595     qemu_iovec_reset(&acb->hd_qiov);
 596     qemu_iovec_copy(&acb->hd_qiov, acb->qiov, acb->bytes_done,
 597         cur_nr_sectors * 512);
 598
 599     if (s->crypt_method) {
 600         if (!acb->cluster_data) {
 601             acb->cluster_data = g_malloc0(QCOW_MAX_CRYPT_CLUSTERS *
 602                                              s->cluster_size);
 603         }
 604
 605         assert(acb->hd_qiov.size <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
 606         qemu_iovec_to_buffer(&acb->hd_qiov, acb->cluster_data);
 607
 608         qcow2_encrypt_sectors(s, acb->sector_num, acb->cluster_data,
 609             acb->cluster_data, cur_nr_sectors, 1, &s->aes_encrypt_key);
 610
 611         qemu_iovec_reset(&acb->hd_qiov);
 612         qemu_iovec_add(&acb->hd_qiov, acb->cluster_data,
 613             cur_nr_sectors * 512);
 614     }
 615
 616     BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
 617     qemu_co_mutex_unlock(&s->lock);
 618     ret = bdrv_co_writev(bs->file,
 619                          (cluster_offset >> 9) + index_in_cluster,
 620                          cur_nr_sectors, &acb->hd_qiov);
 621     qemu_co_mutex_lock(&s->lock);
 622     if (ret < 0) {
 623         return ret;
 624     }
 625
 626     ret = qcow2_alloc_cluster_link_l2(bs, &l2meta);
 627
 628     run_dependent_requests(s, &l2meta);
 629
 630     if (ret < 0) {
 631         return ret;
 632     }
 633
 634     acb->remaining_sectors -= cur_nr_sectors;
 635     acb->sector_num += cur_nr_sectors;
 636     acb->bytes_done += cur_nr_sectors * 512;
 637
 638     return 1;
 639 }
 640
 641 static int qcow2_co_writev(BlockDriverState *bs,
 642                            int64_t sector_num,
 643                            int nb_sectors,
 644                            QEMUIOVector *qiov)
 645 {
 646     BDRVQcowState *s = bs->opaque;
 647     QCowAIOCB acb;
 648     int ret;
 649
 650     qcow2_aio_setup(bs, sector_num, qiov, nb_sectors, NULL, NULL, &acb);
 651     s->cluster_cache_offset = -1; /* disable compressed cache */
 652
 653     qemu_co_mutex_lock(&s->lock);
 654     do {
 655         ret = qcow2_aio_write_cb(&acb);
 656     } while (ret > 0);
 657     qemu_co_mutex_unlock(&s->lock);
 658
 659     qemu_iovec_destroy(&acb.hd_qiov);
 660
 661     return ret;
 662 }
 663
 664 static void qcow2_close(BlockDriverState *bs)
 665 {
 666     BDRVQcowState *s = bs->opaque;
 667     g_free(s->l1_table);
 668
 669     qcow2_cache_flush(bs, s->l2_table_cache);
 670     qcow2_cache_flush(bs, s->refcount_block_cache);
 671
 672     qcow2_cache_destroy(bs, s->l2_table_cache);
 673     qcow2_cache_destroy(bs, s->refcount_block_cache);
 674
 675     g_free(s->cluster_cache);
 676     g_free(s->cluster_data);
 677     qcow2_refcount_close(bs);
 678 }
 679
 680 /*
 681  * Updates the variable length parts of the qcow2 header, i.e. the backing file
 682  * name and all extensions. qcow2 was not designed to allow such changes, so if
 683  * we run out of space (we can only use the first cluster) this function may
 684  * fail.
 685  *
 686  * Returns 0 on success, -errno in error cases.
 687  */
 688 static int qcow2_update_ext_header(BlockDriverState *bs,
 689     const char *backing_file, const char *backing_fmt)
 690 {
 691     size_t backing_file_len = 0;
 692     size_t backing_fmt_len = 0;
 693     BDRVQcowState *s = bs->opaque;
 694     QCowExtension ext_backing_fmt = {0, 0};
 695     int ret;
 696
 697     /* Backing file format doesn't make sense without a backing file */
 698     if (backing_fmt && !backing_file) {
 699         return -EINVAL;
 700     }
 701
 702     /* Prepare the backing file format extension if needed */
 703     if (backing_fmt) {
 704         ext_backing_fmt.len = cpu_to_be32(strlen(backing_fmt));
 705         ext_backing_fmt.magic = cpu_to_be32(QCOW2_EXT_MAGIC_BACKING_FORMAT);
 706         backing_fmt_len = ((sizeof(ext_backing_fmt)
 707             + strlen(backing_fmt) + 7) & ~7);
 708     }
 709
 710     /* Check if we can fit the new header into the first cluster */
 711     if (backing_file) {
 712         backing_file_len = strlen(backing_file);
 713     }
 714
 715     size_t header_size = sizeof(QCowHeader) + backing_file_len
 716         + backing_fmt_len;
 717
 718     if (header_size > s->cluster_size) {
 719         return -ENOSPC;
 720     }
 721
 722     /* Rewrite backing file name and qcow2 extensions */
 723     size_t ext_size = header_size - sizeof(QCowHeader);
 724     uint8_t buf[ext_size];
 725     size_t offset = 0;
 726     size_t backing_file_offset = 0;
 727
 728     if (backing_file) {
 729         if (backing_fmt) {
 730             int padding = backing_fmt_len -
 731                 (sizeof(ext_backing_fmt) + strlen(backing_fmt));
 732
 733             memcpy(buf + offset, &ext_backing_fmt, sizeof(ext_backing_fmt));
 734             offset += sizeof(ext_backing_fmt);
 735
 736             memcpy(buf + offset, backing_fmt, strlen(backing_fmt));
 737             offset += strlen(backing_fmt);
 738
 739             memset(buf + offset, 0, padding);
 740             offset += padding;
 741         }
 742
 743         memcpy(buf + offset, backing_file, backing_file_len);
 744         backing_file_offset = sizeof(QCowHeader) + offset;
 745     }
 746
 747     ret = bdrv_pwrite_sync(bs->file, sizeof(QCowHeader), buf, ext_size);
 748     if (ret < 0) {
 749         goto fail;
 750     }
 751
 752     /* Update header fields */
 753     uint64_t be_backing_file_offset = cpu_to_be64(backing_file_offset);
 754     uint32_t be_backing_file_size = cpu_to_be32(backing_file_len);
 755
 756     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_offset),
 757         &be_backing_file_offset, sizeof(uint64_t));
 758     if (ret < 0) {
 759         goto fail;
 760     }
 761
 762     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_size),
 763         &be_backing_file_size, sizeof(uint32_t));
 764     if (ret < 0) {
 765         goto fail;
 766     }
 767
 768     ret = 0;
 769 fail:
 770     return ret;
 771 }
 772
 773 static int qcow2_change_backing_file(BlockDriverState *bs,
 774     const char *backing_file, const char *backing_fmt)
 775 {
 776     return qcow2_update_ext_header(bs, backing_file, backing_fmt);
 777 }
 778
 779 static int preallocate(BlockDriverState *bs)
 780 {
 781     uint64_t nb_sectors;
 782     uint64_t offset;
 783     int num;
 784     int ret;
 785     QCowL2Meta meta;
 786
 787     nb_sectors = bdrv_getlength(bs) >> 9;
 788     offset = 0;
 789     qemu_co_queue_init(&meta.dependent_requests);
 790     meta.cluster_offset = 0;
 791
 792     while (nb_sectors) {
 793         num = MIN(nb_sectors, INT_MAX >> 9);
 794         ret = qcow2_alloc_cluster_offset(bs, offset, 0, num, &num, &meta);
 795         if (ret < 0) {
 796             return ret;
 797         }
 798
 799         ret = qcow2_alloc_cluster_link_l2(bs, &meta);
 800         if (ret < 0) {
 801             qcow2_free_any_clusters(bs, meta.cluster_offset, meta.nb_clusters);
 802             return ret;
 803         }
 804
 805         /* There are no dependent requests, but we need to remove our request
 806          * from the list of in-flight requests */
 807         run_dependent_requests(bs->opaque, &meta);
 808
 809         /* TODO Preallocate data if requested */
 810
 811         nb_sectors -= num;
 812         offset += num << 9;
 813     }
 814
 815     /*
 816      * It is expected that the image file is large enough to actually contain
 817      * all of the allocated clusters (otherwise we get failing reads after
 818      * EOF). Extend the image to the last allocated sector.
 819      */
 820     if (meta.cluster_offset != 0) {
 821         uint8_t buf[512];
 822         memset(buf, 0, 512);
 823         ret = bdrv_write(bs->file, (meta.cluster_offset >> 9) + num - 1, buf, 1);
 824         if (ret < 0) {
 825             return ret;
 826         }
 827     }
 828
 829     return 0;
 830 }
 831
 832 static int qcow2_create2(const char *filename, int64_t total_size,
 833                          const char *backing_file, const char *backing_format,
 834                          int flags, size_t cluster_size, int prealloc,
 835                          QEMUOptionParameter *options)
 836 {
 837     /* Calulate cluster_bits */
 838     int cluster_bits;
 839     cluster_bits = ffs(cluster_size) - 1;
 840     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
 841         (1 << cluster_bits) != cluster_size)
 842     {
 843         error_report(
 844             "Cluster size must be a power of two between %d and %dk",
 845             1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
 846         return -EINVAL;
 847     }
 848
 849     /*
 850      * Open the image file and write a minimal qcow2 header.
 851      *
 852      * We keep things simple and start with a zero-sized image. We also
 853      * do without refcount blocks or a L1 table for now. We'll fix the
 854      * inconsistency later.
 855      *
 856      * We do need a refcount table because growing the refcount table means
 857      * allocating two new refcount blocks - the seconds of which would be at
 858      * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
 859      * size for any qcow2 image.
 860      */
 861     BlockDriverState* bs;
 862     QCowHeader header;
 863     uint8_t* refcount_table;
 864     int ret;
 865
 866     ret = bdrv_create_file(filename, options);
 867     if (ret < 0) {
 868         return ret;
 869     }
 870
 871     ret = bdrv_file_open(&bs, filename, BDRV_O_RDWR);
 872     if (ret < 0) {
 873         return ret;
 874     }
 875
 876     /* Write the header */
 877     memset(&header, 0, sizeof(header));
 878     header.magic = cpu_to_be32(QCOW_MAGIC);
 879     header.version = cpu_to_be32(QCOW_VERSION);
 880     header.cluster_bits = cpu_to_be32(cluster_bits);
 881     header.size = cpu_to_be64(0);
 882     header.l1_table_offset = cpu_to_be64(0);
 883     header.l1_size = cpu_to_be32(0);
 884     header.refcount_table_offset = cpu_to_be64(cluster_size);
 885     header.refcount_table_clusters = cpu_to_be32(1);
 886
 887     if (flags & BLOCK_FLAG_ENCRYPT) {
 888         header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
 889     } else {
 890         header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
 891     }
 892
 893     ret = bdrv_pwrite(bs, 0, &header, sizeof(header));
 894     if (ret < 0) {
 895         goto out;
 896     }
 897
 898     /* Write an empty refcount table */
 899     refcount_table = g_malloc0(cluster_size);
 900     ret = bdrv_pwrite(bs, cluster_size, refcount_table, cluster_size);
 901     g_free(refcount_table);
 902
 903     if (ret < 0) {
 904         goto out;
 905     }
 906
 907     bdrv_close(bs);
 908
 909     /*
 910      * And now open the image and make it consistent first (i.e. increase the
 911      * refcount of the cluster that is occupied by the header and the refcount
 912      * table)
 913      */
 914     BlockDriver* drv = bdrv_find_format("qcow2");
 915     assert(drv != NULL);
 916     ret = bdrv_open(bs, filename,
 917         BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH, drv);
 918     if (ret < 0) {
 919         goto out;
 920     }
 921
 922     ret = qcow2_alloc_clusters(bs, 2 * cluster_size);
 923     if (ret < 0) {
 924         goto out;
 925
 926     } else if (ret != 0) {
 927         error_report("Huh, first cluster in empty image is already in use?");
 928         abort();
 929     }
 930
 931     /* Okay, now that we have a valid image, let's give it the right size */
 932     ret = bdrv_truncate(bs, total_size * BDRV_SECTOR_SIZE);
 933     if (ret < 0) {
 934         goto out;
 935     }
 936
 937     /* Want a backing file? There you go.*/
 938     if (backing_file) {
 939         ret = bdrv_change_backing_file(bs, backing_file, backing_format);
 940         if (ret < 0) {
 941             goto out;
 942         }
 943     }
 944
 945     /* And if we're supposed to preallocate metadata, do that now */
 946     if (prealloc) {
 947         ret = preallocate(bs);
 948         if (ret < 0) {
 949             goto out;
 950         }
 951     }
 952
 953     ret = 0;
 954 out:
 955     bdrv_delete(bs);
 956     return ret;
 957 }
 958
 959 static int qcow2_create(const char *filename, QEMUOptionParameter *options)
 960 {
 961     const char *backing_file = NULL;
 962     const char *backing_fmt = NULL;
 963     uint64_t sectors = 0;
 964     int flags = 0;
 965     size_t cluster_size = DEFAULT_CLUSTER_SIZE;
 966     int prealloc = 0;
 967
 968     /* Read out options */
 969     while (options && options->name) {
 970         if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
 971             sectors = options->value.n / 512;
 972         } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
 973             backing_file = options->value.s;
 974         } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) {
 975             backing_fmt = options->value.s;
 976         } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) {
 977             flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
 978         } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {
 979             if (options->value.n) {
 980                 cluster_size = options->value.n;
 981             }
 982         } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
 983             if (!options->value.s || !strcmp(options->value.s, "off")) {
 984                 prealloc = 0;
 985             } else if (!strcmp(options->value.s, "metadata")) {
 986                 prealloc = 1;
 987             } else {
 988                 fprintf(stderr, "Invalid preallocation mode: '%s'\n",
 989                     options->value.s);
 990                 return -EINVAL;
 991             }
 992         }
 993         options++;
 994     }
 995
 996     if (backing_file && prealloc) {
 997         fprintf(stderr, "Backing file and preallocation cannot be used at "
 998             "the same time\n");
 999         return -EINVAL;
1000     }
1001
1002     return qcow2_create2(filename, sectors, backing_file, backing_fmt, flags,
1003                          cluster_size, prealloc, options);
1004 }
1005
1006 static int qcow2_make_empty(BlockDriverState *bs)
1007 {
1008 #if 0
1009     /* XXX: not correct */
1010     BDRVQcowState *s = bs->opaque;
1011     uint32_t l1_length = s->l1_size * sizeof(uint64_t);
1012     int ret;
1013
1014     memset(s->l1_table, 0, l1_length);
1015     if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0)
1016         return -1;
1017     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);
1018     if (ret < 0)
1019         return ret;
1020
1021     l2_cache_reset(bs);
1022 #endif
1023     return 0;
1024 }
1025
1026 static int qcow2_discard(BlockDriverState *bs, int64_t sector_num,
1027     int nb_sectors)
1028 {
1029     return qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS,
1030         nb_sectors);
1031 }
1032
1033 static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
1034 {
1035     BDRVQcowState *s = bs->opaque;
1036     int ret, new_l1_size;
1037
1038     if (offset & 511) {
1039         return -EINVAL;
1040     }
1041
1042     /* cannot proceed if image has snapshots */
1043     if (s->nb_snapshots) {
1044         return -ENOTSUP;
1045     }
1046
1047     /* shrinking is currently not supported */
1048     if (offset < bs->total_sectors * 512) {
1049         return -ENOTSUP;
1050     }
1051
1052     new_l1_size = size_to_l1(s, offset);
1053     ret = qcow2_grow_l1_table(bs, new_l1_size, true);
1054     if (ret < 0) {
1055         return ret;
1056     }
1057
1058     /* write updated header.size */
1059     offset = cpu_to_be64(offset);
1060     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
1061                            &offset, sizeof(uint64_t));
1062     if (ret < 0) {
1063         return ret;
1064     }
1065
1066     s->l1_vm_state_index = new_l1_size;
1067     return 0;
1068 }
1069
1070 /* XXX: put compressed sectors first, then all the cluster aligned
1071    tables to avoid losing bytes in alignment */
1072 static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
1073                                   const uint8_t *buf, int nb_sectors)
1074 {
1075     BDRVQcowState *s = bs->opaque;
1076     z_stream strm;
1077     int ret, out_len;
1078     uint8_t *out_buf;
1079     uint64_t cluster_offset;
1080
1081     if (nb_sectors == 0) {
1082         /* align end of file to a sector boundary to ease reading with
1083            sector based I/Os */
1084         cluster_offset = bdrv_getlength(bs->file);
1085         cluster_offset = (cluster_offset + 511) & ~511;
1086         bdrv_truncate(bs->file, cluster_offset);
1087         return 0;
1088     }
1089
1090     if (nb_sectors != s->cluster_sectors)
1091         return -EINVAL;
1092
1093     out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
1094
1095     /* best compression, small window, no zlib header */
1096     memset(&strm, 0, sizeof(strm));
1097     ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
1098                        Z_DEFLATED, -12,
1099                        9, Z_DEFAULT_STRATEGY);
1100     if (ret != 0) {
1101         g_free(out_buf);
1102         return -1;
1103     }
1104
1105     strm.avail_in = s->cluster_size;
1106     strm.next_in = (uint8_t *)buf;
1107     strm.avail_out = s->cluster_size;
1108     strm.next_out = out_buf;
1109
1110     ret = deflate(&strm, Z_FINISH);
1111     if (ret != Z_STREAM_END && ret != Z_OK) {
1112         g_free(out_buf);
1113         deflateEnd(&strm);
1114         return -1;
1115     }
1116     out_len = strm.next_out - out_buf;
1117
1118     deflateEnd(&strm);
1119
1120     if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
1121         /* could not compress: write normal cluster */
1122         bdrv_write(bs, sector_num, buf, s->cluster_sectors);
1123     } else {
1124         cluster_offset = qcow2_alloc_compressed_cluster_offset(bs,
1125             sector_num << 9, out_len);
1126         if (!cluster_offset)
1127             return -1;
1128         cluster_offset &= s->cluster_offset_mask;
1129         BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
1130         if (bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len) != out_len) {
1131             g_free(out_buf);
1132             return -1;
1133         }
1134     }
1135
1136     g_free(out_buf);
1137     return 0;
1138 }
1139
1140 static int qcow2_flush(BlockDriverState *bs)
1141 {
1142     BDRVQcowState *s = bs->opaque;
1143     int ret;
1144
1145     ret = qcow2_cache_flush(bs, s->l2_table_cache);
1146     if (ret < 0) {
1147         return ret;
1148     }
1149
1150     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
1151     if (ret < 0) {
1152         return ret;
1153     }
1154
1155     return bdrv_flush(bs->file);
1156 }
1157
1158 static BlockDriverAIOCB *qcow2_aio_flush(BlockDriverState *bs,
1159                                          BlockDriverCompletionFunc *cb,
1160                                          void *opaque)
1161 {
1162     BDRVQcowState *s = bs->opaque;
1163     int ret;
1164
1165     ret = qcow2_cache_flush(bs, s->l2_table_cache);
1166     if (ret < 0) {
1167         return NULL;
1168     }
1169
1170     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
1171     if (ret < 0) {
1172         return NULL;
1173     }
1174
1175     return bdrv_aio_flush(bs->file, cb, opaque);
1176 }
1177
1178 static int64_t qcow2_vm_state_offset(BDRVQcowState *s)
1179 {
1180         return (int64_t)s->l1_vm_state_index << (s->cluster_bits + s->l2_bits);
1181 }
1182
1183 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1184 {
1185     BDRVQcowState *s = bs->opaque;
1186     bdi->cluster_size = s->cluster_size;
1187     bdi->vm_state_offset = qcow2_vm_state_offset(s);
1188     return 0;
1189 }
1190
1191
1192 static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result)
1193 {
1194     return qcow2_check_refcounts(bs, result);
1195 }
1196
1197 #if 0
1198 static void dump_refcounts(BlockDriverState *bs)
1199 {
1200     BDRVQcowState *s = bs->opaque;
1201     int64_t nb_clusters, k, k1, size;
1202     int refcount;
1203
1204     size = bdrv_getlength(bs->file);
1205     nb_clusters = size_to_clusters(s, size);
1206     for(k = 0; k < nb_clusters;) {
1207         k1 = k;
1208         refcount = get_refcount(bs, k);
1209         k++;
1210         while (k < nb_clusters && get_refcount(bs, k) == refcount)
1211             k++;
1212         printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount,
1213                k - k1);
1214     }
1215 }
1216 #endif
1217
1218 static int qcow2_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1219                               int64_t pos, int size)
1220 {
1221     BDRVQcowState *s = bs->opaque;
1222     int growable = bs->growable;
1223     int ret;
1224
1225     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
1226     bs->growable = 1;
1227     ret = bdrv_pwrite(bs, qcow2_vm_state_offset(s) + pos, buf, size);
1228     bs->growable = growable;
1229
1230     return ret;
1231 }
1232
1233 static int qcow2_load_vmstate(BlockDriverState *bs, 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_LOAD);
1241     bs->growable = 1;
1242     ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size);
1243     bs->growable = growable;
1244
1245     return ret;
1246 }
1247
1248 static QEMUOptionParameter qcow2_create_options[] = {
1249     {
1250         .name = BLOCK_OPT_SIZE,
1251         .type = OPT_SIZE,
1252         .help = "Virtual disk size"
1253     },
1254     {
1255         .name = BLOCK_OPT_BACKING_FILE,
1256         .type = OPT_STRING,
1257         .help = "File name of a base image"
1258     },
1259     {
1260         .name = BLOCK_OPT_BACKING_FMT,
1261         .type = OPT_STRING,
1262         .help = "Image format of the base image"
1263     },
1264     {
1265         .name = BLOCK_OPT_ENCRYPT,
1266         .type = OPT_FLAG,
1267         .help = "Encrypt the image"
1268     },
1269     {
1270         .name = BLOCK_OPT_CLUSTER_SIZE,
1271         .type = OPT_SIZE,
1272         .help = "qcow2 cluster size",
1273         .value = { .n = DEFAULT_CLUSTER_SIZE },
1274     },
1275     {
1276         .name = BLOCK_OPT_PREALLOC,
1277         .type = OPT_STRING,
1278         .help = "Preallocation mode (allowed values: off, metadata)"
1279     },
1280     { NULL }
1281 };
1282
1283 static BlockDriver bdrv_qcow2 = {
1284     .format_name        = "qcow2",
1285     .instance_size      = sizeof(BDRVQcowState),
1286     .bdrv_probe         = qcow2_probe,
1287     .bdrv_open          = qcow2_open,
1288     .bdrv_close         = qcow2_close,
1289     .bdrv_create        = qcow2_create,
1290     .bdrv_flush         = qcow2_flush,
1291     .bdrv_is_allocated  = qcow2_is_allocated,
1292     .bdrv_set_key       = qcow2_set_key,
1293     .bdrv_make_empty    = qcow2_make_empty,
1294
1295     .bdrv_co_readv      = qcow2_co_readv,
1296     .bdrv_co_writev     = qcow2_co_writev,
1297     .bdrv_aio_flush     = qcow2_aio_flush,
1298
1299     .bdrv_discard           = qcow2_discard,
1300     .bdrv_truncate          = qcow2_truncate,
1301     .bdrv_write_compressed  = qcow2_write_compressed,
1302
1303     .bdrv_snapshot_create   = qcow2_snapshot_create,
1304     .bdrv_snapshot_goto     = qcow2_snapshot_goto,
1305     .bdrv_snapshot_delete   = qcow2_snapshot_delete,
1306     .bdrv_snapshot_list     = qcow2_snapshot_list,
1307     .bdrv_snapshot_load_tmp     = qcow2_snapshot_load_tmp,
1308     .bdrv_get_info      = qcow2_get_info,
1309
1310     .bdrv_save_vmstate    = qcow2_save_vmstate,
1311     .bdrv_load_vmstate    = qcow2_load_vmstate,
1312
1313     .bdrv_change_backing_file   = qcow2_change_backing_file,
1314
1315     .create_options = qcow2_create_options,
1316     .bdrv_check = qcow2_check,
1317 };
1318
1319 static void bdrv_qcow2_init(void)
1320 {
1321     bdrv_register(&bdrv_qcow2);
1322 }
1323
1324 block_init(bdrv_qcow2_init);