block/qcow2.c

   1 /*
   2  * Block driver for the QCOW version 2 format
   3  *
   4  * Copyright (c) 2004-2006 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu-common.h"
  25 #include "block/block_int.h"
  26 #include "qemu/module.h"
  27 #include <zlib.h>
  28 #include "block/qcow2.h"
  29 #include "qemu/error-report.h"
  30 #include "qapi/qmp/qerror.h"
  31 #include "qapi/qmp/qbool.h"
  32 #include "qapi/util.h"
  33 #include "qapi/qmp/types.h"
  34 #include "qapi-event.h"
  35 #include "trace.h"
  36 #include "qemu/option_int.h"
  37
  38 /*
  39   Differences with QCOW:
  40
  41   - Support for multiple incremental snapshots.
  42   - Memory management by reference counts.
  43   - Clusters which have a reference count of one have the bit
  44     QCOW_OFLAG_COPIED to optimize write performance.
  45   - Size of compressed clusters is stored in sectors to reduce bit usage
  46     in the cluster offsets.
  47   - Support for storing additional data (such as the VM state) in the
  48     snapshots.
  49   - If a backing store is used, the cluster size is not constrained
  50     (could be backported to QCOW).
  51   - L2 tables have always a size of one cluster.
  52 */
  53
  54
  55 typedef struct {
  56     uint32_t magic;
  57     uint32_t len;
  58 } QEMU_PACKED QCowExtension;
  59
  60 #define  QCOW2_EXT_MAGIC_END 0
  61 #define  QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
  62 #define  QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
  63
  64 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
  65 {
  66     const QCowHeader *cow_header = (const void *)buf;
  67
  68     if (buf_size >= sizeof(QCowHeader) &&
  69         be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
  70         be32_to_cpu(cow_header->version) >= 2)
  71         return 100;
  72     else
  73         return 0;
  74 }
  75
  76
  77 /*
  78  * read qcow2 extension and fill bs
  79  * start reading from start_offset
  80  * finish reading upon magic of value 0 or when end_offset reached
  81  * unknown magic is skipped (future extension this version knows nothing about)
  82  * return 0 upon success, non-0 otherwise
  83  */
  84 static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
  85                                  uint64_t end_offset, void **p_feature_table,
  86                                  Error **errp)
  87 {
  88     BDRVQcow2State *s = bs->opaque;
  89     QCowExtension ext;
  90     uint64_t offset;
  91     int ret;
  92
  93 #ifdef DEBUG_EXT
  94     printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
  95 #endif
  96     offset = start_offset;
  97     while (offset < end_offset) {
  98
  99 #ifdef DEBUG_EXT
 100         /* Sanity check */
 101         if (offset > s->cluster_size)
 102             printf("qcow2_read_extension: suspicious offset %lu\n", offset);
 103
 104         printf("attempting to read extended header in offset %lu\n", offset);
 105 #endif
 106
 107         ret = bdrv_pread(bs->file->bs, offset, &ext, sizeof(ext));
 108         if (ret < 0) {
 109             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
 110                              "pread fail from offset %" PRIu64, offset);
 111             return 1;
 112         }
 113         be32_to_cpus(&ext.magic);
 114         be32_to_cpus(&ext.len);
 115         offset += sizeof(ext);
 116 #ifdef DEBUG_EXT
 117         printf("ext.magic = 0x%x\n", ext.magic);
 118 #endif
 119         if (offset > end_offset || ext.len > end_offset - offset) {
 120             error_setg(errp, "Header extension too large");
 121             return -EINVAL;
 122         }
 123
 124         switch (ext.magic) {
 125         case QCOW2_EXT_MAGIC_END:
 126             return 0;
 127
 128         case QCOW2_EXT_MAGIC_BACKING_FORMAT:
 129             if (ext.len >= sizeof(bs->backing_format)) {
 130                 error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
 131                            " too large (>=%zu)", ext.len,
 132                            sizeof(bs->backing_format));
 133                 return 2;
 134             }
 135             ret = bdrv_pread(bs->file->bs, offset, bs->backing_format, ext.len);
 136             if (ret < 0) {
 137                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
 138                                  "Could not read format name");
 139                 return 3;
 140             }
 141             bs->backing_format[ext.len] = '\0';
 142             s->image_backing_format = g_strdup(bs->backing_format);
 143 #ifdef DEBUG_EXT
 144             printf("Qcow2: Got format extension %s\n", bs->backing_format);
 145 #endif
 146             break;
 147
 148         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
 149             if (p_feature_table != NULL) {
 150                 void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
 151                 ret = bdrv_pread(bs->file->bs, offset , feature_table, ext.len);
 152                 if (ret < 0) {
 153                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
 154                                      "Could not read table");
 155                     return ret;
 156                 }
 157
 158                 *p_feature_table = feature_table;
 159             }
 160             break;
 161
 162         default:
 163             /* unknown magic - save it in case we need to rewrite the header */
 164             {
 165                 Qcow2UnknownHeaderExtension *uext;
 166
 167                 uext = g_malloc0(sizeof(*uext)  + ext.len);
 168                 uext->magic = ext.magic;
 169                 uext->len = ext.len;
 170                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
 171
 172                 ret = bdrv_pread(bs->file->bs, offset , uext->data, uext->len);
 173                 if (ret < 0) {
 174                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
 175                                      "Could not read data");
 176                     return ret;
 177                 }
 178             }
 179             break;
 180         }
 181
 182         offset += ((ext.len + 7) & ~7);
 183     }
 184
 185     return 0;
 186 }
 187
 188 static void cleanup_unknown_header_ext(BlockDriverState *bs)
 189 {
 190     BDRVQcow2State *s = bs->opaque;
 191     Qcow2UnknownHeaderExtension *uext, *next;
 192
 193     QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
 194         QLIST_REMOVE(uext, next);
 195         g_free(uext);
 196     }
 197 }
 198
 199 static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState *bs,
 200     Error **errp, const char *fmt, ...)
 201 {
 202     char msg[64];
 203     va_list ap;
 204
 205     va_start(ap, fmt);
 206     vsnprintf(msg, sizeof(msg), fmt, ap);
 207     va_end(ap);
 208
 209     error_setg(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
 210                bdrv_get_device_or_node_name(bs), "qcow2", msg);
 211 }
 212
 213 static void report_unsupported_feature(BlockDriverState *bs,
 214     Error **errp, Qcow2Feature *table, uint64_t mask)
 215 {
 216     char *features = g_strdup("");
 217     char *old;
 218
 219     while (table && table->name[0] != '\0') {
 220         if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
 221             if (mask & (1ULL << table->bit)) {
 222                 old = features;
 223                 features = g_strdup_printf("%s%s%.46s", old, *old ? ", " : "",
 224                                            table->name);
 225                 g_free(old);
 226                 mask &= ~(1ULL << table->bit);
 227             }
 228         }
 229         table++;
 230     }
 231
 232     if (mask) {
 233         old = features;
 234         features = g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64,
 235                                    old, *old ? ", " : "", mask);
 236         g_free(old);
 237     }
 238
 239     report_unsupported(bs, errp, "%s", features);
 240     g_free(features);
 241 }
 242
 243 /*
 244  * Sets the dirty bit and flushes afterwards if necessary.
 245  *
 246  * The incompatible_features bit is only set if the image file header was
 247  * updated successfully.  Therefore it is not required to check the return
 248  * value of this function.
 249  */
 250 int qcow2_mark_dirty(BlockDriverState *bs)
 251 {
 252     BDRVQcow2State *s = bs->opaque;
 253     uint64_t val;
 254     int ret;
 255
 256     assert(s->qcow_version >= 3);
 257
 258     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
 259         return 0; /* already dirty */
 260     }
 261
 262     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
 263     ret = bdrv_pwrite(bs->file->bs, offsetof(QCowHeader, incompatible_features),
 264                       &val, sizeof(val));
 265     if (ret < 0) {
 266         return ret;
 267     }
 268     ret = bdrv_flush(bs->file->bs);
 269     if (ret < 0) {
 270         return ret;
 271     }
 272
 273     /* Only treat image as dirty if the header was updated successfully */
 274     s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
 275     return 0;
 276 }
 277
 278 /*
 279  * Clears the dirty bit and flushes before if necessary.  Only call this
 280  * function when there are no pending requests, it does not guard against
 281  * concurrent requests dirtying the image.
 282  */
 283 static int qcow2_mark_clean(BlockDriverState *bs)
 284 {
 285     BDRVQcow2State *s = bs->opaque;
 286
 287     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
 288         int ret;
 289
 290         s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;
 291
 292         ret = bdrv_flush(bs);
 293         if (ret < 0) {
 294             return ret;
 295         }
 296
 297         return qcow2_update_header(bs);
 298     }
 299     return 0;
 300 }
 301
 302 /*
 303  * Marks the image as corrupt.
 304  */
 305 int qcow2_mark_corrupt(BlockDriverState *bs)
 306 {
 307     BDRVQcow2State *s = bs->opaque;
 308
 309     s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
 310     return qcow2_update_header(bs);
 311 }
 312
 313 /*
 314  * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
 315  * before if necessary.
 316  */
 317 int qcow2_mark_consistent(BlockDriverState *bs)
 318 {
 319     BDRVQcow2State *s = bs->opaque;
 320
 321     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
 322         int ret = bdrv_flush(bs);
 323         if (ret < 0) {
 324             return ret;
 325         }
 326
 327         s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT;
 328         return qcow2_update_header(bs);
 329     }
 330     return 0;
 331 }
 332
 333 static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result,
 334                        BdrvCheckMode fix)
 335 {
 336     int ret = qcow2_check_refcounts(bs, result, fix);
 337     if (ret < 0) {
 338         return ret;
 339     }
 340
 341     if (fix && result->check_errors == 0 && result->corruptions == 0) {
 342         ret = qcow2_mark_clean(bs);
 343         if (ret < 0) {
 344             return ret;
 345         }
 346         return qcow2_mark_consistent(bs);
 347     }
 348     return ret;
 349 }
 350
 351 static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
 352                                  uint64_t entries, size_t entry_len)
 353 {
 354     BDRVQcow2State *s = bs->opaque;
 355     uint64_t size;
 356
 357     /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
 358      * because values will be passed to qemu functions taking int64_t. */
 359     if (entries > INT64_MAX / entry_len) {
 360         return -EINVAL;
 361     }
 362
 363     size = entries * entry_len;
 364
 365     if (INT64_MAX - size < offset) {
 366         return -EINVAL;
 367     }
 368
 369     /* Tables must be cluster aligned */
 370     if (offset & (s->cluster_size - 1)) {
 371         return -EINVAL;
 372     }
 373
 374     return 0;
 375 }
 376
 377 static QemuOptsList qcow2_runtime_opts = {
 378     .name = "qcow2",
 379     .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
 380     .desc = {
 381         {
 382             .name = QCOW2_OPT_LAZY_REFCOUNTS,
 383             .type = QEMU_OPT_BOOL,
 384             .help = "Postpone refcount updates",
 385         },
 386         {
 387             .name = QCOW2_OPT_DISCARD_REQUEST,
 388             .type = QEMU_OPT_BOOL,
 389             .help = "Pass guest discard requests to the layer below",
 390         },
 391         {
 392             .name = QCOW2_OPT_DISCARD_SNAPSHOT,
 393             .type = QEMU_OPT_BOOL,
 394             .help = "Generate discard requests when snapshot related space "
 395                     "is freed",
 396         },
 397         {
 398             .name = QCOW2_OPT_DISCARD_OTHER,
 399             .type = QEMU_OPT_BOOL,
 400             .help = "Generate discard requests when other clusters are freed",
 401         },
 402         {
 403             .name = QCOW2_OPT_OVERLAP,
 404             .type = QEMU_OPT_STRING,
 405             .help = "Selects which overlap checks to perform from a range of "
 406                     "templates (none, constant, cached, all)",
 407         },
 408         {
 409             .name = QCOW2_OPT_OVERLAP_TEMPLATE,
 410             .type = QEMU_OPT_STRING,
 411             .help = "Selects which overlap checks to perform from a range of "
 412                     "templates (none, constant, cached, all)",
 413         },
 414         {
 415             .name = QCOW2_OPT_OVERLAP_MAIN_HEADER,
 416             .type = QEMU_OPT_BOOL,
 417             .help = "Check for unintended writes into the main qcow2 header",
 418         },
 419         {
 420             .name = QCOW2_OPT_OVERLAP_ACTIVE_L1,
 421             .type = QEMU_OPT_BOOL,
 422             .help = "Check for unintended writes into the active L1 table",
 423         },
 424         {
 425             .name = QCOW2_OPT_OVERLAP_ACTIVE_L2,
 426             .type = QEMU_OPT_BOOL,
 427             .help = "Check for unintended writes into an active L2 table",
 428         },
 429         {
 430             .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
 431             .type = QEMU_OPT_BOOL,
 432             .help = "Check for unintended writes into the refcount table",
 433         },
 434         {
 435             .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
 436             .type = QEMU_OPT_BOOL,
 437             .help = "Check for unintended writes into a refcount block",
 438         },
 439         {
 440             .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
 441             .type = QEMU_OPT_BOOL,
 442             .help = "Check for unintended writes into the snapshot table",
 443         },
 444         {
 445             .name = QCOW2_OPT_OVERLAP_INACTIVE_L1,
 446             .type = QEMU_OPT_BOOL,
 447             .help = "Check for unintended writes into an inactive L1 table",
 448         },
 449         {
 450             .name = QCOW2_OPT_OVERLAP_INACTIVE_L2,
 451             .type = QEMU_OPT_BOOL,
 452             .help = "Check for unintended writes into an inactive L2 table",
 453         },
 454         {
 455             .name = QCOW2_OPT_CACHE_SIZE,
 456             .type = QEMU_OPT_SIZE,
 457             .help = "Maximum combined metadata (L2 tables and refcount blocks) "
 458                     "cache size",
 459         },
 460         {
 461             .name = QCOW2_OPT_L2_CACHE_SIZE,
 462             .type = QEMU_OPT_SIZE,
 463             .help = "Maximum L2 table cache size",
 464         },
 465         {
 466             .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE,
 467             .type = QEMU_OPT_SIZE,
 468             .help = "Maximum refcount block cache size",
 469         },
 470         {
 471             .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
 472             .type = QEMU_OPT_NUMBER,
 473             .help = "Clean unused cache entries after this time (in seconds)",
 474         },
 475         { /* end of list */ }
 476     },
 477 };
 478
 479 static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
 480     [QCOW2_OL_MAIN_HEADER_BITNR]    = QCOW2_OPT_OVERLAP_MAIN_HEADER,
 481     [QCOW2_OL_ACTIVE_L1_BITNR]      = QCOW2_OPT_OVERLAP_ACTIVE_L1,
 482     [QCOW2_OL_ACTIVE_L2_BITNR]      = QCOW2_OPT_OVERLAP_ACTIVE_L2,
 483     [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
 484     [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
 485     [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
 486     [QCOW2_OL_INACTIVE_L1_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L1,
 487     [QCOW2_OL_INACTIVE_L2_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L2,
 488 };
 489
 490 static void cache_clean_timer_cb(void *opaque)
 491 {
 492     BlockDriverState *bs = opaque;
 493     BDRVQcow2State *s = bs->opaque;
 494     qcow2_cache_clean_unused(bs, s->l2_table_cache);
 495     qcow2_cache_clean_unused(bs, s->refcount_block_cache);
 496     timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
 497               (int64_t) s->cache_clean_interval * 1000);
 498 }
 499
 500 static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
 501 {
 502     BDRVQcow2State *s = bs->opaque;
 503     if (s->cache_clean_interval > 0) {
 504         s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL,
 505                                              SCALE_MS, cache_clean_timer_cb,
 506                                              bs);
 507         timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
 508                   (int64_t) s->cache_clean_interval * 1000);
 509     }
 510 }
 511
 512 static void cache_clean_timer_del(BlockDriverState *bs)
 513 {
 514     BDRVQcow2State *s = bs->opaque;
 515     if (s->cache_clean_timer) {
 516         timer_del(s->cache_clean_timer);
 517         timer_free(s->cache_clean_timer);
 518         s->cache_clean_timer = NULL;
 519     }
 520 }
 521
 522 static void qcow2_detach_aio_context(BlockDriverState *bs)
 523 {
 524     cache_clean_timer_del(bs);
 525 }
 526
 527 static void qcow2_attach_aio_context(BlockDriverState *bs,
 528                                      AioContext *new_context)
 529 {
 530     cache_clean_timer_init(bs, new_context);
 531 }
 532
 533 static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
 534                              uint64_t *l2_cache_size,
 535                              uint64_t *refcount_cache_size, Error **errp)
 536 {
 537     BDRVQcow2State *s = bs->opaque;
 538     uint64_t combined_cache_size;
 539     bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
 540
 541     combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
 542     l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
 543     refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
 544
 545     combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0);
 546     *l2_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE, 0);
 547     *refcount_cache_size = qemu_opt_get_size(opts,
 548                                              QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0);
 549
 550     if (combined_cache_size_set) {
 551         if (l2_cache_size_set && refcount_cache_size_set) {
 552             error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE
 553                        " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set "
 554                        "the same time");
 555             return;
 556         } else if (*l2_cache_size > combined_cache_size) {
 557             error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed "
 558                        QCOW2_OPT_CACHE_SIZE);
 559             return;
 560         } else if (*refcount_cache_size > combined_cache_size) {
 561             error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed "
 562                        QCOW2_OPT_CACHE_SIZE);
 563             return;
 564         }
 565
 566         if (l2_cache_size_set) {
 567             *refcount_cache_size = combined_cache_size - *l2_cache_size;
 568         } else if (refcount_cache_size_set) {
 569             *l2_cache_size = combined_cache_size - *refcount_cache_size;
 570         } else {
 571             *refcount_cache_size = combined_cache_size
 572                                  / (DEFAULT_L2_REFCOUNT_SIZE_RATIO + 1);
 573             *l2_cache_size = combined_cache_size - *refcount_cache_size;
 574         }
 575     } else {
 576         if (!l2_cache_size_set && !refcount_cache_size_set) {
 577             *l2_cache_size = MAX(DEFAULT_L2_CACHE_BYTE_SIZE,
 578                                  (uint64_t)DEFAULT_L2_CACHE_CLUSTERS
 579                                  * s->cluster_size);
 580             *refcount_cache_size = *l2_cache_size
 581                                  / DEFAULT_L2_REFCOUNT_SIZE_RATIO;
 582         } else if (!l2_cache_size_set) {
 583             *l2_cache_size = *refcount_cache_size
 584                            * DEFAULT_L2_REFCOUNT_SIZE_RATIO;
 585         } else if (!refcount_cache_size_set) {
 586             *refcount_cache_size = *l2_cache_size
 587                                  / DEFAULT_L2_REFCOUNT_SIZE_RATIO;
 588         }
 589     }
 590 }
 591
 592 typedef struct Qcow2ReopenState {
 593     Qcow2Cache *l2_table_cache;
 594     Qcow2Cache *refcount_block_cache;
 595     bool use_lazy_refcounts;
 596     int overlap_check;
 597     bool discard_passthrough[QCOW2_DISCARD_MAX];
 598     uint64_t cache_clean_interval;
 599 } Qcow2ReopenState;
 600
 601 static int qcow2_update_options_prepare(BlockDriverState *bs,
 602                                         Qcow2ReopenState *r,
 603                                         QDict *options, int flags,
 604                                         Error **errp)
 605 {
 606     BDRVQcow2State *s = bs->opaque;
 607     QemuOpts *opts = NULL;
 608     const char *opt_overlap_check, *opt_overlap_check_template;
 609     int overlap_check_template = 0;
 610     uint64_t l2_cache_size, refcount_cache_size;
 611     int i;
 612     Error *local_err = NULL;
 613     int ret;
 614
 615     opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
 616     qemu_opts_absorb_qdict(opts, options, &local_err);
 617     if (local_err) {
 618         error_propagate(errp, local_err);
 619         ret = -EINVAL;
 620         goto fail;
 621     }
 622
 623     /* get L2 table/refcount block cache size from command line options */
 624     read_cache_sizes(bs, opts, &l2_cache_size, &refcount_cache_size,
 625                      &local_err);
 626     if (local_err) {
 627         error_propagate(errp, local_err);
 628         ret = -EINVAL;
 629         goto fail;
 630     }
 631
 632     l2_cache_size /= s->cluster_size;
 633     if (l2_cache_size < MIN_L2_CACHE_SIZE) {
 634         l2_cache_size = MIN_L2_CACHE_SIZE;
 635     }
 636     if (l2_cache_size > INT_MAX) {
 637         error_setg(errp, "L2 cache size too big");
 638         ret = -EINVAL;
 639         goto fail;
 640     }
 641
 642     refcount_cache_size /= s->cluster_size;
 643     if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
 644         refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
 645     }
 646     if (refcount_cache_size > INT_MAX) {
 647         error_setg(errp, "Refcount cache size too big");
 648         ret = -EINVAL;
 649         goto fail;
 650     }
 651
 652     /* alloc new L2 table/refcount block cache, flush old one */
 653     if (s->l2_table_cache) {
 654         ret = qcow2_cache_flush(bs, s->l2_table_cache);
 655         if (ret) {
 656             error_setg_errno(errp, -ret, "Failed to flush the L2 table cache");
 657             goto fail;
 658         }
 659     }
 660
 661     if (s->refcount_block_cache) {
 662         ret = qcow2_cache_flush(bs, s->refcount_block_cache);
 663         if (ret) {
 664             error_setg_errno(errp, -ret,
 665                              "Failed to flush the refcount block cache");
 666             goto fail;
 667         }
 668     }
 669
 670     r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size);
 671     r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size);
 672     if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) {
 673         error_setg(errp, "Could not allocate metadata caches");
 674         ret = -ENOMEM;
 675         goto fail;
 676     }
 677
 678     /* New interval for cache cleanup timer */
 679     r->cache_clean_interval =
 680         qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
 681                             s->cache_clean_interval);
 682     if (r->cache_clean_interval > UINT_MAX) {
 683         error_setg(errp, "Cache clean interval too big");
 684         ret = -EINVAL;
 685         goto fail;
 686     }
 687
 688     /* lazy-refcounts; flush if going from enabled to disabled */
 689     r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
 690         (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
 691     if (r->use_lazy_refcounts && s->qcow_version < 3) {
 692         error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
 693                    "qemu 1.1 compatibility level");
 694         ret = -EINVAL;
 695         goto fail;
 696     }
 697
 698     if (s->use_lazy_refcounts && !r->use_lazy_refcounts) {
 699         ret = qcow2_mark_clean(bs);
 700         if (ret < 0) {
 701             error_setg_errno(errp, -ret, "Failed to disable lazy refcounts");
 702             goto fail;
 703         }
 704     }
 705
 706     /* Overlap check options */
 707     opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
 708     opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
 709     if (opt_overlap_check_template && opt_overlap_check &&
 710         strcmp(opt_overlap_check_template, opt_overlap_check))
 711     {
 712         error_setg(errp, "Conflicting values for qcow2 options '"
 713                    QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
 714                    "' ('%s')", opt_overlap_check, opt_overlap_check_template);
 715         ret = -EINVAL;
 716         goto fail;
 717     }
 718     if (!opt_overlap_check) {
 719         opt_overlap_check = opt_overlap_check_template ?: "cached";
 720     }
 721
 722     if (!strcmp(opt_overlap_check, "none")) {
 723         overlap_check_template = 0;
 724     } else if (!strcmp(opt_overlap_check, "constant")) {
 725         overlap_check_template = QCOW2_OL_CONSTANT;
 726     } else if (!strcmp(opt_overlap_check, "cached")) {
 727         overlap_check_template = QCOW2_OL_CACHED;
 728     } else if (!strcmp(opt_overlap_check, "all")) {
 729         overlap_check_template = QCOW2_OL_ALL;
 730     } else {
 731         error_setg(errp, "Unsupported value '%s' for qcow2 option "
 732                    "'overlap-check'. Allowed are any of the following: "
 733                    "none, constant, cached, all", opt_overlap_check);
 734         ret = -EINVAL;
 735         goto fail;
 736     }
 737
 738     r->overlap_check = 0;
 739     for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
 740         /* overlap-check defines a template bitmask, but every flag may be
 741          * overwritten through the associated boolean option */
 742         r->overlap_check |=
 743             qemu_opt_get_bool(opts, overlap_bool_option_names[i],
 744                               overlap_check_template & (1 << i)) << i;
 745     }
 746
 747     r->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
 748     r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
 749     r->discard_passthrough[QCOW2_DISCARD_REQUEST] =
 750         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
 751                           flags & BDRV_O_UNMAP);
 752     r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
 753         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
 754     r->discard_passthrough[QCOW2_DISCARD_OTHER] =
 755         qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);
 756
 757     ret = 0;
 758 fail:
 759     qemu_opts_del(opts);
 760     opts = NULL;
 761     return ret;
 762 }
 763
 764 static void qcow2_update_options_commit(BlockDriverState *bs,
 765                                         Qcow2ReopenState *r)
 766 {
 767     BDRVQcow2State *s = bs->opaque;
 768     int i;
 769
 770     if (s->l2_table_cache) {
 771         qcow2_cache_destroy(bs, s->l2_table_cache);
 772     }
 773     if (s->refcount_block_cache) {
 774         qcow2_cache_destroy(bs, s->refcount_block_cache);
 775     }
 776     s->l2_table_cache = r->l2_table_cache;
 777     s->refcount_block_cache = r->refcount_block_cache;
 778
 779     s->overlap_check = r->overlap_check;
 780     s->use_lazy_refcounts = r->use_lazy_refcounts;
 781
 782     for (i = 0; i < QCOW2_DISCARD_MAX; i++) {
 783         s->discard_passthrough[i] = r->discard_passthrough[i];
 784     }
 785
 786     if (s->cache_clean_interval != r->cache_clean_interval) {
 787         cache_clean_timer_del(bs);
 788         s->cache_clean_interval = r->cache_clean_interval;
 789         cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
 790     }
 791 }
 792
 793 static void qcow2_update_options_abort(BlockDriverState *bs,
 794                                        Qcow2ReopenState *r)
 795 {
 796     if (r->l2_table_cache) {
 797         qcow2_cache_destroy(bs, r->l2_table_cache);
 798     }
 799     if (r->refcount_block_cache) {
 800         qcow2_cache_destroy(bs, r->refcount_block_cache);
 801     }
 802 }
 803
 804 static int qcow2_update_options(BlockDriverState *bs, QDict *options,
 805                                 int flags, Error **errp)
 806 {
 807     Qcow2ReopenState r = {};
 808     int ret;
 809
 810     ret = qcow2_update_options_prepare(bs, &r, options, flags, errp);
 811     if (ret >= 0) {
 812         qcow2_update_options_commit(bs, &r);
 813     } else {
 814         qcow2_update_options_abort(bs, &r);
 815     }
 816
 817     return ret;
 818 }
 819
 820 static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
 821                       Error **errp)
 822 {
 823     BDRVQcow2State *s = bs->opaque;
 824     unsigned int len, i;
 825     int ret = 0;
 826     QCowHeader header;
 827     Error *local_err = NULL;
 828     uint64_t ext_end;
 829     uint64_t l1_vm_state_index;
 830
 831     ret = bdrv_pread(bs->file->bs, 0, &header, sizeof(header));
 832     if (ret < 0) {
 833         error_setg_errno(errp, -ret, "Could not read qcow2 header");
 834         goto fail;
 835     }
 836     be32_to_cpus(&header.magic);
 837     be32_to_cpus(&header.version);
 838     be64_to_cpus(&header.backing_file_offset);
 839     be32_to_cpus(&header.backing_file_size);
 840     be64_to_cpus(&header.size);
 841     be32_to_cpus(&header.cluster_bits);
 842     be32_to_cpus(&header.crypt_method);
 843     be64_to_cpus(&header.l1_table_offset);
 844     be32_to_cpus(&header.l1_size);
 845     be64_to_cpus(&header.refcount_table_offset);
 846     be32_to_cpus(&header.refcount_table_clusters);
 847     be64_to_cpus(&header.snapshots_offset);
 848     be32_to_cpus(&header.nb_snapshots);
 849
 850     if (header.magic != QCOW_MAGIC) {
 851         error_setg(errp, "Image is not in qcow2 format");
 852         ret = -EINVAL;
 853         goto fail;
 854     }
 855     if (header.version < 2 || header.version > 3) {
 856         report_unsupported(bs, errp, "QCOW version %" PRIu32, header.version);
 857         ret = -ENOTSUP;
 858         goto fail;
 859     }
 860
 861     s->qcow_version = header.version;
 862
 863     /* Initialise cluster size */
 864     if (header.cluster_bits < MIN_CLUSTER_BITS ||
 865         header.cluster_bits > MAX_CLUSTER_BITS) {
 866         error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
 867                    header.cluster_bits);
 868         ret = -EINVAL;
 869         goto fail;
 870     }
 871
 872     s->cluster_bits = header.cluster_bits;
 873     s->cluster_size = 1 << s->cluster_bits;
 874     s->cluster_sectors = 1 << (s->cluster_bits - 9);
 875
 876     /* Initialise version 3 header fields */
 877     if (header.version == 2) {
 878         header.incompatible_features    = 0;
 879         header.compatible_features      = 0;
 880         header.autoclear_features       = 0;
 881         header.refcount_order           = 4;
 882         header.header_length            = 72;
 883     } else {
 884         be64_to_cpus(&header.incompatible_features);
 885         be64_to_cpus(&header.compatible_features);
 886         be64_to_cpus(&header.autoclear_features);
 887         be32_to_cpus(&header.refcount_order);
 888         be32_to_cpus(&header.header_length);
 889
 890         if (header.header_length < 104) {
 891             error_setg(errp, "qcow2 header too short");
 892             ret = -EINVAL;
 893             goto fail;
 894         }
 895     }
 896
 897     if (header.header_length > s->cluster_size) {
 898         error_setg(errp, "qcow2 header exceeds cluster size");
 899         ret = -EINVAL;
 900         goto fail;
 901     }
 902
 903     if (header.header_length > sizeof(header)) {
 904         s->unknown_header_fields_size = header.header_length - sizeof(header);
 905         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
 906         ret = bdrv_pread(bs->file->bs, sizeof(header), s->unknown_header_fields,
 907                          s->unknown_header_fields_size);
 908         if (ret < 0) {
 909             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
 910                              "fields");
 911             goto fail;
 912         }
 913     }
 914
 915     if (header.backing_file_offset > s->cluster_size) {
 916         error_setg(errp, "Invalid backing file offset");
 917         ret = -EINVAL;
 918         goto fail;
 919     }
 920
 921     if (header.backing_file_offset) {
 922         ext_end = header.backing_file_offset;
 923     } else {
 924         ext_end = 1 << header.cluster_bits;
 925     }
 926
 927     /* Handle feature bits */
 928     s->incompatible_features    = header.incompatible_features;
 929     s->compatible_features      = header.compatible_features;
 930     s->autoclear_features       = header.autoclear_features;
 931
 932     if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
 933         void *feature_table = NULL;
 934         qcow2_read_extensions(bs, header.header_length, ext_end,
 935                               &feature_table, NULL);
 936         report_unsupported_feature(bs, errp, feature_table,
 937                                    s->incompatible_features &
 938                                    ~QCOW2_INCOMPAT_MASK);
 939         ret = -ENOTSUP;
 940         g_free(feature_table);
 941         goto fail;
 942     }
 943
 944     if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
 945         /* Corrupt images may not be written to unless they are being repaired
 946          */
 947         if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
 948             error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
 949                        "read/write");
 950             ret = -EACCES;
 951             goto fail;
 952         }
 953     }
 954
 955     /* Check support for various header values */
 956     if (header.refcount_order > 6) {
 957         error_setg(errp, "Reference count entry width too large; may not "
 958                    "exceed 64 bits");
 959         ret = -EINVAL;
 960         goto fail;
 961     }
 962     s->refcount_order = header.refcount_order;
 963     s->refcount_bits = 1 << s->refcount_order;
 964     s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
 965     s->refcount_max += s->refcount_max - 1;
 966
 967     if (header.crypt_method > QCOW_CRYPT_AES) {
 968         error_setg(errp, "Unsupported encryption method: %" PRIu32,
 969                    header.crypt_method);
 970         ret = -EINVAL;
 971         goto fail;
 972     }
 973     if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128)) {
 974         error_setg(errp, "AES cipher not available");
 975         ret = -EINVAL;
 976         goto fail;
 977     }
 978     s->crypt_method_header = header.crypt_method;
 979     if (s->crypt_method_header) {
 980         bs->encrypted = 1;
 981     }
 982
 983     s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
 984     s->l2_size = 1 << s->l2_bits;
 985     /* 2^(s->refcount_order - 3) is the refcount width in bytes */
 986     s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
 987     s->refcount_block_size = 1 << s->refcount_block_bits;
 988     bs->total_sectors = header.size / 512;
 989     s->csize_shift = (62 - (s->cluster_bits - 8));
 990     s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
 991     s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
 992
 993     s->refcount_table_offset = header.refcount_table_offset;
 994     s->refcount_table_size =
 995         header.refcount_table_clusters << (s->cluster_bits - 3);
 996
 997     if (header.refcount_table_clusters > qcow2_max_refcount_clusters(s)) {
 998         error_setg(errp, "Reference count table too large");
 999         ret = -EINVAL;
1000         goto fail;
1001     }
1002
1003     ret = validate_table_offset(bs, s->refcount_table_offset,
1004                                 s->refcount_table_size, sizeof(uint64_t));
1005     if (ret < 0) {
1006         error_setg(errp, "Invalid reference count table offset");
1007         goto fail;
1008     }
1009
1010     /* Snapshot table offset/length */
1011     if (header.nb_snapshots > QCOW_MAX_SNAPSHOTS) {
1012         error_setg(errp, "Too many snapshots");
1013         ret = -EINVAL;
1014         goto fail;
1015     }
1016
1017     ret = validate_table_offset(bs, header.snapshots_offset,
1018                                 header.nb_snapshots,
1019                                 sizeof(QCowSnapshotHeader));
1020     if (ret < 0) {
1021         error_setg(errp, "Invalid snapshot table offset");
1022         goto fail;
1023     }
1024
1025     /* read the level 1 table */
1026     if (header.l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
1027         error_setg(errp, "Active L1 table too large");
1028         ret = -EFBIG;
1029         goto fail;
1030     }
1031     s->l1_size = header.l1_size;
1032
1033     l1_vm_state_index = size_to_l1(s, header.size);
1034     if (l1_vm_state_index > INT_MAX) {
1035         error_setg(errp, "Image is too big");
1036         ret = -EFBIG;
1037         goto fail;
1038     }
1039     s->l1_vm_state_index = l1_vm_state_index;
1040
1041     /* the L1 table must contain at least enough entries to put
1042        header.size bytes */
1043     if (s->l1_size < s->l1_vm_state_index) {
1044         error_setg(errp, "L1 table is too small");
1045         ret = -EINVAL;
1046         goto fail;
1047     }
1048
1049     ret = validate_table_offset(bs, header.l1_table_offset,
1050                                 header.l1_size, sizeof(uint64_t));
1051     if (ret < 0) {
1052         error_setg(errp, "Invalid L1 table offset");
1053         goto fail;
1054     }
1055     s->l1_table_offset = header.l1_table_offset;
1056
1057
1058     if (s->l1_size > 0) {
1059         s->l1_table = qemu_try_blockalign(bs->file->bs,
1060             align_offset(s->l1_size * sizeof(uint64_t), 512));
1061         if (s->l1_table == NULL) {
1062             error_setg(errp, "Could not allocate L1 table");
1063             ret = -ENOMEM;
1064             goto fail;
1065         }
1066         ret = bdrv_pread(bs->file->bs, s->l1_table_offset, s->l1_table,
1067                          s->l1_size * sizeof(uint64_t));
1068         if (ret < 0) {
1069             error_setg_errno(errp, -ret, "Could not read L1 table");
1070             goto fail;
1071         }
1072         for(i = 0;i < s->l1_size; i++) {
1073             be64_to_cpus(&s->l1_table[i]);
1074         }
1075     }
1076
1077     /* Parse driver-specific options */
1078     ret = qcow2_update_options(bs, options, flags, errp);
1079     if (ret < 0) {
1080         goto fail;
1081     }
1082
1083     s->cluster_cache = g_malloc(s->cluster_size);
1084     /* one more sector for decompressed data alignment */
1085     s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
1086                                                     * s->cluster_size + 512);
1087     if (s->cluster_data == NULL) {
1088         error_setg(errp, "Could not allocate temporary cluster buffer");
1089         ret = -ENOMEM;
1090         goto fail;
1091     }
1092
1093     s->cluster_cache_offset = -1;
1094     s->flags = flags;
1095
1096     ret = qcow2_refcount_init(bs);
1097     if (ret != 0) {
1098         error_setg_errno(errp, -ret, "Could not initialize refcount handling");
1099         goto fail;
1100     }
1101
1102     QLIST_INIT(&s->cluster_allocs);
1103     QTAILQ_INIT(&s->discards);
1104
1105     /* read qcow2 extensions */
1106     if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
1107         &local_err)) {
1108         error_propagate(errp, local_err);
1109         ret = -EINVAL;
1110         goto fail;
1111     }
1112
1113     /* read the backing file name */
1114     if (header.backing_file_offset != 0) {
1115         len = header.backing_file_size;
1116         if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
1117             len >= sizeof(bs->backing_file)) {
1118             error_setg(errp, "Backing file name too long");
1119             ret = -EINVAL;
1120             goto fail;
1121         }
1122         ret = bdrv_pread(bs->file->bs, header.backing_file_offset,
1123                          bs->backing_file, len);
1124         if (ret < 0) {
1125             error_setg_errno(errp, -ret, "Could not read backing file name");
1126             goto fail;
1127         }
1128         bs->backing_file[len] = '\0';
1129         s->image_backing_file = g_strdup(bs->backing_file);
1130     }
1131
1132     /* Internal snapshots */
1133     s->snapshots_offset = header.snapshots_offset;
1134     s->nb_snapshots = header.nb_snapshots;
1135
1136     ret = qcow2_read_snapshots(bs);
1137     if (ret < 0) {
1138         error_setg_errno(errp, -ret, "Could not read snapshots");
1139         goto fail;
1140     }
1141
1142     /* Clear unknown autoclear feature bits */
1143     if (!bs->read_only && !(flags & BDRV_O_INCOMING) && s->autoclear_features) {
1144         s->autoclear_features = 0;
1145         ret = qcow2_update_header(bs);
1146         if (ret < 0) {
1147             error_setg_errno(errp, -ret, "Could not update qcow2 header");
1148             goto fail;
1149         }
1150     }
1151
1152     /* Initialise locks */
1153     qemu_co_mutex_init(&s->lock);
1154
1155     /* Repair image if dirty */
1156     if (!(flags & (BDRV_O_CHECK | BDRV_O_INCOMING)) && !bs->read_only &&
1157         (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
1158         BdrvCheckResult result = {0};
1159
1160         ret = qcow2_check(bs, &result, BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
1161         if (ret < 0) {
1162             error_setg_errno(errp, -ret, "Could not repair dirty image");
1163             goto fail;
1164         }
1165     }
1166
1167 #ifdef DEBUG_ALLOC
1168     {
1169         BdrvCheckResult result = {0};
1170         qcow2_check_refcounts(bs, &result, 0);
1171     }
1172 #endif
1173     return ret;
1174
1175  fail:
1176     g_free(s->unknown_header_fields);
1177     cleanup_unknown_header_ext(bs);
1178     qcow2_free_snapshots(bs);
1179     qcow2_refcount_close(bs);
1180     qemu_vfree(s->l1_table);
1181     /* else pre-write overlap checks in cache_destroy may crash */
1182     s->l1_table = NULL;
1183     cache_clean_timer_del(bs);
1184     if (s->l2_table_cache) {
1185         qcow2_cache_destroy(bs, s->l2_table_cache);
1186     }
1187     if (s->refcount_block_cache) {
1188         qcow2_cache_destroy(bs, s->refcount_block_cache);
1189     }
1190     g_free(s->cluster_cache);
1191     qemu_vfree(s->cluster_data);
1192     return ret;
1193 }
1194
1195 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
1196 {
1197     BDRVQcow2State *s = bs->opaque;
1198
1199     bs->bl.write_zeroes_alignment = s->cluster_sectors;
1200 }
1201
1202 static int qcow2_set_key(BlockDriverState *bs, const char *key)
1203 {
1204     BDRVQcow2State *s = bs->opaque;
1205     uint8_t keybuf[16];
1206     int len, i;
1207     Error *err = NULL;
1208
1209     memset(keybuf, 0, 16);
1210     len = strlen(key);
1211     if (len > 16)
1212         len = 16;
1213     /* XXX: we could compress the chars to 7 bits to increase
1214        entropy */
1215     for(i = 0;i < len;i++) {
1216         keybuf[i] = key[i];
1217     }
1218     assert(bs->encrypted);
1219
1220     qcrypto_cipher_free(s->cipher);
1221     s->cipher = qcrypto_cipher_new(
1222         QCRYPTO_CIPHER_ALG_AES_128,
1223         QCRYPTO_CIPHER_MODE_CBC,
1224         keybuf, G_N_ELEMENTS(keybuf),
1225         &err);
1226
1227     if (!s->cipher) {
1228         /* XXX would be nice if errors in this method could
1229          * be properly propagate to the caller. Would need
1230          * the bdrv_set_key() API signature to be fixed. */
1231         error_free(err);
1232         return -1;
1233     }
1234     return 0;
1235 }
1236
1237 static int qcow2_reopen_prepare(BDRVReopenState *state,
1238                                 BlockReopenQueue *queue, Error **errp)
1239 {
1240     Qcow2ReopenState *r;
1241     int ret;
1242
1243     r = g_new0(Qcow2ReopenState, 1);
1244     state->opaque = r;
1245
1246     ret = qcow2_update_options_prepare(state->bs, r, state->options,
1247                                        state->flags, errp);
1248     if (ret < 0) {
1249         goto fail;
1250     }
1251
1252     /* We need to write out any unwritten data if we reopen read-only. */
1253     if ((state->flags & BDRV_O_RDWR) == 0) {
1254         ret = bdrv_flush(state->bs);
1255         if (ret < 0) {
1256             goto fail;
1257         }
1258
1259         ret = qcow2_mark_clean(state->bs);
1260         if (ret < 0) {
1261             goto fail;
1262         }
1263     }
1264
1265     return 0;
1266
1267 fail:
1268     qcow2_update_options_abort(state->bs, r);
1269     g_free(r);
1270     return ret;
1271 }
1272
1273 static void qcow2_reopen_commit(BDRVReopenState *state)
1274 {
1275     qcow2_update_options_commit(state->bs, state->opaque);
1276     g_free(state->opaque);
1277 }
1278
1279 static void qcow2_reopen_abort(BDRVReopenState *state)
1280 {
1281     qcow2_update_options_abort(state->bs, state->opaque);
1282     g_free(state->opaque);
1283 }
1284
1285 static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
1286         int64_t sector_num, int nb_sectors, int *pnum)
1287 {
1288     BDRVQcow2State *s = bs->opaque;
1289     uint64_t cluster_offset;
1290     int index_in_cluster, ret;
1291     int64_t status = 0;
1292
1293     *pnum = nb_sectors;
1294     qemu_co_mutex_lock(&s->lock);
1295     ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);
1296     qemu_co_mutex_unlock(&s->lock);
1297     if (ret < 0) {
1298         return ret;
1299     }
1300
1301     if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
1302         !s->cipher) {
1303         index_in_cluster = sector_num & (s->cluster_sectors - 1);
1304         cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
1305         status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;
1306     }
1307     if (ret == QCOW2_CLUSTER_ZERO) {
1308         status |= BDRV_BLOCK_ZERO;
1309     } else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
1310         status |= BDRV_BLOCK_DATA;
1311     }
1312     return status;
1313 }
1314
1315 /* handle reading after the end of the backing file */
1316 int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
1317                   int64_t sector_num, int nb_sectors)
1318 {
1319     int n1;
1320     if ((sector_num + nb_sectors) <= bs->total_sectors)
1321         return nb_sectors;
1322     if (sector_num >= bs->total_sectors)
1323         n1 = 0;
1324     else
1325         n1 = bs->total_sectors - sector_num;
1326
1327     qemu_iovec_memset(qiov, 512 * n1, 0, 512 * (nb_sectors - n1));
1328
1329     return n1;
1330 }
1331
1332 static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
1333                           int remaining_sectors, QEMUIOVector *qiov)
1334 {
1335     BDRVQcow2State *s = bs->opaque;
1336     int index_in_cluster, n1;
1337     int ret;
1338     int cur_nr_sectors; /* number of sectors in current iteration */
1339     uint64_t cluster_offset = 0;
1340     uint64_t bytes_done = 0;
1341     QEMUIOVector hd_qiov;
1342     uint8_t *cluster_data = NULL;
1343
1344     qemu_iovec_init(&hd_qiov, qiov->niov);
1345
1346     qemu_co_mutex_lock(&s->lock);
1347
1348     while (remaining_sectors != 0) {
1349
1350         /* prepare next request */
1351         cur_nr_sectors = remaining_sectors;
1352         if (s->cipher) {
1353             cur_nr_sectors = MIN(cur_nr_sectors,
1354                 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
1355         }
1356
1357         ret = qcow2_get_cluster_offset(bs, sector_num << 9,
1358             &cur_nr_sectors, &cluster_offset);
1359         if (ret < 0) {
1360             goto fail;
1361         }
1362
1363         index_in_cluster = sector_num & (s->cluster_sectors - 1);
1364
1365         qemu_iovec_reset(&hd_qiov);
1366         qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
1367             cur_nr_sectors * 512);
1368
1369         switch (ret) {
1370         case QCOW2_CLUSTER_UNALLOCATED:
1371
1372             if (bs->backing) {
1373                 /* read from the base image */
1374                 n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov,
1375                     sector_num, cur_nr_sectors);
1376                 if (n1 > 0) {
1377                     QEMUIOVector local_qiov;
1378
1379                     qemu_iovec_init(&local_qiov, hd_qiov.niov);
1380                     qemu_iovec_concat(&local_qiov, &hd_qiov, 0,
1381                                       n1 * BDRV_SECTOR_SIZE);
1382
1383                     BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
1384                     qemu_co_mutex_unlock(&s->lock);
1385                     ret = bdrv_co_readv(bs->backing->bs, sector_num,
1386                                         n1, &local_qiov);
1387                     qemu_co_mutex_lock(&s->lock);
1388
1389                     qemu_iovec_destroy(&local_qiov);
1390
1391                     if (ret < 0) {
1392                         goto fail;
1393                     }
1394                 }
1395             } else {
1396                 /* Note: in this case, no need to wait */
1397                 qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors);
1398             }
1399             break;
1400
1401         case QCOW2_CLUSTER_ZERO:
1402             qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors);
1403             break;
1404
1405         case QCOW2_CLUSTER_COMPRESSED:
1406             /* add AIO support for compressed blocks ? */
1407             ret = qcow2_decompress_cluster(bs, cluster_offset);
1408             if (ret < 0) {
1409                 goto fail;
1410             }
1411
1412             qemu_iovec_from_buf(&hd_qiov, 0,
1413                 s->cluster_cache + index_in_cluster * 512,
1414                 512 * cur_nr_sectors);
1415             break;
1416
1417         case QCOW2_CLUSTER_NORMAL:
1418             if ((cluster_offset & 511) != 0) {
1419                 ret = -EIO;
1420                 goto fail;
1421             }
1422
1423             if (bs->encrypted) {
1424                 assert(s->cipher);
1425
1426                 /*
1427                  * For encrypted images, read everything into a temporary
1428                  * contiguous buffer on which the AES functions can work.
1429                  */
1430                 if (!cluster_data) {
1431                     cluster_data =
1432                         qemu_try_blockalign(bs->file->bs,
1433                                             QCOW_MAX_CRYPT_CLUSTERS
1434                                             * s->cluster_size);
1435                     if (cluster_data == NULL) {
1436                         ret = -ENOMEM;
1437                         goto fail;
1438                     }
1439                 }
1440
1441                 assert(cur_nr_sectors <=
1442                     QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
1443                 qemu_iovec_reset(&hd_qiov);
1444                 qemu_iovec_add(&hd_qiov, cluster_data,
1445                     512 * cur_nr_sectors);
1446             }
1447
1448             BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
1449             qemu_co_mutex_unlock(&s->lock);
1450             ret = bdrv_co_readv(bs->file->bs,
1451                                 (cluster_offset >> 9) + index_in_cluster,
1452                                 cur_nr_sectors, &hd_qiov);
1453             qemu_co_mutex_lock(&s->lock);
1454             if (ret < 0) {
1455                 goto fail;
1456             }
1457             if (bs->encrypted) {
1458                 assert(s->cipher);
1459                 Error *err = NULL;
1460                 if (qcow2_encrypt_sectors(s, sector_num,  cluster_data,
1461                                           cluster_data, cur_nr_sectors, false,
1462                                           &err) < 0) {
1463                     error_free(err);
1464                     ret = -EIO;
1465                     goto fail;
1466                 }
1467                 qemu_iovec_from_buf(qiov, bytes_done,
1468                     cluster_data, 512 * cur_nr_sectors);
1469             }
1470             break;
1471
1472         default:
1473             g_assert_not_reached();
1474             ret = -EIO;
1475             goto fail;
1476         }
1477
1478         remaining_sectors -= cur_nr_sectors;
1479         sector_num += cur_nr_sectors;
1480         bytes_done += cur_nr_sectors * 512;
1481     }
1482     ret = 0;
1483
1484 fail:
1485     qemu_co_mutex_unlock(&s->lock);
1486
1487     qemu_iovec_destroy(&hd_qiov);
1488     qemu_vfree(cluster_data);
1489
1490     return ret;
1491 }
1492
1493 static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
1494                            int64_t sector_num,
1495                            int remaining_sectors,
1496                            QEMUIOVector *qiov)
1497 {
1498     BDRVQcow2State *s = bs->opaque;
1499     int index_in_cluster;
1500     int ret;
1501     int cur_nr_sectors; /* number of sectors in current iteration */
1502     uint64_t cluster_offset;
1503     QEMUIOVector hd_qiov;
1504     uint64_t bytes_done = 0;
1505     uint8_t *cluster_data = NULL;
1506     QCowL2Meta *l2meta = NULL;
1507
1508     trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num,
1509                                  remaining_sectors);
1510
1511     qemu_iovec_init(&hd_qiov, qiov->niov);
1512
1513     s->cluster_cache_offset = -1; /* disable compressed cache */
1514
1515     qemu_co_mutex_lock(&s->lock);
1516
1517     while (remaining_sectors != 0) {
1518
1519         l2meta = NULL;
1520
1521         trace_qcow2_writev_start_part(qemu_coroutine_self());
1522         index_in_cluster = sector_num & (s->cluster_sectors - 1);
1523         cur_nr_sectors = remaining_sectors;
1524         if (bs->encrypted &&
1525             cur_nr_sectors >
1526             QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors - index_in_cluster) {
1527             cur_nr_sectors =
1528                 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors - index_in_cluster;
1529         }
1530
1531         ret = qcow2_alloc_cluster_offset(bs, sector_num << 9,
1532             &cur_nr_sectors, &cluster_offset, &l2meta);
1533         if (ret < 0) {
1534             goto fail;
1535         }
1536
1537         assert((cluster_offset & 511) == 0);
1538
1539         qemu_iovec_reset(&hd_qiov);
1540         qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
1541             cur_nr_sectors * 512);
1542
1543         if (bs->encrypted) {
1544             Error *err = NULL;
1545             assert(s->cipher);
1546             if (!cluster_data) {
1547                 cluster_data = qemu_try_blockalign(bs->file->bs,
1548                                                    QCOW_MAX_CRYPT_CLUSTERS
1549                                                    * s->cluster_size);
1550                 if (cluster_data == NULL) {
1551                     ret = -ENOMEM;
1552                     goto fail;
1553                 }
1554             }
1555
1556             assert(hd_qiov.size <=
1557                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
1558             qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
1559
1560             if (qcow2_encrypt_sectors(s, sector_num, cluster_data,
1561                                       cluster_data, cur_nr_sectors,
1562                                       true, &err) < 0) {
1563                 error_free(err);
1564                 ret = -EIO;
1565                 goto fail;
1566             }
1567
1568             qemu_iovec_reset(&hd_qiov);
1569             qemu_iovec_add(&hd_qiov, cluster_data,
1570                 cur_nr_sectors * 512);
1571         }
1572
1573         ret = qcow2_pre_write_overlap_check(bs, 0,
1574                 cluster_offset + index_in_cluster * BDRV_SECTOR_SIZE,
1575                 cur_nr_sectors * BDRV_SECTOR_SIZE);
1576         if (ret < 0) {
1577             goto fail;
1578         }
1579
1580         qemu_co_mutex_unlock(&s->lock);
1581         BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
1582         trace_qcow2_writev_data(qemu_coroutine_self(),
1583                                 (cluster_offset >> 9) + index_in_cluster);
1584         ret = bdrv_co_writev(bs->file->bs,
1585                              (cluster_offset >> 9) + index_in_cluster,
1586                              cur_nr_sectors, &hd_qiov);
1587         qemu_co_mutex_lock(&s->lock);
1588         if (ret < 0) {
1589             goto fail;
1590         }
1591
1592         while (l2meta != NULL) {
1593             QCowL2Meta *next;
1594
1595             ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
1596             if (ret < 0) {
1597                 goto fail;
1598             }
1599
1600             /* Take the request off the list of running requests */
1601             if (l2meta->nb_clusters != 0) {
1602                 QLIST_REMOVE(l2meta, next_in_flight);
1603             }
1604
1605             qemu_co_queue_restart_all(&l2meta->dependent_requests);
1606
1607             next = l2meta->next;
1608             g_free(l2meta);
1609             l2meta = next;
1610         }
1611
1612         remaining_sectors -= cur_nr_sectors;
1613         sector_num += cur_nr_sectors;
1614         bytes_done += cur_nr_sectors * 512;
1615         trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors);
1616     }
1617     ret = 0;
1618
1619 fail:
1620     qemu_co_mutex_unlock(&s->lock);
1621
1622     while (l2meta != NULL) {
1623         QCowL2Meta *next;
1624
1625         if (l2meta->nb_clusters != 0) {
1626             QLIST_REMOVE(l2meta, next_in_flight);
1627         }
1628         qemu_co_queue_restart_all(&l2meta->dependent_requests);
1629
1630         next = l2meta->next;
1631         g_free(l2meta);
1632         l2meta = next;
1633     }
1634
1635     qemu_iovec_destroy(&hd_qiov);
1636     qemu_vfree(cluster_data);
1637     trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
1638
1639     return ret;
1640 }
1641
1642 static void qcow2_close(BlockDriverState *bs)
1643 {
1644     BDRVQcow2State *s = bs->opaque;
1645     qemu_vfree(s->l1_table);
1646     /* else pre-write overlap checks in cache_destroy may crash */
1647     s->l1_table = NULL;
1648
1649     if (!(bs->open_flags & BDRV_O_INCOMING)) {
1650         int ret1, ret2;
1651
1652         ret1 = qcow2_cache_flush(bs, s->l2_table_cache);
1653         ret2 = qcow2_cache_flush(bs, s->refcount_block_cache);
1654
1655         if (ret1) {
1656             error_report("Failed to flush the L2 table cache: %s",
1657                          strerror(-ret1));
1658         }
1659         if (ret2) {
1660             error_report("Failed to flush the refcount block cache: %s",
1661                          strerror(-ret2));
1662         }
1663
1664         if (!ret1 && !ret2) {
1665             qcow2_mark_clean(bs);
1666         }
1667     }
1668
1669     cache_clean_timer_del(bs);
1670     qcow2_cache_destroy(bs, s->l2_table_cache);
1671     qcow2_cache_destroy(bs, s->refcount_block_cache);
1672
1673     qcrypto_cipher_free(s->cipher);
1674     s->cipher = NULL;
1675
1676     g_free(s->unknown_header_fields);
1677     cleanup_unknown_header_ext(bs);
1678
1679     g_free(s->image_backing_file);
1680     g_free(s->image_backing_format);
1681
1682     g_free(s->cluster_cache);
1683     qemu_vfree(s->cluster_data);
1684     qcow2_refcount_close(bs);
1685     qcow2_free_snapshots(bs);
1686 }
1687
1688 static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
1689 {
1690     BDRVQcow2State *s = bs->opaque;
1691     int flags = s->flags;
1692     QCryptoCipher *cipher = NULL;
1693     QDict *options;
1694     Error *local_err = NULL;
1695     int ret;
1696
1697     /*
1698      * Backing files are read-only which makes all of their metadata immutable,
1699      * that means we don't have to worry about reopening them here.
1700      */
1701
1702     cipher = s->cipher;
1703     s->cipher = NULL;
1704
1705     qcow2_close(bs);
1706
1707     bdrv_invalidate_cache(bs->file->bs, &local_err);
1708     if (local_err) {
1709         error_propagate(errp, local_err);
1710         return;
1711     }
1712
1713     memset(s, 0, sizeof(BDRVQcow2State));
1714     options = qdict_clone_shallow(bs->options);
1715
1716     ret = qcow2_open(bs, options, flags, &local_err);
1717     QDECREF(options);
1718     if (local_err) {
1719         error_setg(errp, "Could not reopen qcow2 layer: %s",
1720                    error_get_pretty(local_err));
1721         error_free(local_err);
1722         return;
1723     } else if (ret < 0) {
1724         error_setg_errno(errp, -ret, "Could not reopen qcow2 layer");
1725         return;
1726     }
1727
1728     s->cipher = cipher;
1729 }
1730
1731 static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
1732     size_t len, size_t buflen)
1733 {
1734     QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
1735     size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
1736
1737     if (buflen < ext_len) {
1738         return -ENOSPC;
1739     }
1740
1741     *ext_backing_fmt = (QCowExtension) {
1742         .magic  = cpu_to_be32(magic),
1743         .len    = cpu_to_be32(len),
1744     };
1745     memcpy(buf + sizeof(QCowExtension), s, len);
1746
1747     return ext_len;
1748 }
1749
1750 /*
1751  * Updates the qcow2 header, including the variable length parts of it, i.e.
1752  * the backing file name and all extensions. qcow2 was not designed to allow
1753  * such changes, so if we run out of space (we can only use the first cluster)
1754  * this function may fail.
1755  *
1756  * Returns 0 on success, -errno in error cases.
1757  */
1758 int qcow2_update_header(BlockDriverState *bs)
1759 {
1760     BDRVQcow2State *s = bs->opaque;
1761     QCowHeader *header;
1762     char *buf;
1763     size_t buflen = s->cluster_size;
1764     int ret;
1765     uint64_t total_size;
1766     uint32_t refcount_table_clusters;
1767     size_t header_length;
1768     Qcow2UnknownHeaderExtension *uext;
1769
1770     buf = qemu_blockalign(bs, buflen);
1771
1772     /* Header structure */
1773     header = (QCowHeader*) buf;
1774
1775     if (buflen < sizeof(*header)) {
1776         ret = -ENOSPC;
1777         goto fail;
1778     }
1779
1780     header_length = sizeof(*header) + s->unknown_header_fields_size;
1781     total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
1782     refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
1783
1784     *header = (QCowHeader) {
1785         /* Version 2 fields */
1786         .magic                  = cpu_to_be32(QCOW_MAGIC),
1787         .version                = cpu_to_be32(s->qcow_version),
1788         .backing_file_offset    = 0,
1789         .backing_file_size      = 0,
1790         .cluster_bits           = cpu_to_be32(s->cluster_bits),
1791         .size                   = cpu_to_be64(total_size),
1792         .crypt_method           = cpu_to_be32(s->crypt_method_header),
1793         .l1_size                = cpu_to_be32(s->l1_size),
1794         .l1_table_offset        = cpu_to_be64(s->l1_table_offset),
1795         .refcount_table_offset  = cpu_to_be64(s->refcount_table_offset),
1796         .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
1797         .nb_snapshots           = cpu_to_be32(s->nb_snapshots),
1798         .snapshots_offset       = cpu_to_be64(s->snapshots_offset),
1799
1800         /* Version 3 fields */
1801         .incompatible_features  = cpu_to_be64(s->incompatible_features),
1802         .compatible_features    = cpu_to_be64(s->compatible_features),
1803         .autoclear_features     = cpu_to_be64(s->autoclear_features),
1804         .refcount_order         = cpu_to_be32(s->refcount_order),
1805         .header_length          = cpu_to_be32(header_length),
1806     };
1807
1808     /* For older versions, write a shorter header */
1809     switch (s->qcow_version) {
1810     case 2:
1811         ret = offsetof(QCowHeader, incompatible_features);
1812         break;
1813     case 3:
1814         ret = sizeof(*header);
1815         break;
1816     default:
1817         ret = -EINVAL;
1818         goto fail;
1819     }
1820
1821     buf += ret;
1822     buflen -= ret;
1823     memset(buf, 0, buflen);
1824
1825     /* Preserve any unknown field in the header */
1826     if (s->unknown_header_fields_size) {
1827         if (buflen < s->unknown_header_fields_size) {
1828             ret = -ENOSPC;
1829             goto fail;
1830         }
1831
1832         memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
1833         buf += s->unknown_header_fields_size;
1834         buflen -= s->unknown_header_fields_size;
1835     }
1836
1837     /* Backing file format header extension */
1838     if (s->image_backing_format) {
1839         ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
1840                              s->image_backing_format,
1841                              strlen(s->image_backing_format),
1842                              buflen);
1843         if (ret < 0) {
1844             goto fail;
1845         }
1846
1847         buf += ret;
1848         buflen -= ret;
1849     }
1850
1851     /* Feature table */
1852     Qcow2Feature features[] = {
1853         {
1854             .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
1855             .bit  = QCOW2_INCOMPAT_DIRTY_BITNR,
1856             .name = "dirty bit",
1857         },
1858         {
1859             .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
1860             .bit  = QCOW2_INCOMPAT_CORRUPT_BITNR,
1861             .name = "corrupt bit",
1862         },
1863         {
1864             .type = QCOW2_FEAT_TYPE_COMPATIBLE,
1865             .bit  = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
1866             .name = "lazy refcounts",
1867         },
1868     };
1869
1870     ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
1871                          features, sizeof(features), buflen);
1872     if (ret < 0) {
1873         goto fail;
1874     }
1875     buf += ret;
1876     buflen -= ret;
1877
1878     /* Keep unknown header extensions */
1879     QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
1880         ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
1881         if (ret < 0) {
1882             goto fail;
1883         }
1884
1885         buf += ret;
1886         buflen -= ret;
1887     }
1888
1889     /* End of header extensions */
1890     ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
1891     if (ret < 0) {
1892         goto fail;
1893     }
1894
1895     buf += ret;
1896     buflen -= ret;
1897
1898     /* Backing file name */
1899     if (s->image_backing_file) {
1900         size_t backing_file_len = strlen(s->image_backing_file);
1901
1902         if (buflen < backing_file_len) {
1903             ret = -ENOSPC;
1904             goto fail;
1905         }
1906
1907         /* Using strncpy is ok here, since buf is not NUL-terminated. */
1908         strncpy(buf, s->image_backing_file, buflen);
1909
1910         header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
1911         header->backing_file_size   = cpu_to_be32(backing_file_len);
1912     }
1913
1914     /* Write the new header */
1915     ret = bdrv_pwrite(bs->file->bs, 0, header, s->cluster_size);
1916     if (ret < 0) {
1917         goto fail;
1918     }
1919
1920     ret = 0;
1921 fail:
1922     qemu_vfree(header);
1923     return ret;
1924 }
1925
1926 static int qcow2_change_backing_file(BlockDriverState *bs,
1927     const char *backing_file, const char *backing_fmt)
1928 {
1929     BDRVQcow2State *s = bs->opaque;
1930
1931     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
1932     pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
1933
1934     g_free(s->image_backing_file);
1935     g_free(s->image_backing_format);
1936
1937     s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
1938     s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
1939
1940     return qcow2_update_header(bs);
1941 }
1942
1943 static int preallocate(BlockDriverState *bs)
1944 {
1945     uint64_t nb_sectors;
1946     uint64_t offset;
1947     uint64_t host_offset = 0;
1948     int num;
1949     int ret;
1950     QCowL2Meta *meta;
1951
1952     nb_sectors = bdrv_nb_sectors(bs);
1953     offset = 0;
1954
1955     while (nb_sectors) {
1956         num = MIN(nb_sectors, INT_MAX >> BDRV_SECTOR_BITS);
1957         ret = qcow2_alloc_cluster_offset(bs, offset, &num,
1958                                          &host_offset, &meta);
1959         if (ret < 0) {
1960             return ret;
1961         }
1962
1963         while (meta) {
1964             QCowL2Meta *next = meta->next;
1965
1966             ret = qcow2_alloc_cluster_link_l2(bs, meta);
1967             if (ret < 0) {
1968                 qcow2_free_any_clusters(bs, meta->alloc_offset,
1969                                         meta->nb_clusters, QCOW2_DISCARD_NEVER);
1970                 return ret;
1971             }
1972
1973             /* There are no dependent requests, but we need to remove our
1974              * request from the list of in-flight requests */
1975             QLIST_REMOVE(meta, next_in_flight);
1976
1977             g_free(meta);
1978             meta = next;
1979         }
1980
1981         /* TODO Preallocate data if requested */
1982
1983         nb_sectors -= num;
1984         offset += num << BDRV_SECTOR_BITS;
1985     }
1986
1987     /*
1988      * It is expected that the image file is large enough to actually contain
1989      * all of the allocated clusters (otherwise we get failing reads after
1990      * EOF). Extend the image to the last allocated sector.
1991      */
1992     if (host_offset != 0) {
1993         uint8_t buf[BDRV_SECTOR_SIZE];
1994         memset(buf, 0, BDRV_SECTOR_SIZE);
1995         ret = bdrv_write(bs->file->bs,
1996                          (host_offset >> BDRV_SECTOR_BITS) + num - 1,
1997                          buf, 1);
1998         if (ret < 0) {
1999             return ret;
2000         }
2001     }
2002
2003     return 0;
2004 }
2005
2006 static int qcow2_create2(const char *filename, int64_t total_size,
2007                          const char *backing_file, const char *backing_format,
2008                          int flags, size_t cluster_size, PreallocMode prealloc,
2009                          QemuOpts *opts, int version, int refcount_order,
2010                          Error **errp)
2011 {
2012     int cluster_bits;
2013     QDict *options;
2014
2015     /* Calculate cluster_bits */
2016     cluster_bits = ctz32(cluster_size);
2017     if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
2018         (1 << cluster_bits) != cluster_size)
2019     {
2020         error_setg(errp, "Cluster size must be a power of two between %d and "
2021                    "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
2022         return -EINVAL;
2023     }
2024
2025     /*
2026      * Open the image file and write a minimal qcow2 header.
2027      *
2028      * We keep things simple and start with a zero-sized image. We also
2029      * do without refcount blocks or a L1 table for now. We'll fix the
2030      * inconsistency later.
2031      *
2032      * We do need a refcount table because growing the refcount table means
2033      * allocating two new refcount blocks - the seconds of which would be at
2034      * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
2035      * size for any qcow2 image.
2036      */
2037     BlockDriverState* bs;
2038     QCowHeader *header;
2039     uint64_t* refcount_table;
2040     Error *local_err = NULL;
2041     int ret;
2042
2043     if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
2044         /* Note: The following calculation does not need to be exact; if it is a
2045          * bit off, either some bytes will be "leaked" (which is fine) or we
2046          * will need to increase the file size by some bytes (which is fine,
2047          * too, as long as the bulk is allocated here). Therefore, using
2048          * floating point arithmetic is fine. */
2049         int64_t meta_size = 0;
2050         uint64_t nreftablee, nrefblocke, nl1e, nl2e;
2051         int64_t aligned_total_size = align_offset(total_size, cluster_size);
2052         int refblock_bits, refblock_size;
2053         /* refcount entry size in bytes */
2054         double rces = (1 << refcount_order) / 8.;
2055
2056         /* see qcow2_open() */
2057         refblock_bits = cluster_bits - (refcount_order - 3);
2058         refblock_size = 1 << refblock_bits;
2059
2060         /* header: 1 cluster */
2061         meta_size += cluster_size;
2062
2063         /* total size of L2 tables */
2064         nl2e = aligned_total_size / cluster_size;
2065         nl2e = align_offset(nl2e, cluster_size / sizeof(uint64_t));
2066         meta_size += nl2e * sizeof(uint64_t);
2067
2068         /* total size of L1 tables */
2069         nl1e = nl2e * sizeof(uint64_t) / cluster_size;
2070         nl1e = align_offset(nl1e, cluster_size / sizeof(uint64_t));
2071         meta_size += nl1e * sizeof(uint64_t);
2072
2073         /* total size of refcount blocks
2074          *
2075          * note: every host cluster is reference-counted, including metadata
2076          * (even refcount blocks are recursively included).
2077          * Let:
2078          *   a = total_size (this is the guest disk size)
2079          *   m = meta size not including refcount blocks and refcount tables
2080          *   c = cluster size
2081          *   y1 = number of refcount blocks entries
2082          *   y2 = meta size including everything
2083          *   rces = refcount entry size in bytes
2084          * then,
2085          *   y1 = (y2 + a)/c
2086          *   y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m
2087          * we can get y1:
2088          *   y1 = (a + m) / (c - rces - rces * sizeof(u64) / c)
2089          */
2090         nrefblocke = (aligned_total_size + meta_size + cluster_size)
2091                    / (cluster_size - rces - rces * sizeof(uint64_t)
2092                                                  / cluster_size);
2093         meta_size += DIV_ROUND_UP(nrefblocke, refblock_size) * cluster_size;
2094
2095         /* total size of refcount tables */
2096         nreftablee = nrefblocke / refblock_size;
2097         nreftablee = align_offset(nreftablee, cluster_size / sizeof(uint64_t));
2098         meta_size += nreftablee * sizeof(uint64_t);
2099
2100         qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
2101                             aligned_total_size + meta_size, &error_abort);
2102         qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_lookup[prealloc],
2103                      &error_abort);
2104     }
2105
2106     ret = bdrv_create_file(filename, opts, &local_err);
2107     if (ret < 0) {
2108         error_propagate(errp, local_err);
2109         return ret;
2110     }
2111
2112     bs = NULL;
2113     ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
2114                     &local_err);
2115     if (ret < 0) {
2116         error_propagate(errp, local_err);
2117         return ret;
2118     }
2119
2120     /* Write the header */
2121     QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
2122     header = g_malloc0(cluster_size);
2123     *header = (QCowHeader) {
2124         .magic                      = cpu_to_be32(QCOW_MAGIC),
2125         .version                    = cpu_to_be32(version),
2126         .cluster_bits               = cpu_to_be32(cluster_bits),
2127         .size                       = cpu_to_be64(0),
2128         .l1_table_offset            = cpu_to_be64(0),
2129         .l1_size                    = cpu_to_be32(0),
2130         .refcount_table_offset      = cpu_to_be64(cluster_size),
2131         .refcount_table_clusters    = cpu_to_be32(1),
2132         .refcount_order             = cpu_to_be32(refcount_order),
2133         .header_length              = cpu_to_be32(sizeof(*header)),
2134     };
2135
2136     if (flags & BLOCK_FLAG_ENCRYPT) {
2137         header->crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
2138     } else {
2139         header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
2140     }
2141
2142     if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) {
2143         header->compatible_features |=
2144             cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
2145     }
2146
2147     ret = bdrv_pwrite(bs, 0, header, cluster_size);
2148     g_free(header);
2149     if (ret < 0) {
2150         error_setg_errno(errp, -ret, "Could not write qcow2 header");
2151         goto out;
2152     }
2153
2154     /* Write a refcount table with one refcount block */
2155     refcount_table = g_malloc0(2 * cluster_size);
2156     refcount_table[0] = cpu_to_be64(2 * cluster_size);
2157     ret = bdrv_pwrite(bs, cluster_size, refcount_table, 2 * cluster_size);
2158     g_free(refcount_table);
2159
2160     if (ret < 0) {
2161         error_setg_errno(errp, -ret, "Could not write refcount table");
2162         goto out;
2163     }
2164
2165     bdrv_unref(bs);
2166     bs = NULL;
2167
2168     /*
2169      * And now open the image and make it consistent first (i.e. increase the
2170      * refcount of the cluster that is occupied by the header and the refcount
2171      * table)
2172      */
2173     options = qdict_new();
2174     qdict_put(options, "driver", qstring_from_str("qcow2"));
2175     ret = bdrv_open(&bs, filename, NULL, options,
2176                     BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH,
2177                     &local_err);
2178     if (ret < 0) {
2179         error_propagate(errp, local_err);
2180         goto out;
2181     }
2182
2183     ret = qcow2_alloc_clusters(bs, 3 * cluster_size);
2184     if (ret < 0) {
2185         error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
2186                          "header and refcount table");
2187         goto out;
2188
2189     } else if (ret != 0) {
2190         error_report("Huh, first cluster in empty image is already in use?");
2191         abort();
2192     }
2193
2194     /* Okay, now that we have a valid image, let's give it the right size */
2195     ret = bdrv_truncate(bs, total_size);
2196     if (ret < 0) {
2197         error_setg_errno(errp, -ret, "Could not resize image");
2198         goto out;
2199     }
2200
2201     /* Want a backing file? There you go.*/
2202     if (backing_file) {
2203         ret = bdrv_change_backing_file(bs, backing_file, backing_format);
2204         if (ret < 0) {
2205             error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
2206                              "with format '%s'", backing_file, backing_format);
2207             goto out;
2208         }
2209     }
2210
2211     /* And if we're supposed to preallocate metadata, do that now */
2212     if (prealloc != PREALLOC_MODE_OFF) {
2213         BDRVQcow2State *s = bs->opaque;
2214         qemu_co_mutex_lock(&s->lock);
2215         ret = preallocate(bs);
2216         qemu_co_mutex_unlock(&s->lock);
2217         if (ret < 0) {
2218             error_setg_errno(errp, -ret, "Could not preallocate metadata");
2219             goto out;
2220         }
2221     }
2222
2223     bdrv_unref(bs);
2224     bs = NULL;
2225
2226     /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
2227     options = qdict_new();
2228     qdict_put(options, "driver", qstring_from_str("qcow2"));
2229     ret = bdrv_open(&bs, filename, NULL, options,
2230                     BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_BACKING,
2231                     &local_err);
2232     if (local_err) {
2233         error_propagate(errp, local_err);
2234         goto out;
2235     }
2236
2237     ret = 0;
2238 out:
2239     if (bs) {
2240         bdrv_unref(bs);
2241     }
2242     return ret;
2243 }
2244
2245 static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
2246 {
2247     char *backing_file = NULL;
2248     char *backing_fmt = NULL;
2249     char *buf = NULL;
2250     uint64_t size = 0;
2251     int flags = 0;
2252     size_t cluster_size = DEFAULT_CLUSTER_SIZE;
2253     PreallocMode prealloc;
2254     int version = 3;
2255     uint64_t refcount_bits = 16;
2256     int refcount_order;
2257     Error *local_err = NULL;
2258     int ret;
2259
2260     /* Read out options */
2261     size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2262                     BDRV_SECTOR_SIZE);
2263     backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
2264     backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT);
2265     if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
2266         flags |= BLOCK_FLAG_ENCRYPT;
2267     }
2268     cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
2269                                          DEFAULT_CLUSTER_SIZE);
2270     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2271     prealloc = qapi_enum_parse(PreallocMode_lookup, buf,
2272                                PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,
2273                                &local_err);
2274     if (local_err) {
2275         error_propagate(errp, local_err);
2276         ret = -EINVAL;
2277         goto finish;
2278     }
2279     g_free(buf);
2280     buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
2281     if (!buf) {
2282         /* keep the default */
2283     } else if (!strcmp(buf, "0.10")) {
2284         version = 2;
2285     } else if (!strcmp(buf, "1.1")) {
2286         version = 3;
2287     } else {
2288         error_setg(errp, "Invalid compatibility level: '%s'", buf);
2289         ret = -EINVAL;
2290         goto finish;
2291     }
2292
2293     if (qemu_opt_get_bool_del(opts, BLOCK_OPT_LAZY_REFCOUNTS, false)) {
2294         flags |= BLOCK_FLAG_LAZY_REFCOUNTS;
2295     }
2296
2297     if (backing_file && prealloc != PREALLOC_MODE_OFF) {
2298         error_setg(errp, "Backing file and preallocation cannot be used at "
2299                    "the same time");
2300         ret = -EINVAL;
2301         goto finish;
2302     }
2303
2304     if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) {
2305         error_setg(errp, "Lazy refcounts only supported with compatibility "
2306                    "level 1.1 and above (use compat=1.1 or greater)");
2307         ret = -EINVAL;
2308         goto finish;
2309     }
2310
2311     refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS,
2312                                             refcount_bits);
2313     if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
2314         error_setg(errp, "Refcount width must be a power of two and may not "
2315                    "exceed 64 bits");
2316         ret = -EINVAL;
2317         goto finish;
2318     }
2319
2320     if (version < 3 && refcount_bits != 16) {
2321         error_setg(errp, "Different refcount widths than 16 bits require "
2322                    "compatibility level 1.1 or above (use compat=1.1 or "
2323                    "greater)");
2324         ret = -EINVAL;
2325         goto finish;
2326     }
2327
2328     refcount_order = ctz32(refcount_bits);
2329
2330     ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags,
2331                         cluster_size, prealloc, opts, version, refcount_order,
2332                         &local_err);
2333     if (local_err) {
2334         error_propagate(errp, local_err);
2335     }
2336
2337 finish:
2338     g_free(backing_file);
2339     g_free(backing_fmt);
2340     g_free(buf);
2341     return ret;
2342 }
2343
2344 static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs,
2345     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
2346 {
2347     int ret;
2348     BDRVQcow2State *s = bs->opaque;
2349
2350     /* Emulate misaligned zero writes */
2351     if (sector_num % s->cluster_sectors || nb_sectors % s->cluster_sectors) {
2352         return -ENOTSUP;
2353     }
2354
2355     /* Whatever is left can use real zero clusters */
2356     qemu_co_mutex_lock(&s->lock);
2357     ret = qcow2_zero_clusters(bs, sector_num << BDRV_SECTOR_BITS,
2358         nb_sectors);
2359     qemu_co_mutex_unlock(&s->lock);
2360
2361     return ret;
2362 }
2363
2364 static coroutine_fn int qcow2_co_discard(BlockDriverState *bs,
2365     int64_t sector_num, int nb_sectors)
2366 {
2367     int ret;
2368     BDRVQcow2State *s = bs->opaque;
2369
2370     qemu_co_mutex_lock(&s->lock);
2371     ret = qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS,
2372         nb_sectors, QCOW2_DISCARD_REQUEST, false);
2373     qemu_co_mutex_unlock(&s->lock);
2374     return ret;
2375 }
2376
2377 static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
2378 {
2379     BDRVQcow2State *s = bs->opaque;
2380     int64_t new_l1_size;
2381     int ret;
2382
2383     if (offset & 511) {
2384         error_report("The new size must be a multiple of 512");
2385         return -EINVAL;
2386     }
2387
2388     /* cannot proceed if image has snapshots */
2389     if (s->nb_snapshots) {
2390         error_report("Can't resize an image which has snapshots");
2391         return -ENOTSUP;
2392     }
2393
2394     /* shrinking is currently not supported */
2395     if (offset < bs->total_sectors * 512) {
2396         error_report("qcow2 doesn't support shrinking images yet");
2397         return -ENOTSUP;
2398     }
2399
2400     new_l1_size = size_to_l1(s, offset);
2401     ret = qcow2_grow_l1_table(bs, new_l1_size, true);
2402     if (ret < 0) {
2403         return ret;
2404     }
2405
2406     /* write updated header.size */
2407     offset = cpu_to_be64(offset);
2408     ret = bdrv_pwrite_sync(bs->file->bs, offsetof(QCowHeader, size),
2409                            &offset, sizeof(uint64_t));
2410     if (ret < 0) {
2411         return ret;
2412     }
2413
2414     s->l1_vm_state_index = new_l1_size;
2415     return 0;
2416 }
2417
2418 /* XXX: put compressed sectors first, then all the cluster aligned
2419    tables to avoid losing bytes in alignment */
2420 static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
2421                                   const uint8_t *buf, int nb_sectors)
2422 {
2423     BDRVQcow2State *s = bs->opaque;
2424     z_stream strm;
2425     int ret, out_len;
2426     uint8_t *out_buf;
2427     uint64_t cluster_offset;
2428
2429     if (nb_sectors == 0) {
2430         /* align end of file to a sector boundary to ease reading with
2431            sector based I/Os */
2432         cluster_offset = bdrv_getlength(bs->file->bs);
2433         return bdrv_truncate(bs->file->bs, cluster_offset);
2434     }
2435
2436     if (nb_sectors != s->cluster_sectors) {
2437         ret = -EINVAL;
2438
2439         /* Zero-pad last write if image size is not cluster aligned */
2440         if (sector_num + nb_sectors == bs->total_sectors &&
2441             nb_sectors < s->cluster_sectors) {
2442             uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size);
2443             memset(pad_buf, 0, s->cluster_size);
2444             memcpy(pad_buf, buf, nb_sectors * BDRV_SECTOR_SIZE);
2445             ret = qcow2_write_compressed(bs, sector_num,
2446                                          pad_buf, s->cluster_sectors);
2447             qemu_vfree(pad_buf);
2448         }
2449         return ret;
2450     }
2451
2452     out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
2453
2454     /* best compression, small window, no zlib header */
2455     memset(&strm, 0, sizeof(strm));
2456     ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
2457                        Z_DEFLATED, -12,
2458                        9, Z_DEFAULT_STRATEGY);
2459     if (ret != 0) {
2460         ret = -EINVAL;
2461         goto fail;
2462     }
2463
2464     strm.avail_in = s->cluster_size;
2465     strm.next_in = (uint8_t *)buf;
2466     strm.avail_out = s->cluster_size;
2467     strm.next_out = out_buf;
2468
2469     ret = deflate(&strm, Z_FINISH);
2470     if (ret != Z_STREAM_END && ret != Z_OK) {
2471         deflateEnd(&strm);
2472         ret = -EINVAL;
2473         goto fail;
2474     }
2475     out_len = strm.next_out - out_buf;
2476
2477     deflateEnd(&strm);
2478
2479     if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
2480         /* could not compress: write normal cluster */
2481         ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
2482         if (ret < 0) {
2483             goto fail;
2484         }
2485     } else {
2486         cluster_offset = qcow2_alloc_compressed_cluster_offset(bs,
2487             sector_num << 9, out_len);
2488         if (!cluster_offset) {
2489             ret = -EIO;
2490             goto fail;
2491         }
2492         cluster_offset &= s->cluster_offset_mask;
2493
2494         ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len);
2495         if (ret < 0) {
2496             goto fail;
2497         }
2498
2499         BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
2500         ret = bdrv_pwrite(bs->file->bs, cluster_offset, out_buf, out_len);
2501         if (ret < 0) {
2502             goto fail;
2503         }
2504     }
2505
2506     ret = 0;
2507 fail:
2508     g_free(out_buf);
2509     return ret;
2510 }
2511
2512 static int make_completely_empty(BlockDriverState *bs)
2513 {
2514     BDRVQcow2State *s = bs->opaque;
2515     int ret, l1_clusters;
2516     int64_t offset;
2517     uint64_t *new_reftable = NULL;
2518     uint64_t rt_entry, l1_size2;
2519     struct {
2520         uint64_t l1_offset;
2521         uint64_t reftable_offset;
2522         uint32_t reftable_clusters;
2523     } QEMU_PACKED l1_ofs_rt_ofs_cls;
2524
2525     ret = qcow2_cache_empty(bs, s->l2_table_cache);
2526     if (ret < 0) {
2527         goto fail;
2528     }
2529
2530     ret = qcow2_cache_empty(bs, s->refcount_block_cache);
2531     if (ret < 0) {
2532         goto fail;
2533     }
2534
2535     /* Refcounts will be broken utterly */
2536     ret = qcow2_mark_dirty(bs);
2537     if (ret < 0) {
2538         goto fail;
2539     }
2540
2541     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
2542
2543     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
2544     l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t);
2545
2546     /* After this call, neither the in-memory nor the on-disk refcount
2547      * information accurately describe the actual references */
2548
2549     ret = bdrv_write_zeroes(bs->file->bs, s->l1_table_offset / BDRV_SECTOR_SIZE,
2550                             l1_clusters * s->cluster_sectors, 0);
2551     if (ret < 0) {
2552         goto fail_broken_refcounts;
2553     }
2554     memset(s->l1_table, 0, l1_size2);
2555
2556     BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);
2557
2558     /* Overwrite enough clusters at the beginning of the sectors to place
2559      * the refcount table, a refcount block and the L1 table in; this may
2560      * overwrite parts of the existing refcount and L1 table, which is not
2561      * an issue because the dirty flag is set, complete data loss is in fact
2562      * desired and partial data loss is consequently fine as well */
2563     ret = bdrv_write_zeroes(bs->file->bs, s->cluster_size / BDRV_SECTOR_SIZE,
2564                             (2 + l1_clusters) * s->cluster_size /
2565                             BDRV_SECTOR_SIZE, 0);
2566     /* This call (even if it failed overall) may have overwritten on-disk
2567      * refcount structures; in that case, the in-memory refcount information
2568      * will probably differ from the on-disk information which makes the BDS
2569      * unusable */
2570     if (ret < 0) {
2571         goto fail_broken_refcounts;
2572     }
2573
2574     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
2575     BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);
2576
2577     /* "Create" an empty reftable (one cluster) directly after the image
2578      * header and an empty L1 table three clusters after the image header;
2579      * the cluster between those two will be used as the first refblock */
2580     cpu_to_be64w(&l1_ofs_rt_ofs_cls.l1_offset, 3 * s->cluster_size);
2581     cpu_to_be64w(&l1_ofs_rt_ofs_cls.reftable_offset, s->cluster_size);
2582     cpu_to_be32w(&l1_ofs_rt_ofs_cls.reftable_clusters, 1);
2583     ret = bdrv_pwrite_sync(bs->file->bs, offsetof(QCowHeader, l1_table_offset),
2584                            &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
2585     if (ret < 0) {
2586         goto fail_broken_refcounts;
2587     }
2588
2589     s->l1_table_offset = 3 * s->cluster_size;
2590
2591     new_reftable = g_try_new0(uint64_t, s->cluster_size / sizeof(uint64_t));
2592     if (!new_reftable) {
2593         ret = -ENOMEM;
2594         goto fail_broken_refcounts;
2595     }
2596
2597     s->refcount_table_offset = s->cluster_size;
2598     s->refcount_table_size   = s->cluster_size / sizeof(uint64_t);
2599
2600     g_free(s->refcount_table);
2601     s->refcount_table = new_reftable;
2602     new_reftable = NULL;
2603
2604     /* Now the in-memory refcount information again corresponds to the on-disk
2605      * information (reftable is empty and no refblocks (the refblock cache is
2606      * empty)); however, this means some clusters (e.g. the image header) are
2607      * referenced, but not refcounted, but the normal qcow2 code assumes that
2608      * the in-memory information is always correct */
2609
2610     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
2611
2612     /* Enter the first refblock into the reftable */
2613     rt_entry = cpu_to_be64(2 * s->cluster_size);
2614     ret = bdrv_pwrite_sync(bs->file->bs, s->cluster_size,
2615                            &rt_entry, sizeof(rt_entry));
2616     if (ret < 0) {
2617         goto fail_broken_refcounts;
2618     }
2619     s->refcount_table[0] = 2 * s->cluster_size;
2620
2621     s->free_cluster_index = 0;
2622     assert(3 + l1_clusters <= s->refcount_block_size);
2623     offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2);
2624     if (offset < 0) {
2625         ret = offset;
2626         goto fail_broken_refcounts;
2627     } else if (offset > 0) {
2628         error_report("First cluster in emptied image is in use");
2629         abort();
2630     }
2631
2632     /* Now finally the in-memory information corresponds to the on-disk
2633      * structures and is correct */
2634     ret = qcow2_mark_clean(bs);
2635     if (ret < 0) {
2636         goto fail;
2637     }
2638
2639     ret = bdrv_truncate(bs->file->bs, (3 + l1_clusters) * s->cluster_size);
2640     if (ret < 0) {
2641         goto fail;
2642     }
2643
2644     return 0;
2645
2646 fail_broken_refcounts:
2647     /* The BDS is unusable at this point. If we wanted to make it usable, we
2648      * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
2649      * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
2650      * again. However, because the functions which could have caused this error
2651      * path to be taken are used by those functions as well, it's very likely
2652      * that that sequence will fail as well. Therefore, just eject the BDS. */
2653     bs->drv = NULL;
2654
2655 fail:
2656     g_free(new_reftable);
2657     return ret;
2658 }
2659
2660 static int qcow2_make_empty(BlockDriverState *bs)
2661 {
2662     BDRVQcow2State *s = bs->opaque;
2663     uint64_t start_sector;
2664     int sector_step = INT_MAX / BDRV_SECTOR_SIZE;
2665     int l1_clusters, ret = 0;
2666
2667     l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
2668
2669     if (s->qcow_version >= 3 && !s->snapshots &&
2670         3 + l1_clusters <= s->refcount_block_size) {
2671         /* The following function only works for qcow2 v3 images (it requires
2672          * the dirty flag) and only as long as there are no snapshots (because
2673          * it completely empties the image). Furthermore, the L1 table and three
2674          * additional clusters (image header, refcount table, one refcount
2675          * block) have to fit inside one refcount block. */
2676         return make_completely_empty(bs);
2677     }
2678
2679     /* This fallback code simply discards every active cluster; this is slow,
2680      * but works in all cases */
2681     for (start_sector = 0; start_sector < bs->total_sectors;
2682          start_sector += sector_step)
2683     {
2684         /* As this function is generally used after committing an external
2685          * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
2686          * default action for this kind of discard is to pass the discard,
2687          * which will ideally result in an actually smaller image file, as
2688          * is probably desired. */
2689         ret = qcow2_discard_clusters(bs, start_sector * BDRV_SECTOR_SIZE,
2690                                      MIN(sector_step,
2691                                          bs->total_sectors - start_sector),
2692                                      QCOW2_DISCARD_SNAPSHOT, true);
2693         if (ret < 0) {
2694             break;
2695         }
2696     }
2697
2698     return ret;
2699 }
2700
2701 static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
2702 {
2703     BDRVQcow2State *s = bs->opaque;
2704     int ret;
2705
2706     qemu_co_mutex_lock(&s->lock);
2707     ret = qcow2_cache_flush(bs, s->l2_table_cache);
2708     if (ret < 0) {
2709         qemu_co_mutex_unlock(&s->lock);
2710         return ret;
2711     }
2712
2713     if (qcow2_need_accurate_refcounts(s)) {
2714         ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2715         if (ret < 0) {
2716             qemu_co_mutex_unlock(&s->lock);
2717             return ret;
2718         }
2719     }
2720     qemu_co_mutex_unlock(&s->lock);
2721
2722     return 0;
2723 }
2724
2725 static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2726 {
2727     BDRVQcow2State *s = bs->opaque;
2728     bdi->unallocated_blocks_are_zero = true;
2729     bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3);
2730     bdi->cluster_size = s->cluster_size;
2731     bdi->vm_state_offset = qcow2_vm_state_offset(s);
2732     return 0;
2733 }
2734
2735 static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
2736 {
2737     BDRVQcow2State *s = bs->opaque;
2738     ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
2739
2740     *spec_info = (ImageInfoSpecific){
2741         .type  = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
2742         .u.qcow2 = g_new(ImageInfoSpecificQCow2, 1),
2743     };
2744     if (s->qcow_version == 2) {
2745         *spec_info->u.qcow2 = (ImageInfoSpecificQCow2){
2746             .compat             = g_strdup("0.10"),
2747             .refcount_bits      = s->refcount_bits,
2748         };
2749     } else if (s->qcow_version == 3) {
2750         *spec_info->u.qcow2 = (ImageInfoSpecificQCow2){
2751             .compat             = g_strdup("1.1"),
2752             .lazy_refcounts     = s->compatible_features &
2753                                   QCOW2_COMPAT_LAZY_REFCOUNTS,
2754             .has_lazy_refcounts = true,
2755             .corrupt            = s->incompatible_features &
2756                                   QCOW2_INCOMPAT_CORRUPT,
2757             .has_corrupt        = true,
2758             .refcount_bits      = s->refcount_bits,
2759         };
2760     }
2761
2762     return spec_info;
2763 }
2764
2765 #if 0
2766 static void dump_refcounts(BlockDriverState *bs)
2767 {
2768     BDRVQcow2State *s = bs->opaque;
2769     int64_t nb_clusters, k, k1, size;
2770     int refcount;
2771
2772     size = bdrv_getlength(bs->file->bs);
2773     nb_clusters = size_to_clusters(s, size);
2774     for(k = 0; k < nb_clusters;) {
2775         k1 = k;
2776         refcount = get_refcount(bs, k);
2777         k++;
2778         while (k < nb_clusters && get_refcount(bs, k) == refcount)
2779             k++;
2780         printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount,
2781                k - k1);
2782     }
2783 }
2784 #endif
2785
2786 static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2787                               int64_t pos)
2788 {
2789     BDRVQcow2State *s = bs->opaque;
2790     int64_t total_sectors = bs->total_sectors;
2791     bool zero_beyond_eof = bs->zero_beyond_eof;
2792     int ret;
2793
2794     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
2795     bs->zero_beyond_eof = false;
2796     ret = bdrv_pwritev(bs, qcow2_vm_state_offset(s) + pos, qiov);
2797     bs->zero_beyond_eof = zero_beyond_eof;
2798
2799     /* bdrv_co_do_writev will have increased the total_sectors value to include
2800      * the VM state - the VM state is however not an actual part of the block
2801      * device, therefore, we need to restore the old value. */
2802     bs->total_sectors = total_sectors;
2803
2804     return ret;
2805 }
2806
2807 static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
2808                               int64_t pos, int size)
2809 {
2810     BDRVQcow2State *s = bs->opaque;
2811     bool zero_beyond_eof = bs->zero_beyond_eof;
2812     int ret;
2813
2814     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
2815     bs->zero_beyond_eof = false;
2816     ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size);
2817     bs->zero_beyond_eof = zero_beyond_eof;
2818
2819     return ret;
2820 }
2821
2822 /*
2823  * Downgrades an image's version. To achieve this, any incompatible features
2824  * have to be removed.
2825  */
2826 static int qcow2_downgrade(BlockDriverState *bs, int target_version,
2827                            BlockDriverAmendStatusCB *status_cb)
2828 {
2829     BDRVQcow2State *s = bs->opaque;
2830     int current_version = s->qcow_version;
2831     int ret;
2832
2833     if (target_version == current_version) {
2834         return 0;
2835     } else if (target_version > current_version) {
2836         return -EINVAL;
2837     } else if (target_version != 2) {
2838         return -EINVAL;
2839     }
2840
2841     if (s->refcount_order != 4) {
2842         /* we would have to convert the image to a refcount_order == 4 image
2843          * here; however, since qemu (at the time of writing this) does not
2844          * support anything different than 4 anyway, there is no point in doing
2845          * so right now; however, we should error out (if qemu supports this in
2846          * the future and this code has not been adapted) */
2847         error_report("qcow2_downgrade: Image refcount orders other than 4 are "
2848                      "currently not supported.");
2849         return -ENOTSUP;
2850     }
2851
2852     /* clear incompatible features */
2853     if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
2854         ret = qcow2_mark_clean(bs);
2855         if (ret < 0) {
2856             return ret;
2857         }
2858     }
2859
2860     /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
2861      * the first place; if that happens nonetheless, returning -ENOTSUP is the
2862      * best thing to do anyway */
2863
2864     if (s->incompatible_features) {
2865         return -ENOTSUP;
2866     }
2867
2868     /* since we can ignore compatible features, we can set them to 0 as well */
2869     s->compatible_features = 0;
2870     /* if lazy refcounts have been used, they have already been fixed through
2871      * clearing the dirty flag */
2872
2873     /* clearing autoclear features is trivial */
2874     s->autoclear_features = 0;
2875
2876     ret = qcow2_expand_zero_clusters(bs, status_cb);
2877     if (ret < 0) {
2878         return ret;
2879     }
2880
2881     s->qcow_version = target_version;
2882     ret = qcow2_update_header(bs);
2883     if (ret < 0) {
2884         s->qcow_version = current_version;
2885         return ret;
2886     }
2887     return 0;
2888 }
2889
2890 static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
2891                                BlockDriverAmendStatusCB *status_cb)
2892 {
2893     BDRVQcow2State *s = bs->opaque;
2894     int old_version = s->qcow_version, new_version = old_version;
2895     uint64_t new_size = 0;
2896     const char *backing_file = NULL, *backing_format = NULL;
2897     bool lazy_refcounts = s->use_lazy_refcounts;
2898     const char *compat = NULL;
2899     uint64_t cluster_size = s->cluster_size;
2900     bool encrypt;
2901     int ret;
2902     QemuOptDesc *desc = opts->list->desc;
2903
2904     while (desc && desc->name) {
2905         if (!qemu_opt_find(opts, desc->name)) {
2906             /* only change explicitly defined options */
2907             desc++;
2908             continue;
2909         }
2910
2911         if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
2912             compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
2913             if (!compat) {
2914                 /* preserve default */
2915             } else if (!strcmp(compat, "0.10")) {
2916                 new_version = 2;
2917             } else if (!strcmp(compat, "1.1")) {
2918                 new_version = 3;
2919             } else {
2920                 fprintf(stderr, "Unknown compatibility level %s.\n", compat);
2921                 return -EINVAL;
2922             }
2923         } else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) {
2924             fprintf(stderr, "Cannot change preallocation mode.\n");
2925             return -ENOTSUP;
2926         } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) {
2927             new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
2928         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) {
2929             backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
2930         } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) {
2931             backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
2932         } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) {
2933             encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT,
2934                                         !!s->cipher);
2935
2936             if (encrypt != !!s->cipher) {
2937                 fprintf(stderr, "Changing the encryption flag is not "
2938                         "supported.\n");
2939                 return -ENOTSUP;
2940             }
2941         } else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) {
2942             cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE,
2943                                              cluster_size);
2944             if (cluster_size != s->cluster_size) {
2945                 fprintf(stderr, "Changing the cluster size is not "
2946                         "supported.\n");
2947                 return -ENOTSUP;
2948             }
2949         } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
2950             lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
2951                                                lazy_refcounts);
2952         } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
2953             error_report("Cannot change refcount entry width");
2954             return -ENOTSUP;
2955         } else {
2956             /* if this assertion fails, this probably means a new option was
2957              * added without having it covered here */
2958             assert(false);
2959         }
2960
2961         desc++;
2962     }
2963
2964     if (new_version != old_version) {
2965         if (new_version > old_version) {
2966             /* Upgrade */
2967             s->qcow_version = new_version;
2968             ret = qcow2_update_header(bs);
2969             if (ret < 0) {
2970                 s->qcow_version = old_version;
2971                 return ret;
2972             }
2973         } else {
2974             ret = qcow2_downgrade(bs, new_version, status_cb);
2975             if (ret < 0) {
2976                 return ret;
2977             }
2978         }
2979     }
2980
2981     if (backing_file || backing_format) {
2982         ret = qcow2_change_backing_file(bs,
2983                     backing_file ?: s->image_backing_file,
2984                     backing_format ?: s->image_backing_format);
2985         if (ret < 0) {
2986             return ret;
2987         }
2988     }
2989
2990     if (s->use_lazy_refcounts != lazy_refcounts) {
2991         if (lazy_refcounts) {
2992             if (s->qcow_version < 3) {
2993                 fprintf(stderr, "Lazy refcounts only supported with compatibility "
2994                         "level 1.1 and above (use compat=1.1 or greater)\n");
2995                 return -EINVAL;
2996             }
2997             s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
2998             ret = qcow2_update_header(bs);
2999             if (ret < 0) {
3000                 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
3001                 return ret;
3002             }
3003             s->use_lazy_refcounts = true;
3004         } else {
3005             /* make image clean first */
3006             ret = qcow2_mark_clean(bs);
3007             if (ret < 0) {
3008                 return ret;
3009             }
3010             /* now disallow lazy refcounts */
3011             s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
3012             ret = qcow2_update_header(bs);
3013             if (ret < 0) {
3014                 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
3015                 return ret;
3016             }
3017             s->use_lazy_refcounts = false;
3018         }
3019     }
3020
3021     if (new_size) {
3022         ret = bdrv_truncate(bs, new_size);
3023         if (ret < 0) {
3024             return ret;
3025         }
3026     }
3027
3028     return 0;
3029 }
3030
3031 /*
3032  * If offset or size are negative, respectively, they will not be included in
3033  * the BLOCK_IMAGE_CORRUPTED event emitted.
3034  * fatal will be ignored for read-only BDS; corruptions found there will always
3035  * be considered non-fatal.
3036  */
3037 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
3038                              int64_t size, const char *message_format, ...)
3039 {
3040     BDRVQcow2State *s = bs->opaque;
3041     const char *node_name;
3042     char *message;
3043     va_list ap;
3044
3045     fatal = fatal && !bs->read_only;
3046
3047     if (s->signaled_corruption &&
3048         (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT)))
3049     {
3050         return;
3051     }
3052
3053     va_start(ap, message_format);
3054     message = g_strdup_vprintf(message_format, ap);
3055     va_end(ap);
3056
3057     if (fatal) {
3058         fprintf(stderr, "qcow2: Marking image as corrupt: %s; further "
3059                 "corruption events will be suppressed\n", message);
3060     } else {
3061         fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal "
3062                 "corruption events will be suppressed\n", message);
3063     }
3064
3065     node_name = bdrv_get_node_name(bs);
3066     qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
3067                                           *node_name != '\0', node_name,
3068                                           message, offset >= 0, offset,
3069                                           size >= 0, size,
3070                                           fatal, &error_abort);
3071     g_free(message);
3072
3073     if (fatal) {
3074         qcow2_mark_corrupt(bs);
3075         bs->drv = NULL; /* make BDS unusable */
3076     }
3077
3078     s->signaled_corruption = true;
3079 }
3080
3081 static QemuOptsList qcow2_create_opts = {
3082     .name = "qcow2-create-opts",
3083     .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
3084     .desc = {
3085         {
3086             .name = BLOCK_OPT_SIZE,
3087             .type = QEMU_OPT_SIZE,
3088             .help = "Virtual disk size"
3089         },
3090         {
3091             .name = BLOCK_OPT_COMPAT_LEVEL,
3092             .type = QEMU_OPT_STRING,
3093             .help = "Compatibility level (0.10 or 1.1)"
3094         },
3095         {
3096             .name = BLOCK_OPT_BACKING_FILE,
3097             .type = QEMU_OPT_STRING,
3098             .help = "File name of a base image"
3099         },
3100         {
3101             .name = BLOCK_OPT_BACKING_FMT,
3102             .type = QEMU_OPT_STRING,
3103             .help = "Image format of the base image"
3104         },
3105         {
3106             .name = BLOCK_OPT_ENCRYPT,
3107             .type = QEMU_OPT_BOOL,
3108             .help = "Encrypt the image",
3109             .def_value_str = "off"
3110         },
3111         {
3112             .name = BLOCK_OPT_CLUSTER_SIZE,
3113             .type = QEMU_OPT_SIZE,
3114             .help = "qcow2 cluster size",
3115             .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
3116         },
3117         {
3118             .name = BLOCK_OPT_PREALLOC,
3119             .type = QEMU_OPT_STRING,
3120             .help = "Preallocation mode (allowed values: off, metadata, "
3121                     "falloc, full)"
3122         },
3123         {
3124             .name = BLOCK_OPT_LAZY_REFCOUNTS,
3125             .type = QEMU_OPT_BOOL,
3126             .help = "Postpone refcount updates",
3127             .def_value_str = "off"
3128         },
3129         {
3130             .name = BLOCK_OPT_REFCOUNT_BITS,
3131             .type = QEMU_OPT_NUMBER,
3132             .help = "Width of a reference count entry in bits",
3133             .def_value_str = "16"
3134         },
3135         { /* end of list */ }
3136     }
3137 };
3138
3139 BlockDriver bdrv_qcow2 = {
3140     .format_name        = "qcow2",
3141     .instance_size      = sizeof(BDRVQcow2State),
3142     .bdrv_probe         = qcow2_probe,
3143     .bdrv_open          = qcow2_open,
3144     .bdrv_close         = qcow2_close,
3145     .bdrv_reopen_prepare  = qcow2_reopen_prepare,
3146     .bdrv_reopen_commit   = qcow2_reopen_commit,
3147     .bdrv_reopen_abort    = qcow2_reopen_abort,
3148     .bdrv_create        = qcow2_create,
3149     .bdrv_has_zero_init = bdrv_has_zero_init_1,
3150     .bdrv_co_get_block_status = qcow2_co_get_block_status,
3151     .bdrv_set_key       = qcow2_set_key,
3152
3153     .bdrv_co_readv          = qcow2_co_readv,
3154     .bdrv_co_writev         = qcow2_co_writev,
3155     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
3156
3157     .bdrv_co_write_zeroes   = qcow2_co_write_zeroes,
3158     .bdrv_co_discard        = qcow2_co_discard,
3159     .bdrv_truncate          = qcow2_truncate,
3160     .bdrv_write_compressed  = qcow2_write_compressed,
3161     .bdrv_make_empty        = qcow2_make_empty,
3162
3163     .bdrv_snapshot_create   = qcow2_snapshot_create,
3164     .bdrv_snapshot_goto     = qcow2_snapshot_goto,
3165     .bdrv_snapshot_delete   = qcow2_snapshot_delete,
3166     .bdrv_snapshot_list     = qcow2_snapshot_list,
3167     .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
3168     .bdrv_get_info          = qcow2_get_info,
3169     .bdrv_get_specific_info = qcow2_get_specific_info,
3170
3171     .bdrv_save_vmstate    = qcow2_save_vmstate,
3172     .bdrv_load_vmstate    = qcow2_load_vmstate,
3173
3174     .supports_backing           = true,
3175     .bdrv_change_backing_file   = qcow2_change_backing_file,
3176
3177     .bdrv_refresh_limits        = qcow2_refresh_limits,
3178     .bdrv_invalidate_cache      = qcow2_invalidate_cache,
3179
3180     .create_opts         = &qcow2_create_opts,
3181     .bdrv_check          = qcow2_check,
3182     .bdrv_amend_options  = qcow2_amend_options,
3183
3184     .bdrv_detach_aio_context  = qcow2_detach_aio_context,
3185     .bdrv_attach_aio_context  = qcow2_attach_aio_context,
3186 };
3187
3188 static void bdrv_qcow2_init(void)
3189 {
3190     bdrv_register(&bdrv_qcow2);
3191 }
3192
3193 block_init(bdrv_qcow2_init);