Patchwork [2/9] block: vhdx - add header update capability.

login
register
mail settings
Submitter Jeff Cody
Date July 24, 2013, 5:54 p.m.
Message ID <c9bbe8373c91444bbc2f2fd2c7a5059a2cf7c552.1374687002.git.jcody@redhat.com>
Download mbox | patch
Permalink /patch/261479/
State New
Headers show

Comments

Jeff Cody - July 24, 2013, 5:54 p.m.
This adds the ability to update the headers in a VHDX image, including
generating a new MS-compatible GUID.

As VHDX depends on uuid.h, VHDX is now a configurable build option.  If
VHDX support is enabled, that will also enable uuid as well.  The
default is to have VHDX enabled.

To enable/disable VHDX:  --enable-vhdx, --disable-vhdx

Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/Makefile.objs |   2 +-
 block/vhdx.c        | 157 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 block/vhdx.h        |  12 +++-
 configure           |  13 +++++
 4 files changed, 180 insertions(+), 4 deletions(-)
Fam Zheng - July 26, 2013, 6:49 a.m.
On Wed, 07/24 13:54, Jeff Cody wrote:
> This adds the ability to update the headers in a VHDX image, including
> generating a new MS-compatible GUID.
> 
> As VHDX depends on uuid.h, VHDX is now a configurable build option.  If
> VHDX support is enabled, that will also enable uuid as well.  The
> default is to have VHDX enabled.
> 
> To enable/disable VHDX:  --enable-vhdx, --disable-vhdx
> 
> Signed-off-by: Jeff Cody <jcody@redhat.com>
> ---
>  block/Makefile.objs |   2 +-
>  block/vhdx.c        | 157 +++++++++++++++++++++++++++++++++++++++++++++++++++-
>  block/vhdx.h        |  12 +++-
>  configure           |  13 +++++
>  4 files changed, 180 insertions(+), 4 deletions(-)
> 
> diff --git a/block/Makefile.objs b/block/Makefile.objs
> index 4cf9aa4..e5e54e6 100644
> --- a/block/Makefile.objs
> +++ b/block/Makefile.objs
> @@ -2,7 +2,7 @@ block-obj-y += raw.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat
>  block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o
>  block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o
>  block-obj-y += qed-check.o
> -block-obj-y += vhdx.o
> +block-obj-$(CONFIG_VHDX) += vhdx.o
>  block-obj-y += parallels.o blkdebug.o blkverify.o
>  block-obj-y += snapshot.o qapi.o
>  block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o
> diff --git a/block/vhdx.c b/block/vhdx.c
> index 56bc88e..13e486d 100644
> --- a/block/vhdx.c
> +++ b/block/vhdx.c
> @@ -21,6 +21,7 @@
>  #include "qemu/crc32c.h"
>  #include "block/vhdx.h"
>  
> +#include <uuid/uuid.h>
>  
>  /* Several metadata and region table data entries are identified by
>   * guids in  a MS-specific GUID format. */
> @@ -156,11 +157,40 @@ typedef struct BDRVVHDXState {
>      VHDXBatEntry *bat;
>      uint64_t bat_offset;
>  
> +    MSGUID session_guid;
> +
> +
>      VHDXParentLocatorHeader parent_header;
>      VHDXParentLocatorEntry *parent_entries;
>  
>  } BDRVVHDXState;
>  
> +/* Calculates new checksum.
> + *
> + * Zero is substituted during crc calculation for the original crc field
> + * crc_offset: byte offset in buf of the buffer crc
> + * buf: buffer pointer
> + * size: size of buffer (must be > crc_offset+4)
> + *
> + * Note: The resulting checksum is in the CPU endianness, not necessarily
> + *       in the file format endianness (LE).  Any header export to disk should
> + *       make sure that vhdx_header_le_export() is used to convert to the
> + *       correct endianness
> + */
> +uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset)
> +{
> +    uint32_t crc;
> +
> +    assert(buf != NULL);
> +    assert(size > (crc_offset + 4));
> +
> +    memset(buf + crc_offset, 0, sizeof(crc));
> +    crc =  crc32c(0xffffffff, buf, size);
> +    memcpy(buf + crc_offset, &crc, sizeof(crc));
> +
> +    return crc;
> +}
> +
>  uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size,
>                              int crc_offset)
>  {
> @@ -212,6 +242,24 @@ bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset)
>  
>  
>  /*
> + * This generates a UUID that is compliant with the MS GUIDs used
> + * in the VHDX spec (and elsewhere).
> + *
> + * We can do this with uuid_generate if uuid.h is present,
> + * however not all systems have uuid and the generation is
> + * pretty straightforward for the DCE + random usage case
> + *
> + */
> +void vhdx_guid_generate(MSGUID *guid)
> +{
> +    uuid_t uuid;
> +    assert(guid != NULL);
> +
> +    uuid_generate(uuid);
> +    memcpy(guid, uuid, 16);
> +}
> +
> +/*
>   * Per the MS VHDX Specification, for every VHDX file:
>   *      - The header section is fixed size - 1 MB
>   *      - The header section is always the first "object"
> @@ -249,6 +297,107 @@ static void vhdx_header_le_import(VHDXHeader *h)
>      le64_to_cpus(&h->log_offset);
>  }
>  
> +/* All VHDX structures on disk are little endian */
> +static void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h)
> +{
> +    assert(orig_h != NULL);
> +    assert(new_h != NULL);
> +
> +    new_h->signature       = cpu_to_le32(orig_h->signature);
> +    new_h->checksum        = cpu_to_le32(orig_h->checksum);
> +    new_h->sequence_number = cpu_to_le64(orig_h->sequence_number);
> +
> +    memcpy(&new_h->file_write_guid, &orig_h->file_write_guid, sizeof(MSGUID));
> +    memcpy(&new_h->data_write_guid, &orig_h->data_write_guid, sizeof(MSGUID));
> +    memcpy(&new_h->log_guid,        &orig_h->log_guid,        sizeof(MSGUID));
> +
> +    cpu_to_leguids(&new_h->file_write_guid);
> +    cpu_to_leguids(&new_h->data_write_guid);
> +    cpu_to_leguids(&new_h->log_guid);
> +
> +    new_h->log_version     = cpu_to_le16(orig_h->log_version);
> +    new_h->version         = cpu_to_le16(orig_h->version);
> +    new_h->log_length      = cpu_to_le32(orig_h->log_length);
> +    new_h->log_offset      = cpu_to_le64(orig_h->log_offset);
> +}
> +
> +/* Update the VHDX headers
> + *
> + * This follows the VHDX spec procedures for header updates.
> + *
> + *  - non-current header is updated with largest sequence number
> + */
> +static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, bool rw)
> +{
> +    int ret = 0;
> +    int hdr_idx = 0;
> +    uint64_t header_offset = VHDX_HEADER1_OFFSET;
> +
> +    VHDXHeader *active_header;
> +    VHDXHeader *inactive_header;
> +    VHDXHeader header_le;
> +    uint8_t *buffer;
> +
> +    /* operate on the non-current header */
> +    if (s->curr_header == 0) {
> +        hdr_idx = 1;
> +        header_offset = VHDX_HEADER2_OFFSET;
> +    }
> +
> +    active_header   = s->headers[s->curr_header];
> +    inactive_header = s->headers[hdr_idx];
> +
> +    inactive_header->sequence_number = active_header->sequence_number + 1;
> +
> +    /* a new file guid must be generate before any file write, including
> +     * headers */
> +    memcpy(&inactive_header->file_write_guid, &s->session_guid,
> +           sizeof(MSGUID));
> +
> +    /* a new data guid only needs to be generate before any guest-visible
> +     * writes, so update it if the image is opened r/w. */
> +    if (rw) {
> +        vhdx_guid_generate(&inactive_header->data_write_guid);
> +    }
> +
> +    /* the header checksum is not over just the packed size of VHDXHeader,
> +     * but rather over the entire 'reserved' range for the header, which is
> +     * 4KB (VHDX_HEADER_SIZE). */
> +
> +    buffer = qemu_blockalign(bs, VHDX_HEADER_SIZE);
> +    /* we can't assume the extra reserved bytes are 0 */
> +    ret = bdrv_pread(bs->file, header_offset, buffer, VHDX_HEADER_SIZE);
> +    if (ret < 0) {
> +        goto fail;
> +    }
> +    /* overwrite the actual VHDXHeader portion */
> +    memcpy(buffer, inactive_header, sizeof(VHDXHeader));
> +    inactive_header->checksum = vhdx_update_checksum(buffer,
> +                                                     VHDX_HEADER_SIZE, 4);
> +    vhdx_header_le_export(inactive_header, &header_le);
> +    bdrv_pwrite_sync(bs->file, header_offset, &header_le, sizeof(VHDXHeader));
> +    s->curr_header = hdr_idx;
> +
> +fail:

Labeling it "fail:" is a bit misleading as normal path ends here too.

> +    qemu_vfree(buffer);
> +    return ret;
> +}
> +
> +/*
> + * The VHDX spec calls for header updates to be performed twice, so that both
> + * the current and non-current header have valid info
> + */
> +static int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, bool rw)
> +{
> +    int ret;
> +
> +    ret = vhdx_update_header(bs, s, rw);
> +    if (ret < 0) {
> +        return ret;
> +    }
> +    ret = vhdx_update_header(bs, s, rw);
> +    return ret;
> +}
>  
>  /* opens the specified header block from the VHDX file header section */
>  static int vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s)
> @@ -739,6 +888,11 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags)
>          goto fail;
>      }
>  
> +    /* This is used for any header updates, for the file_write_guid.
> +     * The spec dictates that a new value should be used for the first
> +     * header update */
> +    vhdx_guid_generate(&s->session_guid);
> +
>      ret = vhdx_parse_header(bs, s);
>      if (ret) {
>          goto fail;
> @@ -801,8 +955,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags)
>      }
>  
>      if (flags & BDRV_O_RDWR) {
> -        ret = -ENOTSUP;
> -        goto fail;
> +        vhdx_update_headers(bs, s, false);
>      }
>  
>      /* TODO: differencing files, write */
> diff --git a/block/vhdx.h b/block/vhdx.h
> index 1dbb320..3999cb1 100644
> --- a/block/vhdx.h
> +++ b/block/vhdx.h
> @@ -309,17 +309,27 @@ typedef struct QEMU_PACKED VHDXParentLocatorEntry {
>  /* ----- END VHDX SPECIFICATION STRUCTURES ---- */
>  
>  
> +void vhdx_guid_generate(MSGUID *guid);
> +
> +uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset);
>  uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size,
>                              int crc_offset);
>  
>  bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset);
>  
>  
> -static void leguid_to_cpus(MSGUID *guid)
> +static inline void leguid_to_cpus(MSGUID *guid)
>  {
>      le32_to_cpus(&guid->data1);
>      le16_to_cpus(&guid->data2);
>      le16_to_cpus(&guid->data3);
>  }
>  
> +static inline void cpu_to_leguids(MSGUID *guid)
> +{
> +    cpu_to_le32s(&guid->data1);
> +    cpu_to_le16s(&guid->data2);
> +    cpu_to_le16s(&guid->data3);
> +}
> +
>  #endif
> diff --git a/configure b/configure
> index 877a821..821b790 100755
> --- a/configure
> +++ b/configure
> @@ -244,6 +244,7 @@ gtk=""
>  gtkabi="2.0"
>  tpm="no"
>  libssh2=""
> +vhdx="yes"
>  
>  # parse CC options first
>  for opt do
> @@ -950,6 +951,11 @@ for opt do
>    ;;
>    --enable-libssh2) libssh2="yes"
>    ;;
> +  --enable-vhdx) vhdx="yes" ;
> +                 uuid="yes"
> +  ;;
> +  --disable-vhdx) vhdx="no"
> +  ;;
>    *) echo "ERROR: unknown option $opt"; show_help="yes"
>    ;;
>    esac
> @@ -1166,6 +1172,8 @@ echo "  --gcov=GCOV              use specified gcov [$gcov_tool]"
>  echo "  --enable-tpm             enable TPM support"
>  echo "  --disable-libssh2        disable ssh block device support"
>  echo "  --enable-libssh2         enable ssh block device support"
> +echo "  --disable-vhdx           disables support for the Microsoft VHDX image format"
> +echo "  --enable-vhdx            enable support for the Microsoft VHDX image format"
>  echo ""
>  echo "NOTE: The object files are built at the place where configure is launched"
>  exit 1
> @@ -3622,6 +3630,7 @@ echo "TPM support       $tpm"
>  echo "libssh2 support   $libssh2"
>  echo "TPM passthrough   $tpm_passthrough"
>  echo "QOM debugging     $qom_cast_debug"
> +echo "vhdx              $vhdx"
>  
>  if test "$sdl_too_old" = "yes"; then
>  echo "-> Your SDL version is too old - please upgrade to have SDL support"
> @@ -4012,6 +4021,10 @@ if test "$virtio_blk_data_plane" = "yes" ; then
>    echo 'CONFIG_VIRTIO_BLK_DATA_PLANE=$(CONFIG_VIRTIO)' >> $config_host_mak
>  fi
>  
> +if test "$vhdx" = "yes" ; then
> +  echo "CONFIG_VHDX=y" >> $config_host_mak
> +fi
> +
>  # USB host support
>  case "$usb" in
>  linux)
> -- 
> 1.8.1.4
> 
>
Jeff Cody - July 26, 2013, 11:39 a.m.
On Fri, Jul 26, 2013 at 02:49:04PM +0800, Fam Zheng wrote:
> On Wed, 07/24 13:54, Jeff Cody wrote:
> > This adds the ability to update the headers in a VHDX image, including
> > generating a new MS-compatible GUID.
> > 
> > As VHDX depends on uuid.h, VHDX is now a configurable build option.  If
> > VHDX support is enabled, that will also enable uuid as well.  The
> > default is to have VHDX enabled.
> > 
> > To enable/disable VHDX:  --enable-vhdx, --disable-vhdx
> > 
> > Signed-off-by: Jeff Cody <jcody@redhat.com>
> > ---
> >  block/Makefile.objs |   2 +-
> >  block/vhdx.c        | 157 +++++++++++++++++++++++++++++++++++++++++++++++++++-
> >  block/vhdx.h        |  12 +++-
> >  configure           |  13 +++++
> >  4 files changed, 180 insertions(+), 4 deletions(-)
> > 
> > diff --git a/block/Makefile.objs b/block/Makefile.objs
> > index 4cf9aa4..e5e54e6 100644
> > --- a/block/Makefile.objs
> > +++ b/block/Makefile.objs
> > @@ -2,7 +2,7 @@ block-obj-y += raw.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat
> >  block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o
> >  block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o
> >  block-obj-y += qed-check.o
> > -block-obj-y += vhdx.o
> > +block-obj-$(CONFIG_VHDX) += vhdx.o
> >  block-obj-y += parallels.o blkdebug.o blkverify.o
> >  block-obj-y += snapshot.o qapi.o
> >  block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o
> > diff --git a/block/vhdx.c b/block/vhdx.c
> > index 56bc88e..13e486d 100644
> > --- a/block/vhdx.c
> > +++ b/block/vhdx.c
> > @@ -21,6 +21,7 @@
> >  #include "qemu/crc32c.h"
> >  #include "block/vhdx.h"
> >  
> > +#include <uuid/uuid.h>
> >  
> >  /* Several metadata and region table data entries are identified by
> >   * guids in  a MS-specific GUID format. */
> > @@ -156,11 +157,40 @@ typedef struct BDRVVHDXState {
> >      VHDXBatEntry *bat;
> >      uint64_t bat_offset;
> >  
> > +    MSGUID session_guid;
> > +
> > +
> >      VHDXParentLocatorHeader parent_header;
> >      VHDXParentLocatorEntry *parent_entries;
> >  
> >  } BDRVVHDXState;
> >  
> > +/* Calculates new checksum.
> > + *
> > + * Zero is substituted during crc calculation for the original crc field
> > + * crc_offset: byte offset in buf of the buffer crc
> > + * buf: buffer pointer
> > + * size: size of buffer (must be > crc_offset+4)
> > + *
> > + * Note: The resulting checksum is in the CPU endianness, not necessarily
> > + *       in the file format endianness (LE).  Any header export to disk should
> > + *       make sure that vhdx_header_le_export() is used to convert to the
> > + *       correct endianness
> > + */
> > +uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset)
> > +{
> > +    uint32_t crc;
> > +
> > +    assert(buf != NULL);
> > +    assert(size > (crc_offset + 4));
> > +
> > +    memset(buf + crc_offset, 0, sizeof(crc));
> > +    crc =  crc32c(0xffffffff, buf, size);
> > +    memcpy(buf + crc_offset, &crc, sizeof(crc));
> > +
> > +    return crc;
> > +}
> > +
> >  uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size,
> >                              int crc_offset)
> >  {
> > @@ -212,6 +242,24 @@ bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset)
> >  
> >  
> >  /*
> > + * This generates a UUID that is compliant with the MS GUIDs used
> > + * in the VHDX spec (and elsewhere).
> > + *
> > + * We can do this with uuid_generate if uuid.h is present,
> > + * however not all systems have uuid and the generation is
> > + * pretty straightforward for the DCE + random usage case
> > + *
> > + */
> > +void vhdx_guid_generate(MSGUID *guid)
> > +{
> > +    uuid_t uuid;
> > +    assert(guid != NULL);
> > +
> > +    uuid_generate(uuid);
> > +    memcpy(guid, uuid, 16);
> > +}
> > +
> > +/*
> >   * Per the MS VHDX Specification, for every VHDX file:
> >   *      - The header section is fixed size - 1 MB
> >   *      - The header section is always the first "object"
> > @@ -249,6 +297,107 @@ static void vhdx_header_le_import(VHDXHeader *h)
> >      le64_to_cpus(&h->log_offset);
> >  }
> >  
> > +/* All VHDX structures on disk are little endian */
> > +static void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h)
> > +{
> > +    assert(orig_h != NULL);
> > +    assert(new_h != NULL);
> > +
> > +    new_h->signature       = cpu_to_le32(orig_h->signature);
> > +    new_h->checksum        = cpu_to_le32(orig_h->checksum);
> > +    new_h->sequence_number = cpu_to_le64(orig_h->sequence_number);
> > +
> > +    memcpy(&new_h->file_write_guid, &orig_h->file_write_guid, sizeof(MSGUID));
> > +    memcpy(&new_h->data_write_guid, &orig_h->data_write_guid, sizeof(MSGUID));
> > +    memcpy(&new_h->log_guid,        &orig_h->log_guid,        sizeof(MSGUID));
> > +
> > +    cpu_to_leguids(&new_h->file_write_guid);
> > +    cpu_to_leguids(&new_h->data_write_guid);
> > +    cpu_to_leguids(&new_h->log_guid);
> > +
> > +    new_h->log_version     = cpu_to_le16(orig_h->log_version);
> > +    new_h->version         = cpu_to_le16(orig_h->version);
> > +    new_h->log_length      = cpu_to_le32(orig_h->log_length);
> > +    new_h->log_offset      = cpu_to_le64(orig_h->log_offset);
> > +}
> > +
> > +/* Update the VHDX headers
> > + *
> > + * This follows the VHDX spec procedures for header updates.
> > + *
> > + *  - non-current header is updated with largest sequence number
> > + */
> > +static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, bool rw)
> > +{
> > +    int ret = 0;
> > +    int hdr_idx = 0;
> > +    uint64_t header_offset = VHDX_HEADER1_OFFSET;
> > +
> > +    VHDXHeader *active_header;
> > +    VHDXHeader *inactive_header;
> > +    VHDXHeader header_le;
> > +    uint8_t *buffer;
> > +
> > +    /* operate on the non-current header */
> > +    if (s->curr_header == 0) {
> > +        hdr_idx = 1;
> > +        header_offset = VHDX_HEADER2_OFFSET;
> > +    }
> > +
> > +    active_header   = s->headers[s->curr_header];
> > +    inactive_header = s->headers[hdr_idx];
> > +
> > +    inactive_header->sequence_number = active_header->sequence_number + 1;
> > +
> > +    /* a new file guid must be generate before any file write, including
> > +     * headers */
> > +    memcpy(&inactive_header->file_write_guid, &s->session_guid,
> > +           sizeof(MSGUID));
> > +
> > +    /* a new data guid only needs to be generate before any guest-visible
> > +     * writes, so update it if the image is opened r/w. */
> > +    if (rw) {
> > +        vhdx_guid_generate(&inactive_header->data_write_guid);
> > +    }
> > +
> > +    /* the header checksum is not over just the packed size of VHDXHeader,
> > +     * but rather over the entire 'reserved' range for the header, which is
> > +     * 4KB (VHDX_HEADER_SIZE). */
> > +
> > +    buffer = qemu_blockalign(bs, VHDX_HEADER_SIZE);
> > +    /* we can't assume the extra reserved bytes are 0 */
> > +    ret = bdrv_pread(bs->file, header_offset, buffer, VHDX_HEADER_SIZE);
> > +    if (ret < 0) {
> > +        goto fail;
> > +    }
> > +    /* overwrite the actual VHDXHeader portion */
> > +    memcpy(buffer, inactive_header, sizeof(VHDXHeader));
> > +    inactive_header->checksum = vhdx_update_checksum(buffer,
> > +                                                     VHDX_HEADER_SIZE, 4);
> > +    vhdx_header_le_export(inactive_header, &header_le);
> > +    bdrv_pwrite_sync(bs->file, header_offset, &header_le, sizeof(VHDXHeader));
> > +    s->curr_header = hdr_idx;
> > +
> > +fail:
> 
> Labeling it "fail:" is a bit misleading as normal path ends here too.
>

Good point; I'll change that to just be 'exit'.

> > +    qemu_vfree(buffer);
> > +    return ret;
> > +}
> > +
> > +/*
> > + * The VHDX spec calls for header updates to be performed twice, so that both
> > + * the current and non-current header have valid info
> > + */
> > +static int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, bool rw)
> > +{
> > +    int ret;
> > +
> > +    ret = vhdx_update_header(bs, s, rw);
> > +    if (ret < 0) {
> > +        return ret;
> > +    }
> > +    ret = vhdx_update_header(bs, s, rw);
> > +    return ret;
> > +}
> >  
> >  /* opens the specified header block from the VHDX file header section */
> >  static int vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s)
> > @@ -739,6 +888,11 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags)
> >          goto fail;
> >      }
> >  
> > +    /* This is used for any header updates, for the file_write_guid.
> > +     * The spec dictates that a new value should be used for the first
> > +     * header update */
> > +    vhdx_guid_generate(&s->session_guid);
> > +
> >      ret = vhdx_parse_header(bs, s);
> >      if (ret) {
> >          goto fail;
> > @@ -801,8 +955,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags)
> >      }
> >  
> >      if (flags & BDRV_O_RDWR) {
> > -        ret = -ENOTSUP;
> > -        goto fail;
> > +        vhdx_update_headers(bs, s, false);
> >      }
> >  
> >      /* TODO: differencing files, write */
> > diff --git a/block/vhdx.h b/block/vhdx.h
> > index 1dbb320..3999cb1 100644
> > --- a/block/vhdx.h
> > +++ b/block/vhdx.h
> > @@ -309,17 +309,27 @@ typedef struct QEMU_PACKED VHDXParentLocatorEntry {
> >  /* ----- END VHDX SPECIFICATION STRUCTURES ---- */
> >  
> >  
> > +void vhdx_guid_generate(MSGUID *guid);
> > +
> > +uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset);
> >  uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size,
> >                              int crc_offset);
> >  
> >  bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset);
> >  
> >  
> > -static void leguid_to_cpus(MSGUID *guid)
> > +static inline void leguid_to_cpus(MSGUID *guid)
> >  {
> >      le32_to_cpus(&guid->data1);
> >      le16_to_cpus(&guid->data2);
> >      le16_to_cpus(&guid->data3);
> >  }
> >  
> > +static inline void cpu_to_leguids(MSGUID *guid)
> > +{
> > +    cpu_to_le32s(&guid->data1);
> > +    cpu_to_le16s(&guid->data2);
> > +    cpu_to_le16s(&guid->data3);
> > +}
> > +
> >  #endif
> > diff --git a/configure b/configure
> > index 877a821..821b790 100755
> > --- a/configure
> > +++ b/configure
> > @@ -244,6 +244,7 @@ gtk=""
> >  gtkabi="2.0"
> >  tpm="no"
> >  libssh2=""
> > +vhdx="yes"
> >  
> >  # parse CC options first
> >  for opt do
> > @@ -950,6 +951,11 @@ for opt do
> >    ;;
> >    --enable-libssh2) libssh2="yes"
> >    ;;
> > +  --enable-vhdx) vhdx="yes" ;
> > +                 uuid="yes"
> > +  ;;
> > +  --disable-vhdx) vhdx="no"
> > +  ;;
> >    *) echo "ERROR: unknown option $opt"; show_help="yes"
> >    ;;
> >    esac
> > @@ -1166,6 +1172,8 @@ echo "  --gcov=GCOV              use specified gcov [$gcov_tool]"
> >  echo "  --enable-tpm             enable TPM support"
> >  echo "  --disable-libssh2        disable ssh block device support"
> >  echo "  --enable-libssh2         enable ssh block device support"
> > +echo "  --disable-vhdx           disables support for the Microsoft VHDX image format"
> > +echo "  --enable-vhdx            enable support for the Microsoft VHDX image format"
> >  echo ""
> >  echo "NOTE: The object files are built at the place where configure is launched"
> >  exit 1
> > @@ -3622,6 +3630,7 @@ echo "TPM support       $tpm"
> >  echo "libssh2 support   $libssh2"
> >  echo "TPM passthrough   $tpm_passthrough"
> >  echo "QOM debugging     $qom_cast_debug"
> > +echo "vhdx              $vhdx"
> >  
> >  if test "$sdl_too_old" = "yes"; then
> >  echo "-> Your SDL version is too old - please upgrade to have SDL support"
> > @@ -4012,6 +4021,10 @@ if test "$virtio_blk_data_plane" = "yes" ; then
> >    echo 'CONFIG_VIRTIO_BLK_DATA_PLANE=$(CONFIG_VIRTIO)' >> $config_host_mak
> >  fi
> >  
> > +if test "$vhdx" = "yes" ; then
> > +  echo "CONFIG_VHDX=y" >> $config_host_mak
> > +fi
> > +
> >  # USB host support
> >  case "$usb" in
> >  linux)
> > -- 
> > 1.8.1.4
> > 
> > 
> 
> -- 
> Fam

Patch

diff --git a/block/Makefile.objs b/block/Makefile.objs
index 4cf9aa4..e5e54e6 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -2,7 +2,7 @@  block-obj-y += raw.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat
 block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o
 block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o
 block-obj-y += qed-check.o
-block-obj-y += vhdx.o
+block-obj-$(CONFIG_VHDX) += vhdx.o
 block-obj-y += parallels.o blkdebug.o blkverify.o
 block-obj-y += snapshot.o qapi.o
 block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o
diff --git a/block/vhdx.c b/block/vhdx.c
index 56bc88e..13e486d 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -21,6 +21,7 @@ 
 #include "qemu/crc32c.h"
 #include "block/vhdx.h"
 
+#include <uuid/uuid.h>
 
 /* Several metadata and region table data entries are identified by
  * guids in  a MS-specific GUID format. */
@@ -156,11 +157,40 @@  typedef struct BDRVVHDXState {
     VHDXBatEntry *bat;
     uint64_t bat_offset;
 
+    MSGUID session_guid;
+
+
     VHDXParentLocatorHeader parent_header;
     VHDXParentLocatorEntry *parent_entries;
 
 } BDRVVHDXState;
 
+/* Calculates new checksum.
+ *
+ * Zero is substituted during crc calculation for the original crc field
+ * crc_offset: byte offset in buf of the buffer crc
+ * buf: buffer pointer
+ * size: size of buffer (must be > crc_offset+4)
+ *
+ * Note: The resulting checksum is in the CPU endianness, not necessarily
+ *       in the file format endianness (LE).  Any header export to disk should
+ *       make sure that vhdx_header_le_export() is used to convert to the
+ *       correct endianness
+ */
+uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset)
+{
+    uint32_t crc;
+
+    assert(buf != NULL);
+    assert(size > (crc_offset + 4));
+
+    memset(buf + crc_offset, 0, sizeof(crc));
+    crc =  crc32c(0xffffffff, buf, size);
+    memcpy(buf + crc_offset, &crc, sizeof(crc));
+
+    return crc;
+}
+
 uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size,
                             int crc_offset)
 {
@@ -212,6 +242,24 @@  bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset)
 
 
 /*
+ * This generates a UUID that is compliant with the MS GUIDs used
+ * in the VHDX spec (and elsewhere).
+ *
+ * We can do this with uuid_generate if uuid.h is present,
+ * however not all systems have uuid and the generation is
+ * pretty straightforward for the DCE + random usage case
+ *
+ */
+void vhdx_guid_generate(MSGUID *guid)
+{
+    uuid_t uuid;
+    assert(guid != NULL);
+
+    uuid_generate(uuid);
+    memcpy(guid, uuid, 16);
+}
+
+/*
  * Per the MS VHDX Specification, for every VHDX file:
  *      - The header section is fixed size - 1 MB
  *      - The header section is always the first "object"
@@ -249,6 +297,107 @@  static void vhdx_header_le_import(VHDXHeader *h)
     le64_to_cpus(&h->log_offset);
 }
 
+/* All VHDX structures on disk are little endian */
+static void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h)
+{
+    assert(orig_h != NULL);
+    assert(new_h != NULL);
+
+    new_h->signature       = cpu_to_le32(orig_h->signature);
+    new_h->checksum        = cpu_to_le32(orig_h->checksum);
+    new_h->sequence_number = cpu_to_le64(orig_h->sequence_number);
+
+    memcpy(&new_h->file_write_guid, &orig_h->file_write_guid, sizeof(MSGUID));
+    memcpy(&new_h->data_write_guid, &orig_h->data_write_guid, sizeof(MSGUID));
+    memcpy(&new_h->log_guid,        &orig_h->log_guid,        sizeof(MSGUID));
+
+    cpu_to_leguids(&new_h->file_write_guid);
+    cpu_to_leguids(&new_h->data_write_guid);
+    cpu_to_leguids(&new_h->log_guid);
+
+    new_h->log_version     = cpu_to_le16(orig_h->log_version);
+    new_h->version         = cpu_to_le16(orig_h->version);
+    new_h->log_length      = cpu_to_le32(orig_h->log_length);
+    new_h->log_offset      = cpu_to_le64(orig_h->log_offset);
+}
+
+/* Update the VHDX headers
+ *
+ * This follows the VHDX spec procedures for header updates.
+ *
+ *  - non-current header is updated with largest sequence number
+ */
+static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, bool rw)
+{
+    int ret = 0;
+    int hdr_idx = 0;
+    uint64_t header_offset = VHDX_HEADER1_OFFSET;
+
+    VHDXHeader *active_header;
+    VHDXHeader *inactive_header;
+    VHDXHeader header_le;
+    uint8_t *buffer;
+
+    /* operate on the non-current header */
+    if (s->curr_header == 0) {
+        hdr_idx = 1;
+        header_offset = VHDX_HEADER2_OFFSET;
+    }
+
+    active_header   = s->headers[s->curr_header];
+    inactive_header = s->headers[hdr_idx];
+
+    inactive_header->sequence_number = active_header->sequence_number + 1;
+
+    /* a new file guid must be generate before any file write, including
+     * headers */
+    memcpy(&inactive_header->file_write_guid, &s->session_guid,
+           sizeof(MSGUID));
+
+    /* a new data guid only needs to be generate before any guest-visible
+     * writes, so update it if the image is opened r/w. */
+    if (rw) {
+        vhdx_guid_generate(&inactive_header->data_write_guid);
+    }
+
+    /* the header checksum is not over just the packed size of VHDXHeader,
+     * but rather over the entire 'reserved' range for the header, which is
+     * 4KB (VHDX_HEADER_SIZE). */
+
+    buffer = qemu_blockalign(bs, VHDX_HEADER_SIZE);
+    /* we can't assume the extra reserved bytes are 0 */
+    ret = bdrv_pread(bs->file, header_offset, buffer, VHDX_HEADER_SIZE);
+    if (ret < 0) {
+        goto fail;
+    }
+    /* overwrite the actual VHDXHeader portion */
+    memcpy(buffer, inactive_header, sizeof(VHDXHeader));
+    inactive_header->checksum = vhdx_update_checksum(buffer,
+                                                     VHDX_HEADER_SIZE, 4);
+    vhdx_header_le_export(inactive_header, &header_le);
+    bdrv_pwrite_sync(bs->file, header_offset, &header_le, sizeof(VHDXHeader));
+    s->curr_header = hdr_idx;
+
+fail:
+    qemu_vfree(buffer);
+    return ret;
+}
+
+/*
+ * The VHDX spec calls for header updates to be performed twice, so that both
+ * the current and non-current header have valid info
+ */
+static int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, bool rw)
+{
+    int ret;
+
+    ret = vhdx_update_header(bs, s, rw);
+    if (ret < 0) {
+        return ret;
+    }
+    ret = vhdx_update_header(bs, s, rw);
+    return ret;
+}
 
 /* opens the specified header block from the VHDX file header section */
 static int vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s)
@@ -739,6 +888,11 @@  static int vhdx_open(BlockDriverState *bs, QDict *options, int flags)
         goto fail;
     }
 
+    /* This is used for any header updates, for the file_write_guid.
+     * The spec dictates that a new value should be used for the first
+     * header update */
+    vhdx_guid_generate(&s->session_guid);
+
     ret = vhdx_parse_header(bs, s);
     if (ret) {
         goto fail;
@@ -801,8 +955,7 @@  static int vhdx_open(BlockDriverState *bs, QDict *options, int flags)
     }
 
     if (flags & BDRV_O_RDWR) {
-        ret = -ENOTSUP;
-        goto fail;
+        vhdx_update_headers(bs, s, false);
     }
 
     /* TODO: differencing files, write */
diff --git a/block/vhdx.h b/block/vhdx.h
index 1dbb320..3999cb1 100644
--- a/block/vhdx.h
+++ b/block/vhdx.h
@@ -309,17 +309,27 @@  typedef struct QEMU_PACKED VHDXParentLocatorEntry {
 /* ----- END VHDX SPECIFICATION STRUCTURES ---- */
 
 
+void vhdx_guid_generate(MSGUID *guid);
+
+uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset);
 uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size,
                             int crc_offset);
 
 bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset);
 
 
-static void leguid_to_cpus(MSGUID *guid)
+static inline void leguid_to_cpus(MSGUID *guid)
 {
     le32_to_cpus(&guid->data1);
     le16_to_cpus(&guid->data2);
     le16_to_cpus(&guid->data3);
 }
 
+static inline void cpu_to_leguids(MSGUID *guid)
+{
+    cpu_to_le32s(&guid->data1);
+    cpu_to_le16s(&guid->data2);
+    cpu_to_le16s(&guid->data3);
+}
+
 #endif
diff --git a/configure b/configure
index 877a821..821b790 100755
--- a/configure
+++ b/configure
@@ -244,6 +244,7 @@  gtk=""
 gtkabi="2.0"
 tpm="no"
 libssh2=""
+vhdx="yes"
 
 # parse CC options first
 for opt do
@@ -950,6 +951,11 @@  for opt do
   ;;
   --enable-libssh2) libssh2="yes"
   ;;
+  --enable-vhdx) vhdx="yes" ;
+                 uuid="yes"
+  ;;
+  --disable-vhdx) vhdx="no"
+  ;;
   *) echo "ERROR: unknown option $opt"; show_help="yes"
   ;;
   esac
@@ -1166,6 +1172,8 @@  echo "  --gcov=GCOV              use specified gcov [$gcov_tool]"
 echo "  --enable-tpm             enable TPM support"
 echo "  --disable-libssh2        disable ssh block device support"
 echo "  --enable-libssh2         enable ssh block device support"
+echo "  --disable-vhdx           disables support for the Microsoft VHDX image format"
+echo "  --enable-vhdx            enable support for the Microsoft VHDX image format"
 echo ""
 echo "NOTE: The object files are built at the place where configure is launched"
 exit 1
@@ -3622,6 +3630,7 @@  echo "TPM support       $tpm"
 echo "libssh2 support   $libssh2"
 echo "TPM passthrough   $tpm_passthrough"
 echo "QOM debugging     $qom_cast_debug"
+echo "vhdx              $vhdx"
 
 if test "$sdl_too_old" = "yes"; then
 echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -4012,6 +4021,10 @@  if test "$virtio_blk_data_plane" = "yes" ; then
   echo 'CONFIG_VIRTIO_BLK_DATA_PLANE=$(CONFIG_VIRTIO)' >> $config_host_mak
 fi
 
+if test "$vhdx" = "yes" ; then
+  echo "CONFIG_VHDX=y" >> $config_host_mak
+fi
+
 # USB host support
 case "$usb" in
 linux)