parallels-ext.c (9858B)
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 }