qcow2.c 94.4 KB
Newer Older
B
bellard 已提交
1 2
/*
 * Block driver for the QCOW version 2 format
3
 *
B
bellard 已提交
4
 * Copyright (c) 2004-2006 Fabrice Bellard
5
 *
B
bellard 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
P
pbrook 已提交
24
#include "qemu-common.h"
25
#include "block/block_int.h"
26
#include "qemu/module.h"
B
bellard 已提交
27
#include <zlib.h>
28
#include "qemu/aes.h"
K
Kevin Wolf 已提交
29
#include "block/qcow2.h"
30
#include "qemu/error-report.h"
31
#include "qapi/qmp/qerror.h"
32
#include "qapi/qmp/qbool.h"
33
#include "qapi/util.h"
M
Max Reitz 已提交
34 35
#include "qapi/qmp/types.h"
#include "qapi-event.h"
K
Kevin Wolf 已提交
36
#include "trace.h"
37
#include "qemu/option_int.h"
B
bellard 已提交
38 39 40 41 42 43 44 45

/*
  Differences with QCOW:

  - Support for multiple incremental snapshots.
  - Memory management by reference counts.
  - Clusters which have a reference count of one have the bit
    QCOW_OFLAG_COPIED to optimize write performance.
46
  - Size of compressed clusters is stored in sectors to reduce bit usage
B
bellard 已提交
47 48
    in the cluster offsets.
  - Support for storing additional data (such as the VM state) in the
49
    snapshots.
B
bellard 已提交
50 51 52 53 54
  - If a backing store is used, the cluster size is not constrained
    (could be backported to QCOW).
  - L2 tables have always a size of one cluster.
*/

55 56 57 58

typedef struct {
    uint32_t magic;
    uint32_t len;
59
} QEMU_PACKED QCowExtension;
J
Jeff Cody 已提交
60

61 62
#define  QCOW2_EXT_MAGIC_END 0
#define  QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
63
#define  QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
64

65
static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
B
bellard 已提交
66 67
{
    const QCowHeader *cow_header = (const void *)buf;
68

B
bellard 已提交
69 70
    if (buf_size >= sizeof(QCowHeader) &&
        be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
K
Kevin Wolf 已提交
71
        be32_to_cpu(cow_header->version) >= 2)
B
bellard 已提交
72 73 74 75 76
        return 100;
    else
        return 0;
}

77 78 79 80 81 82 83 84

/* 
 * read qcow2 extension and fill bs
 * start reading from start_offset
 * finish reading upon magic of value 0 or when end_offset reached
 * unknown magic is skipped (future extension this version knows nothing about)
 * return 0 upon success, non-0 otherwise
 */
85
static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
M
Max Reitz 已提交
86 87
                                 uint64_t end_offset, void **p_feature_table,
                                 Error **errp)
88
{
89
    BDRVQcowState *s = bs->opaque;
90 91
    QCowExtension ext;
    uint64_t offset;
92
    int ret;
93 94

#ifdef DEBUG_EXT
95
    printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
96 97 98 99 100 101 102
#endif
    offset = start_offset;
    while (offset < end_offset) {

#ifdef DEBUG_EXT
        /* Sanity check */
        if (offset > s->cluster_size)
103
            printf("qcow2_read_extension: suspicious offset %lu\n", offset);
104

D
Dong Xu Wang 已提交
105
        printf("attempting to read extended header in offset %lu\n", offset);
106 107
#endif

M
Max Reitz 已提交
108 109 110 111
        ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext));
        if (ret < 0) {
            error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
                             "pread fail from offset %" PRIu64, offset);
112 113 114 115 116 117 118 119
            return 1;
        }
        be32_to_cpus(&ext.magic);
        be32_to_cpus(&ext.len);
        offset += sizeof(ext);
#ifdef DEBUG_EXT
        printf("ext.magic = 0x%x\n", ext.magic);
#endif
120
        if (offset > end_offset || ext.len > end_offset - offset) {
M
Max Reitz 已提交
121
            error_setg(errp, "Header extension too large");
122 123 124
            return -EINVAL;
        }

125
        switch (ext.magic) {
126
        case QCOW2_EXT_MAGIC_END:
127
            return 0;
128

129
        case QCOW2_EXT_MAGIC_BACKING_FORMAT:
130
            if (ext.len >= sizeof(bs->backing_format)) {
131 132 133
                error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
                           " too large (>=%zu)", ext.len,
                           sizeof(bs->backing_format));
134 135
                return 2;
            }
M
Max Reitz 已提交
136 137 138 139
            ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len);
            if (ret < 0) {
                error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
                                 "Could not read format name");
140
                return 3;
M
Max Reitz 已提交
141
            }
142 143 144 145 146 147
            bs->backing_format[ext.len] = '\0';
#ifdef DEBUG_EXT
            printf("Qcow2: Got format extension %s\n", bs->backing_format);
#endif
            break;

148 149 150 151 152
        case QCOW2_EXT_MAGIC_FEATURE_TABLE:
            if (p_feature_table != NULL) {
                void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
                ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
                if (ret < 0) {
M
Max Reitz 已提交
153 154
                    error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
                                     "Could not read table");
155 156 157 158 159 160 161
                    return ret;
                }

                *p_feature_table = feature_table;
            }
            break;

162
        default:
163 164 165 166 167 168 169 170 171 172 173
            /* unknown magic - save it in case we need to rewrite the header */
            {
                Qcow2UnknownHeaderExtension *uext;

                uext = g_malloc0(sizeof(*uext)  + ext.len);
                uext->magic = ext.magic;
                uext->len = ext.len;
                QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);

                ret = bdrv_pread(bs->file, offset , uext->data, uext->len);
                if (ret < 0) {
M
Max Reitz 已提交
174 175
                    error_setg_errno(errp, -ret, "ERROR: unknown extension: "
                                     "Could not read data");
176 177 178
                    return ret;
                }
            }
179 180
            break;
        }
181 182

        offset += ((ext.len + 7) & ~7);
183 184 185 186 187
    }

    return 0;
}

188 189 190 191 192 193 194 195 196 197
static void cleanup_unknown_header_ext(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;
    Qcow2UnknownHeaderExtension *uext, *next;

    QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
        QLIST_REMOVE(uext, next);
        g_free(uext);
    }
}
198

M
Max Reitz 已提交
199 200
static void GCC_FMT_ATTR(3, 4) report_unsupported(BlockDriverState *bs,
    Error **errp, const char *fmt, ...)
K
Kevin Wolf 已提交
201 202 203 204 205 206 207 208
{
    char msg[64];
    va_list ap;

    va_start(ap, fmt);
    vsnprintf(msg, sizeof(msg), fmt, ap);
    va_end(ap);

209 210
    error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
              bdrv_get_device_name(bs), "qcow2", msg);
K
Kevin Wolf 已提交
211 212
}

213
static void report_unsupported_feature(BlockDriverState *bs,
M
Max Reitz 已提交
214
    Error **errp, Qcow2Feature *table, uint64_t mask)
215
{
216 217 218
    char *features = g_strdup("");
    char *old;

219 220
    while (table && table->name[0] != '\0') {
        if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
221 222 223 224 225 226
            if (mask & (1ULL << table->bit)) {
                old = features;
                features = g_strdup_printf("%s%s%.46s", old, *old ? ", " : "",
                                           table->name);
                g_free(old);
                mask &= ~(1ULL << table->bit);
227 228 229 230 231 232
            }
        }
        table++;
    }

    if (mask) {
233 234 235 236
        old = features;
        features = g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64,
                                   old, *old ? ", " : "", mask);
        g_free(old);
237
    }
238 239 240

    report_unsupported(bs, errp, "%s", features);
    g_free(features);
241 242
}

243 244 245 246 247 248 249
/*
 * Sets the dirty bit and flushes afterwards if necessary.
 *
 * The incompatible_features bit is only set if the image file header was
 * updated successfully.  Therefore it is not required to check the return
 * value of this function.
 */
250
int qcow2_mark_dirty(BlockDriverState *bs)
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
{
    BDRVQcowState *s = bs->opaque;
    uint64_t val;
    int ret;

    assert(s->qcow_version >= 3);

    if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
        return 0; /* already dirty */
    }

    val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
    ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
                      &val, sizeof(val));
    if (ret < 0) {
        return ret;
    }
    ret = bdrv_flush(bs->file);
    if (ret < 0) {
        return ret;
    }

    /* Only treat image as dirty if the header was updated successfully */
    s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
    return 0;
}

S
Stefan Hajnoczi 已提交
278 279 280 281 282 283 284 285 286 287
/*
 * Clears the dirty bit and flushes before if necessary.  Only call this
 * function when there are no pending requests, it does not guard against
 * concurrent requests dirtying the image.
 */
static int qcow2_mark_clean(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;

    if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
288 289 290 291 292
        int ret;

        s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;

        ret = bdrv_flush(bs);
S
Stefan Hajnoczi 已提交
293 294 295 296 297 298 299 300 301
        if (ret < 0) {
            return ret;
        }

        return qcow2_update_header(bs);
    }
    return 0;
}

M
Max Reitz 已提交
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
/*
 * Marks the image as corrupt.
 */
int qcow2_mark_corrupt(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;

    s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
    return qcow2_update_header(bs);
}

/*
 * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
 * before if necessary.
 */
int qcow2_mark_consistent(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;

    if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
        int ret = bdrv_flush(bs);
        if (ret < 0) {
            return ret;
        }

        s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT;
        return qcow2_update_header(bs);
    }
    return 0;
}

333 334 335 336 337 338 339 340 341
static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result,
                       BdrvCheckMode fix)
{
    int ret = qcow2_check_refcounts(bs, result, fix);
    if (ret < 0) {
        return ret;
    }

    if (fix && result->check_errors == 0 && result->corruptions == 0) {
M
Max Reitz 已提交
342 343 344 345 346
        ret = qcow2_mark_clean(bs);
        if (ret < 0) {
            return ret;
        }
        return qcow2_mark_consistent(bs);
347 348 349 350
    }
    return ret;
}

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
                                 uint64_t entries, size_t entry_len)
{
    BDRVQcowState *s = bs->opaque;
    uint64_t size;

    /* Use signed INT64_MAX as the maximum even for uint64_t header fields,
     * because values will be passed to qemu functions taking int64_t. */
    if (entries > INT64_MAX / entry_len) {
        return -EINVAL;
    }

    size = entries * entry_len;

    if (INT64_MAX - size < offset) {
        return -EINVAL;
    }

    /* Tables must be cluster aligned */
    if (offset & (s->cluster_size - 1)) {
        return -EINVAL;
    }

    return 0;
}

377 378 379 380 381
static QemuOptsList qcow2_runtime_opts = {
    .name = "qcow2",
    .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
    .desc = {
        {
382
            .name = QCOW2_OPT_LAZY_REFCOUNTS,
383 384 385
            .type = QEMU_OPT_BOOL,
            .help = "Postpone refcount updates",
        },
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
        {
            .name = QCOW2_OPT_DISCARD_REQUEST,
            .type = QEMU_OPT_BOOL,
            .help = "Pass guest discard requests to the layer below",
        },
        {
            .name = QCOW2_OPT_DISCARD_SNAPSHOT,
            .type = QEMU_OPT_BOOL,
            .help = "Generate discard requests when snapshot related space "
                    "is freed",
        },
        {
            .name = QCOW2_OPT_DISCARD_OTHER,
            .type = QEMU_OPT_BOOL,
            .help = "Generate discard requests when other clusters are freed",
        },
M
Max Reitz 已提交
402 403 404 405 406 407
        {
            .name = QCOW2_OPT_OVERLAP,
            .type = QEMU_OPT_STRING,
            .help = "Selects which overlap checks to perform from a range of "
                    "templates (none, constant, cached, all)",
        },
408 409 410 411 412 413
        {
            .name = QCOW2_OPT_OVERLAP_TEMPLATE,
            .type = QEMU_OPT_STRING,
            .help = "Selects which overlap checks to perform from a range of "
                    "templates (none, constant, cached, all)",
        },
M
Max Reitz 已提交
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
        {
            .name = QCOW2_OPT_OVERLAP_MAIN_HEADER,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into the main qcow2 header",
        },
        {
            .name = QCOW2_OPT_OVERLAP_ACTIVE_L1,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into the active L1 table",
        },
        {
            .name = QCOW2_OPT_OVERLAP_ACTIVE_L2,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into an active L2 table",
        },
        {
            .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into the refcount table",
        },
        {
            .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into a refcount block",
        },
        {
            .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into the snapshot table",
        },
        {
            .name = QCOW2_OPT_OVERLAP_INACTIVE_L1,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into an inactive L1 table",
        },
        {
            .name = QCOW2_OPT_OVERLAP_INACTIVE_L2,
            .type = QEMU_OPT_BOOL,
            .help = "Check for unintended writes into an inactive L2 table",
        },
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
        {
            .name = QCOW2_OPT_CACHE_SIZE,
            .type = QEMU_OPT_SIZE,
            .help = "Maximum combined metadata (L2 tables and refcount blocks) "
                    "cache size",
        },
        {
            .name = QCOW2_OPT_L2_CACHE_SIZE,
            .type = QEMU_OPT_SIZE,
            .help = "Maximum L2 table cache size",
        },
        {
            .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE,
            .type = QEMU_OPT_SIZE,
            .help = "Maximum refcount block cache size",
        },
470 471 472 473
        { /* end of list */ }
    },
};

474 475 476 477 478 479 480 481 482 483 484
static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
    [QCOW2_OL_MAIN_HEADER_BITNR]    = QCOW2_OPT_OVERLAP_MAIN_HEADER,
    [QCOW2_OL_ACTIVE_L1_BITNR]      = QCOW2_OPT_OVERLAP_ACTIVE_L1,
    [QCOW2_OL_ACTIVE_L2_BITNR]      = QCOW2_OPT_OVERLAP_ACTIVE_L2,
    [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
    [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
    [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
    [QCOW2_OL_INACTIVE_L1_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L1,
    [QCOW2_OL_INACTIVE_L2_BITNR]    = QCOW2_OPT_OVERLAP_INACTIVE_L2,
};

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
static void read_cache_sizes(QemuOpts *opts, uint64_t *l2_cache_size,
                             uint64_t *refcount_cache_size, Error **errp)
{
    uint64_t combined_cache_size;
    bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;

    combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
    l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
    refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE);

    combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0);
    *l2_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE, 0);
    *refcount_cache_size = qemu_opt_get_size(opts,
                                             QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0);

    if (combined_cache_size_set) {
        if (l2_cache_size_set && refcount_cache_size_set) {
            error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE
                       " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set "
                       "the same time");
            return;
        } else if (*l2_cache_size > combined_cache_size) {
            error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed "
                       QCOW2_OPT_CACHE_SIZE);
            return;
        } else if (*refcount_cache_size > combined_cache_size) {
            error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed "
                       QCOW2_OPT_CACHE_SIZE);
            return;
        }

        if (l2_cache_size_set) {
            *refcount_cache_size = combined_cache_size - *l2_cache_size;
        } else if (refcount_cache_size_set) {
            *l2_cache_size = combined_cache_size - *refcount_cache_size;
        } else {
            *refcount_cache_size = combined_cache_size
                                 / (DEFAULT_L2_REFCOUNT_SIZE_RATIO + 1);
            *l2_cache_size = combined_cache_size - *refcount_cache_size;
        }
    } else {
        if (!l2_cache_size_set && !refcount_cache_size_set) {
            *l2_cache_size = DEFAULT_L2_CACHE_BYTE_SIZE;
            *refcount_cache_size = *l2_cache_size
                                 / DEFAULT_L2_REFCOUNT_SIZE_RATIO;
        } else if (!l2_cache_size_set) {
            *l2_cache_size = *refcount_cache_size
                           * DEFAULT_L2_REFCOUNT_SIZE_RATIO;
        } else if (!refcount_cache_size_set) {
            *refcount_cache_size = *l2_cache_size
                                 / DEFAULT_L2_REFCOUNT_SIZE_RATIO;
        }
    }
}

M
Max Reitz 已提交
540 541
static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
B
bellard 已提交
542 543
{
    BDRVQcowState *s = bs->opaque;
544 545
    unsigned int len, i;
    int ret = 0;
B
bellard 已提交
546
    QCowHeader header;
547
    QemuOpts *opts = NULL;
548
    Error *local_err = NULL;
549
    uint64_t ext_end;
550
    uint64_t l1_vm_state_index;
551
    const char *opt_overlap_check, *opt_overlap_check_template;
M
Max Reitz 已提交
552
    int overlap_check_template = 0;
M
Max Reitz 已提交
553
    uint64_t l2_cache_size, refcount_cache_size;
B
bellard 已提交
554

555 556
    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
    if (ret < 0) {
M
Max Reitz 已提交
557
        error_setg_errno(errp, -ret, "Could not read qcow2 header");
B
bellard 已提交
558
        goto fail;
559
    }
B
bellard 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572
    be32_to_cpus(&header.magic);
    be32_to_cpus(&header.version);
    be64_to_cpus(&header.backing_file_offset);
    be32_to_cpus(&header.backing_file_size);
    be64_to_cpus(&header.size);
    be32_to_cpus(&header.cluster_bits);
    be32_to_cpus(&header.crypt_method);
    be64_to_cpus(&header.l1_table_offset);
    be32_to_cpus(&header.l1_size);
    be64_to_cpus(&header.refcount_table_offset);
    be32_to_cpus(&header.refcount_table_clusters);
    be64_to_cpus(&header.snapshots_offset);
    be32_to_cpus(&header.nb_snapshots);
573

K
Kevin Wolf 已提交
574
    if (header.magic != QCOW_MAGIC) {
M
Max Reitz 已提交
575
        error_setg(errp, "Image is not in qcow2 format");
P
Paolo Bonzini 已提交
576
        ret = -EINVAL;
B
bellard 已提交
577
        goto fail;
578
    }
K
Kevin Wolf 已提交
579
    if (header.version < 2 || header.version > 3) {
580
        report_unsupported(bs, errp, "QCOW version %" PRIu32, header.version);
K
Kevin Wolf 已提交
581 582 583 584 585 586
        ret = -ENOTSUP;
        goto fail;
    }

    s->qcow_version = header.version;

587 588 589
    /* Initialise cluster size */
    if (header.cluster_bits < MIN_CLUSTER_BITS ||
        header.cluster_bits > MAX_CLUSTER_BITS) {
590 591
        error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
                   header.cluster_bits);
592 593 594 595 596 597 598 599
        ret = -EINVAL;
        goto fail;
    }

    s->cluster_bits = header.cluster_bits;
    s->cluster_size = 1 << s->cluster_bits;
    s->cluster_sectors = 1 << (s->cluster_bits - 9);

K
Kevin Wolf 已提交
600 601 602 603 604 605 606 607 608 609 610 611 612
    /* Initialise version 3 header fields */
    if (header.version == 2) {
        header.incompatible_features    = 0;
        header.compatible_features      = 0;
        header.autoclear_features       = 0;
        header.refcount_order           = 4;
        header.header_length            = 72;
    } else {
        be64_to_cpus(&header.incompatible_features);
        be64_to_cpus(&header.compatible_features);
        be64_to_cpus(&header.autoclear_features);
        be32_to_cpus(&header.refcount_order);
        be32_to_cpus(&header.header_length);
613 614 615 616 617 618 619 620 621 622 623 624

        if (header.header_length < 104) {
            error_setg(errp, "qcow2 header too short");
            ret = -EINVAL;
            goto fail;
        }
    }

    if (header.header_length > s->cluster_size) {
        error_setg(errp, "qcow2 header exceeds cluster size");
        ret = -EINVAL;
        goto fail;
K
Kevin Wolf 已提交
625 626 627 628 629 630 631 632
    }

    if (header.header_length > sizeof(header)) {
        s->unknown_header_fields_size = header.header_length - sizeof(header);
        s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
        ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
                         s->unknown_header_fields_size);
        if (ret < 0) {
M
Max Reitz 已提交
633 634
            error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
                             "fields");
K
Kevin Wolf 已提交
635 636 637 638
            goto fail;
        }
    }

639 640 641 642 643 644
    if (header.backing_file_offset > s->cluster_size) {
        error_setg(errp, "Invalid backing file offset");
        ret = -EINVAL;
        goto fail;
    }

645 646 647 648 649 650
    if (header.backing_file_offset) {
        ext_end = header.backing_file_offset;
    } else {
        ext_end = 1 << header.cluster_bits;
    }

K
Kevin Wolf 已提交
651 652 653 654 655
    /* Handle feature bits */
    s->incompatible_features    = header.incompatible_features;
    s->compatible_features      = header.compatible_features;
    s->autoclear_features       = header.autoclear_features;

S
Stefan Hajnoczi 已提交
656
    if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
657 658
        void *feature_table = NULL;
        qcow2_read_extensions(bs, header.header_length, ext_end,
M
Max Reitz 已提交
659 660
                              &feature_table, NULL);
        report_unsupported_feature(bs, errp, feature_table,
S
Stefan Hajnoczi 已提交
661 662
                                   s->incompatible_features &
                                   ~QCOW2_INCOMPAT_MASK);
K
Kevin Wolf 已提交
663
        ret = -ENOTSUP;
664
        g_free(feature_table);
K
Kevin Wolf 已提交
665 666 667
        goto fail;
    }

M
Max Reitz 已提交
668 669 670 671
    if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
        /* Corrupt images may not be written to unless they are being repaired
         */
        if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
M
Max Reitz 已提交
672 673
            error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
                       "read/write");
M
Max Reitz 已提交
674 675 676 677 678
            ret = -EACCES;
            goto fail;
        }
    }

K
Kevin Wolf 已提交
679
    /* Check support for various header values */
680 681 682 683
    if (header.refcount_order > 6) {
        error_setg(errp, "Reference count entry width too large; may not "
                   "exceed 64 bits");
        ret = -EINVAL;
K
Kevin Wolf 已提交
684 685
        goto fail;
    }
686
    s->refcount_order = header.refcount_order;
687 688 689
    s->refcount_bits = 1 << s->refcount_order;
    s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
    s->refcount_max += s->refcount_max - 1;
K
Kevin Wolf 已提交
690

691
    if (header.crypt_method > QCOW_CRYPT_AES) {
692
        error_setg(errp, "Unsupported encryption method: %" PRIu32,
M
Max Reitz 已提交
693
                   header.crypt_method);
694
        ret = -EINVAL;
B
bellard 已提交
695
        goto fail;
696
    }
B
bellard 已提交
697
    s->crypt_method_header = header.crypt_method;
698
    if (s->crypt_method_header) {
B
bellard 已提交
699
        bs->encrypted = 1;
700
    }
701

B
bellard 已提交
702 703
    s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
    s->l2_size = 1 << s->l2_bits;
704 705 706
    /* 2^(s->refcount_order - 3) is the refcount width in bytes */
    s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
    s->refcount_block_size = 1 << s->refcount_block_bits;
B
bellard 已提交
707 708 709 710
    bs->total_sectors = header.size / 512;
    s->csize_shift = (62 - (s->cluster_bits - 8));
    s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
    s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
711

B
bellard 已提交
712
    s->refcount_table_offset = header.refcount_table_offset;
713
    s->refcount_table_size =
B
bellard 已提交
714 715
        header.refcount_table_clusters << (s->cluster_bits - 3);

716
    if (header.refcount_table_clusters > qcow2_max_refcount_clusters(s)) {
717 718 719 720 721
        error_setg(errp, "Reference count table too large");
        ret = -EINVAL;
        goto fail;
    }

722 723 724 725 726 727 728
    ret = validate_table_offset(bs, s->refcount_table_offset,
                                s->refcount_table_size, sizeof(uint64_t));
    if (ret < 0) {
        error_setg(errp, "Invalid reference count table offset");
        goto fail;
    }

729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
    /* Snapshot table offset/length */
    if (header.nb_snapshots > QCOW_MAX_SNAPSHOTS) {
        error_setg(errp, "Too many snapshots");
        ret = -EINVAL;
        goto fail;
    }

    ret = validate_table_offset(bs, header.snapshots_offset,
                                header.nb_snapshots,
                                sizeof(QCowSnapshotHeader));
    if (ret < 0) {
        error_setg(errp, "Invalid snapshot table offset");
        goto fail;
    }

B
bellard 已提交
744
    /* read the level 1 table */
745
    if (header.l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
746 747 748 749
        error_setg(errp, "Active L1 table too large");
        ret = -EFBIG;
        goto fail;
    }
B
bellard 已提交
750
    s->l1_size = header.l1_size;
751 752 753

    l1_vm_state_index = size_to_l1(s, header.size);
    if (l1_vm_state_index > INT_MAX) {
M
Max Reitz 已提交
754
        error_setg(errp, "Image is too big");
755 756 757 758 759
        ret = -EFBIG;
        goto fail;
    }
    s->l1_vm_state_index = l1_vm_state_index;

B
bellard 已提交
760 761
    /* the L1 table must contain at least enough entries to put
       header.size bytes */
762
    if (s->l1_size < s->l1_vm_state_index) {
M
Max Reitz 已提交
763
        error_setg(errp, "L1 table is too small");
764
        ret = -EINVAL;
B
bellard 已提交
765
        goto fail;
766
    }
767 768 769 770 771 772 773

    ret = validate_table_offset(bs, header.l1_table_offset,
                                header.l1_size, sizeof(uint64_t));
    if (ret < 0) {
        error_setg(errp, "Invalid L1 table offset");
        goto fail;
    }
B
bellard 已提交
774
    s->l1_table_offset = header.l1_table_offset;
775 776


777
    if (s->l1_size > 0) {
778
        s->l1_table = qemu_try_blockalign(bs->file,
779
            align_offset(s->l1_size * sizeof(uint64_t), 512));
780 781 782 783 784
        if (s->l1_table == NULL) {
            error_setg(errp, "Could not allocate L1 table");
            ret = -ENOMEM;
            goto fail;
        }
785 786 787
        ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
                         s->l1_size * sizeof(uint64_t));
        if (ret < 0) {
M
Max Reitz 已提交
788
            error_setg_errno(errp, -ret, "Could not read L1 table");
789
            goto fail;
790
        }
791 792 793
        for(i = 0;i < s->l1_size; i++) {
            be64_to_cpus(&s->l1_table[i]);
        }
B
bellard 已提交
794
    }
K
Kevin Wolf 已提交
795

796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
    /* get L2 table/refcount block cache size from command line options */
    opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
    qemu_opts_absorb_qdict(opts, options, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        ret = -EINVAL;
        goto fail;
    }

    read_cache_sizes(opts, &l2_cache_size, &refcount_cache_size, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        ret = -EINVAL;
        goto fail;
    }

    l2_cache_size /= s->cluster_size;
M
Max Reitz 已提交
813 814 815
    if (l2_cache_size < MIN_L2_CACHE_SIZE) {
        l2_cache_size = MIN_L2_CACHE_SIZE;
    }
816 817 818 819 820
    if (l2_cache_size > INT_MAX) {
        error_setg(errp, "L2 cache size too big");
        ret = -EINVAL;
        goto fail;
    }
M
Max Reitz 已提交
821

822
    refcount_cache_size /= s->cluster_size;
M
Max Reitz 已提交
823 824 825
    if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
        refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
    }
826 827 828 829 830
    if (refcount_cache_size > INT_MAX) {
        error_setg(errp, "Refcount cache size too big");
        ret = -EINVAL;
        goto fail;
    }
M
Max Reitz 已提交
831

832
    /* alloc L2 table/refcount block cache */
M
Max Reitz 已提交
833 834
    s->l2_table_cache = qcow2_cache_create(bs, l2_cache_size);
    s->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size);
835 836 837 838 839
    if (s->l2_table_cache == NULL || s->refcount_block_cache == NULL) {
        error_setg(errp, "Could not allocate metadata caches");
        ret = -ENOMEM;
        goto fail;
    }
K
Kevin Wolf 已提交
840

841
    s->cluster_cache = g_malloc(s->cluster_size);
B
bellard 已提交
842
    /* one more sector for decompressed data alignment */
843 844 845 846 847 848 849 850
    s->cluster_data = qemu_try_blockalign(bs->file, QCOW_MAX_CRYPT_CLUSTERS
                                                    * s->cluster_size + 512);
    if (s->cluster_data == NULL) {
        error_setg(errp, "Could not allocate temporary cluster buffer");
        ret = -ENOMEM;
        goto fail;
    }

B
bellard 已提交
851
    s->cluster_cache_offset = -1;
852
    s->flags = flags;
853

854 855
    ret = qcow2_refcount_init(bs);
    if (ret != 0) {
M
Max Reitz 已提交
856
        error_setg_errno(errp, -ret, "Could not initialize refcount handling");
B
bellard 已提交
857
        goto fail;
858
    }
B
bellard 已提交
859

B
Blue Swirl 已提交
860
    QLIST_INIT(&s->cluster_allocs);
K
Kevin Wolf 已提交
861
    QTAILQ_INIT(&s->discards);
862

863
    /* read qcow2 extensions */
M
Max Reitz 已提交
864 865 866
    if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
        &local_err)) {
        error_propagate(errp, local_err);
867
        ret = -EINVAL;
868
        goto fail;
869
    }
870

B
bellard 已提交
871 872 873
    /* read the backing file name */
    if (header.backing_file_offset != 0) {
        len = header.backing_file_size;
874
        if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
875
            len >= sizeof(bs->backing_file)) {
876 877 878
            error_setg(errp, "Backing file name too long");
            ret = -EINVAL;
            goto fail;
879 880 881 882
        }
        ret = bdrv_pread(bs->file, header.backing_file_offset,
                         bs->backing_file, len);
        if (ret < 0) {
M
Max Reitz 已提交
883
            error_setg_errno(errp, -ret, "Could not read backing file name");
B
bellard 已提交
884
            goto fail;
885
        }
B
bellard 已提交
886 887
        bs->backing_file[len] = '\0';
    }
888

889 890 891 892
    /* Internal snapshots */
    s->snapshots_offset = header.snapshots_offset;
    s->nb_snapshots = header.nb_snapshots;

893 894
    ret = qcow2_read_snapshots(bs);
    if (ret < 0) {
M
Max Reitz 已提交
895
        error_setg_errno(errp, -ret, "Could not read snapshots");
B
bellard 已提交
896
        goto fail;
897
    }
B
bellard 已提交
898

899
    /* Clear unknown autoclear feature bits */
900
    if (!bs->read_only && !(flags & BDRV_O_INCOMING) && s->autoclear_features) {
901 902 903
        s->autoclear_features = 0;
        ret = qcow2_update_header(bs);
        if (ret < 0) {
M
Max Reitz 已提交
904
            error_setg_errno(errp, -ret, "Could not update qcow2 header");
905 906 907 908
            goto fail;
        }
    }

K
Kevin Wolf 已提交
909 910 911
    /* Initialise locks */
    qemu_co_mutex_init(&s->lock);

S
Stefan Hajnoczi 已提交
912
    /* Repair image if dirty */
913
    if (!(flags & (BDRV_O_CHECK | BDRV_O_INCOMING)) && !bs->read_only &&
914
        (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
S
Stefan Hajnoczi 已提交
915 916
        BdrvCheckResult result = {0};

M
Max Reitz 已提交
917
        ret = qcow2_check(bs, &result, BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
S
Stefan Hajnoczi 已提交
918
        if (ret < 0) {
M
Max Reitz 已提交
919
            error_setg_errno(errp, -ret, "Could not repair dirty image");
S
Stefan Hajnoczi 已提交
920 921 922 923
            goto fail;
        }
    }

924
    /* Enable lazy_refcounts according to image and command line options */
925
    s->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
926 927
        (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));

928 929 930 931 932 933 934 935 936 937
    s->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
    s->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
    s->discard_passthrough[QCOW2_DISCARD_REQUEST] =
        qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
                          flags & BDRV_O_UNMAP);
    s->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
        qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
    s->discard_passthrough[QCOW2_DISCARD_OTHER] =
        qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);

938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
    opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
    opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
    if (opt_overlap_check_template && opt_overlap_check &&
        strcmp(opt_overlap_check_template, opt_overlap_check))
    {
        error_setg(errp, "Conflicting values for qcow2 options '"
                   QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
                   "' ('%s')", opt_overlap_check, opt_overlap_check_template);
        ret = -EINVAL;
        goto fail;
    }
    if (!opt_overlap_check) {
        opt_overlap_check = opt_overlap_check_template ?: "cached";
    }

M
Max Reitz 已提交
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
    if (!strcmp(opt_overlap_check, "none")) {
        overlap_check_template = 0;
    } else if (!strcmp(opt_overlap_check, "constant")) {
        overlap_check_template = QCOW2_OL_CONSTANT;
    } else if (!strcmp(opt_overlap_check, "cached")) {
        overlap_check_template = QCOW2_OL_CACHED;
    } else if (!strcmp(opt_overlap_check, "all")) {
        overlap_check_template = QCOW2_OL_ALL;
    } else {
        error_setg(errp, "Unsupported value '%s' for qcow2 option "
                   "'overlap-check'. Allowed are either of the following: "
                   "none, constant, cached, all", opt_overlap_check);
        ret = -EINVAL;
        goto fail;
    }

    s->overlap_check = 0;
    for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
        /* overlap-check defines a template bitmask, but every flag may be
         * overwritten through the associated boolean option */
        s->overlap_check |=
            qemu_opt_get_bool(opts, overlap_bool_option_names[i],
                              overlap_check_template & (1 << i)) << i;
    }
977

978
    qemu_opts_del(opts);
979
    opts = NULL;
980 981

    if (s->use_lazy_refcounts && s->qcow_version < 3) {
M
Max Reitz 已提交
982 983
        error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
                   "qemu 1.1 compatibility level");
984 985 986 987
        ret = -EINVAL;
        goto fail;
    }

B
bellard 已提交
988
#ifdef DEBUG_ALLOC
P
Philipp Hahn 已提交
989 990
    {
        BdrvCheckResult result = {0};
991
        qcow2_check_refcounts(bs, &result, 0);
P
Philipp Hahn 已提交
992
    }
B
bellard 已提交
993
#endif
994
    return ret;
B
bellard 已提交
995 996

 fail:
997
    qemu_opts_del(opts);
K
Kevin Wolf 已提交
998
    g_free(s->unknown_header_fields);
999
    cleanup_unknown_header_ext(bs);
K
Kevin Wolf 已提交
1000 1001
    qcow2_free_snapshots(bs);
    qcow2_refcount_close(bs);
1002
    qemu_vfree(s->l1_table);
1003 1004
    /* else pre-write overlap checks in cache_destroy may crash */
    s->l1_table = NULL;
K
Kevin Wolf 已提交
1005 1006 1007
    if (s->l2_table_cache) {
        qcow2_cache_destroy(bs, s->l2_table_cache);
    }
1008 1009 1010
    if (s->refcount_block_cache) {
        qcow2_cache_destroy(bs, s->refcount_block_cache);
    }
1011
    g_free(s->cluster_cache);
1012
    qemu_vfree(s->cluster_data);
1013
    return ret;
B
bellard 已提交
1014 1015
}

1016
static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
1017 1018 1019 1020 1021 1022
{
    BDRVQcowState *s = bs->opaque;

    bs->bl.write_zeroes_alignment = s->cluster_sectors;
}

1023
static int qcow2_set_key(BlockDriverState *bs, const char *key)
B
bellard 已提交
1024 1025 1026 1027
{
    BDRVQcowState *s = bs->opaque;
    uint8_t keybuf[16];
    int len, i;
1028

B
bellard 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
    memset(keybuf, 0, 16);
    len = strlen(key);
    if (len > 16)
        len = 16;
    /* XXX: we could compress the chars to 7 bits to increase
       entropy */
    for(i = 0;i < len;i++) {
        keybuf[i] = key[i];
    }
    s->crypt_method = s->crypt_method_header;

    if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0)
        return -1;
    if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0)
        return -1;
#if 0
    /* test */
    {
        uint8_t in[16];
        uint8_t out[16];
        uint8_t tmp[16];
        for(i=0;i<16;i++)
            in[i] = i;
        AES_encrypt(in, tmp, &s->aes_encrypt_key);
        AES_decrypt(tmp, out, &s->aes_decrypt_key);
        for(i = 0; i < 16; i++)
            printf(" %02x", tmp[i]);
        printf("\n");
        for(i = 0; i < 16; i++)
            printf(" %02x", out[i]);
        printf("\n");
    }
#endif
    return 0;
}

1065 1066
/* We have no actual commit/abort logic for qcow2, but we need to write out any
 * unwritten data if we reopen read-only. */
J
Jeff Cody 已提交
1067 1068 1069
static int qcow2_reopen_prepare(BDRVReopenState *state,
                                BlockReopenQueue *queue, Error **errp)
{
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
    int ret;

    if ((state->flags & BDRV_O_RDWR) == 0) {
        ret = bdrv_flush(state->bs);
        if (ret < 0) {
            return ret;
        }

        ret = qcow2_mark_clean(state->bs);
        if (ret < 0) {
            return ret;
        }
    }

J
Jeff Cody 已提交
1084 1085 1086
    return 0;
}

1087
static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
1088
        int64_t sector_num, int nb_sectors, int *pnum)
B
bellard 已提交
1089
{
1090
    BDRVQcowState *s = bs->opaque;
B
bellard 已提交
1091
    uint64_t cluster_offset;
1092 1093
    int index_in_cluster, ret;
    int64_t status = 0;
B
bellard 已提交
1094

1095
    *pnum = nb_sectors;
1096
    qemu_co_mutex_lock(&s->lock);
1097
    ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);
1098
    qemu_co_mutex_unlock(&s->lock);
1099
    if (ret < 0) {
1100
        return ret;
1101
    }
1102

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
    if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
        !s->crypt_method) {
        index_in_cluster = sector_num & (s->cluster_sectors - 1);
        cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
        status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;
    }
    if (ret == QCOW2_CLUSTER_ZERO) {
        status |= BDRV_BLOCK_ZERO;
    } else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
        status |= BDRV_BLOCK_DATA;
    }
    return status;
B
bellard 已提交
1115 1116
}

B
bellard 已提交
1117
/* handle reading after the end of the backing file */
1118 1119
int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
                  int64_t sector_num, int nb_sectors)
B
bellard 已提交
1120 1121 1122 1123 1124 1125 1126 1127
{
    int n1;
    if ((sector_num + nb_sectors) <= bs->total_sectors)
        return nb_sectors;
    if (sector_num >= bs->total_sectors)
        n1 = 0;
    else
        n1 = bs->total_sectors - sector_num;
1128

1129
    qemu_iovec_memset(qiov, 512 * n1, 0, 512 * (nb_sectors - n1));
1130

B
bellard 已提交
1131 1132 1133
    return n1;
}

1134
static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
1135
                          int remaining_sectors, QEMUIOVector *qiov)
B
bellard 已提交
1136 1137
{
    BDRVQcowState *s = bs->opaque;
B
bellard 已提交
1138
    int index_in_cluster, n1;
K
Kevin Wolf 已提交
1139
    int ret;
1140
    int cur_nr_sectors; /* number of sectors in current iteration */
1141
    uint64_t cluster_offset = 0;
1142 1143 1144
    uint64_t bytes_done = 0;
    QEMUIOVector hd_qiov;
    uint8_t *cluster_data = NULL;
B
bellard 已提交
1145

1146 1147 1148 1149 1150
    qemu_iovec_init(&hd_qiov, qiov->niov);

    qemu_co_mutex_lock(&s->lock);

    while (remaining_sectors != 0) {
1151

1152
        /* prepare next request */
1153
        cur_nr_sectors = remaining_sectors;
1154 1155 1156
        if (s->crypt_method) {
            cur_nr_sectors = MIN(cur_nr_sectors,
                QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
B
bellard 已提交
1157
        }
1158

1159
        ret = qcow2_get_cluster_offset(bs, sector_num << 9,
1160
            &cur_nr_sectors, &cluster_offset);
1161
        if (ret < 0) {
1162
            goto fail;
1163
        }
1164

1165
        index_in_cluster = sector_num & (s->cluster_sectors - 1);
1166

1167
        qemu_iovec_reset(&hd_qiov);
1168
        qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
1169 1170
            cur_nr_sectors * 512);

1171 1172
        switch (ret) {
        case QCOW2_CLUSTER_UNALLOCATED:
1173 1174 1175

            if (bs->backing_hd) {
                /* read from the base image */
1176 1177
                n1 = qcow2_backing_read1(bs->backing_hd, &hd_qiov,
                    sector_num, cur_nr_sectors);
1178
                if (n1 > 0) {
1179 1180 1181 1182 1183 1184
                    QEMUIOVector local_qiov;

                    qemu_iovec_init(&local_qiov, hd_qiov.niov);
                    qemu_iovec_concat(&local_qiov, &hd_qiov, 0,
                                      n1 * BDRV_SECTOR_SIZE);

1185 1186
                    BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
                    qemu_co_mutex_unlock(&s->lock);
1187
                    ret = bdrv_co_readv(bs->backing_hd, sector_num,
1188
                                        n1, &local_qiov);
1189
                    qemu_co_mutex_lock(&s->lock);
1190 1191 1192

                    qemu_iovec_destroy(&local_qiov);

1193
                    if (ret < 0) {
1194
                        goto fail;
1195 1196 1197 1198
                    }
                }
            } else {
                /* Note: in this case, no need to wait */
1199
                qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors);
1200
            }
1201 1202
            break;

1203
        case QCOW2_CLUSTER_ZERO:
1204
            qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors);
1205 1206
            break;

1207
        case QCOW2_CLUSTER_COMPRESSED:
1208 1209 1210
            /* add AIO support for compressed blocks ? */
            ret = qcow2_decompress_cluster(bs, cluster_offset);
            if (ret < 0) {
1211
                goto fail;
1212 1213
            }

1214
            qemu_iovec_from_buf(&hd_qiov, 0,
1215
                s->cluster_cache + index_in_cluster * 512,
1216
                512 * cur_nr_sectors);
1217 1218 1219
            break;

        case QCOW2_CLUSTER_NORMAL:
1220
            if ((cluster_offset & 511) != 0) {
1221 1222
                ret = -EIO;
                goto fail;
1223
            }
1224

1225 1226 1227 1228 1229
            if (s->crypt_method) {
                /*
                 * For encrypted images, read everything into a temporary
                 * contiguous buffer on which the AES functions can work.
                 */
1230 1231
                if (!cluster_data) {
                    cluster_data =
1232 1233 1234 1235 1236 1237
                        qemu_try_blockalign(bs->file, QCOW_MAX_CRYPT_CLUSTERS
                                                      * s->cluster_size);
                    if (cluster_data == NULL) {
                        ret = -ENOMEM;
                        goto fail;
                    }
1238 1239 1240 1241
                }

                assert(cur_nr_sectors <=
                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
1242 1243
                qemu_iovec_reset(&hd_qiov);
                qemu_iovec_add(&hd_qiov, cluster_data,
1244 1245 1246 1247 1248 1249 1250
                    512 * cur_nr_sectors);
            }

            BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
            qemu_co_mutex_unlock(&s->lock);
            ret = bdrv_co_readv(bs->file,
                                (cluster_offset >> 9) + index_in_cluster,
1251
                                cur_nr_sectors, &hd_qiov);
1252 1253
            qemu_co_mutex_lock(&s->lock);
            if (ret < 0) {
1254
                goto fail;
1255 1256
            }
            if (s->crypt_method) {
1257 1258
                qcow2_encrypt_sectors(s, sector_num,  cluster_data,
                    cluster_data, cur_nr_sectors, 0, &s->aes_decrypt_key);
1259 1260
                qemu_iovec_from_buf(qiov, bytes_done,
                    cluster_data, 512 * cur_nr_sectors);
1261
            }
1262 1263 1264 1265 1266 1267
            break;

        default:
            g_assert_not_reached();
            ret = -EIO;
            goto fail;
1268
        }
1269

1270 1271 1272
        remaining_sectors -= cur_nr_sectors;
        sector_num += cur_nr_sectors;
        bytes_done += cur_nr_sectors * 512;
1273
    }
1274
    ret = 0;
1275

1276
fail:
K
Kevin Wolf 已提交
1277
    qemu_co_mutex_unlock(&s->lock);
K
Kevin Wolf 已提交
1278

1279
    qemu_iovec_destroy(&hd_qiov);
1280
    qemu_vfree(cluster_data);
K
Kevin Wolf 已提交
1281 1282

    return ret;
B
bellard 已提交
1283 1284
}

1285
static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
1286 1287 1288
                           int64_t sector_num,
                           int remaining_sectors,
                           QEMUIOVector *qiov)
B
bellard 已提交
1289 1290 1291
{
    BDRVQcowState *s = bs->opaque;
    int index_in_cluster;
K
Kevin Wolf 已提交
1292
    int ret;
1293
    int cur_nr_sectors; /* number of sectors in current iteration */
1294
    uint64_t cluster_offset;
1295 1296 1297
    QEMUIOVector hd_qiov;
    uint64_t bytes_done = 0;
    uint8_t *cluster_data = NULL;
1298
    QCowL2Meta *l2meta = NULL;
1299

K
Kevin Wolf 已提交
1300 1301 1302
    trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num,
                                 remaining_sectors);

1303 1304 1305
    qemu_iovec_init(&hd_qiov, qiov->niov);

    s->cluster_cache_offset = -1; /* disable compressed cache */
1306

1307 1308 1309 1310
    qemu_co_mutex_lock(&s->lock);

    while (remaining_sectors != 0) {

1311
        l2meta = NULL;
K
Kevin Wolf 已提交
1312

K
Kevin Wolf 已提交
1313
        trace_qcow2_writev_start_part(qemu_coroutine_self());
1314
        index_in_cluster = sector_num & (s->cluster_sectors - 1);
1315
        cur_nr_sectors = remaining_sectors;
1316
        if (s->crypt_method &&
1317 1318 1319 1320
            cur_nr_sectors >
            QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors - index_in_cluster) {
            cur_nr_sectors =
                QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors - index_in_cluster;
1321
        }
1322

1323
        ret = qcow2_alloc_cluster_offset(bs, sector_num << 9,
1324
            &cur_nr_sectors, &cluster_offset, &l2meta);
1325
        if (ret < 0) {
1326
            goto fail;
1327
        }
1328

1329
        assert((cluster_offset & 511) == 0);
1330

1331
        qemu_iovec_reset(&hd_qiov);
1332
        qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
1333
            cur_nr_sectors * 512);
1334

1335
        if (s->crypt_method) {
1336
            if (!cluster_data) {
1337 1338 1339 1340 1341 1342 1343
                cluster_data = qemu_try_blockalign(bs->file,
                                                   QCOW_MAX_CRYPT_CLUSTERS
                                                   * s->cluster_size);
                if (cluster_data == NULL) {
                    ret = -ENOMEM;
                    goto fail;
                }
1344
            }
1345

1346
            assert(hd_qiov.size <=
1347
                   QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
1348
            qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
1349

1350 1351
            qcow2_encrypt_sectors(s, sector_num, cluster_data,
                cluster_data, cur_nr_sectors, 1, &s->aes_encrypt_key);
1352

1353 1354
            qemu_iovec_reset(&hd_qiov);
            qemu_iovec_add(&hd_qiov, cluster_data,
1355 1356
                cur_nr_sectors * 512);
        }
1357

M
Max Reitz 已提交
1358
        ret = qcow2_pre_write_overlap_check(bs, 0,
1359 1360 1361 1362 1363 1364
                cluster_offset + index_in_cluster * BDRV_SECTOR_SIZE,
                cur_nr_sectors * BDRV_SECTOR_SIZE);
        if (ret < 0) {
            goto fail;
        }

1365
        qemu_co_mutex_unlock(&s->lock);
1366
        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
K
Kevin Wolf 已提交
1367 1368
        trace_qcow2_writev_data(qemu_coroutine_self(),
                                (cluster_offset >> 9) + index_in_cluster);
1369 1370
        ret = bdrv_co_writev(bs->file,
                             (cluster_offset >> 9) + index_in_cluster,
1371
                             cur_nr_sectors, &hd_qiov);
1372 1373
        qemu_co_mutex_lock(&s->lock);
        if (ret < 0) {
1374
            goto fail;
1375
        }
1376

1377 1378 1379
        while (l2meta != NULL) {
            QCowL2Meta *next;

1380 1381 1382 1383
            ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
            if (ret < 0) {
                goto fail;
            }
1384

1385 1386 1387 1388 1389 1390 1391
            /* Take the request off the list of running requests */
            if (l2meta->nb_clusters != 0) {
                QLIST_REMOVE(l2meta, next_in_flight);
            }

            qemu_co_queue_restart_all(&l2meta->dependent_requests);

1392
            next = l2meta->next;
1393
            g_free(l2meta);
1394
            l2meta = next;
1395
        }
1396

1397 1398 1399
        remaining_sectors -= cur_nr_sectors;
        sector_num += cur_nr_sectors;
        bytes_done += cur_nr_sectors * 512;
K
Kevin Wolf 已提交
1400
        trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors);
1401
    }
1402
    ret = 0;
1403

1404
fail:
1405 1406
    qemu_co_mutex_unlock(&s->lock);

1407 1408 1409
    while (l2meta != NULL) {
        QCowL2Meta *next;

1410 1411 1412 1413
        if (l2meta->nb_clusters != 0) {
            QLIST_REMOVE(l2meta, next_in_flight);
        }
        qemu_co_queue_restart_all(&l2meta->dependent_requests);
1414 1415

        next = l2meta->next;
K
Kevin Wolf 已提交
1416
        g_free(l2meta);
1417
        l2meta = next;
K
Kevin Wolf 已提交
1418
    }
1419

1420
    qemu_iovec_destroy(&hd_qiov);
1421
    qemu_vfree(cluster_data);
K
Kevin Wolf 已提交
1422
    trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
K
Kevin Wolf 已提交
1423

K
Kevin Wolf 已提交
1424
    return ret;
B
bellard 已提交
1425 1426
}

1427
static void qcow2_close(BlockDriverState *bs)
B
bellard 已提交
1428 1429
{
    BDRVQcowState *s = bs->opaque;
1430
    qemu_vfree(s->l1_table);
1431 1432
    /* else pre-write overlap checks in cache_destroy may crash */
    s->l1_table = NULL;
K
Kevin Wolf 已提交
1433

1434
    if (!(bs->open_flags & BDRV_O_INCOMING)) {
1435
        int ret1, ret2;
K
Kevin Wolf 已提交
1436

1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
        ret1 = qcow2_cache_flush(bs, s->l2_table_cache);
        ret2 = qcow2_cache_flush(bs, s->refcount_block_cache);

        if (ret1) {
            error_report("Failed to flush the L2 table cache: %s",
                         strerror(-ret1));
        }
        if (ret2) {
            error_report("Failed to flush the refcount block cache: %s",
                         strerror(-ret2));
        }

        if (!ret1 && !ret2) {
            qcow2_mark_clean(bs);
        }
1452
    }
S
Stefan Hajnoczi 已提交
1453

K
Kevin Wolf 已提交
1454 1455 1456
    qcow2_cache_destroy(bs, s->l2_table_cache);
    qcow2_cache_destroy(bs, s->refcount_block_cache);

K
Kevin Wolf 已提交
1457
    g_free(s->unknown_header_fields);
1458
    cleanup_unknown_header_ext(bs);
K
Kevin Wolf 已提交
1459

1460
    g_free(s->cluster_cache);
1461
    qemu_vfree(s->cluster_data);
K
Kevin Wolf 已提交
1462
    qcow2_refcount_close(bs);
1463
    qcow2_free_snapshots(bs);
B
bellard 已提交
1464 1465
}

1466
static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
1467 1468 1469 1470 1471 1472
{
    BDRVQcowState *s = bs->opaque;
    int flags = s->flags;
    AES_KEY aes_encrypt_key;
    AES_KEY aes_decrypt_key;
    uint32_t crypt_method = 0;
1473
    QDict *options;
1474 1475
    Error *local_err = NULL;
    int ret;
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489

    /*
     * Backing files are read-only which makes all of their metadata immutable,
     * that means we don't have to worry about reopening them here.
     */

    if (s->crypt_method) {
        crypt_method = s->crypt_method;
        memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key));
        memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key));
    }

    qcow2_close(bs);

1490 1491 1492 1493 1494
    bdrv_invalidate_cache(bs->file, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }
1495

1496
    memset(s, 0, sizeof(BDRVQcowState));
1497
    options = qdict_clone_shallow(bs->options);
1498 1499

    ret = qcow2_open(bs, options, flags, &local_err);
1500
    QDECREF(options);
1501 1502 1503 1504 1505 1506 1507 1508 1509
    if (local_err) {
        error_setg(errp, "Could not reopen qcow2 layer: %s",
                   error_get_pretty(local_err));
        error_free(local_err);
        return;
    } else if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not reopen qcow2 layer");
        return;
    }
1510

1511 1512 1513 1514 1515 1516 1517
    if (crypt_method) {
        s->crypt_method = crypt_method;
        memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key));
        memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key));
    }
}

K
Kevin Wolf 已提交
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
    size_t len, size_t buflen)
{
    QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
    size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);

    if (buflen < ext_len) {
        return -ENOSPC;
    }

    *ext_backing_fmt = (QCowExtension) {
        .magic  = cpu_to_be32(magic),
        .len    = cpu_to_be32(len),
    };
    memcpy(buf + sizeof(QCowExtension), s, len);

    return ext_len;
}

K
Kevin Wolf 已提交
1537
/*
K
Kevin Wolf 已提交
1538 1539 1540 1541
 * Updates the qcow2 header, including the variable length parts of it, i.e.
 * the backing file name and all extensions. qcow2 was not designed to allow
 * such changes, so if we run out of space (we can only use the first cluster)
 * this function may fail.
K
Kevin Wolf 已提交
1542 1543 1544
 *
 * Returns 0 on success, -errno in error cases.
 */
K
Kevin Wolf 已提交
1545
int qcow2_update_header(BlockDriverState *bs)
K
Kevin Wolf 已提交
1546 1547
{
    BDRVQcowState *s = bs->opaque;
K
Kevin Wolf 已提交
1548 1549 1550
    QCowHeader *header;
    char *buf;
    size_t buflen = s->cluster_size;
K
Kevin Wolf 已提交
1551
    int ret;
K
Kevin Wolf 已提交
1552 1553
    uint64_t total_size;
    uint32_t refcount_table_clusters;
K
Kevin Wolf 已提交
1554
    size_t header_length;
1555
    Qcow2UnknownHeaderExtension *uext;
K
Kevin Wolf 已提交
1556

K
Kevin Wolf 已提交
1557
    buf = qemu_blockalign(bs, buflen);
K
Kevin Wolf 已提交
1558

K
Kevin Wolf 已提交
1559 1560
    /* Header structure */
    header = (QCowHeader*) buf;
K
Kevin Wolf 已提交
1561

K
Kevin Wolf 已提交
1562 1563 1564
    if (buflen < sizeof(*header)) {
        ret = -ENOSPC;
        goto fail;
K
Kevin Wolf 已提交
1565 1566
    }

K
Kevin Wolf 已提交
1567
    header_length = sizeof(*header) + s->unknown_header_fields_size;
K
Kevin Wolf 已提交
1568 1569 1570 1571
    total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
    refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);

    *header = (QCowHeader) {
K
Kevin Wolf 已提交
1572
        /* Version 2 fields */
K
Kevin Wolf 已提交
1573
        .magic                  = cpu_to_be32(QCOW_MAGIC),
K
Kevin Wolf 已提交
1574
        .version                = cpu_to_be32(s->qcow_version),
K
Kevin Wolf 已提交
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
        .backing_file_offset    = 0,
        .backing_file_size      = 0,
        .cluster_bits           = cpu_to_be32(s->cluster_bits),
        .size                   = cpu_to_be64(total_size),
        .crypt_method           = cpu_to_be32(s->crypt_method_header),
        .l1_size                = cpu_to_be32(s->l1_size),
        .l1_table_offset        = cpu_to_be64(s->l1_table_offset),
        .refcount_table_offset  = cpu_to_be64(s->refcount_table_offset),
        .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
        .nb_snapshots           = cpu_to_be32(s->nb_snapshots),
        .snapshots_offset       = cpu_to_be64(s->snapshots_offset),
K
Kevin Wolf 已提交
1586 1587 1588 1589 1590

        /* Version 3 fields */
        .incompatible_features  = cpu_to_be64(s->incompatible_features),
        .compatible_features    = cpu_to_be64(s->compatible_features),
        .autoclear_features     = cpu_to_be64(s->autoclear_features),
1591
        .refcount_order         = cpu_to_be32(s->refcount_order),
K
Kevin Wolf 已提交
1592
        .header_length          = cpu_to_be32(header_length),
K
Kevin Wolf 已提交
1593
    };
K
Kevin Wolf 已提交
1594

K
Kevin Wolf 已提交
1595 1596 1597 1598 1599 1600 1601 1602 1603
    /* For older versions, write a shorter header */
    switch (s->qcow_version) {
    case 2:
        ret = offsetof(QCowHeader, incompatible_features);
        break;
    case 3:
        ret = sizeof(*header);
        break;
    default:
1604 1605
        ret = -EINVAL;
        goto fail;
K
Kevin Wolf 已提交
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
    }

    buf += ret;
    buflen -= ret;
    memset(buf, 0, buflen);

    /* Preserve any unknown field in the header */
    if (s->unknown_header_fields_size) {
        if (buflen < s->unknown_header_fields_size) {
            ret = -ENOSPC;
            goto fail;
        }

        memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
        buf += s->unknown_header_fields_size;
        buflen -= s->unknown_header_fields_size;
    }
K
Kevin Wolf 已提交
1623

K
Kevin Wolf 已提交
1624 1625 1626 1627 1628 1629 1630
    /* Backing file format header extension */
    if (*bs->backing_format) {
        ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
                             bs->backing_format, strlen(bs->backing_format),
                             buflen);
        if (ret < 0) {
            goto fail;
K
Kevin Wolf 已提交
1631 1632
        }

K
Kevin Wolf 已提交
1633 1634
        buf += ret;
        buflen -= ret;
K
Kevin Wolf 已提交
1635 1636
    }

1637 1638
    /* Feature table */
    Qcow2Feature features[] = {
S
Stefan Hajnoczi 已提交
1639 1640 1641 1642 1643
        {
            .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
            .bit  = QCOW2_INCOMPAT_DIRTY_BITNR,
            .name = "dirty bit",
        },
M
Max Reitz 已提交
1644 1645 1646 1647 1648
        {
            .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
            .bit  = QCOW2_INCOMPAT_CORRUPT_BITNR,
            .name = "corrupt bit",
        },
1649 1650 1651 1652 1653
        {
            .type = QCOW2_FEAT_TYPE_COMPATIBLE,
            .bit  = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
            .name = "lazy refcounts",
        },
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
    };

    ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
                         features, sizeof(features), buflen);
    if (ret < 0) {
        goto fail;
    }
    buf += ret;
    buflen -= ret;

1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
    /* Keep unknown header extensions */
    QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
        ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
        if (ret < 0) {
            goto fail;
        }

        buf += ret;
        buflen -= ret;
    }

K
Kevin Wolf 已提交
1675 1676
    /* End of header extensions */
    ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
K
Kevin Wolf 已提交
1677 1678 1679 1680
    if (ret < 0) {
        goto fail;
    }

K
Kevin Wolf 已提交
1681 1682
    buf += ret;
    buflen -= ret;
K
Kevin Wolf 已提交
1683

K
Kevin Wolf 已提交
1684 1685 1686 1687 1688 1689 1690 1691 1692
    /* Backing file name */
    if (*bs->backing_file) {
        size_t backing_file_len = strlen(bs->backing_file);

        if (buflen < backing_file_len) {
            ret = -ENOSPC;
            goto fail;
        }

1693
        /* Using strncpy is ok here, since buf is not NUL-terminated. */
K
Kevin Wolf 已提交
1694 1695 1696 1697
        strncpy(buf, bs->backing_file, buflen);

        header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
        header->backing_file_size   = cpu_to_be32(backing_file_len);
K
Kevin Wolf 已提交
1698 1699
    }

K
Kevin Wolf 已提交
1700 1701
    /* Write the new header */
    ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
K
Kevin Wolf 已提交
1702 1703 1704 1705 1706 1707
    if (ret < 0) {
        goto fail;
    }

    ret = 0;
fail:
K
Kevin Wolf 已提交
1708
    qemu_vfree(header);
K
Kevin Wolf 已提交
1709 1710 1711 1712 1713 1714
    return ret;
}

static int qcow2_change_backing_file(BlockDriverState *bs,
    const char *backing_file, const char *backing_fmt)
{
K
Kevin Wolf 已提交
1715 1716 1717 1718
    pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
    pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");

    return qcow2_update_header(bs);
K
Kevin Wolf 已提交
1719 1720
}

K
Kevin Wolf 已提交
1721 1722 1723 1724
static int preallocate(BlockDriverState *bs)
{
    uint64_t nb_sectors;
    uint64_t offset;
K
Kevin Wolf 已提交
1725
    uint64_t host_offset = 0;
K
Kevin Wolf 已提交
1726
    int num;
1727
    int ret;
1728
    QCowL2Meta *meta;
K
Kevin Wolf 已提交
1729

1730
    nb_sectors = bdrv_nb_sectors(bs);
K
Kevin Wolf 已提交
1731 1732 1733
    offset = 0;

    while (nb_sectors) {
H
Hu Tao 已提交
1734
        num = MIN(nb_sectors, INT_MAX >> BDRV_SECTOR_BITS);
1735
        ret = qcow2_alloc_cluster_offset(bs, offset, &num,
K
Kevin Wolf 已提交
1736
                                         &host_offset, &meta);
1737
        if (ret < 0) {
1738
            return ret;
K
Kevin Wolf 已提交
1739 1740
        }

1741 1742 1743
        while (meta) {
            QCowL2Meta *next = meta->next;

H
Hu Tao 已提交
1744 1745 1746 1747 1748 1749 1750 1751 1752
            ret = qcow2_alloc_cluster_link_l2(bs, meta);
            if (ret < 0) {
                qcow2_free_any_clusters(bs, meta->alloc_offset,
                                        meta->nb_clusters, QCOW2_DISCARD_NEVER);
                return ret;
            }

            /* There are no dependent requests, but we need to remove our
             * request from the list of in-flight requests */
1753
            QLIST_REMOVE(meta, next_in_flight);
1754 1755 1756

            g_free(meta);
            meta = next;
1757
        }
1758

K
Kevin Wolf 已提交
1759 1760 1761
        /* TODO Preallocate data if requested */

        nb_sectors -= num;
H
Hu Tao 已提交
1762
        offset += num << BDRV_SECTOR_BITS;
K
Kevin Wolf 已提交
1763 1764 1765 1766 1767 1768 1769
    }

    /*
     * It is expected that the image file is large enough to actually contain
     * all of the allocated clusters (otherwise we get failing reads after
     * EOF). Extend the image to the last allocated sector.
     */
K
Kevin Wolf 已提交
1770
    if (host_offset != 0) {
H
Hu Tao 已提交
1771 1772 1773 1774
        uint8_t buf[BDRV_SECTOR_SIZE];
        memset(buf, 0, BDRV_SECTOR_SIZE);
        ret = bdrv_write(bs->file, (host_offset >> BDRV_SECTOR_BITS) + num - 1,
                         buf, 1);
1775 1776 1777
        if (ret < 0) {
            return ret;
        }
K
Kevin Wolf 已提交
1778 1779 1780 1781 1782
    }

    return 0;
}

1783 1784
static int qcow2_create2(const char *filename, int64_t total_size,
                         const char *backing_file, const char *backing_format,
1785
                         int flags, size_t cluster_size, PreallocMode prealloc,
1786
                         QemuOpts *opts, int version, int refcount_order,
M
Max Reitz 已提交
1787
                         Error **errp)
K
Kevin Wolf 已提交
1788
{
D
Dong Xu Wang 已提交
1789
    /* Calculate cluster_bits */
K
Kevin Wolf 已提交
1790 1791 1792 1793 1794
    int cluster_bits;
    cluster_bits = ffs(cluster_size) - 1;
    if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
        (1 << cluster_bits) != cluster_size)
    {
M
Max Reitz 已提交
1795 1796
        error_setg(errp, "Cluster size must be a power of two between %d and "
                   "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
K
Kevin Wolf 已提交
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
        return -EINVAL;
    }

    /*
     * Open the image file and write a minimal qcow2 header.
     *
     * We keep things simple and start with a zero-sized image. We also
     * do without refcount blocks or a L1 table for now. We'll fix the
     * inconsistency later.
     *
     * We do need a refcount table because growing the refcount table means
     * allocating two new refcount blocks - the seconds of which would be at
     * 2 GB for 64k clusters, and we don't want to have a 2 GB initial file
     * size for any qcow2 image.
     */
    BlockDriverState* bs;
1813
    QCowHeader *header;
1814
    uint64_t* refcount_table;
M
Max Reitz 已提交
1815
    Error *local_err = NULL;
K
Kevin Wolf 已提交
1816 1817
    int ret;

1818
    if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
1819 1820 1821 1822 1823
        /* Note: The following calculation does not need to be exact; if it is a
         * bit off, either some bytes will be "leaked" (which is fine) or we
         * will need to increase the file size by some bytes (which is fine,
         * too, as long as the bulk is allocated here). Therefore, using
         * floating point arithmetic is fine. */
1824 1825 1826
        int64_t meta_size = 0;
        uint64_t nreftablee, nrefblocke, nl1e, nl2e;
        int64_t aligned_total_size = align_offset(total_size, cluster_size);
1827 1828 1829 1830 1831 1832 1833
        int refblock_bits, refblock_size;
        /* refcount entry size in bytes */
        double rces = (1 << refcount_order) / 8.;

        /* see qcow2_open() */
        refblock_bits = cluster_bits - (refcount_order - 3);
        refblock_size = 1 << refblock_bits;
1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857

        /* header: 1 cluster */
        meta_size += cluster_size;

        /* total size of L2 tables */
        nl2e = aligned_total_size / cluster_size;
        nl2e = align_offset(nl2e, cluster_size / sizeof(uint64_t));
        meta_size += nl2e * sizeof(uint64_t);

        /* total size of L1 tables */
        nl1e = nl2e * sizeof(uint64_t) / cluster_size;
        nl1e = align_offset(nl1e, cluster_size / sizeof(uint64_t));
        meta_size += nl1e * sizeof(uint64_t);

        /* total size of refcount blocks
         *
         * note: every host cluster is reference-counted, including metadata
         * (even refcount blocks are recursively included).
         * Let:
         *   a = total_size (this is the guest disk size)
         *   m = meta size not including refcount blocks and refcount tables
         *   c = cluster size
         *   y1 = number of refcount blocks entries
         *   y2 = meta size including everything
1858
         *   rces = refcount entry size in bytes
1859 1860
         * then,
         *   y1 = (y2 + a)/c
1861
         *   y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m
1862
         * we can get y1:
1863
         *   y1 = (a + m) / (c - rces - rces * sizeof(u64) / c)
1864
         */
1865 1866 1867 1868
        nrefblocke = (aligned_total_size + meta_size + cluster_size)
                   / (cluster_size - rces - rces * sizeof(uint64_t)
                                                 / cluster_size);
        meta_size += DIV_ROUND_UP(nrefblocke, refblock_size) * cluster_size;
1869 1870

        /* total size of refcount tables */
1871
        nreftablee = nrefblocke / refblock_size;
1872 1873 1874 1875
        nreftablee = align_offset(nreftablee, cluster_size / sizeof(uint64_t));
        meta_size += nreftablee * sizeof(uint64_t);

        qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
1876
                            aligned_total_size + meta_size, &error_abort);
1877 1878
        qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_lookup[prealloc],
                     &error_abort);
1879 1880
    }

C
Chunyan Liu 已提交
1881
    ret = bdrv_create_file(filename, opts, &local_err);
K
Kevin Wolf 已提交
1882
    if (ret < 0) {
M
Max Reitz 已提交
1883
        error_propagate(errp, local_err);
K
Kevin Wolf 已提交
1884 1885 1886
        return ret;
    }

M
Max Reitz 已提交
1887 1888 1889
    bs = NULL;
    ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
                    NULL, &local_err);
K
Kevin Wolf 已提交
1890
    if (ret < 0) {
M
Max Reitz 已提交
1891
        error_propagate(errp, local_err);
K
Kevin Wolf 已提交
1892 1893 1894 1895
        return ret;
    }

    /* Write the header */
1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
    QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
    header = g_malloc0(cluster_size);
    *header = (QCowHeader) {
        .magic                      = cpu_to_be32(QCOW_MAGIC),
        .version                    = cpu_to_be32(version),
        .cluster_bits               = cpu_to_be32(cluster_bits),
        .size                       = cpu_to_be64(0),
        .l1_table_offset            = cpu_to_be64(0),
        .l1_size                    = cpu_to_be32(0),
        .refcount_table_offset      = cpu_to_be64(cluster_size),
        .refcount_table_clusters    = cpu_to_be32(1),
1907
        .refcount_order             = cpu_to_be32(refcount_order),
1908 1909
        .header_length              = cpu_to_be32(sizeof(*header)),
    };
K
Kevin Wolf 已提交
1910 1911

    if (flags & BLOCK_FLAG_ENCRYPT) {
1912
        header->crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
K
Kevin Wolf 已提交
1913
    } else {
1914
        header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
K
Kevin Wolf 已提交
1915 1916
    }

1917
    if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) {
1918
        header->compatible_features |=
1919 1920 1921
            cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
    }

1922 1923
    ret = bdrv_pwrite(bs, 0, header, cluster_size);
    g_free(header);
K
Kevin Wolf 已提交
1924
    if (ret < 0) {
M
Max Reitz 已提交
1925
        error_setg_errno(errp, -ret, "Could not write qcow2 header");
K
Kevin Wolf 已提交
1926 1927 1928
        goto out;
    }

1929 1930 1931 1932
    /* Write a refcount table with one refcount block */
    refcount_table = g_malloc0(2 * cluster_size);
    refcount_table[0] = cpu_to_be64(2 * cluster_size);
    ret = bdrv_pwrite(bs, cluster_size, refcount_table, 2 * cluster_size);
1933
    g_free(refcount_table);
K
Kevin Wolf 已提交
1934 1935

    if (ret < 0) {
M
Max Reitz 已提交
1936
        error_setg_errno(errp, -ret, "Could not write refcount table");
K
Kevin Wolf 已提交
1937 1938 1939
        goto out;
    }

1940 1941
    bdrv_unref(bs);
    bs = NULL;
K
Kevin Wolf 已提交
1942 1943 1944 1945 1946 1947

    /*
     * And now open the image and make it consistent first (i.e. increase the
     * refcount of the cluster that is occupied by the header and the refcount
     * table)
     */
1948
    ret = bdrv_open(&bs, filename, NULL, NULL,
1949 1950
                    BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH,
                    &bdrv_qcow2, &local_err);
K
Kevin Wolf 已提交
1951
    if (ret < 0) {
M
Max Reitz 已提交
1952
        error_propagate(errp, local_err);
K
Kevin Wolf 已提交
1953 1954 1955
        goto out;
    }

1956
    ret = qcow2_alloc_clusters(bs, 3 * cluster_size);
K
Kevin Wolf 已提交
1957
    if (ret < 0) {
M
Max Reitz 已提交
1958 1959
        error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
                         "header and refcount table");
K
Kevin Wolf 已提交
1960 1961 1962 1963 1964 1965 1966 1967
        goto out;

    } else if (ret != 0) {
        error_report("Huh, first cluster in empty image is already in use?");
        abort();
    }

    /* Okay, now that we have a valid image, let's give it the right size */
1968
    ret = bdrv_truncate(bs, total_size);
K
Kevin Wolf 已提交
1969
    if (ret < 0) {
M
Max Reitz 已提交
1970
        error_setg_errno(errp, -ret, "Could not resize image");
K
Kevin Wolf 已提交
1971 1972 1973 1974 1975 1976 1977
        goto out;
    }

    /* Want a backing file? There you go.*/
    if (backing_file) {
        ret = bdrv_change_backing_file(bs, backing_file, backing_format);
        if (ret < 0) {
M
Max Reitz 已提交
1978 1979
            error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
                             "with format '%s'", backing_file, backing_format);
K
Kevin Wolf 已提交
1980 1981 1982 1983 1984
            goto out;
        }
    }

    /* And if we're supposed to preallocate metadata, do that now */
1985
    if (prealloc != PREALLOC_MODE_OFF) {
Z
Zhi Yong Wu 已提交
1986 1987
        BDRVQcowState *s = bs->opaque;
        qemu_co_mutex_lock(&s->lock);
K
Kevin Wolf 已提交
1988
        ret = preallocate(bs);
Z
Zhi Yong Wu 已提交
1989
        qemu_co_mutex_unlock(&s->lock);
K
Kevin Wolf 已提交
1990
        if (ret < 0) {
M
Max Reitz 已提交
1991
            error_setg_errno(errp, -ret, "Could not preallocate metadata");
K
Kevin Wolf 已提交
1992 1993 1994 1995
            goto out;
        }
    }

1996 1997
    bdrv_unref(bs);
    bs = NULL;
M
Max Reitz 已提交
1998 1999

    /* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
2000
    ret = bdrv_open(&bs, filename, NULL, NULL,
2001
                    BDRV_O_RDWR | BDRV_O_CACHE_WB | BDRV_O_NO_BACKING,
2002
                    &bdrv_qcow2, &local_err);
2003
    if (local_err) {
M
Max Reitz 已提交
2004 2005 2006 2007
        error_propagate(errp, local_err);
        goto out;
    }

K
Kevin Wolf 已提交
2008 2009
    ret = 0;
out:
2010 2011 2012
    if (bs) {
        bdrv_unref(bs);
    }
K
Kevin Wolf 已提交
2013 2014
    return ret;
}
K
Kevin Wolf 已提交
2015

2016
static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
K
Kevin Wolf 已提交
2017
{
2018 2019 2020
    char *backing_file = NULL;
    char *backing_fmt = NULL;
    char *buf = NULL;
2021
    uint64_t size = 0;
K
Kevin Wolf 已提交
2022
    int flags = 0;
2023
    size_t cluster_size = DEFAULT_CLUSTER_SIZE;
2024
    PreallocMode prealloc;
2025
    int version = 3;
2026 2027
    uint64_t refcount_bits = 16;
    int refcount_order;
M
Max Reitz 已提交
2028 2029
    Error *local_err = NULL;
    int ret;
K
Kevin Wolf 已提交
2030 2031

    /* Read out options */
2032 2033
    size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                    BDRV_SECTOR_SIZE);
2034 2035 2036 2037 2038 2039 2040 2041
    backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
    backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT);
    if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
        flags |= BLOCK_FLAG_ENCRYPT;
    }
    cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
                                         DEFAULT_CLUSTER_SIZE);
    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2042 2043 2044 2045 2046
    prealloc = qapi_enum_parse(PreallocMode_lookup, buf,
                               PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,
                               &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
        ret = -EINVAL;
        goto finish;
    }
    g_free(buf);
    buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
    if (!buf) {
        /* keep the default */
    } else if (!strcmp(buf, "0.10")) {
        version = 2;
    } else if (!strcmp(buf, "1.1")) {
        version = 3;
    } else {
        error_setg(errp, "Invalid compatibility level: '%s'", buf);
        ret = -EINVAL;
        goto finish;
    }

    if (qemu_opt_get_bool_del(opts, BLOCK_OPT_LAZY_REFCOUNTS, false)) {
        flags |= BLOCK_FLAG_LAZY_REFCOUNTS;
K
Kevin Wolf 已提交
2066 2067
    }

2068
    if (backing_file && prealloc != PREALLOC_MODE_OFF) {
M
Max Reitz 已提交
2069 2070
        error_setg(errp, "Backing file and preallocation cannot be used at "
                   "the same time");
2071 2072
        ret = -EINVAL;
        goto finish;
K
Kevin Wolf 已提交
2073 2074
    }

2075
    if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) {
M
Max Reitz 已提交
2076 2077
        error_setg(errp, "Lazy refcounts only supported with compatibility "
                   "level 1.1 and above (use compat=1.1 or greater)");
2078 2079
        ret = -EINVAL;
        goto finish;
2080 2081
    }

2082 2083 2084 2085 2086 2087 2088 2089 2090
    refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS,
                                            refcount_bits);
    if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
        error_setg(errp, "Refcount width must be a power of two and may not "
                   "exceed 64 bits");
        ret = -EINVAL;
        goto finish;
    }

2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
    if (version < 3 && refcount_bits != 16) {
        error_setg(errp, "Different refcount widths than 16 bits require "
                   "compatibility level 1.1 or above (use compat=1.1 or "
                   "greater)");
        ret = -EINVAL;
        goto finish;
    }

    refcount_order = ffs(refcount_bits) - 1;

2101
    ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags,
2102 2103
                        cluster_size, prealloc, opts, version, refcount_order,
                        &local_err);
2104
    if (local_err) {
M
Max Reitz 已提交
2105 2106
        error_propagate(errp, local_err);
    }
2107 2108 2109 2110 2111

finish:
    g_free(backing_file);
    g_free(backing_fmt);
    g_free(buf);
M
Max Reitz 已提交
2112
    return ret;
K
Kevin Wolf 已提交
2113 2114
}

K
Kevin Wolf 已提交
2115
static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs,
2116
    int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
K
Kevin Wolf 已提交
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
{
    int ret;
    BDRVQcowState *s = bs->opaque;

    /* Emulate misaligned zero writes */
    if (sector_num % s->cluster_sectors || nb_sectors % s->cluster_sectors) {
        return -ENOTSUP;
    }

    /* Whatever is left can use real zero clusters */
    qemu_co_mutex_lock(&s->lock);
    ret = qcow2_zero_clusters(bs, sector_num << BDRV_SECTOR_BITS,
        nb_sectors);
    qemu_co_mutex_unlock(&s->lock);

    return ret;
}

2135 2136
static coroutine_fn int qcow2_co_discard(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors)
K
Kevin Wolf 已提交
2137
{
2138 2139 2140 2141 2142
    int ret;
    BDRVQcowState *s = bs->opaque;

    qemu_co_mutex_lock(&s->lock);
    ret = qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS,
M
Max Reitz 已提交
2143
        nb_sectors, QCOW2_DISCARD_REQUEST, false);
2144 2145
    qemu_co_mutex_unlock(&s->lock);
    return ret;
K
Kevin Wolf 已提交
2146 2147
}

2148 2149 2150
static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
{
    BDRVQcowState *s = bs->opaque;
2151 2152
    int64_t new_l1_size;
    int ret;
2153 2154

    if (offset & 511) {
2155
        error_report("The new size must be a multiple of 512");
2156 2157 2158 2159 2160
        return -EINVAL;
    }

    /* cannot proceed if image has snapshots */
    if (s->nb_snapshots) {
2161
        error_report("Can't resize an image which has snapshots");
2162 2163 2164 2165 2166
        return -ENOTSUP;
    }

    /* shrinking is currently not supported */
    if (offset < bs->total_sectors * 512) {
2167
        error_report("qcow2 doesn't support shrinking images yet");
2168 2169 2170 2171
        return -ENOTSUP;
    }

    new_l1_size = size_to_l1(s, offset);
2172
    ret = qcow2_grow_l1_table(bs, new_l1_size, true);
2173 2174 2175 2176 2177 2178
    if (ret < 0) {
        return ret;
    }

    /* write updated header.size */
    offset = cpu_to_be64(offset);
2179 2180
    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
                           &offset, sizeof(uint64_t));
2181 2182 2183 2184 2185 2186 2187 2188
    if (ret < 0) {
        return ret;
    }

    s->l1_vm_state_index = new_l1_size;
    return 0;
}

B
Blue Swirl 已提交
2189 2190
/* XXX: put compressed sectors first, then all the cluster aligned
   tables to avoid losing bytes in alignment */
2191 2192
static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
                                  const uint8_t *buf, int nb_sectors)
B
Blue Swirl 已提交
2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
{
    BDRVQcowState *s = bs->opaque;
    z_stream strm;
    int ret, out_len;
    uint8_t *out_buf;
    uint64_t cluster_offset;

    if (nb_sectors == 0) {
        /* align end of file to a sector boundary to ease reading with
           sector based I/Os */
2203
        cluster_offset = bdrv_getlength(bs->file);
M
Max Reitz 已提交
2204
        return bdrv_truncate(bs->file, cluster_offset);
B
Blue Swirl 已提交
2205 2206
    }

2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
    if (nb_sectors != s->cluster_sectors) {
        ret = -EINVAL;

        /* Zero-pad last write if image size is not cluster aligned */
        if (sector_num + nb_sectors == bs->total_sectors &&
            nb_sectors < s->cluster_sectors) {
            uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size);
            memset(pad_buf, 0, s->cluster_size);
            memcpy(pad_buf, buf, nb_sectors * BDRV_SECTOR_SIZE);
            ret = qcow2_write_compressed(bs, sector_num,
                                         pad_buf, s->cluster_sectors);
            qemu_vfree(pad_buf);
        }
        return ret;
    }
B
Blue Swirl 已提交
2222

2223
    out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
B
Blue Swirl 已提交
2224 2225 2226 2227 2228 2229 2230

    /* best compression, small window, no zlib header */
    memset(&strm, 0, sizeof(strm));
    ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
                       Z_DEFLATED, -12,
                       9, Z_DEFAULT_STRATEGY);
    if (ret != 0) {
2231 2232
        ret = -EINVAL;
        goto fail;
B
Blue Swirl 已提交
2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
    }

    strm.avail_in = s->cluster_size;
    strm.next_in = (uint8_t *)buf;
    strm.avail_out = s->cluster_size;
    strm.next_out = out_buf;

    ret = deflate(&strm, Z_FINISH);
    if (ret != Z_STREAM_END && ret != Z_OK) {
        deflateEnd(&strm);
2243 2244
        ret = -EINVAL;
        goto fail;
B
Blue Swirl 已提交
2245 2246 2247 2248 2249 2250 2251
    }
    out_len = strm.next_out - out_buf;

    deflateEnd(&strm);

    if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
        /* could not compress: write normal cluster */
2252 2253 2254 2255
        ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
        if (ret < 0) {
            goto fail;
        }
B
Blue Swirl 已提交
2256 2257 2258
    } else {
        cluster_offset = qcow2_alloc_compressed_cluster_offset(bs,
            sector_num << 9, out_len);
2259 2260 2261 2262
        if (!cluster_offset) {
            ret = -EIO;
            goto fail;
        }
B
Blue Swirl 已提交
2263
        cluster_offset &= s->cluster_offset_mask;
2264

M
Max Reitz 已提交
2265
        ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len);
2266 2267 2268 2269
        if (ret < 0) {
            goto fail;
        }

2270
        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
2271 2272 2273
        ret = bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len);
        if (ret < 0) {
            goto fail;
B
Blue Swirl 已提交
2274 2275 2276
        }
    }

2277 2278
    ret = 0;
fail:
2279
    g_free(out_buf);
2280
    return ret;
B
Blue Swirl 已提交
2281 2282
}

M
Max Reitz 已提交
2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430
static int make_completely_empty(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;
    int ret, l1_clusters;
    int64_t offset;
    uint64_t *new_reftable = NULL;
    uint64_t rt_entry, l1_size2;
    struct {
        uint64_t l1_offset;
        uint64_t reftable_offset;
        uint32_t reftable_clusters;
    } QEMU_PACKED l1_ofs_rt_ofs_cls;

    ret = qcow2_cache_empty(bs, s->l2_table_cache);
    if (ret < 0) {
        goto fail;
    }

    ret = qcow2_cache_empty(bs, s->refcount_block_cache);
    if (ret < 0) {
        goto fail;
    }

    /* Refcounts will be broken utterly */
    ret = qcow2_mark_dirty(bs);
    if (ret < 0) {
        goto fail;
    }

    BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);

    l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));
    l1_size2 = (uint64_t)s->l1_size * sizeof(uint64_t);

    /* After this call, neither the in-memory nor the on-disk refcount
     * information accurately describe the actual references */

    ret = bdrv_write_zeroes(bs->file, s->l1_table_offset / BDRV_SECTOR_SIZE,
                            l1_clusters * s->cluster_sectors, 0);
    if (ret < 0) {
        goto fail_broken_refcounts;
    }
    memset(s->l1_table, 0, l1_size2);

    BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);

    /* Overwrite enough clusters at the beginning of the sectors to place
     * the refcount table, a refcount block and the L1 table in; this may
     * overwrite parts of the existing refcount and L1 table, which is not
     * an issue because the dirty flag is set, complete data loss is in fact
     * desired and partial data loss is consequently fine as well */
    ret = bdrv_write_zeroes(bs->file, s->cluster_size / BDRV_SECTOR_SIZE,
                            (2 + l1_clusters) * s->cluster_size /
                            BDRV_SECTOR_SIZE, 0);
    /* This call (even if it failed overall) may have overwritten on-disk
     * refcount structures; in that case, the in-memory refcount information
     * will probably differ from the on-disk information which makes the BDS
     * unusable */
    if (ret < 0) {
        goto fail_broken_refcounts;
    }

    BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
    BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);

    /* "Create" an empty reftable (one cluster) directly after the image
     * header and an empty L1 table three clusters after the image header;
     * the cluster between those two will be used as the first refblock */
    cpu_to_be64w(&l1_ofs_rt_ofs_cls.l1_offset, 3 * s->cluster_size);
    cpu_to_be64w(&l1_ofs_rt_ofs_cls.reftable_offset, s->cluster_size);
    cpu_to_be32w(&l1_ofs_rt_ofs_cls.reftable_clusters, 1);
    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
                           &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
    if (ret < 0) {
        goto fail_broken_refcounts;
    }

    s->l1_table_offset = 3 * s->cluster_size;

    new_reftable = g_try_new0(uint64_t, s->cluster_size / sizeof(uint64_t));
    if (!new_reftable) {
        ret = -ENOMEM;
        goto fail_broken_refcounts;
    }

    s->refcount_table_offset = s->cluster_size;
    s->refcount_table_size   = s->cluster_size / sizeof(uint64_t);

    g_free(s->refcount_table);
    s->refcount_table = new_reftable;
    new_reftable = NULL;

    /* Now the in-memory refcount information again corresponds to the on-disk
     * information (reftable is empty and no refblocks (the refblock cache is
     * empty)); however, this means some clusters (e.g. the image header) are
     * referenced, but not refcounted, but the normal qcow2 code assumes that
     * the in-memory information is always correct */

    BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);

    /* Enter the first refblock into the reftable */
    rt_entry = cpu_to_be64(2 * s->cluster_size);
    ret = bdrv_pwrite_sync(bs->file, s->cluster_size,
                           &rt_entry, sizeof(rt_entry));
    if (ret < 0) {
        goto fail_broken_refcounts;
    }
    s->refcount_table[0] = 2 * s->cluster_size;

    s->free_cluster_index = 0;
    assert(3 + l1_clusters <= s->refcount_block_size);
    offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2);
    if (offset < 0) {
        ret = offset;
        goto fail_broken_refcounts;
    } else if (offset > 0) {
        error_report("First cluster in emptied image is in use");
        abort();
    }

    /* Now finally the in-memory information corresponds to the on-disk
     * structures and is correct */
    ret = qcow2_mark_clean(bs);
    if (ret < 0) {
        goto fail;
    }

    ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size);
    if (ret < 0) {
        goto fail;
    }

    return 0;

fail_broken_refcounts:
    /* The BDS is unusable at this point. If we wanted to make it usable, we
     * would have to call qcow2_refcount_close(), qcow2_refcount_init(),
     * qcow2_check_refcounts(), qcow2_refcount_close() and qcow2_refcount_init()
     * again. However, because the functions which could have caused this error
     * path to be taken are used by those functions as well, it's very likely
     * that that sequence will fail as well. Therefore, just eject the BDS. */
    bs->drv = NULL;

fail:
    g_free(new_reftable);
    return ret;
}

M
Max Reitz 已提交
2431 2432
static int qcow2_make_empty(BlockDriverState *bs)
{
M
Max Reitz 已提交
2433
    BDRVQcowState *s = bs->opaque;
M
Max Reitz 已提交
2434 2435
    uint64_t start_sector;
    int sector_step = INT_MAX / BDRV_SECTOR_SIZE;
M
Max Reitz 已提交
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448
    int l1_clusters, ret = 0;

    l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / sizeof(uint64_t));

    if (s->qcow_version >= 3 && !s->snapshots &&
        3 + l1_clusters <= s->refcount_block_size) {
        /* The following function only works for qcow2 v3 images (it requires
         * the dirty flag) and only as long as there are no snapshots (because
         * it completely empties the image). Furthermore, the L1 table and three
         * additional clusters (image header, refcount table, one refcount
         * block) have to fit inside one refcount block. */
        return make_completely_empty(bs);
    }
M
Max Reitz 已提交
2449

M
Max Reitz 已提交
2450 2451
    /* This fallback code simply discards every active cluster; this is slow,
     * but works in all cases */
M
Max Reitz 已提交
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
    for (start_sector = 0; start_sector < bs->total_sectors;
         start_sector += sector_step)
    {
        /* As this function is generally used after committing an external
         * snapshot, QCOW2_DISCARD_SNAPSHOT seems appropriate. Also, the
         * default action for this kind of discard is to pass the discard,
         * which will ideally result in an actually smaller image file, as
         * is probably desired. */
        ret = qcow2_discard_clusters(bs, start_sector * BDRV_SECTOR_SIZE,
                                     MIN(sector_step,
                                         bs->total_sectors - start_sector),
                                     QCOW2_DISCARD_SNAPSHOT, true);
        if (ret < 0) {
            break;
        }
    }

    return ret;
}

2472
static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
B
Blue Swirl 已提交
2473
{
K
Kevin Wolf 已提交
2474 2475 2476
    BDRVQcowState *s = bs->opaque;
    int ret;

P
Paolo Bonzini 已提交
2477
    qemu_co_mutex_lock(&s->lock);
K
Kevin Wolf 已提交
2478 2479
    ret = qcow2_cache_flush(bs, s->l2_table_cache);
    if (ret < 0) {
D
Dong Xu Wang 已提交
2480
        qemu_co_mutex_unlock(&s->lock);
P
Paolo Bonzini 已提交
2481
        return ret;
K
Kevin Wolf 已提交
2482 2483
    }

2484 2485 2486 2487 2488 2489
    if (qcow2_need_accurate_refcounts(s)) {
        ret = qcow2_cache_flush(bs, s->refcount_block_cache);
        if (ret < 0) {
            qemu_co_mutex_unlock(&s->lock);
            return ret;
        }
K
Kevin Wolf 已提交
2490
    }
P
Paolo Bonzini 已提交
2491
    qemu_co_mutex_unlock(&s->lock);
K
Kevin Wolf 已提交
2492

K
Kevin Wolf 已提交
2493 2494 2495
    return 0;
}

2496
static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
B
Blue Swirl 已提交
2497 2498
{
    BDRVQcowState *s = bs->opaque;
2499 2500
    bdi->unallocated_blocks_are_zero = true;
    bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3);
B
Blue Swirl 已提交
2501
    bdi->cluster_size = s->cluster_size;
2502
    bdi->vm_state_offset = qcow2_vm_state_offset(s);
B
Blue Swirl 已提交
2503 2504 2505
    return 0;
}

2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;
    ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);

    *spec_info = (ImageInfoSpecific){
        .kind  = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
        {
            .qcow2 = g_new(ImageInfoSpecificQCow2, 1),
        },
    };
    if (s->qcow_version == 2) {
        *spec_info->qcow2 = (ImageInfoSpecificQCow2){
2519 2520
            .compat             = g_strdup("0.10"),
            .refcount_bits      = s->refcount_bits,
2521 2522 2523 2524 2525 2526 2527
        };
    } else if (s->qcow_version == 3) {
        *spec_info->qcow2 = (ImageInfoSpecificQCow2){
            .compat             = g_strdup("1.1"),
            .lazy_refcounts     = s->compatible_features &
                                  QCOW2_COMPAT_LAZY_REFCOUNTS,
            .has_lazy_refcounts = true,
2528 2529 2530
            .corrupt            = s->incompatible_features &
                                  QCOW2_INCOMPAT_CORRUPT,
            .has_corrupt        = true,
2531
            .refcount_bits      = s->refcount_bits,
2532 2533 2534 2535 2536 2537
        };
    }

    return spec_info;
}

B
Blue Swirl 已提交
2538 2539 2540 2541 2542 2543 2544
#if 0
static void dump_refcounts(BlockDriverState *bs)
{
    BDRVQcowState *s = bs->opaque;
    int64_t nb_clusters, k, k1, size;
    int refcount;

2545
    size = bdrv_getlength(bs->file);
B
Blue Swirl 已提交
2546 2547 2548 2549 2550 2551 2552
    nb_clusters = size_to_clusters(s, size);
    for(k = 0; k < nb_clusters;) {
        k1 = k;
        refcount = get_refcount(bs, k);
        k++;
        while (k < nb_clusters && get_refcount(bs, k) == refcount)
            k++;
B
Blue Swirl 已提交
2553 2554
        printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount,
               k - k1);
B
Blue Swirl 已提交
2555 2556 2557 2558
    }
}
#endif

2559 2560
static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
                              int64_t pos)
B
Blue Swirl 已提交
2561 2562
{
    BDRVQcowState *s = bs->opaque;
2563
    int64_t total_sectors = bs->total_sectors;
2564
    bool zero_beyond_eof = bs->zero_beyond_eof;
B
Blue Swirl 已提交
2565 2566
    int ret;

2567
    BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
2568
    bs->zero_beyond_eof = false;
2569
    ret = bdrv_pwritev(bs, qcow2_vm_state_offset(s) + pos, qiov);
2570
    bs->zero_beyond_eof = zero_beyond_eof;
B
Blue Swirl 已提交
2571

2572 2573 2574 2575 2576
    /* bdrv_co_do_writev will have increased the total_sectors value to include
     * the VM state - the VM state is however not an actual part of the block
     * device, therefore, we need to restore the old value. */
    bs->total_sectors = total_sectors;

B
Blue Swirl 已提交
2577 2578 2579
    return ret;
}

2580 2581
static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                              int64_t pos, int size)
B
Blue Swirl 已提交
2582 2583
{
    BDRVQcowState *s = bs->opaque;
A
Asias He 已提交
2584
    bool zero_beyond_eof = bs->zero_beyond_eof;
B
Blue Swirl 已提交
2585 2586
    int ret;

2587
    BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
A
Asias He 已提交
2588
    bs->zero_beyond_eof = false;
2589
    ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size);
A
Asias He 已提交
2590
    bs->zero_beyond_eof = zero_beyond_eof;
B
Blue Swirl 已提交
2591 2592 2593 2594

    return ret;
}

M
Max Reitz 已提交
2595 2596 2597 2598
/*
 * Downgrades an image's version. To achieve this, any incompatible features
 * have to be removed.
 */
2599 2600
static int qcow2_downgrade(BlockDriverState *bs, int target_version,
                           BlockDriverAmendStatusCB *status_cb)
M
Max Reitz 已提交
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619
{
    BDRVQcowState *s = bs->opaque;
    int current_version = s->qcow_version;
    int ret;

    if (target_version == current_version) {
        return 0;
    } else if (target_version > current_version) {
        return -EINVAL;
    } else if (target_version != 2) {
        return -EINVAL;
    }

    if (s->refcount_order != 4) {
        /* we would have to convert the image to a refcount_order == 4 image
         * here; however, since qemu (at the time of writing this) does not
         * support anything different than 4 anyway, there is no point in doing
         * so right now; however, we should error out (if qemu supports this in
         * the future and this code has not been adapted) */
2620
        error_report("qcow2_downgrade: Image refcount orders other than 4 are "
M
Max Reitz 已提交
2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648
                     "currently not supported.");
        return -ENOTSUP;
    }

    /* clear incompatible features */
    if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
        ret = qcow2_mark_clean(bs);
        if (ret < 0) {
            return ret;
        }
    }

    /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in
     * the first place; if that happens nonetheless, returning -ENOTSUP is the
     * best thing to do anyway */

    if (s->incompatible_features) {
        return -ENOTSUP;
    }

    /* since we can ignore compatible features, we can set them to 0 as well */
    s->compatible_features = 0;
    /* if lazy refcounts have been used, they have already been fixed through
     * clearing the dirty flag */

    /* clearing autoclear features is trivial */
    s->autoclear_features = 0;

2649
    ret = qcow2_expand_zero_clusters(bs, status_cb);
M
Max Reitz 已提交
2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
    if (ret < 0) {
        return ret;
    }

    s->qcow_version = target_version;
    ret = qcow2_update_header(bs);
    if (ret < 0) {
        s->qcow_version = current_version;
        return ret;
    }
    return 0;
}

2663 2664
static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
                               BlockDriverAmendStatusCB *status_cb)
M
Max Reitz 已提交
2665 2666 2667 2668 2669 2670
{
    BDRVQcowState *s = bs->opaque;
    int old_version = s->qcow_version, new_version = old_version;
    uint64_t new_size = 0;
    const char *backing_file = NULL, *backing_format = NULL;
    bool lazy_refcounts = s->use_lazy_refcounts;
2671 2672 2673
    const char *compat = NULL;
    uint64_t cluster_size = s->cluster_size;
    bool encrypt;
M
Max Reitz 已提交
2674
    int ret;
2675
    QemuOptDesc *desc = opts->list->desc;
M
Max Reitz 已提交
2676

2677 2678
    while (desc && desc->name) {
        if (!qemu_opt_find(opts, desc->name)) {
M
Max Reitz 已提交
2679
            /* only change explicitly defined options */
2680
            desc++;
M
Max Reitz 已提交
2681 2682 2683
            continue;
        }

2684 2685
        if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
            compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
2686
            if (!compat) {
M
Max Reitz 已提交
2687
                /* preserve default */
2688
            } else if (!strcmp(compat, "0.10")) {
M
Max Reitz 已提交
2689
                new_version = 2;
2690
            } else if (!strcmp(compat, "1.1")) {
M
Max Reitz 已提交
2691 2692
                new_version = 3;
            } else {
2693
                fprintf(stderr, "Unknown compatibility level %s.\n", compat);
M
Max Reitz 已提交
2694 2695
                return -EINVAL;
            }
2696
        } else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) {
M
Max Reitz 已提交
2697 2698
            fprintf(stderr, "Cannot change preallocation mode.\n");
            return -ENOTSUP;
2699 2700 2701 2702 2703 2704 2705 2706 2707
        } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) {
            new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
        } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) {
            backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
        } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) {
            backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
        } else if (!strcmp(desc->name, BLOCK_OPT_ENCRYPT)) {
            encrypt = qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT,
                                        s->crypt_method);
2708
            if (encrypt != !!s->crypt_method) {
M
Max Reitz 已提交
2709 2710 2711 2712
                fprintf(stderr, "Changing the encryption flag is not "
                        "supported.\n");
                return -ENOTSUP;
            }
2713 2714
        } else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) {
            cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE,
2715 2716
                                             cluster_size);
            if (cluster_size != s->cluster_size) {
M
Max Reitz 已提交
2717 2718 2719 2720
                fprintf(stderr, "Changing the cluster size is not "
                        "supported.\n");
                return -ENOTSUP;
            }
2721 2722
        } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
            lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
2723
                                               lazy_refcounts);
2724 2725 2726
        } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
            error_report("Cannot change refcount entry width");
            return -ENOTSUP;
M
Max Reitz 已提交
2727 2728 2729 2730 2731
        } else {
            /* if this assertion fails, this probably means a new option was
             * added without having it covered here */
            assert(false);
        }
2732 2733

        desc++;
M
Max Reitz 已提交
2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745
    }

    if (new_version != old_version) {
        if (new_version > old_version) {
            /* Upgrade */
            s->qcow_version = new_version;
            ret = qcow2_update_header(bs);
            if (ret < 0) {
                s->qcow_version = old_version;
                return ret;
            }
        } else {
2746
            ret = qcow2_downgrade(bs, new_version, status_cb);
M
Max Reitz 已提交
2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801
            if (ret < 0) {
                return ret;
            }
        }
    }

    if (backing_file || backing_format) {
        ret = qcow2_change_backing_file(bs, backing_file ?: bs->backing_file,
                                        backing_format ?: bs->backing_format);
        if (ret < 0) {
            return ret;
        }
    }

    if (s->use_lazy_refcounts != lazy_refcounts) {
        if (lazy_refcounts) {
            if (s->qcow_version < 3) {
                fprintf(stderr, "Lazy refcounts only supported with compatibility "
                        "level 1.1 and above (use compat=1.1 or greater)\n");
                return -EINVAL;
            }
            s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
            ret = qcow2_update_header(bs);
            if (ret < 0) {
                s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
                return ret;
            }
            s->use_lazy_refcounts = true;
        } else {
            /* make image clean first */
            ret = qcow2_mark_clean(bs);
            if (ret < 0) {
                return ret;
            }
            /* now disallow lazy refcounts */
            s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
            ret = qcow2_update_header(bs);
            if (ret < 0) {
                s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
                return ret;
            }
            s->use_lazy_refcounts = false;
        }
    }

    if (new_size) {
        ret = bdrv_truncate(bs, new_size);
        if (ret < 0) {
            return ret;
        }
    }

    return 0;
}

M
Max Reitz 已提交
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847
/*
 * If offset or size are negative, respectively, they will not be included in
 * the BLOCK_IMAGE_CORRUPTED event emitted.
 * fatal will be ignored for read-only BDS; corruptions found there will always
 * be considered non-fatal.
 */
void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
                             int64_t size, const char *message_format, ...)
{
    BDRVQcowState *s = bs->opaque;
    char *message;
    va_list ap;

    fatal = fatal && !bs->read_only;

    if (s->signaled_corruption &&
        (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT)))
    {
        return;
    }

    va_start(ap, message_format);
    message = g_strdup_vprintf(message_format, ap);
    va_end(ap);

    if (fatal) {
        fprintf(stderr, "qcow2: Marking image as corrupt: %s; further "
                "corruption events will be suppressed\n", message);
    } else {
        fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal "
                "corruption events will be suppressed\n", message);
    }

    qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs), message,
                                          offset >= 0, offset, size >= 0, size,
                                          fatal, &error_abort);
    g_free(message);

    if (fatal) {
        qcow2_mark_corrupt(bs);
        bs->drv = NULL; /* make BDS unusable */
    }

    s->signaled_corruption = true;
}

2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886
static QemuOptsList qcow2_create_opts = {
    .name = "qcow2-create-opts",
    .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
    .desc = {
        {
            .name = BLOCK_OPT_SIZE,
            .type = QEMU_OPT_SIZE,
            .help = "Virtual disk size"
        },
        {
            .name = BLOCK_OPT_COMPAT_LEVEL,
            .type = QEMU_OPT_STRING,
            .help = "Compatibility level (0.10 or 1.1)"
        },
        {
            .name = BLOCK_OPT_BACKING_FILE,
            .type = QEMU_OPT_STRING,
            .help = "File name of a base image"
        },
        {
            .name = BLOCK_OPT_BACKING_FMT,
            .type = QEMU_OPT_STRING,
            .help = "Image format of the base image"
        },
        {
            .name = BLOCK_OPT_ENCRYPT,
            .type = QEMU_OPT_BOOL,
            .help = "Encrypt the image",
            .def_value_str = "off"
        },
        {
            .name = BLOCK_OPT_CLUSTER_SIZE,
            .type = QEMU_OPT_SIZE,
            .help = "qcow2 cluster size",
            .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
        },
        {
            .name = BLOCK_OPT_PREALLOC,
            .type = QEMU_OPT_STRING,
2887 2888
            .help = "Preallocation mode (allowed values: off, metadata, "
                    "falloc, full)"
2889 2890 2891 2892 2893 2894 2895
        },
        {
            .name = BLOCK_OPT_LAZY_REFCOUNTS,
            .type = QEMU_OPT_BOOL,
            .help = "Postpone refcount updates",
            .def_value_str = "off"
        },
2896 2897 2898 2899 2900 2901
        {
            .name = BLOCK_OPT_REFCOUNT_BITS,
            .type = QEMU_OPT_NUMBER,
            .help = "Width of a reference count entry in bits",
            .def_value_str = "16"
        },
2902 2903
        { /* end of list */ }
    }
B
Blue Swirl 已提交
2904 2905
};

2906
BlockDriver bdrv_qcow2 = {
2907 2908 2909 2910 2911
    .format_name        = "qcow2",
    .instance_size      = sizeof(BDRVQcowState),
    .bdrv_probe         = qcow2_probe,
    .bdrv_open          = qcow2_open,
    .bdrv_close         = qcow2_close,
J
Jeff Cody 已提交
2912
    .bdrv_reopen_prepare  = qcow2_reopen_prepare,
C
Chunyan Liu 已提交
2913
    .bdrv_create        = qcow2_create,
2914
    .bdrv_has_zero_init = bdrv_has_zero_init_1,
2915
    .bdrv_co_get_block_status = qcow2_co_get_block_status,
2916 2917
    .bdrv_set_key       = qcow2_set_key,

2918 2919
    .bdrv_co_readv          = qcow2_co_readv,
    .bdrv_co_writev         = qcow2_co_writev,
K
Kevin Wolf 已提交
2920
    .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
2921

K
Kevin Wolf 已提交
2922
    .bdrv_co_write_zeroes   = qcow2_co_write_zeroes,
2923
    .bdrv_co_discard        = qcow2_co_discard,
2924
    .bdrv_truncate          = qcow2_truncate,
2925
    .bdrv_write_compressed  = qcow2_write_compressed,
M
Max Reitz 已提交
2926
    .bdrv_make_empty        = qcow2_make_empty,
B
Blue Swirl 已提交
2927 2928 2929 2930 2931

    .bdrv_snapshot_create   = qcow2_snapshot_create,
    .bdrv_snapshot_goto     = qcow2_snapshot_goto,
    .bdrv_snapshot_delete   = qcow2_snapshot_delete,
    .bdrv_snapshot_list     = qcow2_snapshot_list,
2932 2933
    .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
    .bdrv_get_info          = qcow2_get_info,
2934
    .bdrv_get_specific_info = qcow2_get_specific_info,
B
Blue Swirl 已提交
2935

2936 2937
    .bdrv_save_vmstate    = qcow2_save_vmstate,
    .bdrv_load_vmstate    = qcow2_load_vmstate,
B
Blue Swirl 已提交
2938

2939
    .supports_backing           = true,
B
Blue Swirl 已提交
2940 2941
    .bdrv_change_backing_file   = qcow2_change_backing_file,

2942
    .bdrv_refresh_limits        = qcow2_refresh_limits,
2943 2944
    .bdrv_invalidate_cache      = qcow2_invalidate_cache,

2945 2946
    .create_opts         = &qcow2_create_opts,
    .bdrv_check          = qcow2_check,
C
Chunyan Liu 已提交
2947
    .bdrv_amend_options  = qcow2_amend_options,
B
Blue Swirl 已提交
2948 2949
};

2950 2951 2952 2953 2954 2955
static void bdrv_qcow2_init(void)
{
    bdrv_register(&bdrv_qcow2);
}

block_init(bdrv_qcow2_init);