block/parallels-ext.c

   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-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"
  35
  36 #define PARALLELS_FORMAT_EXTENSION_MAGIC 0xAB234CEF23DCEA87ULL
  37
  38 #define PARALLELS_END_OF_FEATURES_MAGIC 0x0ULL
  39 #define PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC 0x20385FAE252CB34AULL
  40
  41 typedef struct ParallelsFormatExtensionHeader {
  42     uint64_t magic; /* PARALLELS_FORMAT_EXTENSION_MAGIC */
  43     uint8_t check_sum[16];
  44 } QEMU_PACKED ParallelsFormatExtensionHeader;
  45
  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;
  52
  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;
  60
  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)
  67 {
  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);
  76
  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;
  82     }
  83
  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];
  89
  90         if (entry == 0) {
  91             /* No need to deserialize zeros because @bitmap is cleared. */
  92             continue;
  93         }
  94
  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;
 104             }
 105             bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
 106                                                false);
 107         }
 108     }
 109     ret = 0;
 110
 111     bdrv_dirty_bitmap_deserialize_finish(bitmap);
 112
 113 finish:
 114     qemu_vfree(buf);
 115
 116     return ret;
 117 }
 118
 119 /*
 120  * @data buffer (of @data_size size) is the Dirty bitmaps feature which
 121  * consists of ParallelsDirtyBitmapFeature followed by L1 table.
 122  */
 123 static BdrvDirtyBitmap *parallels_load_bitmap(BlockDriverState *bs,
 124                                               uint8_t *data,
 125                                               size_t data_size,
 126                                               Error **errp)
 127 {
 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;
 135
 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;
 141     }
 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);
 148
 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;
 153     }
 154
 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;
 159     }
 160
 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;
 166     }
 167
 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);
 171     }
 172
 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;
 177     }
 178
 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);
 182
 183     return bitmap;
 184 }
 185
 186 static int parallels_parse_format_extension(BlockDriverState *bs,
 187                                             uint8_t *ext_cluster, Error **errp)
 188 {
 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;
 197
 198     memcpy(&eh, pos, sizeof(eh));
 199     eh.magic = le64_to_cpu(eh.magic);
 200     pos += sizeof(eh);
 201     remaining -= sizeof(eh);
 202
 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;
 208     }
 209
 210     ret = qcrypto_hash_bytes(QCRYPTO_HASH_ALG_MD5, (char *)pos, remaining,
 211                              &hash, &hash_len, errp);
 212     if (ret < 0) {
 213         goto fail;
 214     }
 215
 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;
 221     }
 222
 223     while (true) {
 224         ParallelsFeatureHeader fh;
 225         BdrvDirtyBitmap *bitmap;
 226
 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;
 232         }
 233
 234         memcpy(&fh, pos, sizeof(fh));
 235         pos += sizeof(fh);
 236         remaining -= sizeof(fh);
 237
 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);
 241
 242         if (fh.flags) {
 243             error_setg(errp, "Flags for extension feature are unsupported");
 244             goto fail;
 245         }
 246
 247         if (fh.data_size > remaining) {
 248             error_setg(errp, "Feature data_size exceedes Format Extension "
 249                        "cluster");
 250             goto fail;
 251         }
 252
 253         switch (fh.magic) {
 254         case PARALLELS_END_OF_FEATURES_MAGIC:
 255             return 0;
 256
 257         case PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC:
 258             bitmap = parallels_load_bitmap(bs, pos, fh.data_size, errp);
 259             if (!bitmap) {
 260                 goto fail;
 261             }
 262             bitmaps = g_slist_append(bitmaps, bitmap);
 263             break;
 264
 265         default:
 266             error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
 267             goto fail;
 268         }
 269
 270         pos = ext_cluster + QEMU_ALIGN_UP(pos + fh.data_size - ext_cluster, 8);
 271     }
 272
 273 fail:
 274     for (el = bitmaps; el; el = el->next) {
 275         bdrv_release_dirty_bitmap(el->data);
 276     }
 277     g_slist_free(bitmaps);
 278
 279     return -EINVAL;
 280 }
 281
 282 int parallels_read_format_extension(BlockDriverState *bs,
 283                                     int64_t ext_off, Error **errp)
 284 {
 285     BDRVParallelsState *s = bs->opaque;
 286     int ret;
 287     uint8_t *ext_cluster = qemu_blockalign(bs, s->cluster_size);
 288
 289     assert(ext_off > 0);
 290
 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;
 295     }
 296
 297     ret = parallels_parse_format_extension(bs, ext_cluster, errp);
 298
 299 out:
 300     qemu_vfree(ext_cluster);
 301
 302     return ret;
 303 }