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
  25 #include "qemu/osdep.h"
  26
  27 #include "block/qdict.h"
  28 #include "sysemu/block-backend.h"
  29 #include "qemu/module.h"
  30 #include "qcow2.h"
  31 #include "qemu/error-report.h"
  32 #include "qapi/error.h"
  33 #include "qapi/qapi-events-block-core.h"
  34 #include "qapi/qmp/qdict.h"
  35 #include "qapi/qmp/qstring.h"
  36 #include "trace.h"
  37 #include "qemu/option_int.h"
  38 #include "qemu/cutils.h"
  39 #include "qemu/bswap.h"
  40 #include "qapi/qobject-input-visitor.h"
  41 #include "qapi/qapi-visit-block-core.h"
  42 #include "crypto.h"
  43
  44 /*
  45   Differences with QCOW:
  46
  47   - Support for multiple incremental snapshots.
  48   - Memory management by reference counts.
  49   - Clusters which have a reference count of one have the bit
  50     QCOW_OFLAG_COPIED to optimize write performance.
  51   - Size of compressed clusters is stored in sectors to reduce bit usage
  52     in the cluster offsets.
  53   - Support for storing additional data (such as the VM state) in the
  54     snapshots.
  55   - If a backing store is used, the cluster size is not constrained
  56     (could be backported to QCOW).
  57   - L2 tables have always a size of one cluster.
  58 */
  59
  60
  61 typedef struct {
  62     uint32_t magic;
  63     uint32_t len;
  64 } QEMU_PACKED QCowExtension;
  65
  66 #define  QCOW2_EXT_MAGIC_END 0
  67 #define  QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
  68 #define  QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
  69 #define  QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
  70 #define  QCOW2_EXT_MAGIC_BITMAPS 0x23852875
  71 #define  QCOW2_EXT_MAGIC_DATA_FILE 0x44415441
  72
  73 static int coroutine_fn
  74 qcow2_co_preadv_compressed(BlockDriverState *bs,
  75                            uint64_t file_cluster_offset,
  76                            uint64_t offset,
  77                            uint64_t bytes,
  78                            QEMUIOVector *qiov);
  79
  80 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
  81 {
  82     const QCowHeader *cow_header = (const void *)buf;
  83
  84     if (buf_size >= sizeof(QCowHeader) &&
  85         be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
  86         be32_to_cpu(cow_header->version) >= 2)
  87         return 100;
  88     else
  89         return 0;
  90 }
  91
  92
  93 static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
  94                                           uint8_t *buf, size_t buflen,
  95                                           void *opaque, Error **errp)
  96 {
  97     BlockDriverState *bs = opaque;
  98     BDRVQcow2State *s = bs->opaque;
  99     ssize_t ret;
 100
 101     if ((offset + buflen) > s->crypto_header.length) {
 102         error_setg(errp, "Request for data outside of extension header");
 103         return -1;
 104     }
 105
 106     ret = bdrv_pread(bs->file,
 107                      s->crypto_header.offset + offset, buf, buflen);
 108     if (ret < 0) {
 109         error_setg_errno(errp, -ret, "Could not read encryption header");
 110         return -1;
 111     }
 112     return ret;
 113 }
 114
 115
 116 static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
 117                                           void *opaque, Error **errp)
 118 {
 119     BlockDriverState *bs = opaque;
 120     BDRVQcow2State *s = bs->opaque;
 121     int64_t ret;
 122     int64_t clusterlen;
 123
 124     ret = qcow2_alloc_clusters(bs, headerlen);
 125     if (ret < 0) {
 126         error_setg_errno(errp, -ret,
 127                          "Cannot allocate cluster for LUKS header size %zu",
 128                          headerlen);
 129         return -1;
 130     }
 131
 132     s->crypto_header.length = headerlen;
 133     s->crypto_header.offset = ret;
 134
 135     /* Zero fill remaining space in cluster so it has predictable
 136      * content in case of future spec changes */
 137     clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
 138     assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
 139     ret = bdrv_pwrite_zeroes(bs->file,
 140                              ret + headerlen,
 141                              clusterlen - headerlen, 0);
 142     if (ret < 0) {
 143         error_setg_errno(errp, -ret, "Could not zero fill encryption header");
 144         return -1;
 145     }
 146
 147     return ret;
 148 }
 149
 150
 151 static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
 152                                            const uint8_t *buf, size_t buflen,
 153                                            void *opaque, Error **errp)
 154 {
 155     BlockDriverState *bs = opaque;
 156     BDRVQcow2State *s = bs->opaque;
 157     ssize_t ret;
 158
 159     if ((offset + buflen) > s->crypto_header.length) {
 160         error_setg(errp, "Request for data outside of extension header");
 161         return -1;
 162     }
 163
 164     ret = bdrv_pwrite(bs->file,
 165                       s->crypto_header.offset + offset, buf, buflen);
 166     if (ret < 0) {
 167         error_setg_errno(errp, -ret, "Could not read encryption header");
 168         return -1;
 169     }
 170     return ret;
 171 }
 172
 173
 174 /*
 175  * read qcow2 extension and fill bs
 176  * start reading from start_offset
 177  * finish reading upon magic of value 0 or when end_offset reached
 178  * unknown magic is skipped (future extension this version knows nothing about)
 179  * return 0 upon success, non-0 otherwise
 180  */
 181 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
 182                                  uint64_t end_offset, void **p_feature_table,
 183                                  int flags, bool *need_update_header,
 184                                  Error **errp)
 185 {
 186     BDRVQcow2State *s = bs->opaque;
 187     QCowExtension ext;
 188     uint64_t offset;
 189     int ret;
 190     Qcow2BitmapHeaderExt bitmaps_ext;
 191
 192     if (need_update_header != NULL) {
 193         *need_update_header = false;
 194     }
 195
 196 #ifdef DEBUG_EXT
 197     printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
 198 #endif
 199     offset = start_offset;
 200     while (offset < end_offset) {
 201
 202 #ifdef DEBUG_EXT
 203         /* Sanity check */
 204         if (offset > s->cluster_size)
 205             printf("qcow2_read_extension: suspicious offset %lu\n", offset);
 206
 207         printf("attempting to read extended header in offset %lu\n", offset);
 208 #endif
 209
 210         ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext));
 211         if (ret < 0) {
 212             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
 213                              "pread fail from offset %" PRIu64, offset);
 214             return 1;
 215         }
 216         ext.magic = be32_to_cpu(ext.magic);
 217         ext.len = be32_to_cpu(ext.len);
 218         offset += sizeof(ext);
 219 #ifdef DEBUG_EXT
 220         printf("ext.magic = 0x%x\n", ext.magic);
 221 #endif
 222         if (offset > end_offset || ext.len > end_offset - offset) {
 223             error_setg(errp, "Header extension too large");
 224             return -EINVAL;
 225         }
 226
 227         switch (ext.magic) {
 228         case QCOW2_EXT_MAGIC_END:
 229             return 0;
 230
 231         case QCOW2_EXT_MAGIC_BACKING_FORMAT:
 232             if (ext.len >= sizeof(bs->backing_format)) {
 233                 error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
 234                            " too large (>=%zu)", ext.len,
 235                            sizeof(bs->backing_format));
 236                 return 2;
 237             }
 238             ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len);
 239             if (ret < 0) {
 240                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
 241                                  "Could not read format name");
 242                 return 3;
 243             }
 244             bs->backing_format[ext.len] = '\0';
 245             s->image_backing_format = g_strdup(bs->backing_format);
 246 #ifdef DEBUG_EXT
 247             printf("Qcow2: Got format extension %s\n", bs->backing_format);
 248 #endif
 249             break;
 250
 251         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
 252             if (p_feature_table != NULL) {
 253                 void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
 254                 ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
 255                 if (ret < 0) {
 256                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
 257                                      "Could not read table");
 258                     return ret;
 259                 }
 260
 261                 *p_feature_table = feature_table;
 262             }
 263             break;
 264
 265         case QCOW2_EXT_MAGIC_CRYPTO_HEADER: {
 266             unsigned int cflags = 0;
 267             if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
 268                 error_setg(errp, "CRYPTO header extension only "
 269                            "expected with LUKS encryption method");
 270                 return -EINVAL;
 271             }
 272             if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) {
 273                 error_setg(errp, "CRYPTO header extension size %u, "
 274                            "but expected size %zu", ext.len,
 275                            sizeof(Qcow2CryptoHeaderExtension));
 276                 return -EINVAL;
 277             }
 278
 279             ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len);
 280             if (ret < 0) {
 281                 error_setg_errno(errp, -ret,
 282                                  "Unable to read CRYPTO header extension");
 283                 return ret;
 284             }
 285             s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
 286             s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
 287
 288             if ((s->crypto_header.offset % s->cluster_size) != 0) {
 289                 error_setg(errp, "Encryption header offset '%" PRIu64 "' is "
 290                            "not a multiple of cluster size '%u'",
 291                            s->crypto_header.offset, s->cluster_size);
 292                 return -EINVAL;
 293             }
 294
 295             if (flags & BDRV_O_NO_IO) {
 296                 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
 297             }
 298             s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
 299                                            qcow2_crypto_hdr_read_func,
 300                                            bs, cflags, 1, errp);
 301             if (!s->crypto) {
 302                 return -EINVAL;
 303             }
 304         }   break;
 305
 306         case QCOW2_EXT_MAGIC_BITMAPS:
 307             if (ext.len != sizeof(bitmaps_ext)) {
 308                 error_setg_errno(errp, -ret, "bitmaps_ext: "
 309                                  "Invalid extension length");
 310                 return -EINVAL;
 311             }
 312
 313             if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) {
 314                 if (s->qcow_version < 3) {
 315                     /* Let's be a bit more specific */
 316                     warn_report("This qcow2 v2 image contains bitmaps, but "
 317                                 "they may have been modified by a program "
 318                                 "without persistent bitmap support; so now "
 319                                 "they must all be considered inconsistent");
 320                 } else {
 321                     warn_report("a program lacking bitmap support "
 322                                 "modified this file, so all bitmaps are now "
 323                                 "considered inconsistent");
 324                 }
 325                 error_printf("Some clusters may be leaked, "
 326                              "run 'qemu-img check -r' on the image "
 327                              "file to fix.");
 328                 if (need_update_header != NULL) {
 329                     /* Updating is needed to drop invalid bitmap extension. */
 330                     *need_update_header = true;
 331                 }
 332                 break;
 333             }
 334
 335             ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len);
 336             if (ret < 0) {
 337                 error_setg_errno(errp, -ret, "bitmaps_ext: "
 338                                  "Could not read ext header");
 339                 return ret;
 340             }
 341
 342             if (bitmaps_ext.reserved32 != 0) {
 343                 error_setg_errno(errp, -ret, "bitmaps_ext: "
 344                                  "Reserved field is not zero");
 345                 return -EINVAL;
 346             }
 347
 348             bitmaps_ext.nb_bitmaps = be32_to_cpu(bitmaps_ext.nb_bitmaps);
 349             bitmaps_ext.bitmap_directory_size =
 350                 be64_to_cpu(bitmaps_ext.bitmap_directory_size);
 351             bitmaps_ext.bitmap_directory_offset =
 352                 be64_to_cpu(bitmaps_ext.bitmap_directory_offset);
 353
 354             if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) {
 355                 error_setg(errp,
 356                            "bitmaps_ext: Image has %" PRIu32 " bitmaps, "
 357                            "exceeding the QEMU supported maximum of %d",
 358                            bitmaps_ext.nb_bitmaps, QCOW2_MAX_BITMAPS);
 359                 return -EINVAL;
 360             }
 361
 362             if (bitmaps_ext.nb_bitmaps == 0) {
 363                 error_setg(errp, "found bitmaps extension with zero bitmaps");
 364                 return -EINVAL;
 365             }
 366
 367             if (bitmaps_ext.bitmap_directory_offset & (s->cluster_size - 1)) {
 368                 error_setg(errp, "bitmaps_ext: "
 369                                  "invalid bitmap directory offset");
 370                 return -EINVAL;
 371             }
 372
 373             if (bitmaps_ext.bitmap_directory_size >
 374                 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
 375                 error_setg(errp, "bitmaps_ext: "
 376                                  "bitmap directory size (%" PRIu64 ") exceeds "
 377                                  "the maximum supported size (%d)",
 378                                  bitmaps_ext.bitmap_directory_size,
 379                                  QCOW2_MAX_BITMAP_DIRECTORY_SIZE);
 380                 return -EINVAL;
 381             }
 382
 383             s->nb_bitmaps = bitmaps_ext.nb_bitmaps;
 384             s->bitmap_directory_offset =
 385                     bitmaps_ext.bitmap_directory_offset;
 386             s->bitmap_directory_size =
 387                     bitmaps_ext.bitmap_directory_size;
 388
 389 #ifdef DEBUG_EXT
 390             printf("Qcow2: Got bitmaps extension: "
 391                    "offset=%" PRIu64 " nb_bitmaps=%" PRIu32 "\n",
 392                    s->bitmap_directory_offset, s->nb_bitmaps);
 393 #endif
 394             break;
 395
 396         case QCOW2_EXT_MAGIC_DATA_FILE:
 397         {
 398             s->image_data_file = g_malloc0(ext.len + 1);
 399             ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len);
 400             if (ret < 0) {
 401                 error_setg_errno(errp, -ret,
 402                                  "ERROR: Could not read data file name");
 403                 return ret;
 404             }
 405 #ifdef DEBUG_EXT
 406             printf("Qcow2: Got external data file %s\n", s->image_data_file);
 407 #endif
 408             break;
 409         }
 410
 411         default:
 412             /* unknown magic - save it in case we need to rewrite the header */
 413             /* If you add a new feature, make sure to also update the fast
 414              * path of qcow2_make_empty() to deal with it. */
 415             {
 416                 Qcow2UnknownHeaderExtension *uext;
 417
 418                 uext = g_malloc0(sizeof(*uext)  + ext.len);
 419                 uext->magic = ext.magic;
 420                 uext->len = ext.len;
 421                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
 422
 423                 ret = bdrv_pread(bs->file, offset , uext->data, uext->len);
 424                 if (ret < 0) {
 425                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
 426                                      "Could not read data");
 427                     return ret;
 428                 }
 429             }
 430             break;
 431         }
 432
 433         offset += ((ext.len + 7) & ~7);
 434     }
 435
 436     return 0;
 437 }
 438
 439 static void cleanup_unknown_header_ext(BlockDriverState *bs)
 440 {
 441     BDRVQcow2State *s = bs->opaque;
 442     Qcow2UnknownHeaderExtension *uext, *next;
 443
 444     QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
 445         QLIST_REMOVE(uext, next);
 446         g_free(uext);
 447     }
 448 }
 449
 450 static void report_unsupported_feature(Error **errp, Qcow2Feature *table,
 451                                        uint64_t mask)
 452 {
 453     char *features = g_strdup("");
 454     char *old;
 455
 456     while (table && table->name[0] != '\0') {
 457         if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
 458             if (mask & (1ULL << table->bit)) {
 459                 old = features;
 460                 features = g_strdup_printf("%s%s%.46s", old, *old ? ", " : "",
 461                                            table->name);
 462                 g_free(old);
 463                 mask &= ~(1ULL << table->bit);
 464             }
 465         }
 466         table++;
 467     }
 468
 469     if (mask) {
 470         old = features;
 471         features = g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64,
 472                                    old, *old ? ", " : "", mask);
 473         g_free(old);
 474     }
 475
 476     error_setg(errp, "Unsupported qcow2 feature(s): %s", features);
 477     g_free(features);
 478 }
 479
 480 /*
 481  * Sets the dirty bit and flushes afterwards if necessary.
 482  *
 483  * The incompatible_features bit is only set if the image file header was
 484  * updated successfully.  Therefore it is not required to check the return
 485  * value of this function.
 486  */
 487 int qcow2_mark_dirty(BlockDriverState *bs)
 488 {
 489     BDRVQcow2State *s = bs->opaque;
 490     uint64_t val;
 491     int ret;
 492
 493     assert(s->qcow_version >= 3);
 494
 495     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
 496         return 0; /* already dirty */
 497     }
 498
 499     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
 500     ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
 501                       &val, sizeof(val));
 502     if (ret < 0) {
 503         return ret;
 504     }
 505     ret = bdrv_flush(bs->file->bs);
 506     if (ret < 0) {
 507         return ret;
 508     }
 509
 510     /* Only treat image as dirty if the header was updated successfully */
 511     s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
 512     return 0;
 513 }
 514
 515 /*
 516  * Clears the dirty bit and flushes before if necessary.  Only call this
 517  * function when there are no pending requests, it does not guard against
 518  * concurrent requests dirtying the image.
 519  */
 520 static int qcow2_mark_clean(BlockDriverState *bs)
 521 {
 522     BDRVQcow2State *s = bs->opaque;
 523
 524     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
 525         int ret;
 526
 527         s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;
 528
 529         ret = qcow2_flush_caches(bs);
 530         if (ret < 0) {
 531             return ret;
 532         }
 533
 534         return qcow2_update_header(bs);
 535     }
 536     return 0;
 537 }
 538
 539 /*
 540  * Marks the image as corrupt.
 541  */
 542 int qcow2_mark_corrupt(BlockDriverState *bs)
 543 {
 544     BDRVQcow2State *s = bs->opaque;
 545
 546     s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
 547     return qcow2_update_header(bs);
 548 }
 549
 550 /*
 551  * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
 552  * before if necessary.
 553  */
 554 int qcow2_mark_consistent(BlockDriverState *bs)
 555 {
 556     BDRVQcow2State *s = bs->opaque;
 557
 558     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
 559         int ret = qcow2_flush_caches(bs);
 560         if (ret < 0) {
 561             return ret;
 562         }
 563
 564         s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT;
 565         return qcow2_update_header(bs);
 566     }
 567     return 0;
 568 }
 569
 570 static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs,
 571                                               BdrvCheckResult *result,
 572                                               BdrvCheckMode fix)
 573 {
 574     int ret = qcow2_check_refcounts(bs, result, fix);
 575     if (ret < 0) {
 576         return ret;
 577     }
 578
 579     if (fix && result->check_errors == 0 && result->corruptions == 0) {
 580         ret = qcow2_mark_clean(bs);
 581         if (ret < 0) {
 582             return ret;
 583         }
 584         return qcow2_mark_consistent(bs);
 585     }
 586     return ret;
 587 }
 588
 589 static int coroutine_fn qcow2_co_check(BlockDriverState *bs,
 590                                        BdrvCheckResult *result,
 591                                        BdrvCheckMode fix)
 592 {
 593     BDRVQcow2State *s = bs->opaque;
 594     int ret;
 595
 596     qemu_co_mutex_lock(&s->lock);
 597     ret = qcow2_co_check_locked(bs, result, fix);
 598     qemu_co_mutex_unlock(&s->lock);
 599     return ret;
 600 }
 601
 602 int qcow2_validate_table(BlockDriverState *bs, uint64_t offset,
 603                          uint64_t entries, size_t entry_len,
 604                          int64_t max_size_bytes, const char *table_name,
 605                          Error **errp)
 606 {
 607     BDRVQcow2State *s = bs->opaque;
 608
 609     if (entries > max_size_bytes / entry_len) {
 610         error_setg(errp, "%s too large", table_name);
 611         return -EFBIG;
 612     }
 613
 614     /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
 615      * because values will be passed to qemu functions taking int64_t. */
 616     if ((INT64_MAX - entries * entry_len < offset) ||
 617         (offset_into_cluster(s, offset) != 0)) {
 618         error_setg(errp, "%s offset invalid", table_name);
 619         return -EINVAL;
 620     }
 621
 622     return 0;
 623 }
 624
 625 static const char *const mutable_opts[] = {
 626     QCOW2_OPT_LAZY_REFCOUNTS,
 627     QCOW2_OPT_DISCARD_REQUEST,
 628     QCOW2_OPT_DISCARD_SNAPSHOT,
 629     QCOW2_OPT_DISCARD_OTHER,
 630     QCOW2_OPT_OVERLAP,
 631     QCOW2_OPT_OVERLAP_TEMPLATE,
 632     QCOW2_OPT_OVERLAP_MAIN_HEADER,
 633     QCOW2_OPT_OVERLAP_ACTIVE_L1,
 634     QCOW2_OPT_OVERLAP_ACTIVE_L2,
 635     QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
 636     QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
 637     QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
 638     QCOW2_OPT_OVERLAP_INACTIVE_L1,
 639     QCOW2_OPT_OVERLAP_INACTIVE_L2,
 640     QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
 641     QCOW2_OPT_CACHE_SIZE,
 642     QCOW2_OPT_L2_CACHE_SIZE,
 643     QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
 644     QCOW2_OPT_REFCOUNT_CACHE_SIZE,
 645     QCOW2_OPT_CACHE_CLEAN_INTERVAL,
 646     NULL
 647 };
 648
 649 static QemuOptsList qcow2_runtime_opts = {
 650     .name = "qcow2",
 651     .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
 652     .desc = {
 653         {
 654             .name = QCOW2_OPT_LAZY_REFCOUNTS,
 655             .type = QEMU_OPT_BOOL,
 656             .help = "Postpone refcount updates",
 657         },
 658         {
 659             .name = QCOW2_OPT_DISCARD_REQUEST,
 660             .type = QEMU_OPT_BOOL,
 661             .help = "Pass guest discard requests to the layer below",
 662         },
 663         {
 664             .name = QCOW2_OPT_DISCARD_SNAPSHOT,
 665             .type = QEMU_OPT_BOOL,
 666             .help = "Generate discard requests when snapshot related space "
 667                     "is freed",
 668         },
 669         {
 670             .name = QCOW2_OPT_DISCARD_OTHER,
 671             .type = QEMU_OPT_BOOL,
 672             .help = "Generate discard requests when other clusters are freed",
 673         },
 674         {
 675             .name = QCOW2_OPT_OVERLAP,
 676             .type = QEMU_OPT_STRING,
 677             .help = "Selects which overlap checks to perform from a range of "
 678                     "templates (none, constant, cached, all)",
 679         },
 680         {
 681             .name = QCOW2_OPT_OVERLAP_TEMPLATE,
 682             .type = QEMU_OPT_STRING,
 683             .help = "Selects which overlap checks to perform from a range of "
 684                     "templates (none, constant, cached, all)",
 685         },
 686         {
 687             .name = QCOW2_OPT_OVERLAP_MAIN_HEADER,
 688             .type = QEMU_OPT_BOOL,
 689             .help = "Check for unintended writes into the main qcow2 header",
 690         },
 691         {
 692             .name = QCOW2_OPT_OVERLAP_ACTIVE_L1,
 693             .type = QEMU_OPT_BOOL,
 694             .help = "Check for unintended writes into the active L1 table",
 695         },
 696         {
 697             .name = QCOW2_OPT_OVERLAP_ACTIVE_L2,
 698             .type = QEMU_OPT_BOOL,
 699             .help = "Check for unintended writes into an active L2 table",
 700         },
 701         {
 702             .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
 703             .type = QEMU_OPT_BOOL,
 704             .help = "Check for unintended writes into the refcount table",
 705         },
 706         {
 707             .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
 708             .type = QEMU_OPT_BOOL,
 709             .help = "Check for unintended writes into a refcount block",
 710         },
 711         {
 712             .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
 713             .type = QEMU_OPT_BOOL,
 714             .help = "Check for unintended writes into the snapshot table",
 715         },
 716         {
 717             .name = QCOW2_OPT_OVERLAP_INACTIVE_L1,
 718             .type = QEMU_OPT_BOOL,
 719             .help = "Check for unintended writes into an inactive L1 table",
 720         },
 721         {
 722             .name = QCOW2_OPT_OVERLAP_INACTIVE_L2,
 723             .type = QEMU_OPT_BOOL,
 724             .help = "Check for unintended writes into an inactive L2 table",
 725         },
 726         {
 727             .name = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
 728             .type = QEMU_OPT_BOOL,
 729             .help = "Check for unintended writes into the bitmap directory",
 730         },
 731         {
 732             .name = QCOW2_OPT_CACHE_SIZE,
 733             .type = QEMU_OPT_SIZE,
 734             .help = "Maximum combined metadata (L2 tables and refcount blocks) "
 735                     "cache size",
 736         },
 737         {
 738             .name = QCOW2_OPT_L2_CACHE_SIZE,
 739             .type = QEMU_OPT_SIZE,
 740             .help = "Maximum L2 table cache size",
 741         },
 742         {
 743             .name = QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
 744             .type = QEMU_OPT_SIZE,
 745             .help = "Size of each entry in the L2 cache",
 746         },
 747         {
 748             .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE,
 749             .type = QEMU_OPT_SIZE,
 750             .help = "Maximum refcount block cache size",
 751         },
 752         {
 753             .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
 754             .type = QEMU_OPT_NUMBER,
 755             .help = "Clean unused cache entries after this time (in seconds)",
 756         },
 757         BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
 758             "ID of secret providing qcow2 AES key or LUKS passphrase"),
 759         { /* end of list */ }
 760     },
 761 };
 762
 763 static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
 764     [QCOW2_OL_MAIN_HEADER_BITNR]      = QCOW2_OPT_OVERLAP_MAIN_HEADER,
 765     [QCOW2_OL_ACTIVE_L1_BITNR]        = QCOW2_OPT_OVERLAP_ACTIVE_L1,
 766     [QCOW2_OL_ACTIVE_L2_BITNR]        = QCOW2_OPT_OVERLAP_ACTIVE_L2,
 767     [QCOW2_OL_REFCOUNT_TABLE_BITNR]   = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
 768     [QCOW2_OL_REFCOUNT_BLOCK_BITNR]   = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
 769     [QCOW2_OL_SNAPSHOT_TABLE_BITNR]   = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
 770     [QCOW2_OL_INACTIVE_L1_BITNR]      = QCOW2_OPT_OVERLAP_INACTIVE_L1,
 771     [QCOW2_OL_INACTIVE_L2_BITNR]      = QCOW2_OPT_OVERLAP_INACTIVE_L2,
 772     [QCOW2_OL_BITMAP_DIRECTORY_BITNR] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
 773 };
 774
 775 static void cache_clean_timer_cb(void *opaque)
 776 {
 777     BlockDriverState *bs = opaque;
 778     BDRVQcow2State *s = bs->opaque;
 779     qcow2_cache_clean_unused(s->l2_table_cache);
 780     qcow2_cache_clean_unused(s->refcount_block_cache);
 781     timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
 782               (int64_t) s->cache_clean_interval * 1000);
 783 }
 784
 785 static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
 786 {
 787     BDRVQcow2State *s = bs->opaque;
 788     if (s->cache_clean_interval > 0) {
 789         s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL,
 790                                              SCALE_MS, cache_clean_timer_cb,
 791                                              bs);
 792         timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
 793                   (int64_t) s->cache_clean_interval * 1000);
 794     }
 795 }
 796
 797 static void cache_clean_timer_del(BlockDriverState *bs)
 798 {
 799     BDRVQcow2State *s = bs->opaque;
 800     if (s->cache_clean_timer) {
 801         timer_del(s->cache_clean_timer);
 802         timer_free(s->cache_clean_timer);
 803         s->cache_clean_timer = NULL;
 804     }
 805 }
 806
 807 static void qcow2_detach_aio_context(BlockDriverState *bs)
 808 {
 809     cache_clean_timer_del(bs);
 810 }
 811
 812 static void qcow2_attach_aio_context(BlockDriverState *bs,
 813                                      AioContext *new_context)
 814 {
 815     cache_clean_timer_init(bs, new_context);
 816 }
 817
 818 static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
 819                              uint64_t *l2_cache_size,
 820                              uint64_t *l2_cache_entry_size,
 821                              uint64_t *refcount_cache_size, Error **errp)
 822 {
 823     BDRVQcow2State *s = bs->opaque;
 824     uint64_t combined_cache_size, l2_cache_max_setting;
 825     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
 826     bool l2_cache_entry_size_set;
 827     int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
 828     uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
 829     uint64_t max_l2_cache = virtual_disk_size / (s->cluster_size / 8);
 830
 831     combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
 832     l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
 833     refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
 834     l2_cache_entry_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE);
 835
 836     combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0);
 837     l2_cache_max_setting = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE,
 838                                              DEFAULT_L2_CACHE_MAX_SIZE);
 839     *refcount_cache_size = qemu_opt_get_size(opts,
 840                                              QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0);
 841
 842     *l2_cache_entry_size = qemu_opt_get_size(
 843         opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE, s->cluster_size);
 844
 845     *l2_cache_size = MIN(max_l2_cache, l2_cache_max_setting);
 846
 847     if (combined_cache_size_set) {
 848         if (l2_cache_size_set && refcount_cache_size_set) {
 849             error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE
 850                        " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set "
 851                        "at the same time");
 852             return;
 853         } else if (l2_cache_size_set &&
 854                    (l2_cache_max_setting > combined_cache_size)) {
 855             error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed "
 856                        QCOW2_OPT_CACHE_SIZE);
 857             return;
 858         } else if (*refcount_cache_size > combined_cache_size) {
 859             error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed "
 860                        QCOW2_OPT_CACHE_SIZE);
 861             return;
 862         }
 863
 864         if (l2_cache_size_set) {
 865             *refcount_cache_size = combined_cache_size - *l2_cache_size;
 866         } else if (refcount_cache_size_set) {
 867             *l2_cache_size = combined_cache_size - *refcount_cache_size;
 868         } else {
 869             /* Assign as much memory as possible to the L2 cache, and
 870              * use the remainder for the refcount cache */
 871             if (combined_cache_size >= max_l2_cache + min_refcount_cache) {
 872                 *l2_cache_size = max_l2_cache;
 873                 *refcount_cache_size = combined_cache_size - *l2_cache_size;
 874             } else {
 875                 *refcount_cache_size =
 876                     MIN(combined_cache_size, min_refcount_cache);
 877                 *l2_cache_size = combined_cache_size - *refcount_cache_size;
 878             }
 879         }
 880     }
 881
 882     /*
 883      * If the L2 cache is not enough to cover the whole disk then
 884      * default to 4KB entries. Smaller entries reduce the cost of
 885      * loads and evictions and increase I/O performance.
 886      */
 887     if (*l2_cache_size < max_l2_cache && !l2_cache_entry_size_set) {
 888         *l2_cache_entry_size = MIN(s->cluster_size, 4096);
 889     }
 890
 891     /* l2_cache_size and refcount_cache_size are ensured to have at least
 892      * their minimum values in qcow2_update_options_prepare() */
 893
 894     if (*l2_cache_entry_size < (1 << MIN_CLUSTER_BITS) ||
 895         *l2_cache_entry_size > s->cluster_size ||
 896         !is_power_of_2(*l2_cache_entry_size)) {
 897         error_setg(errp, "L2 cache entry size must be a power of two "
 898                    "between %d and the cluster size (%d)",
 899                    1 << MIN_CLUSTER_BITS, s->cluster_size);
 900         return;
 901     }
 902 }
 903
 904 typedef struct Qcow2ReopenState {
 905     Qcow2Cache *l2_table_cache;
 906     Qcow2Cache *refcount_block_cache;
 907     int l2_slice_size; /* Number of entries in a slice of the L2 table */
 908     bool use_lazy_refcounts;
 909     int overlap_check;
 910     bool discard_passthrough[QCOW2_DISCARD_MAX];
 911     uint64_t cache_clean_interval;
 912     QCryptoBlockOpenOptions *crypto_opts; /* Disk encryption runtime options */
 913 } Qcow2ReopenState;
 914
 915 static int qcow2_update_options_prepare(BlockDriverState *bs,
 916                                         Qcow2ReopenState *r,
 917                                         QDict *options, int flags,
 918                                         Error **errp)
 919 {
 920     BDRVQcow2State *s = bs->opaque;
 921     QemuOpts *opts = NULL;
 922     const char *opt_overlap_check, *opt_overlap_check_template;
 923     int overlap_check_template = 0;
 924     uint64_t l2_cache_size, l2_cache_entry_size, refcount_cache_size;
 925     int i;
 926     const char *encryptfmt;
 927     QDict *encryptopts = NULL;
 928     Error *local_err = NULL;
 929     int ret;
 930
 931     qdict_extract_subqdict(options, &encryptopts, "encrypt.");
 932     encryptfmt = qdict_get_try_str(encryptopts, "format");
 933
 934     opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
 935     qemu_opts_absorb_qdict(opts, options, &local_err);
 936     if (local_err) {
 937         error_propagate(errp, local_err);
 938         ret = -EINVAL;
 939         goto fail;
 940     }
 941
 942     /* get L2 table/refcount block cache size from command line options */
 943     read_cache_sizes(bs, opts, &l2_cache_size, &l2_cache_entry_size,
 944                      &refcount_cache_size, &local_err);
 945     if (local_err) {
 946         error_propagate(errp, local_err);
 947         ret = -EINVAL;
 948         goto fail;
 949     }
 950
 951     l2_cache_size /= l2_cache_entry_size;
 952     if (l2_cache_size < MIN_L2_CACHE_SIZE) {
 953         l2_cache_size = MIN_L2_CACHE_SIZE;
 954     }
 955     if (l2_cache_size > INT_MAX) {
 956         error_setg(errp, "L2 cache size too big");
 957         ret = -EINVAL;
 958         goto fail;
 959     }
 960
 961     refcount_cache_size /= s->cluster_size;
 962     if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
 963         refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
 964     }
 965     if (refcount_cache_size > INT_MAX) {
 966         error_setg(errp, "Refcount cache size too big");
 967         ret = -EINVAL;
 968         goto fail;
 969     }
 970
 971     /* alloc new L2 table/refcount block cache, flush old one */
 972     if (s->l2_table_cache) {
 973         ret = qcow2_cache_flush(bs, s->l2_table_cache);
 974         if (ret) {
 975             error_setg_errno(errp, -ret, "Failed to flush the L2 table cache");
 976             goto fail;
 977         }
 978     }
 979
 980     if (s->refcount_block_cache) {
 981         ret = qcow2_cache_flush(bs, s->refcount_block_cache);
 982         if (ret) {
 983             error_setg_errno(errp, -ret,
 984                              "Failed to flush the refcount block cache");
 985             goto fail;
 986         }
 987     }
 988
 989     r->l2_slice_size = l2_cache_entry_size / sizeof(uint64_t);
 990     r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size,
 991                                            l2_cache_entry_size);
 992     r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size,
 993                                                  s->cluster_size);
 994     if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) {
 995         error_setg(errp, "Could not allocate metadata caches");
 996         ret = -ENOMEM;
 997         goto fail;
 998     }
 999
1000     /* New interval for cache cleanup timer */
1001     r->cache_clean_interval =
1002         qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
1003                             DEFAULT_CACHE_CLEAN_INTERVAL);
1004 #ifndef CONFIG_LINUX
1005     if (r->cache_clean_interval != 0) {
1006         error_setg(errp, QCOW2_OPT_CACHE_CLEAN_INTERVAL
1007                    " not supported on this host");
1008         ret = -EINVAL;
1009         goto fail;
1010     }
1011 #endif
1012     if (r->cache_clean_interval > UINT_MAX) {
1013         error_setg(errp, "Cache clean interval too big");
1014         ret = -EINVAL;
1015         goto fail;
1016     }
1017
1018     /* lazy-refcounts; flush if going from enabled to disabled */
1019     r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
1020         (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
1021     if (r->use_lazy_refcounts && s->qcow_version < 3) {
1022         error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
1023                    "qemu 1.1 compatibility level");
1024         ret = -EINVAL;
1025         goto fail;
1026     }
1027
1028     if (s->use_lazy_refcounts && !r->use_lazy_refcounts) {
1029         ret = qcow2_mark_clean(bs);
1030         if (ret < 0) {
1031             error_setg_errno(errp, -ret, "Failed to disable lazy refcounts");
1032             goto fail;
1033         }
1034     }
1035
1036     /* Overlap check options */
1037     opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
1038     opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
1039     if (opt_overlap_check_template && opt_overlap_check &&
1040         strcmp(opt_overlap_check_template, opt_overlap_check))
1041     {
1042         error_setg(errp, "Conflicting values for qcow2 options '"
1043                    QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
1044                    "' ('%s')", opt_overlap_check, opt_overlap_check_template);
1045         ret = -EINVAL;
1046         goto fail;
1047     }
1048     if (!opt_overlap_check) {
1049         opt_overlap_check = opt_overlap_check_template ?: "cached";
1050     }
1051
1052     if (!strcmp(opt_overlap_check, "none")) {
1053         overlap_check_template = 0;
1054     } else if (!strcmp(opt_overlap_check, "constant")) {
1055         overlap_check_template = QCOW2_OL_CONSTANT;
1056     } else if (!strcmp(opt_overlap_check, "cached")) {
1057         overlap_check_template = QCOW2_OL_CACHED;
1058     } else if (!strcmp(opt_overlap_check, "all")) {
1059         overlap_check_template = QCOW2_OL_ALL;
1060     } else {
1061         error_setg(errp, "Unsupported value '%s' for qcow2 option "
1062                    "'overlap-check'. Allowed are any of the following: "
1063                    "none, constant, cached, all", opt_overlap_check);
1064         ret = -EINVAL;
1065         goto fail;
1066     }
1067
1068     r->overlap_check = 0;
1069     for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
1070         /* overlap-check defines a template bitmask, but every flag may be
1071          * overwritten through the associated boolean option */
1072         r->overlap_check |=
1073             qemu_opt_get_bool(opts, overlap_bool_option_names[i],
1074                               overlap_check_template & (1 << i)) << i;
1075     }
1076
1077     r->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
1078     r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
1079     r->discard_passthrough[QCOW2_DISCARD_REQUEST] =
1080         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
1081                           flags & BDRV_O_UNMAP);
1082     r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
1083         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
1084     r->discard_passthrough[QCOW2_DISCARD_OTHER] =
1085         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);
1086
1087     switch (s->crypt_method_header) {
1088     case QCOW_CRYPT_NONE:
1089         if (encryptfmt) {
1090             error_setg(errp, "No encryption in image header, but options "
1091                        "specified format '%s'", encryptfmt);
1092             ret = -EINVAL;
1093             goto fail;
1094         }
1095         break;
1096
1097     case QCOW_CRYPT_AES:
1098         if (encryptfmt && !g_str_equal(encryptfmt, "aes")) {
1099             error_setg(errp,
1100                        "Header reported 'aes' encryption format but "
1101                        "options specify '%s'", encryptfmt);
1102             ret = -EINVAL;
1103             goto fail;
1104         }
1105         qdict_put_str(encryptopts, "format", "qcow");
1106         r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1107         break;
1108
1109     case QCOW_CRYPT_LUKS:
1110         if (encryptfmt && !g_str_equal(encryptfmt, "luks")) {
1111             error_setg(errp,
1112                        "Header reported 'luks' encryption format but "
1113                        "options specify '%s'", encryptfmt);
1114             ret = -EINVAL;
1115             goto fail;
1116         }
1117         qdict_put_str(encryptopts, "format", "luks");
1118         r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1119         break;
1120
1121     default:
1122         error_setg(errp, "Unsupported encryption method %d",
1123                    s->crypt_method_header);
1124         break;
1125     }
1126     if (s->crypt_method_header != QCOW_CRYPT_NONE && !r->crypto_opts) {
1127         ret = -EINVAL;
1128         goto fail;
1129     }
1130
1131     ret = 0;
1132 fail:
1133     qobject_unref(encryptopts);
1134     qemu_opts_del(opts);
1135     opts = NULL;
1136     return ret;
1137 }
1138
1139 static void qcow2_update_options_commit(BlockDriverState *bs,
1140                                         Qcow2ReopenState *r)
1141 {
1142     BDRVQcow2State *s = bs->opaque;
1143     int i;
1144
1145     if (s->l2_table_cache) {
1146         qcow2_cache_destroy(s->l2_table_cache);
1147     }
1148     if (s->refcount_block_cache) {
1149         qcow2_cache_destroy(s->refcount_block_cache);
1150     }
1151     s->l2_table_cache = r->l2_table_cache;
1152     s->refcount_block_cache = r->refcount_block_cache;
1153     s->l2_slice_size = r->l2_slice_size;
1154
1155     s->overlap_check = r->overlap_check;
1156     s->use_lazy_refcounts = r->use_lazy_refcounts;
1157
1158     for (i = 0; i < QCOW2_DISCARD_MAX; i++) {
1159         s->discard_passthrough[i] = r->discard_passthrough[i];
1160     }
1161
1162     if (s->cache_clean_interval != r->cache_clean_interval) {
1163         cache_clean_timer_del(bs);
1164         s->cache_clean_interval = r->cache_clean_interval;
1165         cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
1166     }
1167
1168     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1169     s->crypto_opts = r->crypto_opts;
1170 }
1171
1172 static void qcow2_update_options_abort(BlockDriverState *bs,
1173                                        Qcow2ReopenState *r)
1174 {
1175     if (r->l2_table_cache) {
1176         qcow2_cache_destroy(r->l2_table_cache);
1177     }
1178     if (r->refcount_block_cache) {
1179         qcow2_cache_destroy(r->refcount_block_cache);
1180     }
1181     qapi_free_QCryptoBlockOpenOptions(r->crypto_opts);
1182 }
1183
1184 static int qcow2_update_options(BlockDriverState *bs, QDict *options,
1185                                 int flags, Error **errp)
1186 {
1187     Qcow2ReopenState r = {};
1188     int ret;
1189
1190     ret = qcow2_update_options_prepare(bs, &r, options, flags, errp);
1191     if (ret >= 0) {
1192         qcow2_update_options_commit(bs, &r);
1193     } else {
1194         qcow2_update_options_abort(bs, &r);
1195     }
1196
1197     return ret;
1198 }
1199
1200 /* Called with s->lock held.  */
1201 static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
1202                                       int flags, Error **errp)
1203 {
1204     BDRVQcow2State *s = bs->opaque;
1205     unsigned int len, i;
1206     int ret = 0;
1207     QCowHeader header;
1208     Error *local_err = NULL;
1209     uint64_t ext_end;
1210     uint64_t l1_vm_state_index;
1211     bool update_header = false;
1212
1213     ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
1214     if (ret < 0) {
1215         error_setg_errno(errp, -ret, "Could not read qcow2 header");
1216         goto fail;
1217     }
1218     header.magic = be32_to_cpu(header.magic);
1219     header.version = be32_to_cpu(header.version);
1220     header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
1221     header.backing_file_size = be32_to_cpu(header.backing_file_size);
1222     header.size = be64_to_cpu(header.size);
1223     header.cluster_bits = be32_to_cpu(header.cluster_bits);
1224     header.crypt_method = be32_to_cpu(header.crypt_method);
1225     header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
1226     header.l1_size = be32_to_cpu(header.l1_size);
1227     header.refcount_table_offset = be64_to_cpu(header.refcount_table_offset);
1228     header.refcount_table_clusters =
1229         be32_to_cpu(header.refcount_table_clusters);
1230     header.snapshots_offset = be64_to_cpu(header.snapshots_offset);
1231     header.nb_snapshots = be32_to_cpu(header.nb_snapshots);
1232
1233     if (header.magic != QCOW_MAGIC) {
1234         error_setg(errp, "Image is not in qcow2 format");
1235         ret = -EINVAL;
1236         goto fail;
1237     }
1238     if (header.version < 2 || header.version > 3) {
1239         error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version);
1240         ret = -ENOTSUP;
1241         goto fail;
1242     }
1243
1244     s->qcow_version = header.version;
1245
1246     /* Initialise cluster size */
1247     if (header.cluster_bits < MIN_CLUSTER_BITS ||
1248         header.cluster_bits > MAX_CLUSTER_BITS) {
1249         error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
1250                    header.cluster_bits);
1251         ret = -EINVAL;
1252         goto fail;
1253     }
1254
1255     s->cluster_bits = header.cluster_bits;
1256     s->cluster_size = 1 << s->cluster_bits;
1257
1258     /* Initialise version 3 header fields */
1259     if (header.version == 2) {
1260         header.incompatible_features    = 0;
1261         header.compatible_features      = 0;
1262         header.autoclear_features       = 0;
1263         header.refcount_order           = 4;
1264         header.header_length            = 72;
1265     } else {
1266         header.incompatible_features =
1267             be64_to_cpu(header.incompatible_features);
1268         header.compatible_features = be64_to_cpu(header.compatible_features);
1269         header.autoclear_features = be64_to_cpu(header.autoclear_features);
1270         header.refcount_order = be32_to_cpu(header.refcount_order);
1271         header.header_length = be32_to_cpu(header.header_length);
1272
1273         if (header.header_length < 104) {
1274             error_setg(errp, "qcow2 header too short");
1275             ret = -EINVAL;
1276             goto fail;
1277         }
1278     }
1279
1280     if (header.header_length > s->cluster_size) {
1281         error_setg(errp, "qcow2 header exceeds cluster size");
1282         ret = -EINVAL;
1283         goto fail;
1284     }
1285
1286     if (header.header_length > sizeof(header)) {
1287         s->unknown_header_fields_size = header.header_length - sizeof(header);
1288         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
1289         ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
1290                          s->unknown_header_fields_size);
1291         if (ret < 0) {
1292             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
1293                              "fields");
1294             goto fail;
1295         }
1296     }
1297
1298     if (header.backing_file_offset > s->cluster_size) {
1299         error_setg(errp, "Invalid backing file offset");
1300         ret = -EINVAL;
1301         goto fail;
1302     }
1303
1304     if (header.backing_file_offset) {
1305         ext_end = header.backing_file_offset;
1306     } else {
1307         ext_end = 1 << header.cluster_bits;
1308     }
1309
1310     /* Handle feature bits */
1311     s->incompatible_features    = header.incompatible_features;
1312     s->compatible_features      = header.compatible_features;
1313     s->autoclear_features       = header.autoclear_features;
1314
1315     if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
1316         void *feature_table = NULL;
1317         qcow2_read_extensions(bs, header.header_length, ext_end,
1318                               &feature_table, flags, NULL, NULL);
1319         report_unsupported_feature(errp, feature_table,
1320                                    s->incompatible_features &
1321                                    ~QCOW2_INCOMPAT_MASK);
1322         ret = -ENOTSUP;
1323         g_free(feature_table);
1324         goto fail;
1325     }
1326
1327     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
1328         /* Corrupt images may not be written to unless they are being repaired
1329          */
1330         if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
1331             error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
1332                        "read/write");
1333             ret = -EACCES;
1334             goto fail;
1335         }
1336     }
1337
1338     /* Check support for various header values */
1339     if (header.refcount_order > 6) {
1340         error_setg(errp, "Reference count entry width too large; may not "
1341                    "exceed 64 bits");
1342         ret = -EINVAL;
1343         goto fail;
1344     }
1345     s->refcount_order = header.refcount_order;
1346     s->refcount_bits = 1 << s->refcount_order;
1347     s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
1348     s->refcount_max += s->refcount_max - 1;
1349
1350     s->crypt_method_header = header.crypt_method;
1351     if (s->crypt_method_header) {
1352         if (bdrv_uses_whitelist() &&
1353             s->crypt_method_header == QCOW_CRYPT_AES) {
1354             error_setg(errp,
1355                        "Use of AES-CBC encrypted qcow2 images is no longer "
1356                        "supported in system emulators");
1357             error_append_hint(errp,
1358                               "You can use 'qemu-img convert' to convert your "
1359                               "image to an alternative supported format, such "
1360                               "as unencrypted qcow2, or raw with the LUKS "
1361                               "format instead.\n");
1362             ret = -ENOSYS;
1363             goto fail;
1364         }
1365
1366         if (s->crypt_method_header == QCOW_CRYPT_AES) {
1367             s->crypt_physical_offset = false;
1368         } else {
1369             /* Assuming LUKS and any future crypt methods we
1370              * add will all use physical offsets, due to the
1371              * fact that the alternative is insecure...  */
1372             s->crypt_physical_offset = true;
1373         }
1374
1375         bs->encrypted = true;
1376     }
1377
1378     s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
1379     s->l2_size = 1 << s->l2_bits;
1380     /* 2^(s->refcount_order - 3) is the refcount width in bytes */
1381     s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
1382     s->refcount_block_size = 1 << s->refcount_block_bits;
1383     bs->total_sectors = header.size / BDRV_SECTOR_SIZE;
1384     s->csize_shift = (62 - (s->cluster_bits - 8));
1385     s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
1386     s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
1387
1388     s->refcount_table_offset = header.refcount_table_offset;
1389     s->refcount_table_size =
1390         header.refcount_table_clusters << (s->cluster_bits - 3);
1391
1392     if (header.refcount_table_clusters == 0 && !(flags & BDRV_O_CHECK)) {
1393         error_setg(errp, "Image does not contain a reference count table");
1394         ret = -EINVAL;
1395         goto fail;
1396     }
1397
1398     ret = qcow2_validate_table(bs, s->refcount_table_offset,
1399                                header.refcount_table_clusters,
1400                                s->cluster_size, QCOW_MAX_REFTABLE_SIZE,
1401                                "Reference count table", errp);
1402     if (ret < 0) {
1403         goto fail;
1404     }
1405
1406     /* The total size in bytes of the snapshot table is checked in
1407      * qcow2_read_snapshots() because the size of each snapshot is
1408      * variable and we don't know it yet.
1409      * Here we only check the offset and number of snapshots. */
1410     ret = qcow2_validate_table(bs, header.snapshots_offset,
1411                                header.nb_snapshots,
1412                                sizeof(QCowSnapshotHeader),
1413                                sizeof(QCowSnapshotHeader) * QCOW_MAX_SNAPSHOTS,
1414                                "Snapshot table", errp);
1415     if (ret < 0) {
1416         goto fail;
1417     }
1418
1419     /* read the level 1 table */
1420     ret = qcow2_validate_table(bs, header.l1_table_offset,
1421                                header.l1_size, sizeof(uint64_t),
1422                                QCOW_MAX_L1_SIZE, "Active L1 table", errp);
1423     if (ret < 0) {
1424         goto fail;
1425     }
1426     s->l1_size = header.l1_size;
1427     s->l1_table_offset = header.l1_table_offset;
1428
1429     l1_vm_state_index = size_to_l1(s, header.size);
1430     if (l1_vm_state_index > INT_MAX) {
1431         error_setg(errp, "Image is too big");
1432         ret = -EFBIG;
1433         goto fail;
1434     }
1435     s->l1_vm_state_index = l1_vm_state_index;
1436
1437     /* the L1 table must contain at least enough entries to put
1438        header.size bytes */
1439     if (s->l1_size < s->l1_vm_state_index) {
1440         error_setg(errp, "L1 table is too small");
1441         ret = -EINVAL;
1442         goto fail;
1443     }
1444
1445     if (s->l1_size > 0) {
1446         s->l1_table = qemu_try_blockalign(bs->file->bs,
1447             ROUND_UP(s->l1_size * sizeof(uint64_t), 512));
1448         if (s->l1_table == NULL) {
1449             error_setg(errp, "Could not allocate L1 table");
1450             ret = -ENOMEM;
1451             goto fail;
1452         }
1453         ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
1454                          s->l1_size * sizeof(uint64_t));
1455         if (ret < 0) {
1456             error_setg_errno(errp, -ret, "Could not read L1 table");
1457             goto fail;
1458         }
1459         for(i = 0;i < s->l1_size; i++) {
1460             s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
1461         }
1462     }
1463
1464     /* Parse driver-specific options */
1465     ret = qcow2_update_options(bs, options, flags, errp);
1466     if (ret < 0) {
1467         goto fail;
1468     }
1469
1470     s->flags = flags;
1471
1472     ret = qcow2_refcount_init(bs);
1473     if (ret != 0) {
1474         error_setg_errno(errp, -ret, "Could not initialize refcount handling");
1475         goto fail;
1476     }
1477
1478     QLIST_INIT(&s->cluster_allocs);
1479     QTAILQ_INIT(&s->discards);
1480
1481     /* read qcow2 extensions */
1482     if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
1483                               flags, &update_header, &local_err)) {
1484         error_propagate(errp, local_err);
1485         ret = -EINVAL;
1486         goto fail;
1487     }
1488
1489     /* Open external data file */
1490     s->data_file = bdrv_open_child(NULL, options, "data-file", bs, &child_file,
1491                                    true, &local_err);
1492     if (local_err) {
1493         error_propagate(errp, local_err);
1494         ret = -EINVAL;
1495         goto fail;
1496     }
1497
1498     if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
1499         if (!s->data_file && s->image_data_file) {
1500             s->data_file = bdrv_open_child(s->image_data_file, options,
1501                                            "data-file", bs, &child_file,
1502                                            false, errp);
1503             if (!s->data_file) {
1504                 ret = -EINVAL;
1505                 goto fail;
1506             }
1507         }
1508         if (!s->data_file) {
1509             error_setg(errp, "'data-file' is required for this image");
1510             ret = -EINVAL;
1511             goto fail;
1512         }
1513     } else {
1514         if (s->data_file) {
1515             error_setg(errp, "'data-file' can only be set for images with an "
1516                              "external data file");
1517             ret = -EINVAL;
1518             goto fail;
1519         }
1520
1521         s->data_file = bs->file;
1522
1523         if (data_file_is_raw(bs)) {
1524             error_setg(errp, "data-file-raw requires a data file");
1525             ret = -EINVAL;
1526             goto fail;
1527         }
1528     }
1529
1530     /* qcow2_read_extension may have set up the crypto context
1531      * if the crypt method needs a header region, some methods
1532      * don't need header extensions, so must check here
1533      */
1534     if (s->crypt_method_header && !s->crypto) {
1535         if (s->crypt_method_header == QCOW_CRYPT_AES) {
1536             unsigned int cflags = 0;
1537             if (flags & BDRV_O_NO_IO) {
1538                 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
1539             }
1540             s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
1541                                            NULL, NULL, cflags, 1, errp);
1542             if (!s->crypto) {
1543                 ret = -EINVAL;
1544                 goto fail;
1545             }
1546         } else if (!(flags & BDRV_O_NO_IO)) {
1547             error_setg(errp, "Missing CRYPTO header for crypt method %d",
1548                        s->crypt_method_header);
1549             ret = -EINVAL;
1550             goto fail;
1551         }
1552     }
1553
1554     /* read the backing file name */
1555     if (header.backing_file_offset != 0) {
1556         len = header.backing_file_size;
1557         if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
1558             len >= sizeof(bs->backing_file)) {
1559             error_setg(errp, "Backing file name too long");
1560             ret = -EINVAL;
1561             goto fail;
1562         }
1563         ret = bdrv_pread(bs->file, header.backing_file_offset,
1564                          bs->auto_backing_file, len);
1565         if (ret < 0) {
1566             error_setg_errno(errp, -ret, "Could not read backing file name");
1567             goto fail;
1568         }
1569         bs->auto_backing_file[len] = '\0';
1570         pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1571                 bs->auto_backing_file);
1572         s->image_backing_file = g_strdup(bs->auto_backing_file);
1573     }
1574
1575     /* Internal snapshots */
1576     s->snapshots_offset = header.snapshots_offset;
1577     s->nb_snapshots = header.nb_snapshots;
1578
1579     ret = qcow2_read_snapshots(bs);
1580     if (ret < 0) {
1581         error_setg_errno(errp, -ret, "Could not read snapshots");
1582         goto fail;
1583     }
1584
1585     /* Clear unknown autoclear feature bits */
1586     update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK;
1587     update_header =
1588         update_header && !bs->read_only && !(flags & BDRV_O_INACTIVE);
1589     if (update_header) {
1590         s->autoclear_features &= QCOW2_AUTOCLEAR_MASK;
1591     }
1592
1593     /* == Handle persistent dirty bitmaps ==
1594      *
1595      * We want load dirty bitmaps in three cases:
1596      *
1597      * 1. Normal open of the disk in active mode, not related to invalidation
1598      *    after migration.
1599      *
1600      * 2. Invalidation of the target vm after pre-copy phase of migration, if
1601      *    bitmaps are _not_ migrating through migration channel, i.e.
1602      *    'dirty-bitmaps' capability is disabled.
1603      *
1604      * 3. Invalidation of source vm after failed or canceled migration.
1605      *    This is a very interesting case. There are two possible types of
1606      *    bitmaps:
1607      *
1608      *    A. Stored on inactivation and removed. They should be loaded from the
1609      *       image.
1610      *
1611      *    B. Not stored: not-persistent bitmaps and bitmaps, migrated through
1612      *       the migration channel (with dirty-bitmaps capability).
1613      *
1614      *    On the other hand, there are two possible sub-cases:
1615      *
1616      *    3.1 disk was changed by somebody else while were inactive. In this
1617      *        case all in-RAM dirty bitmaps (both persistent and not) are
1618      *        definitely invalid. And we don't have any method to determine
1619      *        this.
1620      *
1621      *        Simple and safe thing is to just drop all the bitmaps of type B on
1622      *        inactivation. But in this case we lose bitmaps in valid 4.2 case.
1623      *
1624      *        On the other hand, resuming source vm, if disk was already changed
1625      *        is a bad thing anyway: not only bitmaps, the whole vm state is
1626      *        out of sync with disk.
1627      *
1628      *        This means, that user or management tool, who for some reason
1629      *        decided to resume source vm, after disk was already changed by
1630      *        target vm, should at least drop all dirty bitmaps by hand.
1631      *
1632      *        So, we can ignore this case for now, but TODO: "generation"
1633      *        extension for qcow2, to determine, that image was changed after
1634      *        last inactivation. And if it is changed, we will drop (or at least
1635      *        mark as 'invalid' all the bitmaps of type B, both persistent
1636      *        and not).
1637      *
1638      *    3.2 disk was _not_ changed while were inactive. Bitmaps may be saved
1639      *        to disk ('dirty-bitmaps' capability disabled), or not saved
1640      *        ('dirty-bitmaps' capability enabled), but we don't need to care
1641      *        of: let's load bitmaps as always: stored bitmaps will be loaded,
1642      *        and not stored has flag IN_USE=1 in the image and will be skipped
1643      *        on loading.
1644      *
1645      * One remaining possible case when we don't want load bitmaps:
1646      *
1647      * 4. Open disk in inactive mode in target vm (bitmaps are migrating or
1648      *    will be loaded on invalidation, no needs try loading them before)
1649      */
1650
1651     if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) {
1652         /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
1653         bool header_updated = qcow2_load_dirty_bitmaps(bs, &local_err);
1654
1655         update_header = update_header && !header_updated;
1656     }
1657     if (local_err != NULL) {
1658         error_propagate(errp, local_err);
1659         ret = -EINVAL;
1660         goto fail;
1661     }
1662
1663     if (update_header) {
1664         ret = qcow2_update_header(bs);
1665         if (ret < 0) {
1666             error_setg_errno(errp, -ret, "Could not update qcow2 header");
1667             goto fail;
1668         }
1669     }
1670
1671     bs->supported_zero_flags = header.version >= 3 ? BDRV_REQ_MAY_UNMAP : 0;
1672
1673     /* Repair image if dirty */
1674     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
1675         (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
1676         BdrvCheckResult result = {0};
1677
1678         ret = qcow2_co_check_locked(bs, &result,
1679                                     BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
1680         if (ret < 0 || result.check_errors) {
1681             if (ret >= 0) {
1682                 ret = -EIO;
1683             }
1684             error_setg_errno(errp, -ret, "Could not repair dirty image");
1685             goto fail;
1686         }
1687     }
1688
1689 #ifdef DEBUG_ALLOC
1690     {
1691         BdrvCheckResult result = {0};
1692         qcow2_check_refcounts(bs, &result, 0);
1693     }
1694 #endif
1695
1696     qemu_co_queue_init(&s->thread_task_queue);
1697
1698     return ret;
1699
1700  fail:
1701     g_free(s->image_data_file);
1702     if (has_data_file(bs)) {
1703         bdrv_unref_child(bs, s->data_file);
1704     }
1705     g_free(s->unknown_header_fields);
1706     cleanup_unknown_header_ext(bs);
1707     qcow2_free_snapshots(bs);
1708     qcow2_refcount_close(bs);
1709     qemu_vfree(s->l1_table);
1710     /* else pre-write overlap checks in cache_destroy may crash */
1711     s->l1_table = NULL;
1712     cache_clean_timer_del(bs);
1713     if (s->l2_table_cache) {
1714         qcow2_cache_destroy(s->l2_table_cache);
1715     }
1716     if (s->refcount_block_cache) {
1717         qcow2_cache_destroy(s->refcount_block_cache);
1718     }
1719     qcrypto_block_free(s->crypto);
1720     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1721     return ret;
1722 }
1723
1724 typedef struct QCow2OpenCo {
1725     BlockDriverState *bs;
1726     QDict *options;
1727     int flags;
1728     Error **errp;
1729     int ret;
1730 } QCow2OpenCo;
1731
1732 static void coroutine_fn qcow2_open_entry(void *opaque)
1733 {
1734     QCow2OpenCo *qoc = opaque;
1735     BDRVQcow2State *s = qoc->bs->opaque;
1736
1737     qemu_co_mutex_lock(&s->lock);
1738     qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, qoc->errp);
1739     qemu_co_mutex_unlock(&s->lock);
1740 }
1741
1742 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
1743                       Error **errp)
1744 {
1745     BDRVQcow2State *s = bs->opaque;
1746     QCow2OpenCo qoc = {
1747         .bs = bs,
1748         .options = options,
1749         .flags = flags,
1750         .errp = errp,
1751         .ret = -EINPROGRESS
1752     };
1753
1754     bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
1755                                false, errp);
1756     if (!bs->file) {
1757         return -EINVAL;
1758     }
1759
1760     /* Initialise locks */
1761     qemu_co_mutex_init(&s->lock);
1762
1763     if (qemu_in_coroutine()) {
1764         /* From bdrv_co_create.  */
1765         qcow2_open_entry(&qoc);
1766     } else {
1767         assert(qemu_get_current_aio_context() == qemu_get_aio_context());
1768         qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry, &qoc));
1769         BDRV_POLL_WHILE(bs, qoc.ret == -EINPROGRESS);
1770     }
1771     return qoc.ret;
1772 }
1773
1774 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
1775 {
1776     BDRVQcow2State *s = bs->opaque;
1777
1778     if (bs->encrypted) {
1779         /* Encryption works on a sector granularity */
1780         bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto);
1781     }
1782     bs->bl.pwrite_zeroes_alignment = s->cluster_size;
1783     bs->bl.pdiscard_alignment = s->cluster_size;
1784 }
1785
1786 static int qcow2_reopen_prepare(BDRVReopenState *state,
1787                                 BlockReopenQueue *queue, Error **errp)
1788 {
1789     Qcow2ReopenState *r;
1790     int ret;
1791
1792     r = g_new0(Qcow2ReopenState, 1);
1793     state->opaque = r;
1794
1795     ret = qcow2_update_options_prepare(state->bs, r, state->options,
1796                                        state->flags, errp);
1797     if (ret < 0) {
1798         goto fail;
1799     }
1800
1801     /* We need to write out any unwritten data if we reopen read-only. */
1802     if ((state->flags & BDRV_O_RDWR) == 0) {
1803         ret = qcow2_reopen_bitmaps_ro(state->bs, errp);
1804         if (ret < 0) {
1805             goto fail;
1806         }
1807
1808         ret = bdrv_flush(state->bs);
1809         if (ret < 0) {
1810             goto fail;
1811         }
1812
1813         ret = qcow2_mark_clean(state->bs);
1814         if (ret < 0) {
1815             goto fail;
1816         }
1817     }
1818
1819     return 0;
1820
1821 fail:
1822     qcow2_update_options_abort(state->bs, r);
1823     g_free(r);
1824     return ret;
1825 }
1826
1827 static void qcow2_reopen_commit(BDRVReopenState *state)
1828 {
1829     qcow2_update_options_commit(state->bs, state->opaque);
1830     g_free(state->opaque);
1831 }
1832
1833 static void qcow2_reopen_abort(BDRVReopenState *state)
1834 {
1835     qcow2_update_options_abort(state->bs, state->opaque);
1836     g_free(state->opaque);
1837 }
1838
1839 static void qcow2_join_options(QDict *options, QDict *old_options)
1840 {
1841     bool has_new_overlap_template =
1842         qdict_haskey(options, QCOW2_OPT_OVERLAP) ||
1843         qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE);
1844     bool has_new_total_cache_size =
1845         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE);
1846     bool has_all_cache_options;
1847
1848     /* New overlap template overrides all old overlap options */
1849     if (has_new_overlap_template) {
1850         qdict_del(old_options, QCOW2_OPT_OVERLAP);
1851         qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE);
1852         qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER);
1853         qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1);
1854         qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2);
1855         qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE);
1856         qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK);
1857         qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE);
1858         qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1);
1859         qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2);
1860     }
1861
1862     /* New total cache size overrides all old options */
1863     if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) {
1864         qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE);
1865         qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
1866     }
1867
1868     qdict_join(options, old_options, false);
1869
1870     /*
1871      * If after merging all cache size options are set, an old total size is
1872      * overwritten. Do keep all options, however, if all three are new. The
1873      * resulting error message is what we want to happen.
1874      */
1875     has_all_cache_options =
1876         qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) ||
1877         qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) ||
1878         qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
1879
1880     if (has_all_cache_options && !has_new_total_cache_size) {
1881         qdict_del(options, QCOW2_OPT_CACHE_SIZE);
1882     }
1883 }
1884
1885 static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
1886                                               bool want_zero,
1887                                               int64_t offset, int64_t count,
1888                                               int64_t *pnum, int64_t *map,
1889                                               BlockDriverState **file)
1890 {
1891     BDRVQcow2State *s = bs->opaque;
1892     uint64_t cluster_offset;
1893     int index_in_cluster, ret;
1894     unsigned int bytes;
1895     int status = 0;
1896
1897     bytes = MIN(INT_MAX, count);
1898     qemu_co_mutex_lock(&s->lock);
1899     ret = qcow2_get_cluster_offset(bs, offset, &bytes, &cluster_offset);
1900     qemu_co_mutex_unlock(&s->lock);
1901     if (ret < 0) {
1902         return ret;
1903     }
1904
1905     *pnum = bytes;
1906
1907     if ((ret == QCOW2_CLUSTER_NORMAL || ret == QCOW2_CLUSTER_ZERO_ALLOC) &&
1908         !s->crypto) {
1909         index_in_cluster = offset & (s->cluster_size - 1);
1910         *map = cluster_offset | index_in_cluster;
1911         *file = s->data_file->bs;
1912         status |= BDRV_BLOCK_OFFSET_VALID;
1913     }
1914     if (ret == QCOW2_CLUSTER_ZERO_PLAIN || ret == QCOW2_CLUSTER_ZERO_ALLOC) {
1915         status |= BDRV_BLOCK_ZERO;
1916     } else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
1917         status |= BDRV_BLOCK_DATA;
1918     }
1919     return status;
1920 }
1921
1922 static coroutine_fn int qcow2_handle_l2meta(BlockDriverState *bs,
1923                                             QCowL2Meta **pl2meta,
1924                                             bool link_l2)
1925 {
1926     int ret = 0;
1927     QCowL2Meta *l2meta = *pl2meta;
1928
1929     while (l2meta != NULL) {
1930         QCowL2Meta *next;
1931
1932         if (link_l2) {
1933             ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
1934             if (ret) {
1935                 goto out;
1936             }
1937         } else {
1938             qcow2_alloc_cluster_abort(bs, l2meta);
1939         }
1940
1941         /* Take the request off the list of running requests */
1942         if (l2meta->nb_clusters != 0) {
1943             QLIST_REMOVE(l2meta, next_in_flight);
1944         }
1945
1946         qemu_co_queue_restart_all(&l2meta->dependent_requests);
1947
1948         next = l2meta->next;
1949         g_free(l2meta);
1950         l2meta = next;
1951     }
1952 out:
1953     *pl2meta = l2meta;
1954     return ret;
1955 }
1956
1957 static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
1958                                         uint64_t bytes, QEMUIOVector *qiov,
1959                                         int flags)
1960 {
1961     BDRVQcow2State *s = bs->opaque;
1962     int offset_in_cluster;
1963     int ret;
1964     unsigned int cur_bytes; /* number of bytes in current iteration */
1965     uint64_t cluster_offset = 0;
1966     uint64_t bytes_done = 0;
1967     QEMUIOVector hd_qiov;
1968     uint8_t *cluster_data = NULL;
1969
1970     qemu_iovec_init(&hd_qiov, qiov->niov);
1971
1972     while (bytes != 0) {
1973
1974         /* prepare next request */
1975         cur_bytes = MIN(bytes, INT_MAX);
1976         if (s->crypto) {
1977             cur_bytes = MIN(cur_bytes,
1978                             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
1979         }
1980
1981         qemu_co_mutex_lock(&s->lock);
1982         ret = qcow2_get_cluster_offset(bs, offset, &cur_bytes, &cluster_offset);
1983         qemu_co_mutex_unlock(&s->lock);
1984         if (ret < 0) {
1985             goto fail;
1986         }
1987
1988         offset_in_cluster = offset_into_cluster(s, offset);
1989
1990         qemu_iovec_reset(&hd_qiov);
1991         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
1992
1993         switch (ret) {
1994         case QCOW2_CLUSTER_UNALLOCATED:
1995
1996             if (bs->backing) {
1997                 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
1998                 ret = bdrv_co_preadv(bs->backing, offset, cur_bytes,
1999                                      &hd_qiov, 0);
2000                 if (ret < 0) {
2001                     goto fail;
2002                 }
2003             } else {
2004                 /* Note: in this case, no need to wait */
2005                 qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
2006             }
2007             break;
2008
2009         case QCOW2_CLUSTER_ZERO_PLAIN:
2010         case QCOW2_CLUSTER_ZERO_ALLOC:
2011             qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
2012             break;
2013
2014         case QCOW2_CLUSTER_COMPRESSED:
2015             ret = qcow2_co_preadv_compressed(bs, cluster_offset,
2016                                              offset, cur_bytes,
2017                                              &hd_qiov);
2018             if (ret < 0) {
2019                 goto fail;
2020             }
2021
2022             break;
2023
2024         case QCOW2_CLUSTER_NORMAL:
2025             if ((cluster_offset & 511) != 0) {
2026                 ret = -EIO;
2027                 goto fail;
2028             }
2029
2030             if (bs->encrypted) {
2031                 assert(s->crypto);
2032
2033                 /*
2034                  * For encrypted images, read everything into a temporary
2035                  * contiguous buffer on which the AES functions can work.
2036                  */
2037                 if (!cluster_data) {
2038                     cluster_data =
2039                         qemu_try_blockalign(s->data_file->bs,
2040                                             QCOW_MAX_CRYPT_CLUSTERS
2041                                             * s->cluster_size);
2042                     if (cluster_data == NULL) {
2043                         ret = -ENOMEM;
2044                         goto fail;
2045                     }
2046                 }
2047
2048                 assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2049                 qemu_iovec_reset(&hd_qiov);
2050                 qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
2051             }
2052
2053             BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
2054             ret = bdrv_co_preadv(s->data_file,
2055                                  cluster_offset + offset_in_cluster,
2056                                  cur_bytes, &hd_qiov, 0);
2057             if (ret < 0) {
2058                 goto fail;
2059             }
2060             if (bs->encrypted) {
2061                 assert(s->crypto);
2062                 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
2063                 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
2064                 if (qcrypto_block_decrypt(s->crypto,
2065                                           (s->crypt_physical_offset ?
2066                                            cluster_offset + offset_in_cluster :
2067                                            offset),
2068                                           cluster_data,
2069                                           cur_bytes,
2070                                           NULL) < 0) {
2071                     ret = -EIO;
2072                     goto fail;
2073                 }
2074                 qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes);
2075             }
2076             break;
2077
2078         default:
2079             g_assert_not_reached();
2080             ret = -EIO;
2081             goto fail;
2082         }
2083
2084         bytes -= cur_bytes;
2085         offset += cur_bytes;
2086         bytes_done += cur_bytes;
2087     }
2088     ret = 0;
2089
2090 fail:
2091     qemu_iovec_destroy(&hd_qiov);
2092     qemu_vfree(cluster_data);
2093
2094     return ret;
2095 }
2096
2097 /* Check if it's possible to merge a write request with the writing of
2098  * the data from the COW regions */
2099 static bool merge_cow(uint64_t offset, unsigned bytes,
2100                       QEMUIOVector *hd_qiov, QCowL2Meta *l2meta)
2101 {
2102     QCowL2Meta *m;
2103
2104     for (m = l2meta; m != NULL; m = m->next) {
2105         /* If both COW regions are empty then there's nothing to merge */
2106         if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) {
2107             continue;
2108         }
2109
2110         /* The data (middle) region must be immediately after the
2111          * start region */
2112         if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) {
2113             continue;
2114         }
2115
2116         /* The end region must be immediately after the data (middle)
2117          * region */
2118         if (m->offset + m->cow_end.offset != offset + bytes) {
2119             continue;
2120         }
2121
2122         /* Make sure that adding both COW regions to the QEMUIOVector
2123          * does not exceed IOV_MAX */
2124         if (hd_qiov->niov > IOV_MAX - 2) {
2125             continue;
2126         }
2127
2128         m->data_qiov = hd_qiov;
2129         return true;
2130     }
2131
2132     return false;
2133 }
2134
2135 static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
2136                                          uint64_t bytes, QEMUIOVector *qiov,
2137                                          int flags)
2138 {
2139     BDRVQcow2State *s = bs->opaque;
2140     int offset_in_cluster;
2141     int ret;
2142     unsigned int cur_bytes; /* number of sectors in current iteration */
2143     uint64_t cluster_offset;
2144     QEMUIOVector hd_qiov;
2145     uint64_t bytes_done = 0;
2146     uint8_t *cluster_data = NULL;
2147     QCowL2Meta *l2meta = NULL;
2148
2149     trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
2150
2151     qemu_iovec_init(&hd_qiov, qiov->niov);
2152
2153     qemu_co_mutex_lock(&s->lock);
2154
2155     while (bytes != 0) {
2156
2157         l2meta = NULL;
2158
2159         trace_qcow2_writev_start_part(qemu_coroutine_self());
2160         offset_in_cluster = offset_into_cluster(s, offset);
2161         cur_bytes = MIN(bytes, INT_MAX);
2162         if (bs->encrypted) {
2163             cur_bytes = MIN(cur_bytes,
2164                             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size
2165                             - offset_in_cluster);
2166         }
2167
2168         ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,
2169                                          &cluster_offset, &l2meta);
2170         if (ret < 0) {
2171             goto fail;
2172         }
2173
2174         assert((cluster_offset & 511) == 0);
2175
2176         qemu_iovec_reset(&hd_qiov);
2177         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
2178
2179         if (bs->encrypted) {
2180             assert(s->crypto);
2181             if (!cluster_data) {
2182                 cluster_data = qemu_try_blockalign(bs->file->bs,
2183                                                    QCOW_MAX_CRYPT_CLUSTERS
2184                                                    * s->cluster_size);
2185                 if (cluster_data == NULL) {
2186                     ret = -ENOMEM;
2187                     goto fail;
2188                 }
2189             }
2190
2191             assert(hd_qiov.size <=
2192                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2193             qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
2194
2195             if (qcrypto_block_encrypt(s->crypto,
2196                                       (s->crypt_physical_offset ?
2197                                        cluster_offset + offset_in_cluster :
2198                                        offset),
2199                                       cluster_data,
2200                                       cur_bytes, NULL) < 0) {
2201                 ret = -EIO;
2202                 goto fail;
2203             }
2204
2205             qemu_iovec_reset(&hd_qiov);
2206             qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
2207         }
2208
2209         ret = qcow2_pre_write_overlap_check(bs, 0,
2210                 cluster_offset + offset_in_cluster, cur_bytes, true);
2211         if (ret < 0) {
2212             goto fail;
2213         }
2214
2215         /* If we need to do COW, check if it's possible to merge the
2216          * writing of the guest data together with that of the COW regions.
2217          * If it's not possible (or not necessary) then write the
2218          * guest data now. */
2219         if (!merge_cow(offset, cur_bytes, &hd_qiov, l2meta)) {
2220             qemu_co_mutex_unlock(&s->lock);
2221             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
2222             trace_qcow2_writev_data(qemu_coroutine_self(),
2223                                     cluster_offset + offset_in_cluster);
2224             ret = bdrv_co_pwritev(s->data_file,
2225                                   cluster_offset + offset_in_cluster,
2226                                   cur_bytes, &hd_qiov, 0);
2227             qemu_co_mutex_lock(&s->lock);
2228             if (ret < 0) {
2229                 goto fail;
2230             }
2231         }
2232
2233         ret = qcow2_handle_l2meta(bs, &l2meta, true);
2234         if (ret) {
2235             goto fail;
2236         }
2237
2238         bytes -= cur_bytes;
2239         offset += cur_bytes;
2240         bytes_done += cur_bytes;
2241         trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes);
2242     }
2243     ret = 0;
2244
2245 fail:
2246     qcow2_handle_l2meta(bs, &l2meta, false);
2247
2248     qemu_co_mutex_unlock(&s->lock);
2249
2250     qemu_iovec_destroy(&hd_qiov);
2251     qemu_vfree(cluster_data);
2252     trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
2253
2254     return ret;
2255 }
2256
2257 static int qcow2_inactivate(BlockDriverState *bs)
2258 {
2259     BDRVQcow2State *s = bs->opaque;
2260     int ret, result = 0;
2261     Error *local_err = NULL;
2262
2263     qcow2_store_persistent_dirty_bitmaps(bs, &local_err);
2264     if (local_err != NULL) {
2265         result = -EINVAL;
2266         error_reportf_err(local_err, "Lost persistent bitmaps during "
2267                           "inactivation of node '%s': ",
2268                           bdrv_get_device_or_node_name(bs));
2269     }
2270
2271     ret = qcow2_cache_flush(bs, s->l2_table_cache);
2272     if (ret) {
2273         result = ret;
2274         error_report("Failed to flush the L2 table cache: %s",
2275                      strerror(-ret));
2276     }
2277
2278     ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2279     if (ret) {
2280         result = ret;
2281         error_report("Failed to flush the refcount block cache: %s",
2282                      strerror(-ret));
2283     }
2284
2285     if (result == 0) {
2286         qcow2_mark_clean(bs);
2287     }
2288
2289     return result;
2290 }
2291
2292 static void qcow2_close(BlockDriverState *bs)
2293 {
2294     BDRVQcow2State *s = bs->opaque;
2295     qemu_vfree(s->l1_table);
2296     /* else pre-write overlap checks in cache_destroy may crash */
2297     s->l1_table = NULL;
2298
2299     if (!(s->flags & BDRV_O_INACTIVE)) {
2300         qcow2_inactivate(bs);
2301     }
2302
2303     cache_clean_timer_del(bs);
2304     qcow2_cache_destroy(s->l2_table_cache);
2305     qcow2_cache_destroy(s->refcount_block_cache);
2306
2307     qcrypto_block_free(s->crypto);
2308     s->crypto = NULL;
2309
2310     g_free(s->unknown_header_fields);
2311     cleanup_unknown_header_ext(bs);
2312
2313     g_free(s->image_data_file);
2314     g_free(s->image_backing_file);
2315     g_free(s->image_backing_format);
2316
2317     if (has_data_file(bs)) {
2318         bdrv_unref_child(bs, s->data_file);
2319     }
2320
2321     qcow2_refcount_close(bs);
2322     qcow2_free_snapshots(bs);
2323 }
2324
2325 static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
2326                                                    Error **errp)
2327 {
2328     BDRVQcow2State *s = bs->opaque;
2329     int flags = s->flags;
2330     QCryptoBlock *crypto = NULL;
2331     QDict *options;
2332     Error *local_err = NULL;
2333     int ret;
2334
2335     /*
2336      * Backing files are read-only which makes all of their metadata immutable,
2337      * that means we don't have to worry about reopening them here.
2338      */
2339
2340     crypto = s->crypto;
2341     s->crypto = NULL;
2342
2343     qcow2_close(bs);
2344
2345     memset(s, 0, sizeof(BDRVQcow2State));
2346     options = qdict_clone_shallow(bs->options);
2347
2348     flags &= ~BDRV_O_INACTIVE;
2349     qemu_co_mutex_lock(&s->lock);
2350     ret = qcow2_do_open(bs, options, flags, &local_err);
2351     qemu_co_mutex_unlock(&s->lock);
2352     qobject_unref(options);
2353     if (local_err) {
2354         error_propagate_prepend(errp, local_err,
2355                                 "Could not reopen qcow2 layer: ");
2356         bs->drv = NULL;
2357         return;
2358     } else if (ret < 0) {
2359         error_setg_errno(errp, -ret, "Could not reopen qcow2 layer");
2360         bs->drv = NULL;
2361         return;
2362     }
2363
2364     s->crypto = crypto;
2365 }
2366
2367 static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
2368     size_t len, size_t buflen)
2369 {
2370     QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
2371     size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
2372
2373     if (buflen < ext_len) {
2374         return -ENOSPC;
2375     }
2376
2377     *ext_backing_fmt = (QCowExtension) {
2378         .magic  = cpu_to_be32(magic),
2379         .len    = cpu_to_be32(len),
2380     };
2381
2382     if (len) {
2383         memcpy(buf + sizeof(QCowExtension), s, len);
2384     }
2385
2386     return ext_len;
2387 }
2388
2389 /*
2390  * Updates the qcow2 header, including the variable length parts of it, i.e.
2391  * the backing file name and all extensions. qcow2 was not designed to allow
2392  * such changes, so if we run out of space (we can only use the first cluster)
2393  * this function may fail.
2394  *
2395  * Returns 0 on success, -errno in error cases.
2396  */
2397 int qcow2_update_header(BlockDriverState *bs)
2398 {
2399     BDRVQcow2State *s = bs->opaque;
2400     QCowHeader *header;
2401     char *buf;
2402     size_t buflen = s->cluster_size;
2403     int ret;
2404     uint64_t total_size;
2405     uint32_t refcount_table_clusters;
2406     size_t header_length;
2407     Qcow2UnknownHeaderExtension *uext;
2408
2409     buf = qemu_blockalign(bs, buflen);
2410
2411     /* Header structure */
2412     header = (QCowHeader*) buf;
2413
2414     if (buflen < sizeof(*header)) {
2415         ret = -ENOSPC;
2416         goto fail;
2417     }
2418
2419     header_length = sizeof(*header) + s->unknown_header_fields_size;
2420     total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
2421     refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
2422
2423     *header = (QCowHeader) {
2424         /* Version 2 fields */
2425         .magic                  = cpu_to_be32(QCOW_MAGIC),
2426         .version                = cpu_to_be32(s->qcow_version),
2427         .backing_file_offset    = 0,
2428         .backing_file_size      = 0,
2429         .cluster_bits           = cpu_to_be32(s->cluster_bits),
2430         .size                   = cpu_to_be64(total_size),
2431         .crypt_method           = cpu_to_be32(s->crypt_method_header),
2432         .l1_size                = cpu_to_be32(s->l1_size),
2433         .l1_table_offset        = cpu_to_be64(s->l1_table_offset),
2434         .refcount_table_offset  = cpu_to_be64(s->refcount_table_offset),
2435         .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
2436         .nb_snapshots           = cpu_to_be32(s->nb_snapshots),
2437         .snapshots_offset       = cpu_to_be64(s->snapshots_offset),
2438
2439         /* Version 3 fields */
2440         .incompatible_features  = cpu_to_be64(s->incompatible_features),
2441         .compatible_features    = cpu_to_be64(s->compatible_features),
2442         .autoclear_features     = cpu_to_be64(s->autoclear_features),
2443         .refcount_order         = cpu_to_be32(s->refcount_order),
2444         .header_length          = cpu_to_be32(header_length),
2445     };
2446
2447     /* For older versions, write a shorter header */
2448     switch (s->qcow_version) {
2449     case 2:
2450         ret = offsetof(QCowHeader, incompatible_features);
2451         break;
2452     case 3:
2453         ret = sizeof(*header);
2454         break;
2455     default:
2456         ret = -EINVAL;
2457         goto fail;
2458     }
2459
2460     buf += ret;
2461     buflen -= ret;
2462     memset(buf, 0, buflen);
2463
2464     /* Preserve any unknown field in the header */
2465     if (s->unknown_header_fields_size) {
2466         if (buflen < s->unknown_header_fields_size) {
2467             ret = -ENOSPC;
2468             goto fail;
2469         }
2470
2471         memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
2472         buf += s->unknown_header_fields_size;
2473         buflen -= s->unknown_header_fields_size;
2474     }
2475
2476     /* Backing file format header extension */
2477     if (s->image_backing_format) {
2478         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
2479                              s->image_backing_format,
2480                              strlen(s->image_backing_format),
2481                              buflen);
2482         if (ret < 0) {
2483             goto fail;
2484         }
2485
2486         buf += ret;
2487         buflen -= ret;
2488     }
2489
2490     /* External data file header extension */
2491     if (has_data_file(bs) && s->image_data_file) {
2492         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_DATA_FILE,
2493                              s->image_data_file, strlen(s->image_data_file),
2494                              buflen);
2495         if (ret < 0) {
2496             goto fail;
2497         }
2498
2499         buf += ret;
2500         buflen -= ret;
2501     }
2502
2503     /* Full disk encryption header pointer extension */
2504     if (s->crypto_header.offset != 0) {
2505         s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset);
2506         s->crypto_header.length = cpu_to_be64(s->crypto_header.length);
2507         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
2508                              &s->crypto_header, sizeof(s->crypto_header),
2509                              buflen);
2510         s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
2511         s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
2512         if (ret < 0) {
2513             goto fail;
2514         }
2515         buf += ret;
2516         buflen -= ret;
2517     }
2518
2519     /* Feature table */
2520     if (s->qcow_version >= 3) {
2521         Qcow2Feature features[] = {
2522             {
2523                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2524                 .bit  = QCOW2_INCOMPAT_DIRTY_BITNR,
2525                 .name = "dirty bit",
2526             },
2527             {
2528                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2529                 .bit  = QCOW2_INCOMPAT_CORRUPT_BITNR,
2530                 .name = "corrupt bit",
2531             },
2532             {
2533                 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2534                 .bit  = QCOW2_INCOMPAT_DATA_FILE_BITNR,
2535                 .name = "external data file",
2536             },
2537             {
2538                 .type = QCOW2_FEAT_TYPE_COMPATIBLE,
2539                 .bit  = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
2540                 .name = "lazy refcounts",
2541             },
2542         };
2543
2544         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
2545                              features, sizeof(features), buflen);
2546         if (ret < 0) {
2547             goto fail;
2548         }
2549         buf += ret;
2550         buflen -= ret;
2551     }
2552
2553     /* Bitmap extension */
2554     if (s->nb_bitmaps > 0) {
2555         Qcow2BitmapHeaderExt bitmaps_header = {
2556             .nb_bitmaps = cpu_to_be32(s->nb_bitmaps),
2557             .bitmap_directory_size =
2558                     cpu_to_be64(s->bitmap_directory_size),
2559             .bitmap_directory_offset =
2560                     cpu_to_be64(s->bitmap_directory_offset)
2561         };
2562         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS,
2563                              &bitmaps_header, sizeof(bitmaps_header),
2564                              buflen);
2565         if (ret < 0) {
2566             goto fail;
2567         }
2568         buf += ret;
2569         buflen -= ret;
2570     }
2571
2572     /* Keep unknown header extensions */
2573     QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
2574         ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
2575         if (ret < 0) {
2576             goto fail;
2577         }
2578
2579         buf += ret;
2580         buflen -= ret;
2581     }
2582
2583     /* End of header extensions */
2584     ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
2585     if (ret < 0) {
2586         goto fail;
2587     }
2588
2589     buf += ret;
2590     buflen -= ret;
2591
2592     /* Backing file name */
2593     if (s->image_backing_file) {
2594         size_t backing_file_len = strlen(s->image_backing_file);
2595
2596         if (buflen < backing_file_len) {
2597             ret = -ENOSPC;
2598             goto fail;
2599         }
2600
2601         /* Using strncpy is ok here, since buf is not NUL-terminated. */
2602         strncpy(buf, s->image_backing_file, buflen);
2603
2604         header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
2605         header->backing_file_size   = cpu_to_be32(backing_file_len);
2606     }
2607
2608     /* Write the new header */
2609     ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
2610     if (ret < 0) {
2611         goto fail;
2612     }
2613
2614     ret = 0;
2615 fail:
2616     qemu_vfree(header);
2617     return ret;
2618 }
2619
2620 static int qcow2_change_backing_file(BlockDriverState *bs,
2621     const char *backing_file, const char *backing_fmt)
2622 {
2623     BDRVQcow2State *s = bs->opaque;
2624
2625     /* Adding a backing file means that the external data file alone won't be
2626      * enough to make sense of the content */
2627     if (backing_file && data_file_is_raw(bs)) {
2628         return -EINVAL;
2629     }
2630
2631     if (backing_file && strlen(backing_file) > 1023) {
2632         return -EINVAL;
2633     }
2634
2635     pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
2636             backing_file ?: "");
2637     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2638     pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2639
2640     g_free(s->image_backing_file);
2641     g_free(s->image_backing_format);
2642
2643     s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
2644     s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
2645
2646     return qcow2_update_header(bs);
2647 }
2648
2649 static int qcow2_crypt_method_from_format(const char *encryptfmt)
2650 {
2651     if (g_str_equal(encryptfmt, "luks")) {
2652         return QCOW_CRYPT_LUKS;
2653     } else if (g_str_equal(encryptfmt, "aes")) {
2654         return QCOW_CRYPT_AES;
2655     } else {
2656         return -EINVAL;
2657     }
2658 }
2659
2660 static int qcow2_set_up_encryption(BlockDriverState *bs,
2661                                    QCryptoBlockCreateOptions *cryptoopts,
2662                                    Error **errp)
2663 {
2664     BDRVQcow2State *s = bs->opaque;
2665     QCryptoBlock *crypto = NULL;
2666     int fmt, ret;
2667
2668     switch (cryptoopts->format) {
2669     case Q_CRYPTO_BLOCK_FORMAT_LUKS:
2670         fmt = QCOW_CRYPT_LUKS;
2671         break;
2672     case Q_CRYPTO_BLOCK_FORMAT_QCOW:
2673         fmt = QCOW_CRYPT_AES;
2674         break;
2675     default:
2676         error_setg(errp, "Crypto format not supported in qcow2");
2677         return -EINVAL;
2678     }
2679
2680     s->crypt_method_header = fmt;
2681
2682     crypto = qcrypto_block_create(cryptoopts, "encrypt.",
2683                                   qcow2_crypto_hdr_init_func,
2684                                   qcow2_crypto_hdr_write_func,
2685                                   bs, errp);
2686     if (!crypto) {
2687         return -EINVAL;
2688     }
2689
2690     ret = qcow2_update_header(bs);
2691     if (ret < 0) {
2692         error_setg_errno(errp, -ret, "Could not write encryption header");
2693         goto out;
2694     }
2695
2696     ret = 0;
2697  out:
2698     qcrypto_block_free(crypto);
2699     return ret;
2700 }
2701
2702 /**
2703  * Preallocates metadata structures for data clusters between @offset (in the
2704  * guest disk) and @new_length (which is thus generally the new guest disk
2705  * size).
2706  *
2707  * Returns: 0 on success, -errno on failure.
2708  */
2709 static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
2710                                        uint64_t new_length, PreallocMode mode,
2711                                        Error **errp)
2712 {
2713     BDRVQcow2State *s = bs->opaque;
2714     uint64_t bytes;
2715     uint64_t host_offset = 0;
2716     int64_t file_length;
2717     unsigned int cur_bytes;
2718     int ret;
2719     QCowL2Meta *meta;
2720
2721     assert(offset <= new_length);
2722     bytes = new_length - offset;
2723
2724     while (bytes) {
2725         cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size));
2726         ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,
2727                                          &host_offset, &meta);
2728         if (ret < 0) {
2729             error_setg_errno(errp, -ret, "Allocating clusters failed");
2730             return ret;
2731         }
2732
2733         while (meta) {
2734             QCowL2Meta *next = meta->next;
2735
2736             ret = qcow2_alloc_cluster_link_l2(bs, meta);
2737             if (ret < 0) {
2738                 error_setg_errno(errp, -ret, "Mapping clusters failed");
2739                 qcow2_free_any_clusters(bs, meta->alloc_offset,
2740                                         meta->nb_clusters, QCOW2_DISCARD_NEVER);
2741                 return ret;
2742             }
2743
2744             /* There are no dependent requests, but we need to remove our
2745              * request from the list of in-flight requests */
2746             QLIST_REMOVE(meta, next_in_flight);
2747
2748             g_free(meta);
2749             meta = next;
2750         }
2751
2752         /* TODO Preallocate data if requested */
2753
2754         bytes -= cur_bytes;
2755         offset += cur_bytes;
2756     }
2757
2758     /*
2759      * It is expected that the image file is large enough to actually contain
2760      * all of the allocated clusters (otherwise we get failing reads after
2761      * EOF). Extend the image to the last allocated sector.
2762      */
2763     file_length = bdrv_getlength(s->data_file->bs);
2764     if (file_length < 0) {
2765         error_setg_errno(errp, -file_length, "Could not get file size");
2766         return file_length;
2767     }
2768
2769     if (host_offset + cur_bytes > file_length) {
2770         if (mode == PREALLOC_MODE_METADATA) {
2771             mode = PREALLOC_MODE_OFF;
2772         }
2773         ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, mode,
2774                                errp);
2775         if (ret < 0) {
2776             return ret;
2777         }
2778     }
2779
2780     return 0;
2781 }
2782
2783 /* qcow2_refcount_metadata_size:
2784  * @clusters: number of clusters to refcount (including data and L1/L2 tables)
2785  * @cluster_size: size of a cluster, in bytes
2786  * @refcount_order: refcount bits power-of-2 exponent
2787  * @generous_increase: allow for the refcount table to be 1.5x as large as it
2788  *                     needs to be
2789  *
2790  * Returns: Number of bytes required for refcount blocks and table metadata.
2791  */
2792 int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
2793                                      int refcount_order, bool generous_increase,
2794                                      uint64_t *refblock_count)
2795 {
2796     /*
2797      * Every host cluster is reference-counted, including metadata (even
2798      * refcount metadata is recursively included).
2799      *
2800      * An accurate formula for the size of refcount metadata size is difficult
2801      * to derive.  An easier method of calculation is finding the fixed point
2802      * where no further refcount blocks or table clusters are required to
2803      * reference count every cluster.
2804      */
2805     int64_t blocks_per_table_cluster = cluster_size / sizeof(uint64_t);
2806     int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order);
2807     int64_t table = 0;  /* number of refcount table clusters */
2808     int64_t blocks = 0; /* number of refcount block clusters */
2809     int64_t last;
2810     int64_t n = 0;
2811
2812     do {
2813         last = n;
2814         blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block);
2815         table = DIV_ROUND_UP(blocks, blocks_per_table_cluster);
2816         n = clusters + blocks + table;
2817
2818         if (n == last && generous_increase) {
2819             clusters += DIV_ROUND_UP(table, 2);
2820             n = 0; /* force another loop */
2821             generous_increase = false;
2822         }
2823     } while (n != last);
2824
2825     if (refblock_count) {
2826         *refblock_count = blocks;
2827     }
2828
2829     return (blocks + table) * cluster_size;
2830 }
2831
2832 /**
2833  * qcow2_calc_prealloc_size:
2834  * @total_size: virtual disk size in bytes
2835  * @cluster_size: cluster size in bytes
2836  * @refcount_order: refcount bits power-of-2 exponent
2837  *
2838  * Returns: Total number of bytes required for the fully allocated image
2839  * (including metadata).
2840  */
2841 static int64_t qcow2_calc_prealloc_size(int64_t total_size,
2842                                         size_t cluster_size,
2843                                         int refcount_order)
2844 {
2845     int64_t meta_size = 0;
2846     uint64_t nl1e, nl2e;
2847     int64_t aligned_total_size = ROUND_UP(total_size, cluster_size);
2848
2849     /* header: 1 cluster */
2850     meta_size += cluster_size;
2851
2852     /* total size of L2 tables */
2853     nl2e = aligned_total_size / cluster_size;
2854     nl2e = ROUND_UP(nl2e, cluster_size / sizeof(uint64_t));
2855     meta_size += nl2e * sizeof(uint64_t);
2856
2857     /* total size of L1 tables */
2858     nl1e = nl2e * sizeof(uint64_t) / cluster_size;
2859     nl1e = ROUND_UP(nl1e, cluster_size / sizeof(uint64_t));
2860     meta_size += nl1e * sizeof(uint64_t);
2861
2862     /* total size of refcount table and blocks */
2863     meta_size += qcow2_refcount_metadata_size(
2864             (meta_size + aligned_total_size) / cluster_size,
2865             cluster_size, refcount_order, false, NULL);
2866
2867     return meta_size + aligned_total_size;
2868 }
2869
2870 static bool validate_cluster_size(size_t cluster_size, Error **errp)
2871 {
2872     int cluster_bits = ctz32(cluster_size);
2873     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
2874         (1 << cluster_bits) != cluster_size)
2875     {
2876         error_setg(errp, "Cluster size must be a power of two between %d and "
2877                    "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
2878         return false;
2879     }
2880     return true;
2881 }
2882
2883 static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, Error **errp)
2884 {
2885     size_t cluster_size;
2886
2887     cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
2888                                          DEFAULT_CLUSTER_SIZE);
2889     if (!validate_cluster_size(cluster_size, errp)) {
2890         return 0;
2891     }
2892     return cluster_size;
2893 }
2894
2895 static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp)
2896 {
2897     char *buf;
2898     int ret;
2899
2900     buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
2901     if (!buf) {
2902         ret = 3; /* default */
2903     } else if (!strcmp(buf, "0.10")) {
2904         ret = 2;
2905     } else if (!strcmp(buf, "1.1")) {
2906         ret = 3;
2907     } else {
2908         error_setg(errp, "Invalid compatibility level: '%s'", buf);
2909         ret = -EINVAL;
2910     }
2911     g_free(buf);
2912     return ret;
2913 }
2914
2915 static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
2916                                                 Error **errp)
2917 {
2918     uint64_t refcount_bits;
2919
2920     refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16);
2921     if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
2922         error_setg(errp, "Refcount width must be a power of two and may not "
2923                    "exceed 64 bits");
2924         return 0;
2925     }
2926
2927     if (version < 3 && refcount_bits != 16) {
2928         error_setg(errp, "Different refcount widths than 16 bits require "
2929                    "compatibility level 1.1 or above (use compat=1.1 or "
2930                    "greater)");
2931         return 0;
2932     }
2933
2934     return refcount_bits;
2935 }
2936
2937 static int coroutine_fn
2938 qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
2939 {
2940     BlockdevCreateOptionsQcow2 *qcow2_opts;
2941     QDict *options;
2942
2943     /*
2944      * Open the image file and write a minimal qcow2 header.
2945      *
2946      * We keep things simple and start with a zero-sized image. We also
2947      * do without refcount blocks or a L1 table for now. We'll fix the
2948      * inconsistency later.
2949      *
2950      * We do need a refcount table because growing the refcount table means
2951      * allocating two new refcount blocks - the seconds of which would be at
2952      * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
2953      * size for any qcow2 image.
2954      */
2955     BlockBackend *blk = NULL;
2956     BlockDriverState *bs = NULL;
2957     BlockDriverState *data_bs = NULL;
2958     QCowHeader *header;
2959     size_t cluster_size;
2960     int version;
2961     int refcount_order;
2962     uint64_t* refcount_table;
2963     Error *local_err = NULL;
2964     int ret;
2965
2966     assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2);
2967     qcow2_opts = &create_options->u.qcow2;
2968
2969     bs = bdrv_open_blockdev_ref(qcow2_opts->file, errp);
2970     if (bs == NULL) {
2971         return -EIO;
2972     }
2973
2974     /* Validate options and set default values */
2975     if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) {
2976         error_setg(errp, "Image size must be a multiple of 512 bytes");
2977         ret = -EINVAL;
2978         goto out;
2979     }
2980
2981     if (qcow2_opts->has_version) {
2982         switch (qcow2_opts->version) {
2983         case BLOCKDEV_QCOW2_VERSION_V2:
2984             version = 2;
2985             break;
2986         case BLOCKDEV_QCOW2_VERSION_V3:
2987             version = 3;
2988             break;
2989         default:
2990             g_assert_not_reached();
2991         }
2992     } else {
2993         version = 3;
2994     }
2995
2996     if (qcow2_opts->has_cluster_size) {
2997         cluster_size = qcow2_opts->cluster_size;
2998     } else {
2999         cluster_size = DEFAULT_CLUSTER_SIZE;
3000     }
3001
3002     if (!validate_cluster_size(cluster_size, errp)) {
3003         ret = -EINVAL;
3004         goto out;
3005     }
3006
3007     if (!qcow2_opts->has_preallocation) {
3008         qcow2_opts->preallocation = PREALLOC_MODE_OFF;
3009     }
3010     if (qcow2_opts->has_backing_file &&
3011         qcow2_opts->preallocation != PREALLOC_MODE_OFF)
3012     {
3013         error_setg(errp, "Backing file and preallocation cannot be used at "
3014                    "the same time");
3015         ret = -EINVAL;
3016         goto out;
3017     }
3018     if (qcow2_opts->has_backing_fmt && !qcow2_opts->has_backing_file) {
3019         error_setg(errp, "Backing format cannot be used without backing file");
3020         ret = -EINVAL;
3021         goto out;
3022     }
3023
3024     if (!qcow2_opts->has_lazy_refcounts) {
3025         qcow2_opts->lazy_refcounts = false;
3026     }
3027     if (version < 3 && qcow2_opts->lazy_refcounts) {
3028         error_setg(errp, "Lazy refcounts only supported with compatibility "
3029                    "level 1.1 and above (use version=v3 or greater)");
3030         ret = -EINVAL;
3031         goto out;
3032     }
3033
3034     if (!qcow2_opts->has_refcount_bits) {
3035         qcow2_opts->refcount_bits = 16;
3036     }
3037     if (qcow2_opts->refcount_bits > 64 ||
3038         !is_power_of_2(qcow2_opts->refcount_bits))
3039     {
3040         error_setg(errp, "Refcount width must be a power of two and may not "
3041                    "exceed 64 bits");
3042         ret = -EINVAL;
3043         goto out;
3044     }
3045     if (version < 3 && qcow2_opts->refcount_bits != 16) {
3046         error_setg(errp, "Different refcount widths than 16 bits require "
3047                    "compatibility level 1.1 or above (use version=v3 or "
3048                    "greater)");
3049         ret = -EINVAL;
3050         goto out;
3051     }
3052     refcount_order = ctz32(qcow2_opts->refcount_bits);
3053
3054     if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) {
3055         error_setg(errp, "data-file-raw requires data-file");
3056         ret = -EINVAL;
3057         goto out;
3058     }
3059     if (qcow2_opts->data_file_raw && qcow2_opts->has_backing_file) {
3060         error_setg(errp, "Backing file and data-file-raw cannot be used at "
3061                    "the same time");
3062         ret = -EINVAL;
3063         goto out;
3064     }
3065
3066     if (qcow2_opts->data_file) {
3067         if (version < 3) {
3068             error_setg(errp, "External data files are only supported with "
3069                        "compatibility level 1.1 and above (use version=v3 or "
3070                        "greater)");
3071             ret = -EINVAL;
3072             goto out;
3073         }
3074         data_bs = bdrv_open_blockdev_ref(qcow2_opts->data_file, errp);
3075         if (data_bs == NULL) {
3076             ret = -EIO;
3077             goto out;
3078         }
3079     }
3080
3081     /* Create BlockBackend to write to the image */
3082     blk = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
3083     ret = blk_insert_bs(blk, bs, errp);
3084     if (ret < 0) {
3085         goto out;
3086     }
3087     blk_set_allow_write_beyond_eof(blk, true);
3088
3089     /* Clear the protocol layer and preallocate it if necessary */
3090     ret = blk_truncate(blk, 0, PREALLOC_MODE_OFF, errp);
3091     if (ret < 0) {
3092         goto out;
3093     }
3094
3095     /* Write the header */
3096     QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
3097     header = g_malloc0(cluster_size);
3098     *header = (QCowHeader) {
3099         .magic                      = cpu_to_be32(QCOW_MAGIC),
3100         .version                    = cpu_to_be32(version),
3101         .cluster_bits               = cpu_to_be32(ctz32(cluster_size)),
3102         .size                       = cpu_to_be64(0),
3103         .l1_table_offset            = cpu_to_be64(0),
3104         .l1_size                    = cpu_to_be32(0),
3105         .refcount_table_offset      = cpu_to_be64(cluster_size),
3106         .refcount_table_clusters    = cpu_to_be32(1),
3107         .refcount_order             = cpu_to_be32(refcount_order),
3108         .header_length              = cpu_to_be32(sizeof(*header)),
3109     };
3110
3111     /* We'll update this to correct value later */
3112     header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
3113
3114     if (qcow2_opts->lazy_refcounts) {
3115         header->compatible_features |=
3116             cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
3117     }
3118     if (data_bs) {
3119         header->incompatible_features |=
3120             cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE);
3121     }
3122     if (qcow2_opts->data_file_raw) {
3123         header->autoclear_features |=
3124             cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW);
3125     }
3126
3127     ret = blk_pwrite(blk, 0, header, cluster_size, 0);
3128     g_free(header);
3129     if (ret < 0) {
3130         error_setg_errno(errp, -ret, "Could not write qcow2 header");
3131         goto out;
3132     }
3133
3134     /* Write a refcount table with one refcount block */
3135     refcount_table = g_malloc0(2 * cluster_size);
3136     refcount_table[0] = cpu_to_be64(2 * cluster_size);
3137     ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
3138     g_free(refcount_table);
3139
3140     if (ret < 0) {
3141         error_setg_errno(errp, -ret, "Could not write refcount table");
3142         goto out;
3143     }
3144
3145     blk_unref(blk);
3146     blk = NULL;
3147
3148     /*
3149      * And now open the image and make it consistent first (i.e. increase the
3150      * refcount of the cluster that is occupied by the header and the refcount
3151      * table)
3152      */
3153     options = qdict_new();
3154     qdict_put_str(options, "driver", "qcow2");
3155     qdict_put_str(options, "file", bs->node_name);
3156     if (data_bs) {
3157         qdict_put_str(options, "data-file", data_bs->node_name);
3158     }
3159     blk = blk_new_open(NULL, NULL, options,
3160                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
3161                        &local_err);
3162     if (blk == NULL) {
3163         error_propagate(errp, local_err);
3164         ret = -EIO;
3165         goto out;
3166     }
3167
3168     ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
3169     if (ret < 0) {
3170         error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
3171                          "header and refcount table");
3172         goto out;
3173
3174     } else if (ret != 0) {
3175         error_report("Huh, first cluster in empty image is already in use?");
3176         abort();
3177     }
3178
3179     /* Set the external data file if necessary */
3180     if (data_bs) {
3181         BDRVQcow2State *s = blk_bs(blk)->opaque;
3182         s->image_data_file = g_strdup(data_bs->filename);
3183     }
3184
3185     /* Create a full header (including things like feature table) */
3186     ret = qcow2_update_header(blk_bs(blk));
3187     if (ret < 0) {
3188         error_setg_errno(errp, -ret, "Could not update qcow2 header");
3189         goto out;
3190     }
3191
3192     /* Okay, now that we have a valid image, let's give it the right size */
3193     ret = blk_truncate(blk, qcow2_opts->size, qcow2_opts->preallocation, errp);
3194     if (ret < 0) {
3195         error_prepend(errp, "Could not resize image: ");
3196         goto out;
3197     }
3198
3199     /* Want a backing file? There you go.*/
3200     if (qcow2_opts->has_backing_file) {
3201         const char *backing_format = NULL;
3202
3203         if (qcow2_opts->has_backing_fmt) {
3204             backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt);
3205         }
3206
3207         ret = bdrv_change_backing_file(blk_bs(blk), qcow2_opts->backing_file,
3208                                        backing_format);
3209         if (ret < 0) {
3210             error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
3211                              "with format '%s'", qcow2_opts->backing_file,
3212                              backing_format);
3213             goto out;
3214         }
3215     }
3216
3217     /* Want encryption? There you go. */
3218     if (qcow2_opts->has_encrypt) {
3219         ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
3220         if (ret < 0) {
3221             goto out;
3222         }
3223     }
3224
3225     blk_unref(blk);
3226     blk = NULL;
3227
3228     /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning.
3229      * Using BDRV_O_NO_IO, since encryption is now setup we don't want to
3230      * have to setup decryption context. We're not doing any I/O on the top
3231      * level BlockDriverState, only lower layers, where BDRV_O_NO_IO does
3232      * not have effect.
3233      */
3234     options = qdict_new();
3235     qdict_put_str(options, "driver", "qcow2");
3236     qdict_put_str(options, "file", bs->node_name);
3237     if (data_bs) {
3238         qdict_put_str(options, "data-file", data_bs->node_name);
3239     }
3240     blk = blk_new_open(NULL, NULL, options,
3241                        BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
3242                        &local_err);
3243     if (blk == NULL) {
3244         error_propagate(errp, local_err);
3245         ret = -EIO;
3246         goto out;
3247     }
3248
3249     ret = 0;
3250 out:
3251     blk_unref(blk);
3252     bdrv_unref(bs);
3253     bdrv_unref(data_bs);
3254     return ret;
3255 }
3256
3257 static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opts,
3258                                              Error **errp)
3259 {
3260     BlockdevCreateOptions *create_options = NULL;
3261     QDict *qdict;
3262     Visitor *v;
3263     BlockDriverState *bs = NULL;
3264     BlockDriverState *data_bs = NULL;
3265     Error *local_err = NULL;
3266     const char *val;
3267     int ret;
3268
3269     /* Only the keyval visitor supports the dotted syntax needed for
3270      * encryption, so go through a QDict before getting a QAPI type. Ignore
3271      * options meant for the protocol layer so that the visitor doesn't
3272      * complain. */
3273     qdict = qemu_opts_to_qdict_filtered(opts, NULL, bdrv_qcow2.create_opts,
3274                                         true);
3275
3276     /* Handle encryption options */
3277     val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT);
3278     if (val && !strcmp(val, "on")) {
3279         qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow");
3280     } else if (val && !strcmp(val, "off")) {
3281         qdict_del(qdict, BLOCK_OPT_ENCRYPT);
3282     }
3283
3284     val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT);
3285     if (val && !strcmp(val, "aes")) {
3286         qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow");
3287     }
3288
3289     /* Convert compat=0.10/1.1 into compat=v2/v3, to be renamed into
3290      * version=v2/v3 below. */
3291     val = qdict_get_try_str(qdict, BLOCK_OPT_COMPAT_LEVEL);
3292     if (val && !strcmp(val, "0.10")) {
3293         qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v2");
3294     } else if (val && !strcmp(val, "1.1")) {
3295         qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v3");
3296     }
3297
3298     /* Change legacy command line options into QMP ones */
3299     static const QDictRenames opt_renames[] = {
3300         { BLOCK_OPT_BACKING_FILE,       "backing-file" },
3301         { BLOCK_OPT_BACKING_FMT,        "backing-fmt" },
3302         { BLOCK_OPT_CLUSTER_SIZE,       "cluster-size" },
3303         { BLOCK_OPT_LAZY_REFCOUNTS,     "lazy-refcounts" },
3304         { BLOCK_OPT_REFCOUNT_BITS,      "refcount-bits" },
3305         { BLOCK_OPT_ENCRYPT,            BLOCK_OPT_ENCRYPT_FORMAT },
3306         { BLOCK_OPT_COMPAT_LEVEL,       "version" },
3307         { BLOCK_OPT_DATA_FILE_RAW,      "data-file-raw" },
3308         { NULL, NULL },
3309     };
3310
3311     if (!qdict_rename_keys(qdict, opt_renames, errp)) {
3312         ret = -EINVAL;
3313         goto finish;
3314     }
3315
3316     /* Create and open the file (protocol layer) */
3317     ret = bdrv_create_file(filename, opts, errp);
3318     if (ret < 0) {
3319         goto finish;
3320     }
3321
3322     bs = bdrv_open(filename, NULL, NULL,
3323                    BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
3324     if (bs == NULL) {
3325         ret = -EIO;
3326         goto finish;
3327     }
3328
3329     /* Create and open an external data file (protocol layer) */
3330     val = qdict_get_try_str(qdict, BLOCK_OPT_DATA_FILE);
3331     if (val) {
3332         ret = bdrv_create_file(val, opts, errp);
3333         if (ret < 0) {
3334             goto finish;
3335         }
3336
3337         data_bs = bdrv_open(val, NULL, NULL,
3338                             BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
3339                             errp);
3340         if (data_bs == NULL) {
3341             ret = -EIO;
3342             goto finish;
3343         }
3344
3345         qdict_del(qdict, BLOCK_OPT_DATA_FILE);
3346         qdict_put_str(qdict, "data-file", data_bs->node_name);
3347     }
3348
3349     /* Set 'driver' and 'node' options */
3350     qdict_put_str(qdict, "driver", "qcow2");
3351     qdict_put_str(qdict, "file", bs->node_name);
3352
3353     /* Now get the QAPI type BlockdevCreateOptions */
3354     v = qobject_input_visitor_new_flat_confused(qdict, errp);
3355     if (!v) {
3356         ret = -EINVAL;
3357         goto finish;
3358     }
3359
3360     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
3361     visit_free(v);
3362
3363     if (local_err) {
3364         error_propagate(errp, local_err);
3365         ret = -EINVAL;
3366         goto finish;
3367     }
3368
3369     /* Silently round up size */
3370     create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size,
3371                                             BDRV_SECTOR_SIZE);
3372
3373     /* Create the qcow2 image (format layer) */
3374     ret = qcow2_co_create(create_options, errp);
3375     if (ret < 0) {
3376         goto finish;
3377     }
3378
3379     ret = 0;
3380 finish:
3381     qobject_unref(qdict);
3382     bdrv_unref(bs);
3383     bdrv_unref(data_bs);
3384     qapi_free_BlockdevCreateOptions(create_options);
3385     return ret;
3386 }
3387
3388
3389 static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
3390 {
3391     int64_t nr;
3392     int res;
3393
3394     /* Clamp to image length, before checking status of underlying sectors */
3395     if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3396         bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset;
3397     }
3398
3399     if (!bytes) {
3400         return true;
3401     }
3402     res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
3403     return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;
3404 }
3405
3406 static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
3407     int64_t offset, int bytes, BdrvRequestFlags flags)
3408 {
3409     int ret;
3410     BDRVQcow2State *s = bs->opaque;
3411
3412     uint32_t head = offset % s->cluster_size;
3413     uint32_t tail = (offset + bytes) % s->cluster_size;
3414
3415     trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes);
3416     if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) {
3417         tail = 0;
3418     }
3419
3420     if (head || tail) {
3421         uint64_t off;
3422         unsigned int nr;
3423
3424         assert(head + bytes <= s->cluster_size);
3425
3426         /* check whether remainder of cluster already reads as zero */
3427         if (!(is_zero(bs, offset - head, head) &&
3428               is_zero(bs, offset + bytes,
3429                       tail ? s->cluster_size - tail : 0))) {
3430             return -ENOTSUP;
3431         }
3432
3433         qemu_co_mutex_lock(&s->lock);
3434         /* We can have new write after previous check */
3435         offset = QEMU_ALIGN_DOWN(offset, s->cluster_size);
3436         bytes = s->cluster_size;
3437         nr = s->cluster_size;
3438         ret = qcow2_get_cluster_offset(bs, offset, &nr, &off);
3439         if (ret != QCOW2_CLUSTER_UNALLOCATED &&
3440             ret != QCOW2_CLUSTER_ZERO_PLAIN &&
3441             ret != QCOW2_CLUSTER_ZERO_ALLOC) {
3442             qemu_co_mutex_unlock(&s->lock);
3443             return -ENOTSUP;
3444         }
3445     } else {
3446         qemu_co_mutex_lock(&s->lock);
3447     }
3448
3449     trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes);
3450
3451     /* Whatever is left can use real zero clusters */
3452     ret = qcow2_cluster_zeroize(bs, offset, bytes, flags);
3453     qemu_co_mutex_unlock(&s->lock);
3454
3455     return ret;
3456 }
3457
3458 static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
3459                                           int64_t offset, int bytes)
3460 {
3461     int ret;
3462     BDRVQcow2State *s = bs->opaque;
3463
3464     if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) {
3465         assert(bytes < s->cluster_size);
3466         /* Ignore partial clusters, except for the special case of the
3467          * complete partial cluster at the end of an unaligned file */
3468         if (!QEMU_IS_ALIGNED(offset, s->cluster_size) ||
3469             offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) {
3470             return -ENOTSUP;
3471         }
3472     }
3473
3474     qemu_co_mutex_lock(&s->lock);
3475     ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST,
3476                                 false);
3477     qemu_co_mutex_unlock(&s->lock);
3478     return ret;
3479 }
3480
3481 static int coroutine_fn
3482 qcow2_co_copy_range_from(BlockDriverState *bs,
3483                          BdrvChild *src, uint64_t src_offset,
3484                          BdrvChild *dst, uint64_t dst_offset,
3485                          uint64_t bytes, BdrvRequestFlags read_flags,
3486                          BdrvRequestFlags write_flags)
3487 {
3488     BDRVQcow2State *s = bs->opaque;
3489     int ret;
3490     unsigned int cur_bytes; /* number of bytes in current iteration */
3491     BdrvChild *child = NULL;
3492     BdrvRequestFlags cur_write_flags;
3493
3494     assert(!bs->encrypted);
3495     qemu_co_mutex_lock(&s->lock);
3496
3497     while (bytes != 0) {
3498         uint64_t copy_offset = 0;
3499         /* prepare next request */
3500         cur_bytes = MIN(bytes, INT_MAX);
3501         cur_write_flags = write_flags;
3502
3503         ret = qcow2_get_cluster_offset(bs, src_offset, &cur_bytes, &copy_offset);
3504         if (ret < 0) {
3505             goto out;
3506         }
3507
3508         switch (ret) {
3509         case QCOW2_CLUSTER_UNALLOCATED:
3510             if (bs->backing && bs->backing->bs) {
3511                 int64_t backing_length = bdrv_getlength(bs->backing->bs);
3512                 if (src_offset >= backing_length) {
3513                     cur_write_flags |= BDRV_REQ_ZERO_WRITE;
3514                 } else {
3515                     child = bs->backing;
3516                     cur_bytes = MIN(cur_bytes, backing_length - src_offset);
3517                     copy_offset = src_offset;
3518                 }
3519             } else {
3520                 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
3521             }
3522             break;
3523
3524         case QCOW2_CLUSTER_ZERO_PLAIN:
3525         case QCOW2_CLUSTER_ZERO_ALLOC:
3526             cur_write_flags |= BDRV_REQ_ZERO_WRITE;
3527             break;
3528
3529         case QCOW2_CLUSTER_COMPRESSED:
3530             ret = -ENOTSUP;
3531             goto out;
3532
3533         case QCOW2_CLUSTER_NORMAL:
3534             child = s->data_file;
3535             copy_offset += offset_into_cluster(s, src_offset);
3536             if ((copy_offset & 511) != 0) {
3537                 ret = -EIO;
3538                 goto out;
3539             }
3540             break;
3541
3542         default:
3543             abort();
3544         }
3545         qemu_co_mutex_unlock(&s->lock);
3546         ret = bdrv_co_copy_range_from(child,
3547                                       copy_offset,
3548                                       dst, dst_offset,
3549                                       cur_bytes, read_flags, cur_write_flags);
3550         qemu_co_mutex_lock(&s->lock);
3551         if (ret < 0) {
3552             goto out;
3553         }
3554
3555         bytes -= cur_bytes;
3556         src_offset += cur_bytes;
3557         dst_offset += cur_bytes;
3558     }
3559     ret = 0;
3560
3561 out:
3562     qemu_co_mutex_unlock(&s->lock);
3563     return ret;
3564 }
3565
3566 static int coroutine_fn
3567 qcow2_co_copy_range_to(BlockDriverState *bs,
3568                        BdrvChild *src, uint64_t src_offset,
3569                        BdrvChild *dst, uint64_t dst_offset,
3570                        uint64_t bytes, BdrvRequestFlags read_flags,
3571                        BdrvRequestFlags write_flags)
3572 {
3573     BDRVQcow2State *s = bs->opaque;
3574     int offset_in_cluster;
3575     int ret;
3576     unsigned int cur_bytes; /* number of sectors in current iteration */
3577     uint64_t cluster_offset;
3578     QCowL2Meta *l2meta = NULL;
3579
3580     assert(!bs->encrypted);
3581
3582     qemu_co_mutex_lock(&s->lock);
3583
3584     while (bytes != 0) {
3585
3586         l2meta = NULL;
3587
3588         offset_in_cluster = offset_into_cluster(s, dst_offset);
3589         cur_bytes = MIN(bytes, INT_MAX);
3590
3591         /* TODO:
3592          * If src->bs == dst->bs, we could simply copy by incrementing
3593          * the refcnt, without copying user data.
3594          * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
3595         ret = qcow2_alloc_cluster_offset(bs, dst_offset, &cur_bytes,
3596                                          &cluster_offset, &l2meta);
3597         if (ret < 0) {
3598             goto fail;
3599         }
3600
3601         assert((cluster_offset & 511) == 0);
3602
3603         ret = qcow2_pre_write_overlap_check(bs, 0,
3604                 cluster_offset + offset_in_cluster, cur_bytes, true);
3605         if (ret < 0) {
3606             goto fail;
3607         }
3608
3609         qemu_co_mutex_unlock(&s->lock);
3610         ret = bdrv_co_copy_range_to(src, src_offset,
3611                                     s->data_file,
3612                                     cluster_offset + offset_in_cluster,
3613                                     cur_bytes, read_flags, write_flags);
3614         qemu_co_mutex_lock(&s->lock);
3615         if (ret < 0) {
3616             goto fail;
3617         }
3618
3619         ret = qcow2_handle_l2meta(bs, &l2meta, true);
3620         if (ret) {
3621             goto fail;
3622         }
3623
3624         bytes -= cur_bytes;
3625         src_offset += cur_bytes;
3626         dst_offset += cur_bytes;
3627     }
3628     ret = 0;
3629
3630 fail:
3631     qcow2_handle_l2meta(bs, &l2meta, false);
3632
3633     qemu_co_mutex_unlock(&s->lock);
3634
3635     trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
3636
3637     return ret;
3638 }
3639
3640 static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
3641                                           PreallocMode prealloc, Error **errp)
3642 {
3643     BDRVQcow2State *s = bs->opaque;
3644     uint64_t old_length;
3645     int64_t new_l1_size;
3646     int ret;
3647     QDict *options;
3648
3649     if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA &&
3650         prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL)
3651     {
3652         error_setg(errp, "Unsupported preallocation mode '%s'",
3653                    PreallocMode_str(prealloc));
3654         return -ENOTSUP;
3655     }
3656
3657     if (offset & 511) {
3658         error_setg(errp, "The new size must be a multiple of 512");
3659         return -EINVAL;
3660     }
3661
3662     qemu_co_mutex_lock(&s->lock);
3663
3664     /* cannot proceed if image has snapshots */
3665     if (s->nb_snapshots) {
3666         error_setg(errp, "Can't resize an image which has snapshots");
3667         ret = -ENOTSUP;
3668         goto fail;
3669     }
3670
3671     /* cannot proceed if image has bitmaps */
3672     if (qcow2_truncate_bitmaps_check(bs, errp)) {
3673         ret = -ENOTSUP;
3674         goto fail;
3675     }
3676
3677     old_length = bs->total_sectors * BDRV_SECTOR_SIZE;
3678     new_l1_size = size_to_l1(s, offset);
3679
3680     if (offset < old_length) {
3681         int64_t last_cluster, old_file_size;
3682         if (prealloc != PREALLOC_MODE_OFF) {
3683             error_setg(errp,
3684                        "Preallocation can't be used for shrinking an image");
3685             ret = -EINVAL;
3686             goto fail;
3687         }
3688
3689         ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size),
3690                                     old_length - ROUND_UP(offset,
3691                                                           s->cluster_size),
3692                                     QCOW2_DISCARD_ALWAYS, true);
3693         if (ret < 0) {
3694             error_setg_errno(errp, -ret, "Failed to discard cropped clusters");
3695             goto fail;
3696         }
3697
3698         ret = qcow2_shrink_l1_table(bs, new_l1_size);
3699         if (ret < 0) {
3700             error_setg_errno(errp, -ret,
3701                              "Failed to reduce the number of L2 tables");
3702             goto fail;
3703         }
3704
3705         ret = qcow2_shrink_reftable(bs);
3706         if (ret < 0) {
3707             error_setg_errno(errp, -ret,
3708                              "Failed to discard unused refblocks");
3709             goto fail;
3710         }
3711
3712         old_file_size = bdrv_getlength(bs->file->bs);
3713         if (old_file_size < 0) {
3714             error_setg_errno(errp, -old_file_size,
3715                              "Failed to inquire current file length");
3716             ret = old_file_size;
3717             goto fail;
3718         }
3719         last_cluster = qcow2_get_last_cluster(bs, old_file_size);
3720         if (last_cluster < 0) {
3721             error_setg_errno(errp, -last_cluster,
3722                              "Failed to find the last cluster");
3723             ret = last_cluster;
3724             goto fail;
3725         }
3726         if ((last_cluster + 1) * s->cluster_size < old_file_size) {
3727             Error *local_err = NULL;
3728
3729             bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
3730                              PREALLOC_MODE_OFF, &local_err);
3731             if (local_err) {
3732                 warn_reportf_err(local_err,
3733                                  "Failed to truncate the tail of the image: ");
3734             }
3735         }
3736     } else {
3737         ret = qcow2_grow_l1_table(bs, new_l1_size, true);
3738         if (ret < 0) {
3739             error_setg_errno(errp, -ret, "Failed to grow the L1 table");
3740             goto fail;
3741         }
3742     }
3743
3744     switch (prealloc) {
3745     case PREALLOC_MODE_OFF:
3746         if (has_data_file(bs)) {
3747             ret = bdrv_co_truncate(s->data_file, offset, prealloc, errp);
3748             if (ret < 0) {
3749                 goto fail;
3750             }
3751         }
3752         break;
3753
3754     case PREALLOC_MODE_METADATA:
3755         ret = preallocate_co(bs, old_length, offset, prealloc, errp);
3756         if (ret < 0) {
3757             goto fail;
3758         }
3759         break;
3760
3761     case PREALLOC_MODE_FALLOC:
3762     case PREALLOC_MODE_FULL:
3763     {
3764         int64_t allocation_start, host_offset, guest_offset;
3765         int64_t clusters_allocated;
3766         int64_t old_file_size, new_file_size;
3767         uint64_t nb_new_data_clusters, nb_new_l2_tables;
3768
3769         /* With a data file, preallocation means just allocating the metadata
3770          * and forwarding the truncate request to the data file */
3771         if (has_data_file(bs)) {
3772             ret = preallocate_co(bs, old_length, offset, prealloc, errp);
3773             if (ret < 0) {
3774                 goto fail;
3775             }
3776             break;
3777         }
3778
3779         old_file_size = bdrv_getlength(bs->file->bs);
3780         if (old_file_size < 0) {
3781             error_setg_errno(errp, -old_file_size,
3782                              "Failed to inquire current file length");
3783             ret = old_file_size;
3784             goto fail;
3785         }
3786         old_file_size = ROUND_UP(old_file_size, s->cluster_size);
3787
3788         nb_new_data_clusters = DIV_ROUND_UP(offset - old_length,
3789                                             s->cluster_size);
3790
3791         /* This is an overestimation; we will not actually allocate space for
3792          * these in the file but just make sure the new refcount structures are
3793          * able to cover them so we will not have to allocate new refblocks
3794          * while entering the data blocks in the potentially new L2 tables.
3795          * (We do not actually care where the L2 tables are placed. Maybe they
3796          *  are already allocated or they can be placed somewhere before
3797          *  @old_file_size. It does not matter because they will be fully
3798          *  allocated automatically, so they do not need to be covered by the
3799          *  preallocation. All that matters is that we will not have to allocate
3800          *  new refcount structures for them.) */
3801         nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters,
3802                                         s->cluster_size / sizeof(uint64_t));
3803         /* The cluster range may not be aligned to L2 boundaries, so add one L2
3804          * table for a potential head/tail */
3805         nb_new_l2_tables++;
3806
3807         allocation_start = qcow2_refcount_area(bs, old_file_size,
3808                                                nb_new_data_clusters +
3809                                                nb_new_l2_tables,
3810                                                true, 0, 0);
3811         if (allocation_start < 0) {
3812             error_setg_errno(errp, -allocation_start,
3813                              "Failed to resize refcount structures");
3814             ret = allocation_start;
3815             goto fail;
3816         }
3817
3818         clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start,
3819                                                      nb_new_data_clusters);
3820         if (clusters_allocated < 0) {
3821             error_setg_errno(errp, -clusters_allocated,
3822                              "Failed to allocate data clusters");
3823             ret = clusters_allocated;
3824             goto fail;
3825         }
3826
3827         assert(clusters_allocated == nb_new_data_clusters);
3828
3829         /* Allocate the data area */
3830         new_file_size = allocation_start +
3831                         nb_new_data_clusters * s->cluster_size;
3832         ret = bdrv_co_truncate(bs->file, new_file_size, prealloc, errp);
3833         if (ret < 0) {
3834             error_prepend(errp, "Failed to resize underlying file: ");
3835             qcow2_free_clusters(bs, allocation_start,
3836                                 nb_new_data_clusters * s->cluster_size,
3837                                 QCOW2_DISCARD_OTHER);
3838             goto fail;
3839         }
3840
3841         /* Create the necessary L2 entries */
3842         host_offset = allocation_start;
3843         guest_offset = old_length;
3844         while (nb_new_data_clusters) {
3845             int64_t nb_clusters = MIN(
3846                 nb_new_data_clusters,
3847                 s->l2_slice_size - offset_to_l2_slice_index(s, guest_offset));
3848             QCowL2Meta allocation = {
3849                 .offset       = guest_offset,
3850                 .alloc_offset = host_offset,
3851                 .nb_clusters  = nb_clusters,
3852             };
3853             qemu_co_queue_init(&allocation.dependent_requests);
3854
3855             ret = qcow2_alloc_cluster_link_l2(bs, &allocation);
3856             if (ret < 0) {
3857                 error_setg_errno(errp, -ret, "Failed to update L2 tables");
3858                 qcow2_free_clusters(bs, host_offset,
3859                                     nb_new_data_clusters * s->cluster_size,
3860                                     QCOW2_DISCARD_OTHER);
3861                 goto fail;
3862             }
3863
3864             guest_offset += nb_clusters * s->cluster_size;
3865             host_offset += nb_clusters * s->cluster_size;
3866             nb_new_data_clusters -= nb_clusters;
3867         }
3868         break;
3869     }
3870
3871     default:
3872         g_assert_not_reached();
3873     }
3874
3875     if (prealloc != PREALLOC_MODE_OFF) {
3876         /* Flush metadata before actually changing the image size */
3877         ret = qcow2_write_caches(bs);
3878         if (ret < 0) {
3879             error_setg_errno(errp, -ret,
3880                              "Failed to flush the preallocated area to disk");
3881             goto fail;
3882         }
3883     }
3884
3885     bs->total_sectors = offset / BDRV_SECTOR_SIZE;
3886
3887     /* write updated header.size */
3888     offset = cpu_to_be64(offset);
3889     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
3890                            &offset, sizeof(uint64_t));
3891     if (ret < 0) {
3892         error_setg_errno(errp, -ret, "Failed to update the image size");
3893         goto fail;
3894     }
3895
3896     s->l1_vm_state_index = new_l1_size;
3897
3898     /* Update cache sizes */
3899     options = qdict_clone_shallow(bs->options);
3900     ret = qcow2_update_options(bs, options, s->flags, errp);
3901     qobject_unref(options);
3902     if (ret < 0) {
3903         goto fail;
3904     }
3905     ret = 0;
3906 fail:
3907     qemu_co_mutex_unlock(&s->lock);
3908     return ret;
3909 }
3910
3911 /* XXX: put compressed sectors first, then all the cluster aligned
3912    tables to avoid losing bytes in alignment */
3913 static coroutine_fn int
3914 qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
3915                             uint64_t bytes, QEMUIOVector *qiov)
3916 {
3917     BDRVQcow2State *s = bs->opaque;
3918     int ret;
3919     ssize_t out_len;
3920     uint8_t *buf, *out_buf;
3921     uint64_t cluster_offset;
3922
3923     if (has_data_file(bs)) {
3924         return -ENOTSUP;
3925     }
3926
3927     if (bytes == 0) {
3928         /* align end of file to a sector boundary to ease reading with
3929            sector based I/Os */
3930         int64_t len = bdrv_getlength(bs->file->bs);
3931         if (len < 0) {
3932             return len;
3933         }
3934         return bdrv_co_truncate(bs->file, len, PREALLOC_MODE_OFF, NULL);
3935     }
3936
3937     if (offset_into_cluster(s, offset)) {
3938         return -EINVAL;
3939     }
3940
3941     buf = qemu_blockalign(bs, s->cluster_size);
3942     if (bytes != s->cluster_size) {
3943         if (bytes > s->cluster_size ||
3944             offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS)
3945         {
3946             qemu_vfree(buf);
3947             return -EINVAL;
3948         }
3949         /* Zero-pad last write if image size is not cluster aligned */
3950         memset(buf + bytes, 0, s->cluster_size - bytes);
3951     }
3952     qemu_iovec_to_buf(qiov, 0, buf, bytes);
3953
3954     out_buf = g_malloc(s->cluster_size);
3955
3956     out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1,
3957                                 buf, s->cluster_size);
3958     if (out_len == -ENOMEM) {
3959         /* could not compress: write normal cluster */
3960         ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
3961         if (ret < 0) {
3962             goto fail;
3963         }
3964         goto success;
3965     } else if (out_len < 0) {
3966         ret = -EINVAL;
3967         goto fail;
3968     }
3969
3970     qemu_co_mutex_lock(&s->lock);
3971     ret = qcow2_alloc_compressed_cluster_offset(bs, offset, out_len,
3972                                                 &cluster_offset);
3973     if (ret < 0) {
3974         qemu_co_mutex_unlock(&s->lock);
3975         goto fail;
3976     }
3977
3978     ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len, true);
3979     qemu_co_mutex_unlock(&s->lock);
3980     if (ret < 0) {
3981         goto fail;
3982     }
3983
3984     BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
3985     ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);
3986     if (ret < 0) {
3987         goto fail;
3988     }
3989 success:
3990     ret = 0;
3991 fail:
3992     qemu_vfree(buf);
3993     g_free(out_buf);
3994     return ret;
3995 }
3996
3997 static int coroutine_fn
3998 qcow2_co_preadv_compressed(BlockDriverState *bs,
3999                            uint64_t file_cluster_offset,
4000                            uint64_t offset,
4001                            uint64_t bytes,
4002                            QEMUIOVector *qiov)
4003 {
4004     BDRVQcow2State *s = bs->opaque;
4005     int ret = 0, csize, nb_csectors;
4006     uint64_t coffset;
4007     uint8_t *buf, *out_buf;
4008     int offset_in_cluster = offset_into_cluster(s, offset);
4009
4010     coffset = file_cluster_offset & s->cluster_offset_mask;
4011     nb_csectors = ((file_cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
4012     csize = nb_csectors * QCOW2_COMPRESSED_SECTOR_SIZE -
4013         (coffset & ~QCOW2_COMPRESSED_SECTOR_MASK);
4014
4015     buf = g_try_malloc(csize);
4016     if (!buf) {
4017         return -ENOMEM;
4018     }
4019
4020     out_buf = qemu_blockalign(bs, s->cluster_size);
4021
4022     BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
4023     ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);
4024     if (ret < 0) {
4025         goto fail;
4026     }
4027
4028     if (qcow2_co_decompress(bs, out_buf, s->cluster_size, buf, csize) < 0) {
4029         ret = -EIO;
4030         goto fail;
4031     }
4032
4033     qemu_iovec_from_buf(qiov, 0, out_buf + offset_in_cluster, bytes);
4034
4035 fail:
4036     qemu_vfree(out_buf);
4037     g_free(buf);
4038
4039     return ret;
4040 }
4041
4042 static int make_completely_empty(BlockDriverState *bs)
4043 {
4044     BDRVQcow2State *s = bs->opaque;
4045     Error *local_err = NULL;
4046     int ret, l1_clusters;
4047     int64_t offset;
4048     uint64_t *new_reftable = NULL;
4049     uint64_t rt_entry, l1_size2;
4050     struct {
4051         uint64_t l1_offset;
4052         uint64_t reftable_offset;
4053         uint32_t reftable_clusters;
4054     } QEMU_PACKED l1_ofs_rt_ofs_cls;
4055
4056     ret = qcow2_cache_empty(bs, s->l2_table_cache);
4057     if (ret < 0) {
4058         goto fail;
4059     }
4060
4061     ret = qcow2_cache_empty(bs, s->refcount_block_cache);
4062     if (ret < 0) {
4063         goto fail;
4064     }
4065
4066     /* Refcounts will be broken utterly */
4067     ret = qcow2_mark_dirty(bs);
4068     if (ret < 0) {
4069         goto fail;
4070     }
4071
4072     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4073
4074     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
4075     l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t);
4076
4077     /* After this call, neither the in-memory nor the on-disk refcount
4078      * information accurately describe the actual references */
4079
4080     ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset,
4081                              l1_clusters * s->cluster_size, 0);
4082     if (ret < 0) {
4083         goto fail_broken_refcounts;
4084     }
4085     memset(s->l1_table, 0, l1_size2);
4086
4087     BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);
4088
4089     /* Overwrite enough clusters at the beginning of the sectors to place
4090      * the refcount table, a refcount block and the L1 table in; this may
4091      * overwrite parts of the existing refcount and L1 table, which is not
4092      * an issue because the dirty flag is set, complete data loss is in fact
4093      * desired and partial data loss is consequently fine as well */
4094     ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size,
4095                              (2 + l1_clusters) * s->cluster_size, 0);
4096     /* This call (even if it failed overall) may have overwritten on-disk
4097      * refcount structures; in that case, the in-memory refcount information
4098      * will probably differ from the on-disk information which makes the BDS
4099      * unusable */
4100     if (ret < 0) {
4101         goto fail_broken_refcounts;
4102     }
4103
4104     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4105     BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);
4106
4107     /* "Create" an empty reftable (one cluster) directly after the image
4108      * header and an empty L1 table three clusters after the image header;
4109      * the cluster between those two will be used as the first refblock */
4110     l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size);
4111     l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
4112     l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
4113     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
4114                            &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
4115     if (ret < 0) {
4116         goto fail_broken_refcounts;
4117     }
4118
4119     s->l1_table_offset = 3 * s->cluster_size;
4120
4121     new_reftable = g_try_new0(uint64_t, s->cluster_size / sizeof(uint64_t));
4122     if (!new_reftable) {
4123         ret = -ENOMEM;
4124         goto fail_broken_refcounts;
4125     }
4126
4127     s->refcount_table_offset = s->cluster_size;
4128     s->refcount_table_size   = s->cluster_size / sizeof(uint64_t);
4129     s->max_refcount_table_index = 0;
4130
4131     g_free(s->refcount_table);
4132     s->refcount_table = new_reftable;
4133     new_reftable = NULL;
4134
4135     /* Now the in-memory refcount information again corresponds to the on-disk
4136      * information (reftable is empty and no refblocks (the refblock cache is
4137      * empty)); however, this means some clusters (e.g. the image header) are
4138      * referenced, but not refcounted, but the normal qcow2 code assumes that
4139      * the in-memory information is always correct */
4140
4141     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
4142
4143     /* Enter the first refblock into the reftable */
4144     rt_entry = cpu_to_be64(2 * s->cluster_size);
4145     ret = bdrv_pwrite_sync(bs->file, s->cluster_size,
4146                            &rt_entry, sizeof(rt_entry));
4147     if (ret < 0) {
4148         goto fail_broken_refcounts;
4149     }
4150     s->refcount_table[0] = 2 * s->cluster_size;
4151
4152     s->free_cluster_index = 0;
4153     assert(3 + l1_clusters <= s->refcount_block_size);
4154     offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2);
4155     if (offset < 0) {
4156         ret = offset;
4157         goto fail_broken_refcounts;
4158     } else if (offset > 0) {
4159         error_report("First cluster in emptied image is in use");
4160         abort();
4161     }
4162
4163     /* Now finally the in-memory information corresponds to the on-disk
4164      * structures and is correct */
4165     ret = qcow2_mark_clean(bs);
4166     if (ret < 0) {
4167         goto fail;
4168     }
4169
4170     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size,
4171                         PREALLOC_MODE_OFF, &local_err);
4172     if (ret < 0) {
4173         error_report_err(local_err);
4174         goto fail;
4175     }
4176
4177     return 0;
4178
4179 fail_broken_refcounts:
4180     /* The BDS is unusable at this point. If we wanted to make it usable, we
4181      * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
4182      * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
4183      * again. However, because the functions which could have caused this error
4184      * path to be taken are used by those functions as well, it's very likely
4185      * that that sequence will fail as well. Therefore, just eject the BDS. */
4186     bs->drv = NULL;
4187
4188 fail:
4189     g_free(new_reftable);
4190     return ret;
4191 }
4192
4193 static int qcow2_make_empty(BlockDriverState *bs)
4194 {
4195     BDRVQcow2State *s = bs->opaque;
4196     uint64_t offset, end_offset;
4197     int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size);
4198     int l1_clusters, ret = 0;
4199
4200     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
4201
4202     if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps &&
4203         3 + l1_clusters <= s->refcount_block_size &&
4204         s->crypt_method_header != QCOW_CRYPT_LUKS &&
4205         !has_data_file(bs)) {
4206         /* The following function only works for qcow2 v3 images (it
4207          * requires the dirty flag) and only as long as there are no
4208          * features that reserve extra clusters (such as snapshots,
4209          * LUKS header, or persistent bitmaps), because it completely
4210          * empties the image.  Furthermore, the L1 table and three
4211          * additional clusters (image header, refcount table, one
4212          * refcount block) have to fit inside one refcount block. It
4213          * only resets the image file, i.e. does not work with an
4214          * external data file. */
4215         return make_completely_empty(bs);
4216     }
4217
4218     /* This fallback code simply discards every active cluster; this is slow,
4219      * but works in all cases */
4220     end_offset = bs->total_sectors * BDRV_SECTOR_SIZE;
4221     for (offset = 0; offset < end_offset; offset += step) {
4222         /* As this function is generally used after committing an external
4223          * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
4224          * default action for this kind of discard is to pass the discard,
4225          * which will ideally result in an actually smaller image file, as
4226          * is probably desired. */
4227         ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset),
4228                                     QCOW2_DISCARD_SNAPSHOT, true);
4229         if (ret < 0) {
4230             break;
4231         }
4232     }
4233
4234     return ret;
4235 }
4236
4237 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
4238 {
4239     BDRVQcow2State *s = bs->opaque;
4240     int ret;
4241
4242     qemu_co_mutex_lock(&s->lock);
4243     ret = qcow2_write_caches(bs);
4244     qemu_co_mutex_unlock(&s->lock);
4245
4246     return ret;
4247 }
4248
4249 static ssize_t qcow2_measure_crypto_hdr_init_func(QCryptoBlock *block,
4250         size_t headerlen, void *opaque, Error **errp)
4251 {
4252     size_t *headerlenp = opaque;
4253
4254     /* Stash away the payload size */
4255     *headerlenp = headerlen;
4256     return 0;
4257 }
4258
4259 static ssize_t qcow2_measure_crypto_hdr_write_func(QCryptoBlock *block,
4260         size_t offset, const uint8_t *buf, size_t buflen,
4261         void *opaque, Error **errp)
4262 {
4263     /* Discard the bytes, we're not actually writing to an image */
4264     return buflen;
4265 }
4266
4267 /* Determine the number of bytes for the LUKS payload */
4268 static bool qcow2_measure_luks_headerlen(QemuOpts *opts, size_t *len,
4269                                          Error **errp)
4270 {
4271     QDict *opts_qdict;
4272     QDict *cryptoopts_qdict;
4273     QCryptoBlockCreateOptions *cryptoopts;
4274     QCryptoBlock *crypto;
4275
4276     /* Extract "encrypt." options into a qdict */
4277     opts_qdict = qemu_opts_to_qdict(opts, NULL);
4278     qdict_extract_subqdict(opts_qdict, &cryptoopts_qdict, "encrypt.");
4279     qobject_unref(opts_qdict);
4280
4281     /* Build QCryptoBlockCreateOptions object from qdict */
4282     qdict_put_str(cryptoopts_qdict, "format", "luks");
4283     cryptoopts = block_crypto_create_opts_init(cryptoopts_qdict, errp);
4284     qobject_unref(cryptoopts_qdict);
4285     if (!cryptoopts) {
4286         return false;
4287     }
4288
4289     /* Fake LUKS creation in order to determine the payload size */
4290     crypto = qcrypto_block_create(cryptoopts, "encrypt.",
4291                                   qcow2_measure_crypto_hdr_init_func,
4292                                   qcow2_measure_crypto_hdr_write_func,
4293                                   len, errp);
4294     qapi_free_QCryptoBlockCreateOptions(cryptoopts);
4295     if (!crypto) {
4296         return false;
4297     }
4298
4299     qcrypto_block_free(crypto);
4300     return true;
4301 }
4302
4303 static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
4304                                        Error **errp)
4305 {
4306     Error *local_err = NULL;
4307     BlockMeasureInfo *info;
4308     uint64_t required = 0; /* bytes that contribute to required size */
4309     uint64_t virtual_size; /* disk size as seen by guest */
4310     uint64_t refcount_bits;
4311     uint64_t l2_tables;
4312     uint64_t luks_payload_size = 0;
4313     size_t cluster_size;
4314     int version;
4315     char *optstr;
4316     PreallocMode prealloc;
4317     bool has_backing_file;
4318     bool has_luks;
4319
4320     /* Parse image creation options */
4321     cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);
4322     if (local_err) {
4323         goto err;
4324     }
4325
4326     version = qcow2_opt_get_version_del(opts, &local_err);
4327     if (local_err) {
4328         goto err;
4329     }
4330
4331     refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
4332     if (local_err) {
4333         goto err;
4334     }
4335
4336     optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
4337     prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr,
4338                                PREALLOC_MODE_OFF, &local_err);
4339     g_free(optstr);
4340     if (local_err) {
4341         goto err;
4342     }
4343
4344     optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
4345     has_backing_file = !!optstr;
4346     g_free(optstr);
4347
4348     optstr = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
4349     has_luks = optstr && strcmp(optstr, "luks") == 0;
4350     g_free(optstr);
4351
4352     if (has_luks) {
4353         size_t headerlen;
4354
4355         if (!qcow2_measure_luks_headerlen(opts, &headerlen, &local_err)) {
4356             goto err;
4357         }
4358
4359         luks_payload_size = ROUND_UP(headerlen, cluster_size);
4360     }
4361
4362     virtual_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
4363     virtual_size = ROUND_UP(virtual_size, cluster_size);
4364
4365     /* Check that virtual disk size is valid */
4366     l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
4367                              cluster_size / sizeof(uint64_t));
4368     if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) {
4369         error_setg(&local_err, "The image size is too large "
4370                                "(try using a larger cluster size)");
4371         goto err;
4372     }
4373
4374     /* Account for input image */
4375     if (in_bs) {
4376         int64_t ssize = bdrv_getlength(in_bs);
4377         if (ssize < 0) {
4378             error_setg_errno(&local_err, -ssize,
4379                              "Unable to get image virtual_size");
4380             goto err;
4381         }
4382
4383         virtual_size = ROUND_UP(ssize, cluster_size);
4384
4385         if (has_backing_file) {
4386             /* We don't how much of the backing chain is shared by the input
4387              * image and the new image file.  In the worst case the new image's
4388              * backing file has nothing in common with the input image.  Be
4389              * conservative and assume all clusters need to be written.
4390              */
4391             required = virtual_size;
4392         } else {
4393             int64_t offset;
4394             int64_t pnum = 0;
4395
4396             for (offset = 0; offset < ssize; offset += pnum) {
4397                 int ret;
4398
4399                 ret = bdrv_block_status_above(in_bs, NULL, offset,
4400                                               ssize - offset, &pnum, NULL,
4401                                               NULL);
4402                 if (ret < 0) {
4403                     error_setg_errno(&local_err, -ret,
4404                                      "Unable to get block status");
4405                     goto err;
4406                 }
4407
4408                 if (ret & BDRV_BLOCK_ZERO) {
4409                     /* Skip zero regions (safe with no backing file) */
4410                 } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
4411                            (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
4412                     /* Extend pnum to end of cluster for next iteration */
4413                     pnum = ROUND_UP(offset + pnum, cluster_size) - offset;
4414
4415                     /* Count clusters we've seen */
4416                     required += offset % cluster_size + pnum;
4417                 }
4418             }
4419         }
4420     }
4421
4422     /* Take into account preallocation.  Nothing special is needed for
4423      * PREALLOC_MODE_METADATA since metadata is always counted.
4424      */
4425     if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
4426         required = virtual_size;
4427     }
4428
4429     info = g_new(BlockMeasureInfo, 1);
4430     info->fully_allocated =
4431         qcow2_calc_prealloc_size(virtual_size, cluster_size,
4432                                  ctz32(refcount_bits)) + luks_payload_size;
4433
4434     /* Remove data clusters that are not required.  This overestimates the
4435      * required size because metadata needed for the fully allocated file is
4436      * still counted.
4437      */
4438     info->required = info->fully_allocated - virtual_size + required;
4439     return info;
4440
4441 err:
4442     error_propagate(errp, local_err);
4443     return NULL;
4444 }
4445
4446 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4447 {
4448     BDRVQcow2State *s = bs->opaque;
4449     bdi->unallocated_blocks_are_zero = true;
4450     bdi->cluster_size = s->cluster_size;
4451     bdi->vm_state_offset = qcow2_vm_state_offset(s);
4452     return 0;
4453 }
4454
4455 static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
4456                                                   Error **errp)
4457 {
4458     BDRVQcow2State *s = bs->opaque;
4459     ImageInfoSpecific *spec_info;
4460     QCryptoBlockInfo *encrypt_info = NULL;
4461     Error *local_err = NULL;
4462
4463     if (s->crypto != NULL) {
4464         encrypt_info = qcrypto_block_get_info(s->crypto, &local_err);
4465         if (local_err) {
4466             error_propagate(errp, local_err);
4467             return NULL;
4468         }
4469     }
4470
4471     spec_info = g_new(ImageInfoSpecific, 1);
4472     *spec_info = (ImageInfoSpecific){
4473         .type  = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
4474         .u.qcow2.data = g_new0(ImageInfoSpecificQCow2, 1),
4475     };
4476     if (s->qcow_version == 2) {
4477         *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
4478             .compat             = g_strdup("0.10"),
4479             .refcount_bits      = s->refcount_bits,
4480         };
4481     } else if (s->qcow_version == 3) {
4482         Qcow2BitmapInfoList *bitmaps;
4483         bitmaps = qcow2_get_bitmap_info_list(bs, &local_err);
4484         if (local_err) {
4485             error_propagate(errp, local_err);
4486             qapi_free_ImageInfoSpecific(spec_info);
4487             return NULL;
4488         }
4489         *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
4490             .compat             = g_strdup("1.1"),
4491             .lazy_refcounts     = s->compatible_features &
4492                                   QCOW2_COMPAT_LAZY_REFCOUNTS,
4493             .has_lazy_refcounts = true,
4494             .corrupt            = s->incompatible_features &
4495                                   QCOW2_INCOMPAT_CORRUPT,
4496             .has_corrupt        = true,
4497             .refcount_bits      = s->refcount_bits,
4498             .has_bitmaps        = !!bitmaps,
4499             .bitmaps            = bitmaps,
4500             .has_data_file      = !!s->image_data_file,
4501             .data_file          = g_strdup(s->image_data_file),
4502             .has_data_file_raw  = has_data_file(bs),
4503             .data_file_raw      = data_file_is_raw(bs),
4504         };
4505     } else {
4506         /* if this assertion fails, this probably means a new version was
4507          * added without having it covered here */
4508         assert(false);
4509     }
4510
4511     if (encrypt_info) {
4512         ImageInfoSpecificQCow2Encryption *qencrypt =
4513             g_new(ImageInfoSpecificQCow2Encryption, 1);
4514         switch (encrypt_info->format) {
4515         case Q_CRYPTO_BLOCK_FORMAT_QCOW:
4516             qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES;
4517             break;
4518         case Q_CRYPTO_BLOCK_FORMAT_LUKS:
4519             qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS;
4520             qencrypt->u.luks = encrypt_info->u.luks;
4521             break;
4522         default:
4523             abort();
4524         }
4525         /* Since we did shallow copy above, erase any pointers
4526          * in the original info */
4527         memset(&encrypt_info->u, 0, sizeof(encrypt_info->u));
4528         qapi_free_QCryptoBlockInfo(encrypt_info);
4529
4530         spec_info->u.qcow2.data->has_encrypt = true;
4531         spec_info->u.qcow2.data->encrypt = qencrypt;
4532     }
4533
4534     return spec_info;
4535 }
4536
4537 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
4538                               int64_t pos)
4539 {
4540     BDRVQcow2State *s = bs->opaque;
4541
4542     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
4543     return bs->drv->bdrv_co_pwritev(bs, qcow2_vm_state_offset(s) + pos,
4544                                     qiov->size, qiov, 0);
4545 }
4546
4547 static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
4548                               int64_t pos)
4549 {
4550     BDRVQcow2State *s = bs->opaque;
4551
4552     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
4553     return bs->drv->bdrv_co_preadv(bs, qcow2_vm_state_offset(s) + pos,
4554                                    qiov->size, qiov, 0);
4555 }
4556
4557 /*
4558  * Downgrades an image's version. To achieve this, any incompatible features
4559  * have to be removed.
4560  */
4561 static int qcow2_downgrade(BlockDriverState *bs, int target_version,
4562                            BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
4563                            Error **errp)
4564 {
4565     BDRVQcow2State *s = bs->opaque;
4566     int current_version = s->qcow_version;
4567     int ret;
4568
4569     /* This is qcow2_downgrade(), not qcow2_upgrade() */
4570     assert(target_version < current_version);
4571
4572     /* There are no other versions (now) that you can downgrade to */
4573     assert(target_version == 2);
4574
4575     if (s->refcount_order != 4) {
4576         error_setg(errp, "compat=0.10 requires refcount_bits=16");
4577         return -ENOTSUP;
4578     }
4579
4580     if (has_data_file(bs)) {
4581         error_setg(errp, "Cannot downgrade an image with a data file");
4582         return -ENOTSUP;
4583     }
4584
4585     /* clear incompatible features */
4586     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
4587         ret = qcow2_mark_clean(bs);
4588         if (ret < 0) {
4589             error_setg_errno(errp, -ret, "Failed to make the image clean");
4590             return ret;
4591         }
4592     }
4593
4594     /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
4595      * the first place; if that happens nonetheless, returning -ENOTSUP is the
4596      * best thing to do anyway */
4597
4598     if (s->incompatible_features) {
4599         error_setg(errp, "Cannot downgrade an image with incompatible features "
4600                    "%#" PRIx64 " set", s->incompatible_features);
4601         return -ENOTSUP;
4602     }
4603
4604     /* since we can ignore compatible features, we can set them to 0 as well */
4605     s->compatible_features = 0;
4606     /* if lazy refcounts have been used, they have already been fixed through
4607      * clearing the dirty flag */
4608
4609     /* clearing autoclear features is trivial */
4610     s->autoclear_features = 0;
4611
4612     ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque);
4613     if (ret < 0) {
4614         error_setg_errno(errp, -ret, "Failed to turn zero into data clusters");
4615         return ret;
4616     }
4617
4618     s->qcow_version = target_version;
4619     ret = qcow2_update_header(bs);
4620     if (ret < 0) {
4621         s->qcow_version = current_version;
4622         error_setg_errno(errp, -ret, "Failed to update the image header");
4623         return ret;
4624     }
4625     return 0;
4626 }
4627
4628 typedef enum Qcow2AmendOperation {
4629     /* This is the value Qcow2AmendHelperCBInfo::last_operation will be
4630      * statically initialized to so that the helper CB can discern the first
4631      * invocation from an operation change */
4632     QCOW2_NO_OPERATION = 0,
4633
4634     QCOW2_CHANGING_REFCOUNT_ORDER,
4635     QCOW2_DOWNGRADING,
4636 } Qcow2AmendOperation;
4637
4638 typedef struct Qcow2AmendHelperCBInfo {
4639     /* The code coordinating the amend operations should only modify
4640      * these four fields; the rest will be managed by the CB */
4641     BlockDriverAmendStatusCB *original_status_cb;
4642     void *original_cb_opaque;
4643
4644     Qcow2AmendOperation current_operation;
4645
4646     /* Total number of operations to perform (only set once) */
4647     int total_operations;
4648
4649     /* The following fields are managed by the CB */
4650
4651     /* Number of operations completed */
4652     int operations_completed;
4653
4654     /* Cumulative offset of all completed operations */
4655     int64_t offset_completed;
4656
4657     Qcow2AmendOperation last_operation;
4658     int64_t last_work_size;
4659 } Qcow2AmendHelperCBInfo;
4660
4661 static void qcow2_amend_helper_cb(BlockDriverState *bs,
4662                                   int64_t operation_offset,
4663                                   int64_t operation_work_size, void *opaque)
4664 {
4665     Qcow2AmendHelperCBInfo *info = opaque;
4666     int64_t current_work_size;
4667     int64_t projected_work_size;
4668
4669     if (info->current_operation != info->last_operation) {
4670         if (info->last_operation != QCOW2_NO_OPERATION) {
4671             info->offset_completed += info->last_work_size;
4672             info->operations_completed++;
4673         }
4674
4675         info->last_operation = info->current_operation;
4676     }
4677
4678     assert(info->total_operations > 0);
4679     assert(info->operations_completed < info->total_operations);
4680
4681     info->last_work_size = operation_work_size;
4682
4683     current_work_size = info->offset_completed + operation_work_size;
4684
4685     /* current_work_size is the total work size for (operations_completed + 1)
4686      * operations (which includes this one), so multiply it by the number of
4687      * operations not covered and divide it by the number of operations
4688      * covered to get a projection for the operations not covered */
4689     projected_work_size = current_work_size * (info->total_operations -
4690                                                info->operations_completed - 1)
4691                                             / (info->operations_completed + 1);
4692
4693     info->original_status_cb(bs, info->offset_completed + operation_offset,
4694                              current_work_size + projected_work_size,
4695                              info->original_cb_opaque);
4696 }
4697
4698 static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
4699                                BlockDriverAmendStatusCB *status_cb,
4700                                void *cb_opaque,
4701                                Error **errp)
4702 {
4703     BDRVQcow2State *s = bs->opaque;
4704     int old_version = s->qcow_version, new_version = old_version;
4705     uint64_t new_size = 0;
4706     const char *backing_file = NULL, *backing_format = NULL, *data_file = NULL;
4707     bool lazy_refcounts = s->use_lazy_refcounts;
4708     bool data_file_raw = data_file_is_raw(bs);
4709     const char *compat = NULL;
4710     uint64_t cluster_size = s->cluster_size;
4711     bool encrypt;
4712     int encformat;
4713     int refcount_bits = s->refcount_bits;
4714     int ret;
4715     QemuOptDesc *desc = opts->list->desc;
4716     Qcow2AmendHelperCBInfo helper_cb_info;
4717
4718     while (desc && desc->name) {
4719         if (!qemu_opt_find(opts, desc->name)) {
4720             /* only change explicitly defined options */
4721             desc++;
4722             continue;
4723         }
4724
4725         if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
4726             compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
4727             if (!compat) {
4728                 /* preserve default */
4729             } else if (!strcmp(compat, "0.10")) {
4730                 new_version = 2;
4731             } else if (!strcmp(compat, "1.1")) {
4732                 new_version = 3;
4733             } else {
4734                 error_setg(errp, "Unknown compatibility level %s", compat);
4735                 return -EINVAL;
4736             }
4737         } else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) {
4738             error_setg(errp, "Cannot change preallocation mode");
4739             return -ENOTSUP;
4740         } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) {
4741             new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
4742         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) {
4743             backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
4744         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) {
4745             backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
4746         } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) {
4747             encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT,
4748                                         !!s->crypto);
4749
4750             if (encrypt != !!s->crypto) {
4751                 error_setg(errp,
4752                            "Changing the encryption flag is not supported");
4753                 return -ENOTSUP;
4754             }
4755         } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT_FORMAT)) {
4756             encformat = qcow2_crypt_method_from_format(
4757                 qemu_opt_get(opts, BLOCK_OPT_ENCRYPT_FORMAT));
4758
4759             if (encformat != s->crypt_method_header) {
4760                 error_setg(errp,
4761                            "Changing the encryption format is not supported");
4762                 return -ENOTSUP;
4763             }
4764         } else if (g_str_has_prefix(desc->name, "encrypt.")) {
4765             error_setg(errp,
4766                        "Changing the encryption parameters is not supported");
4767             return -ENOTSUP;
4768         } else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) {
4769             cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE,
4770                                              cluster_size);
4771             if (cluster_size != s->cluster_size) {
4772                 error_setg(errp, "Changing the cluster size is not supported");
4773                 return -ENOTSUP;
4774             }
4775         } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
4776             lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
4777                                                lazy_refcounts);
4778         } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
4779             refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS,
4780                                                 refcount_bits);
4781
4782             if (refcount_bits <= 0 || refcount_bits > 64 ||
4783                 !is_power_of_2(refcount_bits))
4784             {
4785                 error_setg(errp, "Refcount width must be a power of two and "
4786                            "may not exceed 64 bits");
4787                 return -EINVAL;
4788             }
4789         } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE)) {
4790             data_file = qemu_opt_get(opts, BLOCK_OPT_DATA_FILE);
4791             if (data_file && !has_data_file(bs)) {
4792                 error_setg(errp, "data-file can only be set for images that "
4793                                  "use an external data file");
4794                 return -EINVAL;
4795             }
4796         } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE_RAW)) {
4797             data_file_raw = qemu_opt_get_bool(opts, BLOCK_OPT_DATA_FILE_RAW,
4798                                               data_file_raw);
4799             if (data_file_raw && !data_file_is_raw(bs)) {
4800                 error_setg(errp, "data-file-raw cannot be set on existing "
4801                                  "images");
4802                 return -EINVAL;
4803             }
4804         } else {
4805             /* if this point is reached, this probably means a new option was
4806              * added without having it covered here */
4807             abort();
4808         }
4809
4810         desc++;
4811     }
4812
4813     helper_cb_info = (Qcow2AmendHelperCBInfo){
4814         .original_status_cb = status_cb,
4815         .original_cb_opaque = cb_opaque,
4816         .total_operations = (new_version < old_version)
4817                           + (s->refcount_bits != refcount_bits)
4818     };
4819
4820     /* Upgrade first (some features may require compat=1.1) */
4821     if (new_version > old_version) {
4822         s->qcow_version = new_version;
4823         ret = qcow2_update_header(bs);
4824         if (ret < 0) {
4825             s->qcow_version = old_version;
4826             error_setg_errno(errp, -ret, "Failed to update the image header");
4827             return ret;
4828         }
4829     }
4830
4831     if (s->refcount_bits != refcount_bits) {
4832         int refcount_order = ctz32(refcount_bits);
4833
4834         if (new_version < 3 && refcount_bits != 16) {
4835             error_setg(errp, "Refcount widths other than 16 bits require "
4836                        "compatibility level 1.1 or above (use compat=1.1 or "
4837                        "greater)");
4838             return -EINVAL;
4839         }
4840
4841         helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER;
4842         ret = qcow2_change_refcount_order(bs, refcount_order,
4843                                           &qcow2_amend_helper_cb,
4844                                           &helper_cb_info, errp);
4845         if (ret < 0) {
4846             return ret;
4847         }
4848     }
4849
4850     /* data-file-raw blocks backing files, so clear it first if requested */
4851     if (data_file_raw) {
4852         s->autoclear_features |= QCOW2_AUTOCLEAR_DATA_FILE_RAW;
4853     } else {
4854         s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW;
4855     }
4856
4857     if (data_file) {
4858         g_free(s->image_data_file);
4859         s->image_data_file = *data_file ? g_strdup(data_file) : NULL;
4860     }
4861
4862     ret = qcow2_update_header(bs);
4863     if (ret < 0) {
4864         error_setg_errno(errp, -ret, "Failed to update the image header");
4865         return ret;
4866     }
4867
4868     if (backing_file || backing_format) {
4869         ret = qcow2_change_backing_file(bs,
4870                     backing_file ?: s->image_backing_file,
4871                     backing_format ?: s->image_backing_format);
4872         if (ret < 0) {
4873             error_setg_errno(errp, -ret, "Failed to change the backing file");
4874             return ret;
4875         }
4876     }
4877
4878     if (s->use_lazy_refcounts != lazy_refcounts) {
4879         if (lazy_refcounts) {
4880             if (new_version < 3) {
4881                 error_setg(errp, "Lazy refcounts only supported with "
4882                            "compatibility level 1.1 and above (use compat=1.1 "
4883                            "or greater)");
4884                 return -EINVAL;
4885             }
4886             s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
4887             ret = qcow2_update_header(bs);
4888             if (ret < 0) {
4889                 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
4890                 error_setg_errno(errp, -ret, "Failed to update the image header");
4891                 return ret;
4892             }
4893             s->use_lazy_refcounts = true;
4894         } else {
4895             /* make image clean first */
4896             ret = qcow2_mark_clean(bs);
4897             if (ret < 0) {
4898                 error_setg_errno(errp, -ret, "Failed to make the image clean");
4899                 return ret;
4900             }
4901             /* now disallow lazy refcounts */
4902             s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
4903             ret = qcow2_update_header(bs);
4904             if (ret < 0) {
4905                 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
4906                 error_setg_errno(errp, -ret, "Failed to update the image header");
4907                 return ret;
4908             }
4909             s->use_lazy_refcounts = false;
4910         }
4911     }
4912
4913     if (new_size) {
4914         BlockBackend *blk = blk_new(BLK_PERM_RESIZE, BLK_PERM_ALL);
4915         ret = blk_insert_bs(blk, bs, errp);
4916         if (ret < 0) {
4917             blk_unref(blk);
4918             return ret;
4919         }
4920
4921         ret = blk_truncate(blk, new_size, PREALLOC_MODE_OFF, errp);
4922         blk_unref(blk);
4923         if (ret < 0) {
4924             return ret;
4925         }
4926     }
4927
4928     /* Downgrade last (so unsupported features can be removed before) */
4929     if (new_version < old_version) {
4930         helper_cb_info.current_operation = QCOW2_DOWNGRADING;
4931         ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb,
4932                               &helper_cb_info, errp);
4933         if (ret < 0) {
4934             return ret;
4935         }
4936     }
4937
4938     return 0;
4939 }
4940
4941 /*
4942  * If offset or size are negative, respectively, they will not be included in
4943  * the BLOCK_IMAGE_CORRUPTED event emitted.
4944  * fatal will be ignored for read-only BDS; corruptions found there will always
4945  * be considered non-fatal.
4946  */
4947 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
4948                              int64_t size, const char *message_format, ...)
4949 {
4950     BDRVQcow2State *s = bs->opaque;
4951     const char *node_name;
4952     char *message;
4953     va_list ap;
4954
4955     fatal = fatal && bdrv_is_writable(bs);
4956
4957     if (s->signaled_corruption &&
4958         (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT)))
4959     {
4960         return;
4961     }
4962
4963     va_start(ap, message_format);
4964     message = g_strdup_vprintf(message_format, ap);
4965     va_end(ap);
4966
4967     if (fatal) {
4968         fprintf(stderr, "qcow2: Marking image as corrupt: %s; further "
4969                 "corruption events will be suppressed\n", message);
4970     } else {
4971         fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal "
4972                 "corruption events will be suppressed\n", message);
4973     }
4974
4975     node_name = bdrv_get_node_name(bs);
4976     qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
4977                                           *node_name != '\0', node_name,
4978                                           message, offset >= 0, offset,
4979                                           size >= 0, size,
4980                                           fatal);
4981     g_free(message);
4982
4983     if (fatal) {
4984         qcow2_mark_corrupt(bs);
4985         bs->drv = NULL; /* make BDS unusable */
4986     }
4987
4988     s->signaled_corruption = true;
4989 }
4990
4991 static QemuOptsList qcow2_create_opts = {
4992     .name = "qcow2-create-opts",
4993     .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
4994     .desc = {
4995         {
4996             .name = BLOCK_OPT_SIZE,
4997             .type = QEMU_OPT_SIZE,
4998             .help = "Virtual disk size"
4999         },
5000         {
5001             .name = BLOCK_OPT_COMPAT_LEVEL,
5002             .type = QEMU_OPT_STRING,
5003             .help = "Compatibility level (0.10 or 1.1)"
5004         },
5005         {
5006             .name = BLOCK_OPT_BACKING_FILE,
5007             .type = QEMU_OPT_STRING,
5008             .help = "File name of a base image"
5009         },
5010         {
5011             .name = BLOCK_OPT_BACKING_FMT,
5012             .type = QEMU_OPT_STRING,
5013             .help = "Image format of the base image"
5014         },
5015         {
5016             .name = BLOCK_OPT_DATA_FILE,
5017             .type = QEMU_OPT_STRING,
5018             .help = "File name of an external data file"
5019         },
5020         {
5021             .name = BLOCK_OPT_DATA_FILE_RAW,
5022             .type = QEMU_OPT_BOOL,
5023             .help = "The external data file must stay valid as a raw image"
5024         },
5025         {
5026             .name = BLOCK_OPT_ENCRYPT,
5027             .type = QEMU_OPT_BOOL,
5028             .help = "Encrypt the image with format 'aes'. (Deprecated "
5029                     "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)",
5030         },
5031         {
5032             .name = BLOCK_OPT_ENCRYPT_FORMAT,
5033             .type = QEMU_OPT_STRING,
5034             .help = "Encrypt the image, format choices: 'aes', 'luks'",
5035         },
5036         BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
5037             "ID of secret providing qcow AES key or LUKS passphrase"),
5038         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."),
5039         BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."),
5040         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."),
5041         BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."),
5042         BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."),
5043         BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
5044         {
5045             .name = BLOCK_OPT_CLUSTER_SIZE,
5046             .type = QEMU_OPT_SIZE,
5047             .help = "qcow2 cluster size",
5048             .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
5049         },
5050         {
5051             .name = BLOCK_OPT_PREALLOC,
5052             .type = QEMU_OPT_STRING,
5053             .help = "Preallocation mode (allowed values: off, metadata, "
5054                     "falloc, full)"
5055         },
5056         {
5057             .name = BLOCK_OPT_LAZY_REFCOUNTS,
5058             .type = QEMU_OPT_BOOL,
5059             .help = "Postpone refcount updates",
5060             .def_value_str = "off"
5061         },
5062         {
5063             .name = BLOCK_OPT_REFCOUNT_BITS,
5064             .type = QEMU_OPT_NUMBER,
5065             .help = "Width of a reference count entry in bits",
5066             .def_value_str = "16"
5067         },
5068         { /* end of list */ }
5069     }
5070 };
5071
5072 static const char *const qcow2_strong_runtime_opts[] = {
5073     "encrypt." BLOCK_CRYPTO_OPT_QCOW_KEY_SECRET,
5074
5075     NULL
5076 };
5077
5078 BlockDriver bdrv_qcow2 = {
5079     .format_name        = "qcow2",
5080     .instance_size      = sizeof(BDRVQcow2State),
5081     .bdrv_probe         = qcow2_probe,
5082     .bdrv_open          = qcow2_open,
5083     .bdrv_close         = qcow2_close,
5084     .bdrv_reopen_prepare  = qcow2_reopen_prepare,
5085     .bdrv_reopen_commit   = qcow2_reopen_commit,
5086     .bdrv_reopen_abort    = qcow2_reopen_abort,
5087     .bdrv_join_options    = qcow2_join_options,
5088     .bdrv_child_perm      = bdrv_format_default_perms,
5089     .bdrv_co_create_opts  = qcow2_co_create_opts,
5090     .bdrv_co_create       = qcow2_co_create,
5091     .bdrv_has_zero_init = bdrv_has_zero_init_1,
5092     .bdrv_co_block_status = qcow2_co_block_status,
5093
5094     .bdrv_co_preadv         = qcow2_co_preadv,
5095     .bdrv_co_pwritev        = qcow2_co_pwritev,
5096     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
5097
5098     .bdrv_co_pwrite_zeroes  = qcow2_co_pwrite_zeroes,
5099     .bdrv_co_pdiscard       = qcow2_co_pdiscard,
5100     .bdrv_co_copy_range_from = qcow2_co_copy_range_from,
5101     .bdrv_co_copy_range_to  = qcow2_co_copy_range_to,
5102     .bdrv_co_truncate       = qcow2_co_truncate,
5103     .bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed,
5104     .bdrv_make_empty        = qcow2_make_empty,
5105
5106     .bdrv_snapshot_create   = qcow2_snapshot_create,
5107     .bdrv_snapshot_goto     = qcow2_snapshot_goto,
5108     .bdrv_snapshot_delete   = qcow2_snapshot_delete,
5109     .bdrv_snapshot_list     = qcow2_snapshot_list,
5110     .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
5111     .bdrv_measure           = qcow2_measure,
5112     .bdrv_get_info          = qcow2_get_info,
5113     .bdrv_get_specific_info = qcow2_get_specific_info,
5114
5115     .bdrv_save_vmstate    = qcow2_save_vmstate,
5116     .bdrv_load_vmstate    = qcow2_load_vmstate,
5117
5118     .supports_backing           = true,
5119     .bdrv_change_backing_file   = qcow2_change_backing_file,
5120
5121     .bdrv_refresh_limits        = qcow2_refresh_limits,
5122     .bdrv_co_invalidate_cache   = qcow2_co_invalidate_cache,
5123     .bdrv_inactivate            = qcow2_inactivate,
5124
5125     .create_opts         = &qcow2_create_opts,
5126     .strong_runtime_opts = qcow2_strong_runtime_opts,
5127     .mutable_opts        = mutable_opts,
5128     .bdrv_co_check       = qcow2_co_check,
5129     .bdrv_amend_options  = qcow2_amend_options,
5130
5131     .bdrv_detach_aio_context  = qcow2_detach_aio_context,
5132     .bdrv_attach_aio_context  = qcow2_attach_aio_context,
5133
5134     .bdrv_reopen_bitmaps_rw = qcow2_reopen_bitmaps_rw,
5135     .bdrv_can_store_new_dirty_bitmap = qcow2_can_store_new_dirty_bitmap,
5136     .bdrv_remove_persistent_dirty_bitmap = qcow2_remove_persistent_dirty_bitmap,
5137 };
5138
5139 static void bdrv_qcow2_init(void)
5140 {
5141     bdrv_register(&bdrv_qcow2);
5142 }
5143
5144 block_init(bdrv_qcow2_init);