[qemu.git] / block / parallels-ext.c

/*
 * Support of Parallels Format Extension. It's a part of Parallels format
 * driver.
 *
 * Copyright (c) 2021 Virtuozzo International GmbH
 *
 * 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.
 */

#include "qemu/osdep.h"
#include "qapi/error.h"
#include "block/block_int.h"
#include "parallels.h"
#include "crypto/hash.h"
#include "qemu/uuid.h"
#include "qemu/memalign.h"

#define PARALLELS_FORMAT_EXTENSION_MAGIC 0xAB234CEF23DCEA87ULL

#define PARALLELS_END_OF_FEATURES_MAGIC 0x0ULL
#define PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC 0x20385FAE252CB34AULL

typedef struct ParallelsFormatExtensionHeader {
    uint64_t magic; /* PARALLELS_FORMAT_EXTENSION_MAGIC */
    uint8_t check_sum[16];
} QEMU_PACKED ParallelsFormatExtensionHeader;

typedef struct ParallelsFeatureHeader {
    uint64_t magic;
    uint64_t flags;
    uint32_t data_size;
    uint32_t _unused;
} QEMU_PACKED ParallelsFeatureHeader;

typedef struct ParallelsDirtyBitmapFeature {
    uint64_t size;
    uint8_t id[16];
    uint32_t granularity;
    uint32_t l1_size;
    /* L1 table follows */
} QEMU_PACKED ParallelsDirtyBitmapFeature;

/* Given L1 table read bitmap data from the image and populate @bitmap */
static int parallels_load_bitmap_data(BlockDriverState *bs,
                                      const uint64_t *l1_table,
                                      uint32_t l1_size,
                                      BdrvDirtyBitmap *bitmap,
                                      Error **errp)
{
    BDRVParallelsState *s = bs->opaque;
    int ret = 0;
    uint64_t offset, limit;
    uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
    uint8_t *buf = NULL;
    uint64_t i, tab_size =
        DIV_ROUND_UP(bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size),
                     s->cluster_size);

    if (tab_size != l1_size) {
        error_setg(errp, "Bitmap table size %" PRIu32 " does not correspond "
                   "to bitmap size and cluster size. Expected %" PRIu64,
                   l1_size, tab_size);
        return -EINVAL;
    }

    buf = qemu_blockalign(bs, s->cluster_size);
    limit = bdrv_dirty_bitmap_serialization_coverage(s->cluster_size, bitmap);
    for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) {
        uint64_t count = MIN(bm_size - offset, limit);
        uint64_t entry = l1_table[i];

        if (entry == 0) {
            /* No need to deserialize zeros because @bitmap is cleared. */
            continue;
        }

        if (entry == 1) {
            bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
        } else {
            ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS,
                             s->cluster_size, buf, 0);
            if (ret < 0) {
                error_setg_errno(errp, -ret,
                                 "Failed to read bitmap data cluster");
                goto finish;
            }
            bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
                                               false);
        }
    }
    ret = 0;

    bdrv_dirty_bitmap_deserialize_finish(bitmap);

finish:
    qemu_vfree(buf);

    return ret;
}

/*
 * @data buffer (of @data_size size) is the Dirty bitmaps feature which
 * consists of ParallelsDirtyBitmapFeature followed by L1 table.
 */
static BdrvDirtyBitmap *parallels_load_bitmap(BlockDriverState *bs,
                                              uint8_t *data,
                                              size_t data_size,
                                              Error **errp)
{
    int ret;
    ParallelsDirtyBitmapFeature bf;
    g_autofree uint64_t *l1_table = NULL;
    BdrvDirtyBitmap *bitmap;
    QemuUUID uuid;
    char uuidstr[UUID_FMT_LEN + 1];
    int i;

    if (data_size < sizeof(bf)) {
        error_setg(errp, "Too small Bitmap Feature area in Parallels Format "
                   "Extension: %zu bytes, expected at least %zu bytes",
                   data_size, sizeof(bf));
        return NULL;
    }
    memcpy(&bf, data, sizeof(bf));
    bf.size = le64_to_cpu(bf.size);
    bf.granularity = le32_to_cpu(bf.granularity) << BDRV_SECTOR_BITS;
    bf.l1_size = le32_to_cpu(bf.l1_size);
    data += sizeof(bf);
    data_size -= sizeof(bf);

    if (bf.size != bs->total_sectors) {
        error_setg(errp, "Bitmap size (in sectors) %" PRId64 " differs from "
                   "disk size in sectors %" PRId64, bf.size, bs->total_sectors);
        return NULL;
    }

    if (bf.l1_size * sizeof(uint64_t) > data_size) {
        error_setg(errp, "Bitmaps feature corrupted: l1 table exceeds "
                   "extension data_size");
        return NULL;
    }

    memcpy(&uuid, bf.id, sizeof(uuid));
    qemu_uuid_unparse(&uuid, uuidstr);
    bitmap = bdrv_create_dirty_bitmap(bs, bf.granularity, uuidstr, errp);
    if (!bitmap) {
        return NULL;
    }

    l1_table = g_new(uint64_t, bf.l1_size);
    for (i = 0; i < bf.l1_size; i++, data += sizeof(uint64_t)) {
        l1_table[i] = ldq_le_p(data);
    }

    ret = parallels_load_bitmap_data(bs, l1_table, bf.l1_size, bitmap, errp);
    if (ret < 0) {
        bdrv_release_dirty_bitmap(bitmap);
        return NULL;
    }

    /* We support format extension only for RO parallels images. */
    assert(!(bs->open_flags & BDRV_O_RDWR));
    bdrv_dirty_bitmap_set_readonly(bitmap, true);

    return bitmap;
}

static int parallels_parse_format_extension(BlockDriverState *bs,
                                            uint8_t *ext_cluster, Error **errp)
{
    BDRVParallelsState *s = bs->opaque;
    int ret;
    int remaining = s->cluster_size;
    uint8_t *pos = ext_cluster;
    ParallelsFormatExtensionHeader eh;
    g_autofree uint8_t *hash = NULL;
    size_t hash_len = 0;
    GSList *bitmaps = NULL, *el;

    memcpy(&eh, pos, sizeof(eh));
    eh.magic = le64_to_cpu(eh.magic);
    pos += sizeof(eh);
    remaining -= sizeof(eh);

    if (eh.magic != PARALLELS_FORMAT_EXTENSION_MAGIC) {
        error_setg(errp, "Wrong parallels Format Extension magic: 0x%" PRIx64
                   ", expected: 0x%llx", eh.magic,
                   PARALLELS_FORMAT_EXTENSION_MAGIC);
        goto fail;
    }

    ret = qcrypto_hash_bytes(QCRYPTO_HASH_ALG_MD5, (char *)pos, remaining,
                             &hash, &hash_len, errp);
    if (ret < 0) {
        goto fail;
    }

    if (hash_len != sizeof(eh.check_sum) ||
        memcmp(hash, eh.check_sum, sizeof(eh.check_sum)) != 0) {
        error_setg(errp, "Wrong checksum in Format Extension header. Format "
                   "extension is corrupted.");
        goto fail;
    }

    while (true) {
        ParallelsFeatureHeader fh;
        BdrvDirtyBitmap *bitmap;

        if (remaining < sizeof(fh)) {
            error_setg(errp, "Can not read feature header, as remaining bytes "
                       "(%d) in Format Extension is less than Feature header "
                       "size (%zu)", remaining, sizeof(fh));
            goto fail;
        }

        memcpy(&fh, pos, sizeof(fh));
        pos += sizeof(fh);
        remaining -= sizeof(fh);

        fh.magic = le64_to_cpu(fh.magic);
        fh.flags = le64_to_cpu(fh.flags);
        fh.data_size = le32_to_cpu(fh.data_size);

        if (fh.flags) {
            error_setg(errp, "Flags for extension feature are unsupported");
            goto fail;
        }

        if (fh.data_size > remaining) {
            error_setg(errp, "Feature data_size exceedes Format Extension "
                       "cluster");
            goto fail;
        }

        switch (fh.magic) {
        case PARALLELS_END_OF_FEATURES_MAGIC:
            return 0;

        case PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC:
            bitmap = parallels_load_bitmap(bs, pos, fh.data_size, errp);
            if (!bitmap) {
                goto fail;
            }
            bitmaps = g_slist_append(bitmaps, bitmap);
            break;

        default:
            error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
            goto fail;
        }

        pos = ext_cluster + QEMU_ALIGN_UP(pos + fh.data_size - ext_cluster, 8);
    }

fail:
    for (el = bitmaps; el; el = el->next) {
        bdrv_release_dirty_bitmap(el->data);
    }
    g_slist_free(bitmaps);

    return -EINVAL;
}

int parallels_read_format_extension(BlockDriverState *bs,
                                    int64_t ext_off, Error **errp)
{
    BDRVParallelsState *s = bs->opaque;
    int ret;
    uint8_t *ext_cluster = qemu_blockalign(bs, s->cluster_size);

    assert(ext_off > 0);

    ret = bdrv_pread(bs->file, ext_off, s->cluster_size, ext_cluster, 0);
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
        goto out;
    }

    ret = parallels_parse_format_extension(bs, ext_cluster, errp);

out:
    qemu_vfree(ext_cluster);

    return ret;
}
Commit	Line	Data
baefd977 VSO	1	/*
	2	* Support of Parallels Format Extension. It's a part of Parallels format
	3	* driver.
	4	*
	5	* Copyright (c) 2021 Virtuozzo International GmbH
	6	*
	7	* Permission is hereby granted, free of charge, to any person obtaining a copy
	8	* of this software and associated documentation files (the "Software"), to deal
	9	* in the Software without restriction, including without limitation the rights
	10	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	11	* copies of the Software, and to permit persons to whom the Software is
	12	* furnished to do so, subject to the following conditions:
	13	*
	14	* The above copyright notice and this permission notice shall be included in
	15	* all copies or substantial portions of the Software.
	16	*
	17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	18	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	19	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	20	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	21	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	22	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	23	* THE SOFTWARE.
	24	*/
	25
	26	#include "qemu/osdep.h"
	27	#include "qapi/error.h"
	28	#include "block/block_int.h"
	29	#include "parallels.h"
	30	#include "crypto/hash.h"
	31	#include "qemu/uuid.h"
5df022cf	32	#include "qemu/memalign.h"
baefd977 VSO	33
	34	#define PARALLELS_FORMAT_EXTENSION_MAGIC 0xAB234CEF23DCEA87ULL
	35
	36	#define PARALLELS_END_OF_FEATURES_MAGIC 0x0ULL
	37	#define PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC 0x20385FAE252CB34AULL
	38
	39	typedef struct ParallelsFormatExtensionHeader {
	40	uint64_t magic; /* PARALLELS_FORMAT_EXTENSION_MAGIC */
	41	uint8_t check_sum[16];
	42	} QEMU_PACKED ParallelsFormatExtensionHeader;
	43
	44	typedef struct ParallelsFeatureHeader {
	45	uint64_t magic;
	46	uint64_t flags;
	47	uint32_t data_size;
	48	uint32_t _unused;
	49	} QEMU_PACKED ParallelsFeatureHeader;
	50
	51	typedef struct ParallelsDirtyBitmapFeature {
	52	uint64_t size;
	53	uint8_t id[16];
	54	uint32_t granularity;
	55	uint32_t l1_size;
	56	/* L1 table follows */
	57	} QEMU_PACKED ParallelsDirtyBitmapFeature;
	58
	59	/* Given L1 table read bitmap data from the image and populate @bitmap */
	60	static int parallels_load_bitmap_data(BlockDriverState *bs,
	61	const uint64_t *l1_table,
	62	uint32_t l1_size,
	63	BdrvDirtyBitmap *bitmap,
	64	Error **errp)
	65	{
	66	BDRVParallelsState *s = bs->opaque;
	67	int ret = 0;
	68	uint64_t offset, limit;
	69	uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
	70	uint8_t *buf = NULL;
	71	uint64_t i, tab_size =
	72	DIV_ROUND_UP(bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size),
	73	s->cluster_size);
	74
	75	if (tab_size != l1_size) {
	76	error_setg(errp, "Bitmap table size %" PRIu32 " does not correspond "
	77	"to bitmap size and cluster size. Expected %" PRIu64,
	78	l1_size, tab_size);
	79	return -EINVAL;
	80	}
	81
	82	buf = qemu_blockalign(bs, s->cluster_size);
	83	limit = bdrv_dirty_bitmap_serialization_coverage(s->cluster_size, bitmap);
	84	for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) {
	85	uint64_t count = MIN(bm_size - offset, limit);
	86	uint64_t entry = l1_table[i];
	87
	88	if (entry == 0) {
	89	/* No need to deserialize zeros because @bitmap is cleared. */
	90	continue;
	91	}
	92
	93	if (entry == 1) {
	94	bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
	95	} else {
32cc71de AF	96	ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS,
32cc71de AF	97	s->cluster_size, buf, 0);
baefd977 VSO	98	if (ret < 0) {
	99	error_setg_errno(errp, -ret,
	100	"Failed to read bitmap data cluster");
	101	goto finish;
	102	}
	103	bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
	104	false);
	105	}
	106	}
	107	ret = 0;
	108
	109	bdrv_dirty_bitmap_deserialize_finish(bitmap);
	110
	111	finish:
	112	qemu_vfree(buf);
	113
	114	return ret;
	115	}
	116
	117	/*
	118	* @data buffer (of @data_size size) is the Dirty bitmaps feature which
	119	* consists of ParallelsDirtyBitmapFeature followed by L1 table.
	120	*/
	121	static BdrvDirtyBitmap parallels_load_bitmap(BlockDriverState bs,
	122	uint8_t *data,
	123	size_t data_size,
	124	Error **errp)
	125	{
	126	int ret;
	127	ParallelsDirtyBitmapFeature bf;
	128	g_autofree uint64_t *l1_table = NULL;
	129	BdrvDirtyBitmap *bitmap;
	130	QemuUUID uuid;
	131	char uuidstr[UUID_FMT_LEN + 1];
	132	int i;
	133
	134	if (data_size < sizeof(bf)) {
	135	error_setg(errp, "Too small Bitmap Feature area in Parallels Format "
	136	"Extension: %zu bytes, expected at least %zu bytes",
	137	data_size, sizeof(bf));
	138	return NULL;
	139	}
	140	memcpy(&bf, data, sizeof(bf));
	141	bf.size = le64_to_cpu(bf.size);
	142	bf.granularity = le32_to_cpu(bf.granularity) << BDRV_SECTOR_BITS;
	143	bf.l1_size = le32_to_cpu(bf.l1_size);
	144	data += sizeof(bf);
	145	data_size -= sizeof(bf);
	146
	147	if (bf.size != bs->total_sectors) {
	148	error_setg(errp, "Bitmap size (in sectors) %" PRId64 " differs from "
	149	"disk size in sectors %" PRId64, bf.size, bs->total_sectors);
	150	return NULL;
	151	}
	152
	153	if (bf.l1_size * sizeof(uint64_t) > data_size) {
	154	error_setg(errp, "Bitmaps feature corrupted: l1 table exceeds "
	155	"extension data_size");
	156	return NULL;
	157	}
	158
	159	memcpy(&uuid, bf.id, sizeof(uuid));
	160	qemu_uuid_unparse(&uuid, uuidstr);
	161	bitmap = bdrv_create_dirty_bitmap(bs, bf.granularity, uuidstr, errp);
162	if (!bitmap) {
163	return NULL;
164	}
165
166	l1_table = g_new(uint64_t, bf.l1_size);
167	for (i = 0; i < bf.l1_size; i++, data += sizeof(uint64_t)) {
168	l1_table[i] = ldq_le_p(data);
169	}
170
171	ret = parallels_load_bitmap_data(bs, l1_table, bf.l1_size, bitmap, errp);
172	if (ret < 0) {
173	bdrv_release_dirty_bitmap(bitmap);
174	return NULL;
175	}
176
177	/* We support format extension only for RO parallels images. */
178	assert(!(bs->open_flags & BDRV_O_RDWR));
179	bdrv_dirty_bitmap_set_readonly(bitmap, true);
180
181	return bitmap;
182	}
183
184	static int parallels_parse_format_extension(BlockDriverState *bs,
185	uint8_t ext_cluster, Error *errp)
186	{
187	BDRVParallelsState *s = bs->opaque;
188	int ret;
189	int remaining = s->cluster_size;
190	uint8_t *pos = ext_cluster;
191	ParallelsFormatExtensionHeader eh;
192	g_autofree uint8_t *hash = NULL;
193	size_t hash_len = 0;
194	GSList bitmaps = NULL, el;
195
196	memcpy(&eh, pos, sizeof(eh));
197	eh.magic = le64_to_cpu(eh.magic);
198	pos += sizeof(eh);
199	remaining -= sizeof(eh);
200
201	if (eh.magic != PARALLELS_FORMAT_EXTENSION_MAGIC) {
202	error_setg(errp, "Wrong parallels Format Extension magic: 0x%" PRIx64
203	", expected: 0x%llx", eh.magic,
204	PARALLELS_FORMAT_EXTENSION_MAGIC);
205	goto fail;
206	}
207
208	ret = qcrypto_hash_bytes(QCRYPTO_HASH_ALG_MD5, (char *)pos, remaining,
209	&hash, &hash_len, errp);
210	if (ret < 0) {
211	goto fail;
212	}
213
214	if (hash_len != sizeof(eh.check_sum) \|\|
215	memcmp(hash, eh.check_sum, sizeof(eh.check_sum)) != 0) {
216	error_setg(errp, "Wrong checksum in Format Extension header. Format "
217	"extension is corrupted.");
218	goto fail;
219	}
220
221	while (true) {
222	ParallelsFeatureHeader fh;
223	BdrvDirtyBitmap *bitmap;
224
225	if (remaining < sizeof(fh)) {
226	error_setg(errp, "Can not read feature header, as remaining bytes "
227	"(%d) in Format Extension is less than Feature header "
228	"size (%zu)", remaining, sizeof(fh));
229	goto fail;
230	}
231
232	memcpy(&fh, pos, sizeof(fh));
233	pos += sizeof(fh);
234	remaining -= sizeof(fh);
235
236	fh.magic = le64_to_cpu(fh.magic);
237	fh.flags = le64_to_cpu(fh.flags);
238	fh.data_size = le32_to_cpu(fh.data_size);
239
240	if (fh.flags) {
241	error_setg(errp, "Flags for extension feature are unsupported");
242	goto fail;
243	}
244
245	if (fh.data_size > remaining) {
246	error_setg(errp, "Feature data_size exceedes Format Extension "
247	"cluster");
248	goto fail;
249	}
250
251	switch (fh.magic) {
252	case PARALLELS_END_OF_FEATURES_MAGIC:
253	return 0;
254
255	case PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC:
256	bitmap = parallels_load_bitmap(bs, pos, fh.data_size, errp);
257	if (!bitmap) {
258	goto fail;
259	}
260	bitmaps = g_slist_append(bitmaps, bitmap);
261	break;
262
263	default:
3f1db959	264	error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
baefd977 VSO	265	goto fail;
	266	}
	267
	268	pos = ext_cluster + QEMU_ALIGN_UP(pos + fh.data_size - ext_cluster, 8);
	269	}
	270
	271	fail:
	272	for (el = bitmaps; el; el = el->next) {
	273	bdrv_release_dirty_bitmap(el->data);
	274	}
	275	g_slist_free(bitmaps);
	276
	277	return -EINVAL;
	278	}
	279
	280	int parallels_read_format_extension(BlockDriverState *bs,
	281	int64_t ext_off, Error **errp)
	282	{
	283	BDRVParallelsState *s = bs->opaque;
	284	int ret;
	285	uint8_t *ext_cluster = qemu_blockalign(bs, s->cluster_size);
	286
	287	assert(ext_off > 0);
	288
32cc71de	289	ret = bdrv_pread(bs->file, ext_off, s->cluster_size, ext_cluster, 0);
baefd977 VSO	290	if (ret < 0) {
	291	error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
	292	goto out;
	293	}
	294
	295	ret = parallels_parse_format_extension(bs, ext_cluster, errp);
	296
	297	out:
	298	qemu_vfree(ext_cluster);
	299
	300	return ret;
	301	}