1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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"
32#include "qemu/memalign.h"
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
39typedef struct ParallelsFormatExtensionHeader {
40 uint64_t magic;
41 uint8_t check_sum[16];
42} QEMU_PACKED ParallelsFormatExtensionHeader;
43
44typedef struct ParallelsFeatureHeader {
45 uint64_t magic;
46 uint64_t flags;
47 uint32_t data_size;
48 uint32_t _unused;
49} QEMU_PACKED ParallelsFeatureHeader;
50
51typedef struct ParallelsDirtyBitmapFeature {
52 uint64_t size;
53 uint8_t id[16];
54 uint32_t granularity;
55 uint32_t l1_size;
56
57} QEMU_PACKED ParallelsDirtyBitmapFeature;
58
59
60static 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
90 continue;
91 }
92
93 if (entry == 1) {
94 bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
95 } else {
96 ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS, buf,
97 s->cluster_size);
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
111finish:
112 qemu_vfree(buf);
113
114 return ret;
115}
116
117
118
119
120
121static 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
178 assert(!(bs->open_flags & BDRV_O_RDWR));
179 bdrv_dirty_bitmap_set_readonly(bitmap, true);
180
181 return bitmap;
182}
183
184static 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:
264 error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
265 goto fail;
266 }
267
268 pos = ext_cluster + QEMU_ALIGN_UP(pos + fh.data_size - ext_cluster, 8);
269 }
270
271fail:
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
280int 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
289 ret = bdrv_pread(bs->file, ext_off, ext_cluster, s->cluster_size);
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
297out:
298 qemu_vfree(ext_cluster);
299
300 return ret;
301}
302
