hw/audio/es1370: remove unused dolog macro
[qemu/ar7.git] / block / parallels-ext.c
blob8a109f005ae73e848658e3f044968307a0bfd99d
1 /*
2 * Support of Parallels Format Extension. It's a part of Parallels format
3 * driver.
5 * Copyright (c) 2021 Virtuozzo International GmbH
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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.
26 #include "qemu/osdep.h"
27 #include "qapi/error.h"
28 #include "block/block-io.h"
29 #include "block/block_int.h"
30 #include "block/dirty-bitmap.h"
31 #include "parallels.h"
32 #include "crypto/hash.h"
33 #include "qemu/uuid.h"
34 #include "qemu/memalign.h"
36 #define PARALLELS_FORMAT_EXTENSION_MAGIC 0xAB234CEF23DCEA87ULL
38 #define PARALLELS_END_OF_FEATURES_MAGIC 0x0ULL
39 #define PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC 0x20385FAE252CB34AULL
41 typedef struct ParallelsFormatExtensionHeader {
42 uint64_t magic; /* PARALLELS_FORMAT_EXTENSION_MAGIC */
43 uint8_t check_sum[16];
44 } QEMU_PACKED ParallelsFormatExtensionHeader;
46 typedef struct ParallelsFeatureHeader {
47 uint64_t magic;
48 uint64_t flags;
49 uint32_t data_size;
50 uint32_t _unused;
51 } QEMU_PACKED ParallelsFeatureHeader;
53 typedef struct ParallelsDirtyBitmapFeature {
54 uint64_t size;
55 uint8_t id[16];
56 uint32_t granularity;
57 uint32_t l1_size;
58 /* L1 table follows */
59 } QEMU_PACKED ParallelsDirtyBitmapFeature;
61 /* Given L1 table read bitmap data from the image and populate @bitmap */
62 static int parallels_load_bitmap_data(BlockDriverState *bs,
63 const uint64_t *l1_table,
64 uint32_t l1_size,
65 BdrvDirtyBitmap *bitmap,
66 Error **errp)
68 BDRVParallelsState *s = bs->opaque;
69 int ret = 0;
70 uint64_t offset, limit;
71 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
72 uint8_t *buf = NULL;
73 uint64_t i, tab_size =
74 DIV_ROUND_UP(bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size),
75 s->cluster_size);
77 if (tab_size != l1_size) {
78 error_setg(errp, "Bitmap table size %" PRIu32 " does not correspond "
79 "to bitmap size and cluster size. Expected %" PRIu64,
80 l1_size, tab_size);
81 return -EINVAL;
84 buf = qemu_blockalign(bs, s->cluster_size);
85 limit = bdrv_dirty_bitmap_serialization_coverage(s->cluster_size, bitmap);
86 for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) {
87 uint64_t count = MIN(bm_size - offset, limit);
88 uint64_t entry = l1_table[i];
90 if (entry == 0) {
91 /* No need to deserialize zeros because @bitmap is cleared. */
92 continue;
95 if (entry == 1) {
96 bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
97 } else {
98 ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS,
99 s->cluster_size, buf, 0);
100 if (ret < 0) {
101 error_setg_errno(errp, -ret,
102 "Failed to read bitmap data cluster");
103 goto finish;
105 bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
106 false);
109 ret = 0;
111 bdrv_dirty_bitmap_deserialize_finish(bitmap);
113 finish:
114 qemu_vfree(buf);
116 return ret;
120 * @data buffer (of @data_size size) is the Dirty bitmaps feature which
121 * consists of ParallelsDirtyBitmapFeature followed by L1 table.
123 static BdrvDirtyBitmap *parallels_load_bitmap(BlockDriverState *bs,
124 uint8_t *data,
125 size_t data_size,
126 Error **errp)
128 int ret;
129 ParallelsDirtyBitmapFeature bf;
130 g_autofree uint64_t *l1_table = NULL;
131 BdrvDirtyBitmap *bitmap;
132 QemuUUID uuid;
133 char uuidstr[UUID_FMT_LEN + 1];
134 int i;
136 if (data_size < sizeof(bf)) {
137 error_setg(errp, "Too small Bitmap Feature area in Parallels Format "
138 "Extension: %zu bytes, expected at least %zu bytes",
139 data_size, sizeof(bf));
140 return NULL;
142 memcpy(&bf, data, sizeof(bf));
143 bf.size = le64_to_cpu(bf.size);
144 bf.granularity = le32_to_cpu(bf.granularity) << BDRV_SECTOR_BITS;
145 bf.l1_size = le32_to_cpu(bf.l1_size);
146 data += sizeof(bf);
147 data_size -= sizeof(bf);
149 if (bf.size != bs->total_sectors) {
150 error_setg(errp, "Bitmap size (in sectors) %" PRId64 " differs from "
151 "disk size in sectors %" PRId64, bf.size, bs->total_sectors);
152 return NULL;
155 if (bf.l1_size * sizeof(uint64_t) > data_size) {
156 error_setg(errp, "Bitmaps feature corrupted: l1 table exceeds "
157 "extension data_size");
158 return NULL;
161 memcpy(&uuid, bf.id, sizeof(uuid));
162 qemu_uuid_unparse(&uuid, uuidstr);
163 bitmap = bdrv_create_dirty_bitmap(bs, bf.granularity, uuidstr, errp);
164 if (!bitmap) {
165 return NULL;
168 l1_table = g_new(uint64_t, bf.l1_size);
169 for (i = 0; i < bf.l1_size; i++, data += sizeof(uint64_t)) {
170 l1_table[i] = ldq_le_p(data);
173 ret = parallels_load_bitmap_data(bs, l1_table, bf.l1_size, bitmap, errp);
174 if (ret < 0) {
175 bdrv_release_dirty_bitmap(bitmap);
176 return NULL;
179 /* We support format extension only for RO parallels images. */
180 assert(!(bs->open_flags & BDRV_O_RDWR));
181 bdrv_dirty_bitmap_set_readonly(bitmap, true);
183 return bitmap;
186 static int parallels_parse_format_extension(BlockDriverState *bs,
187 uint8_t *ext_cluster, Error **errp)
189 BDRVParallelsState *s = bs->opaque;
190 int ret;
191 int remaining = s->cluster_size;
192 uint8_t *pos = ext_cluster;
193 ParallelsFormatExtensionHeader eh;
194 g_autofree uint8_t *hash = NULL;
195 size_t hash_len = 0;
196 GSList *bitmaps = NULL, *el;
198 memcpy(&eh, pos, sizeof(eh));
199 eh.magic = le64_to_cpu(eh.magic);
200 pos += sizeof(eh);
201 remaining -= sizeof(eh);
203 if (eh.magic != PARALLELS_FORMAT_EXTENSION_MAGIC) {
204 error_setg(errp, "Wrong parallels Format Extension magic: 0x%" PRIx64
205 ", expected: 0x%llx", eh.magic,
206 PARALLELS_FORMAT_EXTENSION_MAGIC);
207 goto fail;
210 ret = qcrypto_hash_bytes(QCRYPTO_HASH_ALG_MD5, (char *)pos, remaining,
211 &hash, &hash_len, errp);
212 if (ret < 0) {
213 goto fail;
216 if (hash_len != sizeof(eh.check_sum) ||
217 memcmp(hash, eh.check_sum, sizeof(eh.check_sum)) != 0) {
218 error_setg(errp, "Wrong checksum in Format Extension header. Format "
219 "extension is corrupted.");
220 goto fail;
223 while (true) {
224 ParallelsFeatureHeader fh;
225 BdrvDirtyBitmap *bitmap;
227 if (remaining < sizeof(fh)) {
228 error_setg(errp, "Can not read feature header, as remaining bytes "
229 "(%d) in Format Extension is less than Feature header "
230 "size (%zu)", remaining, sizeof(fh));
231 goto fail;
234 memcpy(&fh, pos, sizeof(fh));
235 pos += sizeof(fh);
236 remaining -= sizeof(fh);
238 fh.magic = le64_to_cpu(fh.magic);
239 fh.flags = le64_to_cpu(fh.flags);
240 fh.data_size = le32_to_cpu(fh.data_size);
242 if (fh.flags) {
243 error_setg(errp, "Flags for extension feature are unsupported");
244 goto fail;
247 if (fh.data_size > remaining) {
248 error_setg(errp, "Feature data_size exceedes Format Extension "
249 "cluster");
250 goto fail;
253 switch (fh.magic) {
254 case PARALLELS_END_OF_FEATURES_MAGIC:
255 return 0;
257 case PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC:
258 bitmap = parallels_load_bitmap(bs, pos, fh.data_size, errp);
259 if (!bitmap) {
260 goto fail;
262 bitmaps = g_slist_append(bitmaps, bitmap);
263 break;
265 default:
266 error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
267 goto fail;
270 pos = ext_cluster + QEMU_ALIGN_UP(pos + fh.data_size - ext_cluster, 8);
273 fail:
274 for (el = bitmaps; el; el = el->next) {
275 bdrv_release_dirty_bitmap(el->data);
277 g_slist_free(bitmaps);
279 return -EINVAL;
282 int parallels_read_format_extension(BlockDriverState *bs,
283 int64_t ext_off, Error **errp)
285 BDRVParallelsState *s = bs->opaque;
286 int ret;
287 uint8_t *ext_cluster = qemu_blockalign(bs, s->cluster_size);
289 assert(ext_off > 0);
291 ret = bdrv_pread(bs->file, ext_off, s->cluster_size, ext_cluster, 0);
292 if (ret < 0) {
293 error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
294 goto out;
297 ret = parallels_parse_format_extension(bs, ext_cluster, errp);
299 out:
300 qemu_vfree(ext_cluster);
302 return ret;