2006-08-05 23:14:20 +02:00
|
|
|
/*
|
|
|
|
* Block driver for the QCOW version 2 format
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2006-08-05 23:14:20 +02:00
|
|
|
* Copyright (c) 2004-2006 Fabrice Bellard
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2006-08-05 23:14:20 +02:00
|
|
|
* 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.
|
|
|
|
*/
|
2016-01-18 19:01:42 +01:00
|
|
|
#include "qemu/osdep.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block_int.h"
|
2016-03-08 15:57:05 +01:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/module.h"
|
2006-08-05 23:14:20 +02:00
|
|
|
#include <zlib.h>
|
2009-05-28 16:07:04 +02:00
|
|
|
#include "block/qcow2.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/error-report.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2013-03-18 13:08:10 +01:00
|
|
|
#include "qapi/qmp/qbool.h"
|
2014-09-10 11:05:47 +02:00
|
|
|
#include "qapi/util.h"
|
2014-09-05 16:07:16 +02:00
|
|
|
#include "qapi/qmp/types.h"
|
|
|
|
#include "qapi-event.h"
|
2012-03-01 18:36:21 +01:00
|
|
|
#include "trace.h"
|
2014-06-05 11:20:59 +02:00
|
|
|
#include "qemu/option_int.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2006-08-05 23:14:20 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
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.
|
2007-09-16 23:08:06 +02:00
|
|
|
- Size of compressed clusters is stored in sectors to reduce bit usage
|
2006-08-05 23:14:20 +02:00
|
|
|
in the cluster offsets.
|
|
|
|
- Support for storing additional data (such as the VM state) in the
|
2007-09-17 10:09:54 +02:00
|
|
|
snapshots.
|
2006-08-05 23:14:20 +02:00
|
|
|
- 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.
|
|
|
|
*/
|
|
|
|
|
2009-03-28 18:55:06 +01:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint32_t magic;
|
|
|
|
uint32_t len;
|
2013-09-25 18:08:50 +02:00
|
|
|
} QEMU_PACKED QCowExtension;
|
2012-09-20 21:13:28 +02:00
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
#define QCOW2_EXT_MAGIC_END 0
|
|
|
|
#define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA
|
2012-04-12 15:20:27 +02:00
|
|
|
#define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
|
2009-03-28 18:55:06 +01:00
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
|
2006-08-05 23:14:20 +02:00
|
|
|
{
|
|
|
|
const QCowHeader *cow_header = (const void *)buf;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
if (buf_size >= sizeof(QCowHeader) &&
|
|
|
|
be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
|
2011-12-15 12:20:58 +01:00
|
|
|
be32_to_cpu(cow_header->version) >= 2)
|
2006-08-05 23:14:20 +02:00
|
|
|
return 100;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-28 18:55:06 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
|
2013-09-05 09:40:43 +02:00
|
|
|
uint64_t end_offset, void **p_feature_table,
|
|
|
|
Error **errp)
|
2009-03-28 18:55:06 +01:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2009-03-28 18:55:06 +01:00
|
|
|
QCowExtension ext;
|
|
|
|
uint64_t offset;
|
2012-02-02 14:52:08 +01:00
|
|
|
int ret;
|
2009-03-28 18:55:06 +01:00
|
|
|
|
|
|
|
#ifdef DEBUG_EXT
|
2010-12-17 16:02:39 +01:00
|
|
|
printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
|
2009-03-28 18:55:06 +01:00
|
|
|
#endif
|
|
|
|
offset = start_offset;
|
|
|
|
while (offset < end_offset) {
|
|
|
|
|
|
|
|
#ifdef DEBUG_EXT
|
|
|
|
/* Sanity check */
|
|
|
|
if (offset > s->cluster_size)
|
2010-12-17 16:02:39 +01:00
|
|
|
printf("qcow2_read_extension: suspicious offset %lu\n", offset);
|
2009-03-28 18:55:06 +01:00
|
|
|
|
2011-11-22 11:06:25 +01:00
|
|
|
printf("attempting to read extended header in offset %lu\n", offset);
|
2009-03-28 18:55:06 +01:00
|
|
|
#endif
|
|
|
|
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, offset, &ext, sizeof(ext));
|
2013-09-05 09:40:43 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
|
|
|
|
"pread fail from offset %" PRIu64, offset);
|
2009-03-28 18:55:06 +01:00
|
|
|
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
|
2014-11-25 18:12:40 +01:00
|
|
|
if (offset > end_offset || ext.len > end_offset - offset) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "Header extension too large");
|
2012-02-22 12:37:13 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-03-28 18:55:06 +01:00
|
|
|
switch (ext.magic) {
|
2010-12-17 16:02:39 +01:00
|
|
|
case QCOW2_EXT_MAGIC_END:
|
2009-03-28 18:55:06 +01:00
|
|
|
return 0;
|
2009-03-28 18:55:14 +01:00
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
case QCOW2_EXT_MAGIC_BACKING_FORMAT:
|
2009-03-28 18:55:14 +01:00
|
|
|
if (ext.len >= sizeof(bs->backing_format)) {
|
2014-04-29 19:03:12 +02:00
|
|
|
error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
|
|
|
|
" too large (>=%zu)", ext.len,
|
|
|
|
sizeof(bs->backing_format));
|
2009-03-28 18:55:14 +01:00
|
|
|
return 2;
|
|
|
|
}
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, offset, bs->backing_format, ext.len);
|
2013-09-05 09:40:43 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
|
|
|
|
"Could not read format name");
|
2009-03-28 18:55:14 +01:00
|
|
|
return 3;
|
2013-09-05 09:40:43 +02:00
|
|
|
}
|
2009-03-28 18:55:14 +01:00
|
|
|
bs->backing_format[ext.len] = '\0';
|
2015-04-07 15:03:16 +02:00
|
|
|
s->image_backing_format = g_strdup(bs->backing_format);
|
2009-03-28 18:55:14 +01:00
|
|
|
#ifdef DEBUG_EXT
|
|
|
|
printf("Qcow2: Got format extension %s\n", bs->backing_format);
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
|
2012-04-12 15:20:27 +02:00
|
|
|
case QCOW2_EXT_MAGIC_FEATURE_TABLE:
|
|
|
|
if (p_feature_table != NULL) {
|
|
|
|
void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, offset , feature_table, ext.len);
|
2012-04-12 15:20:27 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
|
|
|
|
"Could not read table");
|
2012-04-12 15:20:27 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
*p_feature_table = feature_table;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2009-03-28 18:55:06 +01:00
|
|
|
default:
|
2012-02-02 14:52:08 +01:00
|
|
|
/* 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);
|
|
|
|
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, offset , uext->data, uext->len);
|
2012-02-02 14:52:08 +01:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "ERROR: unknown extension: "
|
|
|
|
"Could not read data");
|
2012-02-02 14:52:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2009-03-28 18:55:06 +01:00
|
|
|
break;
|
|
|
|
}
|
2012-02-22 12:31:47 +01:00
|
|
|
|
|
|
|
offset += ((ext.len + 7) & ~7);
|
2009-03-28 18:55:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-02 14:52:08 +01:00
|
|
|
static void cleanup_unknown_header_ext(BlockDriverState *bs)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2012-02-02 14:52:08 +01:00
|
|
|
Qcow2UnknownHeaderExtension *uext, *next;
|
|
|
|
|
|
|
|
QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
|
|
|
|
QLIST_REMOVE(uext, next);
|
|
|
|
g_free(uext);
|
|
|
|
}
|
|
|
|
}
|
2009-03-28 18:55:06 +01:00
|
|
|
|
2016-03-16 19:54:33 +01:00
|
|
|
static void report_unsupported_feature(Error **errp, Qcow2Feature *table,
|
|
|
|
uint64_t mask)
|
2012-04-12 15:20:27 +02:00
|
|
|
{
|
2014-07-17 11:41:53 +02:00
|
|
|
char *features = g_strdup("");
|
|
|
|
char *old;
|
|
|
|
|
2012-04-12 15:20:27 +02:00
|
|
|
while (table && table->name[0] != '\0') {
|
|
|
|
if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
|
2014-07-17 11:41:53 +02:00
|
|
|
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);
|
2012-04-12 15:20:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
table++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mask) {
|
2014-07-17 11:41:53 +02:00
|
|
|
old = features;
|
|
|
|
features = g_strdup_printf("%s%sUnknown incompatible feature: %" PRIx64,
|
|
|
|
old, *old ? ", " : "", mask);
|
|
|
|
g_free(old);
|
2012-04-12 15:20:27 +02:00
|
|
|
}
|
2014-07-17 11:41:53 +02:00
|
|
|
|
2016-03-16 19:54:33 +01:00
|
|
|
error_setg(errp, "Unsupported qcow2 feature(s): %s", features);
|
2014-07-17 11:41:53 +02:00
|
|
|
g_free(features);
|
2012-04-12 15:20:27 +02:00
|
|
|
}
|
|
|
|
|
2012-07-27 10:05:22 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-12-07 18:08:47 +01:00
|
|
|
int qcow2_mark_dirty(BlockDriverState *bs)
|
2012-07-27 10:05:22 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2012-07-27 10:05:22 +02:00
|
|
|
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);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pwrite(bs->file->bs, offsetof(QCowHeader, incompatible_features),
|
2012-07-27 10:05:22 +02:00
|
|
|
&val, sizeof(val));
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_flush(bs->file->bs);
|
2012-07-27 10:05:22 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only treat image as dirty if the header was updated successfully */
|
|
|
|
s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-27 10:05:19 +02:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2012-07-27 10:05:19 +02:00
|
|
|
|
|
|
|
if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
|
2014-04-03 13:47:50 +02:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;
|
|
|
|
|
|
|
|
ret = bdrv_flush(bs);
|
2012-07-27 10:05:19 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return qcow2_update_header(bs);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-30 14:34:24 +02:00
|
|
|
/*
|
|
|
|
* Marks the image as corrupt.
|
|
|
|
*/
|
|
|
|
int qcow2_mark_corrupt(BlockDriverState *bs)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-08-30 14:34:24 +02:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-08-30 14:34:24 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-08-09 14:05:55 +02:00
|
|
|
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) {
|
2013-08-30 14:34:30 +02:00
|
|
|
ret = qcow2_mark_clean(bs);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return qcow2_mark_consistent(bs);
|
2012-08-09 14:05:55 +02:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-26 13:05:44 +01:00
|
|
|
static int validate_table_offset(BlockDriverState *bs, uint64_t offset,
|
|
|
|
uint64_t entries, size_t entry_len)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2014-03-26 13:05:44 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-03-15 10:35:08 +01:00
|
|
|
static QemuOptsList qcow2_runtime_opts = {
|
|
|
|
.name = "qcow2",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
2013-07-17 14:45:34 +02:00
|
|
|
.name = QCOW2_OPT_LAZY_REFCOUNTS,
|
2013-03-15 10:35:08 +01:00
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Postpone refcount updates",
|
|
|
|
},
|
2013-06-19 13:44:19 +02:00
|
|
|
{
|
|
|
|
.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",
|
|
|
|
},
|
2013-10-10 11:09:25 +02:00
|
|
|
{
|
|
|
|
.name = QCOW2_OPT_OVERLAP,
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
.help = "Selects which overlap checks to perform from a range of "
|
|
|
|
"templates (none, constant, cached, all)",
|
|
|
|
},
|
2014-08-20 19:59:35 +02:00
|
|
|
{
|
|
|
|
.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)",
|
|
|
|
},
|
2013-10-10 11:09:25 +02:00
|
|
|
{
|
|
|
|
.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",
|
|
|
|
},
|
2014-08-18 22:07:33 +02:00
|
|
|
{
|
|
|
|
.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",
|
|
|
|
},
|
2015-08-04 14:14:40 +02:00
|
|
|
{
|
|
|
|
.name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
|
|
|
|
.type = QEMU_OPT_NUMBER,
|
|
|
|
.help = "Clean unused cache entries after this time (in seconds)",
|
|
|
|
},
|
2013-03-15 10:35:08 +01:00
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-10-10 11:09:26 +02:00
|
|
|
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,
|
|
|
|
};
|
|
|
|
|
2015-08-04 14:14:40 +02:00
|
|
|
static void cache_clean_timer_cb(void *opaque)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = opaque;
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2015-08-04 14:14:40 +02:00
|
|
|
qcow2_cache_clean_unused(bs, s->l2_table_cache);
|
|
|
|
qcow2_cache_clean_unused(bs, s->refcount_block_cache);
|
|
|
|
timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
|
|
|
|
(int64_t) s->cache_clean_interval * 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2015-08-04 14:14:40 +02:00
|
|
|
if (s->cache_clean_interval > 0) {
|
|
|
|
s->cache_clean_timer = aio_timer_new(context, QEMU_CLOCK_VIRTUAL,
|
|
|
|
SCALE_MS, cache_clean_timer_cb,
|
|
|
|
bs);
|
|
|
|
timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
|
|
|
|
(int64_t) s->cache_clean_interval * 1000);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cache_clean_timer_del(BlockDriverState *bs)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2015-08-04 14:14:40 +02:00
|
|
|
if (s->cache_clean_timer) {
|
|
|
|
timer_del(s->cache_clean_timer);
|
|
|
|
timer_free(s->cache_clean_timer);
|
|
|
|
s->cache_clean_timer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qcow2_detach_aio_context(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
cache_clean_timer_del(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qcow2_attach_aio_context(BlockDriverState *bs,
|
|
|
|
AioContext *new_context)
|
|
|
|
{
|
|
|
|
cache_clean_timer_init(bs, new_context);
|
|
|
|
}
|
|
|
|
|
2015-06-01 18:09:19 +02:00
|
|
|
static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
|
|
|
|
uint64_t *l2_cache_size,
|
2014-08-18 22:07:33 +02:00
|
|
|
uint64_t *refcount_cache_size, Error **errp)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2014-08-18 22:07:33 +02:00
|
|
|
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) {
|
2015-06-01 18:09:19 +02:00
|
|
|
*l2_cache_size = MAX(DEFAULT_L2_CACHE_BYTE_SIZE,
|
|
|
|
(uint64_t)DEFAULT_L2_CACHE_CLUSTERS
|
|
|
|
* s->cluster_size);
|
2014-08-18 22:07:33 +02:00
|
|
|
*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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-16 16:16:02 +02:00
|
|
|
typedef struct Qcow2ReopenState {
|
|
|
|
Qcow2Cache *l2_table_cache;
|
|
|
|
Qcow2Cache *refcount_block_cache;
|
|
|
|
bool use_lazy_refcounts;
|
|
|
|
int overlap_check;
|
|
|
|
bool discard_passthrough[QCOW2_DISCARD_MAX];
|
|
|
|
uint64_t cache_clean_interval;
|
|
|
|
} Qcow2ReopenState;
|
|
|
|
|
|
|
|
static int qcow2_update_options_prepare(BlockDriverState *bs,
|
|
|
|
Qcow2ReopenState *r,
|
|
|
|
QDict *options, int flags,
|
|
|
|
Error **errp)
|
2015-04-16 11:29:27 +02:00
|
|
|
{
|
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2015-04-16 11:44:26 +02:00
|
|
|
QemuOpts *opts = NULL;
|
2015-04-16 11:29:27 +02:00
|
|
|
const char *opt_overlap_check, *opt_overlap_check_template;
|
|
|
|
int overlap_check_template = 0;
|
2015-04-16 11:44:26 +02:00
|
|
|
uint64_t l2_cache_size, refcount_cache_size;
|
2015-04-16 11:29:27 +02:00
|
|
|
int i;
|
2015-04-16 11:44:26 +02:00
|
|
|
Error *local_err = NULL;
|
2015-04-16 11:29:27 +02:00
|
|
|
int ret;
|
|
|
|
|
2015-04-16 11:44:26 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get L2 table/refcount block cache size from command line options */
|
|
|
|
read_cache_sizes(bs, 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;
|
|
|
|
if (l2_cache_size < MIN_L2_CACHE_SIZE) {
|
|
|
|
l2_cache_size = MIN_L2_CACHE_SIZE;
|
|
|
|
}
|
|
|
|
if (l2_cache_size > INT_MAX) {
|
|
|
|
error_setg(errp, "L2 cache size too big");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
refcount_cache_size /= s->cluster_size;
|
|
|
|
if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
|
|
|
|
refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
|
|
|
|
}
|
|
|
|
if (refcount_cache_size > INT_MAX) {
|
|
|
|
error_setg(errp, "Refcount cache size too big");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-04-16 13:42:27 +02:00
|
|
|
/* alloc new L2 table/refcount block cache, flush old one */
|
|
|
|
if (s->l2_table_cache) {
|
|
|
|
ret = qcow2_cache_flush(bs, s->l2_table_cache);
|
|
|
|
if (ret) {
|
|
|
|
error_setg_errno(errp, -ret, "Failed to flush the L2 table cache");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->refcount_block_cache) {
|
|
|
|
ret = qcow2_cache_flush(bs, s->refcount_block_cache);
|
|
|
|
if (ret) {
|
|
|
|
error_setg_errno(errp, -ret,
|
|
|
|
"Failed to flush the refcount block cache");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-16 16:16:02 +02:00
|
|
|
r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size);
|
|
|
|
r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size);
|
|
|
|
if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) {
|
2015-04-16 11:44:26 +02:00
|
|
|
error_setg(errp, "Could not allocate metadata caches");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* New interval for cache cleanup timer */
|
2015-04-16 16:16:02 +02:00
|
|
|
r->cache_clean_interval =
|
2015-04-16 13:42:27 +02:00
|
|
|
qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
|
|
|
|
s->cache_clean_interval);
|
2015-04-16 16:16:02 +02:00
|
|
|
if (r->cache_clean_interval > UINT_MAX) {
|
2015-04-16 11:44:26 +02:00
|
|
|
error_setg(errp, "Cache clean interval too big");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-04-16 13:42:27 +02:00
|
|
|
/* lazy-refcounts; flush if going from enabled to disabled */
|
2015-04-16 16:16:02 +02:00
|
|
|
r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
|
2015-04-16 11:29:27 +02:00
|
|
|
(s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
|
2015-04-16 16:16:02 +02:00
|
|
|
if (r->use_lazy_refcounts && s->qcow_version < 3) {
|
2015-04-16 13:11:39 +02:00
|
|
|
error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
|
|
|
|
"qemu 1.1 compatibility level");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-04-16 11:29:27 +02:00
|
|
|
|
2015-04-16 13:42:27 +02:00
|
|
|
if (s->use_lazy_refcounts && !r->use_lazy_refcounts) {
|
|
|
|
ret = qcow2_mark_clean(bs);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "Failed to disable lazy refcounts");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-16 13:11:39 +02:00
|
|
|
/* Overlap check options */
|
2015-04-16 11:29:27 +02:00
|
|
|
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";
|
|
|
|
}
|
|
|
|
|
|
|
|
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 any of the following: "
|
|
|
|
"none, constant, cached, all", opt_overlap_check);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-04-16 16:16:02 +02:00
|
|
|
r->overlap_check = 0;
|
2015-04-16 11:29:27 +02:00
|
|
|
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 */
|
2015-04-16 16:16:02 +02:00
|
|
|
r->overlap_check |=
|
2015-04-16 11:29:27 +02:00
|
|
|
qemu_opt_get_bool(opts, overlap_bool_option_names[i],
|
|
|
|
overlap_check_template & (1 << i)) << i;
|
|
|
|
}
|
|
|
|
|
2015-04-16 16:16:02 +02:00
|
|
|
r->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
|
|
|
|
r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
|
|
|
|
r->discard_passthrough[QCOW2_DISCARD_REQUEST] =
|
2015-04-16 13:11:39 +02:00
|
|
|
qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
|
|
|
|
flags & BDRV_O_UNMAP);
|
2015-04-16 16:16:02 +02:00
|
|
|
r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
|
2015-04-16 13:11:39 +02:00
|
|
|
qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
|
2015-04-16 16:16:02 +02:00
|
|
|
r->discard_passthrough[QCOW2_DISCARD_OTHER] =
|
2015-04-16 13:11:39 +02:00
|
|
|
qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);
|
|
|
|
|
2015-04-16 11:29:27 +02:00
|
|
|
ret = 0;
|
|
|
|
fail:
|
2015-04-16 11:44:26 +02:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
opts = NULL;
|
2015-04-16 16:16:02 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qcow2_update_options_commit(BlockDriverState *bs,
|
|
|
|
Qcow2ReopenState *r)
|
|
|
|
{
|
|
|
|
BDRVQcow2State *s = bs->opaque;
|
|
|
|
int i;
|
|
|
|
|
2015-04-16 13:42:27 +02:00
|
|
|
if (s->l2_table_cache) {
|
|
|
|
qcow2_cache_destroy(bs, s->l2_table_cache);
|
|
|
|
}
|
|
|
|
if (s->refcount_block_cache) {
|
|
|
|
qcow2_cache_destroy(bs, s->refcount_block_cache);
|
|
|
|
}
|
2015-04-16 16:16:02 +02:00
|
|
|
s->l2_table_cache = r->l2_table_cache;
|
|
|
|
s->refcount_block_cache = r->refcount_block_cache;
|
|
|
|
|
|
|
|
s->overlap_check = r->overlap_check;
|
|
|
|
s->use_lazy_refcounts = r->use_lazy_refcounts;
|
|
|
|
|
|
|
|
for (i = 0; i < QCOW2_DISCARD_MAX; i++) {
|
|
|
|
s->discard_passthrough[i] = r->discard_passthrough[i];
|
|
|
|
}
|
|
|
|
|
2015-04-16 13:42:27 +02:00
|
|
|
if (s->cache_clean_interval != r->cache_clean_interval) {
|
|
|
|
cache_clean_timer_del(bs);
|
|
|
|
s->cache_clean_interval = r->cache_clean_interval;
|
|
|
|
cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
|
|
|
|
}
|
2015-04-16 16:16:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qcow2_update_options_abort(BlockDriverState *bs,
|
|
|
|
Qcow2ReopenState *r)
|
|
|
|
{
|
|
|
|
if (r->l2_table_cache) {
|
|
|
|
qcow2_cache_destroy(bs, r->l2_table_cache);
|
|
|
|
}
|
|
|
|
if (r->refcount_block_cache) {
|
|
|
|
qcow2_cache_destroy(bs, r->refcount_block_cache);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qcow2_update_options(BlockDriverState *bs, QDict *options,
|
|
|
|
int flags, Error **errp)
|
|
|
|
{
|
|
|
|
Qcow2ReopenState r = {};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = qcow2_update_options_prepare(bs, &r, options, flags, errp);
|
|
|
|
if (ret >= 0) {
|
|
|
|
qcow2_update_options_commit(bs, &r);
|
|
|
|
} else {
|
|
|
|
qcow2_update_options_abort(bs, &r);
|
|
|
|
}
|
2015-04-16 11:44:26 +02:00
|
|
|
|
2015-04-16 11:29:27 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-09-05 14:22:29 +02:00
|
|
|
static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
|
|
|
|
Error **errp)
|
2006-08-05 23:14:20 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2014-03-26 13:05:47 +01:00
|
|
|
unsigned int len, i;
|
|
|
|
int ret = 0;
|
2006-08-05 23:14:20 +02:00
|
|
|
QCowHeader header;
|
2013-03-15 10:35:08 +01:00
|
|
|
Error *local_err = NULL;
|
2009-03-28 18:55:06 +01:00
|
|
|
uint64_t ext_end;
|
2013-05-14 16:14:33 +02:00
|
|
|
uint64_t l1_vm_state_index;
|
2006-08-05 23:14:20 +02:00
|
|
|
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, 0, &header, sizeof(header));
|
2010-12-17 16:02:40 +01:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not read qcow2 header");
|
2006-08-05 23:14:20 +02:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
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);
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2011-02-09 11:11:07 +01:00
|
|
|
if (header.magic != QCOW_MAGIC) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "Image is not in qcow2 format");
|
2014-02-17 14:44:06 +01:00
|
|
|
ret = -EINVAL;
|
2006-08-05 23:14:20 +02:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2011-12-15 12:20:58 +01:00
|
|
|
if (header.version < 2 || header.version > 3) {
|
2016-03-16 19:54:33 +01:00
|
|
|
error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version);
|
2011-12-15 12:20:58 +01:00
|
|
|
ret = -ENOTSUP;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->qcow_version = header.version;
|
|
|
|
|
2014-03-26 13:05:41 +01:00
|
|
|
/* Initialise cluster size */
|
|
|
|
if (header.cluster_bits < MIN_CLUSTER_BITS ||
|
|
|
|
header.cluster_bits > MAX_CLUSTER_BITS) {
|
2014-04-29 19:03:12 +02:00
|
|
|
error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
|
|
|
|
header.cluster_bits);
|
2014-03-26 13:05:41 +01:00
|
|
|
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);
|
|
|
|
|
2011-12-15 12:20:58 +01:00
|
|
|
/* 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);
|
2014-03-26 13:05:41 +01:00
|
|
|
|
|
|
|
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;
|
2011-12-15 12:20:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, sizeof(header), s->unknown_header_fields,
|
2011-12-15 12:20:58 +01:00
|
|
|
s->unknown_header_fields_size);
|
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
|
|
|
|
"fields");
|
2011-12-15 12:20:58 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-26 13:05:42 +01:00
|
|
|
if (header.backing_file_offset > s->cluster_size) {
|
|
|
|
error_setg(errp, "Invalid backing file offset");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2012-04-12 15:20:27 +02:00
|
|
|
if (header.backing_file_offset) {
|
|
|
|
ext_end = header.backing_file_offset;
|
|
|
|
} else {
|
|
|
|
ext_end = 1 << header.cluster_bits;
|
|
|
|
}
|
|
|
|
|
2011-12-15 12:20:58 +01:00
|
|
|
/* Handle feature bits */
|
|
|
|
s->incompatible_features = header.incompatible_features;
|
|
|
|
s->compatible_features = header.compatible_features;
|
|
|
|
s->autoclear_features = header.autoclear_features;
|
|
|
|
|
2012-07-27 10:05:19 +02:00
|
|
|
if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
|
2012-04-12 15:20:27 +02:00
|
|
|
void *feature_table = NULL;
|
|
|
|
qcow2_read_extensions(bs, header.header_length, ext_end,
|
2013-09-05 09:40:43 +02:00
|
|
|
&feature_table, NULL);
|
2016-03-16 19:54:33 +01:00
|
|
|
report_unsupported_feature(errp, feature_table,
|
2012-07-27 10:05:19 +02:00
|
|
|
s->incompatible_features &
|
|
|
|
~QCOW2_INCOMPAT_MASK);
|
2011-12-15 12:20:58 +01:00
|
|
|
ret = -ENOTSUP;
|
2014-03-28 18:38:58 +01:00
|
|
|
g_free(feature_table);
|
2011-12-15 12:20:58 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2013-08-30 14:34:24 +02:00
|
|
|
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)) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
|
|
|
|
"read/write");
|
2013-08-30 14:34:24 +02:00
|
|
|
ret = -EACCES;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-15 12:20:58 +01:00
|
|
|
/* Check support for various header values */
|
2015-02-10 21:28:52 +01:00
|
|
|
if (header.refcount_order > 6) {
|
|
|
|
error_setg(errp, "Reference count entry width too large; may not "
|
|
|
|
"exceed 64 bits");
|
|
|
|
ret = -EINVAL;
|
2011-02-09 11:11:07 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
2013-09-03 10:09:53 +02:00
|
|
|
s->refcount_order = header.refcount_order;
|
2015-02-10 21:28:43 +01:00
|
|
|
s->refcount_bits = 1 << s->refcount_order;
|
|
|
|
s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
|
|
|
|
s->refcount_max += s->refcount_max - 1;
|
2011-12-15 12:20:58 +01:00
|
|
|
|
2010-12-17 16:02:40 +01:00
|
|
|
if (header.crypt_method > QCOW_CRYPT_AES) {
|
2014-04-29 19:03:12 +02:00
|
|
|
error_setg(errp, "Unsupported encryption method: %" PRIu32,
|
2013-09-05 09:40:43 +02:00
|
|
|
header.crypt_method);
|
2010-12-17 16:02:40 +01:00
|
|
|
ret = -EINVAL;
|
2006-08-05 23:14:20 +02:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2015-07-01 19:10:37 +02:00
|
|
|
if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128)) {
|
|
|
|
error_setg(errp, "AES cipher not available");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
s->crypt_method_header = header.crypt_method;
|
2010-12-17 16:02:40 +01:00
|
|
|
if (s->crypt_method_header) {
|
2016-03-21 15:11:48 +01:00
|
|
|
if (bdrv_uses_whitelist() &&
|
|
|
|
s->crypt_method_header == QCOW_CRYPT_AES) {
|
|
|
|
error_report("qcow2 built-in AES encryption is deprecated");
|
|
|
|
error_printf("Support for it will be removed in a future release.\n"
|
|
|
|
"You can use 'qemu-img convert' to switch to an\n"
|
|
|
|
"unencrypted qcow2 image, or a LUKS raw image.\n");
|
|
|
|
}
|
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
bs->encrypted = 1;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2014-03-26 13:05:41 +01:00
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */
|
|
|
|
s->l2_size = 1 << s->l2_bits;
|
2014-10-22 14:09:28 +02:00
|
|
|
/* 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;
|
2006-08-05 23:14:20 +02:00
|
|
|
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;
|
2014-03-26 13:05:43 +01:00
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
s->refcount_table_offset = header.refcount_table_offset;
|
2007-09-16 23:08:06 +02:00
|
|
|
s->refcount_table_size =
|
2006-08-05 23:14:20 +02:00
|
|
|
header.refcount_table_clusters << (s->cluster_bits - 3);
|
|
|
|
|
2014-03-26 13:05:50 +01:00
|
|
|
if (header.refcount_table_clusters > qcow2_max_refcount_clusters(s)) {
|
2014-03-26 13:05:43 +01:00
|
|
|
error_setg(errp, "Reference count table too large");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2014-03-26 13:05:44 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-03-26 13:05:45 +01:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
/* read the level 1 table */
|
2015-03-11 04:05:21 +01:00
|
|
|
if (header.l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {
|
2014-03-26 13:05:46 +01:00
|
|
|
error_setg(errp, "Active L1 table too large");
|
|
|
|
ret = -EFBIG;
|
|
|
|
goto fail;
|
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
s->l1_size = header.l1_size;
|
2013-05-14 16:14:33 +02:00
|
|
|
|
|
|
|
l1_vm_state_index = size_to_l1(s, header.size);
|
|
|
|
if (l1_vm_state_index > INT_MAX) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "Image is too big");
|
2013-05-14 16:14:33 +02:00
|
|
|
ret = -EFBIG;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
s->l1_vm_state_index = l1_vm_state_index;
|
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
/* the L1 table must contain at least enough entries to put
|
|
|
|
header.size bytes */
|
2010-12-17 16:02:40 +01:00
|
|
|
if (s->l1_size < s->l1_vm_state_index) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "L1 table is too small");
|
2010-12-17 16:02:40 +01:00
|
|
|
ret = -EINVAL;
|
2006-08-05 23:14:20 +02:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2014-03-26 13:05:46 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
s->l1_table_offset = header.l1_table_offset;
|
2014-03-26 13:05:46 +01:00
|
|
|
|
|
|
|
|
2009-10-26 16:11:16 +01:00
|
|
|
if (s->l1_size > 0) {
|
2015-06-16 14:19:22 +02:00
|
|
|
s->l1_table = qemu_try_blockalign(bs->file->bs,
|
2009-10-26 16:11:16 +01:00
|
|
|
align_offset(s->l1_size * sizeof(uint64_t), 512));
|
2014-05-20 17:12:47 +02:00
|
|
|
if (s->l1_table == NULL) {
|
|
|
|
error_setg(errp, "Could not allocate L1 table");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, s->l1_table_offset, s->l1_table,
|
2010-12-17 16:02:40 +01:00
|
|
|
s->l1_size * sizeof(uint64_t));
|
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not read L1 table");
|
2009-10-26 16:11:16 +01:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2009-10-26 16:11:16 +01:00
|
|
|
for(i = 0;i < s->l1_size; i++) {
|
|
|
|
be64_to_cpus(&s->l1_table[i]);
|
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
2011-01-10 17:17:28 +01:00
|
|
|
|
2015-04-16 11:44:26 +02:00
|
|
|
/* Parse driver-specific options */
|
|
|
|
ret = qcow2_update_options(bs, options, flags, errp);
|
2015-04-16 11:36:10 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
s->cluster_cache = g_malloc(s->cluster_size);
|
2006-08-05 23:14:20 +02:00
|
|
|
/* one more sector for decompressed data alignment */
|
2015-06-16 14:19:22 +02:00
|
|
|
s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
|
2014-05-20 17:12:47 +02:00
|
|
|
* s->cluster_size + 512);
|
|
|
|
if (s->cluster_data == NULL) {
|
|
|
|
error_setg(errp, "Could not allocate temporary cluster buffer");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
s->cluster_cache_offset = -1;
|
2011-11-14 22:09:46 +01:00
|
|
|
s->flags = flags;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2010-12-17 16:02:40 +01:00
|
|
|
ret = qcow2_refcount_init(bs);
|
|
|
|
if (ret != 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not initialize refcount handling");
|
2006-08-05 23:14:20 +02:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QLIST_INIT(&s->cluster_allocs);
|
2013-06-19 13:44:20 +02:00
|
|
|
QTAILQ_INIT(&s->discards);
|
2009-08-31 16:48:49 +02:00
|
|
|
|
2009-03-28 18:55:06 +01:00
|
|
|
/* read qcow2 extensions */
|
2013-09-05 09:40:43 +02:00
|
|
|
if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
|
|
|
|
&local_err)) {
|
|
|
|
error_propagate(errp, local_err);
|
2010-12-17 16:02:40 +01:00
|
|
|
ret = -EINVAL;
|
2009-03-28 18:55:06 +01:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2009-03-28 18:55:06 +01:00
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
/* read the backing file name */
|
|
|
|
if (header.backing_file_offset != 0) {
|
|
|
|
len = header.backing_file_size;
|
2015-01-22 14:03:30 +01:00
|
|
|
if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
|
2015-01-27 14:33:55 +01:00
|
|
|
len >= sizeof(bs->backing_file)) {
|
2014-03-26 13:05:47 +01:00
|
|
|
error_setg(errp, "Backing file name too long");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pread(bs->file->bs, header.backing_file_offset,
|
2010-12-17 16:02:40 +01:00
|
|
|
bs->backing_file, len);
|
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not read backing file name");
|
2006-08-05 23:14:20 +02:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
bs->backing_file[len] = '\0';
|
2015-04-07 15:03:16 +02:00
|
|
|
s->image_backing_file = g_strdup(bs->backing_file);
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
2011-11-16 11:43:28 +01:00
|
|
|
|
2014-03-26 13:06:04 +01:00
|
|
|
/* Internal snapshots */
|
|
|
|
s->snapshots_offset = header.snapshots_offset;
|
|
|
|
s->nb_snapshots = header.nb_snapshots;
|
|
|
|
|
2011-11-16 11:43:28 +01:00
|
|
|
ret = qcow2_read_snapshots(bs);
|
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not read snapshots");
|
2006-08-05 23:14:20 +02:00
|
|
|
goto fail;
|
2010-12-17 16:02:40 +01:00
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
|
2012-06-14 12:42:23 +02:00
|
|
|
/* Clear unknown autoclear feature bits */
|
2016-01-13 15:56:06 +01:00
|
|
|
if (!bs->read_only && !(flags & BDRV_O_INACTIVE) && s->autoclear_features) {
|
2012-06-14 12:42:23 +02:00
|
|
|
s->autoclear_features = 0;
|
|
|
|
ret = qcow2_update_header(bs);
|
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not update qcow2 header");
|
2012-06-14 12:42:23 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-30 17:42:09 +02:00
|
|
|
/* Initialise locks */
|
|
|
|
qemu_co_mutex_init(&s->lock);
|
|
|
|
|
2012-07-27 10:05:19 +02:00
|
|
|
/* Repair image if dirty */
|
2016-01-13 15:56:06 +01:00
|
|
|
if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
|
2012-08-09 14:05:56 +02:00
|
|
|
(s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
|
2012-07-27 10:05:19 +02:00
|
|
|
BdrvCheckResult result = {0};
|
|
|
|
|
2014-10-22 14:09:29 +02:00
|
|
|
ret = qcow2_check(bs, &result, BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
|
2012-07-27 10:05:19 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not repair dirty image");
|
2012-07-27 10:05:19 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
#ifdef DEBUG_ALLOC
|
2011-08-04 19:22:10 +02:00
|
|
|
{
|
|
|
|
BdrvCheckResult result = {0};
|
2012-06-15 17:41:07 +02:00
|
|
|
qcow2_check_refcounts(bs, &result, 0);
|
2011-08-04 19:22:10 +02:00
|
|
|
}
|
2006-08-05 23:14:20 +02:00
|
|
|
#endif
|
2010-12-17 16:02:40 +01:00
|
|
|
return ret;
|
2006-08-05 23:14:20 +02:00
|
|
|
|
|
|
|
fail:
|
2011-12-15 12:20:58 +01:00
|
|
|
g_free(s->unknown_header_fields);
|
2012-02-02 14:52:08 +01:00
|
|
|
cleanup_unknown_header_ext(bs);
|
2009-05-28 16:07:07 +02:00
|
|
|
qcow2_free_snapshots(bs);
|
|
|
|
qcow2_refcount_close(bs);
|
2014-05-20 17:12:47 +02:00
|
|
|
qemu_vfree(s->l1_table);
|
2013-08-30 14:34:26 +02:00
|
|
|
/* else pre-write overlap checks in cache_destroy may crash */
|
|
|
|
s->l1_table = NULL;
|
2015-08-04 14:14:40 +02:00
|
|
|
cache_clean_timer_del(bs);
|
2011-01-10 17:17:28 +01:00
|
|
|
if (s->l2_table_cache) {
|
|
|
|
qcow2_cache_destroy(bs, s->l2_table_cache);
|
|
|
|
}
|
2014-03-28 18:38:58 +01:00
|
|
|
if (s->refcount_block_cache) {
|
|
|
|
qcow2_cache_destroy(bs, s->refcount_block_cache);
|
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s->cluster_cache);
|
2011-09-10 10:59:16 +02:00
|
|
|
qemu_vfree(s->cluster_data);
|
2010-12-17 16:02:40 +01:00
|
|
|
return ret;
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
|
|
|
|
2014-07-16 17:48:16 +02:00
|
|
|
static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
|
2013-12-11 19:26:16 +01:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-12-11 19:26:16 +01:00
|
|
|
|
|
|
|
bs->bl.write_zeroes_alignment = s->cluster_sectors;
|
|
|
|
}
|
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_set_key(BlockDriverState *bs, const char *key)
|
2006-08-05 23:14:20 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2006-08-05 23:14:20 +02:00
|
|
|
uint8_t keybuf[16];
|
|
|
|
int len, i;
|
2015-07-01 19:10:37 +02:00
|
|
|
Error *err = NULL;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2006-08-05 23:14:20 +02:00
|
|
|
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];
|
|
|
|
}
|
qcow2/qcow: protect against uninitialized encryption key
When a qcow[2] file is opened, if the header reports an
encryption method, this is used to set the 'crypt_method_header'
field on the BDRVQcow[2]State struct, and the 'encrypted' flag
in the BDRVState struct.
When doing I/O operations, the 'crypt_method' field on the
BDRVQcow[2]State struct is checked to determine if encryption
needs to be applied.
The crypt_method_header value is copied into crypt_method when
the bdrv_set_key() method is called.
The QEMU code which opens a block device is expected to always
do a check
if (bdrv_is_encrypted(bs)) {
bdrv_set_key(bs, ....key...);
}
If code forgets to do this, then 'crypt_method' is never set
and so when I/O is performed, QEMU writes plain text data
into a sector which is expected to contain cipher text, or
when reading, will return cipher text instead of plain
text.
Change the qcow[2] code to consult bs->encrypted when deciding
whether encryption is required, and assert(s->crypt_method)
to protect against cases where the caller forgets to set the
encryption key.
Also put an assert in the set_key methods to protect against
the case where the caller sets an encryption key on a block
device that does not have encryption
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-05-12 18:09:18 +02:00
|
|
|
assert(bs->encrypted);
|
2006-08-05 23:14:20 +02:00
|
|
|
|
2015-07-01 19:10:37 +02:00
|
|
|
qcrypto_cipher_free(s->cipher);
|
|
|
|
s->cipher = qcrypto_cipher_new(
|
|
|
|
QCRYPTO_CIPHER_ALG_AES_128,
|
|
|
|
QCRYPTO_CIPHER_MODE_CBC,
|
|
|
|
keybuf, G_N_ELEMENTS(keybuf),
|
|
|
|
&err);
|
|
|
|
|
|
|
|
if (!s->cipher) {
|
|
|
|
/* XXX would be nice if errors in this method could
|
|
|
|
* be properly propagate to the caller. Would need
|
|
|
|
* the bdrv_set_key() API signature to be fixed. */
|
|
|
|
error_free(err);
|
2006-08-05 23:14:20 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-20 21:13:28 +02:00
|
|
|
static int qcow2_reopen_prepare(BDRVReopenState *state,
|
|
|
|
BlockReopenQueue *queue, Error **errp)
|
|
|
|
{
|
2015-04-16 13:42:27 +02:00
|
|
|
Qcow2ReopenState *r;
|
2014-04-03 13:47:50 +02:00
|
|
|
int ret;
|
|
|
|
|
2015-04-16 13:42:27 +02:00
|
|
|
r = g_new0(Qcow2ReopenState, 1);
|
|
|
|
state->opaque = r;
|
|
|
|
|
|
|
|
ret = qcow2_update_options_prepare(state->bs, r, state->options,
|
|
|
|
state->flags, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We need to write out any unwritten data if we reopen read-only. */
|
2014-04-03 13:47:50 +02:00
|
|
|
if ((state->flags & BDRV_O_RDWR) == 0) {
|
|
|
|
ret = bdrv_flush(state->bs);
|
|
|
|
if (ret < 0) {
|
2015-04-16 13:42:27 +02:00
|
|
|
goto fail;
|
2014-04-03 13:47:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = qcow2_mark_clean(state->bs);
|
|
|
|
if (ret < 0) {
|
2015-04-16 13:42:27 +02:00
|
|
|
goto fail;
|
2014-04-03 13:47:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-20 21:13:28 +02:00
|
|
|
return 0;
|
2015-04-16 13:42:27 +02:00
|
|
|
|
|
|
|
fail:
|
|
|
|
qcow2_update_options_abort(state->bs, r);
|
|
|
|
g_free(r);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qcow2_reopen_commit(BDRVReopenState *state)
|
|
|
|
{
|
|
|
|
qcow2_update_options_commit(state->bs, state->opaque);
|
|
|
|
g_free(state->opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qcow2_reopen_abort(BDRVReopenState *state)
|
|
|
|
{
|
|
|
|
qcow2_update_options_abort(state->bs, state->opaque);
|
|
|
|
g_free(state->opaque);
|
2012-09-20 21:13:28 +02:00
|
|
|
}
|
|
|
|
|
2015-11-16 15:34:59 +01:00
|
|
|
static void qcow2_join_options(QDict *options, QDict *old_options)
|
|
|
|
{
|
|
|
|
bool has_new_overlap_template =
|
|
|
|
qdict_haskey(options, QCOW2_OPT_OVERLAP) ||
|
|
|
|
qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE);
|
|
|
|
bool has_new_total_cache_size =
|
|
|
|
qdict_haskey(options, QCOW2_OPT_CACHE_SIZE);
|
|
|
|
bool has_all_cache_options;
|
|
|
|
|
|
|
|
/* New overlap template overrides all old overlap options */
|
|
|
|
if (has_new_overlap_template) {
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* New total cache size overrides all old options */
|
|
|
|
if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) {
|
|
|
|
qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE);
|
|
|
|
qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
qdict_join(options, old_options, false);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If after merging all cache size options are set, an old total size is
|
|
|
|
* overwritten. Do keep all options, however, if all three are new. The
|
|
|
|
* resulting error message is what we want to happen.
|
|
|
|
*/
|
|
|
|
has_all_cache_options =
|
|
|
|
qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) ||
|
|
|
|
qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) ||
|
|
|
|
qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
|
|
|
|
|
|
|
|
if (has_all_cache_options && !has_new_total_cache_size) {
|
|
|
|
qdict_del(options, QCOW2_OPT_CACHE_SIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-04 19:00:28 +02:00
|
|
|
static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
|
2016-01-26 04:58:48 +01:00
|
|
|
int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
|
2006-08-05 23:14:20 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2006-08-05 23:14:20 +02:00
|
|
|
uint64_t cluster_offset;
|
2013-09-04 19:00:30 +02:00
|
|
|
int index_in_cluster, ret;
|
|
|
|
int64_t status = 0;
|
2006-08-05 23:14:20 +02:00
|
|
|
|
2008-08-14 20:10:28 +02:00
|
|
|
*pnum = nb_sectors;
|
2011-11-14 13:44:21 +01:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2010-05-21 17:59:36 +02:00
|
|
|
ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);
|
2011-11-14 13:44:21 +01:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2010-05-21 17:59:36 +02:00
|
|
|
if (ret < 0) {
|
2013-09-04 19:00:25 +02:00
|
|
|
return ret;
|
2010-05-21 17:59:36 +02:00
|
|
|
}
|
2008-08-14 20:10:28 +02:00
|
|
|
|
2013-09-04 19:00:30 +02:00
|
|
|
if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
|
2015-07-01 19:10:37 +02:00
|
|
|
!s->cipher) {
|
2013-09-04 19:00:30 +02:00
|
|
|
index_in_cluster = sector_num & (s->cluster_sectors - 1);
|
|
|
|
cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
|
2016-01-26 04:58:50 +01:00
|
|
|
*file = bs->file->bs;
|
2013-09-04 19:00:30 +02:00
|
|
|
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;
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
|
|
|
|
2006-08-06 15:34:04 +02:00
|
|
|
/* handle reading after the end of the backing file */
|
2010-09-13 18:08:52 +02:00
|
|
|
int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
|
|
|
|
int64_t sector_num, int nb_sectors)
|
2006-08-06 15:34:04 +02:00
|
|
|
{
|
|
|
|
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;
|
2010-09-13 18:08:52 +02:00
|
|
|
|
consolidate qemu_iovec_memset{,_skip}() into single function and use existing iov_memset()
This patch combines two functions into one, and replaces
the implementation with already existing iov_memset() from
iov.c.
The new prototype of qemu_iovec_memset():
size_t qemu_iovec_memset(qiov, size_t offset, int fillc, size_t bytes)
It is different from former qemu_iovec_memset_skip(), and
I want to make other functions to be consistent with it
too: first how much to skip, second what, and 3rd how many
of it. It also returns actual number of bytes filled in,
which may be less than the requested `bytes' if qiov is
smaller than offset+bytes, in the same way iov_memset()
does.
While at it, use utility function iov_memset() from
iov.h in posix-aio-compat.c, where qiov was used.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-10 13:54:23 +01:00
|
|
|
qemu_iovec_memset(qiov, 512 * n1, 0, 512 * (nb_sectors - n1));
|
2010-09-13 18:08:52 +02:00
|
|
|
|
2006-08-06 15:34:04 +02:00
|
|
|
return n1;
|
|
|
|
}
|
|
|
|
|
2011-11-10 09:23:22 +01:00
|
|
|
static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
|
2011-08-23 15:21:19 +02:00
|
|
|
int remaining_sectors, QEMUIOVector *qiov)
|
2006-08-05 23:14:20 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2006-08-06 15:34:04 +02:00
|
|
|
int index_in_cluster, n1;
|
2011-06-30 17:42:09 +02:00
|
|
|
int ret;
|
2011-08-23 15:21:14 +02:00
|
|
|
int cur_nr_sectors; /* number of sectors in current iteration */
|
2011-08-23 15:21:16 +02:00
|
|
|
uint64_t cluster_offset = 0;
|
2011-08-23 15:21:19 +02:00
|
|
|
uint64_t bytes_done = 0;
|
|
|
|
QEMUIOVector hd_qiov;
|
|
|
|
uint8_t *cluster_data = NULL;
|
2006-08-05 23:14:20 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_init(&hd_qiov, qiov->niov);
|
|
|
|
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
|
|
|
|
while (remaining_sectors != 0) {
|
2010-09-13 18:08:52 +02:00
|
|
|
|
2011-08-23 15:21:18 +02:00
|
|
|
/* prepare next request */
|
2011-08-23 15:21:19 +02:00
|
|
|
cur_nr_sectors = remaining_sectors;
|
2015-07-01 19:10:37 +02:00
|
|
|
if (s->cipher) {
|
2011-08-23 15:21:18 +02:00
|
|
|
cur_nr_sectors = MIN(cur_nr_sectors,
|
|
|
|
QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
2011-08-23 15:21:18 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
ret = qcow2_get_cluster_offset(bs, sector_num << 9,
|
2011-08-23 15:21:18 +02:00
|
|
|
&cur_nr_sectors, &cluster_offset);
|
2011-02-09 10:26:06 +01:00
|
|
|
if (ret < 0) {
|
2011-08-23 15:21:19 +02:00
|
|
|
goto fail;
|
2011-02-09 10:26:06 +01:00
|
|
|
}
|
2010-09-13 18:08:52 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
index_in_cluster = sector_num & (s->cluster_sectors - 1);
|
2009-04-07 20:43:20 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_reset(&hd_qiov);
|
consolidate qemu_iovec_copy() and qemu_iovec_concat() and make them consistent
qemu_iovec_concat() is currently a wrapper for
qemu_iovec_copy(), use the former (with extra
"0" arg) in a few places where it is used.
Change skip argument of qemu_iovec_copy() from
uint64_t to size_t, since size of qiov itself
is size_t, so there's no way to skip larger
sizes. Rename it to soffset, to make it clear
that the offset is applied to src.
Also change the only usage of uint64_t in
hw/9pfs/virtio-9p.c, in v9fs_init_qiov_from_pdu() -
all callers of it actually uses size_t too,
not uint64_t.
One added restriction: as for all other iovec-related
functions, soffset must point inside src.
Order of argumens is already good:
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes)
vs:
qemu_iovec_concat(QEMUIOVector *dst,
QEMUIOVector *src,
size_t soffset, size_t sbytes)
(note soffset is after _src_ not dst, since it applies to src;
for memset it applies to qiov).
Note that in many places where this function is used,
the previous call is qemu_iovec_reset(), which means
many callers actually want copy (replacing dst content),
not concat. So we may want to add a wrapper like
qemu_iovec_copy() with the same arguments but which
calls qemu_iovec_reset() before _concat().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-12 18:28:06 +01:00
|
|
|
qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
|
2011-08-23 15:21:18 +02:00
|
|
|
cur_nr_sectors * 512);
|
|
|
|
|
2012-03-14 19:15:03 +01:00
|
|
|
switch (ret) {
|
|
|
|
case QCOW2_CLUSTER_UNALLOCATED:
|
2011-08-23 15:21:18 +02:00
|
|
|
|
2015-06-17 14:55:21 +02:00
|
|
|
if (bs->backing) {
|
2011-08-23 15:21:18 +02:00
|
|
|
/* read from the base image */
|
2015-06-17 14:55:21 +02:00
|
|
|
n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov,
|
2011-08-23 15:21:19 +02:00
|
|
|
sector_num, cur_nr_sectors);
|
2011-08-23 15:21:18 +02:00
|
|
|
if (n1 > 0) {
|
2014-07-03 14:43:32 +02:00
|
|
|
QEMUIOVector local_qiov;
|
|
|
|
|
|
|
|
qemu_iovec_init(&local_qiov, hd_qiov.niov);
|
|
|
|
qemu_iovec_concat(&local_qiov, &hd_qiov, 0,
|
|
|
|
n1 * BDRV_SECTOR_SIZE);
|
|
|
|
|
2011-08-23 15:21:18 +02:00
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2015-06-17 14:55:21 +02:00
|
|
|
ret = bdrv_co_readv(bs->backing->bs, sector_num,
|
2014-07-03 14:43:32 +02:00
|
|
|
n1, &local_qiov);
|
2011-08-23 15:21:18 +02:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2014-07-03 14:43:32 +02:00
|
|
|
|
|
|
|
qemu_iovec_destroy(&local_qiov);
|
|
|
|
|
2011-08-23 15:21:18 +02:00
|
|
|
if (ret < 0) {
|
2011-08-23 15:21:19 +02:00
|
|
|
goto fail;
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Note: in this case, no need to wait */
|
consolidate qemu_iovec_memset{,_skip}() into single function and use existing iov_memset()
This patch combines two functions into one, and replaces
the implementation with already existing iov_memset() from
iov.c.
The new prototype of qemu_iovec_memset():
size_t qemu_iovec_memset(qiov, size_t offset, int fillc, size_t bytes)
It is different from former qemu_iovec_memset_skip(), and
I want to make other functions to be consistent with it
too: first how much to skip, second what, and 3rd how many
of it. It also returns actual number of bytes filled in,
which may be less than the requested `bytes' if qiov is
smaller than offset+bytes, in the same way iov_memset()
does.
While at it, use utility function iov_memset() from
iov.h in posix-aio-compat.c, where qiov was used.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-10 13:54:23 +01:00
|
|
|
qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors);
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2012-03-14 19:15:03 +01:00
|
|
|
break;
|
|
|
|
|
2012-03-16 15:02:38 +01:00
|
|
|
case QCOW2_CLUSTER_ZERO:
|
consolidate qemu_iovec_memset{,_skip}() into single function and use existing iov_memset()
This patch combines two functions into one, and replaces
the implementation with already existing iov_memset() from
iov.c.
The new prototype of qemu_iovec_memset():
size_t qemu_iovec_memset(qiov, size_t offset, int fillc, size_t bytes)
It is different from former qemu_iovec_memset_skip(), and
I want to make other functions to be consistent with it
too: first how much to skip, second what, and 3rd how many
of it. It also returns actual number of bytes filled in,
which may be less than the requested `bytes' if qiov is
smaller than offset+bytes, in the same way iov_memset()
does.
While at it, use utility function iov_memset() from
iov.h in posix-aio-compat.c, where qiov was used.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-10 13:54:23 +01:00
|
|
|
qemu_iovec_memset(&hd_qiov, 0, 0, 512 * cur_nr_sectors);
|
2012-03-16 15:02:38 +01:00
|
|
|
break;
|
|
|
|
|
2012-03-14 19:15:03 +01:00
|
|
|
case QCOW2_CLUSTER_COMPRESSED:
|
2011-08-23 15:21:18 +02:00
|
|
|
/* add AIO support for compressed blocks ? */
|
|
|
|
ret = qcow2_decompress_cluster(bs, cluster_offset);
|
|
|
|
if (ret < 0) {
|
2011-08-23 15:21:19 +02:00
|
|
|
goto fail;
|
2010-09-13 18:08:52 +02:00
|
|
|
}
|
|
|
|
|
allow qemu_iovec_from_buffer() to specify offset from which to start copying
Similar to
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes);
the new prototype is:
qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
const void *buf, size_t bytes);
The processing starts at offset bytes within qiov.
This way, we may copy a bounce buffer directly to
a middle of qiov.
This is exactly the same function as iov_from_buf() from
iov.c, so use the existing implementation and rename it
to qemu_iovec_from_buf() to be shorter and to match the
utility function.
As with utility implementation, we now assert that the
offset is inside actual iovec. Nothing changed for
current callers, because `offset' parameter is new.
While at it, stop using "bounce-qiov" in block/qcow2.c
and copy decrypted data directly from cluster_data
instead of recreating a temp qiov for doing that.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-07 18:17:55 +02:00
|
|
|
qemu_iovec_from_buf(&hd_qiov, 0,
|
2011-08-23 15:21:18 +02:00
|
|
|
s->cluster_cache + index_in_cluster * 512,
|
2011-08-23 15:21:14 +02:00
|
|
|
512 * cur_nr_sectors);
|
2012-03-14 19:15:03 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case QCOW2_CLUSTER_NORMAL:
|
2011-08-23 15:21:18 +02:00
|
|
|
if ((cluster_offset & 511) != 0) {
|
2011-08-23 15:21:19 +02:00
|
|
|
ret = -EIO;
|
|
|
|
goto fail;
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2010-09-13 18:08:52 +02:00
|
|
|
|
qcow2/qcow: protect against uninitialized encryption key
When a qcow[2] file is opened, if the header reports an
encryption method, this is used to set the 'crypt_method_header'
field on the BDRVQcow[2]State struct, and the 'encrypted' flag
in the BDRVState struct.
When doing I/O operations, the 'crypt_method' field on the
BDRVQcow[2]State struct is checked to determine if encryption
needs to be applied.
The crypt_method_header value is copied into crypt_method when
the bdrv_set_key() method is called.
The QEMU code which opens a block device is expected to always
do a check
if (bdrv_is_encrypted(bs)) {
bdrv_set_key(bs, ....key...);
}
If code forgets to do this, then 'crypt_method' is never set
and so when I/O is performed, QEMU writes plain text data
into a sector which is expected to contain cipher text, or
when reading, will return cipher text instead of plain
text.
Change the qcow[2] code to consult bs->encrypted when deciding
whether encryption is required, and assert(s->crypt_method)
to protect against cases where the caller forgets to set the
encryption key.
Also put an assert in the set_key methods to protect against
the case where the caller sets an encryption key on a block
device that does not have encryption
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-05-12 18:09:18 +02:00
|
|
|
if (bs->encrypted) {
|
2015-07-01 19:10:37 +02:00
|
|
|
assert(s->cipher);
|
qcow2/qcow: protect against uninitialized encryption key
When a qcow[2] file is opened, if the header reports an
encryption method, this is used to set the 'crypt_method_header'
field on the BDRVQcow[2]State struct, and the 'encrypted' flag
in the BDRVState struct.
When doing I/O operations, the 'crypt_method' field on the
BDRVQcow[2]State struct is checked to determine if encryption
needs to be applied.
The crypt_method_header value is copied into crypt_method when
the bdrv_set_key() method is called.
The QEMU code which opens a block device is expected to always
do a check
if (bdrv_is_encrypted(bs)) {
bdrv_set_key(bs, ....key...);
}
If code forgets to do this, then 'crypt_method' is never set
and so when I/O is performed, QEMU writes plain text data
into a sector which is expected to contain cipher text, or
when reading, will return cipher text instead of plain
text.
Change the qcow[2] code to consult bs->encrypted when deciding
whether encryption is required, and assert(s->crypt_method)
to protect against cases where the caller forgets to set the
encryption key.
Also put an assert in the set_key methods to protect against
the case where the caller sets an encryption key on a block
device that does not have encryption
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-05-12 18:09:18 +02:00
|
|
|
|
2011-08-23 15:21:18 +02:00
|
|
|
/*
|
|
|
|
* For encrypted images, read everything into a temporary
|
|
|
|
* contiguous buffer on which the AES functions can work.
|
|
|
|
*/
|
2011-08-23 15:21:19 +02:00
|
|
|
if (!cluster_data) {
|
|
|
|
cluster_data =
|
2015-06-16 14:19:22 +02:00
|
|
|
qemu_try_blockalign(bs->file->bs,
|
|
|
|
QCOW_MAX_CRYPT_CLUSTERS
|
|
|
|
* s->cluster_size);
|
2014-05-20 17:12:47 +02:00
|
|
|
if (cluster_data == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(cur_nr_sectors <=
|
|
|
|
QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors);
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_reset(&hd_qiov);
|
|
|
|
qemu_iovec_add(&hd_qiov, cluster_data,
|
2011-08-23 15:21:18 +02:00
|
|
|
512 * cur_nr_sectors);
|
|
|
|
}
|
|
|
|
|
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_co_readv(bs->file->bs,
|
2011-08-23 15:21:18 +02:00
|
|
|
(cluster_offset >> 9) + index_in_cluster,
|
2011-08-23 15:21:19 +02:00
|
|
|
cur_nr_sectors, &hd_qiov);
|
2011-08-23 15:21:18 +02:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
if (ret < 0) {
|
2011-08-23 15:21:19 +02:00
|
|
|
goto fail;
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
qcow2/qcow: protect against uninitialized encryption key
When a qcow[2] file is opened, if the header reports an
encryption method, this is used to set the 'crypt_method_header'
field on the BDRVQcow[2]State struct, and the 'encrypted' flag
in the BDRVState struct.
When doing I/O operations, the 'crypt_method' field on the
BDRVQcow[2]State struct is checked to determine if encryption
needs to be applied.
The crypt_method_header value is copied into crypt_method when
the bdrv_set_key() method is called.
The QEMU code which opens a block device is expected to always
do a check
if (bdrv_is_encrypted(bs)) {
bdrv_set_key(bs, ....key...);
}
If code forgets to do this, then 'crypt_method' is never set
and so when I/O is performed, QEMU writes plain text data
into a sector which is expected to contain cipher text, or
when reading, will return cipher text instead of plain
text.
Change the qcow[2] code to consult bs->encrypted when deciding
whether encryption is required, and assert(s->crypt_method)
to protect against cases where the caller forgets to set the
encryption key.
Also put an assert in the set_key methods to protect against
the case where the caller sets an encryption key on a block
device that does not have encryption
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-05-12 18:09:18 +02:00
|
|
|
if (bs->encrypted) {
|
2015-07-01 19:10:37 +02:00
|
|
|
assert(s->cipher);
|
|
|
|
Error *err = NULL;
|
|
|
|
if (qcow2_encrypt_sectors(s, sector_num, cluster_data,
|
|
|
|
cluster_data, cur_nr_sectors, false,
|
|
|
|
&err) < 0) {
|
|
|
|
error_free(err);
|
|
|
|
ret = -EIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
allow qemu_iovec_from_buffer() to specify offset from which to start copying
Similar to
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes);
the new prototype is:
qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
const void *buf, size_t bytes);
The processing starts at offset bytes within qiov.
This way, we may copy a bounce buffer directly to
a middle of qiov.
This is exactly the same function as iov_from_buf() from
iov.c, so use the existing implementation and rename it
to qemu_iovec_from_buf() to be shorter and to match the
utility function.
As with utility implementation, we now assert that the
offset is inside actual iovec. Nothing changed for
current callers, because `offset' parameter is new.
While at it, stop using "bounce-qiov" in block/qcow2.c
and copy decrypted data directly from cluster_data
instead of recreating a temp qiov for doing that.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-06-07 18:17:55 +02:00
|
|
|
qemu_iovec_from_buf(qiov, bytes_done,
|
|
|
|
cluster_data, 512 * cur_nr_sectors);
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2012-03-14 19:15:03 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
ret = -EIO;
|
|
|
|
goto fail;
|
2011-08-23 15:21:14 +02:00
|
|
|
}
|
2009-04-07 20:43:24 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
remaining_sectors -= cur_nr_sectors;
|
|
|
|
sector_num += cur_nr_sectors;
|
|
|
|
bytes_done += cur_nr_sectors * 512;
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2011-08-23 15:21:19 +02:00
|
|
|
ret = 0;
|
2011-08-23 15:21:14 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
fail:
|
2011-06-30 17:42:09 +02:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2011-06-07 15:04:32 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_destroy(&hd_qiov);
|
2011-09-10 10:59:16 +02:00
|
|
|
qemu_vfree(cluster_data);
|
2011-06-30 17:42:09 +02:00
|
|
|
|
|
|
|
return ret;
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
|
|
|
|
2011-11-10 09:23:22 +01:00
|
|
|
static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
|
2011-08-23 15:21:19 +02:00
|
|
|
int64_t sector_num,
|
|
|
|
int remaining_sectors,
|
|
|
|
QEMUIOVector *qiov)
|
2006-08-05 23:14:20 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2006-08-05 23:14:20 +02:00
|
|
|
int index_in_cluster;
|
2011-06-30 17:42:09 +02:00
|
|
|
int ret;
|
2011-08-23 15:21:14 +02:00
|
|
|
int cur_nr_sectors; /* number of sectors in current iteration */
|
2011-08-23 15:21:16 +02:00
|
|
|
uint64_t cluster_offset;
|
2011-08-23 15:21:19 +02:00
|
|
|
QEMUIOVector hd_qiov;
|
|
|
|
uint64_t bytes_done = 0;
|
|
|
|
uint8_t *cluster_data = NULL;
|
2013-01-14 17:31:31 +01:00
|
|
|
QCowL2Meta *l2meta = NULL;
|
2011-08-23 15:21:15 +02:00
|
|
|
|
2012-03-01 18:36:21 +01:00
|
|
|
trace_qcow2_writev_start_req(qemu_coroutine_self(), sector_num,
|
|
|
|
remaining_sectors);
|
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_init(&hd_qiov, qiov->niov);
|
|
|
|
|
|
|
|
s->cluster_cache_offset = -1; /* disable compressed cache */
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
|
|
|
|
while (remaining_sectors != 0) {
|
|
|
|
|
2012-12-07 18:08:46 +01:00
|
|
|
l2meta = NULL;
|
2012-12-07 18:08:44 +01:00
|
|
|
|
2012-03-01 18:36:21 +01:00
|
|
|
trace_qcow2_writev_start_part(qemu_coroutine_self());
|
2011-08-23 15:21:19 +02:00
|
|
|
index_in_cluster = sector_num & (s->cluster_sectors - 1);
|
2014-01-26 04:12:37 +01:00
|
|
|
cur_nr_sectors = remaining_sectors;
|
qcow2/qcow: protect against uninitialized encryption key
When a qcow[2] file is opened, if the header reports an
encryption method, this is used to set the 'crypt_method_header'
field on the BDRVQcow[2]State struct, and the 'encrypted' flag
in the BDRVState struct.
When doing I/O operations, the 'crypt_method' field on the
BDRVQcow[2]State struct is checked to determine if encryption
needs to be applied.
The crypt_method_header value is copied into crypt_method when
the bdrv_set_key() method is called.
The QEMU code which opens a block device is expected to always
do a check
if (bdrv_is_encrypted(bs)) {
bdrv_set_key(bs, ....key...);
}
If code forgets to do this, then 'crypt_method' is never set
and so when I/O is performed, QEMU writes plain text data
into a sector which is expected to contain cipher text, or
when reading, will return cipher text instead of plain
text.
Change the qcow[2] code to consult bs->encrypted when deciding
whether encryption is required, and assert(s->crypt_method)
to protect against cases where the caller forgets to set the
encryption key.
Also put an assert in the set_key methods to protect against
the case where the caller sets an encryption key on a block
device that does not have encryption
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-05-12 18:09:18 +02:00
|
|
|
if (bs->encrypted &&
|
2014-01-26 04:12:37 +01:00
|
|
|
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;
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2008-08-14 20:10:28 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
ret = qcow2_alloc_cluster_offset(bs, sector_num << 9,
|
2014-01-26 04:12:37 +01:00
|
|
|
&cur_nr_sectors, &cluster_offset, &l2meta);
|
2011-08-23 15:21:18 +02:00
|
|
|
if (ret < 0) {
|
2011-08-23 15:21:19 +02:00
|
|
|
goto fail;
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2010-01-20 15:03:01 +01:00
|
|
|
|
2011-08-23 15:21:18 +02:00
|
|
|
assert((cluster_offset & 511) == 0);
|
2010-01-20 15:03:01 +01:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_reset(&hd_qiov);
|
consolidate qemu_iovec_copy() and qemu_iovec_concat() and make them consistent
qemu_iovec_concat() is currently a wrapper for
qemu_iovec_copy(), use the former (with extra
"0" arg) in a few places where it is used.
Change skip argument of qemu_iovec_copy() from
uint64_t to size_t, since size of qiov itself
is size_t, so there's no way to skip larger
sizes. Rename it to soffset, to make it clear
that the offset is applied to src.
Also change the only usage of uint64_t in
hw/9pfs/virtio-9p.c, in v9fs_init_qiov_from_pdu() -
all callers of it actually uses size_t too,
not uint64_t.
One added restriction: as for all other iovec-related
functions, soffset must point inside src.
Order of argumens is already good:
qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int c, size_t bytes)
vs:
qemu_iovec_concat(QEMUIOVector *dst,
QEMUIOVector *src,
size_t soffset, size_t sbytes)
(note soffset is after _src_ not dst, since it applies to src;
for memset it applies to qiov).
Note that in many places where this function is used,
the previous call is qemu_iovec_reset(), which means
many callers actually want copy (replacing dst content),
not concat. So we may want to add a wrapper like
qemu_iovec_copy() with the same arguments but which
calls qemu_iovec_reset() before _concat().
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-12 18:28:06 +01:00
|
|
|
qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
|
2011-08-23 15:21:18 +02:00
|
|
|
cur_nr_sectors * 512);
|
2010-09-13 18:24:10 +02:00
|
|
|
|
qcow2/qcow: protect against uninitialized encryption key
When a qcow[2] file is opened, if the header reports an
encryption method, this is used to set the 'crypt_method_header'
field on the BDRVQcow[2]State struct, and the 'encrypted' flag
in the BDRVState struct.
When doing I/O operations, the 'crypt_method' field on the
BDRVQcow[2]State struct is checked to determine if encryption
needs to be applied.
The crypt_method_header value is copied into crypt_method when
the bdrv_set_key() method is called.
The QEMU code which opens a block device is expected to always
do a check
if (bdrv_is_encrypted(bs)) {
bdrv_set_key(bs, ....key...);
}
If code forgets to do this, then 'crypt_method' is never set
and so when I/O is performed, QEMU writes plain text data
into a sector which is expected to contain cipher text, or
when reading, will return cipher text instead of plain
text.
Change the qcow[2] code to consult bs->encrypted when deciding
whether encryption is required, and assert(s->crypt_method)
to protect against cases where the caller forgets to set the
encryption key.
Also put an assert in the set_key methods to protect against
the case where the caller sets an encryption key on a block
device that does not have encryption
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2015-05-12 18:09:18 +02:00
|
|
|
if (bs->encrypted) {
|
2015-07-01 19:10:37 +02:00
|
|
|
Error *err = NULL;
|
|
|
|
assert(s->cipher);
|
2011-08-23 15:21:19 +02:00
|
|
|
if (!cluster_data) {
|
2015-06-16 14:19:22 +02:00
|
|
|
cluster_data = qemu_try_blockalign(bs->file->bs,
|
2014-05-20 17:12:47 +02:00
|
|
|
QCOW_MAX_CRYPT_CLUSTERS
|
|
|
|
* s->cluster_size);
|
|
|
|
if (cluster_data == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2010-09-13 18:24:10 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
assert(hd_qiov.size <=
|
2011-08-23 15:21:18 +02:00
|
|
|
QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
|
2012-06-07 18:21:06 +02:00
|
|
|
qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
|
2010-09-13 18:24:10 +02:00
|
|
|
|
2015-07-01 19:10:37 +02:00
|
|
|
if (qcow2_encrypt_sectors(s, sector_num, cluster_data,
|
|
|
|
cluster_data, cur_nr_sectors,
|
|
|
|
true, &err) < 0) {
|
|
|
|
error_free(err);
|
|
|
|
ret = -EIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-09-13 18:24:10 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_reset(&hd_qiov);
|
|
|
|
qemu_iovec_add(&hd_qiov, cluster_data,
|
2011-08-23 15:21:18 +02:00
|
|
|
cur_nr_sectors * 512);
|
|
|
|
}
|
2010-09-13 18:24:10 +02:00
|
|
|
|
2013-10-10 11:09:23 +02:00
|
|
|
ret = qcow2_pre_write_overlap_check(bs, 0,
|
2013-08-30 14:34:26 +02:00
|
|
|
cluster_offset + index_in_cluster * BDRV_SECTOR_SIZE,
|
|
|
|
cur_nr_sectors * BDRV_SECTOR_SIZE);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-08-23 15:21:18 +02:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2012-12-06 14:32:59 +01:00
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
|
2012-03-01 18:36:21 +01:00
|
|
|
trace_qcow2_writev_data(qemu_coroutine_self(),
|
|
|
|
(cluster_offset >> 9) + index_in_cluster);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_co_writev(bs->file->bs,
|
2011-08-23 15:21:18 +02:00
|
|
|
(cluster_offset >> 9) + index_in_cluster,
|
2011-08-23 15:21:19 +02:00
|
|
|
cur_nr_sectors, &hd_qiov);
|
2011-08-23 15:21:18 +02:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
if (ret < 0) {
|
2011-08-23 15:21:19 +02:00
|
|
|
goto fail;
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2009-04-07 20:43:24 +02:00
|
|
|
|
2013-03-26 17:50:11 +01:00
|
|
|
while (l2meta != NULL) {
|
|
|
|
QCowL2Meta *next;
|
|
|
|
|
2012-12-07 18:08:46 +01:00
|
|
|
ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-08-23 15:21:14 +02:00
|
|
|
|
2012-12-07 18:08:48 +01:00
|
|
|
/* 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);
|
|
|
|
|
2013-03-26 17:50:11 +01:00
|
|
|
next = l2meta->next;
|
2012-12-07 18:08:46 +01:00
|
|
|
g_free(l2meta);
|
2013-03-26 17:50:11 +01:00
|
|
|
l2meta = next;
|
2012-12-07 18:08:46 +01:00
|
|
|
}
|
2011-09-01 15:02:13 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
remaining_sectors -= cur_nr_sectors;
|
|
|
|
sector_num += cur_nr_sectors;
|
|
|
|
bytes_done += cur_nr_sectors * 512;
|
2012-03-01 18:36:21 +01:00
|
|
|
trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_nr_sectors);
|
2011-08-23 15:21:18 +02:00
|
|
|
}
|
2011-08-23 15:21:19 +02:00
|
|
|
ret = 0;
|
2011-08-23 15:21:14 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
fail:
|
2012-12-07 18:08:48 +01:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
|
2013-03-26 17:50:11 +01:00
|
|
|
while (l2meta != NULL) {
|
|
|
|
QCowL2Meta *next;
|
|
|
|
|
2012-12-07 18:08:48 +01:00
|
|
|
if (l2meta->nb_clusters != 0) {
|
|
|
|
QLIST_REMOVE(l2meta, next_in_flight);
|
|
|
|
}
|
|
|
|
qemu_co_queue_restart_all(&l2meta->dependent_requests);
|
2013-03-26 17:50:11 +01:00
|
|
|
|
|
|
|
next = l2meta->next;
|
2012-12-07 18:08:44 +01:00
|
|
|
g_free(l2meta);
|
2013-03-26 17:50:11 +01:00
|
|
|
l2meta = next;
|
2012-12-07 18:08:44 +01:00
|
|
|
}
|
2011-09-01 15:02:13 +02:00
|
|
|
|
2011-08-23 15:21:19 +02:00
|
|
|
qemu_iovec_destroy(&hd_qiov);
|
2011-09-10 10:59:16 +02:00
|
|
|
qemu_vfree(cluster_data);
|
2012-03-01 18:36:21 +01:00
|
|
|
trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
|
2011-06-07 15:04:32 +02:00
|
|
|
|
2011-06-30 17:42:09 +02:00
|
|
|
return ret;
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
|
|
|
|
2015-12-22 16:04:57 +01:00
|
|
|
static int qcow2_inactivate(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVQcow2State *s = bs->opaque;
|
|
|
|
int ret, result = 0;
|
|
|
|
|
|
|
|
ret = qcow2_cache_flush(bs, s->l2_table_cache);
|
|
|
|
if (ret) {
|
|
|
|
result = ret;
|
|
|
|
error_report("Failed to flush the L2 table cache: %s",
|
|
|
|
strerror(-ret));
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = qcow2_cache_flush(bs, s->refcount_block_cache);
|
|
|
|
if (ret) {
|
|
|
|
result = ret;
|
|
|
|
error_report("Failed to flush the refcount block cache: %s",
|
|
|
|
strerror(-ret));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (result == 0) {
|
|
|
|
qcow2_mark_clean(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
static void qcow2_close(BlockDriverState *bs)
|
2006-08-05 23:14:20 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2014-05-20 17:12:47 +02:00
|
|
|
qemu_vfree(s->l1_table);
|
2013-08-30 14:34:26 +02:00
|
|
|
/* else pre-write overlap checks in cache_destroy may crash */
|
|
|
|
s->l1_table = NULL;
|
2011-01-10 17:17:28 +01:00
|
|
|
|
2015-12-22 16:10:32 +01:00
|
|
|
if (!(s->flags & BDRV_O_INACTIVE)) {
|
2015-12-22 16:04:57 +01:00
|
|
|
qcow2_inactivate(bs);
|
2014-03-11 15:15:03 +01:00
|
|
|
}
|
2012-07-27 10:05:19 +02:00
|
|
|
|
2015-08-04 14:14:40 +02:00
|
|
|
cache_clean_timer_del(bs);
|
2011-01-10 17:17:28 +01:00
|
|
|
qcow2_cache_destroy(bs, s->l2_table_cache);
|
|
|
|
qcow2_cache_destroy(bs, s->refcount_block_cache);
|
|
|
|
|
2015-07-01 19:10:37 +02:00
|
|
|
qcrypto_cipher_free(s->cipher);
|
|
|
|
s->cipher = NULL;
|
|
|
|
|
2011-12-15 12:20:58 +01:00
|
|
|
g_free(s->unknown_header_fields);
|
2012-02-02 14:52:08 +01:00
|
|
|
cleanup_unknown_header_ext(bs);
|
2011-12-15 12:20:58 +01:00
|
|
|
|
2015-04-07 15:03:16 +02:00
|
|
|
g_free(s->image_backing_file);
|
|
|
|
g_free(s->image_backing_format);
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s->cluster_cache);
|
2011-09-10 10:59:16 +02:00
|
|
|
qemu_vfree(s->cluster_data);
|
2009-05-28 16:07:07 +02:00
|
|
|
qcow2_refcount_close(bs);
|
2011-12-07 10:25:48 +01:00
|
|
|
qcow2_free_snapshots(bs);
|
2006-08-05 23:14:20 +02:00
|
|
|
}
|
|
|
|
|
2014-03-12 15:59:16 +01:00
|
|
|
static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
|
2011-11-14 22:09:46 +01:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2011-11-14 22:09:46 +01:00
|
|
|
int flags = s->flags;
|
2015-07-01 19:10:37 +02:00
|
|
|
QCryptoCipher *cipher = NULL;
|
2013-03-18 13:08:10 +01:00
|
|
|
QDict *options;
|
2014-03-12 15:59:16 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
2011-11-14 22:09:46 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Backing files are read-only which makes all of their metadata immutable,
|
|
|
|
* that means we don't have to worry about reopening them here.
|
|
|
|
*/
|
|
|
|
|
2015-07-01 19:10:37 +02:00
|
|
|
cipher = s->cipher;
|
|
|
|
s->cipher = NULL;
|
2011-11-14 22:09:46 +01:00
|
|
|
|
|
|
|
qcow2_close(bs);
|
|
|
|
|
2015-09-07 17:12:56 +02:00
|
|
|
memset(s, 0, sizeof(BDRVQcow2State));
|
2014-03-11 17:42:41 +01:00
|
|
|
options = qdict_clone_shallow(bs->options);
|
2014-03-12 15:59:16 +01:00
|
|
|
|
2015-12-22 16:10:32 +01:00
|
|
|
flags &= ~BDRV_O_INACTIVE;
|
2014-03-12 15:59:16 +01:00
|
|
|
ret = qcow2_open(bs, options, flags, &local_err);
|
2014-05-28 11:16:56 +02:00
|
|
|
QDECREF(options);
|
2014-03-12 15:59:16 +01:00
|
|
|
if (local_err) {
|
error: Use error_prepend() where it makes obvious sense
Done with this Coccinelle semantic patch
@@
expression FMT, E1, E2;
expression list ARGS;
@@
- error_setg(E1, FMT, ARGS, error_get_pretty(E2));
+ error_propagate(E1, E2);/*###*/
+ error_prepend(E1, FMT/*@@@*/, ARGS);
followed by manual cleanup, first because I can't figure out how to
make Coccinelle transform strings, and second to get rid of now
superfluous error_propagate().
We now use or propagate the original error whole instead of just its
message obtained with error_get_pretty(). This avoids suppressing its
hint (see commit 50b7b00), but I can't see how the errors touched in
this commit could come with hints. It also improves the message
printed with &error_abort when we screw up (see commit 1e9b65b).
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
2015-12-18 16:35:15 +01:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
error_prepend(errp, "Could not reopen qcow2 layer: ");
|
2015-12-22 16:14:10 +01:00
|
|
|
bs->drv = NULL;
|
2014-03-12 15:59:16 +01:00
|
|
|
return;
|
|
|
|
} else if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "Could not reopen qcow2 layer");
|
2015-12-22 16:14:10 +01:00
|
|
|
bs->drv = NULL;
|
2014-03-12 15:59:16 +01:00
|
|
|
return;
|
|
|
|
}
|
2013-03-18 13:08:10 +01:00
|
|
|
|
2015-07-01 19:10:37 +02:00
|
|
|
s->cipher = cipher;
|
2011-11-14 22:09:46 +01:00
|
|
|
}
|
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-01-12 12:55:17 +01:00
|
|
|
/*
|
2012-02-02 12:32:31 +01:00
|
|
|
* 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.
|
2010-01-12 12:55:17 +01:00
|
|
|
*
|
|
|
|
* Returns 0 on success, -errno in error cases.
|
|
|
|
*/
|
2012-02-02 12:32:31 +01:00
|
|
|
int qcow2_update_header(BlockDriverState *bs)
|
2010-01-12 12:55:17 +01:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2012-02-02 12:32:31 +01:00
|
|
|
QCowHeader *header;
|
|
|
|
char *buf;
|
|
|
|
size_t buflen = s->cluster_size;
|
2010-01-12 12:55:17 +01:00
|
|
|
int ret;
|
2012-02-02 12:32:31 +01:00
|
|
|
uint64_t total_size;
|
|
|
|
uint32_t refcount_table_clusters;
|
2011-12-15 12:20:58 +01:00
|
|
|
size_t header_length;
|
2012-02-02 14:52:08 +01:00
|
|
|
Qcow2UnknownHeaderExtension *uext;
|
2010-01-12 12:55:17 +01:00
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
buf = qemu_blockalign(bs, buflen);
|
2010-01-12 12:55:17 +01:00
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
/* Header structure */
|
|
|
|
header = (QCowHeader*) buf;
|
2010-01-12 12:55:17 +01:00
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
if (buflen < sizeof(*header)) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto fail;
|
2010-01-12 12:55:17 +01:00
|
|
|
}
|
|
|
|
|
2011-12-15 12:20:58 +01:00
|
|
|
header_length = sizeof(*header) + s->unknown_header_fields_size;
|
2012-02-02 12:32:31 +01:00
|
|
|
total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
|
|
|
|
refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
|
|
|
|
|
|
|
|
*header = (QCowHeader) {
|
2011-12-15 12:20:58 +01:00
|
|
|
/* Version 2 fields */
|
2012-02-02 12:32:31 +01:00
|
|
|
.magic = cpu_to_be32(QCOW_MAGIC),
|
2011-12-15 12:20:58 +01:00
|
|
|
.version = cpu_to_be32(s->qcow_version),
|
2012-02-02 12:32:31 +01:00
|
|
|
.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),
|
2011-12-15 12:20:58 +01:00
|
|
|
|
|
|
|
/* 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),
|
2013-09-03 10:09:53 +02:00
|
|
|
.refcount_order = cpu_to_be32(s->refcount_order),
|
2011-12-15 12:20:58 +01:00
|
|
|
.header_length = cpu_to_be32(header_length),
|
2012-02-02 12:32:31 +01:00
|
|
|
};
|
2010-01-12 12:55:17 +01:00
|
|
|
|
2011-12-15 12:20:58 +01:00
|
|
|
/* 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:
|
2012-05-21 13:06:54 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
2011-12-15 12:20:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2010-01-12 12:55:17 +01:00
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
/* Backing file format header extension */
|
2015-04-07 15:03:16 +02:00
|
|
|
if (s->image_backing_format) {
|
2012-02-02 12:32:31 +01:00
|
|
|
ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
|
2015-04-07 15:03:16 +02:00
|
|
|
s->image_backing_format,
|
|
|
|
strlen(s->image_backing_format),
|
2012-02-02 12:32:31 +01:00
|
|
|
buflen);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
2010-01-12 12:55:17 +01:00
|
|
|
}
|
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
buf += ret;
|
|
|
|
buflen -= ret;
|
2010-01-12 12:55:17 +01:00
|
|
|
}
|
|
|
|
|
2012-04-12 15:20:27 +02:00
|
|
|
/* Feature table */
|
2015-12-02 19:11:04 +01:00
|
|
|
if (s->qcow_version >= 3) {
|
|
|
|
Qcow2Feature features[] = {
|
|
|
|
{
|
|
|
|
.type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
|
|
|
|
.bit = QCOW2_INCOMPAT_DIRTY_BITNR,
|
|
|
|
.name = "dirty bit",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
|
|
|
|
.bit = QCOW2_INCOMPAT_CORRUPT_BITNR,
|
|
|
|
.name = "corrupt bit",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.type = QCOW2_FEAT_TYPE_COMPATIBLE,
|
|
|
|
.bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
|
|
|
|
.name = "lazy refcounts",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
|
|
|
|
features, sizeof(features), buflen);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
buf += ret;
|
|
|
|
buflen -= ret;
|
2012-04-12 15:20:27 +02:00
|
|
|
}
|
|
|
|
|
2012-02-02 14:52:08 +01:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
/* End of header extensions */
|
|
|
|
ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
|
2010-01-12 12:55:17 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
buf += ret;
|
|
|
|
buflen -= ret;
|
2010-01-12 12:55:17 +01:00
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
/* Backing file name */
|
2015-04-07 15:03:16 +02:00
|
|
|
if (s->image_backing_file) {
|
|
|
|
size_t backing_file_len = strlen(s->image_backing_file);
|
2012-02-02 12:32:31 +01:00
|
|
|
|
|
|
|
if (buflen < backing_file_len) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2012-10-04 13:10:01 +02:00
|
|
|
/* Using strncpy is ok here, since buf is not NUL-terminated. */
|
2015-04-07 15:03:16 +02:00
|
|
|
strncpy(buf, s->image_backing_file, buflen);
|
2012-02-02 12:32:31 +01:00
|
|
|
|
|
|
|
header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
|
|
|
|
header->backing_file_size = cpu_to_be32(backing_file_len);
|
2010-01-12 12:55:17 +01:00
|
|
|
}
|
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
/* Write the new header */
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pwrite(bs->file->bs, 0, header, s->cluster_size);
|
2010-01-12 12:55:17 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
fail:
|
2012-02-02 12:32:31 +01:00
|
|
|
qemu_vfree(header);
|
2010-01-12 12:55:17 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qcow2_change_backing_file(BlockDriverState *bs,
|
|
|
|
const char *backing_file, const char *backing_fmt)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2015-04-07 15:03:16 +02:00
|
|
|
|
2016-04-06 18:32:48 +02:00
|
|
|
if (backing_file && strlen(backing_file) > 1023) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
|
|
|
|
pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
|
|
|
|
|
2015-04-07 15:03:16 +02:00
|
|
|
g_free(s->image_backing_file);
|
|
|
|
g_free(s->image_backing_format);
|
|
|
|
|
|
|
|
s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
|
|
|
|
s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
|
|
|
|
|
2012-02-02 12:32:31 +01:00
|
|
|
return qcow2_update_header(bs);
|
2010-01-12 12:55:17 +01:00
|
|
|
}
|
|
|
|
|
2009-08-17 15:50:10 +02:00
|
|
|
static int preallocate(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
uint64_t nb_sectors;
|
|
|
|
uint64_t offset;
|
2012-12-07 18:08:45 +01:00
|
|
|
uint64_t host_offset = 0;
|
2009-08-17 15:50:10 +02:00
|
|
|
int num;
|
2010-01-20 15:03:01 +01:00
|
|
|
int ret;
|
2012-12-07 18:08:46 +01:00
|
|
|
QCowL2Meta *meta;
|
2009-08-17 15:50:10 +02:00
|
|
|
|
2014-06-26 13:23:22 +02:00
|
|
|
nb_sectors = bdrv_nb_sectors(bs);
|
2009-08-17 15:50:10 +02:00
|
|
|
offset = 0;
|
|
|
|
|
|
|
|
while (nb_sectors) {
|
2014-01-26 04:12:39 +01:00
|
|
|
num = MIN(nb_sectors, INT_MAX >> BDRV_SECTOR_BITS);
|
2014-01-26 04:12:37 +01:00
|
|
|
ret = qcow2_alloc_cluster_offset(bs, offset, &num,
|
2012-12-07 18:08:45 +01:00
|
|
|
&host_offset, &meta);
|
2010-01-20 15:03:01 +01:00
|
|
|
if (ret < 0) {
|
2010-06-22 16:59:46 +02:00
|
|
|
return ret;
|
2009-08-17 15:50:10 +02:00
|
|
|
}
|
|
|
|
|
2014-04-01 11:12:57 +02:00
|
|
|
while (meta) {
|
|
|
|
QCowL2Meta *next = meta->next;
|
|
|
|
|
2014-01-26 04:12:39 +01:00
|
|
|
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 */
|
2012-12-07 18:08:48 +01:00
|
|
|
QLIST_REMOVE(meta, next_in_flight);
|
2014-04-01 11:12:57 +02:00
|
|
|
|
|
|
|
g_free(meta);
|
|
|
|
meta = next;
|
2012-12-07 18:08:46 +01:00
|
|
|
}
|
2009-08-31 16:48:49 +02:00
|
|
|
|
2009-08-17 15:50:10 +02:00
|
|
|
/* TODO Preallocate data if requested */
|
|
|
|
|
|
|
|
nb_sectors -= num;
|
2014-01-26 04:12:39 +01:00
|
|
|
offset += num << BDRV_SECTOR_BITS;
|
2009-08-17 15:50:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-12-07 18:08:45 +01:00
|
|
|
if (host_offset != 0) {
|
2014-01-26 04:12:39 +01:00
|
|
|
uint8_t buf[BDRV_SECTOR_SIZE];
|
|
|
|
memset(buf, 0, BDRV_SECTOR_SIZE);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_write(bs->file->bs,
|
|
|
|
(host_offset >> BDRV_SECTOR_BITS) + num - 1,
|
2014-01-26 04:12:39 +01:00
|
|
|
buf, 1);
|
2010-06-22 16:59:46 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-17 15:50:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_create2(const char *filename, int64_t total_size,
|
|
|
|
const char *backing_file, const char *backing_format,
|
2014-09-10 11:05:47 +02:00
|
|
|
int flags, size_t cluster_size, PreallocMode prealloc,
|
2015-02-18 23:40:46 +01:00
|
|
|
QemuOpts *opts, int version, int refcount_order,
|
2013-09-05 09:40:43 +02:00
|
|
|
Error **errp)
|
2010-06-11 21:37:37 +02:00
|
|
|
{
|
|
|
|
int cluster_bits;
|
2015-08-26 19:47:48 +02:00
|
|
|
QDict *options;
|
|
|
|
|
|
|
|
/* Calculate cluster_bits */
|
2015-03-23 16:29:26 +01:00
|
|
|
cluster_bits = ctz32(cluster_size);
|
2010-06-11 21:37:37 +02:00
|
|
|
if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
|
|
|
|
(1 << cluster_bits) != cluster_size)
|
|
|
|
{
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "Cluster size must be a power of two between %d and "
|
|
|
|
"%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
|
2010-06-11 21:37:37 +02:00
|
|
|
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.
|
|
|
|
*/
|
2016-03-08 15:57:05 +01:00
|
|
|
BlockBackend *blk;
|
2013-12-04 11:06:36 +01:00
|
|
|
QCowHeader *header;
|
2014-03-28 18:06:31 +01:00
|
|
|
uint64_t* refcount_table;
|
2013-09-05 09:40:43 +02:00
|
|
|
Error *local_err = NULL;
|
2010-06-11 21:37:37 +02:00
|
|
|
int ret;
|
|
|
|
|
2014-09-10 11:05:49 +02:00
|
|
|
if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
|
2015-02-18 23:40:46 +01:00
|
|
|
/* 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. */
|
2014-09-10 11:05:49 +02:00
|
|
|
int64_t meta_size = 0;
|
|
|
|
uint64_t nreftablee, nrefblocke, nl1e, nl2e;
|
|
|
|
int64_t aligned_total_size = align_offset(total_size, cluster_size);
|
2015-02-18 23:40:46 +01:00
|
|
|
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;
|
2014-09-10 11:05:49 +02:00
|
|
|
|
|
|
|
/* 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
|
2015-02-18 23:40:46 +01:00
|
|
|
* rces = refcount entry size in bytes
|
2014-09-10 11:05:49 +02:00
|
|
|
* then,
|
|
|
|
* y1 = (y2 + a)/c
|
2015-02-18 23:40:46 +01:00
|
|
|
* y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m
|
2014-09-10 11:05:49 +02:00
|
|
|
* we can get y1:
|
2015-02-18 23:40:46 +01:00
|
|
|
* y1 = (a + m) / (c - rces - rces * sizeof(u64) / c)
|
2014-09-10 11:05:49 +02:00
|
|
|
*/
|
2015-02-18 23:40:46 +01:00
|
|
|
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;
|
2014-09-10 11:05:49 +02:00
|
|
|
|
|
|
|
/* total size of refcount tables */
|
2015-02-18 23:40:46 +01:00
|
|
|
nreftablee = nrefblocke / refblock_size;
|
2014-09-10 11:05:49 +02:00
|
|
|
nreftablee = align_offset(nreftablee, cluster_size / sizeof(uint64_t));
|
|
|
|
meta_size += nreftablee * sizeof(uint64_t);
|
|
|
|
|
|
|
|
qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
|
2015-02-12 16:46:36 +01:00
|
|
|
aligned_total_size + meta_size, &error_abort);
|
2015-02-12 17:52:20 +01:00
|
|
|
qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_lookup[prealloc],
|
|
|
|
&error_abort);
|
2014-09-10 11:05:49 +02:00
|
|
|
}
|
|
|
|
|
2014-06-05 11:21:11 +02:00
|
|
|
ret = bdrv_create_file(filename, opts, &local_err);
|
2010-06-11 21:37:37 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_propagate(errp, local_err);
|
2010-06-11 21:37:37 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-03-16 19:54:38 +01:00
|
|
|
blk = blk_new_open(filename, NULL, NULL,
|
2016-03-15 14:34:37 +01:00
|
|
|
BDRV_O_RDWR | BDRV_O_PROTOCOL, &local_err);
|
2016-03-08 15:57:05 +01:00
|
|
|
if (blk == NULL) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_propagate(errp, local_err);
|
2016-03-08 15:57:05 +01:00
|
|
|
return -EIO;
|
2010-06-11 21:37:37 +02:00
|
|
|
}
|
|
|
|
|
2016-03-08 15:57:05 +01:00
|
|
|
blk_set_allow_write_beyond_eof(blk, true);
|
|
|
|
|
2010-06-11 21:37:37 +02:00
|
|
|
/* Write the header */
|
2013-12-04 11:06:36 +01:00
|
|
|
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),
|
2015-02-18 23:40:46 +01:00
|
|
|
.refcount_order = cpu_to_be32(refcount_order),
|
2013-12-04 11:06:36 +01:00
|
|
|
.header_length = cpu_to_be32(sizeof(*header)),
|
|
|
|
};
|
2010-06-11 21:37:37 +02:00
|
|
|
|
|
|
|
if (flags & BLOCK_FLAG_ENCRYPT) {
|
2013-12-04 11:06:36 +01:00
|
|
|
header->crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
|
2010-06-11 21:37:37 +02:00
|
|
|
} else {
|
2013-12-04 11:06:36 +01:00
|
|
|
header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
|
2010-06-11 21:37:37 +02:00
|
|
|
}
|
|
|
|
|
2012-07-27 10:05:22 +02:00
|
|
|
if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) {
|
2013-12-04 11:06:36 +01:00
|
|
|
header->compatible_features |=
|
2012-07-27 10:05:22 +02:00
|
|
|
cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
|
|
|
|
}
|
|
|
|
|
2016-05-06 18:26:27 +02:00
|
|
|
ret = blk_pwrite(blk, 0, header, cluster_size, 0);
|
2013-12-04 11:06:36 +01:00
|
|
|
g_free(header);
|
2010-06-11 21:37:37 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not write qcow2 header");
|
2010-06-11 21:37:37 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-03-28 18:06:31 +01:00
|
|
|
/* Write a refcount table with one refcount block */
|
|
|
|
refcount_table = g_malloc0(2 * cluster_size);
|
|
|
|
refcount_table[0] = cpu_to_be64(2 * cluster_size);
|
2016-05-06 18:26:27 +02:00
|
|
|
ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(refcount_table);
|
2010-06-11 21:37:37 +02:00
|
|
|
|
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not write refcount table");
|
2010-06-11 21:37:37 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-03-08 15:57:05 +01:00
|
|
|
blk_unref(blk);
|
|
|
|
blk = NULL;
|
2010-06-11 21:37:37 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
*/
|
2015-08-26 19:47:48 +02:00
|
|
|
options = qdict_new();
|
|
|
|
qdict_put(options, "driver", qstring_from_str("qcow2"));
|
2016-03-16 19:54:38 +01:00
|
|
|
blk = blk_new_open(filename, NULL, options,
|
2016-03-15 14:34:37 +01:00
|
|
|
BDRV_O_RDWR | BDRV_O_NO_FLUSH, &local_err);
|
2016-03-08 15:57:05 +01:00
|
|
|
if (blk == NULL) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_propagate(errp, local_err);
|
2016-03-08 15:57:05 +01:00
|
|
|
ret = -EIO;
|
2010-06-11 21:37:37 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-03-08 15:57:05 +01:00
|
|
|
ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
|
2010-06-11 21:37:37 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
|
|
|
|
"header and refcount table");
|
2010-06-11 21:37:37 +02:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
} else if (ret != 0) {
|
|
|
|
error_report("Huh, first cluster in empty image is already in use?");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2015-12-02 18:34:39 +01:00
|
|
|
/* Create a full header (including things like feature table) */
|
2016-03-08 15:57:05 +01:00
|
|
|
ret = qcow2_update_header(blk_bs(blk));
|
2015-12-02 18:34:39 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
error_setg_errno(errp, -ret, "Could not update qcow2 header");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-06-11 21:37:37 +02:00
|
|
|
/* Okay, now that we have a valid image, let's give it the right size */
|
2016-03-08 15:57:05 +01:00
|
|
|
ret = blk_truncate(blk, total_size);
|
2010-06-11 21:37:37 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not resize image");
|
2010-06-11 21:37:37 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Want a backing file? There you go.*/
|
|
|
|
if (backing_file) {
|
2016-03-08 15:57:05 +01:00
|
|
|
ret = bdrv_change_backing_file(blk_bs(blk), backing_file, backing_format);
|
2010-06-11 21:37:37 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
|
|
|
|
"with format '%s'", backing_file, backing_format);
|
2010-06-11 21:37:37 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* And if we're supposed to preallocate metadata, do that now */
|
2014-09-10 11:05:49 +02:00
|
|
|
if (prealloc != PREALLOC_MODE_OFF) {
|
2016-03-08 15:57:05 +01:00
|
|
|
BDRVQcow2State *s = blk_bs(blk)->opaque;
|
2012-05-07 10:51:03 +02:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2016-03-08 15:57:05 +01:00
|
|
|
ret = preallocate(blk_bs(blk));
|
2012-05-07 10:51:03 +02:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2010-06-11 21:37:37 +02:00
|
|
|
if (ret < 0) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg_errno(errp, -ret, "Could not preallocate metadata");
|
2010-06-11 21:37:37 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-08 15:57:05 +01:00
|
|
|
blk_unref(blk);
|
|
|
|
blk = NULL;
|
2013-10-24 20:35:06 +02:00
|
|
|
|
|
|
|
/* Reopen the image without BDRV_O_NO_FLUSH to flush it before returning */
|
2015-08-26 19:47:48 +02:00
|
|
|
options = qdict_new();
|
|
|
|
qdict_put(options, "driver", qstring_from_str("qcow2"));
|
2016-03-16 19:54:38 +01:00
|
|
|
blk = blk_new_open(filename, NULL, options,
|
2016-03-15 14:34:37 +01:00
|
|
|
BDRV_O_RDWR | BDRV_O_NO_BACKING, &local_err);
|
2016-03-08 15:57:05 +01:00
|
|
|
if (blk == NULL) {
|
2013-10-24 20:35:06 +02:00
|
|
|
error_propagate(errp, local_err);
|
2016-03-08 15:57:05 +01:00
|
|
|
ret = -EIO;
|
2013-10-24 20:35:06 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-06-11 21:37:37 +02:00
|
|
|
ret = 0;
|
|
|
|
out:
|
2016-03-08 15:57:05 +01:00
|
|
|
if (blk) {
|
|
|
|
blk_unref(blk);
|
2014-02-18 18:33:05 +01:00
|
|
|
}
|
2010-06-11 21:37:37 +02:00
|
|
|
return ret;
|
|
|
|
}
|
2010-05-07 12:43:45 +02:00
|
|
|
|
2014-06-05 11:20:59 +02:00
|
|
|
static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
|
2010-05-07 12:43:45 +02:00
|
|
|
{
|
2014-06-05 11:20:59 +02:00
|
|
|
char *backing_file = NULL;
|
|
|
|
char *backing_fmt = NULL;
|
|
|
|
char *buf = NULL;
|
2014-09-10 11:05:46 +02:00
|
|
|
uint64_t size = 0;
|
2010-05-07 12:43:45 +02:00
|
|
|
int flags = 0;
|
2011-05-31 15:01:46 +02:00
|
|
|
size_t cluster_size = DEFAULT_CLUSTER_SIZE;
|
2014-09-10 11:05:47 +02:00
|
|
|
PreallocMode prealloc;
|
2013-08-19 10:38:01 +02:00
|
|
|
int version = 3;
|
2015-02-18 23:40:46 +01:00
|
|
|
uint64_t refcount_bits = 16;
|
|
|
|
int refcount_order;
|
2013-09-05 09:40:43 +02:00
|
|
|
Error *local_err = NULL;
|
|
|
|
int ret;
|
2010-05-07 12:43:45 +02:00
|
|
|
|
|
|
|
/* Read out options */
|
2014-09-10 11:05:46 +02:00
|
|
|
size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
|
|
|
|
BDRV_SECTOR_SIZE);
|
2014-06-05 11:20:59 +02:00
|
|
|
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);
|
2014-09-10 11:05:47 +02:00
|
|
|
prealloc = qapi_enum_parse(PreallocMode_lookup, buf,
|
qapi: Don't let implicit enum MAX member collide
Now that we guarantee the user doesn't have any enum values
beginning with a single underscore, we can use that for our
own purposes. Renaming ENUM_MAX to ENUM__MAX makes it obvious
that the sentinel is generated.
This patch was mostly generated by applying a temporary patch:
|diff --git a/scripts/qapi.py b/scripts/qapi.py
|index e6d014b..b862ec9 100644
|--- a/scripts/qapi.py
|+++ b/scripts/qapi.py
|@@ -1570,6 +1570,7 @@ const char *const %(c_name)s_lookup[] = {
| max_index = c_enum_const(name, 'MAX', prefix)
| ret += mcgen('''
| [%(max_index)s] = NULL,
|+// %(max_index)s
| };
| ''',
| max_index=max_index)
then running:
$ cat qapi-{types,event}.c tests/test-qapi-types.c |
sed -n 's,^// \(.*\)MAX,s|\1MAX|\1_MAX|g,p' > list
$ git grep -l _MAX | xargs sed -i -f list
The only things not generated are the changes in scripts/qapi.py.
Rejecting enum members named 'MAX' is now useless, and will be dropped
in the next patch.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-23-git-send-email-eblake@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
[Rebased to current master, commit message tweaked]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:57 +01:00
|
|
|
PREALLOC_MODE__MAX, PREALLOC_MODE_OFF,
|
2014-09-10 11:05:47 +02:00
|
|
|
&local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2014-06-05 11:20:59 +02:00
|
|
|
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;
|
2010-05-07 12:43:45 +02:00
|
|
|
}
|
|
|
|
|
2014-09-10 11:05:47 +02:00
|
|
|
if (backing_file && prealloc != PREALLOC_MODE_OFF) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "Backing file and preallocation cannot be used at "
|
|
|
|
"the same time");
|
2014-06-05 11:20:59 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto finish;
|
2010-05-07 12:43:45 +02:00
|
|
|
}
|
|
|
|
|
2012-07-27 10:05:22 +02:00
|
|
|
if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_setg(errp, "Lazy refcounts only supported with compatibility "
|
|
|
|
"level 1.1 and above (use compat=1.1 or greater)");
|
2014-06-05 11:20:59 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto finish;
|
2012-07-27 10:05:22 +02:00
|
|
|
}
|
|
|
|
|
2015-02-18 23:40:49 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-02-18 23:40:46 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-03-23 16:29:26 +01:00
|
|
|
refcount_order = ctz32(refcount_bits);
|
2015-02-18 23:40:46 +01:00
|
|
|
|
2014-09-10 11:05:46 +02:00
|
|
|
ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags,
|
2015-02-18 23:40:46 +01:00
|
|
|
cluster_size, prealloc, opts, version, refcount_order,
|
|
|
|
&local_err);
|
2014-01-30 15:07:28 +01:00
|
|
|
if (local_err) {
|
2013-09-05 09:40:43 +02:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
}
|
2014-06-05 11:20:59 +02:00
|
|
|
|
|
|
|
finish:
|
|
|
|
g_free(backing_file);
|
|
|
|
g_free(backing_fmt);
|
|
|
|
g_free(buf);
|
2013-09-05 09:40:43 +02:00
|
|
|
return ret;
|
2010-05-07 12:43:45 +02:00
|
|
|
}
|
|
|
|
|
2016-05-11 09:00:14 +02:00
|
|
|
|
|
|
|
static bool is_zero_cluster(BlockDriverState *bs, int64_t start)
|
|
|
|
{
|
|
|
|
BDRVQcow2State *s = bs->opaque;
|
|
|
|
int nr;
|
|
|
|
BlockDriverState *file;
|
|
|
|
int64_t res = bdrv_get_block_status_above(bs, NULL, start,
|
|
|
|
s->cluster_sectors, &nr, &file);
|
2016-05-17 11:15:42 +02:00
|
|
|
return res >= 0 && (res & BDRV_BLOCK_ZERO);
|
2016-05-11 09:00:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool is_zero_cluster_top_locked(BlockDriverState *bs, int64_t start)
|
|
|
|
{
|
|
|
|
BDRVQcow2State *s = bs->opaque;
|
|
|
|
int nr = s->cluster_sectors;
|
|
|
|
uint64_t off;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = qcow2_get_cluster_offset(bs, start << BDRV_SECTOR_BITS, &nr, &off);
|
|
|
|
return ret == QCOW2_CLUSTER_UNALLOCATED || ret == QCOW2_CLUSTER_ZERO;
|
|
|
|
}
|
|
|
|
|
2012-03-20 15:12:58 +01:00
|
|
|
static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs,
|
2013-10-24 12:06:51 +02:00
|
|
|
int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
|
2012-03-20 15:12:58 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2012-03-20 15:12:58 +01:00
|
|
|
|
2016-05-11 09:00:14 +02:00
|
|
|
int head = sector_num % s->cluster_sectors;
|
|
|
|
int tail = (sector_num + nb_sectors) % s->cluster_sectors;
|
|
|
|
|
|
|
|
if (head != 0 || tail != 0) {
|
|
|
|
int64_t cl_end = -1;
|
|
|
|
|
|
|
|
sector_num -= head;
|
|
|
|
nb_sectors += head;
|
|
|
|
|
|
|
|
if (tail != 0) {
|
|
|
|
nb_sectors += s->cluster_sectors - tail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_zero_cluster(bs, sector_num)) {
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nb_sectors > s->cluster_sectors) {
|
|
|
|
/* Technically the request can cover 2 clusters, f.e. 4k write
|
|
|
|
at s->cluster_sectors - 2k offset. One of these cluster can
|
|
|
|
be zeroed, one unallocated */
|
|
|
|
cl_end = sector_num + nb_sectors - s->cluster_sectors;
|
|
|
|
if (!is_zero_cluster(bs, cl_end)) {
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
/* We can have new write after previous check */
|
|
|
|
if (!is_zero_cluster_top_locked(bs, sector_num) ||
|
|
|
|
(cl_end > 0 && !is_zero_cluster_top_locked(bs, cl_end))) {
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2012-03-20 15:12:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Whatever is left can use real zero clusters */
|
2016-05-11 09:00:14 +02:00
|
|
|
ret = qcow2_zero_clusters(bs, sector_num << BDRV_SECTOR_BITS, nb_sectors);
|
2012-03-20 15:12:58 +01:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-20 13:16:25 +02:00
|
|
|
static coroutine_fn int qcow2_co_discard(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors)
|
2011-01-26 16:56:48 +01:00
|
|
|
{
|
2011-10-20 13:16:25 +02:00
|
|
|
int ret;
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2011-10-20 13:16:25 +02:00
|
|
|
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
ret = qcow2_discard_clusters(bs, sector_num << BDRV_SECTOR_BITS,
|
2014-10-24 15:57:30 +02:00
|
|
|
nb_sectors, QCOW2_DISCARD_REQUEST, false);
|
2011-10-20 13:16:25 +02:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return ret;
|
2011-01-26 16:56:48 +01:00
|
|
|
}
|
|
|
|
|
2010-04-28 12:36:11 +02:00
|
|
|
static int qcow2_truncate(BlockDriverState *bs, int64_t offset)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-05-14 16:14:33 +02:00
|
|
|
int64_t new_l1_size;
|
|
|
|
int ret;
|
2010-04-28 12:36:11 +02:00
|
|
|
|
|
|
|
if (offset & 511) {
|
2012-03-06 12:44:45 +01:00
|
|
|
error_report("The new size must be a multiple of 512");
|
2010-04-28 12:36:11 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cannot proceed if image has snapshots */
|
|
|
|
if (s->nb_snapshots) {
|
2012-03-06 12:44:45 +01:00
|
|
|
error_report("Can't resize an image which has snapshots");
|
2010-04-28 12:36:11 +02:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* shrinking is currently not supported */
|
|
|
|
if (offset < bs->total_sectors * 512) {
|
2012-03-06 12:44:45 +01:00
|
|
|
error_report("qcow2 doesn't support shrinking images yet");
|
2010-04-28 12:36:11 +02:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_l1_size = size_to_l1(s, offset);
|
2010-10-18 17:53:53 +02:00
|
|
|
ret = qcow2_grow_l1_table(bs, new_l1_size, true);
|
2010-04-28 12:36:11 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* write updated header.size */
|
|
|
|
offset = cpu_to_be64(offset);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pwrite_sync(bs->file->bs, offsetof(QCowHeader, size),
|
2010-06-16 17:44:35 +02:00
|
|
|
&offset, sizeof(uint64_t));
|
2010-04-28 12:36:11 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->l1_vm_state_index = new_l1_size;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-23 22:19:47 +02:00
|
|
|
/* XXX: put compressed sectors first, then all the cluster aligned
|
|
|
|
tables to avoid losing bytes in alignment */
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
const uint8_t *buf, int nb_sectors)
|
2010-04-23 22:19:47 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2010-04-23 22:19:47 +02:00
|
|
|
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 */
|
2015-06-16 14:19:22 +02:00
|
|
|
cluster_offset = bdrv_getlength(bs->file->bs);
|
|
|
|
return bdrv_truncate(bs->file->bs, cluster_offset);
|
2010-04-23 22:19:47 +02:00
|
|
|
}
|
|
|
|
|
2013-04-15 17:17:31 +02:00
|
|
|
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;
|
|
|
|
}
|
2010-04-23 22:19:47 +02:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
|
2010-04-23 22:19:47 +02:00
|
|
|
|
|
|
|
/* 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) {
|
2011-10-18 17:12:44 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
2010-04-23 22:19:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2011-10-18 17:12:44 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
2010-04-23 22:19:47 +02:00
|
|
|
}
|
|
|
|
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 */
|
2011-10-18 17:12:44 +02:00
|
|
|
ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-04-23 22:19:47 +02:00
|
|
|
} else {
|
|
|
|
cluster_offset = qcow2_alloc_compressed_cluster_offset(bs,
|
|
|
|
sector_num << 9, out_len);
|
2011-10-18 17:12:44 +02:00
|
|
|
if (!cluster_offset) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-04-23 22:19:47 +02:00
|
|
|
cluster_offset &= s->cluster_offset_mask;
|
2013-08-30 14:34:26 +02:00
|
|
|
|
2013-10-10 11:09:23 +02:00
|
|
|
ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len);
|
2013-08-30 14:34:26 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2010-04-14 14:17:38 +02:00
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pwrite(bs->file->bs, cluster_offset, out_buf, out_len);
|
2011-10-18 17:12:44 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
goto fail;
|
2010-04-23 22:19:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-18 17:12:44 +02:00
|
|
|
ret = 0;
|
|
|
|
fail:
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(out_buf);
|
2011-10-18 17:12:44 +02:00
|
|
|
return ret;
|
2010-04-23 22:19:47 +02:00
|
|
|
}
|
|
|
|
|
2014-10-24 15:57:32 +02:00
|
|
|
static int make_completely_empty(BlockDriverState *bs)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2014-10-24 15:57:32 +02:00
|
|
|
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 */
|
|
|
|
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_write_zeroes(bs->file->bs, s->l1_table_offset / BDRV_SECTOR_SIZE,
|
2014-10-24 15:57:32 +02:00
|
|
|
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 */
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_write_zeroes(bs->file->bs, s->cluster_size / BDRV_SECTOR_SIZE,
|
2014-10-24 15:57:32 +02:00
|
|
|
(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);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pwrite_sync(bs->file->bs, offsetof(QCowHeader, l1_table_offset),
|
2014-10-24 15:57:32 +02:00
|
|
|
&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);
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_pwrite_sync(bs->file->bs, s->cluster_size,
|
2014-10-24 15:57:32 +02:00
|
|
|
&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;
|
|
|
|
}
|
|
|
|
|
2015-06-16 14:19:22 +02:00
|
|
|
ret = bdrv_truncate(bs->file->bs, (3 + l1_clusters) * s->cluster_size);
|
2014-10-24 15:57:32 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-10-24 15:57:31 +02:00
|
|
|
static int qcow2_make_empty(BlockDriverState *bs)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2014-10-24 15:57:31 +02:00
|
|
|
uint64_t start_sector;
|
|
|
|
int sector_step = INT_MAX / BDRV_SECTOR_SIZE;
|
2014-10-24 15:57:32 +02:00
|
|
|
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);
|
|
|
|
}
|
2014-10-24 15:57:31 +02:00
|
|
|
|
2014-10-24 15:57:32 +02:00
|
|
|
/* This fallback code simply discards every active cluster; this is slow,
|
|
|
|
* but works in all cases */
|
2014-10-24 15:57:31 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-11-10 09:23:22 +01:00
|
|
|
static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
|
2010-04-23 22:19:47 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2011-01-10 17:17:28 +01:00
|
|
|
int ret;
|
|
|
|
|
2011-10-20 13:16:24 +02:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2011-01-10 17:17:28 +01:00
|
|
|
ret = qcow2_cache_flush(bs, s->l2_table_cache);
|
|
|
|
if (ret < 0) {
|
2011-10-27 11:22:28 +02:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2011-10-20 13:16:24 +02:00
|
|
|
return ret;
|
2011-01-10 17:17:28 +01:00
|
|
|
}
|
|
|
|
|
2012-07-27 10:05:22 +02:00
|
|
|
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;
|
|
|
|
}
|
2011-01-10 17:17:28 +01:00
|
|
|
}
|
2011-10-20 13:16:24 +02:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2011-01-10 17:17:28 +01:00
|
|
|
|
2011-11-10 18:10:11 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
|
2010-04-23 22:19:47 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-11-22 13:39:50 +01:00
|
|
|
bdi->unallocated_blocks_are_zero = true;
|
|
|
|
bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3);
|
2010-04-23 22:19:47 +02:00
|
|
|
bdi->cluster_size = s->cluster_size;
|
2010-12-17 16:02:39 +01:00
|
|
|
bdi->vm_state_offset = qcow2_vm_state_offset(s);
|
2010-04-23 22:19:47 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-09 10:46:18 +02:00
|
|
|
static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-10-09 10:46:18 +02:00
|
|
|
ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
|
|
|
|
|
|
|
|
*spec_info = (ImageInfoSpecific){
|
2015-10-26 23:34:54 +01:00
|
|
|
.type = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
.u.qcow2.data = g_new(ImageInfoSpecificQCow2, 1),
|
2013-10-09 10:46:18 +02:00
|
|
|
};
|
|
|
|
if (s->qcow_version == 2) {
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
*spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
|
2015-02-10 21:28:44 +01:00
|
|
|
.compat = g_strdup("0.10"),
|
|
|
|
.refcount_bits = s->refcount_bits,
|
2013-10-09 10:46:18 +02:00
|
|
|
};
|
|
|
|
} else if (s->qcow_version == 3) {
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
*spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
|
2013-10-09 10:46:18 +02:00
|
|
|
.compat = g_strdup("1.1"),
|
|
|
|
.lazy_refcounts = s->compatible_features &
|
|
|
|
QCOW2_COMPAT_LAZY_REFCOUNTS,
|
|
|
|
.has_lazy_refcounts = true,
|
2014-09-30 21:31:28 +02:00
|
|
|
.corrupt = s->incompatible_features &
|
|
|
|
QCOW2_INCOMPAT_CORRUPT,
|
|
|
|
.has_corrupt = true,
|
2015-02-10 21:28:44 +01:00
|
|
|
.refcount_bits = s->refcount_bits,
|
2013-10-09 10:46:18 +02:00
|
|
|
};
|
2015-12-10 10:55:48 +01:00
|
|
|
} else {
|
|
|
|
/* if this assertion fails, this probably means a new version was
|
|
|
|
* added without having it covered here */
|
|
|
|
assert(false);
|
2013-10-09 10:46:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return spec_info;
|
|
|
|
}
|
|
|
|
|
2010-04-23 22:19:47 +02:00
|
|
|
#if 0
|
|
|
|
static void dump_refcounts(BlockDriverState *bs)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2010-04-23 22:19:47 +02:00
|
|
|
int64_t nb_clusters, k, k1, size;
|
|
|
|
int refcount;
|
|
|
|
|
2015-06-16 14:19:22 +02:00
|
|
|
size = bdrv_getlength(bs->file->bs);
|
2010-04-23 22:19:47 +02:00
|
|
|
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++;
|
2010-05-22 10:02:12 +02:00
|
|
|
printf("%" PRId64 ": refcount=%d nb=%" PRId64 "\n", k, refcount,
|
|
|
|
k - k1);
|
2010-04-23 22:19:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-04-05 21:27:53 +02:00
|
|
|
static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
|
|
|
|
int64_t pos)
|
2010-04-23 22:19:47 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-10-20 20:28:20 +02:00
|
|
|
int64_t total_sectors = bs->total_sectors;
|
2013-10-20 21:52:35 +02:00
|
|
|
bool zero_beyond_eof = bs->zero_beyond_eof;
|
2010-04-23 22:19:47 +02:00
|
|
|
int ret;
|
|
|
|
|
2010-04-14 14:17:38 +02:00
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
|
2013-10-20 21:52:35 +02:00
|
|
|
bs->zero_beyond_eof = false;
|
2013-04-05 21:27:55 +02:00
|
|
|
ret = bdrv_pwritev(bs, qcow2_vm_state_offset(s) + pos, qiov);
|
2013-10-20 21:52:35 +02:00
|
|
|
bs->zero_beyond_eof = zero_beyond_eof;
|
2010-04-23 22:19:47 +02:00
|
|
|
|
2013-10-20 20:28:20 +02:00
|
|
|
/* 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;
|
|
|
|
|
2010-04-23 22:19:47 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,
|
|
|
|
int64_t pos, int size)
|
2010-04-23 22:19:47 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-08-22 09:24:14 +02:00
|
|
|
bool zero_beyond_eof = bs->zero_beyond_eof;
|
2010-04-23 22:19:47 +02:00
|
|
|
int ret;
|
|
|
|
|
2010-04-14 14:17:38 +02:00
|
|
|
BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
|
2013-08-22 09:24:14 +02:00
|
|
|
bs->zero_beyond_eof = false;
|
2010-12-17 16:02:39 +01:00
|
|
|
ret = bdrv_pread(bs, qcow2_vm_state_offset(s) + pos, buf, size);
|
2013-08-22 09:24:14 +02:00
|
|
|
bs->zero_beyond_eof = zero_beyond_eof;
|
2010-04-23 22:19:47 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-09-03 10:09:54 +02:00
|
|
|
/*
|
|
|
|
* Downgrades an image's version. To achieve this, any incompatible features
|
|
|
|
* have to be removed.
|
|
|
|
*/
|
2014-10-27 11:12:53 +01:00
|
|
|
static int qcow2_downgrade(BlockDriverState *bs, int target_version,
|
2015-07-27 17:51:32 +02:00
|
|
|
BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
|
2013-09-03 10:09:54 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-09-03 10:09:54 +02:00
|
|
|
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) {
|
2015-07-27 17:51:38 +02:00
|
|
|
error_report("compat=0.10 requires refcount_bits=16");
|
2013-09-03 10:09:54 +02:00
|
|
|
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;
|
|
|
|
|
2015-07-27 17:51:32 +02:00
|
|
|
ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque);
|
2013-09-03 10:09:54 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-07-27 17:51:36 +02:00
|
|
|
typedef enum Qcow2AmendOperation {
|
|
|
|
/* This is the value Qcow2AmendHelperCBInfo::last_operation will be
|
|
|
|
* statically initialized to so that the helper CB can discern the first
|
|
|
|
* invocation from an operation change */
|
|
|
|
QCOW2_NO_OPERATION = 0,
|
|
|
|
|
2015-07-27 17:51:38 +02:00
|
|
|
QCOW2_CHANGING_REFCOUNT_ORDER,
|
2015-07-27 17:51:36 +02:00
|
|
|
QCOW2_DOWNGRADING,
|
|
|
|
} Qcow2AmendOperation;
|
|
|
|
|
|
|
|
typedef struct Qcow2AmendHelperCBInfo {
|
|
|
|
/* The code coordinating the amend operations should only modify
|
|
|
|
* these four fields; the rest will be managed by the CB */
|
|
|
|
BlockDriverAmendStatusCB *original_status_cb;
|
|
|
|
void *original_cb_opaque;
|
|
|
|
|
|
|
|
Qcow2AmendOperation current_operation;
|
|
|
|
|
|
|
|
/* Total number of operations to perform (only set once) */
|
|
|
|
int total_operations;
|
|
|
|
|
|
|
|
/* The following fields are managed by the CB */
|
|
|
|
|
|
|
|
/* Number of operations completed */
|
|
|
|
int operations_completed;
|
|
|
|
|
|
|
|
/* Cumulative offset of all completed operations */
|
|
|
|
int64_t offset_completed;
|
|
|
|
|
|
|
|
Qcow2AmendOperation last_operation;
|
|
|
|
int64_t last_work_size;
|
|
|
|
} Qcow2AmendHelperCBInfo;
|
|
|
|
|
|
|
|
static void qcow2_amend_helper_cb(BlockDriverState *bs,
|
|
|
|
int64_t operation_offset,
|
|
|
|
int64_t operation_work_size, void *opaque)
|
|
|
|
{
|
|
|
|
Qcow2AmendHelperCBInfo *info = opaque;
|
|
|
|
int64_t current_work_size;
|
|
|
|
int64_t projected_work_size;
|
|
|
|
|
|
|
|
if (info->current_operation != info->last_operation) {
|
|
|
|
if (info->last_operation != QCOW2_NO_OPERATION) {
|
|
|
|
info->offset_completed += info->last_work_size;
|
|
|
|
info->operations_completed++;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->last_operation = info->current_operation;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(info->total_operations > 0);
|
|
|
|
assert(info->operations_completed < info->total_operations);
|
|
|
|
|
|
|
|
info->last_work_size = operation_work_size;
|
|
|
|
|
|
|
|
current_work_size = info->offset_completed + operation_work_size;
|
|
|
|
|
|
|
|
/* current_work_size is the total work size for (operations_completed + 1)
|
|
|
|
* operations (which includes this one), so multiply it by the number of
|
|
|
|
* operations not covered and divide it by the number of operations
|
|
|
|
* covered to get a projection for the operations not covered */
|
|
|
|
projected_work_size = current_work_size * (info->total_operations -
|
|
|
|
info->operations_completed - 1)
|
|
|
|
/ (info->operations_completed + 1);
|
|
|
|
|
|
|
|
info->original_status_cb(bs, info->offset_completed + operation_offset,
|
|
|
|
current_work_size + projected_work_size,
|
|
|
|
info->original_cb_opaque);
|
|
|
|
}
|
|
|
|
|
2014-10-27 11:12:50 +01:00
|
|
|
static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
|
2015-07-27 17:51:32 +02:00
|
|
|
BlockDriverAmendStatusCB *status_cb,
|
|
|
|
void *cb_opaque)
|
2013-09-03 10:09:54 +02:00
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2013-09-03 10:09:54 +02:00
|
|
|
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;
|
2014-06-05 11:20:59 +02:00
|
|
|
const char *compat = NULL;
|
|
|
|
uint64_t cluster_size = s->cluster_size;
|
|
|
|
bool encrypt;
|
2015-07-27 17:51:38 +02:00
|
|
|
int refcount_bits = s->refcount_bits;
|
2013-09-03 10:09:54 +02:00
|
|
|
int ret;
|
2014-06-05 11:20:59 +02:00
|
|
|
QemuOptDesc *desc = opts->list->desc;
|
2015-07-27 17:51:36 +02:00
|
|
|
Qcow2AmendHelperCBInfo helper_cb_info;
|
2013-09-03 10:09:54 +02:00
|
|
|
|
2014-06-05 11:20:59 +02:00
|
|
|
while (desc && desc->name) {
|
|
|
|
if (!qemu_opt_find(opts, desc->name)) {
|
2013-09-03 10:09:54 +02:00
|
|
|
/* only change explicitly defined options */
|
2014-06-05 11:20:59 +02:00
|
|
|
desc++;
|
2013-09-03 10:09:54 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-02-18 23:40:47 +01:00
|
|
|
if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
|
|
|
|
compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
|
2014-06-05 11:20:59 +02:00
|
|
|
if (!compat) {
|
2013-09-03 10:09:54 +02:00
|
|
|
/* preserve default */
|
2014-06-05 11:20:59 +02:00
|
|
|
} else if (!strcmp(compat, "0.10")) {
|
2013-09-03 10:09:54 +02:00
|
|
|
new_version = 2;
|
2014-06-05 11:20:59 +02:00
|
|
|
} else if (!strcmp(compat, "1.1")) {
|
2013-09-03 10:09:54 +02:00
|
|
|
new_version = 3;
|
|
|
|
} else {
|
2015-07-27 17:51:33 +02:00
|
|
|
error_report("Unknown compatibility level %s", compat);
|
2013-09-03 10:09:54 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-02-18 23:40:47 +01:00
|
|
|
} else if (!strcmp(desc->name, BLOCK_OPT_PREALLOC)) {
|
2015-07-27 17:51:33 +02:00
|
|
|
error_report("Cannot change preallocation mode");
|
2013-09-03 10:09:54 +02:00
|
|
|
return -ENOTSUP;
|
2015-02-18 23:40:47 +01:00
|
|
|
} 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,
|
2015-07-01 19:10:37 +02:00
|
|
|
!!s->cipher);
|
|
|
|
|
|
|
|
if (encrypt != !!s->cipher) {
|
2015-07-27 17:51:33 +02:00
|
|
|
error_report("Changing the encryption flag is not supported");
|
2013-09-03 10:09:54 +02:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2015-02-18 23:40:47 +01:00
|
|
|
} else if (!strcmp(desc->name, BLOCK_OPT_CLUSTER_SIZE)) {
|
|
|
|
cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE,
|
2014-06-05 11:20:59 +02:00
|
|
|
cluster_size);
|
|
|
|
if (cluster_size != s->cluster_size) {
|
2015-07-27 17:51:33 +02:00
|
|
|
error_report("Changing the cluster size is not supported");
|
2013-09-03 10:09:54 +02:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2015-02-18 23:40:47 +01:00
|
|
|
} else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
|
|
|
|
lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
|
2014-06-05 11:20:59 +02:00
|
|
|
lazy_refcounts);
|
2015-02-18 23:40:49 +01:00
|
|
|
} else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
|
2015-07-27 17:51:38 +02:00
|
|
|
refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS,
|
|
|
|
refcount_bits);
|
|
|
|
|
|
|
|
if (refcount_bits <= 0 || refcount_bits > 64 ||
|
|
|
|
!is_power_of_2(refcount_bits))
|
|
|
|
{
|
|
|
|
error_report("Refcount width must be a power of two and may "
|
|
|
|
"not exceed 64 bits");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-09-03 10:09:54 +02:00
|
|
|
} else {
|
2015-07-27 17:51:34 +02:00
|
|
|
/* if this point is reached, this probably means a new option was
|
2013-09-03 10:09:54 +02:00
|
|
|
* added without having it covered here */
|
2015-07-27 17:51:34 +02:00
|
|
|
abort();
|
2013-09-03 10:09:54 +02:00
|
|
|
}
|
2014-06-05 11:20:59 +02:00
|
|
|
|
|
|
|
desc++;
|
2013-09-03 10:09:54 +02:00
|
|
|
}
|
|
|
|
|
2015-07-27 17:51:36 +02:00
|
|
|
helper_cb_info = (Qcow2AmendHelperCBInfo){
|
|
|
|
.original_status_cb = status_cb,
|
|
|
|
.original_cb_opaque = cb_opaque,
|
|
|
|
.total_operations = (new_version < old_version)
|
2015-07-27 17:51:38 +02:00
|
|
|
+ (s->refcount_bits != refcount_bits)
|
2015-07-27 17:51:36 +02:00
|
|
|
};
|
|
|
|
|
2015-07-27 17:51:35 +02:00
|
|
|
/* Upgrade first (some features may require compat=1.1) */
|
|
|
|
if (new_version > old_version) {
|
|
|
|
s->qcow_version = new_version;
|
|
|
|
ret = qcow2_update_header(bs);
|
|
|
|
if (ret < 0) {
|
|
|
|
s->qcow_version = old_version;
|
|
|
|
return ret;
|
2013-09-03 10:09:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-27 17:51:38 +02:00
|
|
|
if (s->refcount_bits != refcount_bits) {
|
|
|
|
int refcount_order = ctz32(refcount_bits);
|
|
|
|
Error *local_error = NULL;
|
|
|
|
|
|
|
|
if (new_version < 3 && refcount_bits != 16) {
|
|
|
|
error_report("Different refcount widths than 16 bits require "
|
|
|
|
"compatibility level 1.1 or above (use compat=1.1 or "
|
|
|
|
"greater)");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER;
|
|
|
|
ret = qcow2_change_refcount_order(bs, refcount_order,
|
|
|
|
&qcow2_amend_helper_cb,
|
|
|
|
&helper_cb_info, &local_error);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report_err(local_error);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-03 10:09:54 +02:00
|
|
|
if (backing_file || backing_format) {
|
2015-04-07 15:03:16 +02:00
|
|
|
ret = qcow2_change_backing_file(bs,
|
|
|
|
backing_file ?: s->image_backing_file,
|
|
|
|
backing_format ?: s->image_backing_format);
|
2013-09-03 10:09:54 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->use_lazy_refcounts != lazy_refcounts) {
|
|
|
|
if (lazy_refcounts) {
|
2015-07-27 17:51:35 +02:00
|
|
|
if (new_version < 3) {
|
2015-07-27 17:51:33 +02:00
|
|
|
error_report("Lazy refcounts only supported with compatibility "
|
|
|
|
"level 1.1 and above (use compat=1.1 or greater)");
|
2013-09-03 10:09:54 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-27 17:51:35 +02:00
|
|
|
/* Downgrade last (so unsupported features can be removed before) */
|
|
|
|
if (new_version < old_version) {
|
2015-07-27 17:51:36 +02:00
|
|
|
helper_cb_info.current_operation = QCOW2_DOWNGRADING;
|
|
|
|
ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb,
|
|
|
|
&helper_cb_info);
|
2015-07-27 17:51:35 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-03 10:09:54 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-05 16:07:16 +02:00
|
|
|
/*
|
|
|
|
* 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, ...)
|
|
|
|
{
|
2015-09-07 17:12:56 +02:00
|
|
|
BDRVQcow2State *s = bs->opaque;
|
2015-04-08 11:29:20 +02:00
|
|
|
const char *node_name;
|
2014-09-05 16:07:16 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-04-08 11:29:20 +02:00
|
|
|
node_name = bdrv_get_node_name(bs);
|
|
|
|
qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
|
|
|
|
*node_name != '\0', node_name,
|
|
|
|
message, offset >= 0, offset,
|
|
|
|
size >= 0, size,
|
2014-09-05 16:07:16 +02:00
|
|
|
fatal, &error_abort);
|
|
|
|
g_free(message);
|
|
|
|
|
|
|
|
if (fatal) {
|
|
|
|
qcow2_mark_corrupt(bs);
|
|
|
|
bs->drv = NULL; /* make BDS unusable */
|
|
|
|
}
|
|
|
|
|
|
|
|
s->signaled_corruption = true;
|
|
|
|
}
|
|
|
|
|
2014-06-05 11:20:59 +02:00
|
|
|
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,
|
2014-09-10 11:05:49 +02:00
|
|
|
.help = "Preallocation mode (allowed values: off, metadata, "
|
|
|
|
"falloc, full)"
|
2014-06-05 11:20:59 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_LAZY_REFCOUNTS,
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
.help = "Postpone refcount updates",
|
|
|
|
.def_value_str = "off"
|
|
|
|
},
|
2015-02-18 23:40:49 +01:00
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_REFCOUNT_BITS,
|
|
|
|
.type = QEMU_OPT_NUMBER,
|
|
|
|
.help = "Width of a reference count entry in bits",
|
|
|
|
.def_value_str = "16"
|
|
|
|
},
|
2014-06-05 11:20:59 +02:00
|
|
|
{ /* end of list */ }
|
|
|
|
}
|
2010-04-23 22:19:47 +02:00
|
|
|
};
|
|
|
|
|
2014-12-02 18:32:41 +01:00
|
|
|
BlockDriver bdrv_qcow2 = {
|
2010-12-17 16:02:39 +01:00
|
|
|
.format_name = "qcow2",
|
2015-09-07 17:12:56 +02:00
|
|
|
.instance_size = sizeof(BDRVQcow2State),
|
2010-12-17 16:02:39 +01:00
|
|
|
.bdrv_probe = qcow2_probe,
|
|
|
|
.bdrv_open = qcow2_open,
|
|
|
|
.bdrv_close = qcow2_close,
|
2012-09-20 21:13:28 +02:00
|
|
|
.bdrv_reopen_prepare = qcow2_reopen_prepare,
|
2015-04-16 13:42:27 +02:00
|
|
|
.bdrv_reopen_commit = qcow2_reopen_commit,
|
|
|
|
.bdrv_reopen_abort = qcow2_reopen_abort,
|
2015-11-16 15:34:59 +01:00
|
|
|
.bdrv_join_options = qcow2_join_options,
|
2014-06-05 11:21:11 +02:00
|
|
|
.bdrv_create = qcow2_create,
|
2013-06-28 12:47:42 +02:00
|
|
|
.bdrv_has_zero_init = bdrv_has_zero_init_1,
|
2013-09-04 19:00:28 +02:00
|
|
|
.bdrv_co_get_block_status = qcow2_co_get_block_status,
|
2010-12-17 16:02:39 +01:00
|
|
|
.bdrv_set_key = qcow2_set_key,
|
|
|
|
|
2011-11-10 17:25:44 +01:00
|
|
|
.bdrv_co_readv = qcow2_co_readv,
|
|
|
|
.bdrv_co_writev = qcow2_co_writev,
|
2011-11-10 18:10:11 +01:00
|
|
|
.bdrv_co_flush_to_os = qcow2_co_flush_to_os,
|
2010-04-28 12:36:11 +02:00
|
|
|
|
2012-03-20 15:12:58 +01:00
|
|
|
.bdrv_co_write_zeroes = qcow2_co_write_zeroes,
|
2011-10-20 13:16:25 +02:00
|
|
|
.bdrv_co_discard = qcow2_co_discard,
|
2010-04-28 12:36:11 +02:00
|
|
|
.bdrv_truncate = qcow2_truncate,
|
2010-12-17 16:02:39 +01:00
|
|
|
.bdrv_write_compressed = qcow2_write_compressed,
|
2014-10-24 15:57:31 +02:00
|
|
|
.bdrv_make_empty = qcow2_make_empty,
|
2010-04-23 22:19:47 +02:00
|
|
|
|
|
|
|
.bdrv_snapshot_create = qcow2_snapshot_create,
|
|
|
|
.bdrv_snapshot_goto = qcow2_snapshot_goto,
|
|
|
|
.bdrv_snapshot_delete = qcow2_snapshot_delete,
|
|
|
|
.bdrv_snapshot_list = qcow2_snapshot_list,
|
2014-06-05 11:20:59 +02:00
|
|
|
.bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
|
|
|
|
.bdrv_get_info = qcow2_get_info,
|
2013-10-09 10:46:18 +02:00
|
|
|
.bdrv_get_specific_info = qcow2_get_specific_info,
|
2010-04-23 22:19:47 +02:00
|
|
|
|
2010-12-17 16:02:39 +01:00
|
|
|
.bdrv_save_vmstate = qcow2_save_vmstate,
|
|
|
|
.bdrv_load_vmstate = qcow2_load_vmstate,
|
2010-04-23 22:19:47 +02:00
|
|
|
|
2014-06-04 15:09:35 +02:00
|
|
|
.supports_backing = true,
|
2010-04-23 22:19:47 +02:00
|
|
|
.bdrv_change_backing_file = qcow2_change_backing_file,
|
|
|
|
|
2013-12-11 19:26:16 +01:00
|
|
|
.bdrv_refresh_limits = qcow2_refresh_limits,
|
2011-11-14 22:09:46 +01:00
|
|
|
.bdrv_invalidate_cache = qcow2_invalidate_cache,
|
2015-12-22 16:04:57 +01:00
|
|
|
.bdrv_inactivate = qcow2_inactivate,
|
2011-11-14 22:09:46 +01:00
|
|
|
|
2014-06-05 11:20:59 +02:00
|
|
|
.create_opts = &qcow2_create_opts,
|
|
|
|
.bdrv_check = qcow2_check,
|
2014-06-05 11:21:11 +02:00
|
|
|
.bdrv_amend_options = qcow2_amend_options,
|
2015-08-04 14:14:40 +02:00
|
|
|
|
|
|
|
.bdrv_detach_aio_context = qcow2_detach_aio_context,
|
|
|
|
.bdrv_attach_aio_context = qcow2_attach_aio_context,
|
2010-04-23 22:19:47 +02:00
|
|
|
};
|
|
|
|
|
2009-05-10 00:03:42 +02:00
|
|
|
static void bdrv_qcow2_init(void)
|
|
|
|
{
|
|
|
|
bdrv_register(&bdrv_qcow2);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_init(bdrv_qcow2_init);
|