From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:47898) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1V6MER-0000x5-DT for qemu-devel@nongnu.org; Mon, 05 Aug 2013 10:58:05 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1V6MEL-0003VH-Bc for qemu-devel@nongnu.org; Mon, 05 Aug 2013 10:57:59 -0400 Received: from mx1.redhat.com ([209.132.183.28]:57844) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1V6MEL-0003VB-4w for qemu-devel@nongnu.org; Mon, 05 Aug 2013 10:57:53 -0400 Received: from int-mx02.intmail.prod.int.phx2.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id r75EvpSL012457 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Mon, 5 Aug 2013 10:57:52 -0400 Date: Mon, 5 Aug 2013 10:57:48 -0400 From: Jeff Cody Message-ID: <20130805145748.GB19080@localhost.localdomain> References: <595d71cf1cd25ac9deff521bceb82b8c3da888d0.1375325971.git.jcody@redhat.com> <20130805144502.GJ2654@dhcp-200-207.str.redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20130805144502.GJ2654@dhcp-200-207.str.redhat.com> Subject: Re: [Qemu-devel] [PATCH v2 2/9] block: vhdx - add header update capability. List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Kevin Wolf Cc: famz@redhat.com, qemu-devel@nongnu.org, stefanha@redhat.com On Mon, Aug 05, 2013 at 04:45:02PM +0200, Kevin Wolf wrote: > Am 01.08.2013 um 05:23 hat Jeff Cody geschrieben: > > 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 > > --- > > 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..9b50442 100644 > > --- a/block/vhdx.c > > +++ b/block/vhdx.c > > @@ -21,6 +21,7 @@ > > #include "qemu/crc32c.h" > > #include "block/vhdx.h" > > > > +#include > > > > /* 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)); > > sizeof(crc) for consistency. > OK > > + > > + 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); > > +} > > Should MSGUID be QEMU_PACKED to make sure that this works? Also > sizeof(guid) instead of 16? > Yikes, yes it definitely should be packed. > > + > > +/* > > * 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)); > > Can we avoid memcpy? I think this should work: > > new_h->file_write_guid = orig_h->file_write_guid; > new_h->data_write_guid = orig_h->data_write_guid; > new_h->log_guid = orig_h->log_guid; > Yes, that should work fine as well - I'll change it to that. > > + > > + 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)); > > Here a simple assignment should do as well. > > > + > > + /* 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 exit; > > + } > > + /* 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; > > + > > +exit: > > + qemu_vfree(buffer); > > + return ret; > > +} > > Kevin