xref: /openbmc/qemu/block/parallels-ext.c (revision b14df228)
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"
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 
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 {
96             ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS,
97                              s->cluster_size, buf, 0);
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:
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 
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 
289     ret = bdrv_pread(bs->file, ext_off, s->cluster_size, ext_cluster, 0);
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 }
302