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 GRAPH_RDLOCK
  63 parallels_load_bitmap_data(BlockDriverState *bs, const uint64_t *l1_table,
  64                            uint32_t l1_size, BdrvDirtyBitmap *bitmap,
  65                            Error **errp)
  66 {
  67     BDRVParallelsState *s = bs->opaque;
  68     int ret = 0;
  69     uint64_t offset, limit;
  70     uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
  71     uint8_t *buf = NULL;
  72     uint64_t i, tab_size =
  73         DIV_ROUND_UP(bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size),
  74                      s->cluster_size);
  75
  76     if (tab_size != l1_size) {
  77         error_setg(errp, "Bitmap table size %" PRIu32 " does not correspond "
  78                    "to bitmap size and cluster size. Expected %" PRIu64,
  79                    l1_size, tab_size);
  80         return -EINVAL;
  81     }
  82
  83     buf = qemu_blockalign(bs, s->cluster_size);
  84     limit = bdrv_dirty_bitmap_serialization_coverage(s->cluster_size, bitmap);
  85     for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) {
  86         uint64_t count = MIN(bm_size - offset, limit);
  87         uint64_t entry = l1_table[i];
  88
  89         if (entry == 0) {
  90             /* No need to deserialize zeros because @bitmap is cleared. */
  91             continue;
  92         }
  93
  94         if (entry == 1) {
  95             bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
  96         } else {
  97             ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS,
  98                              s->cluster_size, buf, 0);
  99             if (ret < 0) {
 100                 error_setg_errno(errp, -ret,
 101                                  "Failed to read bitmap data cluster");
 102                 goto finish;
 103             }
 104             bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
 105                                                false);
 106         }
 107     }
 108     ret = 0;
 109
 110     bdrv_dirty_bitmap_deserialize_finish(bitmap);
 111
 112 finish:
 113     qemu_vfree(buf);
 114
 115     return ret;
 116 }
 117
 118 /*
 119  * @data buffer (of @data_size size) is the Dirty bitmaps feature which
 120  * consists of ParallelsDirtyBitmapFeature followed by L1 table.
 121  */
 122 static BdrvDirtyBitmap * GRAPH_RDLOCK
 123 parallels_load_bitmap(BlockDriverState *bs, uint8_t *data, 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_STR_LEN];
 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 GRAPH_RDLOCK
 185 parallels_parse_format_extension(BlockDriverState *bs, uint8_t *ext_cluster,
 186                                  Error **errp)
 187 {
 188     BDRVParallelsState *s = bs->opaque;
 189     int ret;
 190     int remaining = s->cluster_size;
 191     uint8_t *pos = ext_cluster;
 192     ParallelsFormatExtensionHeader eh;
 193     g_autofree uint8_t *hash = NULL;
 194     size_t hash_len = 0;
 195     GSList *bitmaps = NULL, *el;
 196
 197     memcpy(&eh, pos, sizeof(eh));
 198     eh.magic = le64_to_cpu(eh.magic);
 199     pos += sizeof(eh);
 200     remaining -= sizeof(eh);
 201
 202     if (eh.magic != PARALLELS_FORMAT_EXTENSION_MAGIC) {
 203         error_setg(errp, "Wrong parallels Format Extension magic: 0x%" PRIx64
 204                    ", expected: 0x%llx", eh.magic,
 205                    PARALLELS_FORMAT_EXTENSION_MAGIC);
 206         goto fail;
 207     }
 208
 209     ret = qcrypto_hash_bytes(QCRYPTO_HASH_ALG_MD5, (char *)pos, remaining,
 210                              &hash, &hash_len, errp);
 211     if (ret < 0) {
 212         goto fail;
 213     }
 214
 215     if (hash_len != sizeof(eh.check_sum) ||
 216         memcmp(hash, eh.check_sum, sizeof(eh.check_sum)) != 0) {
 217         error_setg(errp, "Wrong checksum in Format Extension header. Format "
 218                    "extension is corrupted.");
 219         goto fail;
 220     }
 221
 222     while (true) {
 223         ParallelsFeatureHeader fh;
 224         BdrvDirtyBitmap *bitmap;
 225
 226         if (remaining < sizeof(fh)) {
 227             error_setg(errp, "Can not read feature header, as remaining bytes "
 228                        "(%d) in Format Extension is less than Feature header "
 229                        "size (%zu)", remaining, sizeof(fh));
 230             goto fail;
 231         }
 232
 233         memcpy(&fh, pos, sizeof(fh));
 234         pos += sizeof(fh);
 235         remaining -= sizeof(fh);
 236
 237         fh.magic = le64_to_cpu(fh.magic);
 238         fh.flags = le64_to_cpu(fh.flags);
 239         fh.data_size = le32_to_cpu(fh.data_size);
 240
 241         if (fh.flags) {
 242             error_setg(errp, "Flags for extension feature are unsupported");
 243             goto fail;
 244         }
 245
 246         if (fh.data_size > remaining) {
 247             error_setg(errp, "Feature data_size exceedes Format Extension "
 248                        "cluster");
 249             goto fail;
 250         }
 251
 252         switch (fh.magic) {
 253         case PARALLELS_END_OF_FEATURES_MAGIC:
 254             return 0;
 255
 256         case PARALLELS_DIRTY_BITMAP_FEATURE_MAGIC:
 257             bitmap = parallels_load_bitmap(bs, pos, fh.data_size, errp);
 258             if (!bitmap) {
 259                 goto fail;
 260             }
 261             bitmaps = g_slist_append(bitmaps, bitmap);
 262             break;
 263
 264         default:
 265             error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
 266             goto fail;
 267         }
 268
 269         pos = ext_cluster + QEMU_ALIGN_UP(pos + fh.data_size - ext_cluster, 8);
 270     }
 271
 272 fail:
 273     for (el = bitmaps; el; el = el->next) {
 274         bdrv_release_dirty_bitmap(el->data);
 275     }
 276     g_slist_free(bitmaps);
 277
 278     return -EINVAL;
 279 }
 280
 281 int parallels_read_format_extension(BlockDriverState *bs,
 282                                     int64_t ext_off, Error **errp)
 283 {
 284     BDRVParallelsState *s = bs->opaque;
 285     int ret;
 286     uint8_t *ext_cluster = qemu_blockalign(bs, s->cluster_size);
 287
 288     assert(ext_off > 0);
 289
 290     ret = bdrv_pread(bs->file, ext_off, s->cluster_size, ext_cluster, 0);
 291     if (ret < 0) {
 292         error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
 293         goto out;
 294     }
 295
 296     ret = parallels_parse_format_extension(bs, ext_cluster, errp);
 297
 298 out:
 299     qemu_vfree(ext_cluster);
 300
 301     return ret;
 302 }