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_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 }