From 243d499717ebba0c0644620237c266112164d5ed Mon Sep 17 00:00:00 2001

From: Jeffrey Cody <jcody@redhat.com>

Date: Wed, 20 Nov 2013 19:44:05 +0100

Subject: [PATCH 22/25] block: vhdx - add .bdrv_create() support

RH-Author: Jeffrey Cody <jcody@redhat.com>

Message-id: <450971418e351130082c4c5f3c8ac8231810c556.1384975172.git.jcody@redhat.com>

Patchwork-id: 55814

O-Subject: [RHEL7 qemu-kvm PATCH 22/26] block: vhdx - add .bdrv_create() support

Bugzilla: 879234

RH-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

RH-Acked-by: Paolo Bonzini <pbonzini@redhat.com>

RH-Acked-by: Fam Zheng <famz@redhat.com>

This adds support for VHDX image creation, for images of type "Fixed"

and "Dynamic".  "Differencing" types (i.e., VHDX images with backing

files) are currently not supported.

Options for image creation include:

    * log size:

        The size of the journaling log for VHDX.  Minimum is 1MB,

        and it must be a multiple of 1MB. Invalid log sizes will be

        silently fixed by rounding up to the nearest MB.

        Default is 1MB.

    * block size:

        This is the size of a payload block.  The range is 1MB to 256MB,

        inclusive, and must be a multiple of 1MB as well.  Invalid sizes

        and multiples will be silently fixed.  If '0' is passed, then

        a sane size is chosen (depending on virtual image size).

        Default is 0 (Auto-select).

    * subformat:

        - "dynamic"

            An image without data pre-allocated.

        - "fixed"

            An image with data pre-allocated.

        Default is "dynamic"

When creating the image file, the lettered sections are created:

-----------------------------------------------------------------.

|   (A)    |   (B)    |    (C)    |     (D)       |     (E)

|  File ID |  Header1 |  Header 2 |  Region Tbl 1 |  Region Tbl 2

|          |          |           |               |

.-----------------------------------------------------------------.

0         64KB      128KB       192KB           256KB          320KB

.---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.

|     (F)     |     (G)       |    (H)    |

| Journal Log |  BAT / Bitmap |  Metadata |  .... data ......

|             |               |           |

.---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.

1MB         (var.)          (var.)      (var.)

Signed-off-by: Jeff Cody <jcody@redhat.com>

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

(cherry picked from commit 3412f7b1bd8f250c34c9f933767d06b9444bb821)

RHEL7 Note: Although the cherry-pick applied clean, the 'bdrv_unref()'

            call in the upstream version was reverted back to the

            original 'bdrv_delete()' that is present in RHEL7.

Signed-off-by: Jeff Cody <jcody@redhat.com>

---

 block/vhdx.c | 558 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 block/vhdx.h |  15 +-

 2 files changed, 572 insertions(+), 1 deletion(-)

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 block/vhdx.c |  557 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 block/vhdx.h |   15 ++-

 2 files changed, 571 insertions(+), 1 deletions(-)

diff --git a/block/vhdx.c b/block/vhdx.c

index 5a112e8..8e3b371 100644

--- a/block/vhdx.c

+++ b/block/vhdx.c

@@ -23,6 +23,19 @@

 #include "migration/migration.h"

 #include <uuid/uuid.h>

+#include <glib.h>

+

+/* Options for VHDX creation */

+

+#define VHDX_BLOCK_OPT_LOG_SIZE   "log_size"

+#define VHDX_BLOCK_OPT_BLOCK_SIZE "block_size"

+#define VHDX_BLOCK_OPT_ZERO "block_state_zero"

+

+typedef enum VHDXImageType {

+    VHDX_TYPE_DYNAMIC = 0,

+    VHDX_TYPE_FIXED,

+    VHDX_TYPE_DIFFERENCING,   /* Currently unsupported */

+} VHDXImageType;

 /* Several metadata and region table data entries are identified by

  * guids in  a MS-specific GUID format. */

@@ -1332,6 +1345,548 @@ exit:

 }

+

+/*

+ * Create VHDX Headers

+ *

+ * There are 2 headers, and the highest sequence number will represent

+ * the active header

+ */

+static int vhdx_create_new_headers(BlockDriverState *bs, uint64_t image_size,

+                                   uint32_t log_size)

+{

+    int ret = 0;

+    VHDXHeader *hdr = NULL;

+

+    hdr = g_malloc0(sizeof(VHDXHeader));

+

+    hdr->signature       = VHDX_HEADER_SIGNATURE;

+    hdr->sequence_number = g_random_int();

+    hdr->log_version     = 0;

+    hdr->version         = 1;

+    hdr->log_length      = log_size;

+    hdr->log_offset      = VHDX_HEADER_SECTION_END;

+    vhdx_guid_generate(&hdr->file_write_guid);

+    vhdx_guid_generate(&hdr->data_write_guid);

+

+    ret = vhdx_write_header(bs, hdr, VHDX_HEADER1_OFFSET, false);

+    if (ret < 0) {

+        goto exit;

+    }

+    hdr->sequence_number++;

+    ret = vhdx_write_header(bs, hdr, VHDX_HEADER2_OFFSET, false);

+    if (ret < 0) {

+        goto exit;

+    }

+

+exit:

+    g_free(hdr);

+    return ret;

+}

+

+

+/*

+ * Create the Metadata entries.

+ *

+ * For more details on the entries, see section 3.5 (pg 29) in the

+ * VHDX 1.00 specification.

+ *

+ * We support 5 metadata entries (all required by spec):

+ *          File Parameters,

+ *          Virtual Disk Size,

+ *          Page 83 Data,

+ *          Logical Sector Size,

+ *          Physical Sector Size

+ *

+ * The first 64KB of the Metadata section is reserved for the metadata

+ * header and entries; beyond that, the metadata items themselves reside.

+ */

+static int vhdx_create_new_metadata(BlockDriverState *bs,

+                                    uint64_t image_size,

+                                    uint32_t block_size,

+                                    uint32_t sector_size,

+                                    uint64_t metadata_offset,

+                                    VHDXImageType type)

+{

+    int ret = 0;

+    uint32_t offset = 0;

+    void *buffer = NULL;

+    void *entry_buffer;

+    VHDXMetadataTableHeader *md_table;;

+    VHDXMetadataTableEntry  *md_table_entry;

+

+    /* Metadata entries */

+    VHDXFileParameters     *mt_file_params;

+    VHDXVirtualDiskSize    *mt_virtual_size;

+    VHDXPage83Data         *mt_page83;

+    VHDXVirtualDiskLogicalSectorSize  *mt_log_sector_size;

+    VHDXVirtualDiskPhysicalSectorSize *mt_phys_sector_size;

+

+    entry_buffer = g_malloc0(sizeof(VHDXFileParameters)               +

+                             sizeof(VHDXVirtualDiskSize)              +

+                             sizeof(VHDXPage83Data)                   +

+                             sizeof(VHDXVirtualDiskLogicalSectorSize) +

+                             sizeof(VHDXVirtualDiskPhysicalSectorSize));

+

+    mt_file_params = entry_buffer;

+    offset += sizeof(VHDXFileParameters);

+    mt_virtual_size = entry_buffer + offset;

+    offset += sizeof(VHDXVirtualDiskSize);

+    mt_page83 = entry_buffer + offset;

+    offset += sizeof(VHDXPage83Data);

+    mt_log_sector_size = entry_buffer + offset;

+    offset += sizeof(VHDXVirtualDiskLogicalSectorSize);

+    mt_phys_sector_size = entry_buffer + offset;

+

+    mt_file_params->block_size = cpu_to_le32(block_size);

+    if (type == VHDX_TYPE_FIXED) {

+        mt_file_params->data_bits |= VHDX_PARAMS_LEAVE_BLOCKS_ALLOCED;

+        cpu_to_le32s(&mt_file_params->data_bits);

+    }

+

+    vhdx_guid_generate(&mt_page83->page_83_data);

+    cpu_to_leguids(&mt_page83->page_83_data);

+    mt_virtual_size->virtual_disk_size        = cpu_to_le64(image_size);

+    mt_log_sector_size->logical_sector_size   = cpu_to_le32(sector_size);

+    mt_phys_sector_size->physical_sector_size = cpu_to_le32(sector_size);

+

+    buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE);

+    md_table = buffer;

+

+    md_table->signature   = VHDX_METADATA_SIGNATURE;

+    md_table->entry_count = 5;

+    vhdx_metadata_header_le_export(md_table);

+

+

+    /* This will reference beyond the reserved table portion */

+    offset = 64 * KiB;

+

+    md_table_entry = buffer + sizeof(VHDXMetadataTableHeader);

+

+    md_table_entry[0].item_id = file_param_guid;

+    md_table_entry[0].offset  = offset;

+    md_table_entry[0].length  = sizeof(VHDXFileParameters);

+    md_table_entry[0].data_bits |= VHDX_META_FLAGS_IS_REQUIRED;

+    offset += md_table_entry[0].length;

+    vhdx_metadata_entry_le_export(&md_table_entry[0]);

+

+    md_table_entry[1].item_id = virtual_size_guid;

+    md_table_entry[1].offset  = offset;

+    md_table_entry[1].length  = sizeof(VHDXVirtualDiskSize);

+    md_table_entry[1].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |

+                                   VHDX_META_FLAGS_IS_VIRTUAL_DISK;

+    offset += md_table_entry[1].length;

+    vhdx_metadata_entry_le_export(&md_table_entry[1]);

+

+    md_table_entry[2].item_id = page83_guid;

+    md_table_entry[2].offset  = offset;

+    md_table_entry[2].length  = sizeof(VHDXPage83Data);

+    md_table_entry[2].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |

+                                   VHDX_META_FLAGS_IS_VIRTUAL_DISK;

+    offset += md_table_entry[2].length;

+    vhdx_metadata_entry_le_export(&md_table_entry[2]);

+

+    md_table_entry[3].item_id = logical_sector_guid;

+    md_table_entry[3].offset  = offset;

+    md_table_entry[3].length  = sizeof(VHDXVirtualDiskLogicalSectorSize);

+    md_table_entry[3].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |

+                                   VHDX_META_FLAGS_IS_VIRTUAL_DISK;

+    offset += md_table_entry[3].length;

+    vhdx_metadata_entry_le_export(&md_table_entry[3]);

+

+    md_table_entry[4].item_id = phys_sector_guid;

+    md_table_entry[4].offset  = offset;

+    md_table_entry[4].length  = sizeof(VHDXVirtualDiskPhysicalSectorSize);

+    md_table_entry[4].data_bits |= VHDX_META_FLAGS_IS_REQUIRED |

+                                   VHDX_META_FLAGS_IS_VIRTUAL_DISK;

+    vhdx_metadata_entry_le_export(&md_table_entry[4]);

+

+    ret = bdrv_pwrite(bs, metadata_offset, buffer, VHDX_HEADER_BLOCK_SIZE);

+    if (ret < 0) {

+        goto exit;

+    }

+

+    ret = bdrv_pwrite(bs, metadata_offset + (64 * KiB), entry_buffer,

+                      VHDX_HEADER_BLOCK_SIZE);

+    if (ret < 0) {

+        goto exit;

+    }

+

+

+exit:

+    g_free(buffer);

+    g_free(entry_buffer);

+    return ret;

+}

+

+/* This create the actual BAT itself.  We currently only support

+ * 'Dynamic' and 'Fixed' image types.

+ *

+ *  Dynamic images: default state of the BAT is all zeroes.

+ *

+ *  Fixed images: default state of the BAT is fully populated, with

+ *                file offsets and state PAYLOAD_BLOCK_FULLY_PRESENT.

+ */

+static int vhdx_create_bat(BlockDriverState *bs, BDRVVHDXState *s,

+                           uint64_t image_size, VHDXImageType type,

+                           bool use_zero_blocks, VHDXRegionTableEntry *rt_bat)

+{

+    int ret = 0;

+    uint64_t data_file_offset;

+    uint64_t total_sectors = 0;

+    uint64_t sector_num = 0;

+    uint64_t unused;

+    int block_state;

+    VHDXSectorInfo sinfo;

+

+    assert(s->bat == NULL);

+

+    /* this gives a data start after BAT/bitmap entries, and well

+     * past any metadata entries (with a 4 MB buffer for future

+     * expansion */

+    data_file_offset = rt_bat->file_offset + rt_bat->length + 5 * MiB;

+    total_sectors = image_size >> s->logical_sector_size_bits;

+

+    if (type == VHDX_TYPE_DYNAMIC) {

+        /* All zeroes, so we can just extend the file - the end of the BAT

+         * is the furthest thing we have written yet */

+        ret = bdrv_truncate(bs, data_file_offset);

+        if (ret < 0) {

+            goto exit;

+        }

+    } else if (type == VHDX_TYPE_FIXED) {

+        ret = bdrv_truncate(bs, data_file_offset + image_size);

+        if (ret < 0) {

+            goto exit;

+        }

+    } else {

+        ret = -ENOTSUP;

+        goto exit;

+    }

+

+    if (type == VHDX_TYPE_FIXED ||

+                use_zero_blocks ||

+                bdrv_has_zero_init(bs) == 0) {

+        /* for a fixed file, the default BAT entry is not zero */

+        s->bat = g_malloc0(rt_bat->length);

+        block_state = type == VHDX_TYPE_FIXED ? PAYLOAD_BLOCK_FULLY_PRESENT :

+                                                PAYLOAD_BLOCK_NOT_PRESENT;

+        block_state = use_zero_blocks ? PAYLOAD_BLOCK_ZERO : block_state;

+        /* fill the BAT by emulating sector writes of sectors_per_block size */

+        while (sector_num < total_sectors) {

+            vhdx_block_translate(s, sector_num, s->sectors_per_block, &sinfo);

+            sinfo.file_offset = data_file_offset +

+                                (sector_num << s->logical_sector_size_bits);

+            sinfo.file_offset = ROUND_UP(sinfo.file_offset, MiB);

+            vhdx_update_bat_table_entry(bs, s, &sinfo, &unused, &unused,

+                                        block_state);

+            cpu_to_le64s(&s->bat[sinfo.bat_idx]);

+            sector_num += s->sectors_per_block;

+        }

+        ret = bdrv_pwrite(bs, rt_bat->file_offset, s->bat, rt_bat->length);

+        if (ret < 0) {

+            goto exit;

+        }

+    }

+

+

+

+exit:

+    g_free(s->bat);

+    return ret;

+}

+

+/* Creates the region table header, and region table entries.

+ * There are 2 supported region table entries: BAT, and Metadata/

+ *

+ * As the calculations for the BAT region table are also needed

+ * to create the BAT itself, we will also cause the BAT to be

+ * created.

+ */

+static int vhdx_create_new_region_table(BlockDriverState *bs,

+                                        uint64_t image_size,

+                                        uint32_t block_size,

+                                        uint32_t sector_size,

+                                        uint32_t log_size,

+                                        bool use_zero_blocks,

+                                        VHDXImageType type,

+                                        uint64_t *metadata_offset)

+{

+    int ret = 0;

+    uint32_t offset = 0;

+    void *buffer = NULL;

+    BDRVVHDXState *s = NULL;

+    VHDXRegionTableHeader *region_table;

+    VHDXRegionTableEntry *rt_bat;

+    VHDXRegionTableEntry *rt_metadata;

+

+    assert(metadata_offset != NULL);

+

+    /* Populate enough of the BDRVVHDXState to be able to use the

+     * pre-existing BAT calculation, translation, and update functions */

+    s = g_malloc0(sizeof(BDRVVHDXState));

+

+    s->chunk_ratio = (VHDX_MAX_SECTORS_PER_BLOCK) *

+                     (uint64_t) sector_size / (uint64_t) block_size;

+

+    s->sectors_per_block = block_size / sector_size;

+    s->virtual_disk_size = image_size;

+    s->block_size = block_size;

+    s->logical_sector_size = sector_size;

+

+    vhdx_set_shift_bits(s);

+

+    vhdx_calc_bat_entries(s);

+

+    /* At this point the VHDX state is populated enough for creation */

+

+    /* a single buffer is used so we can calculate the checksum over the

+     * entire 64KB block */

+    buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE);

+    region_table = buffer;

+    offset += sizeof(VHDXRegionTableHeader);

+    rt_bat = buffer + offset;

+    offset += sizeof(VHDXRegionTableEntry);

+    rt_metadata  = buffer + offset;

+

+    region_table->signature = VHDX_REGION_SIGNATURE;

+    region_table->entry_count = 2;   /* BAT and Metadata */

+

+    rt_bat->guid        = bat_guid;

+    rt_bat->length      = ROUND_UP(s->bat_entries * sizeof(VHDXBatEntry), MiB);

+    rt_bat->file_offset = ROUND_UP(VHDX_HEADER_SECTION_END + log_size, MiB);

+    s->bat_offset = rt_bat->file_offset;

+

+    rt_metadata->guid        = metadata_guid;

+    rt_metadata->file_offset = ROUND_UP(rt_bat->file_offset + rt_bat->length,

+                                        MiB);

+    rt_metadata->length      = 1 * MiB; /* min size, and more than enough */

+    *metadata_offset = rt_metadata->file_offset;

+

+    vhdx_update_checksum(buffer, VHDX_HEADER_BLOCK_SIZE,

+                         offsetof(VHDXRegionTableHeader, checksum));

+

+

+    /* The region table gives us the data we need to create the BAT,

+     * so do that now */

+    ret = vhdx_create_bat(bs, s, image_size, type, use_zero_blocks, rt_bat);

+

+    /* Now write out the region headers to disk */

+    vhdx_region_header_le_export(region_table);

+    vhdx_region_entry_le_export(rt_bat);

+    vhdx_region_entry_le_export(rt_metadata);

+

+    ret = bdrv_pwrite(bs, VHDX_REGION_TABLE_OFFSET, buffer,

+                      VHDX_HEADER_BLOCK_SIZE);

+    if (ret < 0) {

+        goto exit;

+    }

+

+    ret = bdrv_pwrite(bs, VHDX_REGION_TABLE2_OFFSET, buffer,

+                      VHDX_HEADER_BLOCK_SIZE);

+    if (ret < 0) {

+        goto exit;

+    }

+

+

+exit:

+    g_free(s);

+    g_free(buffer);

+    return ret;

+}

+

+/* We need to create the following elements:

+ *

+ *    .-----------------------------------------------------------------.

+ *    |   (A)    |   (B)    |    (C)    |     (D)       |     (E)       |

+ *    |  File ID |  Header1 |  Header 2 |  Region Tbl 1 |  Region Tbl 2 |

+ *    |          |          |           |               |               |

+ *    .-----------------------------------------------------------------.

+ *    0         64KB      128KB       192KB           256KB           320KB

+ *

+ *

+ *    .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.

+ *    |     (F)     |     (G)       |    (H)    |                        |

+ *    | Journal Log |  BAT / Bitmap |  Metadata |  .... data ......      |

+ *    |             |               |           |                        |

+ *    .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.

+ *   1MB

+ */

+static int vhdx_create(const char *filename, QEMUOptionParameter *options,

+                       Error **errp)

+{

+    int ret = 0;

+    uint64_t image_size = (uint64_t) 2 * GiB;

+    uint32_t log_size   = 1 * MiB;

+    uint32_t block_size = 0;

+    uint64_t signature;

+    uint64_t metadata_offset;

+    bool use_zero_blocks = false;

+

+    gunichar2 *creator = NULL;

+    glong creator_items;

+    BlockDriverState *bs;

+    const char *type = NULL;

+    VHDXImageType image_type;

+    Error *local_err = NULL;

+

+    while (options && options->name) {

+        if (!strcmp(options->name, BLOCK_OPT_SIZE)) {

+            image_size = options->value.n;

+        } else if (!strcmp(options->name, VHDX_BLOCK_OPT_LOG_SIZE)) {

+            log_size = options->value.n;

+        } else if (!strcmp(options->name, VHDX_BLOCK_OPT_BLOCK_SIZE)) {

+            block_size = options->value.n;

+        } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) {

+            type = options->value.s;

+        } else if (!strcmp(options->name, VHDX_BLOCK_OPT_ZERO)) {

+            use_zero_blocks = options->value.n != 0;

+        }

+        options++;

+    }

+

+    if (image_size > VHDX_MAX_IMAGE_SIZE) {

+        error_setg_errno(errp, EINVAL, "Image size too large; max of 64TB");

+        ret = -EINVAL;

+        goto exit;

+    }

+

+    if (type == NULL) {

+        type = "dynamic";

+    }

+

+    if (!strcmp(type, "dynamic")) {

+        image_type = VHDX_TYPE_DYNAMIC;

+    } else if (!strcmp(type, "fixed")) {

+        image_type = VHDX_TYPE_FIXED;

+    } else if (!strcmp(type, "differencing")) {

+        error_setg_errno(errp, ENOTSUP,

+                         "Differencing files not yet supported");

+        ret = -ENOTSUP;

+        goto exit;

+    } else {

+        ret = -EINVAL;

+        goto exit;

+    }

+

+    /* These are pretty arbitrary, and mainly designed to keep the BAT

+     * size reasonable to load into RAM */

+    if (block_size == 0) {

+        if (image_size > 32 * TiB) {

+            block_size = 64 * MiB;

+        } else if (image_size > (uint64_t) 100 * GiB) {

+            block_size = 32 * MiB;

+        } else if (image_size > 1 * GiB) {

+            block_size = 16 * MiB;

+        } else {

+            block_size = 8 * MiB;

+        }

+    }

+

+

+    /* make the log size close to what was specified, but must be

+     * min 1MB, and multiple of 1MB */

+    log_size = ROUND_UP(log_size, MiB);

+

+    block_size = ROUND_UP(block_size, MiB);

+    block_size = block_size > VHDX_BLOCK_SIZE_MAX ? VHDX_BLOCK_SIZE_MAX :

+                                                    block_size;

+

+    ret = bdrv_create_file(filename, options, &local_err);

+    if (ret < 0) {

+        error_propagate(errp, local_err);

+        goto exit;

+    }

+

+    ret = bdrv_file_open(&bs, filename, NULL, BDRV_O_RDWR, &local_err);

+    if (ret < 0) {

+        error_propagate(errp, local_err);

+        goto exit;

+    }

+

+    /* Create (A) */

+

+    /* The creator field is optional, but may be useful for

+     * debugging / diagnostics */

+    creator = g_utf8_to_utf16("QEMU v" QEMU_VERSION, -1, NULL,

+                              &creator_items, NULL);

+    signature = cpu_to_le64(VHDX_FILE_SIGNATURE);

+    bdrv_pwrite(bs, VHDX_FILE_ID_OFFSET, &signature, sizeof(signature));

+    if (ret < 0) {

+        goto delete_and_exit;

+    }

+    if (creator) {

+        bdrv_pwrite(bs, VHDX_FILE_ID_OFFSET + sizeof(signature), creator,

+                    creator_items * sizeof(gunichar2));

+        if (ret < 0) {

+            goto delete_and_exit;

+        }

+    }

+

+

+    /* Creates (B),(C) */

+    ret = vhdx_create_new_headers(bs, image_size, log_size);

+    if (ret < 0) {

+        goto delete_and_exit;

+    }

+

+    /* Creates (D),(E),(G) explicitly. (F) created as by-product */

+    ret = vhdx_create_new_region_table(bs, image_size, block_size, 512,

+                                       log_size, use_zero_blocks, image_type,

+                                       &metadata_offset);

+    if (ret < 0) {

+        goto delete_and_exit;

+    }

+

+    /* Creates (H) */

+    ret = vhdx_create_new_metadata(bs, image_size, block_size, 512,

+                                   metadata_offset, image_type);

+    if (ret < 0) {

+        goto delete_and_exit;

+    }

+

+

+

+delete_and_exit:

+    bdrv_delete(bs);

+exit:

+    g_free(creator);

+    return ret;

+}

+

+static QEMUOptionParameter vhdx_create_options[] = {

+    {

+        .name = BLOCK_OPT_SIZE,

+        .type = OPT_SIZE,

+        .help = "Virtual disk size; max of 64TB."

+    },

+    {

+        .name = VHDX_BLOCK_OPT_LOG_SIZE,

+        .type = OPT_SIZE,

+        .value.n = 1 * MiB,

+        .help = "Log size; min 1MB."

+    },

+    {

+        .name = VHDX_BLOCK_OPT_BLOCK_SIZE,

+        .type = OPT_SIZE,

+        .value.n = 0,

+        .help = "Block Size; min 1MB, max 256MB. " \

+                "0 means auto-calculate based on image size."

+    },

+    {

+        .name = BLOCK_OPT_SUBFMT,

+        .type = OPT_STRING,

+        .help = "VHDX format type, can be either 'dynamic' or 'fixed'. "\

+                "Default is 'dynamic'."

+    },

+    {

+        .name = VHDX_BLOCK_OPT_ZERO,

+        .type = OPT_FLAG,

+        .help = "Force use of payload blocks of type 'ZERO'.  Non-standard."

+    },

+    { NULL }

+};

+

 static BlockDriver bdrv_vhdx = {

     .format_name            = "vhdx",

     .instance_size          = sizeof(BDRVVHDXState),

@@ -1342,6 +1897,8 @@ static BlockDriver bdrv_vhdx = {

     .bdrv_co_readv          = vhdx_co_readv,

     .bdrv_co_writev         = vhdx_co_writev,

     .bdrv_get_info          = vhdx_get_info,

+    .bdrv_create            = vhdx_create,

+    .create_options         = vhdx_create_options,

 };

 static void bdrv_vhdx_init(void)

diff --git a/block/vhdx.h b/block/vhdx.h

index 245547b..365eca0 100644

--- a/block/vhdx.h

+++ b/block/vhdx.h

@@ -18,6 +18,11 @@

 #ifndef BLOCK_VHDX_H

 #define BLOCK_VHDX_H

+#define KiB              (1 * 1024)

+#define MiB            (KiB * 1024)

+#define GiB            (MiB * 1024)

+#define TiB ((uint64_t) GiB * 1024)

+

 /* Structures and fields present in the VHDX file */

 /* The header section has the following blocks,

@@ -36,8 +41,9 @@

 #define VHDX_HEADER1_OFFSET         (VHDX_HEADER_BLOCK_SIZE * 1)

 #define VHDX_HEADER2_OFFSET         (VHDX_HEADER_BLOCK_SIZE * 2)

 #define VHDX_REGION_TABLE_OFFSET    (VHDX_HEADER_BLOCK_SIZE * 3)

+#define VHDX_REGION_TABLE2_OFFSET   (VHDX_HEADER_BLOCK_SIZE * 4)

-

+#define VHDX_HEADER_SECTION_END     (1 * MiB)

 /*

  * A note on the use of MS-GUID fields.  For more details on the GUID,

  * please see: https://en.wikipedia.org/wiki/Globally_unique_identifier.

@@ -55,6 +61,7 @@

 /* These structures are ones that are defined in the VHDX specification

  * document */

+#define VHDX_FILE_SIGNATURE 0x656C696678646876  /* "vhdxfile" in ASCII */

 typedef struct VHDXFileIdentifier {

     uint64_t    signature;              /* "vhdxfile" in ASCII */

     uint16_t    creator[256];           /* optional; utf-16 string to identify

@@ -85,6 +92,7 @@ typedef struct QEMU_PACKED MSGUID {

 /* The full header is 4KB, although the actual header data is much smaller.

  * But for the checksum calculation, it is over the entire 4KB structure,

  * not just the defined portion of it */

+#define VHDX_HEADER_SIGNATURE 0x64616568

 typedef struct QEMU_PACKED VHDXHeader {

     uint32_t    signature;              /* "head" in ASCII */

     uint32_t    checksum;               /* CRC-32C hash of the whole header */

@@ -125,6 +133,7 @@ typedef struct QEMU_PACKED VHDXHeader {

 } VHDXHeader;

 /* Header for the region table block */

+#define VHDX_REGION_SIGNATURE  0x69676572  /* "regi" in ASCII */

 typedef struct QEMU_PACKED VHDXRegionTableHeader {

     uint32_t    signature;              /* "regi" in ASCII */

     uint32_t    checksum;               /* CRC-32C hash of the 64KB table */

@@ -238,6 +247,7 @@ typedef uint64_t VHDXBatEntry;

 #define VHDX_METADATA_MAX_ENTRIES 2047  /* not including the header */

 #define VHDX_METADATA_TABLE_MAX_SIZE \

     (VHDX_METADATA_ENTRY_SIZE * (VHDX_METADATA_MAX_ENTRIES+1))

+#define VHDX_METADATA_SIGNATURE 0x617461646174656D  /* "metadata" in ASCII */

 typedef struct QEMU_PACKED VHDXMetadataTableHeader {

     uint64_t    signature;              /* "metadata" in ASCII */

     uint16_t    reserved;